forgecraft 1.4.0 → 2.0.0

package/dist/chunk-NYOV5D5J.js

@@ -1,3129 +0,0 @@
-// src/core/adapters/nextjs.ts
-var nextjsAdapter = {
-  id: "nextjs",
-  name: "Next.js",
-  language: "typescript",
-  scaffoldCommands: [
-    "npx create-next-app@latest . --typescript --tailwind --eslint --app --src-dir --import-alias '@/*' --use-npm --no-turbopack"
-  ],
-  buildCommand: "npm run build",
-  lintCommand: "npm run lint",
-  typecheckCommand: "npx tsc --noEmit",
-  devCommand: "npm run dev",
-  devPort: 3e3,
-  designSupport: true,
-  packageManager: "npm",
-  requiredFiles: ["package.json", "tsconfig.json", "next.config.ts", "tailwind.config.ts"],
-  buildPromptAdditions: `
-FOR NEXT.JS:
-- Use App Router (not Pages Router)
-- Server Components by default \u2014 only use "use client" when genuinely needed
-- Server Actions for mutations
-- Proper metadata and SEO in layout.tsx
-- Dynamic imports for heavy components
-- Use next/image for all images with width, height, alt
-- Use next/link for all internal navigation
-- Use next/font for custom fonts (no Google Fonts CDN)
-
-ASSETS & SEO (REQUIRED):
-- Create favicon.ico, icon.svg, and apple-touch-icon.png in public/
-- Create og.png (1200x630 placeholder) for Open Graph sharing
-- Add complete metadata in layout.tsx: title, description, Open Graph tags, Twitter cards
-- Create robots.txt, sitemap.xml, and manifest.json in public/
-- Ensure every page has a unique <title> and meta description
-`.trim(),
-  designPromptAdditions: `
-NEXT.JS DESIGN:
-- Components use shadcn/ui + Tailwind CSS
-- Use CSF3 format for Storybook stories
-- Include viewport decorators for mobile (375px) and desktop (1440px)
-`.trim(),
-  fileStructure: `
-src/
-\u251C\u2500\u2500 app/
-\u2502   \u251C\u2500\u2500 layout.tsx          # Root layout with metadata
-\u2502   \u251C\u2500\u2500 page.tsx             # Home page
-\u2502   \u251C\u2500\u2500 globals.css          # Global styles + Tailwind
-\u2502   \u2514\u2500\u2500 [route]/
-\u2502       \u2514\u2500\u2500 page.tsx         # Route pages
-\u251C\u2500\u2500 components/
-\u2502   \u251C\u2500\u2500 ui/                  # shadcn/ui components
-\u2502   \u2514\u2500\u2500 [feature]/           # Feature-specific components
-\u251C\u2500\u2500 lib/
-\u2502   \u2514\u2500\u2500 utils.ts             # Shared utilities
-\u2514\u2500\u2500 types/
-    \u2514\u2500\u2500 index.ts             # TypeScript types
-public/
-\u251C\u2500\u2500 favicon.ico
-\u251C\u2500\u2500 og.png
-\u251C\u2500\u2500 robots.txt
-\u2514\u2500\u2500 sitemap.xml
-`.trim()
-};
-
-// src/core/adapters/react-vite.ts
-var reactViteAdapter = {
-  id: "react",
-  name: "React + Vite",
-  language: "typescript",
-  scaffoldCommands: [
-    "npm create vite@latest . -- --template react-ts",
-    "npm install",
-    "npm install -D tailwindcss @tailwindcss/vite",
-    "npm install react-router-dom"
-  ],
-  buildCommand: "npm run build",
-  lintCommand: "npm run lint",
-  typecheckCommand: "npx tsc --noEmit",
-  devCommand: "npm run dev",
-  devPort: 5173,
-  designSupport: true,
-  packageManager: "npm",
-  requiredFiles: ["package.json", "tsconfig.json", "vite.config.ts", "index.html"],
-  buildPromptAdditions: `
-FOR REACT + VITE:
-- Use React Router v6 with createBrowserRouter for routing
-- Functional components only \u2014 no class components
-- Use TypeScript strict mode throughout
-- Tailwind CSS for styling (configured via @tailwindcss/vite plugin)
-- Use React.lazy() and Suspense for code splitting
-- State management: React context + useReducer for simple state, or Zustand if complex
-- No SSR \u2014 this is a client-side SPA
-- Put entry point in src/main.tsx, root component in src/App.tsx
-- Environment variables: import.meta.env.VITE_* prefix
-
-VITE CONFIG:
-- Configure in vite.config.ts
-- Add @tailwindcss/vite plugin
-- Set resolve aliases: "@/" -> "./src/"
-
-ASSETS & SEO:
-- favicon.ico and icon.svg in public/
-- og.png (1200x630) in public/
-- Update index.html with proper <title>, meta description, og tags
-- robots.txt in public/
-`.trim(),
-  designPromptAdditions: `
-REACT + VITE DESIGN:
-- Components use Tailwind CSS utility classes
-- Use CSF3 format for Storybook stories
-- No Next.js-specific features (no next/image, next/link, etc.)
-- Use standard <img>, <a> tags or react-router <Link>
-`.trim(),
-  fileStructure: `
-src/
-\u251C\u2500\u2500 main.tsx                 # Entry point
-\u251C\u2500\u2500 App.tsx                  # Root component with router
-\u251C\u2500\u2500 index.css                # Global styles + Tailwind
-\u251C\u2500\u2500 components/
-\u2502   \u251C\u2500\u2500 ui/                  # Reusable UI components
-\u2502   \u2514\u2500\u2500 [feature]/           # Feature-specific components
-\u251C\u2500\u2500 pages/
-\u2502   \u2514\u2500\u2500 [PageName].tsx       # Route pages
-\u251C\u2500\u2500 hooks/
-\u2502   \u2514\u2500\u2500 use[Hook].ts         # Custom hooks
-\u251C\u2500\u2500 lib/
-\u2502   \u2514\u2500\u2500 utils.ts             # Shared utilities
-\u2514\u2500\u2500 types/
-    \u2514\u2500\u2500 index.ts             # TypeScript types
-public/
-\u251C\u2500\u2500 favicon.ico
-\u251C\u2500\u2500 og.png
-\u2514\u2500\u2500 robots.txt
-`.trim()
-};
-
-// src/core/adapters/django.ts
-var isWin = process.platform === "win32";
-var venvBin = isWin ? "venv\\Scripts" : "venv/bin";
-var python = isWin ? "python" : "python3";
-var venvPython = isWin ? `${venvBin}\\python` : `${venvBin}/python`;
-var venvPip = isWin ? `${venvBin}\\pip` : `${venvBin}/pip`;
-var venvDjangoAdmin = isWin ? `${venvBin}\\django-admin` : `${venvBin}/django-admin`;
-var djangoAdapter = {
-  id: "django",
-  name: "Django",
-  language: "python",
-  scaffoldCommands: [
-    `${python} -m venv venv`,
-    `${venvPip} install django djangorestframework django-cors-headers python-dotenv`,
-    `${venvDjangoAdmin} startproject config .`,
-    `${venvPython} manage.py startapp core`
-  ],
-  buildCommand: `${venvPython} manage.py check --deploy`,
-  lintCommand: `${venvPython} -m py_compile manage.py`,
-  typecheckCommand: isWin ? "echo Type checking skipped (Python)" : "echo 'Type checking skipped (Python)'",
-  devCommand: `${venvPython} manage.py runserver`,
-  devPort: 8e3,
-  designSupport: false,
-  packageManager: "pip",
-  requiredFiles: ["manage.py", "config/settings.py", "config/urls.py", "requirements.txt"],
-  buildPromptAdditions: `
-FOR DJANGO:
-- Use Django 5.x with Django REST Framework for APIs
-- Class-Based Views for CRUD, function-based views for custom logic
-- Use Django models with proper field types, validators, and Meta classes
-- Migrations: always run makemigrations + migrate after model changes
-- URL patterns in config/urls.py, app-level urls in each app's urls.py
-- Use Django templates (Jinja-style) for server-rendered pages
-- Static files in static/, templates in templates/
-- Settings: use python-dotenv for environment variables
-- Always create a superuser: python manage.py createsuperuser --noinput
-  (set DJANGO_SUPERUSER_USERNAME, DJANGO_SUPERUSER_PASSWORD, DJANGO_SUPERUSER_EMAIL)
-- Register models in admin.py for Django Admin access
-- Use django-cors-headers for API CORS configuration
-
-PLATFORM NOTE:
-- On Windows, use venv\\Scripts\\python instead of venv/bin/python
-- On Unix/macOS, use venv/bin/python
-- Detect the platform and use the correct path
-
-SECURITY:
-- CSRF protection enabled by default \u2014 don't disable it
-- Use Django's built-in auth system (User model, login/logout views)
-- Set DEBUG=False in production settings
-- Configure ALLOWED_HOSTS properly
-
-AFTER WRITING CODE:
-1. Run: ${venvPython} manage.py makemigrations
-2. Run: ${venvPython} manage.py migrate
-3. Run: ${venvPython} manage.py check --deploy
-4. Fix any warnings or errors before proceeding
-
-ALWAYS generate a requirements.txt with: ${venvPip} freeze > requirements.txt
-`.trim(),
-  designPromptAdditions: `
-DJANGO DESIGN:
-- No Storybook \u2014 Django uses server-rendered templates
-- Design phase is skipped for Django projects
-- Focus on clean, functional UI with Django templates + CSS
-`.trim(),
-  fileStructure: `
-config/
-\u251C\u2500\u2500 __init__.py
-\u251C\u2500\u2500 settings.py              # Django settings
-\u251C\u2500\u2500 urls.py                  # Root URL configuration
-\u251C\u2500\u2500 wsgi.py                  # WSGI entry point
-\u2514\u2500\u2500 asgi.py                  # ASGI entry point
-core/
-\u251C\u2500\u2500 __init__.py
-\u251C\u2500\u2500 admin.py                 # Admin registrations
-\u251C\u2500\u2500 apps.py                  # App config
-\u251C\u2500\u2500 models.py                # Database models
-\u251C\u2500\u2500 views.py                 # Views (CBV/FBV)
-\u251C\u2500\u2500 urls.py                  # App URL patterns
-\u251C\u2500\u2500 serializers.py           # DRF serializers
-\u251C\u2500\u2500 forms.py                 # Django forms
-\u251C\u2500\u2500 tests.py                 # Tests
-\u251C\u2500\u2500 migrations/
-\u2502   \u2514\u2500\u2500 __init__.py
-\u2514\u2500\u2500 templates/
-    \u2514\u2500\u2500 core/                # App templates
-static/
-\u251C\u2500\u2500 css/
-\u251C\u2500\u2500 js/
-\u2514\u2500\u2500 images/
-templates/
-\u2514\u2500\u2500 base.html                # Base template
-manage.py                    # Django CLI
-requirements.txt             # Python dependencies
-.env                         # Environment variables
-`.trim()
-};
-
-// src/core/adapters/generic.ts
-var genericAdapter = {
-  id: "generic",
-  name: "Custom Stack",
-  language: "typescript",
-  // default, but prompts tell the agent to auto-detect
-  scaffoldCommands: [],
-  buildCommand: "AUTO_DETECT",
-  lintCommand: "AUTO_DETECT",
-  typecheckCommand: "AUTO_DETECT",
-  devCommand: "npm run dev",
-  devPort: 3e3,
-  designSupport: false,
-  packageManager: "npm",
-  requiredFiles: [],
-  buildPromptAdditions: `
-CUSTOM TECH STACK \u2014 IMPORTANT:
-This project uses a tech stack chosen by the user. You MUST auto-detect everything.
-
-STEP 1 \u2014 DETECT THE STACK:
-Before writing ANY code, read these files (whichever exist):
-- package.json (Node.js/JS/TS projects)
-- requirements.txt / pyproject.toml / Pipfile (Python projects)
-- go.mod (Go projects)
-- Cargo.toml (Rust projects)
-- pom.xml / build.gradle (Java/Kotlin projects)
-- pubspec.yaml (Flutter/Dart projects)
-- Gemfile (Ruby projects)
-- composer.json (PHP projects)
-- Any existing source files to understand patterns
-
-STEP 2 \u2014 FOLLOW EXISTING CONVENTIONS:
-- If the project already has code, match its style exactly (naming, file structure, patterns)
-- If starting from scratch, use the standard project structure for the detected tech stack
-- Use the package manager the project already uses (npm, yarn, pnpm, pip, poetry, cargo, go, etc.)
-
-STEP 3 \u2014 BUILD VERIFICATION:
-- Detect the correct build/lint/test commands from the project config
-- For Node.js: check package.json "scripts" for build, lint, typecheck commands
-- For Python: use pytest, flake8/ruff, mypy if configured
-- For Go: use go build, go vet, go test
-- For Rust: use cargo build, cargo clippy, cargo test
-- If no build script exists, skip the build step \u2014 do NOT fail
-- If a command does not exist or is not configured, skip it gracefully
-
-STEP 4 \u2014 SCAFFOLDING:
-- If the project directory is empty, scaffold the project using the standard tooling for the stack
-  (e.g., npm init, cargo init, go mod init, django-admin startproject, etc.)
-- Install dependencies after scaffolding
-`.trim(),
-  designPromptAdditions: "",
-  fileStructure: `
-(auto-detected \u2014 read the project's existing files to determine structure)
-`.trim()
-};
-
-// src/core/adapters/index.ts
-var adapters = {
-  nextjs: nextjsAdapter,
-  react: reactViteAdapter,
-  django: djangoAdapter,
-  generic: genericAdapter
-};
-function getAdapter(framework) {
-  const adapter = adapters[framework];
-  if (!adapter) {
-    throw new Error(
-      `Unknown framework "${framework}". Supported: ${Object.keys(adapters).join(", ")}`
-    );
-  }
-  return adapter;
-}
-function listAdapters() {
-  return Object.values(adapters);
-}
-
-// src/core/utils/sound.ts
-import { exec } from "child_process";
-import { platform } from "os";
-function playSound() {
-  if (!process.stdout.isTTY) return;
-  try {
-    switch (platform()) {
-      case "darwin":
-        exec("afplay /System/Library/Sounds/Blow.aiff", () => {
-        });
-        break;
-      case "win32":
-        exec(
-          'powershell -NoProfile -NonInteractive -Command "[System.Media.SystemSounds]::Exclamation.Play()"',
-          { shell: "cmd.exe" },
-          () => {
-          }
-        );
-        break;
-      case "linux":
-        exec(
-          "paplay /usr/share/sounds/freedesktop/stereo/complete.oga",
-          (err) => {
-            if (err) process.stdout.write("\x07");
-          }
-        );
-        break;
-      default:
-        process.stdout.write("\x07");
-    }
-  } catch {
-  }
-}
-
-// src/core/orchestrator/index.ts
-import { query } from "@anthropic-ai/claude-agent-sdk";
-import chalk from "chalk";
-
-// src/core/orchestrator/prompts.ts
-var ORCHESTRATOR_SYSTEM_PROMPT = `
-You are the Orchestrator \u2014 a senior tech lead managing an AI development sprint for the "Forge" framework.
-
-YOUR ROLE:
-You NEVER write code. You plan, delegate, and review. You are the brain of the operation.
-
-RESPONSIBILITIES:
-1. Break user requirements into epics and stories
-2. Craft detailed, specific prompts for the Worker agent
-3. Route user feedback to the correct Worker mode
-4. Review Worker output and decide next steps
-5. Maintain project context and sprint state
-
-WHEN CREATING STORIES:
-- Each story must be independently buildable
-- UI stories need design phase; backend-only stories skip it
-- Order stories by dependency (foundation/setup first, then data layer, then UI, then integration)
-- Each story should result in working, testable code
-- Story IDs should be kebab-case: "auth-login", "dashboard-layout"
-- First story should always be project setup/scaffolding
-
-WHEN CRAFTING WORKER PROMPTS:
-- Include EXACT file paths to create or modify
-- Reference approved designs when available
-- Specify the framework patterns to follow (App Router, Server Components, etc.)
-- Include acceptance criteria \u2014 what "done" looks like
-- Never be vague \u2014 the Worker should not have to guess anything
-- Include the full project context the Worker needs (but not more)
-
-WHEN ROUTING USER FEEDBACK:
-- Visual tweak (color, spacing, font, border) \u2192 Worker fix mode, direct code change
-- Layout/UX redesign (page structure, navigation, flow) \u2192 Worker design mode first, then build
-- Bug fix (something broken, error, crash) \u2192 Worker fix mode with debug focus
-- New feature (something that doesn't exist yet) \u2192 Create new story, full pipeline
-- Content change (text, labels, copy) \u2192 Worker fix mode, string replacement
-- Question about the project \u2192 Answer directly, don't route
-- If Worker is currently busy \u2192 Queue the change for after current task
-
-WHEN REVIEWING WORKER OUTPUT:
-- Does the output match what was requested?
-- Did the Worker run build/lint/typecheck?
-- Are there any obvious issues?
-- Minor issues: send back to Worker fix mode
-- Major issues: send back to Worker build mode with specific instructions
-
-OUTPUT FORMAT:
-Always respond with valid JSON when asked for structured data.
-When answering questions, respond in plain text.
-Never include markdown code fences around JSON output.
-
-DESIGN QUALITY STANDARDS:
-When the Worker is in design mode, ensure designs reference real products:
-- Finance/Banking \u2192 Stripe, Mercury, Wise
-- Dashboard/Admin \u2192 Linear, Vercel, Raycast
-- E-commerce \u2192 Shopify Admin, Gumroad
-- Social/Community \u2192 Discord, Slack
-- Content/Blog \u2192 Medium, Ghost, Substack
-- SaaS/Productivity \u2192 Notion, Figma
-- Healthcare/Church/Nonprofit \u2192 warm, trustworthy, accessible
-
-NEVER accept generic AI-looking designs (purple gradients, Inter font, rounded white cards on gray).
-`.trim();
-var ROUTING_CLASSIFICATION_PROMPT = `
-Classify the user's message into one of these categories:
-
-1. VISUAL_TWEAK \u2014 Small CSS/styling change
-   Examples: "make it blue", "bigger font", "add shadow", "more padding"
-   
-2. REDESIGN \u2014 Significant layout or UX change
-   Examples: "redesign the dashboard", "switch to sidebar nav", "make it look like Stripe"
-   
-3. BUG_FIX \u2014 Something is broken or not working
-   Examples: "button doesn't work", "page is blank", "getting an error"
-   
-4. NEW_FEATURE \u2014 Something that doesn't exist yet
-   Examples: "add dark mode", "add recurring donations", "add export to PDF"
-   
-5. CONTENT_CHANGE \u2014 Text, labels, or copy changes
-   Examples: "change 'Submit' to 'Send'", "update the footer text"
-   
-6. QUESTION \u2014 Asking for information
-   Examples: "what stack are we using?", "how many stories left?", "show me the schema"
-   
-7. PRIORITY_CHANGE \u2014 Wants to reorder or skip stories
-   Examples: "do reports next", "skip the settings page for now"
-
-Respond with ONLY the category name and a brief routing instruction.
-`.trim();
-
-// src/core/orchestrator/index.ts
-var Orchestrator = class {
-  config;
-  plan = null;
-  constructor(config) {
-    this.config = config;
-  }
-  // ── Plan Generation ───────────────────────────────────────
-  async generatePlan(description) {
-    const adapter = getAdapter(this.config.framework);
-    const isGeneric = adapter.id === "generic";
-    const frameworkHint = isGeneric ? `Tech stack: Detect from the user's description below. The user may specify their own framework, language, and tools.` : `Framework: ${adapter.name} (${this.config.framework})
-      Language: ${adapter.language}`;
-    const prompt = `
-      The user wants to build the following application:
-      "${description}"
-
-      ${frameworkHint}
-      Design support: ${adapter.designSupport ? "yes (Storybook)" : "no"}
-
-      IMPORTANT: If the user references any files (like .md, .txt, .pdf, or any document),
-      READ those files first to understand the full requirements before planning.
-      Also read any existing project files (package.json, requirements.txt, etc.) to understand the current state.
-
-      Break this down into epics and stories. Each story should be:
-      - Small enough to build in one agent session
-      - Independently testable
-      - Ordered by dependency (foundation first)
-
-      Story types:
-      - "ui" = has a visual component ${adapter.designSupport ? "(needs design phase)" : "(no design phase for this framework)"}
-      - "backend" = API/database only (skip design phase)
-      - "fullstack" = both UI and backend
-
-      Return ONLY valid JSON with this structure:
-      {
-        "project": "project name",
-        "framework": "${this.config.framework}",
-        "description": "brief description",
-        "epics": [
-          {
-            "id": "epic-id",
-            "title": "Epic Title",
-            "stories": [
-              {
-                "id": "story-id",
-                "title": "Story Title",
-                "description": "What to build",
-                "type": "ui" | "backend" | "fullstack",
-                "priority": 1,
-                "dependencies": ["other-story-id"]
-              }
-            ]
-          }
-        ]
-      }
-
-      CRITICAL: Return ONLY the raw JSON object. No explanation, no markdown, no text before or after.
-      Your entire response must be a single valid JSON object starting with { and ending with }.
-    `;
-    const resultText = await this.runQuery(prompt, { maxTurns: 10 });
-    let rawPlan;
-    try {
-      rawPlan = JSON.parse(this.cleanJson(resultText));
-    } catch {
-      const preview = resultText.slice(0, 200).replace(/\n/g, " ");
-      throw new Error(
-        `Failed to parse plan \u2014 Claude returned text instead of JSON.
-  Preview: "${preview}${resultText.length > 200 ? "..." : ""}"
-  Try a more specific description, e.g.: forge auto "build a todo app with React and Express"`
-      );
-    }
-    if (!rawPlan.epics || !Array.isArray(rawPlan.epics)) {
-      throw new Error("Invalid plan: missing epics array. Try regenerating.");
-    }
-    const plan = {
-      project: rawPlan.project || "Untitled",
-      framework: rawPlan.framework || this.config.framework,
-      description: rawPlan.description || description,
-      created: (/* @__PURE__ */ new Date()).toISOString(),
-      epics: rawPlan.epics.map((epic) => ({
-        id: epic.id || `epic-${Date.now()}`,
-        title: epic.title || "Untitled Epic",
-        status: "planned",
-        stories: (epic.stories || []).map((story) => ({
-          id: story.id || `story-${Date.now()}`,
-          title: story.title || "Untitled Story",
-          description: story.description || "",
-          type: story.type || "fullstack",
-          status: "planned",
-          branch: null,
-          designApproved: false,
-          tags: [],
-          priority: story.priority || 1,
-          dependencies: story.dependencies || []
-        }))
-      }))
-    };
-    this.plan = plan;
-    return plan;
-  }
-  // ── User Input Routing ────────────────────────────────────
-  async routeUserInput(message, currentState) {
-    const routingPrompt = `
-      Current sprint state:
-      - Phase: ${currentState.currentPhase}
-      - Current story: ${currentState.currentStory || "none"}
-      - Worker mode: ${currentState.workerMode || "idle"}
-      - Framework: ${this.config.framework}
-
-      The user said: "${message}"
-
-      Classify this input and decide what to do.
-      Return ONLY valid JSON with this structure:
-      {
-        "action": "route-to-worker" | "add-story" | "reprioritize" | "answer" | "queue-change",
-        "workerMode": "design" | "build" | "review" | "fix" (if routing to worker),
-        "response": "your response to the user" (if answering directly),
-        "prompt": "detailed prompt for the worker" (if routing to worker),
-        "story": { "title": "...", "description": "...", "type": "..." } (if adding a new story)
-      }
-
-      Routing rules:
-      - Visual tweak (color, spacing, font) \u2192 route-to-worker, mode: fix
-      - Layout/UX redesign \u2192 route-to-worker, mode: design
-      - Bug fix \u2192 route-to-worker, mode: fix
-      - New feature \u2192 add-story (include title, description, type)
-      - Content change (text, labels) \u2192 route-to-worker, mode: fix
-      - Question \u2192 answer directly
-      - If worker is currently active \u2192 queue-change (apply after current task)
-    `;
-    const resultText = await this.runQuery(routingPrompt, { maxTurns: 1 });
-    try {
-      return JSON.parse(this.cleanJson(resultText));
-    } catch {
-      return { action: "answer", response: resultText };
-    }
-  }
-  // ── Prompt Crafting ───────────────────────────────────────
-  craftWorkerPrompt(story, mode, context) {
-    const adapter = getAdapter(this.config.framework);
-    switch (mode) {
-      case "design":
-        return this.craftDesignPrompt(story, context, adapter);
-      case "build":
-        return this.craftBuildPrompt(story, context, adapter);
-      case "review":
-        return this.craftReviewPrompt(story, context, adapter);
-      case "fix":
-        return this.craftFixPrompt(story, context, adapter);
-    }
-  }
-  craftDesignPrompt(story, context, adapter) {
-    const refsDir = ".forge/designs/references";
-    return `
-      You are designing the UI for: "${story.title}"
-
-      Description: ${story.description}
-      App: ${context.plan.project} (${adapter.name})
-      Full app context: ${context.plan.description}
-
-      DESIGN REFERENCES:
-      Check if ${refsDir}/ exists and contains reference images.
-      If so, read them and match their visual style, color palette, typography, and layout.
-
-      Create a Storybook story file that renders this component/page.
-      The file should be at: stories/${story.id}.stories.tsx
-
-      Requirements:
-      - Must be responsive (mobile-first: 375px, then 768px, then 1440px)
-      - Use Tailwind CSS for styling
-      - Include realistic placeholder data (not lorem ipsum)
-      - Show default, loading, empty, and error states as separate stories
-      - Use a distinctive, professional design (not generic AI aesthetics)
-      - Choose fonts and colors that match the app's purpose
-
-      DO NOT write the actual app code. Only the Storybook preview.
-    `;
-  }
-  craftBuildPrompt(story, context, adapter) {
-    const isGeneric = adapter.id === "generic";
-    const designRef = context.designMeta ? `
-Approved design: Follow the design in stories/${story.id}.stories.tsx exactly.` : "";
-    const existingRef = context.existingFiles?.length ? `
-Existing files to reference for patterns:
-${context.existingFiles.map((f) => `  - ${f}`).join("\n")}` : "";
-    const verifySteps = isGeneric ? `
-      After writing code:
-      1. Detect the project's build/lint/typecheck commands from its config files (package.json scripts, Makefile, pyproject.toml, etc.)
-      2. Run whichever commands exist \u2014 skip any that aren't configured
-      3. Fix any errors before finishing
-      ` : `
-      After writing code:
-      1. Run: ${adapter.buildCommand} (fix any errors)
-      2. Run: ${adapter.lintCommand} (fix any warnings)
-      3. Run: ${adapter.typecheckCommand} (fix any type errors)
-      `;
-    const structureRef = isGeneric ? `
-      Project structure:
-      Read the existing project files to understand the structure.
-      If starting from scratch, use the standard conventions for this tech stack.
-      ` : `
-      Expected project structure:
-      ${adapter.fileStructure}
-      `;
-    return `
-      Implement: "${story.title}"
-
-      Description: ${story.description}
-      App: ${context.plan.project} (${adapter.name})
-      ${designRef}
-      ${existingRef}
-
-      ${structureRef}
-
-      Technical requirements:
-      - Follow existing code patterns in the project
-      - Small, focused components/functions
-      - Proper error handling
-      - Responsive design (mobile-first)
-
-      ${verifySteps}
-
-      If any command fails, read the error, fix it, and re-run.
-      Do NOT leave broken code.
-    `;
-  }
-  craftReviewPrompt(story, context, adapter) {
-    const isGeneric = adapter.id === "generic";
-    const runCmds = isGeneric ? `Run the project's build/lint/test commands (detect from config files). Skip any that aren't configured.` : `Run:
-      - ${adapter.buildCommand}
-      - ${adapter.lintCommand}
-      - ${adapter.typecheckCommand}`;
-    return `
-      Review the code for: "${story.title}"
-
-      Framework: ${adapter.name}
-
-      Check:
-      1. Does the implementation match the story description?
-      ${context.designMeta ? "2. Does it match the approved design?" : ""}
-      3. Code quality \u2014 no shortcuts, proper types
-      4. Responsive design \u2014 works on mobile and desktop
-      5. Error handling \u2014 graceful failures, loading states
-      6. Accessibility \u2014 semantic HTML, ARIA labels
-      7. No debug logs, no commented-out code, no TODOs
-
-      ${runCmds}
-
-      If you find issues:
-      - Minor (formatting, missing type): fix them directly
-      - Major (broken logic, missing feature): list them and do NOT fix
-
-      Return a summary of what you found and what you fixed.
-    `;
-  }
-  craftFixPrompt(story, context, adapter) {
-    const isGeneric = adapter.id === "generic";
-    const verifyCmds = isGeneric ? "After fixing, run the project's build/test commands to verify (detect from config files)." : `After fixing, run ${adapter.buildCommand} and ${adapter.typecheckCommand} to verify.`;
-    return `
-      Fix an issue in: "${story.title}"
-      Framework: ${adapter.name}
-
-      Make the smallest possible change. Do not refactor.
-      ${verifyCmds}
-    `;
-  }
-  // ── SDK Query Helper ──────────────────────────────────────
-  async runQuery(prompt, opts = {}) {
-    const maxRetries = 3;
-    for (let attempt = 1; attempt <= maxRetries; attempt++) {
-      try {
-        return await this.executeQuery(prompt, opts);
-      } catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        if (this.isAuthError(msg) && attempt < maxRetries) {
-          playSound();
-          console.log(chalk.yellow("\n  Authentication expired"));
-          console.log(chalk.dim("  Run: claude login"));
-          console.log(chalk.dim(`  Retrying in 30s (attempt ${attempt}/${maxRetries})...
-`));
-          await new Promise((r) => setTimeout(r, 3e4));
-          continue;
-        }
-        throw error;
-      }
-    }
-    throw new Error("Max retries exceeded");
-  }
-  async executeQuery(prompt, opts = {}) {
-    let resultText = "";
-    try {
-      for await (const msg of query({
-        prompt,
-        options: {
-          model: this.config.model,
-          systemPrompt: ORCHESTRATOR_SYSTEM_PROMPT,
-          maxTurns: opts.maxTurns,
-          allowedTools: ["Read", "Glob", "Grep"]
-        }
-      })) {
-        if (msg.type === "result") {
-          const hasError = "is_error" in msg && msg.is_error;
-          const errors = "errors" in msg && Array.isArray(msg.errors) ? msg.errors : [];
-          const subtype = "subtype" in msg ? String(msg.subtype) : "";
-          if (hasError || errors.length > 0) {
-            const errorParts = [];
-            if (subtype) errorParts.push(subtype);
-            for (const e of errors) {
-              const eStr = typeof e === "string" ? e : JSON.stringify(e);
-              if (eStr && eStr.length > 0) errorParts.push(eStr);
-            }
-            const errorMsg = errorParts.length > 0 ? errorParts.join(" \u2014 ") : "Unknown error from Claude. Check your auth with: claude login";
-            throw new Error(errorMsg);
-          }
-          if ("result" in msg && typeof msg.result === "string") {
-            resultText = msg.result;
-          }
-        }
-        if (msg.type === "assistant" && msg.message?.content) {
-          const textBlocks = msg.message.content.filter((b) => b.type === "text").map((b) => b.text);
-          if (textBlocks.length > 0) {
-            resultText = textBlocks.join("\n");
-          }
-        }
-      }
-    } catch (error) {
-      if (error instanceof Error && !error.message.includes("EPIPE") && !error.message.includes("ENOENT")) {
-        throw error;
-      }
-      const msg = error instanceof Error ? error.message : String(error);
-      throw new Error(
-        `Failed to communicate with Claude. ${msg}
-  Possible fixes:
-  1. Run: claude login
-  2. Check your internet connection
-  3. Run: forge doctor`
-      );
-    }
-    if (!resultText) {
-      throw new Error(
-        "No response from Claude.\n  Possible fixes:\n  1. Run: claude login\n  2. Check your internet connection\n  3. Run: forge doctor"
-      );
-    }
-    return resultText;
-  }
-  isAuthError(msg) {
-    const lower = msg.toLowerCase();
-    return lower.includes("401") || lower.includes("unauthorized") || lower.includes("auth") || lower.includes("token expired") || lower.includes("session expired") || lower.includes("not authenticated");
-  }
-  cleanJson(text) {
-    let cleaned = text.replace(/```json\s*/g, "").replace(/```\s*/g, "").trim();
-    try {
-      JSON.parse(cleaned);
-      return cleaned;
-    } catch {
-    }
-    const firstBrace = cleaned.indexOf("{");
-    const lastBrace = cleaned.lastIndexOf("}");
-    if (firstBrace !== -1 && lastBrace > firstBrace) {
-      const extracted = cleaned.slice(firstBrace, lastBrace + 1);
-      try {
-        JSON.parse(extracted);
-        return extracted;
-      } catch {
-        return extracted;
-      }
-    }
-    return cleaned;
-  }
-};
-
-// src/core/worker/index.ts
-import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
-import chalk2 from "chalk";
-
-// src/core/worker/prompts/index.ts
-function getDesignPrompt(framework) {
-  const adapter = framework ? getAdapter(framework) : null;
-  const additions = adapter?.designPromptAdditions || "";
-  return `
-You are a senior UI/UX designer working within the Forge development framework.
-Your job is to create beautiful, professional component previews as Storybook stories.
-
-DESIGN PRINCIPLES:
-- Mobile-first: design for 375px, then scale up to 768px and 1440px
-- Use the project's design system (shadcn/ui + Tailwind CSS)
-- Choose distinctive typography \u2014 NEVER use Inter, Arial, or Roboto
-- Commit to a cohesive color palette with a dominant color and sharp accents
-- Add micro-interactions (hover states, transitions)
-- Use realistic placeholder data (real names, real numbers, not "Lorem ipsum")
-- Include all states: default, loading, empty, error, success
-
-STORYBOOK OUTPUT FORMAT:
-- Create .stories.tsx files in the stories/ directory
-- Each story file should export a default meta and named story variants
-- Use CSF3 format (Component Story Format)
-- Include args/controls for interactive props
-- Add viewport decorators for mobile/desktop
-
-QUALITY BAR:
-Your designs should look like they came from a professional design agency.
-Reference real, well-designed products:
-- Finance \u2192 Stripe, Mercury, Wise
-- Dashboards \u2192 Linear, Vercel
-- E-commerce \u2192 Shopify, Gumroad
-- Social \u2192 Discord, Slack
-
-NEVER produce:
-- Purple gradient backgrounds
-- Generic rounded white cards on gray
-- Stock-photo placeholder images
-- Inconsistent spacing or alignment
-- Missing hover/focus states
-
-${additions}
-`.trim();
-}
-function getBuildPrompt(framework) {
-  const adapter = framework ? getAdapter(framework) : null;
-  const additions = adapter?.buildPromptAdditions || "";
-  const isGeneric = adapter?.id === "generic";
-  const verifyBlock = isGeneric ? `
-AFTER WRITING CODE:
-1. Detect the project's build/lint/typecheck/test commands from its config files
-   (package.json scripts, Makefile, pyproject.toml, Cargo.toml, etc.)
-2. Run whichever commands exist \u2014 skip any that aren't configured
-3. Fix ALL errors before proceeding
-4. If no build system is configured, verify the code is syntactically valid
-` : `
-AFTER WRITING CODE:
-1. Run: ${adapter?.buildCommand || "npm run build"} \u2014 fix ALL errors before proceeding
-2. Run: ${adapter?.lintCommand || "npm run lint"} \u2014 fix warnings
-3. Run: ${adapter?.typecheckCommand || "npx tsc --noEmit"} \u2014 fix type errors
-`;
-  return `
-You are a senior fullstack developer working within the Forge development framework.
-Your job is to implement features based on approved designs and story requirements.
-
-CODING STANDARDS:
-- Small, focused components and functions (< 100 lines per file)
-- Proper error handling \u2014 try/catch, error boundaries, loading states
-- Responsive design \u2014 mobile-first with Tailwind breakpoints
-- Semantic HTML with accessibility (ARIA labels, keyboard navigation)
-- Clean imports, no circular dependencies
-
-${additions}
-
-${verifyBlock}
-
-If any command fails:
-- Read the full error output
-- Identify the root cause
-- Fix it
-- Re-run the command
-- Repeat until all checks pass
-
-NEVER leave code in a broken state. Every commit must build successfully.
-
-GIT:
-- Make small, atomic changes
-- Write descriptive file names and function names
-`.trim();
-}
-function getReviewPrompt(framework) {
-  const adapter = framework ? getAdapter(framework) : null;
-  const isGeneric = adapter?.id === "generic";
-  const lang = adapter?.language || "typescript";
-  const langCheck = isGeneric ? "3. Code quality \u2014 follows the language's best practices and idioms" : lang === "typescript" ? "3. TypeScript strict compliance (no any, no ts-ignore, no ts-expect-error)" : "3. Python code quality (no bare except, proper type hints where used)";
-  const runBlock = isGeneric ? `
-RUN THESE COMMANDS:
-- Detect build/lint/test commands from the project's config files (package.json, Makefile, pyproject.toml, Cargo.toml, etc.)
-- Run whichever exist \u2014 skip any that aren't configured
-- Run tests if a test runner is configured
-` : `
-RUN THESE COMMANDS:
-- ${adapter?.buildCommand || "npm run build"}
-- ${adapter?.lintCommand || "npm run lint"}
-- ${adapter?.typecheckCommand || "npx tsc --noEmit"}
-- npm run test (if tests exist)
-`;
-  return `
-You are a QA engineer reviewing code within the Forge development framework.
-Your job is to catch issues before code is merged to main.
-
-REVIEW CHECKLIST:
-1. Implementation matches the story description
-2. If design was approved \u2014 implementation matches the design
-${langCheck}
-4. Responsive design works at 375px, 768px, 1440px
-5. Error handling \u2014 what happens when things fail?
-6. Loading states \u2014 what does the user see while waiting?
-7. Empty states \u2014 what if there's no data?
-8. Accessibility \u2014 semantic HTML, focus management, screen reader support
-9. No debug logs (console.log / print() for debugging)
-10. No commented-out code
-11. No TODO/FIXME/HACK comments left behind
-12. No hardcoded values that should be configurable
-
-${runBlock}
-
-ISSUE CLASSIFICATION:
-- MINOR: formatting, missing type annotation, unused import
-  \u2192 Fix it directly, note what you fixed
-- MAJOR: broken logic, missing error handling, security issue, missing feature
-  \u2192 List the issue with file path and line, do NOT attempt to fix
-
-OUTPUT:
-Provide a structured review summary:
-- Files reviewed
-- Issues found (with severity)
-- Issues auto-fixed
-- Commands run and their results
-- PASS or FAIL recommendation
-`.trim();
-}
-function getFixPrompt(framework) {
-  const adapter = framework ? getAdapter(framework) : null;
-  const isGeneric = adapter?.id === "generic";
-  const verifyBlock = isGeneric ? `
-AFTER EVERY FIX:
-1. Detect the project's build/test commands from its config files
-2. Run whichever exist to verify nothing is broken
-3. Verify the fix works
-` : `
-AFTER EVERY FIX:
-1. Run: ${adapter?.buildCommand || "npm run build"}
-2. Run: ${adapter?.typecheckCommand || "npx tsc --noEmit"}
-3. Verify the fix works
-`;
-  return `
-You are a debugger and problem solver within the Forge development framework.
-Your job is to make targeted fixes without breaking anything else.
-
-PRINCIPLES:
-- Make the SMALLEST possible change to fix the issue
-- Do NOT refactor surrounding code \u2014 you're here to fix, not improve
-- Read the existing code carefully before changing anything
-- Understand the full context of what you're changing
-
-FOR VISUAL TWEAKS:
-- Change only the specific CSS/Tailwind classes needed
-- Verify the change doesn't break other viewports
-- Check both mobile and desktop after changing
-
-FOR BUG FIXES:
-- Read error messages and stack traces carefully
-- Trace the issue to its ROOT CAUSE
-- Fix the cause, not the symptom
-- Check if the same bug pattern exists elsewhere
-- Verify the fix by running the relevant command
-
-${verifyBlock}
-
-If your fix introduces new errors, undo it and try a different approach.
-`.trim();
-}
-var DESIGN_SYSTEM_PROMPT = getDesignPrompt();
-var BUILD_SYSTEM_PROMPT = getBuildPrompt();
-var REVIEW_SYSTEM_PROMPT = getReviewPrompt();
-var FIX_SYSTEM_PROMPT = getFixPrompt();
-
-// src/core/worker/index.ts
-var MODE_TOOLS = {
-  design: ["Read", "Write", "Glob", "LS"],
-  build: ["Read", "Write", "Edit", "Bash", "Glob", "LS", "Grep"],
-  review: ["Read", "Bash", "Glob", "LS", "Grep"],
-  fix: ["Read", "Write", "Edit", "Bash", "Glob", "LS", "Grep"]
-};
-function getModePrompt(mode, framework) {
-  switch (mode) {
-    case "design":
-      return getDesignPrompt(framework);
-    case "build":
-      return getBuildPrompt(framework);
-    case "review":
-      return getReviewPrompt(framework);
-    case "fix":
-      return getFixPrompt(framework);
-  }
-}
-var MODE_MAX_TURNS = {
-  design: 30,
-  build: 50,
-  review: 20,
-  fix: 15
-};
-var MAX_AUTH_RETRIES = 3;
-var AUTH_RETRY_DELAY_MS = 3e4;
-var Worker = class {
-  config;
-  sandboxOpts;
-  mute;
-  constructor(config, sandboxOpts = {}, mute = false) {
-    this.config = config;
-    this.sandboxOpts = sandboxOpts;
-    this.mute = mute;
-  }
-  async run(mode, prompt, options = {}) {
-    for (let attempt = 1; attempt <= MAX_AUTH_RETRIES; attempt++) {
-      const result = await this.executeQuery(mode, prompt, options);
-      if (!result.success && this.isAuthError(result.errors)) {
-        if (attempt < MAX_AUTH_RETRIES) {
-          this.notifyAuthError(attempt);
-          await this.waitForReauth();
-          result.errors = result.errors.filter((e) => !this.isAuthErrorMsg(e));
-          continue;
-        }
-        result.errors.push(
-          "Authentication failed after retries. Run: claude login"
-        );
-      }
-      return result;
-    }
-    return {
-      success: false,
-      filesCreated: [],
-      filesModified: [],
-      errors: ["Max retries exceeded"],
-      summary: "",
-      usage: { inputTokens: 0, outputTokens: 0, costUsd: 0, durationMs: 0 }
-    };
-  }
-  async executeQuery(mode, prompt, options = {}) {
-    let workingDir = options.workingDir || this.sandboxOpts.workingDir;
-    if (!workingDir) {
-      try {
-        workingDir = process.cwd();
-      } catch {
-        return {
-          success: false,
-          filesCreated: [],
-          filesModified: [],
-          errors: ["Working directory no longer exists. Please cd to your project and retry."],
-          summary: "",
-          usage: { inputTokens: 0, outputTokens: 0, costUsd: 0, durationMs: 0 }
-        };
-      }
-    }
-    const { onProgress } = options;
-    const result = {
-      success: false,
-      filesCreated: [],
-      filesModified: [],
-      errors: [],
-      summary: "",
-      usage: { inputTokens: 0, outputTokens: 0, costUsd: 0, durationMs: 0 }
-    };
-    const sdkOptions = {
-      model: this.config.model,
-      systemPrompt: getModePrompt(mode, this.config.framework),
-      allowedTools: MODE_TOOLS[mode],
-      cwd: workingDir,
-      maxTurns: MODE_MAX_TURNS[mode]
-    };
-    if (this.sandboxOpts.yes && !this.sandboxOpts.sandbox) {
-      sdkOptions.permissionMode = "bypassPermissions";
-    }
-    if (this.sandboxOpts.sandbox) {
-      sdkOptions.permissionMode = "bypassPermissions";
-      sdkOptions.sandbox = {
-        enabled: true,
-        autoAllowBashIfSandboxed: true,
-        filesystem: {
-          allowWrite: [workingDir]
-        },
-        network: {
-          allowedDomains: this.sandboxOpts.allowedDomains || [
-            "registry.npmjs.org",
-            "api.anthropic.com"
-          ]
-        }
-      };
-    }
-    try {
-      for await (const msg of query2({ prompt, options: sdkOptions })) {
-        if (msg.type === "assistant") {
-          if (msg.message?.usage) {
-            result.usage.inputTokens += msg.message.usage.input_tokens || 0;
-            result.usage.outputTokens += msg.message.usage.output_tokens || 0;
-          }
-          for (const block of msg.message?.content || []) {
-            if (block.type === "text") {
-              onProgress?.({ type: "thinking", content: block.text.slice(0, 120) });
-            }
-            if (block.type === "tool_use") {
-              const detail = this.describeToolUse(block);
-              onProgress?.({ type: "tool_use", content: detail, tool: block.name });
-              if (block.name === "Write" && block.input?.file_path) {
-                result.filesCreated.push(block.input.file_path);
-              }
-              if (block.name === "Edit" && block.input?.file_path) {
-                result.filesModified.push(block.input.file_path);
-              }
-            }
-          }
-        }
-        if (msg.type === "tool_progress") {
-          onProgress?.({
-            type: "tool_running",
-            content: msg.tool_name,
-            tool: msg.tool_name,
-            elapsed: msg.elapsed_time_seconds
-          });
-        }
-        if (msg.type === "tool_use_summary") {
-          onProgress?.({ type: "tool_done", content: msg.summary });
-        }
-        if (msg.type === "result") {
-          if ("result" in msg && typeof msg.result === "string") {
-            result.summary = msg.result;
-          }
-          const hasError = "is_error" in msg && msg.is_error;
-          const errors = "errors" in msg && Array.isArray(msg.errors) ? msg.errors : [];
-          const subtype = "subtype" in msg ? String(msg.subtype || "") : "";
-          if (errors.length > 0) {
-            for (const e of errors) {
-              const eStr = typeof e === "string" ? e : JSON.stringify(e);
-              if (eStr && eStr.length > 0) result.errors.push(eStr);
-            }
-          }
-          if (hasError && result.errors.length === 0) {
-            result.errors.push(
-              subtype || "Claude encountered an error. Run: claude login"
-            );
-          }
-          if (msg.usage) {
-            result.usage.inputTokens = msg.usage.input_tokens || 0;
-            result.usage.outputTokens = msg.usage.output_tokens || 0;
-          }
-          if (typeof msg.total_cost_usd === "number") {
-            result.usage.costUsd = msg.total_cost_usd;
-          }
-          if (typeof msg.duration_ms === "number") {
-            result.usage.durationMs = msg.duration_ms;
-          }
-          if ("is_error" in msg && msg.subtype === "error_max_turns") {
-            result.errors.push(`Hit ${MODE_MAX_TURNS[mode]}-turn safety cap \u2014 story may be incomplete`);
-          }
-        }
-      }
-      result.success = result.errors.length === 0;
-      if (!result.summary) {
-        result.summary = "Completed without summary.";
-      }
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : String(error);
-      result.success = false;
-      result.errors.push(msg);
-    }
-    return result;
-  }
-  // ── Auth Error Detection ──────────────────────────────────
-  isAuthErrorMsg(msg) {
-    const lower = msg.toLowerCase();
-    return lower.includes("401") || lower.includes("unauthorized") || lower.includes("auth") || lower.includes("token expired") || lower.includes("session expired") || lower.includes("not authenticated") || lower.includes("login required") || lower.includes("credential");
-  }
-  isAuthError(errors) {
-    return errors.some((e) => this.isAuthErrorMsg(e));
-  }
-  notifyAuthError(attempt) {
-    if (!this.mute) playSound();
-    console.log("");
-    console.log(chalk2.yellow("  \u26A0 Authentication expired"));
-    console.log(chalk2.dim("  Your Claude session token has expired."));
-    console.log(chalk2.dim("  Please re-authenticate:"));
-    console.log(chalk2.white("    claude login"));
-    console.log(chalk2.dim(`
-  Waiting to retry (attempt ${attempt}/${MAX_AUTH_RETRIES})...`));
-    console.log(chalk2.dim("  Forge will resume automatically once auth is renewed.\n"));
-  }
-  waitForReauth() {
-    return new Promise((resolve) => setTimeout(resolve, AUTH_RETRY_DELAY_MS));
-  }
-  /** Turn a tool_use block into a short human-readable string */
-  describeToolUse(block) {
-    const name = block.name;
-    const input = block.input || {};
-    switch (name) {
-      case "Write":
-        return `Write ${this.shortPath(input.file_path)}`;
-      case "Edit":
-        return `Edit ${this.shortPath(input.file_path)}`;
-      case "Read":
-        return `Read ${this.shortPath(input.file_path)}`;
-      case "Bash":
-        return `Run ${(input.command || "").slice(0, 60)}`;
-      case "Glob":
-        return `Search ${input.pattern || ""}`;
-      case "Grep":
-        return `Grep ${input.pattern || ""}`;
-      default:
-        return name;
-    }
-  }
-  shortPath(p) {
-    if (!p) return "";
-    const parts = p.split(/[/\\]/);
-    return parts.length > 2 ? ".../" + parts.slice(-2).join("/") : p;
-  }
-};
-
-// src/core/git/index.ts
-import simpleGit from "simple-git";
-import fs from "fs/promises";
-import path from "path";
-var GitManager = class {
-  git;
-  basePath;
-  cachedBranch = null;
-  repoVerified = false;
-  constructor(basePath = process.cwd()) {
-    this.basePath = basePath;
-    this.git = simpleGit(basePath);
-  }
-  // ── Branch Operations ─────────────────────────────────────
-  async createBranch(name) {
-    await this.stashDirtyState();
-    const currentBranch = await this.getCurrentBranch();
-    if (currentBranch !== "main") {
-      await this.git.checkout("main");
-    }
-    await this.git.checkoutLocalBranch(name);
-  }
-  async checkout(branch) {
-    await this.stashDirtyState();
-    await this.git.checkout(branch);
-    this.cachedBranch = branch;
-  }
-  async merge(branch) {
-    await this.git.merge([branch, "--no-ff"]);
-  }
-  async deleteBranch(branch) {
-    await this.git.deleteLocalBranch(branch, true);
-  }
-  async getCurrentBranch() {
-    if (this.cachedBranch) return this.cachedBranch;
-    try {
-      const status = await this.git.status();
-      if (status.current) {
-        this.cachedBranch = status.current;
-        return this.cachedBranch;
-      }
-    } catch {
-    }
-    return "main";
-  }
-  async listBranches() {
-    const result = await this.git.branchLocal();
-    return result.all;
-  }
-  // ── Commit Operations ─────────────────────────────────────
-  async commitAll(message) {
-    await this.git.add(".");
-    try {
-      await this.git.commit(message);
-    } catch (err) {
-      if (!err?.message?.includes("nothing to commit")) throw err;
-    }
-  }
-  async commitState(message) {
-    await this.git.add(".forge/");
-    await this.git.add("forge.config.json");
-    const status = await this.git.status();
-    if (status.staged.length > 0) {
-      await this.git.commit(`forge: ${message}`);
-    }
-  }
-  // ── Tag Operations ────────────────────────────────────────
-  async tag(name) {
-    await this.git.addTag(name);
-  }
-  async listTags() {
-    const result = await this.git.tags();
-    return result.all.filter((t) => t.startsWith("forge/"));
-  }
-  async checkoutTag(tagName) {
-    await this.stashDirtyState();
-    await this.git.checkout(tagName);
-  }
-  // ── Diff & History ────────────────────────────────────────
-  async getDiff(branch) {
-    return this.git.diff(["main", branch]);
-  }
-  /** Diff between any two refs (tags, commits, branches) */
-  async getDiff2(ref1, ref2) {
-    return this.git.diff([ref1, ref2]);
-  }
-  async getLog(count = 10) {
-    const log = await this.git.log({ maxCount: count });
-    return log.all;
-  }
-  /** Get the current HEAD commit hash */
-  async getHead() {
-    const log = await this.git.log({ maxCount: 1 });
-    return log.latest?.hash || "";
-  }
-  /** Revert a specific commit (creates a new revert commit) */
-  async revertCommit(hash) {
-    await this.git.raw(["revert", "--no-edit", hash]);
-  }
-  /** Get forge-related commits (feat:, fix:, forge:, docs:, ci:) */
-  async getForgeLog(count = 20) {
-    const log = await this.git.log({ maxCount: count });
-    return log.all.map((entry) => ({
-      hash: entry.hash,
-      date: entry.date,
-      message: entry.message
-    }));
-  }
-  /** Get tags pointing at a specific commit */
-  async getTagsAtCommit(hash) {
-    try {
-      const result = await this.git.raw(["tag", "--points-at", hash]);
-      return result.trim().split("\n").filter(Boolean);
-    } catch {
-      return [];
-    }
-  }
-  // ── Push Operations ─────────────────────────────────────
-  /** Check if a remote named 'origin' exists */
-  async hasRemote() {
-    try {
-      const remotes = await this.git.getRemotes();
-      return remotes.some((r) => r.name === "origin");
-    } catch {
-      return false;
-    }
-  }
-  /** Push current branch to origin */
-  async push() {
-    const branch = await this.getCurrentBranch();
-    await this.git.push("origin", branch, ["--set-upstream"]);
-  }
-  /** Push tags to origin */
-  async pushTags() {
-    await this.git.pushTags("origin");
-  }
-  // ── Status ────────────────────────────────────────────────
-  async isClean() {
-    const status = await this.git.status();
-    return status.isClean();
-  }
-  async hasUncommittedChanges() {
-    const status = await this.git.status();
-    return !status.isClean();
-  }
-  // ── Init (for new projects) ───────────────────────────────
-  async ensureRepo() {
-    if (this.repoVerified) return;
-    const isRepo = await this.git.checkIsRepo();
-    if (!isRepo) {
-      await this.git.init();
-    }
-    await this.ensureGitignore();
-    const log = await this.git.log().catch(() => null);
-    if (!log || log.total === 0) {
-      await this.git.add(".");
-      await this.git.commit("Initial commit");
-    }
-    this.repoVerified = true;
-  }
-  async ensureMainBranch() {
-    const current = await this.getCurrentBranch();
-    if (current !== "main") {
-      const branches = await this.listBranches();
-      if (!branches.includes("main")) {
-        await this.git.branch(["-M", "main"]);
-        this.cachedBranch = "main";
-      }
-    }
-  }
-  // ── Internal ──────────────────────────────────────────────
-  /** Commit any uncommitted changes before branch operations */
-  async stashDirtyState() {
-    const status = await this.git.status();
-    if (status.isClean()) return;
-    await this.git.add(".");
-    await this.git.commit("forge: save state before branch switch");
-  }
-  /** Ensure .gitignore covers build artifacts and forge internals */
-  async ensureGitignore() {
-    const gitignorePath = path.join(this.basePath, ".gitignore");
-    const requiredEntries = [
-      "node_modules/",
-      ".next/",
-      ".forge/snapshots/",
-      "dist/",
-      ".env",
-      ".env.local"
-    ];
-    let content = "";
-    try {
-      content = await fs.readFile(gitignorePath, "utf-8");
-    } catch {
-    }
-    const missing = requiredEntries.filter((e) => !content.includes(e));
-    if (missing.length > 0) {
-      const addition = (content ? "\n" : "") + missing.join("\n") + "\n";
-      await fs.appendFile(gitignorePath, addition);
-    }
-  }
-};
-
-// src/state/index.ts
-import fs2 from "fs/promises";
-import path2 from "path";
-var FORGE_DIR = ".forge";
-var PLAN_FILE = "plan.json";
-var STATE_FILE = "state.json";
-var CONFIG_FILE = "forge.config.json";
-var SNAPSHOTS_DIR = "snapshots";
-var StateManager = class {
-  basePath;
-  cache = /* @__PURE__ */ new Map();
-  dirCreated = /* @__PURE__ */ new Set();
-  constructor(basePath = process.cwd()) {
-    this.basePath = basePath;
-  }
-  /** Clear all caches (call when basePath changes) */
-  clearCache() {
-    this.cache.clear();
-    this.dirCreated.clear();
-  }
-  // ── Paths ─────────────────────────────────────────────────
-  forgePath(...parts) {
-    return path2.join(this.basePath, FORGE_DIR, ...parts);
-  }
-  rootPath(...parts) {
-    return path2.join(this.basePath, ...parts);
-  }
-  // ── Plan ──────────────────────────────────────────────────
-  async savePlan(plan) {
-    await this.writeJson(this.forgePath(PLAN_FILE), plan);
-  }
-  async getPlan() {
-    return this.readJson(this.forgePath(PLAN_FILE));
-  }
-  async hasPlan() {
-    return this.fileExists(this.forgePath(PLAN_FILE));
-  }
-  // ── State ─────────────────────────────────────────────────
-  async getState() {
-    const state = await this.readJson(
-      this.forgePath(STATE_FILE)
-    );
-    return state || {
-      currentPhase: "init",
-      currentStory: null,
-      workerMode: null,
-      queue: [],
-      history: []
-    };
-  }
-  async updatePhase(phase) {
-    const state = await this.getState();
-    state.currentPhase = phase;
-    await this.writeJson(this.forgePath(STATE_FILE), state);
-  }
-  async updateState(updates) {
-    const state = await this.getState();
-    Object.assign(state, updates);
-    await this.writeJson(this.forgePath(STATE_FILE), state);
-  }
-  async addHistoryEntry(entry) {
-    const state = await this.getState();
-    state.history.push({
-      ...entry,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      snapshotId: entry.snapshotId || null
-    });
-    await this.writeJson(this.forgePath(STATE_FILE), state);
-  }
-  // ── Config ────────────────────────────────────────────────
-  async getConfig() {
-    return this.readJson(this.rootPath(CONFIG_FILE));
-  }
-  async isInitialized() {
-    return this.fileExists(this.rootPath(CONFIG_FILE));
-  }
-  // ── Snapshots ─────────────────────────────────────────────
-  async saveSnapshot(data) {
-    const state = await this.getState();
-    const id = String(state.history.length + 1).padStart(3, "0");
-    const snapshot = {
-      id,
-      action: data.action,
-      storyId: data.storyId,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      files: [],
-      branch: data.branch,
-      commitBefore: data.commitBefore || ""
-    };
-    await this.writeJson(
-      this.forgePath(SNAPSHOTS_DIR, `${id}-pre-${data.action}-${data.storyId || "global"}.json`),
-      snapshot
-    );
-    await this.addHistoryEntry({
-      action: data.action,
-      storyId: data.storyId,
-      details: `Snapshot taken before ${data.action}`,
-      snapshotId: id
-    });
-    return id;
-  }
-  async getSnapshot(id) {
-    const dir = this.forgePath(SNAPSHOTS_DIR);
-    const files = await fs2.readdir(dir).catch(() => []);
-    const match = files.find((f) => f.startsWith(id));
-    if (!match) return null;
-    return this.readJson(path2.join(dir, match));
-  }
-  async listSnapshots() {
-    const dir = this.forgePath(SNAPSHOTS_DIR);
-    const files = await fs2.readdir(dir).catch(() => []);
-    const snapshots = [];
-    for (const file of files.filter((f) => f.endsWith(".json"))) {
-      const snapshot = await this.readJson(path2.join(dir, file));
-      if (snapshot) snapshots.push(snapshot);
-    }
-    return snapshots.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-  }
-  // ── Design References ──────────────────────────────────────
-  async saveDesignReferences(files) {
-    const refDir = this.forgePath("designs", "references");
-    await fs2.mkdir(refDir, { recursive: true });
-    const manifest = [];
-    for (const file of files) {
-      const basename = path2.basename(file);
-      const dest = path2.join(refDir, basename);
-      await fs2.copyFile(file, dest);
-      manifest.push({ original: file, saved: dest });
-    }
-    await this.writeJson(this.forgePath("designs", "references.json"), manifest);
-  }
-  async getDesignReferences() {
-    const manifest = await this.readJson(
-      this.forgePath("designs", "references.json")
-    );
-    return manifest?.map((r) => r.saved) || [];
-  }
-  // ── Helpers ───────────────────────────────────────────────
-  async readJson(filePath) {
-    try {
-      const stat = await fs2.stat(filePath);
-      const mtime = stat.mtimeMs;
-      const cached = this.cache.get(filePath);
-      if (cached && cached.mtime === mtime) {
-        return cached.data;
-      }
-      const content = await fs2.readFile(filePath, "utf-8");
-      const data = JSON.parse(content);
-      this.cache.set(filePath, { data, mtime });
-      return data;
-    } catch (err) {
-      if (err?.code === "ENOENT") return null;
-      if (err instanceof SyntaxError) return null;
-      throw err;
-    }
-  }
-  async writeJson(filePath, data) {
-    const dir = path2.dirname(filePath);
-    if (!this.dirCreated.has(dir)) {
-      await fs2.mkdir(dir, { recursive: true });
-      this.dirCreated.add(dir);
-    }
-    const json = JSON.stringify(data, null, 2);
-    await fs2.writeFile(filePath, json);
-    const stat = await fs2.stat(filePath);
-    this.cache.set(filePath, { data, mtime: stat.mtimeMs });
-  }
-  async fileExists(filePath) {
-    try {
-      await fs2.access(filePath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-};
-var stateManager = new StateManager();
-
-// src/core/pipeline/index.ts
-import chalk3 from "chalk";
-import ora from "ora";
-import inquirer from "inquirer";
-var MAX_REGEN_ATTEMPTS = 5;
-var Pipeline = class {
-  orchestrator;
-  worker;
-  git;
-  config;
-  plan = null;
-  changeQueue = [];
-  constructor(config) {
-    this.config = config;
-    this.orchestrator = new Orchestrator(config);
-    this.worker = new Worker(config, {});
-    this.git = new GitManager();
-  }
-  // ── Full Sprint (all phases) ──────────────────────────────
-  async runSprint(description) {
-    console.log(chalk3.bold("\n  forge") + chalk3.dim(" sprint\n"));
-    await this.git.ensureRepo();
-    await this.git.ensureMainBranch();
-    this.plan = await this.runPlanPhase(description);
-    if (!this.plan) return;
-    const adapter = getAdapter(this.config.framework);
-    if (adapter.designSupport) {
-      await this.runDesignPhase(this.plan);
-    } else {
-      console.log(chalk3.dim(`
-  Design skipped (${adapter.name} \u2014 no Storybook support)
-`));
-    }
-    await this.runBuildPhase(this.plan);
-    await this.runReviewPhase(this.plan);
-    console.log(chalk3.dim("\n  \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"));
-    console.log(chalk3.bold("  Sprint complete\n"));
-    console.log(chalk3.dim("  Run your app and test it."));
-    console.log(chalk3.dim("  Use " + chalk3.white('forge fix "description"') + " to make changes."));
-    console.log(chalk3.dim("  Use " + chalk3.white("forge undo") + " to revert.\n"));
-  }
-  // ── Phase 1: Plan ────────────────────────────────────────
-  async runPlanPhase(description, attempt = 1) {
-    if (attempt === 1) {
-      console.log(chalk3.bold("  Plan\n"));
-    }
-    const spinner = ora({ text: "Analyzing requirements...", indent: 2 }).start();
-    let plan;
-    try {
-      plan = await this.orchestrator.generatePlan(description);
-    } catch (err) {
-      spinner.fail("Plan generation failed");
-      console.log(chalk3.red(`  ${err instanceof Error ? err.message : err}`));
-      return null;
-    }
-    spinner.succeed("Plan generated");
-    this.displayPlan(plan);
-    const { action } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "action",
-        message: "Action",
-        choices: [
-          { name: "Approve plan", value: "approve" },
-          { name: "Edit (describe changes)", value: "edit" },
-          { name: "Regenerate", value: "regen" },
-          { name: "Cancel", value: "cancel" }
-        ]
-      }
-    ]);
-    switch (action) {
-      case "approve":
-        await stateManager.savePlan(plan);
-        await stateManager.updatePhase("plan");
-        await this.git.commitState("Sprint plan approved");
-        await this.git.tag("forge/v0.0-plan");
-        console.log(chalk3.green("  Plan saved\n"));
-        return plan;
-      case "edit": {
-        if (attempt >= MAX_REGEN_ATTEMPTS) {
-          console.log(chalk3.yellow(`  Max edit attempts (${MAX_REGEN_ATTEMPTS}) reached. Approving current plan.`));
-          await stateManager.savePlan(plan);
-          return plan;
-        }
-        const { changes } = await inquirer.prompt([
-          { type: "input", name: "changes", message: "Describe changes:" }
-        ]);
-        console.log(chalk3.dim("  Re-planning..."));
-        return this.runPlanPhase(`${description}
-
-User edits: ${changes}`, attempt + 1);
-      }
-      case "regen": {
-        if (attempt >= MAX_REGEN_ATTEMPTS) {
-          console.log(chalk3.yellow(`  Max regeneration attempts (${MAX_REGEN_ATTEMPTS}) reached.`));
-          return null;
-        }
-        return this.runPlanPhase(description, attempt + 1);
-      }
-      case "cancel":
-        console.log(chalk3.dim("  Cancelled."));
-        return null;
-      default:
-        return null;
-    }
-  }
-  // ── Phase 2: Design ──────────────────────────────────────
-  async runDesignPhase(plan) {
-    const uiStories = this.getStoriesByType(plan, ["ui", "fullstack"]);
-    if (uiStories.length === 0) {
-      console.log(chalk3.dim("\n  No UI stories, skipping design.\n"));
-      return;
-    }
-    console.log(chalk3.bold(`
-  Design`) + chalk3.dim(` \xB7 ${uiStories.length} stories
-`));
-    for (const story of uiStories) {
-      const spinner = ora({ text: story.title, indent: 4 }).start();
-      const prompt = this.orchestrator.craftWorkerPrompt(story, "design", { plan });
-      const result = await this.worker.run("design", prompt, {
-        onProgress: (event) => {
-          if (event.type === "tool_use") {
-            spinner.text = event.content;
-          }
-        }
-      });
-      if (result.success) {
-        spinner.succeed(story.title);
-      } else {
-        spinner.fail(story.title);
-        console.log(chalk3.red(`       ${result.errors.join(", ")}`));
-        continue;
-      }
-      const adapter = getAdapter(this.config.framework);
-      console.log(chalk3.dim(`    Preview: http://localhost:${adapter.devPort}
-`));
-      const { approval } = await inquirer.prompt([
-        {
-          type: "list",
-          name: "approval",
-          message: `Approve "${story.title}"?`,
-          choices: [
-            { name: "Approve", value: "approve" },
-            { name: "Request changes", value: "change" },
-            { name: "Skip", value: "skip" }
-          ]
-        }
-      ]);
-      if (approval === "approve") {
-        story.designApproved = true;
-        story.status = "design-approved";
-        console.log(chalk3.green(`    Approved
-`));
-      } else if (approval === "change") {
-        const { feedback } = await inquirer.prompt([
-          { type: "input", name: "feedback", message: "Describe changes:" }
-        ]);
-        const fixResult = await this.worker.run("fix", `Revise design for "${story.title}": ${feedback}`);
-        if (fixResult.success) {
-          console.log(chalk3.dim("    Revised.\n"));
-        }
-      }
-    }
-    await stateManager.savePlan(plan);
-    await stateManager.updatePhase("design");
-    await this.git.commitAll("forge: designs reviewed");
-    await this.git.tag("forge/v0.1-designs");
-    console.log(chalk3.dim("  Design phase complete\n"));
-  }
-  // ── Phase 3: Build ───────────────────────────────────────
-  async runBuildPhase(plan) {
-    const buildableStories = this.getAllStories(plan).filter(
-      (s) => s.status === "design-approved" || s.status === "planned"
-    );
-    if (buildableStories.length === 0) {
-      console.log(chalk3.dim("\n  No stories to build.\n"));
-      return;
-    }
-    console.log(chalk3.bold(`
-  Build`) + chalk3.dim(` \xB7 ${buildableStories.length} stories
-`));
-    for (const story of buildableStories) {
-      const spinner = ora({ text: story.title, indent: 4 }).start();
-      const headBefore = await this.git.getHead();
-      await stateManager.saveSnapshot({
-        action: "build",
-        storyId: story.id,
-        branch: "main",
-        commitBefore: headBefore
-      });
-      story.status = "building";
-      await stateManager.savePlan(plan);
-      const prompt = this.orchestrator.craftWorkerPrompt(story, "build", {
-        plan,
-        designMeta: story.designApproved ? { storyId: story.id } : void 0
-      });
-      const result = await this.worker.run("build", prompt, {
-        onProgress: (event) => {
-          if (event.type === "tool_use") {
-            spinner.text = event.content;
-          }
-        }
-      });
-      if (result.success) {
-        await this.git.commitAll(`feat: ${story.title}`);
-        story.status = "reviewing";
-        spinner.succeed(story.title + chalk3.dim(` \xB7 ${result.filesCreated.length} files`));
-      } else {
-        story.status = "blocked";
-        spinner.fail(story.title);
-        for (const error of result.errors) {
-          console.log(chalk3.red(`       ${error}`));
-        }
-      }
-      await stateManager.savePlan(plan);
-      await this.processQueue(plan);
-    }
-    await stateManager.updatePhase("build");
-    console.log(chalk3.dim("\n  Build phase complete\n"));
-  }
-  // ── Phase 4: Review ──────────────────────────────────────
-  async runReviewPhase(plan) {
-    const reviewableStories = this.getAllStories(plan).filter(
-      (s) => s.status === "reviewing"
-    );
-    if (reviewableStories.length === 0) return;
-    console.log(chalk3.bold(`
-  Review`) + chalk3.dim(` \xB7 ${reviewableStories.length} stories
-`));
-    for (const story of reviewableStories) {
-      const spinner = ora({ text: story.title, indent: 4 }).start();
-      const prompt = this.orchestrator.craftWorkerPrompt(story, "review", {
-        plan,
-        designMeta: story.designApproved ? { storyId: story.id } : void 0
-      });
-      let result;
-      try {
-        result = await this.worker.run("review", prompt);
-      } catch (err) {
-        spinner.fail(story.title + chalk3.dim(" \u2014 review error"));
-        console.log(chalk3.red(`       ${err instanceof Error ? err.message : err}`));
-        continue;
-      }
-      if (result.success) {
-        const tagName = `forge/v0.${this.getNextTagNumber()}-${story.id}`;
-        await this.git.tag(tagName);
-        story.tags.push(tagName);
-        story.status = "done";
-        spinner.succeed(story.title + chalk3.dim(` [${tagName}]`));
-      } else {
-        spinner.fail(story.title);
-        console.log(chalk3.dim(`       ${result.summary}`));
-      }
-      await stateManager.savePlan(plan);
-    }
-    await stateManager.updatePhase("review");
-    console.log(chalk3.dim("\n  Review phase complete\n"));
-  }
-  // ── Change Queue ─────────────────────────────────────────
-  queueChange(change) {
-    this.changeQueue.push(change);
-    console.log(chalk3.dim(`  Queued: "${change.message}"`));
-  }
-  async processQueue(plan) {
-    if (this.changeQueue.length === 0) return;
-    console.log(chalk3.dim(`
-  Processing ${this.changeQueue.length} queued changes...
-`));
-    for (const change of this.changeQueue) {
-      const decision = await this.orchestrator.routeUserInput(
-        change.message,
-        await stateManager.getState()
-      );
-      if (decision.action === "route-to-worker" && decision.prompt) {
-        const mode = decision.workerMode || "fix";
-        const spinner = ora({ text: change.message, indent: 4 }).start();
-        const result = await this.worker.run(mode, decision.prompt);
-        if (result.success) {
-          await this.git.commitAll(`fix: ${change.message}`);
-          spinner.succeed(change.message);
-        } else {
-          spinner.fail(change.message);
-        }
-      }
-    }
-    this.changeQueue = [];
-  }
-  // ── Helpers ──────────────────────────────────────────────
-  displayPlan(plan) {
-    console.log(chalk3.bold(`
-  ${plan.project}`) + chalk3.dim(` \xB7 ${plan.framework}`));
-    console.log(chalk3.dim(`  ${plan.description}
-`));
-    for (const epic of plan.epics) {
-      console.log(chalk3.dim(`  ${epic.title}`));
-      for (const story of epic.stories) {
-        const tag = story.type === "ui" ? "ui" : story.type === "backend" ? "api" : "full";
-        console.log(`    ${chalk3.dim(`[${tag}]`)} ${story.id} ${chalk3.dim("\u2014")} ${story.title}`);
-      }
-      console.log("");
-    }
-  }
-  getAllStories(plan) {
-    return plan.epics.flatMap((epic) => epic.stories);
-  }
-  getStoriesByType(plan, types) {
-    return this.getAllStories(plan).filter((s) => types.includes(s.type));
-  }
-  tagCounter = 2;
-  getNextTagNumber() {
-    return this.tagCounter++;
-  }
-};
-
-// src/core/pipeline/auto.ts
-import chalk4 from "chalk";
-import ora2 from "ora";
-import readline from "readline";
-import inquirer2 from "inquirer";
-
-// src/core/github/index.ts
-import { spawnSync } from "child_process";
-var GitHubSync = class {
-  repo;
-  constructor(repo) {
-    this.repo = repo;
-  }
-  /** Check if `gh` CLI is installed and authenticated */
-  static isAvailable() {
-    const result = spawnSync("gh", ["auth", "status"], { stdio: "ignore", shell: true });
-    return result.status === 0;
-  }
-  /** Create GitHub labels for forge story tracking */
-  async ensureLabels() {
-    const labels = [
-      { name: "forge", color: "000000", description: "Managed by ForgeAI" },
-      { name: "type:ui", color: "7057ff", description: "UI component" },
-      { name: "type:backend", color: "0075ca", description: "Backend/API" },
-      { name: "type:fullstack", color: "008672", description: "Full stack" },
-      { name: "status:planned", color: "d4c5f9", description: "Planned" },
-      { name: "status:in-progress", color: "fbca04", description: "Building" },
-      { name: "status:review", color: "f9d0c4", description: "In review" },
-      { name: "status:done", color: "0e8a16", description: "Complete" },
-      { name: "status:blocked", color: "e11d48", description: "Blocked" }
-    ];
-    for (const label of labels) {
-      spawnSync("gh", [
-        "label",
-        "create",
-        label.name,
-        "--repo",
-        this.repo,
-        "--color",
-        label.color,
-        "--description",
-        label.description,
-        "--force"
-      ], { stdio: "ignore", shell: true });
-    }
-  }
-  /** Sync all stories in a plan to GitHub Issues */
-  async syncPlan(plan) {
-    let created = 0;
-    let updated = 0;
-    for (const epic of plan.epics) {
-      for (const story of epic.stories) {
-        const result = await this.syncStory(story, epic.title);
-        if (result === "created") created++;
-        else if (result === "updated") updated++;
-      }
-    }
-    return { created, updated };
-  }
-  /** Sync a single story to a GitHub Issue */
-  async syncStory(story, epicTitle) {
-    const title = `[${epicTitle}] ${story.title}`;
-    const labels = this.getLabels(story);
-    const body = [
-      `**Story ID:** \`${story.id}\``,
-      `**Type:** ${story.type}`,
-      `**Priority:** ${story.priority}`,
-      `**Status:** ${story.status}`,
-      "",
-      story.description,
-      "",
-      "---",
-      "_Managed by [ForgeAI](https://github.com/joeljohn159/forgeai)_"
-    ].join("\n");
-    const searchResult = spawnSync("gh", [
-      "issue",
-      "list",
-      "--repo",
-      this.repo,
-      "--search",
-      story.id,
-      "--label",
-      "forge",
-      "--json",
-      "number",
-      "--jq",
-      ".[0].number",
-      "--state",
-      "all"
-    ], { encoding: "utf-8", shell: true });
-    const existingNumber = searchResult.stdout?.trim();
-    if (existingNumber && /^\d+$/.test(existingNumber)) {
-      const args = [
-        "issue",
-        "edit",
-        existingNumber,
-        "--repo",
-        this.repo,
-        "--title",
-        title,
-        "--body",
-        body
-      ];
-      for (const label of labels) {
-        args.push("--add-label", label);
-      }
-      spawnSync("gh", args, { stdio: "ignore" });
-      if (story.status === "done") {
-        spawnSync("gh", [
-          "issue",
-          "close",
-          existingNumber,
-          "--repo",
-          this.repo
-        ], { stdio: "ignore", shell: true });
-      }
-      return "updated";
-    }
-    const createArgs = [
-      "issue",
-      "create",
-      "--repo",
-      this.repo,
-      "--title",
-      title,
-      "--body",
-      body
-    ];
-    for (const label of labels) {
-      createArgs.push("--label", label);
-    }
-    const createResult = spawnSync("gh", createArgs, { stdio: "ignore" });
-    if (createResult.status === 0) {
-      return "created";
-    }
-    return "skipped";
-  }
-  /** Map story status to GitHub labels */
-  getLabels(story) {
-    const labels = ["forge", `type:${story.type}`];
-    switch (story.status) {
-      case "planned":
-      case "designing":
-      case "design-approved":
-        labels.push("status:planned");
-        break;
-      case "building":
-        labels.push("status:in-progress");
-        break;
-      case "reviewing":
-        labels.push("status:review");
-        break;
-      case "done":
-        labels.push("status:done");
-        break;
-      case "blocked":
-        labels.push("status:blocked");
-        break;
-    }
-    return labels;
-  }
-};
-
-// src/core/utils/attachments.ts
-import fs3 from "fs";
-import path3 from "path";
-var IMAGE_EXTS = /* @__PURE__ */ new Set([
-  ".png",
-  ".jpg",
-  ".jpeg",
-  ".gif",
-  ".webp",
-  ".svg",
-  ".bmp",
-  ".ico",
-  ".tiff",
-  ".avif"
-]);
-var DOCUMENT_EXTS = /* @__PURE__ */ new Set([
-  ".pdf",
-  ".doc",
-  ".docx",
-  ".txt",
-  ".md",
-  ".csv",
-  ".xls",
-  ".xlsx",
-  ".ppt",
-  ".pptx",
-  ".rtf",
-  ".html",
-  ".json",
-  ".yaml",
-  ".yml",
-  ".xml",
-  ".figma",
-  ".sketch",
-  ".xd"
-]);
-var PATH_PATTERN = /(?:"([^"]+\.[\w]+)")|(?:'([^']+\.[\w]+)')|(?:((?:\/|[A-Z]:\\)(?:[^\s,;]|\\[ ])+\.[\w]+))/g;
-function parseAttachments(input) {
-  const attachments = [];
-  let imageCount = 0;
-  let docCount = 0;
-  let cleaned = input.replace(PATH_PATTERN, (match, quoted, singleQuoted, raw) => {
-    const filePath = (quoted || singleQuoted || raw || "").replace(/\\ /g, " ").trim();
-    if (!filePath) return match;
-    const resolved = path3.resolve(filePath);
-    if (!fs3.existsSync(resolved)) return match;
-    const ext = path3.extname(resolved).toLowerCase();
-    const fileName = path3.basename(resolved);
-    let type;
-    let label;
-    if (IMAGE_EXTS.has(ext)) {
-      imageCount++;
-      type = "image";
-      label = `[Image${imageCount}]`;
-    } else if (DOCUMENT_EXTS.has(ext)) {
-      docCount++;
-      type = "document";
-      label = `[Document${docCount}]`;
-    } else {
-      docCount++;
-      type = "document";
-      label = `[Document${docCount}]`;
-    }
-    attachments.push({
-      label,
-      originalPath: match,
-      resolvedPath: resolved,
-      type,
-      ext,
-      fileName
-    });
-    return label;
-  });
-  cleaned = cleaned.replace(/\s{2,}/g, " ").trim();
-  return { description: cleaned, attachments };
-}
-function stageAttachments(attachments) {
-  if (attachments.length === 0) return [];
-  const attachDir = path3.join(process.cwd(), ".forge", "attachments");
-  fs3.mkdirSync(attachDir, { recursive: true });
-  const stagedPaths = [];
-  for (const att of attachments) {
-    const stagedName = att.label.replace(/[\[\]]/g, "").toLowerCase() + att.ext;
-    const dest = path3.join(attachDir, stagedName);
-    try {
-      fs3.copyFileSync(att.resolvedPath, dest);
-      stagedPaths.push(dest);
-    } catch {
-    }
-  }
-  return stagedPaths;
-}
-function formatAttachmentList(attachments) {
-  if (attachments.length === 0) return "";
-  return attachments.map((a) => `    ${a.label} ${a.fileName}`).join("\n");
-}
-function buildAttachmentPrompt(attachments) {
-  if (attachments.length === 0) return "";
-  const lines = attachments.map((a) => {
-    const relPath = path3.relative(process.cwd(), a.resolvedPath);
-    if (a.type === "image") {
-      return `- ${a.label}: Image file at ${relPath} \u2014 read this file to see the visual reference`;
-    }
-    return `- ${a.label}: Document at ${relPath} \u2014 read this file for requirements/specs`;
-  });
-  return `
-ATTACHMENTS (provided by the user):
-${lines.join("\n")}
-
-Use these attachments as reference material. For images, match the visual style/layout.
-For documents, extract requirements and specifications from them.
-`;
-}
-
-// src/core/pipeline/auto.ts
-var AutoPipeline = class {
-  orchestrator;
-  worker;
-  git;
-  config;
-  plan = null;
-  options;
-  chatQueue = [];
-  rl = null;
-  startTime = 0;
-  totalUsage = { inputTokens: 0, outputTokens: 0, costUsd: 0, durationMs: 0 };
-  shuttingDown = false;
-  activeSpinner = null;
-  tagCounter = 1;
-  constructor(config, options = {}) {
-    this.config = config;
-    this.options = options;
-    this.orchestrator = new Orchestrator(config);
-    this.worker = new Worker(
-      config,
-      {
-        sandbox: options.sandbox ?? true,
-        yes: options.yes ?? false,
-        workingDir: options.workingDir,
-        allowedDomains: options.allowedDomains
-      },
-      options.mute
-    );
-    this.git = new GitManager();
-    this.setupGracefulShutdown();
-  }
-  // ── Graceful Shutdown ────────────────────────────────────
-  setupGracefulShutdown() {
-    const handler = async () => {
-      if (this.shuttingDown) return;
-      this.shuttingDown = true;
-      if (this.activeSpinner?.isSpinning) {
-        this.activeSpinner.stop();
-      }
-      console.log(chalk4.yellow("\n\n  Interrupted \u2014 saving progress..."));
-      try {
-        if (this.plan) {
-          await stateManager.savePlan(this.plan);
-          await this.git.commitAll("forge: save progress (interrupted)");
-          console.log(chalk4.dim("  Progress saved. Resume with: forge resume\n"));
-        }
-      } catch {
-        console.log(chalk4.dim("  Could not save progress.\n"));
-      }
-      this.stopChatListener();
-      process.exit(130);
-    };
-    process.on("SIGINT", handler);
-    if (process.platform !== "win32") {
-      process.on("SIGTERM", handler);
-    }
-  }
-  // ── Resume an interrupted sprint ──────────────────────────
-  async resume(existingPlan) {
-    const errors = [];
-    this.startTime = Date.now();
-    this.plan = existingPlan;
-    console.log(chalk4.bold("\n  forge") + chalk4.dim(" resume"));
-    console.log(chalk4.dim(`  Continuing from last checkpoint
-`));
-    this.startChatListener();
-    await this.git.ensureRepo();
-    await this.git.ensureMainBranch();
-    const allStories = this.getAllStories(this.plan);
-    const needsDesign = allStories.some(
-      (s) => s.status === "planned" && (s.type === "ui" || s.type === "fullstack")
-    );
-    const needsBuild = allStories.some(
-      (s) => s.status === "planned" || s.status === "design-approved"
-    );
-    const needsReview = allStories.some((s) => s.status === "reviewing");
-    if (!needsDesign && !needsBuild && !needsReview) {
-      console.log(chalk4.green("  Nothing to resume \u2014 all stories are complete or blocked.\n"));
-      this.stopChatListener();
-      return { success: true, plan: this.plan, errors };
-    }
-    if (needsDesign && !this.options.skipDesign) {
-      try {
-        await this.runDesignPhase(this.plan);
-      } catch (err) {
-        await this.saveProgressOnError("design");
-        errors.push(`Design: ${err instanceof Error ? err.message : err}`);
-      }
-    }
-    if (needsBuild) {
-      try {
-        await this.runBuildPhase(this.plan);
-      } catch (err) {
-        await this.saveProgressOnError("build");
-        errors.push(`Build: ${err instanceof Error ? err.message : err}`);
-      }
-    }
-    if (needsReview || needsBuild) {
-      const gateAction = await this.reviewGate();
-      if (gateAction === "abort") {
-        this.stopChatListener();
-        this.printSummary(errors);
-        return { success: false, plan: this.plan, errors: [...errors, "Aborted"] };
-      }
-      if (gateAction !== "skip") {
-        try {
-          await this.runReviewPhase(this.plan);
-        } catch (err) {
-          await this.saveProgressOnError("review");
-          errors.push(`Review: ${err instanceof Error ? err.message : err}`);
-        }
-      }
-    }
-    await this.autoPush();
-    this.stopChatListener();
-    this.printSummary(errors);
-    await stateManager.updatePhase("done");
-    const failedCount = allStories.filter((s) => s.status === "blocked").length;
-    return { success: errors.length === 0 && failedCount === 0, plan: this.plan, errors };
-  }
-  // ── Full Autonomous Sprint ─────────────────────────────────
-  async run(description) {
-    const errors = [];
-    this.startTime = Date.now();
-    console.log(chalk4.bold("\n  forge") + chalk4.dim(" auto"));
-    const flags = [
-      `sandbox ${this.options.sandbox !== false ? "on" : "off"}`,
-      ...this.options.yes ? ["auto-approve on"] : []
-    ].join(" \xB7 ");
-    console.log(chalk4.dim(`  ${flags} \xB7 type a message anytime to queue feedback
-`));
-    this.startChatListener();
-    await this.git.ensureRepo();
-    await this.git.ensureMainBranch();
-    const planSpinner = ora2({ text: `${this.elapsed()} Planning...`, indent: 2 }).start();
-    this.activeSpinner = planSpinner;
-    try {
-      const attachmentContext = buildAttachmentPrompt(this.options.attachments || []);
-      this.plan = await this.orchestrator.generatePlan(description + attachmentContext);
-      planSpinner.succeed(`${this.elapsed()} Plan ready`);
-      this.activeSpinner = null;
-      this.displayPlan(this.plan);
-      await stateManager.savePlan(this.plan);
-      await stateManager.updatePhase("plan");
-      await this.git.commitState("Sprint plan");
-      await this.git.tag("forge/v0.0-plan");
-      await this.syncToGitHub(this.plan);
-    } catch (err) {
-      planSpinner.fail(`${this.elapsed()} Planning failed`);
-      this.activeSpinner = null;
-      const msg = err instanceof Error ? err.message : String(err);
-      console.log(chalk4.red(`
-  ${msg}
-`));
-      if (!msg.includes("Possible fixes")) {
-        console.log(chalk4.dim("  Possible fixes:"));
-        console.log(chalk4.dim("    1. Run: claude login"));
-        console.log(chalk4.dim("    2. Check your internet connection"));
-        console.log(chalk4.dim("    3. Run: forge doctor\n"));
-      }
-      this.stopChatListener();
-      return { success: false, plan: null, errors: [`Plan: ${msg}`] };
-    }
-    this.showInputHint();
-    if (this.options.skipDesign) {
-      for (const story of this.getAllStories(this.plan)) {
-        if (story.status === "planned") {
-          story.designApproved = true;
-        }
-      }
-      console.log(chalk4.dim(`
-  Design skipped (--skip-design)
-`));
-    } else {
-      try {
-        await this.runDesignPhase(this.plan);
-      } catch (err) {
-        await this.saveProgressOnError("design");
-        errors.push(`Design: ${err instanceof Error ? err.message : err}`);
-      }
-    }
-    try {
-      await this.runBuildPhase(this.plan);
-    } catch (err) {
-      await this.saveProgressOnError("build");
-      errors.push(`Build: ${err instanceof Error ? err.message : err}`);
-    }
-    try {
-      await this.generateReadme(this.plan);
-    } catch (err) {
-      errors.push(`README: ${err instanceof Error ? err.message : err}`);
-    }
-    const gateAction = await this.reviewGate();
-    if (gateAction === "abort") {
-      this.stopChatListener();
-      this.printSummary(errors);
-      await stateManager.updatePhase("done");
-      return { success: false, plan: this.plan, errors: [...errors, "Aborted by user"] };
-    }
-    if (gateAction !== "skip") {
-      try {
-        await this.runReviewPhase(this.plan);
-      } catch (err) {
-        await this.saveProgressOnError("review");
-        errors.push(`Review: ${err instanceof Error ? err.message : err}`);
-      }
-    }
-    if (this.options.deploy) {
-      try {
-        await this.runDeployPhase(this.plan);
-      } catch (err) {
-        errors.push(`Deploy: ${err instanceof Error ? err.message : err}`);
-      }
-    }
-    await this.autoPush();
-    this.stopChatListener();
-    this.printSummary(errors);
-    await stateManager.updatePhase("done");
-    const allStories = this.getAllStories(this.plan);
-    const failedCount = allStories.filter((s) => s.status === "blocked").length;
-    return { success: errors.length === 0 && failedCount === 0, plan: this.plan, errors };
-  }
-  /** Save current progress when a phase fails — prevents data loss */
-  async saveProgressOnError(phase) {
-    try {
-      if (this.plan) {
-        await stateManager.savePlan(this.plan);
-        await stateManager.updatePhase(phase);
-        await this.git.commitAll(`forge: save progress (${phase} interrupted)`);
-        console.log(chalk4.dim(`  Progress saved. Resume with: forge resume
-`));
-      }
-    } catch {
-    }
-  }
-  // ── Elapsed Timer ─────────────────────────────────────────
-  elapsed() {
-    const sec = Math.floor((Date.now() - this.startTime) / 1e3);
-    const minutes = Math.floor(sec / 60);
-    const seconds = sec % 60;
-    return chalk4.dim(`[${minutes}:${seconds.toString().padStart(2, "0")}]`);
-  }
-  // ── Progress Helper with Timer ────────────────────────────
-  makeProgress(spinner, storyTitle) {
-    if (this.options.quiet) {
-      return { onProgress: () => {
-      }, stop: () => {
-      } };
-    }
-    let lastDetail = "";
-    const update = () => {
-      if (!spinner.isSpinning) return;
-      const prefix = this.elapsed();
-      const detail = lastDetail ? " " + chalk4.dim(lastDetail) : "";
-      spinner.text = `${prefix} ${storyTitle}${detail}`;
-    };
-    const interval = setInterval(update, 5e3);
-    const onProgress = (event) => {
-      switch (event.type) {
-        case "tool_use":
-          lastDetail = event.content;
-          break;
-        case "tool_running":
-          if (event.elapsed && event.elapsed > 3) {
-            lastDetail = `${event.tool} (${Math.round(event.elapsed)}s)`;
-          }
-          break;
-        case "tool_done":
-          lastDetail = event.content.slice(0, 80);
-          break;
-      }
-      update();
-    };
-    return {
-      onProgress,
-      stop: () => clearInterval(interval)
-    };
-  }
-  // ── Input Hint ────────────────────────────────────────────
-  showInputHint() {
-    if (process.stdout.isTTY && !this.options.quiet) {
-      const wasSpinning = this.activeSpinner?.isSpinning ?? false;
-      const spinnerText = this.activeSpinner?.text ?? "";
-      if (wasSpinning) this.activeSpinner.stop();
-      process.stdout.write(chalk4.dim("\n  \u2500 type a message and press enter \u2500\n  > "));
-      if (wasSpinning && this.activeSpinner) {
-        this.activeSpinner.start(spinnerText);
-      }
-    }
-  }
-  // ── Dependency Grouping ───────────────────────────────────
-  groupByDependency(stories) {
-    const batches = [];
-    const completed = /* @__PURE__ */ new Set();
-    const remaining = new Set(stories.map((s) => s.id));
-    const storyMap = new Map(stories.map((s) => [s.id, s]));
-    if (this.plan) {
-      for (const s of this.getAllStories(this.plan)) {
-        if (s.status === "done" || s.status === "reviewing") {
-          completed.add(s.id);
-        }
-      }
-    }
-    let iterations = 0;
-    const maxIterations = stories.length + 1;
-    while (remaining.size > 0 && iterations < maxIterations) {
-      iterations++;
-      const batch = [];
-      for (const id of remaining) {
-        const story = storyMap.get(id);
-        const depsReady = story.dependencies.every(
-          (dep) => completed.has(dep) || !remaining.has(dep)
-          // dep done or not in buildable set
-        );
-        if (depsReady) {
-          batch.push(story);
-        }
-      }
-      if (batch.length === 0) {
-        for (const id of remaining) {
-          batches.push([storyMap.get(id)]);
-        }
-        break;
-      }
-      batches.push(batch);
-      for (const s of batch) {
-        completed.add(s.id);
-        remaining.delete(s.id);
-      }
-    }
-    return batches;
-  }
-  // ── Design Phase (parallel) ───────────────────────────────
-  async runDesignPhase(plan) {
-    const uiStories = this.getStoriesByType(plan, ["ui", "fullstack"]).filter(
-      (s) => s.status === "planned"
-    );
-    if (uiStories.length === 0) return;
-    console.log(chalk4.bold(`
-  Design`) + chalk4.dim(` \xB7 ${uiStories.length} stories
-`));
-    if (uiStories.length > 1) {
-      await Promise.all(
-        uiStories.map(
-          (story, i) => this.designSingleStory(story, plan, i + 1, uiStories.length)
-        )
-      );
-    } else {
-      await this.designSingleStory(uiStories[0], plan, 1, 1);
-    }
-    await stateManager.savePlan(plan);
-    await stateManager.updatePhase("design");
-    await this.git.commitState("Designs complete");
-    await this.git.tag("forge/v0.1-designs");
-    await this.processChatQueue();
-    this.showInputHint();
-  }
-  async designSingleStory(story, plan, index, total) {
-    const label = `[${index}/${total}] ${story.title}`;
-    const spinner = ora2({ text: `${this.elapsed()} ${label}`, indent: 2 }).start();
-    this.activeSpinner = spinner;
-    const progress = this.makeProgress(spinner, label);
-    try {
-      story.status = "designing";
-      const prompt = this.orchestrator.craftWorkerPrompt(story, "design", { plan });
-      const result = await this.worker.run("design", prompt, {
-        onProgress: progress.onProgress
-      });
-      this.addUsage(result.usage);
-      const tokens = chalk4.dim(
-        `${this.formatTokens(result.usage.inputTokens)} in / ${this.formatTokens(result.usage.outputTokens)} out`
-      );
-      if (result.success) {
-        spinner.succeed(`${this.elapsed()} ${label} ${tokens}`);
-        story.designApproved = true;
-        story.status = "design-approved";
-      } else {
-        spinner.warn(`${this.elapsed()} ${label}` + chalk4.dim(" skipped") + ` ${tokens}`);
-        story.designApproved = false;
-        story.status = "design-approved";
-      }
-    } finally {
-      progress.stop();
-      this.activeSpinner = null;
-    }
-  }
-  // ── Build Phase (parallel by dependency) ──────────────────
-  async runBuildPhase(plan) {
-    const buildable = this.getAllStories(plan).filter(
-      (s) => s.status === "design-approved" || s.status === "planned"
-    );
-    if (buildable.length === 0) return;
-    console.log(chalk4.bold(`
-  Build`) + chalk4.dim(` \xB7 ${buildable.length} stories
-`));
-    const batches = this.groupByDependency(buildable);
-    let storyIndex = 0;
-    for (const batch of batches) {
-      if (batch.length === 1) {
-        storyIndex++;
-        await this.buildSingleStory(batch[0], plan, storyIndex, buildable.length, false);
-      } else {
-        console.log(chalk4.dim(`  ${this.elapsed()} parallel: ${batch.map((s) => s.title).join(", ")}`));
-        const indexedBatch = batch.map((story) => {
-          storyIndex++;
-          return { story, index: storyIndex };
-        });
-        await Promise.all(
-          indexedBatch.map(
-            ({ story, index }) => this.buildSingleStory(story, plan, index, buildable.length, true)
-          )
-        );
-        const builtTitles = batch.filter((s) => s.status === "reviewing").map((s) => s.title);
-        if (builtTitles.length > 0) {
-          await this.git.commitAll(`feat: ${builtTitles.join(", ")}`);
-        }
-      }
-      await stateManager.savePlan(plan);
-      await this.processChatQueue();
-      this.showInputHint();
-    }
-    await stateManager.updatePhase("build");
-  }
-  async buildSingleStory(story, plan, index, total, parallel) {
-    const label = `[${index}/${total}] ${story.title}`;
-    const spinner = ora2({ text: `${this.elapsed()} ${label}`, indent: 2 }).start();
-    this.activeSpinner = spinner;
-    const progress = this.makeProgress(spinner, label);
-    try {
-      const headBefore = await this.git.getHead();
-      await stateManager.saveSnapshot({
-        action: "build",
-        storyId: story.id,
-        branch: "main",
-        commitBefore: headBefore
-      });
-      story.status = "building";
-      const prompt = this.orchestrator.craftWorkerPrompt(story, "build", {
-        plan,
-        designMeta: story.designApproved ? { storyId: story.id } : void 0
-      });
-      const result = await this.worker.run("build", prompt, {
-        onProgress: progress.onProgress
-      });
-      this.addUsage(result.usage);
-      const tokens = chalk4.dim(
-        `${this.formatTokens(result.usage.inputTokens)} in / ${this.formatTokens(result.usage.outputTokens)} out`
-      );
-      if (result.success) {
-        if (!parallel) {
-          await this.git.commitAll(`feat: ${story.title}`);
-        }
-        story.status = "reviewing";
-        spinner.succeed(
-          `${this.elapsed()} ${label}` + chalk4.dim(` \xB7 ${result.filesCreated.length} files`) + ` ${tokens}`
-        );
-      } else {
-        story.status = "blocked";
-        spinner.fail(`${this.elapsed()} ${label} ${tokens}`);
-        for (const error of result.errors) {
-          console.log(chalk4.red(`    ${error}`));
-        }
-        if (result.errors.some((e) => e.includes("safety cap"))) {
-          console.log(chalk4.yellow(`    Tip: Story may be too large. Try splitting it into smaller stories.`));
-        }
-      }
-    } finally {
-      progress.stop();
-      this.activeSpinner = null;
-    }
-  }
-  // ── README Generation ─────────────────────────────────────
-  async generateReadme(plan) {
-    const builtStories = this.getAllStories(plan).filter(
-      (s) => s.status === "reviewing" || s.status === "done"
-    );
-    if (builtStories.length === 0) return;
-    const label = "README.md";
-    const spinner = ora2({ text: `${this.elapsed()} Generating ${label}`, indent: 2 }).start();
-    this.activeSpinner = spinner;
-    const progress = this.makeProgress(spinner, label);
-    try {
-      const storyList = builtStories.map((s) => `- ${s.title}: ${s.description}`).join("\n");
-      const prompt = `
-        Generate a README.md for this project.
-
-        Project: ${plan.project}
-        Description: ${plan.description}
-        Framework: ${plan.framework}
-
-        Features built:
-        ${storyList}
-
-        Read the actual codebase to understand the project structure.
-
-        Include these sections:
-        - Project name and description
-        - Key features (from the stories above)
-        - Tech stack
-        - Getting started (install, dev server, build)
-        - Project structure (based on actual files you can see)
-
-        Write the README.md file in the project root.
-        Keep it concise and professional.
-      `;
-      const result = await this.worker.run("build", prompt, {
-        onProgress: progress.onProgress
-      });
-      this.addUsage(result.usage);
-      if (result.success) {
-        await this.git.commitAll("docs: generate README.md");
-        spinner.succeed(`${this.elapsed()} ${label}`);
-      } else {
-        spinner.warn(`${this.elapsed()} ${label}` + chalk4.dim(" skipped"));
-      }
-    } finally {
-      progress.stop();
-      this.activeSpinner = null;
-    }
-  }
-  // ── Review Gate ───────────────────────────────────────────
-  async reviewGate() {
-    if (this.options.yes) return "continue";
-    if (!process.stdout.isTTY) return "continue";
-    if (!this.options.mute) {
-      playSound();
-    }
-    if (this.activeSpinner?.isSpinning) {
-      this.activeSpinner.stop();
-      this.activeSpinner = null;
-    }
-    this.stopChatListener();
-    console.log("");
-    const { action } = await inquirer2.prompt([
-      {
-        type: "list",
-        name: "action",
-        message: `${this.elapsed()} Build complete. What next?`,
-        choices: [
-          { name: "Continue to review", value: "continue" },
-          { name: "Skip review", value: "skip" },
-          { name: "Abort", value: "abort" }
-        ]
-      }
-    ]);
-    this.startChatListener();
-    return action;
-  }
-  // ── Review Phase ──────────────────────────────────────────
-  async runReviewPhase(plan) {
-    const reviewable = this.getAllStories(plan).filter((s) => s.status === "reviewing");
-    if (reviewable.length === 0) return;
-    console.log(chalk4.bold(`
-  Review`) + chalk4.dim(` \xB7 ${reviewable.length} stories
-`));
-    for (let i = 0; i < reviewable.length; i++) {
-      const story = reviewable[i];
-      const label = `[${i + 1}/${reviewable.length}] ${story.title}`;
-      const spinner = ora2({ text: `${this.elapsed()} ${label}`, indent: 2 }).start();
-      this.activeSpinner = spinner;
-      const progress = this.makeProgress(spinner, label);
-      try {
-        const prompt = this.orchestrator.craftWorkerPrompt(story, "review", {
-          plan,
-          designMeta: story.designApproved ? { storyId: story.id } : void 0
-        });
-        const result = await this.worker.run("review", prompt, {
-          onProgress: progress.onProgress
-        });
-        this.addUsage(result.usage);
-        const tokens = chalk4.dim(
-          `${this.formatTokens(result.usage.inputTokens)} in / ${this.formatTokens(result.usage.outputTokens)} out`
-        );
-        if (result.success) {
-          const tagName = `forge/v0.${this.tagCounter++}-${story.id}`;
-          await this.git.tag(tagName);
-          story.tags.push(tagName);
-          story.status = "done";
-          spinner.succeed(`${this.elapsed()} ${label}` + chalk4.dim(` [${tagName}]`) + ` ${tokens}`);
-        } else {
-          spinner.text = `${this.elapsed()} ${label}` + chalk4.dim(" fixing issues...");
-          const fixed = await this.autoFix(story, plan, result.summary, spinner, label);
-          if (fixed) {
-            const tagName = `forge/v0.${this.tagCounter++}-${story.id}`;
-            await this.git.tag(tagName);
-            story.tags.push(tagName);
-            story.status = "done";
-            spinner.succeed(`${this.elapsed()} ${label}` + chalk4.dim(` [${tagName}] fixed`));
-          } else {
-            story.status = "blocked";
-            spinner.fail(`${this.elapsed()} ${label}` + chalk4.dim(" blocked"));
-          }
-        }
-      } finally {
-        progress.stop();
-        this.activeSpinner = null;
-      }
-      await stateManager.savePlan(plan);
-      await this.processChatQueue();
-      this.showInputHint();
-    }
-    await stateManager.updatePhase("review");
-  }
-  // ── Auto-Fix ──────────────────────────────────────────────
-  async autoFix(story, _plan, reviewSummary, spinner, label) {
-    const fixPrompt = `
-      The review found these issues:
-      ${reviewSummary}
-
-      Fix them. Make minimal changes. Then re-run build/lint/typecheck to verify.
-    `;
-    const fixProgress = this.makeProgress(spinner, label + chalk4.dim(" fix"));
-    try {
-      const result = await this.worker.run("fix", fixPrompt, {
-        onProgress: fixProgress.onProgress
-      });
-      if (result.success) {
-        await this.git.commitAll(`fix: review issues in ${story.title}`);
-        return true;
-      }
-      return false;
-    } finally {
-      fixProgress.stop();
-    }
-  }
-  // ── Deploy Phase (optional) ───────────────────────────────
-  async runDeployPhase(plan) {
-    console.log(chalk4.bold(`
-  Deploy`) + chalk4.dim(` \xB7 GitHub Pages
-`));
-    const label = "GitHub Pages";
-    const spinner = ora2({ text: `${this.elapsed()} Configuring ${label}`, indent: 2 }).start();
-    this.activeSpinner = spinner;
-    const progress = this.makeProgress(spinner, label);
-    try {
-      const framework = plan.framework || "Next.js";
-      const prompt = `
-        Set up GitHub Pages deployment for this ${framework} project.
-
-        1. Update next.config.js or next.config.ts to add: output: "export"
-           (merge with existing config, do not overwrite other settings)
-        2. Create .github/workflows/deploy.yml for GitHub Pages deployment
-        3. The workflow should:
-           - Trigger on push to main
-           - Install dependencies with npm ci
-           - Build with npm run build
-           - Use actions/configure-pages, actions/upload-pages-artifact, actions/deploy-pages
-
-        Do NOT run any git commands. Just create/update the configuration files.
-      `;
-      const result = await this.worker.run("build", prompt, {
-        onProgress: progress.onProgress
-      });
-      this.addUsage(result.usage);
-      if (result.success) {
-        await this.git.commitAll("ci: add GitHub Pages deployment");
-        spinner.succeed(`${this.elapsed()} ${label} configured`);
-      } else {
-        spinner.warn(`${this.elapsed()} ${label}` + chalk4.dim(" skipped"));
-      }
-    } finally {
-      progress.stop();
-      this.activeSpinner = null;
-    }
-  }
-  // ── Chat Queue ────────────────────────────────────────────
-  startChatListener() {
-    if (!process.stdin.isTTY) return;
-    if (this.rl) return;
-    this.rl = readline.createInterface({
-      input: process.stdin,
-      terminal: false
-    });
-    this.rl.on("line", (line) => {
-      const msg = line.trim();
-      if (!msg) return;
-      this.chatQueue.push({
-        type: "content-change",
-        message: msg,
-        queuedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      const count = this.chatQueue.length;
-      const wasSpinning = this.activeSpinner?.isSpinning ?? false;
-      const spinnerText = this.activeSpinner?.text ?? "";
-      if (wasSpinning) this.activeSpinner.stop();
-      if (process.stdout.isTTY) {
-        process.stdout.write(`\r\x1B[K`);
-      }
-      console.log(
-        chalk4.green(`  [queued${count > 1 ? ` #${count}` : ""}]`) + chalk4.dim(` ${msg}`)
-      );
-      console.log(chalk4.dim("  > "));
-      if (wasSpinning && this.activeSpinner) {
-        this.activeSpinner.start(spinnerText);
-      }
-    });
-  }
-  stopChatListener() {
-    if (this.rl) {
-      this.rl.close();
-      this.rl = null;
-    }
-  }
-  async processChatQueue() {
-    if (this.chatQueue.length === 0) return;
-    if (this.activeSpinner?.isSpinning) {
-      this.activeSpinner.stop();
-    }
-    console.log(chalk4.dim(`
-  Processing ${this.chatQueue.length} queued message${this.chatQueue.length > 1 ? "s" : ""}...
-`));
-    const messages = [...this.chatQueue];
-    this.chatQueue = [];
-    for (const change of messages) {
-      try {
-        const state = await stateManager.getState();
-        const decision = await this.orchestrator.routeUserInput(change.message, state);
-        if (decision.action === "answer" && decision.response) {
-          console.log(chalk4.white(`  > ${change.message}`));
-          console.log(chalk4.dim(`    ${decision.response}
-`));
-        } else if (decision.action === "route-to-worker" && decision.prompt) {
-          const mode = decision.workerMode || "fix";
-          const spinner = ora2({ text: change.message, indent: 2 }).start();
-          const result = await this.worker.run(mode, decision.prompt);
-          if (result.success) {
-            await this.git.commitAll(`fix: ${change.message}`);
-            spinner.succeed(change.message);
-          } else {
-            spinner.fail(change.message);
-          }
-        } else if (decision.action === "add-story" && this.plan) {
-          const newStory = {
-            id: `story-${Date.now()}`,
-            title: decision.story?.title || change.message,
-            description: decision.story?.description || change.message,
-            type: decision.story?.type || "fullstack",
-            status: "planned",
-            branch: null,
-            designApproved: false,
-            tags: [],
-            priority: 99,
-            dependencies: []
-          };
-          if (this.plan.epics.length > 0) {
-            this.plan.epics[this.plan.epics.length - 1].stories.push(newStory);
-            console.log(chalk4.dim(`  + Story added: ${newStory.title}`));
-          }
-        }
-      } catch (err) {
-        console.log(chalk4.dim(`  Could not process: ${change.message}`));
-      }
-    }
-  }
-  // ── Summary ───────────────────────────────────────────────
-  printSummary(errors) {
-    const elapsedSec = (Date.now() - this.startTime) / 1e3;
-    const elapsed = elapsedSec >= 60 ? `${Math.floor(elapsedSec / 60)}m ${Math.round(elapsedSec % 60)}s` : `${Math.round(elapsedSec)}s`;
-    const allStories = this.getAllStories(this.plan);
-    const done = allStories.filter((s) => s.status === "done").length;
-    const blocked = allStories.filter((s) => s.status === "blocked").length;
-    const total = allStories.length;
-    if (!this.options.mute) {
-      playSound();
-    }
-    console.log(chalk4.dim("\n  \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"));
-    console.log(chalk4.bold("  Done") + chalk4.dim(` in ${elapsed} \xB7 ${done}/${total} stories`));
-    const u = this.totalUsage;
-    if (u.inputTokens > 0 || u.outputTokens > 0) {
-      console.log(chalk4.dim(
-        `  ${this.formatTokens(u.inputTokens)} in / ${this.formatTokens(u.outputTokens)} out` + (u.costUsd > 0 ? ` \xB7 ${this.formatCost(u.costUsd)}` : "")
-      ));
-    }
-    if (blocked > 0) {
-      console.log(chalk4.yellow(`  ${blocked} blocked`) + chalk4.dim(" \u2014 " + chalk4.white("forge status")));
-    }
-    for (const e of errors) {
-      console.log(chalk4.dim(`  ! ${e}`));
-    }
-    console.log("");
-  }
-  // ── Usage Tracking ────────────────────────────────────────
-  addUsage(usage) {
-    this.totalUsage.inputTokens += usage.inputTokens;
-    this.totalUsage.outputTokens += usage.outputTokens;
-    this.totalUsage.costUsd += usage.costUsd;
-    this.totalUsage.durationMs += usage.durationMs;
-  }
-  formatTokens(n) {
-    if (n >= 1e6) return (n / 1e6).toFixed(1) + "M";
-    if (n >= 1e3) return (n / 1e3).toFixed(1) + "k";
-    return String(n);
-  }
-  formatCost(usd) {
-    return "$" + usd.toFixed(4);
-  }
-  // ── GitHub Sync ────────────────────────────────────────────
-  async syncToGitHub(plan) {
-    if (!this.config.githubSync || !this.config.githubRepo) return;
-    if (!GitHubSync.isAvailable()) return;
-    try {
-      const gh = new GitHubSync(this.config.githubRepo);
-      await gh.ensureLabels();
-      const { created, updated } = await gh.syncPlan(plan);
-      if (created > 0 || updated > 0) {
-        console.log(chalk4.dim(`  GitHub: ${created} issues created, ${updated} updated`));
-      }
-    } catch {
-    }
-  }
-  // ── Auto-Push ───────────────────────────────────────────
-  async autoPush() {
-    const hasRemote = await this.git.hasRemote();
-    if (!hasRemote) return;
-    const spinner = ora2({ text: `${this.elapsed()} Pushing to GitHub...`, indent: 2 }).start();
-    this.activeSpinner = spinner;
-    try {
-      await this.git.push();
-      await this.git.pushTags();
-      spinner.succeed(`${this.elapsed()} Pushed to GitHub`);
-    } catch {
-      spinner.warn(`${this.elapsed()} Push failed` + chalk4.dim(" \u2014 run forge push to retry"));
-    } finally {
-      this.activeSpinner = null;
-    }
-  }
-  // ── Helpers ───────────────────────────────────────────────
-  displayPlan(plan) {
-    console.log(chalk4.bold(`
-  ${plan.project}`) + chalk4.dim(` \xB7 ${plan.framework}`));
-    const total = this.getAllStories(plan).length;
-    console.log(chalk4.dim(`  ${total} stories across ${plan.epics.length} epics
-`));
-    for (const epic of plan.epics) {
-      console.log(chalk4.dim(`  ${epic.title}`));
-      for (const story of epic.stories) {
-        const tag = story.type === "ui" ? "ui" : story.type === "backend" ? "api" : "full";
-        console.log(`    ${chalk4.dim(`[${tag}]`)} ${story.title}`);
-      }
-    }
-    console.log("");
-  }
-  getAllStories(plan) {
-    return plan.epics.flatMap((e) => e.stories);
-  }
-  getStoriesByType(plan, types) {
-    return this.getAllStories(plan).filter((s) => types.includes(s.type));
-  }
-};
-
-// src/core/utils/config.ts
-import chalk5 from "chalk";
-function validateConfig(config) {
-  const errors = [];
-  const warnings = [];
-  if (!config || typeof config !== "object") {
-    return { valid: false, errors: ["Config is empty or not an object"], warnings: [] };
-  }
-  const frameworks = listAdapters().map((a) => a.id);
-  if (!config.framework) {
-    errors.push("Missing 'framework' field");
-  } else if (!frameworks.includes(config.framework)) {
-    errors.push(
-      `Unknown framework "${config.framework}". Supported: ${frameworks.join(", ")}`
-    );
-  }
-  const validModels = ["sonnet", "opus", "haiku"];
-  if (!config.model) {
-    errors.push("Missing 'model' field");
-  } else if (!validModels.includes(config.model)) {
-    warnings.push(
-      `Unknown model "${config.model}". Expected: ${validModels.join(", ")}`
-    );
-  }
-  if (config.githubSync && !config.githubRepo) {
-    warnings.push("GitHub sync enabled but no repo configured");
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings
-  };
-}
-function loadAndValidateConfig(raw) {
-  const result = validateConfig(raw);
-  if (result.warnings.length > 0) {
-    for (const w of result.warnings) {
-      console.log(chalk5.yellow(`  warning: ${w}`));
-    }
-  }
-  if (!result.valid) {
-    for (const e of result.errors) {
-      console.log(chalk5.red(`  error: ${e}`));
-    }
-    console.log(chalk5.dim("\n  Fix forge.config.json or run: forge init\n"));
-    return null;
-  }
-  return raw;
-}
-
-export {
-  getAdapter,
-  listAdapters,
-  playSound,
-  Orchestrator,
-  Worker,
-  GitManager,
-  stateManager,
-  Pipeline,
-  parseAttachments,
-  stageAttachments,
-  formatAttachmentList,
-  buildAttachmentPrompt,
-  AutoPipeline,
-  validateConfig,
-  loadAndValidateConfig
-};
-//# sourceMappingURL=chunk-NYOV5D5J.js.map