forgecraft 1.0.0

package/dist/chunk-2HFEPXBV.js

@@ -0,0 +1,2808 @@
+// 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 djangoAdapter = {
+  id: "django",
+  name: "Django",
+  language: "python",
+  scaffoldCommands: [
+    "python3 -m venv venv",
+    "venv/bin/pip install django djangorestframework django-cors-headers python-dotenv",
+    "venv/bin/django-admin startproject config .",
+    "venv/bin/python manage.py startapp core"
+  ],
+  buildCommand: "venv/bin/python manage.py check --deploy",
+  lintCommand: "venv/bin/python -m py_compile manage.py",
+  typecheckCommand: "echo 'Type checking skipped (Python)'",
+  devCommand: "venv/bin/python 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
+
+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: venv/bin/python manage.py makemigrations
+2. Run: venv/bin/python manage.py migrate
+3. Run: venv/bin/python manage.py check --deploy
+4. Fix any warnings or errors before proceeding
+
+ALWAYS generate a requirements.txt with: venv/bin/pip 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/index.ts
+var adapters = {
+  nextjs: nextjsAdapter,
+  react: reactViteAdapter,
+  django: djangoAdapter
+};
+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;
+  switch (platform()) {
+    case "darwin":
+      exec("afplay /System/Library/Sounds/Blow.aiff");
+      break;
+    case "linux":
+      exec(
+        "paplay /usr/share/sounds/freedesktop/stereo/complete.oga 2>/dev/null || printf '\\x07'"
+      );
+      break;
+    default:
+      process.stdout.write("\x07");
+  }
+}
+
+// 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 prompt = `
+      The user wants to build the following application:
+      "${description}"
+
+      Framework: ${adapter.name} (${this.config.framework})
+      Language: ${adapter.language}
+      Design support: ${adapter.designSupport ? "yes (Storybook)" : "no"}
+
+      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"]
+              }
+            ]
+          }
+        ]
+      }
+
+      No explanation, just the JSON.
+    `;
+    const resultText = await this.runQuery(prompt, { maxTurns: 3 });
+    let rawPlan;
+    try {
+      rawPlan = JSON.parse(this.cleanJson(resultText));
+    } catch {
+      throw new Error(
+        "Failed to parse plan. The AI returned invalid JSON. Try again with a clearer description."
+      );
+    }
+    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 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")}` : "";
+    return `
+      Implement: "${story.title}"
+
+      Description: ${story.description}
+      App: ${context.plan.project} (${adapter.name})
+      ${designRef}
+      ${existingRef}
+
+      Expected project structure:
+      ${adapter.fileStructure}
+
+      Technical requirements:
+      - Follow existing code patterns in the project
+      - Small, focused components/functions
+      - Proper error handling
+      - Responsive design (mobile-first)
+
+      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)
+
+      If any command fails, read the error, fix it, and re-run.
+      Do NOT leave broken code.
+    `;
+  }
+  craftReviewPrompt(story, context, adapter) {
+    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
+
+      Run:
+      - ${adapter.buildCommand}
+      - ${adapter.lintCommand}
+      - ${adapter.typecheckCommand}
+
+      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) {
+    return `
+      Fix an issue in: "${story.title}"
+      Framework: ${adapter.name}
+
+      Make the smallest possible change. Do not refactor.
+      After fixing, run ${adapter.buildCommand} and ${adapter.typecheckCommand} to verify.
+    `;
+  }
+  // ── 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 = "";
+    for await (const msg of query({
+      prompt,
+      options: {
+        model: this.config.model,
+        systemPrompt: ORCHESTRATOR_SYSTEM_PROMPT,
+        maxTurns: opts.maxTurns,
+        allowedTools: []
+      }
+    })) {
+      if (msg.type === "result") {
+        if ("result" in msg && typeof msg.result === "string") {
+          resultText = msg.result;
+        } else if ("errors" in msg && Array.isArray(msg.errors)) {
+          throw new Error(`Agent error: ${msg.errors.join(", ")}`);
+        }
+      }
+      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");
+        }
+      }
+    }
+    if (!resultText) {
+      throw new Error("No response from agent");
+    }
+    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) {
+    return text.replace(/```json\s*/g, "").replace(/```\s*/g, "").trim();
+  }
+};
+
+// 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 buildCmd = adapter?.buildCommand || "npm run build";
+  const lintCmd = adapter?.lintCommand || "npm run lint";
+  const typecheckCmd = adapter?.typecheckCommand || "npx tsc --noEmit";
+  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}
+
+AFTER WRITING CODE:
+1. Run: ${buildCmd} \u2014 fix ALL errors before proceeding
+2. Run: ${lintCmd} \u2014 fix warnings
+3. Run: ${typecheckCmd} \u2014 fix type errors
+
+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 buildCmd = adapter?.buildCommand || "npm run build";
+  const lintCmd = adapter?.lintCommand || "npm run lint";
+  const typecheckCmd = adapter?.typecheckCommand || "npx tsc --noEmit";
+  const lang = adapter?.language || "typescript";
+  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
+${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)"}
+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
+
+RUN THESE COMMANDS:
+- ${buildCmd}
+- ${lintCmd}
+- ${typecheckCmd}
+- npm run test (if tests exist)
+
+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 buildCmd = adapter?.buildCommand || "npm run build";
+  const typecheckCmd = adapter?.typecheckCommand || "npx tsc --noEmit";
+  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
+
+AFTER EVERY FIX:
+1. Run: ${buildCmd}
+2. Run: ${typecheckCmd}
+3. Verify the fix works
+
+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.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;
+          }
+          if ("errors" in msg && Array.isArray(msg.errors) && msg.errors.length > 0) {
+            result.errors.push(...msg.errors);
+          }
+          if ("is_error" in msg && msg.is_error) {
+            result.errors.push(msg.subtype || "unknown error");
+          }
+          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" });
+    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" });
+    }
+  }
+  /** 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" });
+    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" });
+      }
+      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/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,
+        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);
+    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"));
+    console.log(chalk4.dim(`  sandbox ${this.options.sandbox !== false ? "on" : "off"} \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 {
+      this.plan = await this.orchestrator.generatePlan(description);
+      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 (err instanceof Error && err.stack) {
+        console.log(chalk4.dim(`  ${err.stack.split("\n").slice(1, 3).join("\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 (!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,
+  AutoPipeline,
+  validateConfig,
+  loadAndValidateConfig
+};
+//# sourceMappingURL=chunk-2HFEPXBV.js.map