archondev 2.2.0 → 2.3.0

package/dist/index.js

@@ -82,7 +82,7 @@ import "./chunk-QGM4M3NI.js";
 
 // src/cli/index.ts
 import { Command as Command4 } from "commander";
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 import "dotenv/config";
 
 // src/cli/promote.ts
@@ -840,34 +840,1628 @@ async function cleanupAuto(action) {
     console.log(chalk3.green("\n\u2713 Auto cleanup disabled\n"));
   }
 }
-async function shouldRunAutoCleanup(cwd) {
-  const config = await loadCleanupConfig(cwd);
-  return config?.autoEnabled ?? false;
+async function shouldRunAutoCleanup(cwd) {
+  const config = await loadCleanupConfig(cwd);
+  return config?.autoEnabled ?? false;
+}
+async function runAutoCleanupCheck(cwd) {
+  const progressPath = join3(cwd, PROGRESS_FILE);
+  const archonPath = join3(cwd, ARCHON_DIR);
+  const config = await loadCleanupConfig(cwd);
+  const progressMaxKb = config?.progressMaxKb ?? DEFAULT_THRESHOLDS.progressMaxKb;
+  const archonDirMaxMb = config?.archonDirMaxMb ?? DEFAULT_THRESHOLDS.archonDirMaxMb;
+  let needsAttention = false;
+  if (existsSync3(progressPath)) {
+    const size = statSync(progressPath).size;
+    if (size > progressMaxKb * 1024) {
+      needsAttention = true;
+    }
+  }
+  if (existsSync3(archonPath)) {
+    const size = getDirSize(archonPath);
+    if (size > archonDirMaxMb * 1024 * 1024) {
+      needsAttention = true;
+    }
+  }
+  const orphaned = getOrphanedWorktrees(cwd);
+  if (orphaned.length > 0) {
+    needsAttention = true;
+  }
+  return needsAttention;
+}
+
+// src/core/interview/intent.ts
+var APP_BUILDER_PATTERNS = [
+  /build (a|an|my|the) (app|application|website|system|platform|service|product|tool|saas)/i,
+  /create (a|an|my|the) (app|application|website|system|platform|product|saas)/i,
+  /i want to (build|create|make|develop|design)/i,
+  /new (app|application|project|system|platform|product)/i,
+  /start (a|an|my|the|new)? ?(project|app|interview|discovery)/i,
+  /help me (build|create|design|plan|architect)/i,
+  /need (a|an|to build|to create) (new )?/i,
+  /let's (build|create|make|start|plan)/i,
+  /interview/i,
+  /full (stack|project|application)/i,
+  /from scratch/i,
+  /\bmvp\b/i,
+  /\bsaas\b/i,
+  /production(-| )ready/i,
+  /scalable/i,
+  /architecture for/i
+];
+var AD_HOC_PATTERNS = [
+  /^(fix|refactor|update|modify|change|add|remove|delete|improve) /i,
+  /^(write|create|generate) (a |the )?(test|tests|unit test)/i,
+  /^(debug|bug in|issue with)/i,
+  /^(analyze|review|check|audit|scan) (this|these|the|my)/i,
+  /^(explain|how does|what is|why)/i,
+  /^(show me|find|search|look for|locate)/i,
+  /\.(ts|js|tsx|jsx|py|go|rs|java|rb|php|css|html|json|yaml|yml|md)\b/i,
+  /^(install|npm|yarn|pnpm|pip|cargo|go get)/i,
+  /^(run|execute|start|stop|restart) (the |my )?/i,
+  /^(lint|format|typecheck|compile|build|test) /i,
+  /line ?\d+/i,
+  /error|warning|issue/i,
+  /component|function|class|method|api|endpoint/i
+];
+var ESCAPE_PHRASES = [
+  /^just start$/i,
+  /^skip$/i,
+  /^later$/i,
+  /^quick start$/i,
+  /^default(s)?$/i,
+  /^minimal$/i,
+  /^basic setup$/i
+];
+function detectUserIntent(message) {
+  const trimmed = message.trim();
+  if (trimmed.length < 3) {
+    return {
+      mode: "ambiguous",
+      confidence: 0.3,
+      reasoning: "Response too short to determine intent",
+      suggestedAction: "clarify"
+    };
+  }
+  for (const pattern of ESCAPE_PHRASES) {
+    if (pattern.test(trimmed)) {
+      return {
+        mode: "ad_hoc",
+        confidence: 0.95,
+        reasoning: "User explicitly requested to skip interview",
+        suggestedAction: "execute"
+      };
+    }
+  }
+  for (const pattern of APP_BUILDER_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return {
+        mode: "app_builder",
+        confidence: 0.9,
+        reasoning: "User language indicates building a complete application or system",
+        suggestedAction: "interview"
+      };
+    }
+  }
+  for (const pattern of AD_HOC_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return {
+        mode: "ad_hoc",
+        confidence: 0.85,
+        reasoning: "User language indicates a specific, targeted task",
+        suggestedAction: "execute"
+      };
+    }
+  }
+  const wordCount = trimmed.split(/\s+/).length;
+  const hasFileReference = /\.(ts|js|py|go|rs|java)\b/i.test(trimmed);
+  const hasBuildKeywords = /(architecture|scalable|production|deploy|users|customers|clients|saas)/i.test(trimmed);
+  const hasTaskKeywords = /(fix|add|change|update|remove|test)/i.test(trimmed);
+  if (hasFileReference && wordCount < 15) {
+    return {
+      mode: "ad_hoc",
+      confidence: 0.7,
+      reasoning: "Short request with specific file reference",
+      suggestedAction: "execute"
+    };
+  }
+  if (hasBuildKeywords && wordCount > 20) {
+    return {
+      mode: "app_builder",
+      confidence: 0.75,
+      reasoning: "Detailed request with architectural/product keywords",
+      suggestedAction: "interview"
+    };
+  }
+  if (hasTaskKeywords && wordCount < 10) {
+    return {
+      mode: "ad_hoc",
+      confidence: 0.7,
+      reasoning: "Short request with task-oriented keywords",
+      suggestedAction: "execute"
+    };
+  }
+  if (wordCount > 5 && wordCount < 30) {
+    if (wordCount < 15) {
+      return {
+        mode: "ad_hoc",
+        confidence: 0.55,
+        reasoning: "Medium-length request without strong signals (leaning toward task)",
+        suggestedAction: "clarify"
+      };
+    } else {
+      return {
+        mode: "app_builder",
+        confidence: 0.55,
+        reasoning: "Longer request without strong signals (leaning toward project)",
+        suggestedAction: "clarify"
+      };
+    }
+  }
+  return {
+    mode: "ambiguous",
+    confidence: 0.5,
+    reasoning: "Unable to determine intent from message",
+    suggestedAction: "clarify"
+  };
+}
+function needsClarification(result) {
+  return result.confidence < 0.65 || result.suggestedAction === "clarify";
+}
+function wantsToSkip(message) {
+  return ESCAPE_PHRASES.some((pattern) => pattern.test(message.trim()));
+}
+function extractProjectNameHint(message) {
+  const patterns = [
+    /(?:called|named)\s+["']?([a-zA-Z][a-zA-Z0-9_-]+)["']?/i,
+    /["']([a-zA-Z][a-zA-Z0-9_-]+)["']\s*(?:app|project|system|tool)/i,
+    /build\s+["']?([a-zA-Z][a-zA-Z0-9_-]+)["']?$/i
+  ];
+  for (const pattern of patterns) {
+    const match = message.match(pattern);
+    if (match?.[1]) {
+      return match[1];
+    }
+  }
+  return void 0;
+}
+function extractTechStackHints(message) {
+  const hints = {};
+  if (/typescript|\.ts\b/i.test(message)) hints.language = "typescript";
+  else if (/javascript|\.js\b/i.test(message)) hints.language = "javascript";
+  else if (/python|\.py\b/i.test(message)) hints.language = "python";
+  else if (/go(lang)?|\.go\b/i.test(message)) hints.language = "go";
+  else if (/rust|\.rs\b/i.test(message)) hints.language = "rust";
+  if (/next\.?js|next/i.test(message)) hints.framework = "nextjs";
+  else if (/react/i.test(message)) hints.framework = "react";
+  else if (/vue/i.test(message)) hints.framework = "vue";
+  else if (/svelte/i.test(message)) hints.framework = "svelte";
+  else if (/express/i.test(message)) hints.framework = "express";
+  else if (/fastapi/i.test(message)) hints.framework = "fastapi";
+  else if (/django/i.test(message)) hints.framework = "django";
+  if (/postgres(ql)?/i.test(message)) hints.database = "postgresql";
+  else if (/mysql/i.test(message)) hints.database = "mysql";
+  else if (/mongo(db)?/i.test(message)) hints.database = "mongodb";
+  else if (/supabase/i.test(message)) hints.database = "supabase";
+  else if (/firebase/i.test(message)) hints.database = "firebase";
+  else if (/sqlite/i.test(message)) hints.database = "sqlite";
+  if (/cli|command.line/i.test(message)) hints.type = "backend";
+  else if (/api|backend|server|service/i.test(message)) hints.type = "backend";
+  else if (/frontend|ui|web\s*app|spa/i.test(message)) hints.type = "frontend";
+  else if (/full.?stack|website/i.test(message)) hints.type = "fullstack";
+  else if (/library|package|npm|module/i.test(message)) hints.type = "library";
+  return hints;
+}
+
+// src/core/interview/state.ts
+function createInterviewState() {
+  return {
+    startedAt: /* @__PURE__ */ new Date(),
+    completedPhases: [],
+    skippedPhases: [],
+    userWantsToSkip: false
+  };
+}
+function createInterviewStateFromMessage(initialMessage, hints) {
+  const state = createInterviewState();
+  if (hints.projectName) state.projectName = hints.projectName;
+  if (hints.language) state.language = hints.language;
+  if (hints.framework) state.framework = hints.framework;
+  if (hints.database) state.database = hints.database;
+  if (hints.type) state.projectType = hints.type;
+  if (initialMessage.length > 20) {
+    state.description = initialMessage.trim();
+  }
+  return state;
+}
+function getKnownInfo(state) {
+  const known = [];
+  if (state.projectName) known.push(`Project: ${state.projectName}`);
+  if (state.description) known.push(`Description: ${truncate(state.description, 50)}`);
+  if (state.language) known.push(`Language: ${state.language}`);
+  if (state.framework) known.push(`Framework: ${state.framework}`);
+  if (state.projectType) known.push(`Type: ${state.projectType}`);
+  if (state.database) known.push(`Database: ${state.database}`);
+  if (state.posture) known.push(`Posture: ${state.posture}`);
+  if (state.audience) known.push(`Audience: ${state.audience}`);
+  return known;
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+function inferPosture(state) {
+  if (state.dataSensitivity === "pii" || state.dataSensitivity === "phi" || state.dataSensitivity === "pci") {
+    return "enterprise";
+  }
+  if (state.complianceNeeds && state.complianceNeeds.length > 0) {
+    return "enterprise";
+  }
+  if (state.audience === "personal" && !state.dataSensitivity) {
+    return "prototype";
+  }
+  if (state.audience === "endusers") {
+    return "production";
+  }
+  return void 0;
+}
+
+// src/core/interview/phases.ts
+var PHASE_1_DISCOVERY = {
+  phase: 1,
+  name: "Discovery",
+  description: "Understanding what you want to build and who it's for",
+  questions: [
+    {
+      id: "elevator_pitch",
+      prompt: "In one sentence, what are you building? (elevator pitch)",
+      followUp: "Great! Can you tell me more about the specific problem you're solving?",
+      required: true,
+      validator: (answer) => ({
+        valid: answer.length >= 10,
+        error: "Please provide at least a brief description (10+ characters)"
+      }),
+      extractor: (answer, constitution) => ({
+        discovery: {
+          ...constitution.discovery,
+          elevatorPitch: answer.trim()
+        }
+      })
+    },
+    {
+      id: "target_user",
+      prompt: "Who is your target user? Describe them specifically.",
+      followUp: "What do they currently do to solve this problem?",
+      required: true,
+      extractor: (answer, constitution) => ({
+        discovery: {
+          ...constitution.discovery,
+          targetUser: {
+            ...constitution.discovery.targetUser,
+            persona: answer.trim()
+          }
+        }
+      })
+    },
+    {
+      id: "pain_points",
+      prompt: "What are their biggest pain points? (list 2-3)",
+      required: true,
+      extractor: (answer, constitution) => {
+        const painPoints = answer.split(/[,\n]/).map((p) => p.trim()).filter((p) => p.length > 0);
+        return {
+          discovery: {
+            ...constitution.discovery,
+            targetUser: {
+              ...constitution.discovery.targetUser,
+              painPoints
+            }
+          }
+        };
+      }
+    },
+    {
+      id: "core_problem",
+      prompt: "What is the #1 problem your app solves?",
+      required: true,
+      extractor: (answer, constitution) => ({
+        discovery: {
+          ...constitution.discovery,
+          coreProblem: answer.trim()
+        }
+      })
+    },
+    {
+      id: "success_metrics",
+      prompt: "How will you measure success in the first month? (optional)",
+      required: false,
+      extractor: (answer, constitution) => {
+        if (!answer.trim()) return {};
+        const metrics = answer.split(/[,\n]/).map((m) => m.trim()).filter((m) => m.length > 0);
+        return {
+          discovery: {
+            ...constitution.discovery,
+            successMetrics: metrics
+          }
+        };
+      }
+    }
+  ],
+  isComplete: (constitution) => {
+    return !!(constitution.discovery.elevatorPitch && constitution.discovery.targetUser.persona && constitution.discovery.coreProblem);
+  }
+};
+var PHASE_2_FEATURES = {
+  phase: 2,
+  name: "Features",
+  description: "Defining what your MVP will do",
+  questions: [
+    {
+      id: "core_features",
+      prompt: "What are the 3-5 core features your MVP absolutely needs? (list them)",
+      required: true,
+      extractor: (answer, constitution) => {
+        const featureNames = answer.split(/[,\n]/).map((f) => f.trim()).filter((f) => f.length > 0);
+        const features = featureNames.map((name, index) => ({
+          id: `f${index + 1}`,
+          name,
+          userStory: "",
+          acceptanceCriteria: [],
+          priority: "MVP",
+          complexity: 3
+        }));
+        return {
+          mvpFeatures: features
+        };
+      }
+    },
+    {
+      id: "user_stories",
+      prompt: 'For each feature, describe a user story: "As a [user], I want [feature] so that [benefit]"',
+      followUp: "I'll help you refine these into proper acceptance criteria.",
+      required: true,
+      extractor: (answer, constitution) => {
+        const stories = answer.split(/\n/).map((s) => s.trim()).filter((s) => s.length > 0);
+        const updatedFeatures = [...constitution.mvpFeatures];
+        for (let i = 0; i < Math.min(stories.length, updatedFeatures.length); i++) {
+          const feature = updatedFeatures[i];
+          if (feature) {
+            feature.userStory = stories[i] ?? "";
+          }
+        }
+        return { mvpFeatures: updatedFeatures };
+      }
+    },
+    {
+      id: "nice_to_have",
+      prompt: "Any features you'd like post-MVP? (optional, helps me understand full vision)",
+      required: false,
+      extractor: (answer, constitution) => {
+        if (!answer.trim()) return {};
+        const featureNames = answer.split(/[,\n]/).map((f) => f.trim()).filter((f) => f.length > 0);
+        const postMvpFeatures = featureNames.map((name, index) => ({
+          id: `post${index + 1}`,
+          name,
+          userStory: "",
+          acceptanceCriteria: [],
+          priority: "POST_MVP",
+          complexity: 3
+        }));
+        return {
+          mvpFeatures: [...constitution.mvpFeatures, ...postMvpFeatures]
+        };
+      }
+    }
+  ],
+  isComplete: (constitution) => {
+    const mvpFeatures = constitution.mvpFeatures.filter((f) => f.priority === "MVP");
+    return mvpFeatures.length >= 1 && mvpFeatures.some((f) => f.userStory);
+  }
+};
+var PHASE_3_TECHNICAL = {
+  phase: 3,
+  name: "Technical",
+  description: "Choosing your tech stack",
+  questions: [
+    {
+      id: "tech_preference",
+      prompt: `Do you have a tech stack preference? (e.g., "React + Node" or "I don't know, recommend something")`,
+      required: true,
+      extractor: (answer, constitution) => {
+        const lower = answer.toLowerCase();
+        const techStack = { ...constitution.techStack };
+        if (lower.includes("next") || lower.includes("nextjs")) {
+          techStack.framework = "Next.js";
+          techStack.language = "TypeScript";
+        } else if (lower.includes("react")) {
+          techStack.framework = "React";
+          techStack.language = "TypeScript";
+        } else if (lower.includes("vue")) {
+          techStack.framework = "Vue";
+          techStack.language = "TypeScript";
+        } else if (lower.includes("svelte")) {
+          techStack.framework = "SvelteKit";
+          techStack.language = "TypeScript";
+        } else if (lower.includes("python") || lower.includes("django") || lower.includes("fastapi")) {
+          techStack.language = "Python";
+          if (lower.includes("django")) techStack.framework = "Django";
+          if (lower.includes("fastapi")) techStack.framework = "FastAPI";
+        } else if (lower.includes("don't know") || lower.includes("recommend") || lower.includes("no preference")) {
+          techStack.framework = "Next.js";
+          techStack.language = "TypeScript";
+        }
+        if (lower.includes("postgres")) {
+          techStack.database = "PostgreSQL";
+        } else if (lower.includes("supabase")) {
+          techStack.database = "Supabase";
+        } else if (lower.includes("mongo")) {
+          techStack.database = "MongoDB";
+        } else if (lower.includes("mysql")) {
+          techStack.database = "MySQL";
+        }
+        return { techStack };
+      }
+    },
+    {
+      id: "database",
+      prompt: 'What database would you like? (PostgreSQL, Supabase, MongoDB, or "recommend")',
+      required: true,
+      extractor: (answer, constitution) => {
+        const lower = answer.toLowerCase();
+        const techStack = { ...constitution.techStack };
+        if (lower.includes("postgres")) {
+          techStack.database = "PostgreSQL";
+        } else if (lower.includes("supabase")) {
+          techStack.database = "Supabase";
+        } else if (lower.includes("mongo")) {
+          techStack.database = "MongoDB";
+        } else if (lower.includes("mysql")) {
+          techStack.database = "MySQL";
+        } else if (lower.includes("sqlite")) {
+          techStack.database = "SQLite";
+        } else if (lower.includes("recommend") || lower.includes("don't know")) {
+          techStack.database = "Supabase";
+        }
+        return { techStack };
+      }
+    },
+    {
+      id: "hosting",
+      prompt: 'Where do you want to host it? (Vercel, Fly.io, Railway, or "recommend")',
+      required: true,
+      extractor: (answer, constitution) => {
+        const lower = answer.toLowerCase();
+        const techStack = { ...constitution.techStack };
+        if (lower.includes("vercel")) {
+          techStack.hosting = "Vercel";
+        } else if (lower.includes("fly")) {
+          techStack.hosting = "Fly.io";
+        } else if (lower.includes("railway")) {
+          techStack.hosting = "Railway";
+        } else if (lower.includes("netlify")) {
+          techStack.hosting = "Netlify";
+        } else if (lower.includes("render")) {
+          techStack.hosting = "Render";
+        } else if (lower.includes("local") || lower.includes("self")) {
+          techStack.hosting = "Self-hosted";
+        } else if (lower.includes("recommend") || lower.includes("don't know")) {
+          if (techStack.framework === "Next.js") {
+            techStack.hosting = "Vercel";
+          } else {
+            techStack.hosting = "Fly.io";
+          }
+        }
+        return { techStack };
+      }
+    },
+    {
+      id: "auth",
+      prompt: 'Do you need user authentication? If yes, any preference? (Firebase, Supabase Auth, Clerk, or "none")',
+      required: false,
+      extractor: (answer, constitution) => {
+        const lower = answer.toLowerCase();
+        const techStack = { ...constitution.techStack };
+        if (lower.includes("none") || lower.includes("no")) {
+        } else if (lower.includes("firebase")) {
+          techStack.auth = "Firebase Auth";
+        } else if (lower.includes("supabase")) {
+          techStack.auth = "Supabase Auth";
+        } else if (lower.includes("clerk")) {
+          techStack.auth = "Clerk";
+        } else if (lower.includes("auth0")) {
+          techStack.auth = "Auth0";
+        } else if (lower.includes("yes") || lower.includes("recommend")) {
+          if (techStack.database === "Supabase") {
+            techStack.auth = "Supabase Auth";
+          } else {
+            techStack.auth = "Firebase Auth";
+          }
+        }
+        return { techStack };
+      }
+    }
+  ],
+  isComplete: (constitution) => {
+    return !!(constitution.techStack.framework || constitution.techStack.language);
+  }
+};
+var PHASE_4_BRANDING = {
+  phase: 4,
+  name: "Branding",
+  description: "Naming and visual identity",
+  questions: [
+    {
+      id: "project_name",
+      prompt: "What's the name of your project?",
+      required: true,
+      validator: (answer) => ({
+        valid: answer.length >= 2 && /^[a-zA-Z][a-zA-Z0-9\-_ ]*$/.test(answer),
+        error: "Project name must start with a letter and contain only letters, numbers, hyphens, underscores, and spaces"
+      }),
+      extractor: (answer, constitution) => ({
+        branding: {
+          ...constitution.branding,
+          projectName: answer.trim()
+        }
+      })
+    },
+    {
+      id: "tagline",
+      prompt: 'Got a tagline? (optional, e.g., "Project management for solo consultants")',
+      required: false,
+      extractor: (answer, constitution) => {
+        if (!answer.trim()) return {};
+        return {
+          branding: {
+            ...constitution.branding,
+            tagline: answer.trim()
+          }
+        };
+      }
+    },
+    {
+      id: "domain",
+      prompt: 'Any domain name in mind? (optional, e.g., "myapp.com")',
+      required: false,
+      extractor: (answer, constitution) => {
+        if (!answer.trim()) return {};
+        return {
+          branding: {
+            ...constitution.branding,
+            domain: answer.trim().toLowerCase()
+          }
+        };
+      }
+    },
+    {
+      id: "colors",
+      prompt: 'Any color preferences? (optional, e.g., "blue and white" or "modern dark theme")',
+      required: false,
+      extractor: (answer, constitution) => {
+        if (!answer.trim()) return {};
+        const lower = answer.toLowerCase();
+        const branding = { ...constitution.branding };
+        if (lower.includes("blue")) branding.primaryColor = "#3B82F6";
+        else if (lower.includes("green")) branding.primaryColor = "#10B981";
+        else if (lower.includes("purple")) branding.primaryColor = "#8B5CF6";
+        else if (lower.includes("red")) branding.primaryColor = "#EF4444";
+        else if (lower.includes("orange")) branding.primaryColor = "#F97316";
+        else if (lower.includes("dark")) branding.primaryColor = "#1F2937";
+        if (lower.includes("white")) branding.secondaryColor = "#FFFFFF";
+        else if (lower.includes("gray") || lower.includes("grey")) branding.secondaryColor = "#6B7280";
+        else if (lower.includes("dark")) branding.secondaryColor = "#374151";
+        return { branding };
+      }
+    }
+  ],
+  isComplete: (constitution) => {
+    return !!constitution.branding.projectName;
+  }
+};
+var PHASE_5_REVIEW = {
+  phase: 5,
+  name: "Review",
+  description: "Reviewing and finalizing your project specification",
+  questions: [
+    {
+      id: "review_summary",
+      prompt: "Here's what we have so far. Does everything look correct? (yes/no/edit)",
+      required: true,
+      extractor: () => ({})
+      // No extraction, just confirmation
+    },
+    {
+      id: "confirm_freeze",
+      prompt: "Ready to freeze this Constitution and start building? (yes/no)",
+      required: true,
+      extractor: () => ({})
+      // No extraction, just confirmation
+    }
+  ],
+  isComplete: () => false
+  // Review is never "auto-complete"
+};
+var INTERVIEW_PHASES = {
+  1: PHASE_1_DISCOVERY,
+  2: PHASE_2_FEATURES,
+  3: PHASE_3_TECHNICAL,
+  4: PHASE_4_BRANDING,
+  5: PHASE_5_REVIEW
+};
+function getNextPhase(current) {
+  if (current >= 5) return null;
+  return current + 1;
+}
+function getSkippableQuestions(phase, constitution) {
+  const skippable = [];
+  const phaseInfo = INTERVIEW_PHASES[phase];
+  switch (phase) {
+    case 1:
+      if (constitution.discovery.elevatorPitch) skippable.push("elevator_pitch");
+      if (constitution.discovery.targetUser.persona) skippable.push("target_user");
+      if (constitution.discovery.targetUser.painPoints.length > 0) skippable.push("pain_points");
+      if (constitution.discovery.coreProblem) skippable.push("core_problem");
+      break;
+    case 3:
+      if (constitution.techStack.framework) skippable.push("tech_preference");
+      if (constitution.techStack.database) skippable.push("database");
+      if (constitution.techStack.hosting) skippable.push("hosting");
+      if (constitution.techStack.auth) skippable.push("auth");
+      break;
+    case 4:
+      if (constitution.branding.projectName) skippable.push("project_name");
+      if (constitution.branding.tagline) skippable.push("tagline");
+      if (constitution.branding.domain) skippable.push("domain");
+      break;
+  }
+  return skippable;
+}
+function formatProgressBar(currentPhase) {
+  const phases = ["Discovery", "Features", "Technical", "Branding", "Review"];
+  return phases.map((name, index) => {
+    const phaseNum = index + 1;
+    if (phaseNum < currentPhase) {
+      return `[\u2713] ${name}`;
+    } else if (phaseNum === currentPhase) {
+      return `[\u25CF] ${name}`;
+    } else {
+      return `[ ] ${name}`;
+    }
+  }).join("\n");
+}
+
+// src/core/interview/constitution.ts
+import { createHash } from "crypto";
+function createDraftConstitution(projectId, tenantId) {
+  return {
+    version: "1.0.0",
+    state: "DRAFT",
+    projectId,
+    tenantId,
+    createdAt: /* @__PURE__ */ new Date(),
+    discovery: {
+      elevatorPitch: "",
+      targetUser: {
+        persona: "",
+        painPoints: []
+      },
+      coreProblem: ""
+    },
+    mvpFeatures: [],
+    techStack: {},
+    branding: {
+      projectName: ""
+    },
+    complexity: {
+      tier: "SIMPLE",
+      criteria: {
+        routes: 0,
+        tables: 0,
+        integrations: 0,
+        authRoles: 0,
+        hasRealtime: false,
+        hasFileUpload: false,
+        hasPayments: false
+      }
+    },
+    estimatedBuildHours: 0,
+    costs: {
+      buildCost: "TBD"
+    }
+  };
+}
+function calculateComplexity(constitution) {
+  const features = constitution.mvpFeatures;
+  let routes = 0;
+  let tables = 0;
+  const integrationSet = /* @__PURE__ */ new Set();
+  let hasPayments = false;
+  let hasRealtime = false;
+  let hasFileUpload = false;
+  for (const feature of features) {
+    routes += feature.routes?.length ?? 0;
+    tables += feature.tables?.length ?? 0;
+    for (const integration of feature.integrations ?? []) {
+      integrationSet.add(integration);
+      if (integration.toLowerCase().includes("stripe") || integration.toLowerCase().includes("payment")) {
+        hasPayments = true;
+      }
+      if (integration.toLowerCase().includes("socket") || integration.toLowerCase().includes("realtime") || integration.toLowerCase().includes("pusher")) {
+        hasRealtime = true;
+      }
+      if (integration.toLowerCase().includes("upload") || integration.toLowerCase().includes("s3") || integration.toLowerCase().includes("storage")) {
+        hasFileUpload = true;
+      }
+    }
+  }
+  const integrations = integrationSet.size;
+  const authRoles = constitution.techStack.auth ? 2 : 1;
+  let tier;
+  if (routes <= 10 && tables <= 5 && integrations <= 2 && !hasPayments && !hasRealtime) {
+    tier = "SIMPLE";
+  } else if (routes <= 25 && tables <= 10 && integrations <= 5) {
+    tier = "MODERATE";
+  } else if (routes <= 50 && tables <= 20 && integrations <= 10) {
+    tier = "COMPLEX";
+  } else {
+    tier = "ENTERPRISE";
+  }
+  return {
+    tier,
+    criteria: {
+      routes,
+      tables,
+      integrations,
+      authRoles,
+      hasRealtime,
+      hasFileUpload,
+      hasPayments
+    }
+  };
+}
+function estimateBuildHours(complexity) {
+  switch (complexity.tier) {
+    case "SIMPLE":
+      return 4 + complexity.criteria.routes * 0.2;
+    case "MODERATE":
+      return 12 + complexity.criteria.routes * 0.3;
+    case "COMPLEX":
+      return 24 + complexity.criteria.routes * 0.4;
+    case "ENTERPRISE":
+      return 48 + complexity.criteria.routes * 0.5;
+  }
+}
+function estimateCosts(constitution, userTier) {
+  const complexity = constitution.complexity;
+  const breakdown = [];
+  let buildCost;
+  switch (userTier) {
+    case "FREE":
+      buildCost = "$0 (free tier)";
+      break;
+    case "BYOK":
+      buildCost = "$0 to ArchonDev (your API costs)";
+      break;
+    case "CREDITS":
+      const estimatedTokens = constitution.estimatedBuildHours * 1e5;
+      const cost = estimatedTokens / 1e6 * 3 * 1.1;
+      buildCost = `~$${cost.toFixed(2)} (pay-as-you-go)`;
+      break;
+    default:
+      buildCost = "TBD";
+  }
+  if (constitution.techStack.hosting) {
+    switch (constitution.techStack.hosting.toLowerCase()) {
+      case "vercel":
+        breakdown.push("Vercel: $0-20/mo");
+        break;
+      case "fly":
+      case "fly.io":
+        breakdown.push("Fly.io: $5-25/mo");
+        break;
+      case "railway":
+        breakdown.push("Railway: $5-20/mo");
+        break;
+    }
+  }
+  if (constitution.techStack.database) {
+    switch (constitution.techStack.database.toLowerCase()) {
+      case "supabase":
+        breakdown.push("Supabase: $0-25/mo");
+        break;
+      case "planetscale":
+        breakdown.push("PlanetScale: $0-29/mo");
+        break;
+      case "postgresql":
+        breakdown.push("PostgreSQL hosting: $5-15/mo");
+        break;
+    }
+  }
+  if (complexity.criteria.hasPayments) {
+    breakdown.push("Stripe: 2.9% + $0.30 per transaction");
+  }
+  return {
+    buildCost,
+    infrastructureCost: breakdown.length > 0 ? `~$${breakdown.length * 10}-${breakdown.length * 30}/mo` : void 0,
+    breakdown: breakdown.length > 0 ? breakdown : void 0
+  };
+}
+function freezeConstitution(constitution) {
+  if (constitution.state === "FROZEN") {
+    throw new Error("Constitution is already frozen");
+  }
+  const complexity = calculateComplexity(constitution);
+  const estimatedBuildHours = estimateBuildHours(complexity);
+  const frozen = {
+    ...constitution,
+    state: "FROZEN",
+    frozenAt: /* @__PURE__ */ new Date(),
+    complexity,
+    estimatedBuildHours
+  };
+  const hashContent = JSON.stringify({
+    discovery: frozen.discovery,
+    mvpFeatures: frozen.mvpFeatures,
+    techStack: frozen.techStack,
+    branding: frozen.branding
+  });
+  frozen.hash = createHash("sha256").update(hashContent).digest("hex");
+  return frozen;
+}
+function validateConstitution(constitution) {
+  const errors = [];
+  const warnings = [];
+  if (!constitution.discovery.elevatorPitch || constitution.discovery.elevatorPitch.length < 10) {
+    errors.push("Elevator pitch is required (minimum 10 characters)");
+  }
+  if (!constitution.discovery.targetUser.persona) {
+    errors.push("Target user persona is required");
+  }
+  if (!constitution.discovery.coreProblem) {
+    errors.push("Core problem statement is required");
+  }
+  if (constitution.mvpFeatures.length === 0) {
+    errors.push("At least one MVP feature is required");
+  }
+  const mvpCount = constitution.mvpFeatures.filter((f) => f.priority === "MVP").length;
+  if (mvpCount === 0) {
+    warnings.push("No features marked as MVP priority");
+  }
+  if (mvpCount > 10) {
+    warnings.push("More than 10 MVP features may indicate scope creep");
+  }
+  for (const feature of constitution.mvpFeatures) {
+    if (!feature.name) {
+      errors.push(`Feature ${feature.id} is missing a name`);
+    }
+    if (!feature.userStory) {
+      warnings.push(`Feature "${feature.name}" is missing a user story`);
+    }
+    if (feature.acceptanceCriteria.length === 0) {
+      warnings.push(`Feature "${feature.name}" has no acceptance criteria`);
+    }
+  }
+  if (!constitution.techStack.framework && !constitution.techStack.language) {
+    errors.push("Tech stack must specify at least a framework or language");
+  }
+  if (!constitution.branding.projectName) {
+    errors.push("Project name is required");
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function serializeConstitution(constitution) {
+  return JSON.stringify({
+    ...constitution,
+    createdAt: constitution.createdAt.toISOString(),
+    frozenAt: constitution.frozenAt?.toISOString()
+  }, null, 2);
+}
+function deserializeConstitution(json) {
+  const parsed = JSON.parse(json);
+  return {
+    ...parsed,
+    createdAt: new Date(parsed.createdAt),
+    frozenAt: parsed.frozenAt ? new Date(parsed.frozenAt) : void 0
+  };
+}
+function summarizeConstitution(constitution) {
+  const lines = [];
+  lines.push(`# ${constitution.branding.projectName || "Untitled Project"}`);
+  lines.push("");
+  if (constitution.branding.tagline) {
+    lines.push(`*${constitution.branding.tagline}*`);
+    lines.push("");
+  }
+  lines.push("## Discovery");
+  lines.push(`**Pitch:** ${constitution.discovery.elevatorPitch}`);
+  lines.push(`**Target:** ${constitution.discovery.targetUser.persona}`);
+  lines.push(`**Problem:** ${constitution.discovery.coreProblem}`);
+  lines.push("");
+  lines.push("## MVP Features");
+  const mvpFeatures = constitution.mvpFeatures.filter((f) => f.priority === "MVP");
+  for (const feature of mvpFeatures) {
+    lines.push(`- **${feature.name}**: ${feature.userStory}`);
+  }
+  lines.push("");
+  lines.push("## Tech Stack");
+  if (constitution.techStack.framework) lines.push(`- Framework: ${constitution.techStack.framework}`);
+  if (constitution.techStack.database) lines.push(`- Database: ${constitution.techStack.database}`);
+  if (constitution.techStack.hosting) lines.push(`- Hosting: ${constitution.techStack.hosting}`);
+  if (constitution.techStack.auth) lines.push(`- Auth: ${constitution.techStack.auth}`);
+  lines.push("");
+  lines.push("## Complexity");
+  lines.push(`**Tier:** ${constitution.complexity.tier}`);
+  lines.push(`**Estimated Build Time:** ${constitution.estimatedBuildHours} hours`);
+  lines.push(`**Build Cost:** ${constitution.costs.buildCost}`);
+  if (constitution.state === "FROZEN") {
+    lines.push("");
+    lines.push("---");
+    lines.push(`*Constitution frozen at ${constitution.frozenAt?.toISOString()}*`);
+    lines.push(`*Hash: ${constitution.hash?.substring(0, 16)}...*`);
+  }
+  return lines.join("\n");
+}
+
+// src/core/interview/challenge.ts
+var THRESHOLDS = {
+  // MVP feature limits by complexity tier
+  maxMvpFeatures: {
+    SIMPLE: 5,
+    MODERATE: 8,
+    COMPLEX: 12,
+    ENTERPRISE: 20
+  },
+  // Complexity warnings
+  simpleProjectMaxRoutes: 10,
+  simpleProjectMaxTables: 5,
+  // Build time warnings (hours)
+  warningBuildHours: 16,
+  criticalBuildHours: 40,
+  // Feature quality
+  minAcceptanceCriteriaPerFeature: 2,
+  minUserStoryLength: 20
+};
+function analyzeForChallenges(constitution) {
+  const challenges = [];
+  const featuresToDefer = [];
+  const recommendedActions = [];
+  const mvpFeatures = constitution.mvpFeatures.filter((f) => f.priority === "MVP");
+  const complexity = constitution.complexity;
+  const maxFeatures = THRESHOLDS.maxMvpFeatures[complexity.tier];
+  if (mvpFeatures.length > maxFeatures) {
+    const excess = mvpFeatures.length - maxFeatures;
+    const toDefer = suggestFeaturesToDefer(mvpFeatures, excess);
+    featuresToDefer.push(...toDefer);
+    challenges.push({
+      type: "TOO_MANY_MVP_FEATURES",
+      severity: excess > 3 ? "critical" : "warning",
+      title: "Too Many MVP Features",
+      message: `You have ${mvpFeatures.length} MVP features, but ${complexity.tier} projects typically have ${maxFeatures} or fewer. This increases build time and risk of delays.`,
+      suggestion: `Consider moving ${excess} feature(s) to post-MVP: ${toDefer.map((f) => f.name).join(", ")}`,
+      affectedFeatures: toDefer.map((f) => f.id)
+    });
+    recommendedActions.push(`Defer ${excess} features to post-MVP phase`);
+  }
+  if (complexity.tier === "COMPLEX" || complexity.tier === "ENTERPRISE") {
+    challenges.push({
+      type: "HIGH_COMPLEXITY",
+      severity: complexity.tier === "ENTERPRISE" ? "critical" : "warning",
+      title: "High Project Complexity",
+      message: `This project is rated as ${complexity.tier}. It has ${complexity.criteria.routes} routes, ${complexity.criteria.tables} tables, and ${complexity.criteria.integrations} integrations.`,
+      suggestion: "Consider breaking this into multiple phases or reducing initial scope."
+    });
+    recommendedActions.push("Review if all integrations are needed for MVP");
+  }
+  if (!constitution.techStack.auth && hasAuthRequiredFeatures(mvpFeatures)) {
+    challenges.push({
+      type: "MISSING_AUTH",
+      severity: "critical",
+      title: "Authentication May Be Required",
+      message: "Some features appear to require user authentication, but no auth provider is selected.",
+      suggestion: "Add authentication (Supabase Auth, Firebase Auth, or Clerk) to your tech stack."
+    });
+    recommendedActions.push("Add authentication to tech stack");
+  }
+  if (!constitution.techStack.database && hasDatabaseRequiredFeatures(mvpFeatures)) {
+    challenges.push({
+      type: "MISSING_DATABASE",
+      severity: "critical",
+      title: "Database May Be Required",
+      message: "Some features appear to require data persistence, but no database is selected.",
+      suggestion: "Add a database (Supabase, PostgreSQL, or MongoDB) to your tech stack."
+    });
+    recommendedActions.push("Add database to tech stack");
+  }
+  const vagueFeatures = mvpFeatures.filter((f) => isVagueFeature(f));
+  if (vagueFeatures.length > 0) {
+    challenges.push({
+      type: "VAGUE_FEATURES",
+      severity: "warning",
+      title: "Some Features Need More Detail",
+      message: `${vagueFeatures.length} feature(s) lack clear user stories or acceptance criteria.`,
+      suggestion: `Add more detail to: ${vagueFeatures.map((f) => f.name).join(", ")}`,
+      affectedFeatures: vagueFeatures.map((f) => f.id)
+    });
+    recommendedActions.push("Add user stories and acceptance criteria to vague features");
+  }
+  const scopeCreepScore = calculateScopeCreepScore(constitution);
+  if (scopeCreepScore > 70) {
+    challenges.push({
+      type: "SCOPE_CREEP",
+      severity: scopeCreepScore > 85 ? "critical" : "warning",
+      title: "Scope Creep Detected",
+      message: `This project shows signs of scope creep (score: ${scopeCreepScore}/100). Common causes: too many features, complex integrations, or unclear boundaries.`,
+      suggestion: "Focus on the core problem. What is the ONE thing users need most?"
+    });
+  }
+  if (constitution.estimatedBuildHours > THRESHOLDS.criticalBuildHours) {
+    challenges.push({
+      type: "UNREALISTIC_TIMELINE",
+      severity: "critical",
+      title: "Estimated Build Time is High",
+      message: `This project is estimated to take ${Math.round(constitution.estimatedBuildHours)} hours to build. That's ${Math.round(constitution.estimatedBuildHours / 8)} full work days.`,
+      suggestion: "Consider reducing scope or breaking into multiple releases."
+    });
+    recommendedActions.push("Break project into multiple releases");
+  } else if (constitution.estimatedBuildHours > THRESHOLDS.warningBuildHours) {
+    challenges.push({
+      type: "UNREALISTIC_TIMELINE",
+      severity: "warning",
+      title: "Build Time Warning",
+      message: `This project is estimated to take ${Math.round(constitution.estimatedBuildHours)} hours. Make sure this fits your timeline.`,
+      suggestion: "Review features and consider which are truly essential."
+    });
+  }
+  const scopeScore = calculateScopeCreepScore(constitution);
+  return {
+    shouldChallenge: challenges.length > 0,
+    challenges,
+    recommendedActions,
+    scopeScore,
+    featuresToDefer
+  };
+}
+function suggestFeaturesToDefer(features, countToDefer) {
+  const scored = features.map((f) => ({
+    feature: f,
+    score: calculateDeferralScore(f)
+  }));
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, countToDefer).map((s) => s.feature);
+}
+function calculateDeferralScore(feature) {
+  let score = 0;
+  score += feature.complexity * 10;
+  if (isVagueFeature(feature)) {
+    score += 30;
+  }
+  if (feature.dependencies && feature.dependencies.length > 0) {
+    score -= feature.dependencies.length * 5;
+  }
+  if (feature.acceptanceCriteria.length < 2) {
+    score += 20;
+  }
+  const niceToHaveKeywords = ["admin", "analytics", "export", "import", "bulk", "advanced", "custom", "premium"];
+  const nameLower = feature.name.toLowerCase();
+  const storyLower = feature.userStory.toLowerCase();
+  for (const keyword of niceToHaveKeywords) {
+    if (nameLower.includes(keyword) || storyLower.includes(keyword)) {
+      score += 15;
+    }
+  }
+  const coreKeywords = ["auth", "login", "signup", "register", "dashboard", "home", "main", "core"];
+  for (const keyword of coreKeywords) {
+    if (nameLower.includes(keyword)) {
+      score -= 25;
+    }
+  }
+  return score;
+}
+function isVagueFeature(feature) {
+  if (!feature.userStory || feature.userStory.length < THRESHOLDS.minUserStoryLength) {
+    return true;
+  }
+  if (feature.acceptanceCriteria.length < THRESHOLDS.minAcceptanceCriteriaPerFeature) {
+    return true;
+  }
+  return false;
+}
+function hasAuthRequiredFeatures(features) {
+  const authKeywords = ["login", "signup", "register", "account", "profile", "user", "auth", "session", "password"];
+  return features.some((f) => {
+    const text = `${f.name} ${f.userStory}`.toLowerCase();
+    return authKeywords.some((keyword) => text.includes(keyword));
+  });
+}
+function hasDatabaseRequiredFeatures(features) {
+  const dbKeywords = ["save", "store", "create", "update", "delete", "list", "data", "record", "history", "track"];
+  return features.some((f) => {
+    const text = `${f.name} ${f.userStory}`.toLowerCase();
+    return dbKeywords.some((keyword) => text.includes(keyword));
+  });
+}
+function calculateScopeCreepScore(constitution) {
+  let score = 0;
+  const mvpFeatures = constitution.mvpFeatures.filter((f) => f.priority === "MVP");
+  const complexity = constitution.complexity;
+  const maxFeatures = THRESHOLDS.maxMvpFeatures[complexity.tier];
+  const featureRatio = mvpFeatures.length / maxFeatures;
+  score += Math.min(30, featureRatio * 20);
+  switch (complexity.tier) {
+    case "SIMPLE":
+      score += 0;
+      break;
+    case "MODERATE":
+      score += 10;
+      break;
+    case "COMPLEX":
+      score += 20;
+      break;
+    case "ENTERPRISE":
+      score += 25;
+      break;
+  }
+  score += Math.min(20, complexity.criteria.integrations * 4);
+  const vagueCount = mvpFeatures.filter((f) => isVagueFeature(f)).length;
+  score += Math.min(15, vagueCount * 5);
+  if (constitution.estimatedBuildHours > 40) {
+    score += 10;
+  } else if (constitution.estimatedBuildHours > 20) {
+    score += 5;
+  }
+  return Math.min(100, Math.round(score));
+}
+function generateChallengePrompt(challenge) {
+  const prompts = {
+    TOO_MANY_MVP_FEATURES: [
+      "I notice you've listed quite a few features for your MVP. The most successful launches often start smaller.",
+      "Building all these features at once will take longer and cost more. What if we focused on the core experience first?",
+      "Many founders find that their users only use 2-3 features regularly. Which features are absolutely essential for your first users?"
+    ],
+    HIGH_COMPLEXITY: [
+      "This is an ambitious project! Have you considered a phased approach to reduce initial complexity?",
+      "Complex projects often benefit from a 'walking skeleton' approach - build the simplest version that works end-to-end first.",
+      "I want to make sure we set realistic expectations. This complexity level typically requires significant time and resources."
+    ],
+    MISSING_AUTH: [
+      "Some of your features mention users or accounts, but we haven't set up authentication. Should we add that?",
+      "User authentication is a foundational feature - it's much easier to add now than retrofit later."
+    ],
+    MISSING_DATABASE: [
+      "Your features involve storing and retrieving data, but we haven't selected a database yet.",
+      "Data persistence is core to your app. Let's make sure we have the right database for your needs."
+    ],
+    VAGUE_FEATURES: [
+      "Some features could use more detail. Clear acceptance criteria help ensure we build exactly what you envision.",
+      "I want to make sure I understand these features correctly. Can you add more specifics?"
+    ],
+    SCOPE_CREEP: [
+      "I'm seeing signs of scope creep. What's the ONE problem you're solving for your users?",
+      "The best v1 products do one thing really well. What's the core value proposition?",
+      "If you could only ship ONE feature, which would it be? Let's make that amazing first."
+    ],
+    UNREALISTIC_TIMELINE: [
+      "Based on the scope, this will take significant time to build. Is that timeline acceptable?",
+      "I want to be upfront about the time investment. Would you consider a smaller initial release?"
+    ]
+  };
+  const typePrompts = prompts[challenge.type];
+  const randomIndex = Math.floor(Math.random() * typePrompts.length);
+  return typePrompts[randomIndex] ?? typePrompts[0] ?? challenge.message;
+}
+function applyDeferrals(constitution, featureIds) {
+  const updatedFeatures = constitution.mvpFeatures.map((feature) => {
+    if (featureIds.includes(feature.id)) {
+      return { ...feature, priority: "POST_MVP" };
+    }
+    return feature;
+  });
+  return {
+    ...constitution,
+    mvpFeatures: updatedFeatures
+  };
+}
+function summarizeChallenges(result) {
+  const lines = [];
+  lines.push(`Scope Score: ${result.scopeScore}/100 ${getScopeEmoji(result.scopeScore)}`);
+  lines.push("");
+  if (result.challenges.length === 0) {
+    lines.push("\u2713 No major concerns detected. Your project scope looks reasonable!");
+  } else {
+    lines.push(`Found ${result.challenges.length} item(s) to consider:`);
+    lines.push("");
+    for (const challenge of result.challenges) {
+      const icon = challenge.severity === "critical" ? "\u{1F534}" : "\u{1F7E1}";
+      lines.push(`${icon} **${challenge.title}**`);
+      lines.push(`   ${challenge.message}`);
+      lines.push(`   \u2192 ${challenge.suggestion}`);
+      lines.push("");
+    }
+  }
+  if (result.featuresToDefer.length > 0) {
+    lines.push("**Suggested Deferrals:**");
+    for (const feature of result.featuresToDefer) {
+      lines.push(`  \u2022 ${feature.name}`);
+    }
+  }
+  return lines.join("\n");
+}
+function getScopeEmoji(score) {
+  if (score < 30) return "\u2705";
+  if (score < 50) return "\u{1F44D}";
+  if (score < 70) return "\u26A0\uFE0F";
+  if (score < 85) return "\u{1F7E0}";
+  return "\u{1F534}";
+}
+
+// src/core/interview/generator.ts
+var SETUP_ATOM_TEMPLATE = {
+  title: "Project Setup & Configuration",
+  description: "Initialize project structure, install dependencies, configure build tools",
+  goals: [
+    "Create project scaffolding",
+    "Configure TypeScript/ESLint/Prettier",
+    "Set up development environment",
+    "Configure CI/CD basics"
+  ],
+  acceptanceCriteria: [
+    "Project builds without errors",
+    "Linting passes with zero errors",
+    "Development server starts successfully",
+    "Basic test suite runs"
+  ],
+  priority: 1,
+  tags: ["setup", "infrastructure"],
+  estimatedHours: 2
+};
+var AUTH_ATOM_TEMPLATE = {
+  title: "Authentication System",
+  goals: [
+    "Implement user registration",
+    "Implement user login/logout",
+    "Set up session management",
+    "Protect authenticated routes"
+  ],
+  acceptanceCriteria: [
+    "Users can register with email/password",
+    "Users can log in with valid credentials",
+    "Invalid credentials show appropriate error",
+    "Session persists across page refreshes",
+    "Logout clears session"
+  ],
+  priority: 2,
+  tags: ["auth", "security"],
+  estimatedHours: 4
+};
+var DATABASE_ATOM_TEMPLATE = {
+  title: "Database Schema & Migrations",
+  goals: [
+    "Design database schema",
+    "Create migration files",
+    "Set up database connection",
+    "Implement data models"
+  ],
+  acceptanceCriteria: [
+    "Migrations run without errors",
+    "Schema matches requirements",
+    "Connection pooling configured",
+    "Models have proper TypeScript types"
+  ],
+  priority: 2,
+  tags: ["database", "infrastructure"],
+  estimatedHours: 3
+};
+function generateAtomsFromConstitution(constitution, options = {}) {
+  const {
+    includePostMvp = false,
+    maxAtomsPerFeature = 3,
+    addSetupAtom = true,
+    addTestingAtom = true
+  } = options;
+  const atoms = [];
+  const warnings = [];
+  let atomIndex = 0;
+  if (addSetupAtom) {
+    atoms.push({
+      ...SETUP_ATOM_TEMPLATE,
+      featureId: "setup",
+      featureName: "Project Setup",
+      title: `${constitution.branding.projectName} - Project Setup`,
+      description: `Initialize ${constitution.techStack.framework || "project"} with ${constitution.techStack.language || "TypeScript"}`
+    });
+    atomIndex++;
+  }
+  if (constitution.techStack.database) {
+    atoms.push({
+      ...DATABASE_ATOM_TEMPLATE,
+      featureId: "database",
+      featureName: "Database Setup",
+      title: `${constitution.branding.projectName} - Database Setup (${constitution.techStack.database})`,
+      description: `Set up ${constitution.techStack.database} database with initial schema`,
+      acceptanceCriteria: DATABASE_ATOM_TEMPLATE.acceptanceCriteria ?? [],
+      dependencies: addSetupAtom ? ["setup"] : void 0
+    });
+    atomIndex++;
+  }
+  if (constitution.techStack.auth) {
+    atoms.push({
+      ...AUTH_ATOM_TEMPLATE,
+      featureId: "auth",
+      featureName: "Authentication",
+      title: `${constitution.branding.projectName} - Authentication (${constitution.techStack.auth})`,
+      description: `Implement authentication using ${constitution.techStack.auth}`,
+      acceptanceCriteria: AUTH_ATOM_TEMPLATE.acceptanceCriteria ?? [],
+      dependencies: constitution.techStack.database ? ["database"] : addSetupAtom ? ["setup"] : void 0
+    });
+    atomIndex++;
+  }
+  const features = constitution.mvpFeatures.filter(
+    (f) => f.priority === "MVP" || includePostMvp && f.priority === "POST_MVP"
+  );
+  for (const feature of features) {
+    const featureAtoms = generateAtomsForFeature(feature, constitution, {
+      maxAtoms: maxAtomsPerFeature,
+      atomIndexStart: atomIndex,
+      hasAuth: !!constitution.techStack.auth,
+      hasDatabase: !!constitution.techStack.database
+    });
+    if (featureAtoms.length === 0) {
+      warnings.push(`Feature "${feature.name}" generated no atoms - may need more detail`);
+    }
+    atoms.push(...featureAtoms);
+    atomIndex += featureAtoms.length;
+  }
+  if (addTestingAtom && atoms.length > 2) {
+    atoms.push({
+      featureId: "testing",
+      featureName: "Testing Suite",
+      title: `${constitution.branding.projectName} - Integration Tests`,
+      description: "Write integration tests for core functionality",
+      goals: [
+        "Set up test framework",
+        "Write tests for critical paths",
+        "Configure CI test runner"
+      ],
+      acceptanceCriteria: [
+        "All critical paths have test coverage",
+        "Tests pass in CI pipeline",
+        "Coverage report generated"
+      ],
+      priority: 99,
+      tags: ["testing", "qa"],
+      estimatedHours: 4,
+      dependencies: features.map((f) => f.id)
+    });
+  }
+  const totalEstimatedHours = atoms.reduce(
+    (sum, atom) => sum + (atom.estimatedHours ?? 2),
+    0
+  );
+  return {
+    atoms,
+    totalAtoms: atoms.length,
+    totalEstimatedHours,
+    warnings
+  };
+}
+function generateAtomsForFeature(feature, constitution, options) {
+  const atoms = [];
+  const { maxAtoms, hasAuth, hasDatabase } = options;
+  const complexity = feature.complexity ?? 3;
+  const routeCount = feature.routes?.length ?? 0;
+  const hasMultipleRoutes = routeCount > 3;
+  if (complexity >= 4 || hasMultipleRoutes) {
+    if (maxAtoms >= 2) {
+      if (routeCount > 0 || feature.tables?.length) {
+        atoms.push({
+          featureId: feature.id,
+          featureName: feature.name,
+          title: `${feature.name} - Backend/API`,
+          description: `Implement API endpoints and data layer for ${feature.name}`,
+          goals: generateBackendGoals(feature),
+          acceptanceCriteria: filterCriteria(feature.acceptanceCriteria, "backend"),
+          priority: getPriority(feature, "backend"),
+          tags: ["backend", "api", ...extractTags(feature)],
+          estimatedHours: estimateHours(feature, "backend"),
+          dependencies: getDependencies(feature, { hasAuth, hasDatabase })
+        });
+      }
+      atoms.push({
+        featureId: feature.id,
+        featureName: feature.name,
+        title: `${feature.name} - Frontend/UI`,
+        description: `Implement user interface for ${feature.name}`,
+        goals: generateFrontendGoals(feature),
+        acceptanceCriteria: filterCriteria(feature.acceptanceCriteria, "frontend"),
+        priority: getPriority(feature, "frontend"),
+        tags: ["frontend", "ui", ...extractTags(feature)],
+        estimatedHours: estimateHours(feature, "frontend"),
+        dependencies: routeCount > 0 ? [`${feature.id}-backend`] : getDependencies(feature, { hasAuth, hasDatabase })
+      });
+    } else {
+      atoms.push(createSingleAtom(feature, { hasAuth, hasDatabase }));
+    }
+  } else {
+    atoms.push(createSingleAtom(feature, { hasAuth, hasDatabase }));
+  }
+  return atoms;
+}
+function createSingleAtom(feature, deps) {
+  return {
+    featureId: feature.id,
+    featureName: feature.name,
+    title: feature.name,
+    description: feature.userStory || `Implement ${feature.name}`,
+    goals: [
+      `Implement ${feature.name} functionality`,
+      ...feature.routes?.length ? ["Create API endpoints"] : [],
+      ...feature.tables?.length ? ["Set up data models"] : [],
+      "Write unit tests"
+    ],
+    acceptanceCriteria: feature.acceptanceCriteria.length > 0 ? feature.acceptanceCriteria : [`${feature.name} works as specified`],
+    priority: featurePriorityToNumber(feature.priority),
+    tags: extractTags(feature),
+    estimatedHours: estimateHours(feature, "full"),
+    dependencies: getDependencies(feature, deps)
+  };
+}
+function generateBackendGoals(feature) {
+  const goals = [];
+  if (feature.routes?.length) {
+    goals.push(`Implement ${feature.routes.length} API endpoint(s)`);
+  }
+  if (feature.tables?.length) {
+    goals.push(`Create database schema for ${feature.tables.join(", ")}`);
+  }
+  goals.push("Add input validation");
+  goals.push("Implement error handling");
+  goals.push("Write API tests");
+  return goals;
+}
+function generateFrontendGoals(feature) {
+  return [
+    `Create UI components for ${feature.name}`,
+    "Implement form validation",
+    "Add loading and error states",
+    "Ensure responsive design",
+    "Add accessibility attributes"
+  ];
+}
+function filterCriteria(criteria, type) {
+  if (criteria.length === 0) return ["Feature works as specified"];
+  const backendKeywords = ["api", "endpoint", "database", "server", "validation", "auth"];
+  const frontendKeywords = ["ui", "display", "show", "button", "form", "input", "page", "click"];
+  const keywords = type === "backend" ? backendKeywords : frontendKeywords;
+  const filtered = criteria.filter(
+    (c) => keywords.some((k) => c.toLowerCase().includes(k))
+  );
+  if (filtered.length === 0) {
+    const half = Math.ceil(criteria.length / 2);
+    return type === "backend" ? criteria.slice(0, half) : criteria.slice(half);
+  }
+  return filtered;
+}
+function getPriority(feature, type) {
+  const base = featurePriorityToNumber(feature.priority);
+  return type === "backend" ? base : base + 1;
+}
+function featurePriorityToNumber(priority) {
+  switch (priority) {
+    case "MVP":
+      return 10;
+    case "POST_MVP":
+      return 50;
+    case "NICE_TO_HAVE":
+      return 100;
+    default:
+      return 50;
+  }
+}
+function estimateHours(feature, type) {
+  const base = feature.complexity ?? 3;
+  const routeBonus = (feature.routes?.length ?? 0) * 0.5;
+  const tableBonus = (feature.tables?.length ?? 0) * 0.5;
+  switch (type) {
+    case "backend":
+      return Math.round(base * 0.6 + routeBonus + tableBonus);
+    case "frontend":
+      return Math.round(base * 0.6 + 1);
+    case "full":
+      return Math.round(base + routeBonus + tableBonus);
+  }
 }
-async function runAutoCleanupCheck(cwd) {
-  const progressPath = join3(cwd, PROGRESS_FILE);
-  const archonPath = join3(cwd, ARCHON_DIR);
-  const config = await loadCleanupConfig(cwd);
-  const progressMaxKb = config?.progressMaxKb ?? DEFAULT_THRESHOLDS.progressMaxKb;
-  const archonDirMaxMb = config?.archonDirMaxMb ?? DEFAULT_THRESHOLDS.archonDirMaxMb;
-  let needsAttention = false;
-  if (existsSync3(progressPath)) {
-    const size = statSync(progressPath).size;
-    if (size > progressMaxKb * 1024) {
-      needsAttention = true;
+function extractTags(feature) {
+  const tags = [];
+  for (const integration of feature.integrations ?? []) {
+    tags.push(integration.toLowerCase());
+  }
+  const nameLower = feature.name.toLowerCase();
+  if (nameLower.includes("auth")) tags.push("auth");
+  if (nameLower.includes("user")) tags.push("users");
+  if (nameLower.includes("payment") || nameLower.includes("billing")) tags.push("payments");
+  if (nameLower.includes("admin")) tags.push("admin");
+  if (nameLower.includes("dashboard")) tags.push("dashboard");
+  return [...new Set(tags)];
+}
+function getDependencies(feature, deps) {
+  const dependencies = [];
+  if (feature.dependencies?.length) {
+    dependencies.push(...feature.dependencies);
+  }
+  if (deps.hasAuth && requiresAuth(feature)) {
+    dependencies.push("auth");
+  } else if (deps.hasDatabase && requiresDatabase(feature)) {
+    dependencies.push("database");
+  }
+  return dependencies.length > 0 ? dependencies : void 0;
+}
+function requiresAuth(feature) {
+  const authKeywords = ["user", "account", "profile", "login", "auth", "protected"];
+  const text = `${feature.name} ${feature.userStory}`.toLowerCase();
+  if (feature.routes?.some((r) => r.requiresAuth)) {
+    return true;
+  }
+  return authKeywords.some((k) => text.includes(k));
+}
+function requiresDatabase(feature) {
+  return (feature.tables?.length ?? 0) > 0 || (feature.routes?.length ?? 0) > 0;
+}
+function formatAsPrdJson(result, constitution) {
+  return {
+    projectName: constitution.branding.projectName,
+    version: constitution.version,
+    constitutionHash: constitution.hash,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalAtoms: result.totalAtoms,
+    estimatedHours: result.totalEstimatedHours,
+    userStories: result.atoms.map((atom, index) => ({
+      id: `US-${String(index + 1).padStart(3, "0")}`,
+      featureId: atom.featureId,
+      title: atom.title,
+      description: atom.description,
+      goals: atom.goals,
+      acceptanceCriteria: atom.acceptanceCriteria,
+      priority: atom.priority,
+      estimatedHours: atom.estimatedHours,
+      tags: atom.tags,
+      dependencies: atom.dependencies,
+      passes: false
+    }))
+  };
+}
+function summarizeGeneration(result) {
+  const lines = [];
+  lines.push(`Generated ${result.totalAtoms} atom(s)`);
+  lines.push(`Estimated total: ${result.totalEstimatedHours} hours`);
+  lines.push("");
+  const byFeature = /* @__PURE__ */ new Map();
+  for (const atom of result.atoms) {
+    const key = atom.featureName;
+    if (!byFeature.has(key)) {
+      byFeature.set(key, []);
     }
+    byFeature.get(key)?.push(atom);
   }
-  if (existsSync3(archonPath)) {
-    const size = getDirSize(archonPath);
-    if (size > archonDirMaxMb * 1024 * 1024) {
-      needsAttention = true;
+  lines.push("Atoms by feature:");
+  for (const [feature, atoms] of byFeature) {
+    lines.push(`  ${feature}:`);
+    for (const atom of atoms) {
+      const hours = atom.estimatedHours ? `(~${atom.estimatedHours}h)` : "";
+      lines.push(`    \u2022 ${atom.title} ${hours}`);
     }
   }
-  const orphaned = getOrphanedWorktrees(cwd);
-  if (orphaned.length > 0) {
-    needsAttention = true;
+  if (result.warnings.length > 0) {
+    lines.push("");
+    lines.push("Warnings:");
+    for (const warning of result.warnings) {
+      lines.push(`  \u26A0\uFE0F  ${warning}`);
+    }
   }
-  return needsAttention;
+  return lines.join("\n");
 }
 
 // src/cli/start.ts
@@ -877,7 +2471,8 @@ async function start(options = {}) {
     console.log(chalk4.bold("\nArchonDev - AI-Powered Development Governance"));
     console.log(chalk4.blue("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
   }
-  const token = await getAuthToken();
+  const config = await loadConfig();
+  const token = getAuthToken(config);
   if (!token) {
     console.log(chalk4.yellow("[!] Not logged in"));
     const shouldLogin = await promptYesNo("Would you like to login now?", true);
@@ -1067,100 +2662,252 @@ async function displayGovernanceBanner(status2) {
   }
   console.log();
 }
-async function handleNewProject(cwd, state) {
-  console.log(chalk4.bold("Starting a new project? Great!\n"));
-  console.log(chalk4.dim("I'll ask you a few quick questions to set things up right."));
-  console.log(chalk4.dim("Answer as much or as little as you want \u2014 you can always refine later.\n"));
+async function handleNewProject(cwd, _state) {
+  console.log(chalk4.bold("\u{1F389} Starting a new project? Great!\n"));
+  console.log(chalk4.dim("Answer as much or as little as you want \u2014 you can always refine later."));
+  console.log(chalk4.dim('Type "just start" or "skip" to use defaults.\n'));
+  const initialResponse = await prompt("What do you want to do?");
+  if (!initialResponse.trim()) {
+    console.log(chalk4.yellow("\nNo response provided. Showing options...\n"));
+    await showNewProjectMenu(cwd);
+    return;
+  }
+  const intent = detectUserIntent(initialResponse);
+  if (wantsToSkip(initialResponse)) {
+    console.log(chalk4.dim("\n> Using defaults \u2014 let's go!\n"));
+    await quickStart(cwd);
+    return;
+  }
+  if (intent.mode === "ad_hoc" && intent.confidence >= 0.7) {
+    console.log(chalk4.dim("\n> Got it! Creating a task for this...\n"));
+    const { plan: plan2 } = await import("./plan-TVTKS655.js");
+    await plan2(initialResponse, {});
+    return;
+  }
+  if (intent.mode === "app_builder" && intent.confidence >= 0.7) {
+    console.log(chalk4.dim("\n> Sounds like a bigger project. Let me ask a few quick questions...\n"));
+    await runConversationalInterview(cwd, initialResponse);
+    return;
+  }
+  if (needsClarification(intent)) {
+    console.log();
+    console.log(chalk4.dim("I'm not sure what you're looking for. Are you..."));
+    console.log();
+    console.log(`  ${chalk4.cyan("1")}) ${chalk4.bold("Building something new")} \u2014 a complete app, system, or project`);
+    console.log(`  ${chalk4.cyan("2")}) ${chalk4.bold("Doing a specific task")} \u2014 fix, add, refactor, analyze`);
+    console.log(`  ${chalk4.cyan("3")}) ${chalk4.bold("Just exploring")} \u2014 show me what ArchonDev can do`);
+    console.log();
+    const clarification = await prompt("Enter choice (1-3)");
+    switch (clarification.trim()) {
+      case "1":
+        await runConversationalInterview(cwd, initialResponse);
+        break;
+      case "2":
+        console.log(chalk4.dim("\n> Creating a task for this...\n"));
+        const { plan: plan2 } = await import("./plan-TVTKS655.js");
+        await plan2(initialResponse, {});
+        break;
+      case "3":
+      default:
+        await showNewProjectMenu(cwd);
+    }
+    return;
+  }
+  await runConversationalInterview(cwd, initialResponse);
+}
+async function showNewProjectMenu(cwd) {
   console.log(chalk4.bold("What would you like to do?\n"));
   console.log(`  ${chalk4.cyan("1")}) ${chalk4.bold("Start interview")} \u2014 I'll ask questions to understand your project`);
   console.log(`  ${chalk4.cyan("2")}) ${chalk4.bold("Quick start")} \u2014 Just create basic governance files`);
-  console.log(`  ${chalk4.cyan("3")}) ${chalk4.bold("Import from template")} \u2014 Use a predefined project template`);
+  console.log(`  ${chalk4.cyan("3")}) ${chalk4.bold("Plan a task")} \u2014 Create an atom for a specific task`);
   console.log(`  ${chalk4.cyan("q")}) ${chalk4.dim("Quit")}`);
   console.log();
   const choice = await prompt("Enter choice");
   switch (choice.toLowerCase()) {
     case "1":
-      await runNewProjectInterview(cwd);
+      await runConversationalInterview(cwd, "");
       break;
     case "2":
       await quickStart(cwd);
       break;
-    case "3":
-      console.log(chalk4.yellow("\nTemplates coming soon! Using quick start for now.\n"));
-      await quickStart(cwd);
+    case "3": {
+      const description = await prompt("Describe what you want to do");
+      if (description.trim()) {
+        const { plan: plan2 } = await import("./plan-TVTKS655.js");
+        await plan2(description, {});
+      }
       break;
+    }
     case "q":
       process.exit(0);
     default:
       console.log(chalk4.yellow("Invalid choice. Please try again."));
-      await handleNewProject(cwd, state);
-  }
-}
-async function runNewProjectInterview(cwd) {
-  console.log(chalk4.blue("\n-- Project Interview --\n"));
-  console.log(chalk4.bold("Phase 1: The Vision\n"));
-  const projectName = await prompt("What's the project name?");
-  const projectDescription = await prompt("In one sentence, what does this project do?");
-  const audience = await promptChoice("Who is it for?", [
-    { key: "1", label: "Just me (personal project)" },
-    { key: "2", label: "My team (internal tool)" },
-    { key: "3", label: "End users (product)" }
-  ]);
-  const experience = await promptChoice("Your experience level with this tech stack?", [
-    { key: "1", label: "\u{1F7E2} Expert \u2014 I know this well" },
-    { key: "2", label: "\u{1F7E1} Intermediate \u2014 I've done similar work" },
-    { key: "3", label: "\u{1F534} Learning \u2014 This is new to me" }
-  ]);
-  console.log(chalk4.bold("\nPhase 2: Tech Stack\n"));
-  const language = await promptChoice("Primary language/framework?", [
-    { key: "1", label: "TypeScript / JavaScript" },
-    { key: "2", label: "Python" },
-    { key: "3", label: "Go" },
-    { key: "4", label: "Rust" },
-    { key: "5", label: "Other" }
-  ]);
-  const projectType = await promptChoice("Project type?", [
-    { key: "1", label: "Frontend only (web UI)" },
-    { key: "2", label: "Backend only (API, CLI, service)" },
-    { key: "3", label: "Full-stack (both)" },
-    { key: "4", label: "Library/package" }
-  ]);
-  console.log(chalk4.bold("\nPhase 3: Preferences ") + chalk4.dim("(press Enter to skip)\n"));
-  const protectedFiles = await prompt("Any files AI should NEVER modify without asking? (comma-separated)");
-  const noNoPatterns = await prompt('Anything AI should NEVER do? (e.g., "no console.log")');
-  console.log(chalk4.blue("\n-- Generating Project Files --\n"));
+      await showNewProjectMenu(cwd);
+  }
+}
+async function runConversationalInterview(cwd, initialMessage) {
+  const projectNameHint = extractProjectNameHint(initialMessage);
+  const techHints = extractTechStackHints(initialMessage);
+  const state = createInterviewStateFromMessage(initialMessage, {
+    projectName: projectNameHint,
+    ...techHints
+  });
+  const known = getKnownInfo(state);
+  if (known.length > 0) {
+    console.log(chalk4.dim("From what you said, I got:"));
+    for (const info of known) {
+      console.log(chalk4.dim(`  \u2022 ${info}`));
+    }
+    console.log();
+  }
+  if (!state.description && !state.projectName) {
+    console.log(chalk4.bold("Quick question:"));
+    const description = await prompt("In one sentence, what does this project do?");
+    if (wantsToSkip(description)) {
+      await finishInterview(cwd, state);
+      return;
+    }
+    state.description = description.trim() || initialMessage;
+  }
+  if (!state.posture && !state.audience) {
+    console.log();
+    console.log(chalk4.dim("Who is this for?"));
+    console.log(`  ${chalk4.cyan("1")}) Just me (personal/prototype)`);
+    console.log(`  ${chalk4.cyan("2")}) My team (internal tool)`);
+    console.log(`  ${chalk4.cyan("3")}) End users (production product)`);
+    console.log(chalk4.dim("  (or press Enter to skip)"));
+    const audienceChoice = await prompt("");
+    if (wantsToSkip(audienceChoice)) {
+      await finishInterview(cwd, state);
+      return;
+    }
+    switch (audienceChoice.trim()) {
+      case "1":
+        state.audience = "personal";
+        state.posture = "prototype";
+        break;
+      case "2":
+        state.audience = "team";
+        state.posture = "production";
+        break;
+      case "3":
+        state.audience = "endusers";
+        state.posture = "production";
+        break;
+    }
+  }
+  if (!state.language) {
+    console.log();
+    console.log(chalk4.dim("What language/framework?"));
+    console.log(`  ${chalk4.cyan("1")}) TypeScript / JavaScript`);
+    console.log(`  ${chalk4.cyan("2")}) Python`);
+    console.log(`  ${chalk4.cyan("3")}) Go`);
+    console.log(`  ${chalk4.cyan("4")}) Rust`);
+    console.log(`  ${chalk4.cyan("5")}) Other`);
+    console.log(chalk4.dim("  (or press Enter to skip)"));
+    const langChoice = await prompt("");
+    if (!wantsToSkip(langChoice)) {
+      switch (langChoice.trim()) {
+        case "1":
+          state.language = "typescript";
+          break;
+        case "2":
+          state.language = "python";
+          break;
+        case "3":
+          state.language = "go";
+          break;
+        case "4":
+          state.language = "rust";
+          break;
+        case "5":
+          state.language = "other";
+          break;
+      }
+    }
+  }
+  if (!state.projectType) {
+    console.log();
+    console.log(chalk4.dim("Project type?"));
+    console.log(`  ${chalk4.cyan("1")}) Frontend (web UI)`);
+    console.log(`  ${chalk4.cyan("2")}) Backend (API, CLI, service)`);
+    console.log(`  ${chalk4.cyan("3")}) Full-stack (both)`);
+    console.log(`  ${chalk4.cyan("4")}) Library/package`);
+    console.log(chalk4.dim("  (or press Enter to skip)"));
+    const typeChoice = await prompt("");
+    if (!wantsToSkip(typeChoice)) {
+      switch (typeChoice.trim()) {
+        case "1":
+          state.projectType = "frontend";
+          break;
+        case "2":
+          state.projectType = "backend";
+          break;
+        case "3":
+          state.projectType = "fullstack";
+          break;
+        case "4":
+          state.projectType = "library";
+          break;
+      }
+    }
+  }
+  console.log();
+  console.log(chalk4.dim("Any files AI should NEVER modify? ") + chalk4.dim("(comma-separated, or Enter to skip)"));
+  const protectedFilesInput = await prompt("");
+  if (protectedFilesInput.trim() && !wantsToSkip(protectedFilesInput)) {
+    state.protectedFiles = protectedFilesInput.split(",").map((f) => f.trim()).filter(Boolean);
+  }
+  if (!state.posture) {
+    state.posture = inferPosture(state) ?? "production";
+  }
+  await finishInterview(cwd, state);
+}
+async function finishInterview(cwd, state) {
+  console.log(chalk4.blue("\n-- Setting Up Project --\n"));
+  const posture = state.posture === "enterprise" ? "enterprise" : state.posture === "prototype" ? "prototype" : "production";
   const { init: init2 } = await import("./init-6EXMDCWC.js");
-  await init2({ analyze: false, git: true });
+  await init2({ analyze: false, git: true, posture });
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const progressEntry = `
 ## ${today} - Project Initialized via Interview
 
 ### Vision
-- **Name:** ${projectName || "Unnamed Project"}
-- **Description:** ${projectDescription || "No description provided"}
-- **Audience:** ${["Personal", "Team", "End Users"][parseInt(audience) - 1] || "Not specified"}
-- **Experience Level:** ${["Expert", "Intermediate", "Learning"][parseInt(experience) - 1] || "Not specified"}
+- **Name:** ${state.projectName || "Unnamed Project"}
+- **Description:** ${state.description || "No description provided"}
+- **Audience:** ${state.audience || "Not specified"}
+- **Posture:** ${state.posture || "production"}
 
 ### Stack
-- **Language:** ${["TypeScript/JavaScript", "Python", "Go", "Rust", "Other"][parseInt(language) - 1] || "Not specified"}
-- **Type:** ${["Frontend", "Backend", "Full-stack", "Library"][parseInt(projectType) - 1] || "Not specified"}
+- **Language:** ${state.language || "Not specified"}
+- **Framework:** ${state.framework || "Not specified"}
+- **Type:** ${state.projectType || "Not specified"}
+- **Database:** ${state.database || "Not specified"}
 
 ### Preferences
-${protectedFiles ? `- **Protected files:** ${protectedFiles}` : "- No protected files specified"}
-${noNoPatterns ? `- **Forbidden patterns:** ${noNoPatterns}` : "- No forbidden patterns specified"}
+${state.protectedFiles?.length ? `- **Protected files:** ${state.protectedFiles.join(", ")}` : "- No protected files specified"}
+${state.forbiddenPatterns?.length ? `- **Forbidden patterns:** ${state.forbiddenPatterns.join(", ")}` : "- No forbidden patterns specified"}
 
 ### Files Created
-- ARCHITECTURE.md
+- ARCHITECTURE.md (posture: ${posture})
 - .archon/config.yaml
 - progress.txt
 `;
   const progressPath = join4(cwd, "progress.txt");
   if (!existsSync4(progressPath)) {
-    const { writeFileSync } = await import("fs");
-    writeFileSync(progressPath, "# ArchonDev Progress Log\n\nThis file tracks learnings and decisions across sessions.\n");
+    const { writeFileSync: writeFileSync2 } = await import("fs");
+    writeFileSync2(progressPath, "# ArchonDev Progress Log\n\nThis file tracks learnings and decisions across sessions.\n");
   }
   appendFileSync(progressPath, progressEntry);
   console.log(chalk4.green("\n\u2713 Project initialized!\n"));
+  const finalKnown = getKnownInfo(state);
+  if (finalKnown.length > 0) {
+    console.log(chalk4.dim("Project configured with:"));
+    for (const info of finalKnown) {
+      console.log(chalk4.dim(`  \u2022 ${info}`));
+    }
+    console.log();
+  }
   console.log(chalk4.bold("Next steps:"));
   console.log(`  1. ${chalk4.cyan("Review")} ARCHITECTURE.md and customize if needed`);
   console.log(`  2. ${chalk4.cyan("Run")} ${chalk4.dim('archon plan "your first task"')} to create an atom`);
@@ -1181,8 +2928,8 @@ async function quickStart(cwd) {
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const progressPath = join4(cwd, "progress.txt");
   if (!existsSync4(progressPath)) {
-    const { writeFileSync } = await import("fs");
-    writeFileSync(progressPath, `# ArchonDev Progress Log
+    const { writeFileSync: writeFileSync2 } = await import("fs");
+    writeFileSync2(progressPath, `# ArchonDev Progress Log
 
 This file tracks learnings and decisions across sessions.
 
@@ -1240,8 +2987,8 @@ async function analyzeAndAdapt(cwd) {
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const progressPath = join4(cwd, "progress.txt");
   if (!existsSync4(progressPath)) {
-    const { writeFileSync } = await import("fs");
-    writeFileSync(progressPath, "# ArchonDev Progress Log\n\nThis file tracks learnings and decisions across sessions.\n");
+    const { writeFileSync: writeFileSync2 } = await import("fs");
+    writeFileSync2(progressPath, "# ArchonDev Progress Log\n\nThis file tracks learnings and decisions across sessions.\n");
   }
   appendFileSync(progressPath, `
 ## ${today} - ArchonDev Adapted to Existing Project
@@ -1293,8 +3040,8 @@ async function quickAdapt(cwd) {
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const progressPath = join4(cwd, "progress.txt");
   if (!existsSync4(progressPath)) {
-    const { writeFileSync } = await import("fs");
-    writeFileSync(progressPath, "# ArchonDev Progress Log\n\nThis file tracks learnings and decisions across sessions.\n");
+    const { writeFileSync: writeFileSync2 } = await import("fs");
+    writeFileSync2(progressPath, "# ArchonDev Progress Log\n\nThis file tracks learnings and decisions across sessions.\n");
   }
   appendFileSync(progressPath, `
 ## ${today} - Quick Adapt (Defaults)
@@ -1539,22 +3286,6 @@ function promptYesNo(question, defaultValue) {
     });
   });
 }
-function promptChoice(question, options) {
-  return new Promise((resolve) => {
-    console.log(`${chalk4.cyan("?")} ${question}`);
-    for (const opt of options) {
-      console.log(`    ${chalk4.dim(opt.key)}) ${opt.label}`);
-    }
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
-    rl.question(`  ${chalk4.dim("Enter choice")}: `, (answer) => {
-      rl.close();
-      resolve(answer.trim() || "1");
-    });
-  });
-}
 
 // src/cli/credits.ts
 import chalk5 from "chalk";
@@ -2574,7 +4305,7 @@ async function a11yCheck(options) {
   console.log(chalk7.dim(`Full report saved to: .archon/a11y-report.json`));
 }
 async function a11yFix(options) {
-  const prompt2 = createPrompt();
+  const prompt3 = createPrompt();
   try {
     console.log(chalk7.blue("\n\u267F Accessibility Auto-Fix\n"));
     const reportPath = join6(process.cwd(), ".archon/a11y-report.json");
@@ -2651,7 +4382,7 @@ ${totalFixes} fixes would be applied. Run without --dry-run to apply.`));
       console.log(chalk7.dim('Run "archon a11y check" to verify fixes.'));
     }
   } finally {
-    prompt2.close();
+    prompt3.close();
   }
 }
 async function a11yBadge(options) {
@@ -2689,7 +4420,7 @@ async function a11yBadge(options) {
   }
 }
 async function a11yPreDeploy() {
-  const prompt2 = createPrompt();
+  const prompt3 = createPrompt();
   try {
     console.log(chalk7.blue("\n[CHECK] Pre-Deploy Accessibility\n"));
     console.log(chalk7.dim("Before deploying a live website, accessibility compliance is required.\n"));
@@ -2701,7 +4432,7 @@ async function a11yPreDeploy() {
     const reportContent = await readFile5(reportPath, "utf-8");
     const report = JSON.parse(reportContent);
     if (report.passed) {
-      const addBadge = await prompt2.ask("\nWould you like to add a WCAG 2.2 AA badge to your footer? (y/N): ");
+      const addBadge = await prompt3.ask("\nWould you like to add a WCAG 2.2 AA badge to your footer? (y/N): ");
       if (addBadge.toLowerCase() === "y") {
         await a11yBadge({});
       }
@@ -2711,7 +4442,7 @@ async function a11yPreDeploy() {
     console.log("  1) Fix issues now (recommended)");
     console.log("  2) Deploy anyway (not recommended)");
     console.log("  3) Cancel deployment\n");
-    const choice = await prompt2.ask("Which would you like to do? (1/2/3): ");
+    const choice = await prompt3.ask("Which would you like to do? (1/2/3): ");
     if (choice === "1") {
       await a11yFix({});
       await a11yCheck({});
@@ -2725,7 +4456,7 @@ async function a11yPreDeploy() {
       return false;
     }
   } finally {
-    prompt2.close();
+    prompt3.close();
   }
 }
 
@@ -2820,7 +4551,7 @@ Guidelines:
 Output your response as valid JSON.`;
 async function generateIdentityCandidates(pageContent) {
   const agent = new ArchitectAgent({ temperature: 0.8 });
-  const prompt2 = `Based on the following website content, generate brand identity options.
+  const prompt3 = `Based on the following website content, generate brand identity options.
 
 ${pageContent}
 
@@ -2841,7 +4572,7 @@ Output as JSON:
 }`;
   const response = await agent.client.chat(
     IDENTITY_SYSTEM_PROMPT,
-    prompt2,
+    prompt3,
     { temperature: 0.8, maxTokens: 2e3 }
   );
   const jsonMatch = response.content.match(/\{[\s\S]*\}/);
@@ -2853,7 +4584,7 @@ Output as JSON:
 }
 async function geoIdentity() {
   const cwd = process.cwd();
-  const prompt2 = createPrompt2();
+  const prompt3 = createPrompt2();
   try {
     console.log(chalk8.blue("\n\u{1F3AF} GEO Identity Generator\n"));
     const { allowed, tier } = await checkStrongModelAccess();
@@ -2884,7 +4615,7 @@ async function geoIdentity() {
       console.log(`     ${chalk8.dim(p.rationale)}
 `);
     });
-    const phraseChoice = await prompt2.ask('Select a phrase (1-3) or "r" to regenerate: ');
+    const phraseChoice = await prompt3.ask('Select a phrase (1-3) or "r" to regenerate: ');
     if (phraseChoice.toLowerCase() === "r") {
       console.log(chalk8.dim("\nRegenerating... Run the command again.\n"));
       return;
@@ -2901,7 +4632,7 @@ async function geoIdentity() {
       console.log(`     ${chalk8.dim(d.rationale)}
 `);
     });
-    const descChoice = await prompt2.ask('Select a description (1-3) or "r" to regenerate: ');
+    const descChoice = await prompt3.ask('Select a description (1-3) or "r" to regenerate: ');
     if (descChoice.toLowerCase() === "r") {
       console.log(chalk8.dim("\nRegenerating... Run the command again.\n"));
       return;
@@ -2926,7 +4657,7 @@ async function geoIdentity() {
     console.log();
     console.log(chalk8.cyan(`Use 'archon geo schema' to generate JSON-LD.`));
   } finally {
-    prompt2.close();
+    prompt3.close();
   }
 }
 async function geoSchema(options) {
@@ -3043,7 +4774,7 @@ async function geoFaq(options) {
   }
   console.log(chalk8.dim("Generating FAQ content with AI...\n"));
   const agent = new ArchitectAgent({ temperature: 0.7 });
-  const prompt2 = `Generate FAQ content for a product/service with:
+  const prompt3 = `Generate FAQ content for a product/service with:
 - Brand phrase: "${identityPhrase}"
 - Description: "${shortDescription}"
 
@@ -3056,7 +4787,7 @@ Generate 6-8 FAQs as JSON:
 }`;
   const response = await agent.client.chat(
     FAQ_SYSTEM_PROMPT,
-    prompt2,
+    prompt3,
     { temperature: 0.7, maxTokens: 2e3 }
   );
   const jsonMatch = response.content.match(/\{[\s\S]*\}/);
@@ -3418,7 +5149,7 @@ async function seoCheck(options) {
 Full report saved to: .archon/seo-report.json`));
 }
 async function seoFix(options) {
-  const prompt2 = createPrompt3();
+  const prompt3 = createPrompt3();
   try {
     console.log(chalk9.blue("\n\u{1F527} SEO Auto-Fix\n"));
     const reportPath = join8(process.cwd(), ".archon/seo-report.json");
@@ -3474,7 +5205,7 @@ async function seoFix(options) {
         console.log(chalk9.green(`    + ${tag.slice(0, 70)}${tag.length > 70 ? "..." : ""}`));
       }
       if (!options.dryRun) {
-        const confirm = await prompt2.ask(chalk9.dim("    Apply these changes? (y/N): "));
+        const confirm = await prompt3.ask(chalk9.dim("    Apply these changes? (y/N): "));
         if (confirm.toLowerCase() === "y") {
           await writeFile7(filePath, newContent);
           totalFixes += tagsToAdd.length;
@@ -3497,11 +5228,11 @@ ${totalFixes} fixes would be applied. Run without --dry-run to apply.`));
       console.log(chalk9.dim('Run "archon seo check" to verify fixes.'));
     }
   } finally {
-    prompt2.close();
+    prompt3.close();
   }
 }
 async function seoOpenGraph(options) {
-  const prompt2 = createPrompt3();
+  const prompt3 = createPrompt3();
   try {
     console.log(chalk9.blue("\n\u{1F4F1} Add Open Graph Tags\n"));
     let targetFile;
@@ -3520,7 +5251,7 @@ async function seoOpenGraph(options) {
       if (files.length > 10) {
         console.log(chalk9.dim(`  ... and ${files.length - 10} more`));
       }
-      const fileChoice = await prompt2.ask("\nEnter file path or number: ");
+      const fileChoice = await prompt3.ask("\nEnter file path or number: ");
       const num = parseInt(fileChoice, 10);
       if (num > 0 && num <= files.length) {
         targetFile = files[num - 1] ?? "";
@@ -3532,10 +5263,10 @@ async function seoOpenGraph(options) {
       console.log(chalk9.red(`File not found: ${targetFile}`));
       return;
     }
-    const ogTitle = await prompt2.ask("og:title (page title for social): ");
-    const ogDescription = await prompt2.ask("og:description (page description): ");
-    const ogImage = await prompt2.ask("og:image (full URL to image): ");
-    const ogUrl = await prompt2.ask("og:url (canonical page URL): ");
+    const ogTitle = await prompt3.ask("og:title (page title for social): ");
+    const ogDescription = await prompt3.ask("og:description (page description): ");
+    const ogImage = await prompt3.ask("og:image (full URL to image): ");
+    const ogUrl = await prompt3.ask("og:url (canonical page URL): ");
     const tags = [
       `<meta property="og:type" content="website">`,
       `<meta property="og:title" content="${ogTitle}">`,
@@ -3552,7 +5283,7 @@ async function seoOpenGraph(options) {
     }
     console.log(chalk9.dim("\nTags to add:"));
     tags.forEach((tag) => console.log(chalk9.green(`  + ${tag}`)));
-    const confirm = await prompt2.ask("\nApply changes? (y/N): ");
+    const confirm = await prompt3.ask("\nApply changes? (y/N): ");
     if (confirm.toLowerCase() === "y") {
       const newContent = content.slice(0, insertPoint.index) + "\n" + tags.map((tag) => insertPoint.indent + tag).join("\n") + content.slice(insertPoint.index);
       await writeFile7(targetFile, newContent);
@@ -3561,11 +5292,11 @@ async function seoOpenGraph(options) {
       console.log(chalk9.dim("Cancelled."));
     }
   } finally {
-    prompt2.close();
+    prompt3.close();
   }
 }
 async function seoTwitter(options) {
-  const prompt2 = createPrompt3();
+  const prompt3 = createPrompt3();
   try {
     console.log(chalk9.blue("\n\u{1F426} Add Twitter Card Tags\n"));
     let targetFile;
@@ -3584,7 +5315,7 @@ async function seoTwitter(options) {
       if (files.length > 10) {
         console.log(chalk9.dim(`  ... and ${files.length - 10} more`));
       }
-      const fileChoice = await prompt2.ask("\nEnter file path or number: ");
+      const fileChoice = await prompt3.ask("\nEnter file path or number: ");
       const num = parseInt(fileChoice, 10);
       if (num > 0 && num <= files.length) {
         targetFile = files[num - 1] ?? "";
@@ -3597,10 +5328,10 @@ async function seoTwitter(options) {
       return;
     }
     console.log(chalk9.dim("Card types: summary, summary_large_image, app, player"));
-    const cardType = await prompt2.ask("twitter:card type (default: summary_large_image): ") || "summary_large_image";
-    const twitterTitle = await prompt2.ask("twitter:title: ");
-    const twitterDescription = await prompt2.ask("twitter:description: ");
-    const twitterImage = await prompt2.ask("twitter:image (full URL): ");
+    const cardType = await prompt3.ask("twitter:card type (default: summary_large_image): ") || "summary_large_image";
+    const twitterTitle = await prompt3.ask("twitter:title: ");
+    const twitterDescription = await prompt3.ask("twitter:description: ");
+    const twitterImage = await prompt3.ask("twitter:image (full URL): ");
     const tags = [
       `<meta name="twitter:card" content="${cardType}">`,
       `<meta name="twitter:title" content="${twitterTitle}">`,
@@ -3616,7 +5347,7 @@ async function seoTwitter(options) {
     }
     console.log(chalk9.dim("\nTags to add:"));
     tags.forEach((tag) => console.log(chalk9.green(`  + ${tag}`)));
-    const confirm = await prompt2.ask("\nApply changes? (y/N): ");
+    const confirm = await prompt3.ask("\nApply changes? (y/N): ");
     if (confirm.toLowerCase() === "y") {
       const newContent = content.slice(0, insertPoint.index) + "\n" + tags.map((tag) => insertPoint.indent + tag).join("\n") + content.slice(insertPoint.index);
       await writeFile7(targetFile, newContent);
@@ -3625,7 +5356,7 @@ async function seoTwitter(options) {
       console.log(chalk9.dim("Cancelled."));
     }
   } finally {
-    prompt2.close();
+    prompt3.close();
   }
 }
 function createSeoCommand() {
@@ -4176,7 +5907,7 @@ import { createClient as createClient3 } from "@supabase/supabase-js";
 import { readFile as readFile10 } from "fs/promises";
 import { existsSync as existsSync13 } from "fs";
 import { join as join12, extname as extname2 } from "path";
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 var CHUNK_SIZE2 = 1e3;
 var CHUNK_OVERLAP2 = 200;
 var INDEXABLE_EXTENSIONS2 = /* @__PURE__ */ new Set([
@@ -4290,7 +6021,7 @@ var CloudIndexer = class {
    * Compute file hash for change detection
    */
   async computeFileHash(content) {
-    return createHash("sha256").update(content).digest("hex").slice(0, 16);
+    return createHash2("sha256").update(content).digest("hex").slice(0, 16);
   }
   /**
    * Index a single file
@@ -4749,13 +6480,422 @@ async function githubDisconnect() {
   }
 }
 
+// src/cli/interview.ts
+import chalk14 from "chalk";
+import readline2 from "readline";
+import ora3 from "ora";
+import { existsSync as existsSync14, readFileSync as readFileSync3, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join14 } from "path";
+import { randomUUID } from "crypto";
+function getConstitutionPath(cwd) {
+  return join14(cwd, ".archon", "constitution.json");
+}
+function getDraftPath(cwd) {
+  return join14(cwd, ".archon", "constitution-draft.json");
+}
+async function interview(options = {}) {
+  const cwd = process.cwd();
+  const archonDir = join14(cwd, ".archon");
+  if (!existsSync14(archonDir)) {
+    mkdirSync2(archonDir, { recursive: true });
+  }
+  console.log(chalk14.bold("\n\u{1F3AF} ArchonDev Project Interview"));
+  console.log(chalk14.dim("Let's define what you're building.\n"));
+  const constitutionPath = getConstitutionPath(cwd);
+  const draftPath = getDraftPath(cwd);
+  if (existsSync14(constitutionPath)) {
+    const existing = deserializeConstitution(readFileSync3(constitutionPath, "utf-8"));
+    if (existing.state === "FROZEN") {
+      console.log(chalk14.yellow("[!] A frozen Constitution already exists."));
+      console.log(chalk14.dim(`    Project: ${existing.branding.projectName}`));
+      console.log(chalk14.dim(`    Frozen: ${existing.frozenAt?.toISOString()}`));
+      console.log();
+      const action = await prompt2("Start a new interview (overwrite) or view existing? (new/view)");
+      if (action.toLowerCase() === "view") {
+        console.log("\n" + summarizeConstitution(existing));
+        return;
+      } else if (action.toLowerCase() !== "new") {
+        console.log(chalk14.dim("Cancelled."));
+        return;
+      }
+    }
+  }
+  let constitution;
+  let startPhase = 1;
+  if (existsSync14(draftPath) && options.resume !== false) {
+    const draft = deserializeConstitution(readFileSync3(draftPath, "utf-8"));
+    console.log(chalk14.blue("[i] Found draft from previous session."));
+    console.log(chalk14.dim(`    Project: ${draft.branding.projectName || "(unnamed)"}`));
+    console.log();
+    const resumeChoice = await prompt2("Resume draft or start fresh? (resume/fresh)");
+    if (resumeChoice.toLowerCase() === "resume") {
+      constitution = draft;
+      for (let phase = 1; phase <= 5; phase++) {
+        const phaseInfo = INTERVIEW_PHASES[phase];
+        if (!phaseInfo?.isComplete(constitution)) {
+          startPhase = phase;
+          break;
+        }
+      }
+      console.log(chalk14.green(`
+\u2713 Resuming at Phase ${startPhase}: ${INTERVIEW_PHASES[startPhase]?.name}
+`));
+    } else {
+      constitution = createDraftConstitution(randomUUID());
+    }
+  } else {
+    constitution = createDraftConstitution(randomUUID());
+  }
+  if (options.phase && options.phase >= 1 && options.phase <= 5) {
+    startPhase = options.phase;
+    console.log(chalk14.dim(`Starting at Phase ${startPhase}...
+`));
+  }
+  console.log(chalk14.dim("\u2500".repeat(40)));
+  console.log(chalk14.dim(formatProgressBar(startPhase)));
+  console.log(chalk14.dim("\u2500".repeat(40)));
+  console.log();
+  let currentPhase = startPhase;
+  while (currentPhase <= 5) {
+    const result = await runPhase(currentPhase, constitution, cwd);
+    if (result.action === "exit") {
+      saveDraft(cwd, constitution);
+      console.log(chalk14.dim("\nDraft saved. Run `archon interview` to resume.\n"));
+      return;
+    }
+    if (result.action === "back" && currentPhase > 1) {
+      currentPhase = currentPhase - 1;
+      continue;
+    }
+    if (result.constitution) {
+      constitution = result.constitution;
+    }
+    saveDraft(cwd, constitution);
+    const next = getNextPhase(currentPhase);
+    if (next) {
+      currentPhase = next;
+      console.log();
+      console.log(chalk14.dim("\u2500".repeat(40)));
+      console.log(chalk14.dim(formatProgressBar(currentPhase)));
+      console.log(chalk14.dim("\u2500".repeat(40)));
+      console.log();
+    } else {
+      break;
+    }
+  }
+  const validationResult = validateConstitution(constitution);
+  if (!validationResult.valid) {
+    console.log(chalk14.red("\n[!] Constitution has validation errors:\n"));
+    for (const error of validationResult.errors) {
+      console.log(chalk14.red(`   \u2022 ${error}`));
+    }
+    console.log();
+    const fix = await promptYesNo2("Would you like to go back and fix these?", true);
+    if (fix) {
+      await interview({ ...options, phase: 1 });
+      return;
+    }
+  }
+  if (validationResult.warnings.length > 0) {
+    console.log(chalk14.yellow("\n[!] Warnings:\n"));
+    for (const warning of validationResult.warnings) {
+      console.log(chalk14.yellow(`   \u2022 ${warning}`));
+    }
+    console.log();
+  }
+  const config = await loadConfig();
+  constitution.complexity = calculateComplexity(constitution);
+  constitution.estimatedBuildHours = estimateBuildHours(constitution.complexity);
+  constitution.costs = estimateCosts(constitution, config.tier || "FREE");
+  const challengeResult = analyzeForChallenges(constitution);
+  if (challengeResult.shouldChallenge) {
+    console.log(chalk14.bold("\n\u{1F3AF} Challenge Mode\n"));
+    console.log(chalk14.dim("Let me share some observations about your project scope...\n"));
+    for (const challenge of challengeResult.challenges) {
+      const prompt3 = generateChallengePrompt(challenge);
+      const icon = challenge.severity === "critical" ? chalk14.red("\u25CF") : chalk14.yellow("\u25CF");
+      console.log(`${icon} ${chalk14.bold(challenge.title)}`);
+      console.log(chalk14.dim(`   ${prompt3}`));
+      console.log();
+    }
+    console.log(chalk14.dim("\u2500".repeat(40)));
+    console.log(summarizeChallenges(challengeResult));
+    console.log(chalk14.dim("\u2500".repeat(40)));
+    console.log();
+    if (challengeResult.featuresToDefer.length > 0) {
+      console.log(chalk14.bold("Suggested Features to Defer to Post-MVP:\n"));
+      for (const feature of challengeResult.featuresToDefer) {
+        console.log(`   \u2022 ${feature.name}`);
+      }
+      console.log();
+      const acceptDeferrals = await promptYesNo2(
+        `Move ${challengeResult.featuresToDefer.length} feature(s) to post-MVP?`,
+        true
+      );
+      if (acceptDeferrals) {
+        const featureIds = challengeResult.featuresToDefer.map((f) => f.id);
+        constitution = applyDeferrals(constitution, featureIds);
+        constitution.complexity = calculateComplexity(constitution);
+        constitution.estimatedBuildHours = estimateBuildHours(constitution.complexity);
+        constitution.costs = estimateCosts(constitution, config.tier || "FREE");
+        console.log(chalk14.green("\n\u2713 Features deferred. Updated estimates:"));
+        console.log(chalk14.dim(`   Complexity: ${constitution.complexity.tier}`));
+        console.log(chalk14.dim(`   Build time: ~${Math.round(constitution.estimatedBuildHours)} hours`));
+        console.log();
+        saveDraft(cwd, constitution);
+      }
+    }
+    const criticalCount = challengeResult.challenges.filter((c) => c.severity === "critical").length;
+    if (criticalCount > 0) {
+      console.log(chalk14.red(`
+\u26A0\uFE0F  ${criticalCount} critical issue(s) detected.`));
+      const proceed = await promptYesNo2("Proceed anyway?", false);
+      if (!proceed) {
+        saveDraft(cwd, constitution);
+        console.log(chalk14.dim("\nDraft saved. Address the issues and run `archon interview` again.\n"));
+        return;
+      }
+    }
+  } else {
+    console.log(chalk14.green("\n\u2713 Scope looks reasonable! No major concerns detected.\n"));
+  }
+  console.log(chalk14.bold("\n\u{1F4CB} Constitution Summary\n"));
+  console.log(summarizeConstitution(constitution));
+  console.log();
+  if (options.dryRun) {
+    console.log(chalk14.dim("(Dry run mode - not freezing Constitution)"));
+    saveDraft(cwd, constitution);
+    return;
+  }
+  const confirmFreeze = await promptYesNo2("Freeze this Constitution and start building?", true);
+  if (!confirmFreeze) {
+    saveDraft(cwd, constitution);
+    console.log(chalk14.dim("\nDraft saved. Run `archon interview` to continue.\n"));
+    return;
+  }
+  const spinner = ora3("Freezing Constitution...").start();
+  try {
+    const frozen = freezeConstitution(constitution);
+    writeFileSync(constitutionPath, serializeConstitution(frozen));
+    if (existsSync14(draftPath)) {
+      const { unlinkSync } = await import("fs");
+      unlinkSync(draftPath);
+    }
+    spinner.succeed(chalk14.green("Constitution frozen!"));
+    console.log();
+    console.log(chalk14.dim(`Hash: ${frozen.hash?.substring(0, 32)}...`));
+    console.log(chalk14.dim(`Saved: ${constitutionPath}`));
+    console.log();
+    console.log(chalk14.bold("Next Steps:\n"));
+    console.log(`  ${chalk14.cyan("1.")} Run ${chalk14.bold("archon generate")} to create atoms from this Constitution`);
+    console.log(`  ${chalk14.cyan("2.")} Run ${chalk14.bold("archon list")} to see generated atoms`);
+    console.log(`  ${chalk14.cyan("3.")} Run ${chalk14.bold("archon execute <atom-id>")} to start building`);
+    console.log();
+  } catch (err) {
+    spinner.fail("Failed to freeze Constitution");
+    console.error(err);
+  }
+}
+async function runPhase(phase, constitution, cwd) {
+  const phaseInfo = INTERVIEW_PHASES[phase];
+  console.log(chalk14.bold(`Phase ${phase}: ${phaseInfo.name}`));
+  console.log(chalk14.dim(phaseInfo.description));
+  console.log();
+  const skippable = getSkippableQuestions(phase, constitution);
+  let updatedConstitution = { ...constitution };
+  for (const question of phaseInfo.questions) {
+    if (skippable.includes(question.id)) {
+      console.log(chalk14.dim(`[\u2713] ${question.prompt.split("?")[0]}... (already answered)`));
+      continue;
+    }
+    if (phase === 5 && question.id === "review_summary") {
+      console.log(chalk14.bold("\n\u{1F4CB} Current State:\n"));
+      console.log(summarizeConstitution(updatedConstitution));
+      console.log();
+    }
+    const answer = await promptQuestion(question);
+    if (answer.toLowerCase() === "exit" || answer.toLowerCase() === "quit") {
+      return { action: "exit", constitution: updatedConstitution };
+    }
+    if (answer.toLowerCase() === "back") {
+      return { action: "back", constitution: updatedConstitution };
+    }
+    if (answer.toLowerCase() === "skip" && !question.required) {
+      continue;
+    }
+    if (question.validator) {
+      const validation = question.validator(answer);
+      if (!validation.valid) {
+        console.log(chalk14.red(`   ${validation.error}`));
+        continue;
+      }
+    }
+    const extracted = question.extractor(answer, updatedConstitution);
+    updatedConstitution = { ...updatedConstitution, ...extracted };
+    if (question.followUp && answer.length > 10) {
+      console.log(chalk14.dim(`   ${question.followUp}`));
+    }
+  }
+  return { action: "next", constitution: updatedConstitution };
+}
+function saveDraft(cwd, constitution) {
+  const draftPath = getDraftPath(cwd);
+  writeFileSync(draftPath, serializeConstitution(constitution));
+}
+async function promptQuestion(question) {
+  const prefix = question.required ? chalk14.red("*") : " ";
+  return prompt2(`${prefix} ${question.prompt}`);
+}
+function prompt2(question) {
+  return new Promise((resolve) => {
+    const rl = readline2.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(`${chalk14.cyan("?")} ${question}
+  > `, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function promptYesNo2(question, defaultValue) {
+  return new Promise((resolve) => {
+    const rl = readline2.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const hint = defaultValue ? "(Y/n)" : "(y/N)";
+    rl.question(`${chalk14.cyan("?")} ${question} ${hint}: `, (answer) => {
+      rl.close();
+      if (answer.trim() === "") {
+        resolve(defaultValue);
+      } else {
+        resolve(answer.toLowerCase().startsWith("y"));
+      }
+    });
+  });
+}
+async function showConstitution() {
+  const cwd = process.cwd();
+  const constitutionPath = getConstitutionPath(cwd);
+  const draftPath = getDraftPath(cwd);
+  if (existsSync14(constitutionPath)) {
+    const constitution = deserializeConstitution(readFileSync3(constitutionPath, "utf-8"));
+    console.log(summarizeConstitution(constitution));
+  } else if (existsSync14(draftPath)) {
+    const draft = deserializeConstitution(readFileSync3(draftPath, "utf-8"));
+    console.log(chalk14.yellow("[DRAFT]"));
+    console.log(summarizeConstitution(draft));
+  } else {
+    console.log(chalk14.dim("No Constitution found. Run `archon interview` to create one."));
+  }
+}
+async function validateConstitutionCommand() {
+  const cwd = process.cwd();
+  const constitutionPath = getConstitutionPath(cwd);
+  const draftPath = getDraftPath(cwd);
+  const path2 = existsSync14(constitutionPath) ? constitutionPath : draftPath;
+  if (!existsSync14(path2)) {
+    console.log(chalk14.dim("No Constitution found. Run `archon interview` to create one."));
+    return;
+  }
+  const constitution = deserializeConstitution(readFileSync3(path2, "utf-8"));
+  const result = validateConstitution(constitution);
+  if (result.valid) {
+    console.log(chalk14.green("\u2713 Constitution is valid"));
+  } else {
+    console.log(chalk14.red("\u2717 Constitution has errors:"));
+    for (const error of result.errors) {
+      console.log(chalk14.red(`  \u2022 ${error}`));
+    }
+  }
+  if (result.warnings.length > 0) {
+    console.log(chalk14.yellow("\nWarnings:"));
+    for (const warning of result.warnings) {
+      console.log(chalk14.yellow(`  \u2022 ${warning}`));
+    }
+  }
+}
+async function exportConstitution(format) {
+  const cwd = process.cwd();
+  const constitutionPath = getConstitutionPath(cwd);
+  if (!existsSync14(constitutionPath)) {
+    console.log(chalk14.dim("No frozen Constitution found."));
+    return;
+  }
+  const constitution = deserializeConstitution(readFileSync3(constitutionPath, "utf-8"));
+  switch (format.toLowerCase()) {
+    case "json":
+      console.log(serializeConstitution(constitution));
+      break;
+    case "markdown":
+    case "md":
+      console.log(summarizeConstitution(constitution));
+      break;
+    default:
+      console.log(chalk14.red(`Unknown format: ${format}. Use 'json' or 'markdown'.`));
+  }
+}
+async function generateAtoms(options = {}) {
+  const cwd = process.cwd();
+  const constitutionPath = getConstitutionPath(cwd);
+  if (!existsSync14(constitutionPath)) {
+    console.log(chalk14.red("No frozen Constitution found."));
+    console.log(chalk14.dim("Run `archon interview` to create one first."));
+    return;
+  }
+  const constitution = deserializeConstitution(readFileSync3(constitutionPath, "utf-8"));
+  if (constitution.state !== "FROZEN") {
+    console.log(chalk14.yellow("Constitution is not frozen yet."));
+    console.log(chalk14.dim("Complete the interview and freeze before generating atoms."));
+    return;
+  }
+  console.log(chalk14.bold("\n\u{1F527} Generating Atoms from Constitution\n"));
+  console.log(chalk14.dim(`Project: ${constitution.branding.projectName}`));
+  console.log(chalk14.dim(`Hash: ${constitution.hash?.substring(0, 16)}...`));
+  console.log();
+  const spinner = ora3("Generating atoms...").start();
+  const result = generateAtomsFromConstitution(constitution, {
+    includePostMvp: options.includePostMvp,
+    addSetupAtom: true,
+    addTestingAtom: true
+  });
+  spinner.succeed(`Generated ${result.totalAtoms} atom(s)`);
+  console.log();
+  console.log(summarizeGeneration(result));
+  console.log();
+  if (options.dryRun) {
+    console.log(chalk14.dim("(Dry run - not writing prd.json)"));
+    return;
+  }
+  const prdPath = options.output ?? join14(cwd, "prd.json");
+  const prdContent = formatAsPrdJson(result, constitution);
+  if (existsSync14(prdPath)) {
+    const overwrite = await promptYesNo2("prd.json already exists. Overwrite?", false);
+    if (!overwrite) {
+      console.log(chalk14.dim("Cancelled. Existing prd.json preserved."));
+      return;
+    }
+  }
+  writeFileSync(prdPath, JSON.stringify(prdContent, null, 2));
+  console.log(chalk14.green(`
+\u2713 Written to ${prdPath}`));
+  console.log();
+  console.log(chalk14.bold("Next Steps:\n"));
+  console.log(`  ${chalk14.cyan("1.")} Run ${chalk14.bold("archon list")} to see all atoms`);
+  console.log(`  ${chalk14.cyan("2.")} Run ${chalk14.bold("archon execute ATOM-001")} to start building`);
+  console.log(`  ${chalk14.cyan("3.")} Run ${chalk14.bold("archon watch")} to monitor progress`);
+  console.log();
+}
+
 // src/cli/index.ts
 var program = new Command4();
 program.name("archon").description("Local-first AI-powered development governance").version("1.1.0").action(async () => {
   const cwd = process.cwd();
   const wasInitialized = isInitialized(cwd);
   if (!wasInitialized) {
-    console.log(chalk14.blue("\nArchonDev is not initialized in this folder.\n"));
+    console.log(chalk15.blue("\nArchonDev is not initialized in this folder.\n"));
     await init({ analyze: true, git: true });
   }
   await start({ skipGovernanceBanner: !wasInitialized });
@@ -4763,7 +6903,7 @@ program.name("archon").description("Local-first AI-powered development governanc
 program.command("login").description("Authenticate with ArchonDev").option("-p, --provider <provider>", "OAuth provider (github or google)", "github").action(async (options) => {
   const provider = options.provider;
   if (provider !== "github" && provider !== "google") {
-    console.error(chalk14.red('Invalid provider. Use "github" or "google"'));
+    console.error(chalk15.red('Invalid provider. Use "github" or "google"'));
     process.exit(1);
   }
   await login(provider);
@@ -4948,10 +7088,29 @@ cleanupCmd.command("check").description("Analyze workspace for bloat and mainten
 cleanupCmd.command("run").description("Execute cleanup (archive old entries, remove stale files)").action(cleanupRun);
 cleanupCmd.command("auto").description("Enable/disable automatic cleanup checks").argument("[action]", "enable, disable, or status", "status").action(async (action) => {
   if (action !== "enable" && action !== "disable" && action !== "status") {
-    console.error(chalk14.red("Invalid action. Use: enable, disable, or status"));
+    console.error(chalk15.red("Invalid action. Use: enable, disable, or status"));
     process.exit(1);
   }
   await cleanupAuto(action);
 });
 cleanupCmd.action(cleanupCheck);
+var interviewCmd = program.command("interview").description("5-phase structured interview to define your project");
+interviewCmd.command("start").description("Start or resume the project interview").option("-p, --phase <number>", "Start at a specific phase (1-5)").option("--dry-run", "Generate Constitution without freezing").action(async (options) => {
+  await interview({
+    phase: options.phase ? parseInt(options.phase, 10) : void 0,
+    dryRun: options.dryRun
+  });
+});
+interviewCmd.command("show").description("Show current Constitution").action(showConstitution);
+interviewCmd.command("validate").description("Validate current Constitution").action(validateConstitutionCommand);
+interviewCmd.command("export").description("Export Constitution to different formats").argument("<format>", "Output format (json or markdown)").action(exportConstitution);
+interviewCmd.command("generate").description("Generate atoms (prd.json) from frozen Constitution").option("--include-post-mvp", "Include POST_MVP features").option("--dry-run", "Show what would be generated without writing files").option("-o, --output <path>", "Output path for prd.json").action(async (options) => {
+  await generateAtoms(options);
+});
+interviewCmd.action(async () => {
+  await interview();
+});
+program.command("generate").description("Generate atoms from Constitution (alias for interview generate)").option("--include-post-mvp", "Include POST_MVP features").option("--dry-run", "Show what would be generated without writing files").option("-o, --output <path>", "Output path for prd.json").action(async (options) => {
+  await generateAtoms(options);
+});
 program.parse();