vibebusiness 1.2.37 → 1.2.39

package/dist/scripts/heartbeat.js

@@ -2280,9 +2280,9 @@ var require_escape_html = __commonJS({
 });
 
 // scripts/heartbeat.ts
-var fs15 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
-var import_child_process4 = require("child_process");
+var fs19 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
+var import_child_process6 = require("child_process");
 var import_util = require("util");
 
 // scripts/lib/api.ts
@@ -2290,16 +2290,16 @@ var API_URL = process.env.NEXT_PUBLIC_API_URL || "http://localhost:8001";
 var INTERNAL_API_KEY = process.env.INTERNAL_API_KEY;
 async function apiRequest(endpoint, options = {}) {
   const url = `${API_URL}${endpoint}`;
-  const headers = {
+  const headers2 = {
     "Content-Type": "application/json",
     ...options.headers
   };
   if (INTERNAL_API_KEY) {
-    headers["X-Internal-API-Key"] = INTERNAL_API_KEY;
+    headers2["X-Internal-API-Key"] = INTERNAL_API_KEY;
   }
   const response = await fetch(url, {
     ...options,
-    headers
+    headers: headers2
   });
   if (!response.ok) {
     const errorText = await response.text();
@@ -2511,6 +2511,7 @@ var ROADMAP_FILE = path.join(DATA_DIR, "roadmap.json");
 var COMPETITORS_FILE = path.join(DATA_DIR, "competitors.json");
 var POSITIONING_FILE = path.join(DATA_DIR, "positioning.json");
 var PAGES_FILE = path.join(DATA_DIR, "pages.json");
+var PAYMENTS_FILE = path.join(DATA_DIR, "payments.json");
 var TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates");
 var COMMAND_TEMPLATES_DIR = path.join(TEMPLATES_DIR, "commands");
 
@@ -5658,8 +5659,8 @@ function argument(predicate, message) {
   }
 }
 var check = { fail, argument, assert: argument };
-function getPathDefinition(glyph, path15) {
-  var _path = path15 || new Path();
+function getPathDefinition(glyph, path19) {
+  var _path = path19 || new Path();
   return {
     configurable: true,
     get: function() {
@@ -5882,9 +5883,9 @@ function ttfGlyphLoader(font, index, parseGlyph2, data, position, buildPath2) {
     var glyph = new Glyph({ index, font });
     glyph.path = function() {
       parseGlyph2(glyph, data, position);
-      var path15 = buildPath2(font.glyphs, glyph);
-      path15.unitsPerEm = font.unitsPerEm;
-      return path15;
+      var path19 = buildPath2(font.glyphs, glyph);
+      path19.unitsPerEm = font.unitsPerEm;
+      return path19;
     };
     defineDependentProperty(glyph, "xMin", "_xMin");
     defineDependentProperty(glyph, "xMax", "_xMax");
@@ -5897,9 +5898,9 @@ function cffGlyphLoader(font, index, parseCFFCharstring2, charstring) {
   return function() {
     var glyph = new Glyph({ index, font });
     glyph.path = function() {
-      var path15 = parseCFFCharstring2(font, glyph, charstring);
-      path15.unitsPerEm = font.unitsPerEm;
-      return path15;
+      var path19 = parseCFFCharstring2(font, glyph, charstring);
+      path19.unitsPerEm = font.unitsPerEm;
+      return path19;
     };
     return glyph;
   };
@@ -20706,12 +20707,1433 @@ async function executeMarketingVisualTask(taskId, _description) {
   }
 }
 
-// scripts/lib/run.ts
+// scripts/skills/email-marketing.ts
+var import_child_process3 = require("child_process");
+var fs7 = __toESM(require("fs"));
 var path5 = __toESM(require("path"));
+
+// src/lib/loops.ts
+var LOOPS_BASE_URL = "https://app.loops.so/api/v1";
+function getApiKey() {
+  const key = process.env.LOOPS_API_KEY;
+  if (!key) throw new Error("LOOPS_API_KEY environment variable is not set");
+  return key;
+}
+function headers() {
+  return {
+    Authorization: `Bearer ${getApiKey()}`,
+    "Content-Type": "application/json"
+  };
+}
+async function verifyApiKey() {
+  const res = await fetch(`${LOOPS_BASE_URL}/api-key`, {
+    method: "GET",
+    headers: headers()
+  });
+  if (!res.ok) return { success: false };
+  const data = await res.json();
+  return { success: true, teamName: data.teamName };
+}
+async function listContacts(options) {
+  const params = new URLSearchParams();
+  if (options?.limit) params.set("limit", String(options.limit));
+  const res = await fetch(
+    `${LOOPS_BASE_URL}/contacts?${params.toString()}`,
+    { method: "GET", headers: headers() }
+  );
+  if (!res.ok) {
+    throw new Error(`Loops API error: ${res.status} ${await res.text()}`);
+  }
+  const contacts = await res.json();
+  return { contacts, count: Array.isArray(contacts) ? contacts.length : 0 };
+}
+async function getMailingLists() {
+  const res = await fetch(`${LOOPS_BASE_URL}/lists`, {
+    method: "GET",
+    headers: headers()
+  });
+  if (!res.ok) {
+    throw new Error(`Loops API error: ${res.status} ${await res.text()}`);
+  }
+  return res.json();
+}
+
+// scripts/skills/email-marketing.ts
+var EMAIL_PREFIXES = [
+  "email-setup",
+  "email-campaign-",
+  "email-sequence-",
+  "email-blast-",
+  "email-health"
+];
+function isEmailMarketingTask(taskId) {
+  return EMAIL_PREFIXES.some((prefix) => taskId.startsWith(prefix));
+}
+function parseTaskToCommand2(taskId, description) {
+  if (taskId === "email-setup") {
+    return { command: "email-marketing", args: "setup" };
+  }
+  if (taskId.startsWith("email-campaign-")) {
+    const type = taskId.replace("email-campaign-", "");
+    return { command: "email-marketing", args: `campaign ${type}` };
+  }
+  if (taskId.startsWith("email-sequence-")) {
+    const name = taskId.replace("email-sequence-", "");
+    return { command: "email-marketing", args: `sequence ${name}` };
+  }
+  if (taskId.startsWith("email-blast-")) {
+    const slug = taskId.replace("email-blast-", "");
+    return { command: "email-marketing", args: `blast ${slug}` };
+  }
+  if (taskId === "email-health") {
+    return null;
+  }
+  return null;
+}
+async function executeHealthCheck() {
+  const lines = ["## Email Marketing Health Check\n"];
+  try {
+    const keyResult = await verifyApiKey();
+    if (!keyResult.success) {
+      return {
+        success: false,
+        output: "Loops API key is invalid or not set. Run email-setup to configure."
+      };
+    }
+    lines.push(`- API Key: valid (team: ${keyResult.teamName || "unknown"})`);
+    const contactResult = await listContacts({ limit: 1 });
+    lines.push(`- Total Contacts: ${contactResult.count}`);
+    const lists = await getMailingLists();
+    lines.push(`- Mailing Lists: ${lists.length}`);
+    for (const list of lists) {
+      lines.push(`  - ${list.name} (${list.id})`);
+    }
+    lines.push("\nLoops integration is healthy.");
+    return { success: true, output: lines.join("\n") };
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      output: `Health check failed: ${errMsg}`
+    };
+  }
+}
+async function executeEmailMarketingTask(taskId, description, businessContext) {
+  if (taskId === "email-health") {
+    return executeHealthCheck();
+  }
+  const parsed = parseTaskToCommand2(taskId, description);
+  if (!parsed) {
+    return {
+      success: false,
+      output: `Unknown email marketing task: ${taskId}`
+    };
+  }
+  const { command, args: args2 } = parsed;
+  const commandFile = path5.join(PROJECT_DIR, ".claude", "commands", `${command}.md`);
+  if (!fs7.existsSync(commandFile)) {
+    return {
+      success: false,
+      output: `Slash command template not found: ${commandFile}. Run 'init' to scaffold commands.`
+    };
+  }
+  const template = fs7.readFileSync(commandFile, "utf-8");
+  const prompt = args2 ? `${template}
+
+---
+
+$ARGUMENTS: ${args2}
+
+Execute this command now.` : `${template}
+
+---
+
+Execute this command now with no arguments (use defaults).`;
+  console.log(`[EmailMarketing] Executing: /${command} ${args2} (task: ${taskId})`);
+  try {
+    const result = (0, import_child_process3.spawnSync)("claude", [
+      "--print",
+      "--dangerously-skip-permissions",
+      "--allowedTools",
+      "Read Write Edit Bash Glob Grep WebSearch WebFetch"
+    ], {
+      cwd: PROJECT_DIR,
+      input: prompt,
+      encoding: "utf-8",
+      timeout: 6e5,
+      // 10 minute timeout
+      stdio: ["pipe", "pipe", "pipe"],
+      env: process.env
+    });
+    if (result.status !== 0) {
+      const errorOutput = result.stderr || result.stdout || "Unknown error";
+      return {
+        success: false,
+        output: `Claude Code exited with code ${result.status}: ${errorOutput.slice(-1e3)}`
+      };
+    }
+    return {
+      success: true,
+      output: (result.stdout || "").slice(-2e3)
+      // Last 2000 chars
+    };
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      output: `Email marketing task failed: ${errMsg.slice(-1e3)}`
+    };
+  }
+}
+
+// scripts/skills/payments.ts
+var import_child_process4 = require("child_process");
+var fs10 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
+
+// scripts/lib/payments/framework-detect.ts
+var fs8 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
+function detectFramework(projectPath) {
+  const result = {
+    framework: "other",
+    typescript: false,
+    appRouter: false,
+    srcDir: false
+  };
+  result.typescript = fs8.existsSync(path6.join(projectPath, "tsconfig.json"));
+  result.srcDir = fs8.existsSync(path6.join(projectPath, "src"));
+  const pkgPath = path6.join(projectPath, "package.json");
+  if (!fs8.existsSync(pkgPath)) {
+    return result;
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
+  } catch {
+    return result;
+  }
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+  if (allDeps["next"]) {
+    result.framework = "nextjs";
+    const appDirs = [
+      path6.join(projectPath, "app"),
+      path6.join(projectPath, "src", "app")
+    ];
+    result.appRouter = appDirs.some((dir) => fs8.existsSync(dir));
+  } else if (allDeps["@remix-run/node"] || allDeps["@remix-run/react"]) {
+    result.framework = "remix";
+  } else if (allDeps["fastify"]) {
+    result.framework = "fastify";
+  } else if (allDeps["express"]) {
+    result.framework = "express";
+  }
+  return result;
+}
+function getFileExtension(info) {
+  return info.typescript ? ".ts" : ".js";
+}
+
+// scripts/lib/payments/stripe-api.ts
+function loadStripeModule(projectPath) {
+  try {
+    const stripePath = require.resolve("stripe", { paths: [projectPath] });
+    return require(stripePath);
+  } catch {
+    return null;
+  }
+}
+function createStripeClient(secretKey, projectPath) {
+  const Stripe = loadStripeModule(projectPath);
+  if (!Stripe) {
+    throw new Error(
+      "stripe package not found. Install it with: npm install stripe"
+    );
+  }
+  const StripeConstructor = Stripe.default || Stripe;
+  return new StripeConstructor(secretKey);
+}
+async function validateApiKey(stripe) {
+  try {
+    const account = await stripe.accounts.retrieve();
+    return {
+      valid: true,
+      accountName: account.business_profile?.name || account.email || "Unknown"
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error.message || "Invalid API key"
+    };
+  }
+}
+async function findExistingProducts(stripe, name) {
+  try {
+    const products = await stripe.products.search({
+      query: `name~"${name}"`
+    });
+    return products.data.map((p) => ({
+      id: p.id,
+      name: p.name,
+      description: p.description
+    }));
+  } catch {
+    try {
+      const products = await stripe.products.list({ limit: 100 });
+      return products.data.filter((p) => p.name.toLowerCase().includes(name.toLowerCase())).map((p) => ({
+        id: p.id,
+        name: p.name,
+        description: p.description
+      }));
+    } catch {
+      return [];
+    }
+  }
+}
+async function createProduct(stripe, input) {
+  const product = await stripe.products.create({
+    name: input.name,
+    ...input.description && { description: input.description }
+  });
+  return {
+    id: product.id,
+    name: product.name,
+    description: product.description
+  };
+}
+async function createPrice(stripe, input) {
+  const params = {
+    product: input.productId,
+    unit_amount: input.unitAmount,
+    currency: input.currency
+  };
+  if (input.interval) {
+    params.recurring = { interval: input.interval };
+  }
+  const price = await stripe.prices.create(params);
+  return {
+    id: price.id,
+    productId: input.productId,
+    unitAmount: input.unitAmount,
+    currency: input.currency,
+    interval: input.interval || null
+  };
+}
+
+// scripts/lib/payments/code-templates.ts
+var DEFAULT_WEBHOOK_EVENTS = [
+  "checkout.session.completed",
+  "customer.subscription.created",
+  "customer.subscription.updated",
+  "customer.subscription.deleted",
+  "invoice.paid",
+  "invoice.payment_failed"
+];
+function getTemplatesForFramework(info, config = {}) {
+  switch (info.framework) {
+    case "nextjs":
+      return info.appRouter ? getNextjsAppRouterTemplates(info, config) : getNextjsPagesTemplates(info, config);
+    case "express":
+      return getExpressTemplates(info, config);
+    case "fastify":
+      return getFastifyTemplates(info, config);
+    case "remix":
+      return getRemixTemplates(info, config);
+    default:
+      return getGenericTemplates(info, config);
+  }
+}
+function getNextjsAppRouterTemplates(info, config) {
+  const ext = getFileExtension(info);
+  const prefix = info.srcDir ? "src/" : "";
+  const successUrl = config.successUrl || "/success";
+  const cancelUrl = config.cancelUrl || "/pricing";
+  const events = config.webhookEvents || DEFAULT_WEBHOOK_EVENTS;
+  const ts2 = info.typescript;
+  return [
+    {
+      path: `${prefix}app/api/checkout/route${ext}`,
+      description: "Stripe Checkout session creation endpoint",
+      content: `import { NextResponse } from 'next/server';
+import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+
+export async function POST(request${ts2 ? ": Request" : ""}) {
+  try {
+    const body = await request.json();
+    const { priceId, customerId } = body;
+
+    if (!priceId) {
+      return NextResponse.json({ error: 'priceId is required' }, { status: 400 });
+    }
+
+    const session = await stripe.checkout.sessions.create({
+      mode: 'subscription',
+      payment_method_types: ['card'],
+      line_items: [{ price: priceId, quantity: 1 }],
+      success_url: \`\${process.env.NEXT_PUBLIC_APP_URL}${successUrl}?session_id={CHECKOUT_SESSION_ID}\`,
+      cancel_url: \`\${process.env.NEXT_PUBLIC_APP_URL}${cancelUrl}\`,
+      ...(customerId && { customer: customerId }),
+    });
+
+    return NextResponse.json({ url: session.url });
+  } catch (error${ts2 ? ": unknown" : ""}) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+`
+    },
+    {
+      path: `${prefix}app/api/webhook/route${ext}`,
+      description: "Stripe webhook handler with signature verification",
+      content: `import { NextResponse } from 'next/server';
+import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET!;
+
+export async function POST(request${ts2 ? ": Request" : ""}) {
+  const body = await request.text();
+  const signature = request.headers.get('stripe-signature')!;
+
+  let event${ts2 ? ": Stripe.Event" : ""};
+  try {
+    event = stripe.webhooks.constructEvent(body, signature, webhookSecret);
+  } catch (error${ts2 ? ": unknown" : ""}) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    console.error('Webhook signature verification failed:', message);
+    return NextResponse.json({ error: 'Invalid signature' }, { status: 400 });
+  }
+
+  switch (event.type) {
+${events.map((e) => `    case '${e}':
+      console.log('${e}:', event.data.object);
+      // TODO: Handle ${e}
+      break;`).join("\n")}
+    default:
+      console.log('Unhandled event type:', event.type);
+  }
+
+  return NextResponse.json({ received: true });
+}
+`
+    },
+    {
+      path: `${prefix}app/api/portal/route${ext}`,
+      description: "Stripe Customer Portal redirect endpoint",
+      content: `import { NextResponse } from 'next/server';
+import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+
+export async function POST(request${ts2 ? ": Request" : ""}) {
+  try {
+    const body = await request.json();
+    const { customerId } = body;
+
+    if (!customerId) {
+      return NextResponse.json({ error: 'customerId is required' }, { status: 400 });
+    }
+
+    const session = await stripe.billingPortal.sessions.create({
+      customer: customerId,
+      return_url: \`\${process.env.NEXT_PUBLIC_APP_URL}/account\`,
+    });
+
+    return NextResponse.json({ url: session.url });
+  } catch (error${ts2 ? ": unknown" : ""}) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+`
+    },
+    {
+      path: `${prefix}components/CheckoutButton${ext}x`,
+      description: "React checkout button component",
+      content: `'use client';
+
+import { useState } from 'react';
+
+${ts2 ? `interface CheckoutButtonProps {
+  priceId: string;
+  label?: string;
+}
+
+` : ""}export default function CheckoutButton(${ts2 ? '{ priceId, label = "Subscribe" }: CheckoutButtonProps' : '{ priceId, label = "Subscribe" }'}) {
+  const [loading, setLoading] = useState(false);
+
+  async function handleCheckout() {
+    setLoading(true);
+    try {
+      const response = await fetch('/api/checkout', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ priceId }),
+      });
+      const data = await response.json();
+      if (data.url) {
+        window.location.href = data.url;
+      }
+    } catch (error) {
+      console.error('Checkout error:', error);
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  return (
+    <button onClick={handleCheckout} disabled={loading}>
+      {loading ? 'Redirecting...' : label}
+    </button>
+  );
+}
+`
+    }
+  ];
+}
+function getNextjsPagesTemplates(info, config) {
+  const ext = getFileExtension(info);
+  const successUrl = config.successUrl || "/success";
+  const cancelUrl = config.cancelUrl || "/pricing";
+  const events = config.webhookEvents || DEFAULT_WEBHOOK_EVENTS;
+  const ts2 = info.typescript;
+  return [
+    {
+      path: `pages/api/checkout${ext}`,
+      description: "Stripe Checkout session creation endpoint",
+      content: `import type { NextApiRequest, NextApiResponse } from 'next';
+import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+
+export default async function handler(req${ts2 ? ": NextApiRequest" : ""}, res${ts2 ? ": NextApiResponse" : ""}) {
+  if (req.method !== 'POST') {
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  try {
+    const { priceId, customerId } = req.body;
+
+    if (!priceId) {
+      return res.status(400).json({ error: 'priceId is required' });
+    }
+
+    const session = await stripe.checkout.sessions.create({
+      mode: 'subscription',
+      payment_method_types: ['card'],
+      line_items: [{ price: priceId, quantity: 1 }],
+      success_url: \`\${process.env.NEXT_PUBLIC_APP_URL}${successUrl}?session_id={CHECKOUT_SESSION_ID}\`,
+      cancel_url: \`\${process.env.NEXT_PUBLIC_APP_URL}${cancelUrl}\`,
+      ...(customerId && { customer: customerId }),
+    });
+
+    res.json({ url: session.url });
+  } catch (error${ts2 ? ": unknown" : ""}) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    res.status(500).json({ error: message });
+  }
+}
+`
+    },
+    {
+      path: `pages/api/webhook${ext}`,
+      description: "Stripe webhook handler with signature verification",
+      content: `import type { NextApiRequest, NextApiResponse } from 'next';
+import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET!;
+
+// Disable body parsing \u2014 Stripe needs raw body for signature verification
+export const config = { api: { bodyParser: false } };
+
+async function getRawBody(req${ts2 ? ": NextApiRequest" : ""}): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks${ts2 ? ": Buffer[]" : ""} = [];
+    req.on('data', (chunk${ts2 ? ": Buffer" : ""}) => chunks.push(chunk));
+    req.on('end', () => resolve(Buffer.concat(chunks).toString()));
+    req.on('error', reject);
+  });
+}
+
+export default async function handler(req${ts2 ? ": NextApiRequest" : ""}, res${ts2 ? ": NextApiResponse" : ""}) {
+  if (req.method !== 'POST') {
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  const body = await getRawBody(req);
+  const signature = req.headers['stripe-signature'] as string;
+
+  let event${ts2 ? ": Stripe.Event" : ""};
+  try {
+    event = stripe.webhooks.constructEvent(body, signature, webhookSecret);
+  } catch (error${ts2 ? ": unknown" : ""}) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    console.error('Webhook signature verification failed:', message);
+    return res.status(400).json({ error: 'Invalid signature' });
+  }
+
+  switch (event.type) {
+${events.map((e) => `    case '${e}':
+      console.log('${e}:', event.data.object);
+      // TODO: Handle ${e}
+      break;`).join("\n")}
+    default:
+      console.log('Unhandled event type:', event.type);
+  }
+
+  res.json({ received: true });
+}
+`
+    },
+    {
+      path: `pages/api/portal${ext}`,
+      description: "Stripe Customer Portal redirect endpoint",
+      content: `import type { NextApiRequest, NextApiResponse } from 'next';
+import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+
+export default async function handler(req${ts2 ? ": NextApiRequest" : ""}, res${ts2 ? ": NextApiResponse" : ""}) {
+  if (req.method !== 'POST') {
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  try {
+    const { customerId } = req.body;
+
+    if (!customerId) {
+      return res.status(400).json({ error: 'customerId is required' });
+    }
+
+    const session = await stripe.billingPortal.sessions.create({
+      customer: customerId,
+      return_url: \`\${process.env.NEXT_PUBLIC_APP_URL}/account\`,
+    });
+
+    res.json({ url: session.url });
+  } catch (error${ts2 ? ": unknown" : ""}) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    res.status(500).json({ error: message });
+  }
+}
+`
+    }
+  ];
+}
+function getExpressTemplates(info, config) {
+  const ext = getFileExtension(info);
+  const successUrl = config.successUrl || "/success";
+  const cancelUrl = config.cancelUrl || "/pricing";
+  const events = config.webhookEvents || DEFAULT_WEBHOOK_EVENTS;
+  const ts2 = info.typescript;
+  return [
+    {
+      path: `routes/checkout${ext}`,
+      description: "Stripe Checkout session creation route",
+      content: `import { Router } from 'express';
+${ts2 ? "import type { Request, Response } from 'express';\n" : ""}import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+const router = Router();
+
+router.post('/checkout', async (req${ts2 ? ": Request" : ""}, res${ts2 ? ": Response" : ""}) => {
+  try {
+    const { priceId, customerId } = req.body;
+
+    if (!priceId) {
+      return res.status(400).json({ error: 'priceId is required' });
+    }
+
+    const session = await stripe.checkout.sessions.create({
+      mode: 'subscription',
+      payment_method_types: ['card'],
+      line_items: [{ price: priceId, quantity: 1 }],
+      success_url: \`\${process.env.APP_URL}${successUrl}?session_id={CHECKOUT_SESSION_ID}\`,
+      cancel_url: \`\${process.env.APP_URL}${cancelUrl}\`,
+      ...(customerId && { customer: customerId }),
+    });
+
+    res.json({ url: session.url });
+  } catch (error${ts2 ? ": unknown" : ""}) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    res.status(500).json({ error: message });
+  }
+});
+
+export default router;
+`
+    },
+    {
+      path: `routes/webhook${ext}`,
+      description: "Stripe webhook handler with signature verification",
+      content: `import { Router } from 'express';
+${ts2 ? "import type { Request, Response } from 'express';\n" : ""}import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET!;
+const router = Router();
+
+// IMPORTANT: This route needs raw body parsing.
+// Add to your main app: app.use('/webhook', express.raw({ type: 'application/json' }))
+router.post('/webhook', (req${ts2 ? ": Request" : ""}, res${ts2 ? ": Response" : ""}) => {
+  const signature = req.headers['stripe-signature'] as string;
+
+  let event${ts2 ? ": Stripe.Event" : ""};
+  try {
+    event = stripe.webhooks.constructEvent(req.body, signature, webhookSecret);
+  } catch (error${ts2 ? ": unknown" : ""}) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    console.error('Webhook signature verification failed:', message);
+    return res.status(400).json({ error: 'Invalid signature' });
+  }
+
+  switch (event.type) {
+${events.map((e) => `    case '${e}':
+      console.log('${e}:', event.data.object);
+      // TODO: Handle ${e}
+      break;`).join("\n")}
+    default:
+      console.log('Unhandled event type:', event.type);
+  }
+
+  res.json({ received: true });
+});
+
+export default router;
+`
+    },
+    {
+      path: `routes/portal${ext}`,
+      description: "Stripe Customer Portal redirect route",
+      content: `import { Router } from 'express';
+${ts2 ? "import type { Request, Response } from 'express';\n" : ""}import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+const router = Router();
+
+router.post('/portal', async (req${ts2 ? ": Request" : ""}, res${ts2 ? ": Response" : ""}) => {
+  try {
+    const { customerId } = req.body;
+
+    if (!customerId) {
+      return res.status(400).json({ error: 'customerId is required' });
+    }
+
+    const session = await stripe.billingPortal.sessions.create({
+      customer: customerId,
+      return_url: \`\${process.env.APP_URL}/account\`,
+    });
+
+    res.json({ url: session.url });
+  } catch (error${ts2 ? ": unknown" : ""}) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    res.status(500).json({ error: message });
+  }
+});
+
+export default router;
+`
+    }
+  ];
+}
+function getFastifyTemplates(info, config) {
+  const ext = getFileExtension(info);
+  const successUrl = config.successUrl || "/success";
+  const cancelUrl = config.cancelUrl || "/pricing";
+  const events = config.webhookEvents || DEFAULT_WEBHOOK_EVENTS;
+  const ts2 = info.typescript;
+  return [
+    {
+      path: `routes/checkout${ext}`,
+      description: "Stripe Checkout session creation route",
+      content: `import Stripe from 'stripe';
+${ts2 ? "import type { FastifyInstance } from 'fastify';\n" : ""}
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+
+export default async function checkoutRoutes(fastify${ts2 ? ": FastifyInstance" : ""}) {
+  fastify.post('/checkout', async (request, reply) => {
+    const { priceId, customerId } = request.body as any;
+
+    if (!priceId) {
+      return reply.status(400).send({ error: 'priceId is required' });
+    }
+
+    const session = await stripe.checkout.sessions.create({
+      mode: 'subscription',
+      payment_method_types: ['card'],
+      line_items: [{ price: priceId, quantity: 1 }],
+      success_url: \`\${process.env.APP_URL}${successUrl}?session_id={CHECKOUT_SESSION_ID}\`,
+      cancel_url: \`\${process.env.APP_URL}${cancelUrl}\`,
+      ...(customerId && { customer: customerId }),
+    });
+
+    return { url: session.url };
+  });
+}
+`
+    },
+    {
+      path: `routes/webhook${ext}`,
+      description: "Stripe webhook handler with signature verification",
+      content: `import Stripe from 'stripe';
+${ts2 ? "import type { FastifyInstance } from 'fastify';\n" : ""}
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET!;
+
+export default async function webhookRoutes(fastify${ts2 ? ": FastifyInstance" : ""}) {
+  // Register raw body parser for webhook route
+  fastify.addContentTypeParser('application/json', { parseAs: 'string' }, (req, body, done) => {
+    done(null, body);
+  });
+
+  fastify.post('/webhook', async (request, reply) => {
+    const signature = request.headers['stripe-signature'] as string;
+
+    let event${ts2 ? ": Stripe.Event" : ""};
+    try {
+      event = stripe.webhooks.constructEvent(request.body as string, signature, webhookSecret);
+    } catch (error${ts2 ? ": unknown" : ""}) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      fastify.log.error('Webhook signature verification failed:', message);
+      return reply.status(400).send({ error: 'Invalid signature' });
+    }
+
+    switch (event.type) {
+${events.map((e) => `      case '${e}':
+        fastify.log.info('${e}:', event.data.object);
+        // TODO: Handle ${e}
+        break;`).join("\n")}
+      default:
+        fastify.log.info('Unhandled event type:', event.type);
+    }
+
+    return { received: true };
+  });
+}
+`
+    },
+    {
+      path: `routes/portal${ext}`,
+      description: "Stripe Customer Portal redirect route",
+      content: `import Stripe from 'stripe';
+${ts2 ? "import type { FastifyInstance } from 'fastify';\n" : ""}
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+
+export default async function portalRoutes(fastify${ts2 ? ": FastifyInstance" : ""}) {
+  fastify.post('/portal', async (request, reply) => {
+    const { customerId } = request.body as any;
+
+    if (!customerId) {
+      return reply.status(400).send({ error: 'customerId is required' });
+    }
+
+    const session = await stripe.billingPortal.sessions.create({
+      customer: customerId,
+      return_url: \`\${process.env.APP_URL}/account\`,
+    });
+
+    return { url: session.url };
+  });
+}
+`
+    }
+  ];
+}
+function getRemixTemplates(info, config) {
+  const ext = getFileExtension(info);
+  const successUrl = config.successUrl || "/success";
+  const cancelUrl = config.cancelUrl || "/pricing";
+  const events = config.webhookEvents || DEFAULT_WEBHOOK_EVENTS;
+  const ts2 = info.typescript;
+  return [
+    {
+      path: `app/routes/api.checkout${ext}`,
+      description: "Stripe Checkout session creation action",
+      content: `import { json } from '@remix-run/node';
+${ts2 ? "import type { ActionFunctionArgs } from '@remix-run/node';\n" : ""}import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+
+export async function action({ request }${ts2 ? ": ActionFunctionArgs" : ""}) {
+  const body = await request.json();
+  const { priceId, customerId } = body;
+
+  if (!priceId) {
+    return json({ error: 'priceId is required' }, { status: 400 });
+  }
+
+  const session = await stripe.checkout.sessions.create({
+    mode: 'subscription',
+    payment_method_types: ['card'],
+    line_items: [{ price: priceId, quantity: 1 }],
+    success_url: \`\${process.env.APP_URL}${successUrl}?session_id={CHECKOUT_SESSION_ID}\`,
+    cancel_url: \`\${process.env.APP_URL}${cancelUrl}\`,
+    ...(customerId && { customer: customerId }),
+  });
+
+  return json({ url: session.url });
+}
+`
+    },
+    {
+      path: `app/routes/api.webhook${ext}`,
+      description: "Stripe webhook handler with signature verification",
+      content: `import { json } from '@remix-run/node';
+${ts2 ? "import type { ActionFunctionArgs } from '@remix-run/node';\n" : ""}import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET!;
+
+export async function action({ request }${ts2 ? ": ActionFunctionArgs" : ""}) {
+  const body = await request.text();
+  const signature = request.headers.get('stripe-signature')!;
+
+  let event${ts2 ? ": Stripe.Event" : ""};
+  try {
+    event = stripe.webhooks.constructEvent(body, signature, webhookSecret);
+  } catch (error${ts2 ? ": unknown" : ""}) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    console.error('Webhook signature verification failed:', message);
+    return json({ error: 'Invalid signature' }, { status: 400 });
+  }
+
+  switch (event.type) {
+${events.map((e) => `    case '${e}':
+      console.log('${e}:', event.data.object);
+      // TODO: Handle ${e}
+      break;`).join("\n")}
+    default:
+      console.log('Unhandled event type:', event.type);
+  }
+
+  return json({ received: true });
+}
+`
+    },
+    {
+      path: `app/routes/api.portal${ext}`,
+      description: "Stripe Customer Portal redirect action",
+      content: `import { json } from '@remix-run/node';
+${ts2 ? "import type { ActionFunctionArgs } from '@remix-run/node';\n" : ""}import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+
+export async function action({ request }${ts2 ? ": ActionFunctionArgs" : ""}) {
+  const body = await request.json();
+  const { customerId } = body;
+
+  if (!customerId) {
+    return json({ error: 'customerId is required' }, { status: 400 });
+  }
+
+  const session = await stripe.billingPortal.sessions.create({
+    customer: customerId,
+    return_url: \`\${process.env.APP_URL}/account\`,
+  });
+
+  return json({ url: session.url });
+}
+`
+    }
+  ];
+}
+function getGenericTemplates(info, config) {
+  const ext = getFileExtension(info);
+  const successUrl = config.successUrl || "/success";
+  const cancelUrl = config.cancelUrl || "/pricing";
+  const events = config.webhookEvents || DEFAULT_WEBHOOK_EVENTS;
+  const ts2 = info.typescript;
+  return [
+    {
+      path: `stripe/checkout${ext}`,
+      description: "Stripe Checkout session creation function",
+      content: `import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+
+export async function createCheckoutSession(priceId${ts2 ? ": string" : ""}, customerId${ts2 ? "?: string" : ""}) {
+  const session = await stripe.checkout.sessions.create({
+    mode: 'subscription',
+    payment_method_types: ['card'],
+    line_items: [{ price: priceId, quantity: 1 }],
+    success_url: \`\${process.env.APP_URL}${successUrl}?session_id={CHECKOUT_SESSION_ID}\`,
+    cancel_url: \`\${process.env.APP_URL}${cancelUrl}\`,
+    ...(customerId && { customer: customerId }),
+  });
+
+  return session;
+}
+`
+    },
+    {
+      path: `stripe/webhook${ext}`,
+      description: "Stripe webhook event handler",
+      content: `import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET!;
+
+export function handleWebhookEvent(body${ts2 ? ": string" : ""}, signature${ts2 ? ": string" : ""}) {
+  const event = stripe.webhooks.constructEvent(body, signature, webhookSecret);
+
+  switch (event.type) {
+${events.map((e) => `    case '${e}':
+      console.log('${e}:', event.data.object);
+      // TODO: Handle ${e}
+      break;`).join("\n")}
+    default:
+      console.log('Unhandled event type:', event.type);
+  }
+
+  return event;
+}
+`
+    },
+    {
+      path: `stripe/portal${ext}`,
+      description: "Stripe Customer Portal session creation function",
+      content: `import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+
+export async function createPortalSession(customerId${ts2 ? ": string" : ""}) {
+  const session = await stripe.billingPortal.sessions.create({
+    customer: customerId,
+    return_url: \`\${process.env.APP_URL}/account\`,
+  });
+
+  return session;
+}
+`
+    }
+  ];
+}
+
+// scripts/lib/payments/env-manager.ts
+var fs9 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
+function readEnvFile(projectPath) {
+  const envPath = path7.join(projectPath, ".env");
+  if (!fs9.existsSync(envPath)) {
+    return {};
+  }
+  const content = fs9.readFileSync(envPath, "utf-8");
+  const vars = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    vars[key] = value;
+  }
+  return vars;
+}
+function writeEnvVars(projectPath, vars) {
+  const envPath = path7.join(projectPath, ".env");
+  const existing = readEnvFile(projectPath);
+  const added = [];
+  const lines = [];
+  for (const [key, value] of Object.entries(vars)) {
+    if (existing[key]) continue;
+    lines.push(`${key}=${value}`);
+    added.push(key);
+  }
+  if (lines.length === 0) return added;
+  const prefix = fs9.existsSync(envPath) ? "\n" : "";
+  const content = prefix + lines.join("\n") + "\n";
+  fs9.appendFileSync(envPath, content);
+  return added;
+}
+function ensureGitignore(projectPath) {
+  const gitignorePath = path7.join(projectPath, ".gitignore");
+  let content = "";
+  let modified = false;
+  if (fs9.existsSync(gitignorePath)) {
+    content = fs9.readFileSync(gitignorePath, "utf-8");
+  }
+  const lines = content.split("\n").map((l2) => l2.trim());
+  if (!lines.includes(".env")) {
+    const suffix = content.endsWith("\n") || content === "" ? "" : "\n";
+    fs9.appendFileSync(gitignorePath, `${suffix}.env
+`);
+    modified = true;
+  }
+  return modified;
+}
+
+// scripts/skills/payments.ts
+var EMPTY_STATE = {
+  last_updated: (/* @__PURE__ */ new Date()).toISOString(),
+  integration_status: {
+    sdk_installed: false,
+    api_key_valid: false,
+    products_created: false,
+    checkout_endpoint: false,
+    webhook_endpoint: false,
+    portal_endpoint: false
+  },
+  framework: null,
+  products: [],
+  generated_files: []
+};
+var PAYMENTS_PREFIXES = [
+  "payments-setup-stripe",
+  "payments-add-checkout",
+  "payments-add-webhook",
+  "payments-add-portal",
+  "payments-check-status"
+];
+function isPaymentsTask(taskId) {
+  return PAYMENTS_PREFIXES.some((prefix) => taskId.startsWith(prefix));
+}
+async function executePaymentsTask(taskId, description, _businessContext) {
+  try {
+    switch (taskId) {
+      case "payments-setup-stripe":
+        return await executeFullSetup();
+      case "payments-add-checkout":
+        return await executeAddEndpoint("checkout");
+      case "payments-add-webhook":
+        return await executeAddEndpoint("webhook");
+      case "payments-add-portal":
+        return await executeAddEndpoint("portal");
+      case "payments-check-status":
+        return await executeCheckStatus();
+      default:
+        return { success: false, output: `Unknown payments task: ${taskId}` };
+    }
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    return { success: false, output: `Payments task failed: ${errMsg}` };
+  }
+}
+function readPaymentsFreshness() {
+  const result = {
+    configured: false,
+    completeness: 0,
+    missing: []
+  };
+  if (!fs10.existsSync(PAYMENTS_FILE)) {
+    result.missing = ["sdk", "api_key", "products", "checkout", "webhook", "portal"];
+    return result;
+  }
+  try {
+    const state = JSON.parse(fs10.readFileSync(PAYMENTS_FILE, "utf-8"));
+    const status = state.integration_status;
+    const fields = Object.entries(status);
+    const completed = fields.filter(([, v2]) => v2).length;
+    result.configured = completed > 0;
+    result.completeness = Math.round(completed / fields.length * 100);
+    if (!status.sdk_installed) result.missing.push("sdk");
+    if (!status.api_key_valid) result.missing.push("api_key");
+    if (!status.products_created) result.missing.push("products");
+    if (!status.checkout_endpoint) result.missing.push("checkout");
+    if (!status.webhook_endpoint) result.missing.push("webhook");
+    if (!status.portal_endpoint) result.missing.push("portal");
+  } catch {
+    result.missing = ["sdk", "api_key", "products", "checkout", "webhook", "portal"];
+  }
+  return result;
+}
+function loadState() {
+  if (!fs10.existsSync(PAYMENTS_FILE)) {
+    return { ...EMPTY_STATE };
+  }
+  try {
+    return JSON.parse(fs10.readFileSync(PAYMENTS_FILE, "utf-8"));
+  } catch {
+    return { ...EMPTY_STATE };
+  }
+}
+function saveState(state) {
+  state.last_updated = (/* @__PURE__ */ new Date()).toISOString();
+  const dir = path8.dirname(PAYMENTS_FILE);
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, { recursive: true });
+  }
+  fs10.writeFileSync(PAYMENTS_FILE, JSON.stringify(state, null, 2) + "\n");
+}
+function getUserProjectPath() {
+  const configPath = path8.join(PROJECT_DIR, "data", "config.json");
+  if (fs10.existsSync(configPath)) {
+    try {
+      const config = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
+      if (config.repos?.[0]?.path) {
+        const repoPath = config.repos[0].path;
+        if (fs10.existsSync(repoPath)) {
+          return repoPath;
+        }
+      }
+    } catch {
+    }
+  }
+  return PROJECT_DIR;
+}
+function isStripeInstalled(projectPath) {
+  try {
+    require.resolve("stripe", { paths: [projectPath] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function installStripe(projectPath) {
+  try {
+    (0, import_child_process4.execSync)("npm install stripe", {
+      cwd: projectPath,
+      encoding: "utf-8",
+      timeout: 6e4,
+      stdio: "pipe"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writeGeneratedFile(projectPath, file) {
+  const fullPath = path8.join(projectPath, file.path);
+  if (fs10.existsSync(fullPath)) {
+    return false;
+  }
+  const dir = path8.dirname(fullPath);
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, { recursive: true });
+  }
+  fs10.writeFileSync(fullPath, file.content);
+  return true;
+}
+async function executeFullSetup() {
+  const lines = ["## Stripe Integration Setup\n"];
+  const state = loadState();
+  const projectPath = getUserProjectPath();
+  lines.push("### Step 1: Framework Detection");
+  const frameworkInfo = detectFramework(projectPath);
+  state.framework = frameworkInfo;
+  lines.push(`- Framework: ${frameworkInfo.framework}`);
+  lines.push(`- TypeScript: ${frameworkInfo.typescript}`);
+  lines.push(`- App Router: ${frameworkInfo.appRouter}`);
+  lines.push(`- Src directory: ${frameworkInfo.srcDir}`);
+  lines.push("");
+  lines.push("### Step 2: Stripe SDK");
+  if (isStripeInstalled(projectPath)) {
+    lines.push("- Stripe SDK: already installed");
+    state.integration_status.sdk_installed = true;
+  } else {
+    lines.push("- Installing stripe...");
+    if (installStripe(projectPath)) {
+      lines.push("- Stripe SDK: installed successfully");
+      state.integration_status.sdk_installed = true;
+    } else {
+      lines.push("- Failed to install stripe. Run manually: npm install stripe");
+      saveState(state);
+      return { success: false, output: lines.join("\n") };
+    }
+  }
+  lines.push("");
+  lines.push("### Step 3: API Key Validation");
+  const envVars = readEnvFile(projectPath);
+  const secretKey = envVars["STRIPE_SECRET_KEY"] || process.env.STRIPE_SECRET_KEY;
+  if (!secretKey) {
+    lines.push("- STRIPE_SECRET_KEY not found in .env or environment.");
+    lines.push("- Add it to your .env file: STRIPE_SECRET_KEY=sk_test_...");
+    lines.push("- Get your key from: https://dashboard.stripe.com/apikeys");
+    state.integration_status.api_key_valid = false;
+    saveState(state);
+    return { success: false, output: lines.join("\n") };
+  }
+  const stripe = createStripeClient(secretKey, projectPath);
+  const validation = await validateApiKey(stripe);
+  if (!validation.valid) {
+    lines.push(`- API key invalid: ${validation.error}`);
+    lines.push("- Check your STRIPE_SECRET_KEY and try again.");
+    state.integration_status.api_key_valid = false;
+    saveState(state);
+    return { success: false, output: lines.join("\n") };
+  }
+  lines.push(`- API key valid (account: ${validation.accountName})`);
+  state.integration_status.api_key_valid = true;
+  lines.push("");
+  lines.push("### Step 4: Products");
+  const existing = await findExistingProducts(stripe, "Pro");
+  if (existing.length > 0) {
+    lines.push(`- Found ${existing.length} existing product(s): ${existing.map((p) => p.name).join(", ")}`);
+    state.integration_status.products_created = true;
+    state.products = existing.map((p) => ({
+      name: p.name,
+      stripe_product_id: p.id,
+      stripe_price_id: null,
+      amount_cents: null,
+      currency: "usd",
+      interval: null
+    }));
+  } else {
+    lines.push("- No existing products found. Creating default product...");
+    try {
+      const product = await createProduct(stripe, {
+        name: "Pro Plan",
+        description: "Pro subscription plan"
+      });
+      const price = await createPrice(stripe, {
+        productId: product.id,
+        unitAmount: 2900,
+        currency: "usd",
+        interval: "month"
+      });
+      lines.push(`- Created product: ${product.name} (${product.id})`);
+      lines.push(`- Created price: $29/mo (${price.id})`);
+      state.integration_status.products_created = true;
+      state.products = [{
+        name: product.name,
+        stripe_product_id: product.id,
+        stripe_price_id: price.id,
+        amount_cents: 2900,
+        currency: "usd",
+        interval: "month"
+      }];
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      lines.push(`- Failed to create products: ${msg}`);
+    }
+  }
+  lines.push("");
+  lines.push("### Step 5: Code Generation");
+  const templates = getTemplatesForFramework(frameworkInfo);
+  const written = [];
+  const skipped = [];
+  for (const template of templates) {
+    if (writeGeneratedFile(projectPath, template)) {
+      written.push(template.path);
+      lines.push(`- Created: ${template.path} (${template.description})`);
+    } else {
+      skipped.push(template.path);
+      lines.push(`- Skipped: ${template.path} (already exists)`);
+    }
+  }
+  state.generated_files = Array.from(/* @__PURE__ */ new Set([...state.generated_files, ...written]));
+  const allPaths = templates.map((t) => t.path);
+  const checkoutFiles = allPaths.filter((p) => p.includes("checkout"));
+  const webhookFiles = allPaths.filter((p) => p.includes("webhook"));
+  const portalFiles = allPaths.filter((p) => p.includes("portal"));
+  state.integration_status.checkout_endpoint = checkoutFiles.some((f) => written.includes(f) || skipped.includes(f));
+  state.integration_status.webhook_endpoint = webhookFiles.some((f) => written.includes(f) || skipped.includes(f));
+  state.integration_status.portal_endpoint = portalFiles.some((f) => written.includes(f) || skipped.includes(f));
+  lines.push("");
+  lines.push("### Step 6: Environment Variables");
+  const addedVars = writeEnvVars(projectPath, {
+    STRIPE_SECRET_KEY: secretKey,
+    STRIPE_WEBHOOK_SECRET: "whsec_... # Replace with your webhook secret from Stripe Dashboard"
+  });
+  if (addedVars.length > 0) {
+    lines.push(`- Added to .env: ${addedVars.join(", ")}`);
+  } else {
+    lines.push("- All required env vars already present");
+  }
+  const gitignoreModified = ensureGitignore(projectPath);
+  if (gitignoreModified) {
+    lines.push("- Added .env to .gitignore");
+  }
+  lines.push("");
+  saveState(state);
+  const status = state.integration_status;
+  const completed = Object.values(status).filter(Boolean).length;
+  const total = Object.values(status).length;
+  lines.push(`### Summary: ${completed}/${total} steps complete (${Math.round(completed / total * 100)}%)`);
+  if (completed < total) {
+    const missing = Object.entries(status).filter(([, v2]) => !v2).map(([k]) => k);
+    lines.push(`Missing: ${missing.join(", ")}`);
+  }
+  return { success: true, output: lines.join("\n") };
+}
+async function executeAddEndpoint(type) {
+  const lines = [`## Add Stripe ${type} endpoint
+`];
+  const state = loadState();
+  const projectPath = getUserProjectPath();
+  const frameworkInfo = state.framework || detectFramework(projectPath);
+  state.framework = frameworkInfo;
+  const templates = getTemplatesForFramework(frameworkInfo);
+  const matching = templates.filter((t) => t.path.includes(type));
+  if (matching.length === 0) {
+    return { success: false, output: `No ${type} template found for framework: ${frameworkInfo.framework}` };
+  }
+  for (const template of matching) {
+    if (writeGeneratedFile(projectPath, template)) {
+      lines.push(`Created: ${template.path} \u2014 ${template.description}`);
+      state.generated_files = Array.from(/* @__PURE__ */ new Set([...state.generated_files, template.path]));
+    } else {
+      lines.push(`Skipped: ${template.path} \u2014 file already exists`);
+    }
+  }
+  const statusKey = `${type}_endpoint`;
+  state.integration_status[statusKey] = true;
+  saveState(state);
+  return { success: true, output: lines.join("\n") };
+}
+async function executeCheckStatus() {
+  const lines = ["## Stripe Integration Status\n"];
+  const state = loadState();
+  const projectPath = getUserProjectPath();
+  const sdkInstalled = isStripeInstalled(projectPath);
+  state.integration_status.sdk_installed = sdkInstalled;
+  lines.push(`- SDK installed: ${sdkInstalled ? "yes" : "no"}`);
+  const envVars = readEnvFile(projectPath);
+  const secretKey = envVars["STRIPE_SECRET_KEY"] || process.env.STRIPE_SECRET_KEY;
+  if (secretKey && sdkInstalled) {
+    try {
+      const stripe = createStripeClient(secretKey, projectPath);
+      const validation = await validateApiKey(stripe);
+      state.integration_status.api_key_valid = validation.valid;
+      lines.push(`- API key: ${validation.valid ? `valid (${validation.accountName})` : `invalid (${validation.error})`}`);
+      if (validation.valid) {
+        const products = await findExistingProducts(stripe, "");
+        state.integration_status.products_created = products.length > 0;
+        lines.push(`- Products: ${products.length} found`);
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      lines.push(`- API key check failed: ${msg}`);
+    }
+  } else {
+    state.integration_status.api_key_valid = false;
+    lines.push(`- API key: ${secretKey ? "present but SDK not installed" : "not found"}`);
+  }
+  const hasWebhookSecret = !!(envVars["STRIPE_WEBHOOK_SECRET"] || process.env.STRIPE_WEBHOOK_SECRET);
+  lines.push(`- Webhook secret: ${hasWebhookSecret ? "configured" : "not set"}`);
+  const framework = state.framework || detectFramework(projectPath);
+  const templates = getTemplatesForFramework(framework);
+  for (const template of templates) {
+    const exists = fs10.existsSync(path8.join(projectPath, template.path));
+    const type = template.path.includes("checkout") ? "checkout" : template.path.includes("webhook") ? "webhook" : template.path.includes("portal") ? "portal" : null;
+    if (type) {
+      const statusKey = `${type}_endpoint`;
+      state.integration_status[statusKey] = exists;
+    }
+    lines.push(`- ${template.path}: ${exists ? "exists" : "missing"}`);
+  }
+  lines.push("");
+  const status = state.integration_status;
+  const completed = Object.values(status).filter(Boolean).length;
+  const total = Object.values(status).length;
+  lines.push(`**Completeness: ${completed}/${total} (${Math.round(completed / total * 100)}%)**`);
+  saveState(state);
+  return { success: true, output: lines.join("\n") };
+}
+
+// scripts/lib/run.ts
+var path9 = __toESM(require("path"));
 function resolveScript(baseDir, scriptName) {
-  const isCompiled = path5.extname(__filename) === ".js";
+  const isCompiled = path9.extname(__filename) === ".js";
   const resolvedName = isCompiled ? scriptName.replace(/\.ts$/, ".js") : scriptName;
-  const scriptPath = path5.join(baseDir, resolvedName);
+  const scriptPath = path9.join(baseDir, resolvedName);
   return isCompiled ? { command: "node", args: [scriptPath] } : { command: "npx", args: ["tsx", scriptPath] };
 }
 
@@ -20765,8 +22187,8 @@ function groupTasksByConflicts(tasks) {
 }
 
 // scripts/lib/json-lock.ts
-var fs7 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
 var DEFAULT_MAX_WAIT_MS = 1e4;
 var BASE_BACKOFF_MS = 50;
 var MAX_BACKOFF_MS = 150;
@@ -20774,10 +22196,10 @@ function withFileLock(lockPath, fn, maxWaitMs = DEFAULT_MAX_WAIT_MS) {
   const startTime = Date.now();
   while (true) {
     try {
-      fs7.mkdirSync(lockPath, { recursive: false });
+      fs11.mkdirSync(lockPath, { recursive: false });
       try {
-        fs7.writeFileSync(
-          path6.join(lockPath, "owner"),
+        fs11.writeFileSync(
+          path10.join(lockPath, "owner"),
           JSON.stringify({ pid: process.pid, acquired: Date.now() })
         );
       } catch {
@@ -20806,16 +22228,16 @@ function withFileLock(lockPath, fn, maxWaitMs = DEFAULT_MAX_WAIT_MS) {
 }
 function atomicWriteFileSync(filePath, content) {
   const tmpPath = `${filePath}.${process.pid}.tmp`;
-  fs7.writeFileSync(tmpPath, content, "utf-8");
-  fs7.renameSync(tmpPath, filePath);
+  fs11.writeFileSync(tmpPath, content, "utf-8");
+  fs11.renameSync(tmpPath, filePath);
 }
 function releaseLock(lockPath) {
   try {
-    const ownerFile = path6.join(lockPath, "owner");
-    if (fs7.existsSync(ownerFile)) {
-      fs7.unlinkSync(ownerFile);
+    const ownerFile = path10.join(lockPath, "owner");
+    if (fs11.existsSync(ownerFile)) {
+      fs11.unlinkSync(ownerFile);
     }
-    fs7.rmdirSync(lockPath);
+    fs11.rmdirSync(lockPath);
   } catch {
   }
 }
@@ -20826,57 +22248,57 @@ function sleepSync(ms2) {
 }
 
 // scripts/lib/worktree.ts
-var fs9 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
 
 // scripts/lib/git-utils.ts
-var import_child_process3 = require("child_process");
-var fs8 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
+var import_child_process5 = require("child_process");
+var fs12 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
 function cleanGitState(workspacePath) {
-  if (!fs8.existsSync(workspacePath)) return;
-  const gitDir = path7.join(workspacePath, ".git");
-  if (!fs8.existsSync(gitDir)) return;
+  if (!fs12.existsSync(workspacePath)) return;
+  const gitDir = path11.join(workspacePath, ".git");
+  if (!fs12.existsSync(gitDir)) return;
   let actualGitDir = gitDir;
   try {
-    const stat = fs8.statSync(gitDir);
+    const stat = fs12.statSync(gitDir);
     if (stat.isFile()) {
-      const content = fs8.readFileSync(gitDir, "utf-8").trim();
+      const content = fs12.readFileSync(gitDir, "utf-8").trim();
       const match = content.match(/^gitdir:\s+(.+)$/);
       if (match) actualGitDir = match[1];
     }
   } catch {
     return;
   }
-  const lockFile = path7.join(actualGitDir, "index.lock");
-  if (fs8.existsSync(lockFile)) {
+  const lockFile = path11.join(actualGitDir, "index.lock");
+  if (fs12.existsSync(lockFile)) {
     try {
-      const result = (0, import_child_process3.execSync)(
+      const result = (0, import_child_process5.execSync)(
         `lsof "${lockFile}" 2>/dev/null || true`,
         { encoding: "utf-8", timeout: 5e3 }
       ).trim();
       if (!result) {
-        fs8.unlinkSync(lockFile);
+        fs12.unlinkSync(lockFile);
         console.log(`[pre-flight] Removed stale .git/index.lock in ${workspacePath}`);
       }
     } catch {
       try {
-        fs8.unlinkSync(lockFile);
+        fs12.unlinkSync(lockFile);
         console.log(`[pre-flight] Removed stale .git/index.lock in ${workspacePath}`);
       } catch {
       }
     }
   }
   const staleOps = [
-    { marker: path7.join(actualGitDir, "MERGE_HEAD"), abort: "git merge --abort" },
-    { marker: path7.join(actualGitDir, "rebase-merge"), abort: "git rebase --abort" },
-    { marker: path7.join(actualGitDir, "rebase-apply"), abort: "git rebase --abort" },
-    { marker: path7.join(actualGitDir, "CHERRY_PICK_HEAD"), abort: "git cherry-pick --abort" }
+    { marker: path11.join(actualGitDir, "MERGE_HEAD"), abort: "git merge --abort" },
+    { marker: path11.join(actualGitDir, "rebase-merge"), abort: "git rebase --abort" },
+    { marker: path11.join(actualGitDir, "rebase-apply"), abort: "git rebase --abort" },
+    { marker: path11.join(actualGitDir, "CHERRY_PICK_HEAD"), abort: "git cherry-pick --abort" }
   ];
   for (const { marker, abort } of staleOps) {
-    if (fs8.existsSync(marker)) {
+    if (fs12.existsSync(marker)) {
       try {
-        (0, import_child_process3.execSync)(abort, { cwd: workspacePath, encoding: "utf-8", timeout: 1e4, stdio: "pipe" });
+        (0, import_child_process5.execSync)(abort, { cwd: workspacePath, encoding: "utf-8", timeout: 1e4, stdio: "pipe" });
         console.log(`[pre-flight] Aborted stale operation: ${abort} in ${workspacePath}`);
       } catch {
       }
@@ -20885,7 +22307,7 @@ function cleanGitState(workspacePath) {
 }
 function exec2(cmd, cwd, timeoutMs) {
   try {
-    return (0, import_child_process3.execSync)(cmd, {
+    return (0, import_child_process5.execSync)(cmd, {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
@@ -20901,8 +22323,8 @@ ${execError.stderr || execError.message}`);
 // scripts/lib/worktree.ts
 function getWorktreePaths(workspaceDir, repoName) {
   return {
-    baseClonePath: path8.join(workspaceDir, repoName),
-    worktreeContainerDir: path8.join(workspaceDir, `${repoName}-worktrees`)
+    baseClonePath: path12.join(workspaceDir, repoName),
+    worktreeContainerDir: path12.join(workspaceDir, `${repoName}-worktrees`)
   };
 }
 function syncBaseClone(baseClonePath, defaultBranch) {
@@ -20921,16 +22343,16 @@ function ensureIdeaBranch(baseClonePath, branchName, defaultBranch) {
   }
 }
 function createWorktree(baseClonePath, worktreeContainerDir, ideaBranch, groupIndex) {
-  if (!fs9.existsSync(worktreeContainerDir)) {
-    fs9.mkdirSync(worktreeContainerDir, { recursive: true });
+  if (!fs13.existsSync(worktreeContainerDir)) {
+    fs13.mkdirSync(worktreeContainerDir, { recursive: true });
   }
   const tempBranch = `wt/${ideaBranch}-g${groupIndex}`;
-  const worktreePath = path8.join(worktreeContainerDir, `${ideaBranch}-g${groupIndex}`);
-  if (fs9.existsSync(worktreePath)) {
+  const worktreePath = path12.join(worktreeContainerDir, `${ideaBranch}-g${groupIndex}`);
+  if (fs13.existsSync(worktreePath)) {
     try {
       exec2(`git worktree remove --force "${worktreePath}"`, baseClonePath, 1e4);
     } catch {
-      fs9.rmSync(worktreePath, { recursive: true, force: true });
+      fs13.rmSync(worktreePath, { recursive: true, force: true });
     }
   }
   try {
@@ -20964,7 +22386,7 @@ function removeWorktree(baseClonePath, worktreePath, tempBranch) {
     exec2(`git worktree remove --force "${worktreePath}"`, baseClonePath, 1e4);
   } catch {
     try {
-      fs9.rmSync(worktreePath, { recursive: true, force: true });
+      fs13.rmSync(worktreePath, { recursive: true, force: true });
     } catch {
     }
   }
@@ -20974,12 +22396,12 @@ function removeWorktree(baseClonePath, worktreePath, tempBranch) {
   }
 }
 function cleanupIdeaWorktrees(baseClonePath, worktreeContainerDir, ideaBranch) {
-  if (fs9.existsSync(worktreeContainerDir)) {
+  if (fs13.existsSync(worktreeContainerDir)) {
     try {
-      const entries = fs9.readdirSync(worktreeContainerDir);
+      const entries = fs13.readdirSync(worktreeContainerDir);
       for (const entry of entries) {
         if (entry.startsWith(`${ideaBranch}-g`)) {
-          const wtPath = path8.join(worktreeContainerDir, entry);
+          const wtPath = path12.join(worktreeContainerDir, entry);
           const groupMatch = entry.match(/-g(\d+)$/);
           const tempBranch = `wt/${ideaBranch}-g${groupMatch?.[1] ?? "0"}`;
           removeWorktree(baseClonePath, wtPath, tempBranch);
@@ -20993,9 +22415,9 @@ function cleanupIdeaWorktrees(baseClonePath, worktreeContainerDir, ideaBranch) {
   } catch {
   }
   try {
-    const remaining = fs9.readdirSync(worktreeContainerDir);
+    const remaining = fs13.readdirSync(worktreeContainerDir);
     if (remaining.length === 0) {
-      fs9.rmdirSync(worktreeContainerDir);
+      fs13.rmdirSync(worktreeContainerDir);
     }
   } catch {
   }
@@ -21005,24 +22427,24 @@ function getTempBranchName(ideaBranch, groupIndex) {
 }
 
 // scripts/lib/telemetry.ts
-var fs10 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
-var CONFIG_DIR = path9.join(
+var fs14 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
+var CONFIG_DIR = path13.join(
   process.env.HOME || process.env.USERPROFILE || "~",
   ".vibebusiness"
 );
-var TELEMETRY_CONFIG_FILE = path9.join(CONFIG_DIR, "telemetry.json");
-var EVENTS_FILE = path9.join(CONFIG_DIR, "events.jsonl");
+var TELEMETRY_CONFIG_FILE = path13.join(CONFIG_DIR, "telemetry.json");
+var EVENTS_FILE = path13.join(CONFIG_DIR, "events.jsonl");
 function getVersion() {
   try {
     let dir = __dirname;
     for (let i = 0; i < 4; i++) {
-      const pkgPath = path9.join(dir, "package.json");
-      if (fs10.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
+      const pkgPath = path13.join(dir, "package.json");
+      if (fs14.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
         return pkg.version || "0.0.0";
       }
-      dir = path9.dirname(dir);
+      dir = path13.dirname(dir);
     }
   } catch {
   }
@@ -21030,8 +22452,8 @@ function getVersion() {
 }
 function getTelemetryConfig() {
   try {
-    if (!fs10.existsSync(TELEMETRY_CONFIG_FILE)) return null;
-    return JSON.parse(fs10.readFileSync(TELEMETRY_CONFIG_FILE, "utf-8"));
+    if (!fs14.existsSync(TELEMETRY_CONFIG_FILE)) return null;
+    return JSON.parse(fs14.readFileSync(TELEMETRY_CONFIG_FILE, "utf-8"));
   } catch {
     return null;
   }
@@ -21052,8 +22474,8 @@ function trackEvent(event, properties = {}) {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       version: getVersion()
     };
-    fs10.mkdirSync(CONFIG_DIR, { recursive: true });
-    fs10.appendFileSync(EVENTS_FILE, JSON.stringify(entry) + "\n");
+    fs14.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs14.appendFileSync(EVENTS_FILE, JSON.stringify(entry) + "\n");
   } catch {
   }
 }
@@ -21333,22 +22755,22 @@ async function suggestEpics(opts) {
 }
 
 // scripts/lib/scaffold.ts
-var fs12 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
 function scaffoldSlashCommands(rootDir) {
-  let templatesDir = path11.join(__dirname, "..", "..", "templates", "commands");
-  if (!fs12.existsSync(templatesDir)) {
-    templatesDir = path11.join(__dirname, "..", "..", "..", "templates", "commands");
-  }
-  if (!fs12.existsSync(templatesDir)) return;
-  const targetDir = path11.join(rootDir, ".claude", "commands");
-  fs12.mkdirSync(targetDir, { recursive: true });
-  const templates = fs12.readdirSync(templatesDir).filter((f) => f.endsWith(".md"));
+  let templatesDir = path15.join(__dirname, "..", "..", "templates", "commands");
+  if (!fs16.existsSync(templatesDir)) {
+    templatesDir = path15.join(__dirname, "..", "..", "..", "templates", "commands");
+  }
+  if (!fs16.existsSync(templatesDir)) return;
+  const targetDir = path15.join(rootDir, ".claude", "commands");
+  fs16.mkdirSync(targetDir, { recursive: true });
+  const templates = fs16.readdirSync(templatesDir).filter((f) => f.endsWith(".md"));
   let copied = 0;
   for (const file of templates) {
-    const src = path11.join(templatesDir, file);
-    const dest = path11.join(targetDir, file);
-    fs12.copyFileSync(src, dest);
+    const src = path15.join(templatesDir, file);
+    const dest = path15.join(targetDir, file);
+    fs16.copyFileSync(src, dest);
     copied++;
   }
   if (copied > 0) {
@@ -21357,23 +22779,23 @@ function scaffoldSlashCommands(rootDir) {
 }
 
 // scripts/lib/vibe-credits.ts
-var fs13 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs17 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 var WORKER_URL = "https://vibe-credits.luis-e13.workers.dev";
-var CONFIG_DIR2 = path12.join(process.env.HOME || "", ".vibebusiness");
-var BUFFER_FILE = path12.join(CONFIG_DIR2, "vibe-buffer.json");
+var CONFIG_DIR2 = path16.join(process.env.HOME || "", ".vibebusiness");
+var BUFFER_FILE = path16.join(CONFIG_DIR2, "vibe-buffer.json");
 var MAX_BUFFER = 5;
 var REQUEST_TIMEOUT_MS = 5e3;
 function getClientVersion() {
   try {
     let dir = __dirname;
     for (let i = 0; i < 4; i++) {
-      const pkgPath = path12.join(dir, "package.json");
-      if (fs13.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs13.readFileSync(pkgPath, "utf-8"));
+      const pkgPath = path16.join(dir, "package.json");
+      if (fs17.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs17.readFileSync(pkgPath, "utf-8"));
         return pkg.version || "0.0.0";
       }
-      dir = path12.dirname(dir);
+      dir = path16.dirname(dir);
     }
   } catch {
   }
@@ -21382,18 +22804,18 @@ function getClientVersion() {
 var CLIENT_VERSION = getClientVersion();
 function loadBuffer() {
   try {
-    if (fs13.existsSync(BUFFER_FILE)) {
-      return JSON.parse(fs13.readFileSync(BUFFER_FILE, "utf-8"));
+    if (fs17.existsSync(BUFFER_FILE)) {
+      return JSON.parse(fs17.readFileSync(BUFFER_FILE, "utf-8"));
     }
   } catch {
   }
   return { vibes: 0, last_synced: "" };
 }
 function saveBuffer(buffer) {
-  if (!fs13.existsSync(CONFIG_DIR2)) {
-    fs13.mkdirSync(CONFIG_DIR2, { recursive: true });
+  if (!fs17.existsSync(CONFIG_DIR2)) {
+    fs17.mkdirSync(CONFIG_DIR2, { recursive: true });
   }
-  fs13.writeFileSync(BUFFER_FILE, JSON.stringify(buffer, null, 2));
+  fs17.writeFileSync(BUFFER_FILE, JSON.stringify(buffer, null, 2));
 }
 function syncBuffer(vibesRemaining) {
   const buffered = Math.min(vibesRemaining, MAX_BUFFER);
@@ -21467,14 +22889,14 @@ async function consumeVibe(instanceId) {
 }
 
 // scripts/lib/license.ts
-var fs14 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
-var CONFIG_DIR3 = path13.join(process.env.HOME || "", ".vibebusiness");
-var LICENSE_FILE = path13.join(CONFIG_DIR3, "license.json");
+var fs18 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
+var CONFIG_DIR3 = path17.join(process.env.HOME || "", ".vibebusiness");
+var LICENSE_FILE = path17.join(CONFIG_DIR3, "license.json");
 function loadStoredLicense() {
   try {
-    if (fs14.existsSync(LICENSE_FILE)) {
-      return JSON.parse(fs14.readFileSync(LICENSE_FILE, "utf-8"));
+    if (fs18.existsSync(LICENSE_FILE)) {
+      return JSON.parse(fs18.readFileSync(LICENSE_FILE, "utf-8"));
     }
   } catch {
   }
@@ -21494,10 +22916,10 @@ function getInstanceId() {
 
 // scripts/heartbeat.ts
 var ROOT_DIR = PROJECT_DIR;
-var execAsync = (0, import_util.promisify)(import_child_process4.exec);
+var execAsync = (0, import_util.promisify)(import_child_process6.exec);
 function spawnAsync(cmd, args2, options) {
   return new Promise((resolve, reject) => {
-    const child = (0, import_child_process4.spawn)(cmd, args2, {
+    const child = (0, import_child_process6.spawn)(cmd, args2, {
       cwd: options.cwd,
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -21601,7 +23023,7 @@ function sleep(ms2) {
 }
 function loadJson(filePath, defaultValue) {
   try {
-    const content = fs15.readFileSync(filePath, "utf-8");
+    const content = fs19.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return defaultValue;
@@ -21660,7 +23082,7 @@ function isMetaTaskFalseCompletion(output) {
 }
 function reclassifyAsHumanDependent(taskId) {
   try {
-    let content = fs15.readFileSync(TODO_FILE, "utf-8");
+    let content = fs19.readFileSync(TODO_FILE, "utf-8");
     const taskPattern = new RegExp(`^- \\[[ x]\\] \`${taskId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\`.*$`, "m");
     const match = content.match(taskPattern);
     if (!match) return;
@@ -21673,7 +23095,7 @@ function reclassifyAsHumanDependent(taskId) {
       const insertIndex = content.indexOf("\n", blockedIndex) + 1;
       content = content.slice(0, insertIndex) + "\n" + uncheckedLine + content.slice(insertIndex);
     }
-    fs15.writeFileSync(TODO_FILE, content);
+    fs19.writeFileSync(TODO_FILE, content);
     log(`Reclassified task ${taskId} as human-dependent (moved to Blocked)`);
   } catch (error) {
     log(`Failed to reclassify task: ${error instanceof Error ? error.message : "Unknown"}`);
@@ -21681,7 +23103,7 @@ function reclassifyAsHumanDependent(taskId) {
 }
 function parseTodoFile() {
   try {
-    const content = fs15.readFileSync(TODO_FILE, "utf-8");
+    const content = fs19.readFileSync(TODO_FILE, "utf-8");
     const tasks = [];
     let currentSection = "high_priority";
     const lines = content.split("\n");
@@ -21712,7 +23134,7 @@ function parseTodoFile() {
     return [];
   }
 }
-function loadState() {
+function loadState2() {
   const ideasData = loadJson(IDEAS_FILE, { ideas: [] });
   const goalsData = loadJson(GOALS_FILE, { goals: [] });
   const sessionsData = loadJson(SESSIONS_FILE, { sessions: [] });
@@ -21845,10 +23267,10 @@ function captureGitDiffInfo(workspacePath) {
     has_uncommitted_changes: false
   };
   try {
-    const status = (0, import_child_process4.execSync)("git status --porcelain", { cwd: workspacePath, encoding: "utf-8" });
+    const status = (0, import_child_process6.execSync)("git status --porcelain", { cwd: workspacePath, encoding: "utf-8" });
     result.has_uncommitted_changes = status.trim().length > 0;
     try {
-      const diffStat = (0, import_child_process4.execSync)("git diff --stat HEAD~1 HEAD 2>/dev/null || git diff --stat --cached 2>/dev/null || git diff --stat 2>/dev/null", {
+      const diffStat = (0, import_child_process6.execSync)("git diff --stat HEAD~1 HEAD 2>/dev/null || git diff --stat --cached 2>/dev/null || git diff --stat 2>/dev/null", {
         cwd: workspacePath,
         encoding: "utf-8",
         shell: "/bin/bash"
@@ -22139,10 +23561,10 @@ function updateGoalsWithKPIs(kpis) {
   log("Updated goals.json with live KPIs");
 }
 function loadCodebaseSnapshot() {
-  const snapshotPath = path14.join(DATA_DIR, "codebase-snapshot.json");
+  const snapshotPath = path18.join(DATA_DIR, "codebase-snapshot.json");
   try {
-    if (fs15.existsSync(snapshotPath)) {
-      return JSON.parse(fs15.readFileSync(snapshotPath, "utf-8"));
+    if (fs19.existsSync(snapshotPath)) {
+      return JSON.parse(fs19.readFileSync(snapshotPath, "utf-8"));
     }
   } catch {
   }
@@ -22296,7 +23718,8 @@ function buildContextForClaude(state, alerts, businessContext) {
       date: s.completed_at || s.created_at,
       ideas_generated: s.ideas_generated.length
     })),
-    business_intelligence: readBusinessIntelFreshness()
+    business_intelligence: readBusinessIntelFreshness(),
+    payments: readPaymentsFreshness()
   };
 }
 function buildBusinessConstraints(businessContext) {
@@ -22460,6 +23883,23 @@ When to recommend BI tasks:
 5. If business_intelligence.pages.livePagesWithoutMetrics > 0 \u2192 suggest "measure-page-{id}"
 6. These form a natural chain: research competitors \u2192 develop positioning \u2192 generate copy \u2192 build pages \u2192 measure results
 
+PAYMENTS TASKS:
+The "payments" field in CURRENT STATE shows Stripe integration completeness.
+These tasks run directly (no Claude Code delegation) for fast execution.
+
+Task prefixes:
+- "payments-setup-stripe" \u2192 Full wizard: detect framework \u2192 install SDK \u2192 validate key \u2192 create products \u2192 generate code \u2192 update .env
+- "payments-add-checkout" \u2192 Generate only checkout session endpoint
+- "payments-add-webhook" \u2192 Generate only webhook handler
+- "payments-add-portal" \u2192 Generate only customer portal redirect
+- "payments-check-status" \u2192 Audit: SDK installed? Keys present? Products exist? Webhook configured?
+
+When to recommend payments tasks:
+1. If payments.completeness == 0 AND monetization goals exist \u2192 suggest "payments-setup-stripe" (high priority)
+2. If payments.missing includes specific endpoints \u2192 suggest "payments-add-{type}" for each missing endpoint
+3. If payments.completeness > 0 AND payments.completeness < 100 \u2192 suggest "payments-check-status" to audit
+4. Payments setup is a prerequisite for any monetization/subscription features
+
 - Use codebase_context (if present) to understand what services/integrations actually exist before proposing solutions
 
 ${buildBusinessConstraints(businessContext)}
@@ -22557,7 +23997,7 @@ Focus on actionable, specific recommendations. Be concise.`;
       },
       required: ["analysis", "next_action"]
     });
-    const claude = (0, import_child_process4.spawn)("claude", [
+    const claude = (0, import_child_process6.spawn)("claude", [
       "--print",
       "--output-format",
       "json",
@@ -22637,9 +24077,9 @@ Focus on actionable, specific recommendations. Be concise.`;
 }
 function addTasksToTodo(tasks) {
   if (tasks.length === 0) return;
-  if (!fs15.existsSync(TODO_FILE)) return;
+  if (!fs19.existsSync(TODO_FILE)) return;
   try {
-    let content = fs15.readFileSync(TODO_FILE, "utf-8");
+    let content = fs19.readFileSync(TODO_FILE, "utf-8");
     if (!content.includes("## High Priority (Do Now)")) {
       log('TODO.md missing "## High Priority (Do Now)" section \u2014 creating it');
       const scheduledIdx = content.indexOf("## Scheduled");
@@ -22738,15 +24178,15 @@ function addTasksToTodo(tasks) {
       }
       log(`Added TODO: ${task.id} \u2014 ${task.description}`);
     }
-    fs15.writeFileSync(TODO_FILE, content);
+    fs19.writeFileSync(TODO_FILE, content);
   } catch (error) {
     log(`Failed to add tasks to TODO.md: ${error instanceof Error ? error.message : "Unknown error"}`);
   }
 }
 function archiveCompletedTodos() {
   try {
-    if (!fs15.existsSync(TODO_FILE)) return;
-    let content = fs15.readFileSync(TODO_FILE, "utf-8");
+    if (!fs19.existsSync(TODO_FILE)) return;
+    let content = fs19.readFileSync(TODO_FILE, "utf-8");
     const lines = content.split("\n");
     const completedLines = [];
     const newLines = [];
@@ -22772,7 +24212,7 @@ function archiveCompletedTodos() {
       const archiveBlock = completedLines.join("\n") + "\n";
       content = content.slice(0, insertIndex) + archiveBlock + content.slice(insertIndex);
     }
-    fs15.writeFileSync(TODO_FILE, content);
+    fs19.writeFileSync(TODO_FILE, content);
     log(`Archived ${completedLines.length} completed TODO(s) to Completed This Week`);
   } catch (error) {
     log(`Failed to archive completed TODOs: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -22780,8 +24220,8 @@ function archiveCompletedTodos() {
 }
 function pruneStaleScheduledTodos(state) {
   try {
-    if (!fs15.existsSync(TODO_FILE)) return;
-    const content = fs15.readFileSync(TODO_FILE, "utf-8");
+    if (!fs19.existsSync(TODO_FILE)) return;
+    const content = fs19.readFileSync(TODO_FILE, "utf-8");
     const lines = content.split("\n");
     const prunedIds = [];
     const terminalIdeaIds = new Set(
@@ -22808,7 +24248,7 @@ function pruneStaleScheduledTodos(state) {
       return true;
     });
     if (prunedIds.length === 0) return;
-    fs15.writeFileSync(TODO_FILE, newLines.join("\n"));
+    fs19.writeFileSync(TODO_FILE, newLines.join("\n"));
     log(`Pruned ${prunedIds.length} stale TODO(s): ${prunedIds.join(", ")}`);
   } catch (error) {
     log(`Failed to prune stale TODOs: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -22816,8 +24256,8 @@ function pruneStaleScheduledTodos(state) {
 }
 function deduplicateActiveTodos() {
   try {
-    if (!fs15.existsSync(TODO_FILE)) return;
-    const content = fs15.readFileSync(TODO_FILE, "utf-8");
+    if (!fs19.existsSync(TODO_FILE)) return;
+    const content = fs19.readFileSync(TODO_FILE, "utf-8");
     const lines = content.split("\n");
     const removedIds = [];
     let currentSection = "";
@@ -22854,7 +24294,7 @@ function deduplicateActiveTodos() {
     if (linesToRemove.size === 0) return;
     const newLines = lines.filter((_, i) => !linesToRemove.has(i));
     const cleaned = newLines.join("\n").replace(/\n{3,}/g, "\n\n");
-    fs15.writeFileSync(TODO_FILE, cleaned);
+    fs19.writeFileSync(TODO_FILE, cleaned);
     log(`Deduplicated ${removedIds.length} TODO(s): ${removedIds.join(", ")}`);
   } catch (error) {
     log(`Failed to deduplicate TODOs: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -22862,14 +24302,14 @@ function deduplicateActiveTodos() {
 }
 function appendToMemory(learnings) {
   if (learnings.length === 0) return;
-  if (!fs15.existsSync(MEMORY_FILE)) return;
+  if (!fs19.existsSync(MEMORY_FILE)) return;
   const MAX_LEARNINGS_PER_HEARTBEAT = 2;
   let filtered = learnings.slice(0, MAX_LEARNINGS_PER_HEARTBEAT);
   if (learnings.length > MAX_LEARNINGS_PER_HEARTBEAT) {
     log(`Capped learnings from ${learnings.length} to ${MAX_LEARNINGS_PER_HEARTBEAT}`);
   }
   try {
-    let content = fs15.readFileSync(MEMORY_FILE, "utf-8");
+    let content = fs19.readFileSync(MEMORY_FILE, "utf-8");
     const existingLines = content.split("\n").filter((l2) => l2.match(/^- \*\*/));
     filtered = filtered.filter((learning) => {
       const words = learning.toLowerCase().split(/\s+/).filter((w2) => w2.length > 4);
@@ -22910,7 +24350,7 @@ function appendToMemory(learnings) {
         const subsectionEnd = subsectionEndMatch ? subsectionIndex + 22 + (subsectionEndMatch.index || 0) : insertPoint;
         content = content.slice(0, subsectionEnd) + newEntries + "\n" + content.slice(subsectionEnd);
       }
-      fs15.writeFileSync(MEMORY_FILE, content);
+      fs19.writeFileSync(MEMORY_FILE, content);
       log(`Added ${filtered.length} learning(s) to MEMORY.md`);
     }
   } catch (error) {
@@ -23027,7 +24467,7 @@ function detectTargetRepo(idea, config) {
   const filesAnalyzed = idea.source.files_analyzed || [];
   for (const file of filesAnalyzed) {
     for (const repo of config.repos) {
-      if (file.includes(repo.name) || file.includes(path14.basename(repo.path))) {
+      if (file.includes(repo.name) || file.includes(path18.basename(repo.path))) {
         return repo;
       }
     }
@@ -23225,7 +24665,7 @@ Respond with JSON only (no markdown code blocks, just raw JSON):
       },
       required: ["sub_tasks"]
     });
-    const claude = (0, import_child_process4.spawn)("claude", [
+    const claude = (0, import_child_process6.spawn)("claude", [
       "--print",
       "--output-format",
       "json",
@@ -23355,17 +24795,17 @@ function runTestsForRepo(workspacePath, testCommands, sourceRepoPath) {
   const allOutput = [];
   const env = { ...process.env };
   if (sourceRepoPath) {
-    const venvBin = path14.join(sourceRepoPath, ".venv", "bin");
-    if (fs15.existsSync(venvBin)) {
+    const venvBin = path18.join(sourceRepoPath, ".venv", "bin");
+    if (fs19.existsSync(venvBin)) {
       env.PATH = `${venvBin}:${env.PATH}`;
-      env.VIRTUAL_ENV = path14.join(sourceRepoPath, ".venv");
+      env.VIRTUAL_ENV = path18.join(sourceRepoPath, ".venv");
       log(`Using venv from ${sourceRepoPath}/.venv`);
     }
   }
   for (const cmd of testCommands) {
     log(`Running test: ${cmd}`);
     try {
-      const result = (0, import_child_process4.execSync)(cmd, {
+      const result = (0, import_child_process6.execSync)(cmd, {
         cwd: workspacePath,
         encoding: "utf-8",
         env,
@@ -23411,7 +24851,7 @@ async function executeSingleSubTask(subTask, ideaId, idea, ideasData, autonomy,
   });
   const scopeBase64 = Buffer.from(scopePayload).toString("base64");
   const timeoutMs = autonomy.max_sub_task_timeout_ms || 3e5;
-  const workspacePath = options?.worktreePath || path14.join(config.workspace_dir, targetRepo.name);
+  const workspacePath = options?.worktreePath || path18.join(config.workspace_dir, targetRepo.name);
   const executionStartTime = Date.now();
   const updateSubTaskWithDetails = (status, updateOpts = {}) => {
     const endTime = Date.now();
@@ -23489,7 +24929,7 @@ async function executeSingleSubTask(subTask, ideaId, idea, ideasData, autonomy,
     }
     let commitHash = null;
     try {
-      commitHash = (0, import_child_process4.execSync)("git rev-parse HEAD", { cwd: workspacePath, encoding: "utf-8" }).trim();
+      commitHash = (0, import_child_process6.execSync)("git rev-parse HEAD", { cwd: workspacePath, encoding: "utf-8" }).trim();
     } catch {
     }
     updateSubTaskWithDetails("completed", {
@@ -23533,7 +24973,7 @@ async function analyzeAndRetrySubTask(subTask, ideaId, maxRetries) {
     "Be specific about what went wrong and how to fix it. Include any workarounds needed."
   ].filter(Boolean).join("\n");
   try {
-    const spawnResult = (0, import_child_process4.spawnSync)("claude", ["--print", "--model", "sonnet", "-p", errorContext], {
+    const spawnResult = (0, import_child_process6.spawnSync)("claude", ["--print", "--model", "sonnet", "-p", errorContext], {
       cwd: ROOT_DIR,
       encoding: "utf-8",
       timeout: 6e4,
@@ -23630,7 +25070,7 @@ async function executeAutonomousImplementation(ideaId) {
     }
     try {
       const { command, args: args2 } = resolveScript(__dirname, "implement.ts");
-      (0, import_child_process4.execSync)(
+      (0, import_child_process6.execSync)(
         [command, ...args2, `--idea=${ideaId}`, `--repo=${targetRepo2.name}`, "--create-pr-only"].join(" "),
         { cwd: ROOT_DIR, encoding: "utf-8", stdio: "inherit", timeout: 12e4 }
       );
@@ -23638,16 +25078,16 @@ async function executeAutonomousImplementation(ideaId) {
       if (autonomy.auto_merge) {
         const branchName2 = idea.implementation.branch_name;
         const defaultBranch2 = targetRepo2.default_branch || "main";
-        const workspacePath = path14.join(config.workspace_dir, targetRepo2.name);
+        const workspacePath = path18.join(config.workspace_dir, targetRepo2.name);
         if (branchName2) {
           try {
             log(`Auto-merging branch ${branchName2} into ${defaultBranch2}...`);
-            (0, import_child_process4.execSync)(`git checkout ${defaultBranch2}`, { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
-            (0, import_child_process4.execSync)(`git merge ${branchName2} --squash --no-edit`, { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
-            (0, import_child_process4.execSync)(`git commit -m "feat: ${idea.title} (auto-merged from ${branchName2})"`, { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
+            (0, import_child_process6.execSync)(`git checkout ${defaultBranch2}`, { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
+            (0, import_child_process6.execSync)(`git merge ${branchName2} --squash --no-edit`, { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
+            (0, import_child_process6.execSync)(`git commit -m "feat: ${idea.title} (auto-merged from ${branchName2})"`, { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
             log(`Successfully merged ${branchName2} into ${defaultBranch2}`);
             try {
-              (0, import_child_process4.execSync)(`git branch -d ${branchName2}`, { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
+              (0, import_child_process6.execSync)(`git branch -d ${branchName2}`, { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
               log(`Deleted branch ${branchName2}`);
             } catch {
               log(`Could not delete branch ${branchName2} (may need force delete)`);
@@ -23672,8 +25112,8 @@ async function executeAutonomousImplementation(ideaId) {
           } catch (mergeError) {
             log(`Auto-merge failed (likely conflicts): ${mergeError instanceof Error ? mergeError.message : "Unknown"}`);
             try {
-              (0, import_child_process4.execSync)(`git merge --abort`, { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
-              (0, import_child_process4.execSync)(`git checkout ${branchName2}`, { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
+              (0, import_child_process6.execSync)(`git merge --abort`, { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
+              (0, import_child_process6.execSync)(`git checkout ${branchName2}`, { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
             } catch {
             }
             log(`Left idea ${ideaId} in testing stage for manual merge`);
@@ -23867,7 +25307,7 @@ ${allowedFiles.map((f) => `- ${f}`).join("\n")}
 7. Be direct \u2014 read the file, make the edit, done
 `;
   return new Promise((resolve) => {
-    const claude = (0, import_child_process4.spawn)("claude", [
+    const claude = (0, import_child_process6.spawn)("claude", [
       "--print",
       "--dangerously-skip-permissions",
       "--model",
@@ -23951,7 +25391,7 @@ ${kpiLines}`;
   const contextBase64 = Buffer.from(contextPayload).toString("base64");
   return new Promise((resolve) => {
     const { command: analyzeCmd, args: analyzeArgs } = resolveScript(__dirname, "analyze.ts");
-    const childProcess = (0, import_child_process4.spawn)(analyzeCmd, [
+    const childProcess = (0, import_child_process6.spawn)(analyzeCmd, [
       ...analyzeArgs,
       `--type=research`,
       `--topic=${topic}`,
@@ -24115,7 +25555,7 @@ async function executeGoalGapResearch(goalId) {
   return new Promise((resolve) => {
     const TIMEOUT_MS = 9e5;
     const startTime = Date.now();
-    const claude = (0, import_child_process4.spawn)("claude", [
+    const claude = (0, import_child_process6.spawn)("claude", [
       "--print",
       "--dangerously-skip-permissions"
     ], {
@@ -24359,7 +25799,7 @@ async function executeShippedEvaluation(ideaId) {
   const prompt = buildEvaluationPrompt(idea, goal, liveKPIs, daysShipped);
   const TIMEOUT_MS = 12e4;
   const result = await new Promise((resolve) => {
-    const claude = (0, import_child_process4.spawn)("claude", ["--print"], {
+    const claude = (0, import_child_process6.spawn)("claude", ["--print"], {
       cwd: ROOT_DIR,
       env: process.env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -24757,7 +26197,7 @@ async function executeSingleResearchTask(task) {
   task.status = "running";
   task.started_at = (/* @__PURE__ */ new Date()).toISOString();
   return new Promise((resolve) => {
-    const claude = (0, import_child_process4.spawn)("claude", ["--print", "--dangerously-skip-permissions"], {
+    const claude = (0, import_child_process6.spawn)("claude", ["--print", "--dangerously-skip-permissions"], {
       cwd: ROOT_DIR,
       env: process.env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -24868,7 +26308,7 @@ Respond with JSON only:
   "recommendation_reasoning": "Why this recommendation"
 }`;
   return new Promise((resolve) => {
-    const claude = (0, import_child_process4.spawn)("claude", ["--print"], {
+    const claude = (0, import_child_process6.spawn)("claude", ["--print"], {
       cwd: ROOT_DIR,
       env: process.env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -25052,6 +26492,18 @@ async function executeTask(task, config, businessContext) {
           trackEvent("heartbeat_task", { taskType: taskTypePrefix, success: result.success });
           return result.success;
         }
+        if (isEmailMarketingTask(taskId)) {
+          const result = await executeEmailMarketingTask(taskId, taskDesc, businessContext);
+          log(`Email marketing task: ${result.success ? "SUCCESS" : "FAILED"} \u2014 ${result.output.slice(0, 200)}`);
+          trackEvent("heartbeat_task", { taskType: taskTypePrefix, success: result.success });
+          return result.success;
+        }
+        if (isPaymentsTask(taskId)) {
+          const result = await executePaymentsTask(taskId, taskDesc, businessContext);
+          log(`Payments task: ${result.success ? "SUCCESS" : "FAILED"} \u2014 ${result.output.slice(0, 200)}`);
+          trackEvent("heartbeat_task", { taskType: taskTypePrefix, success: result.success });
+          return result.success;
+        }
         if (taskId === "suggest-epics") {
           return await executeSuggestEpics();
         }
@@ -25081,7 +26533,7 @@ async function runAnalysis(type) {
   return new Promise((resolve, reject) => {
     log(`Running ${type} analysis...`);
     const { command: runCmd, args: runArgs } = resolveScript(__dirname, "analyze.ts");
-    const childProcess = (0, import_child_process4.spawn)(runCmd, [...runArgs, `--type=${type}`], {
+    const childProcess = (0, import_child_process6.spawn)(runCmd, [...runArgs, `--type=${type}`], {
       cwd: ROOT_DIR,
       stdio: "inherit"
     });
@@ -25100,7 +26552,7 @@ async function runAnalysis(type) {
 }
 function updateTodoFile(taskId, completed) {
   try {
-    let content = fs15.readFileSync(TODO_FILE, "utf-8");
+    let content = fs19.readFileSync(TODO_FILE, "utf-8");
     const uncheckedPattern = new RegExp(`- \\[ \\] \`${taskId}\``, "g");
     const checkedPattern = new RegExp(`- \\[x\\] \`${taskId}\``, "g");
     if (completed) {
@@ -25108,7 +26560,7 @@ function updateTodoFile(taskId, completed) {
     } else {
       content = content.replace(checkedPattern, `- [ ] \`${taskId}\``);
     }
-    fs15.writeFileSync(TODO_FILE, content);
+    fs19.writeFileSync(TODO_FILE, content);
     log(`Updated TODO.md: ${taskId} marked as ${completed ? "completed" : "pending"}`);
   } catch (error) {
     log(`Failed to update TODO.md: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -25212,8 +26664,8 @@ async function runSingleHeartbeat(beatNumber = 1) {
       if (vibeResult.warning) log(vibeResult.warning);
       log(`Vibe consumed (${vibeResult.vibes_remaining} remaining${vibeResult.plan ? `, plan: ${vibeResult.plan}` : ""}${vibeResult.offline ? ", offline" : ""})`);
     }
-    const commandsDir = path14.join(PROJECT_DIR, ".claude", "commands");
-    if (!fs15.existsSync(commandsDir)) {
+    const commandsDir = path18.join(PROJECT_DIR, ".claude", "commands");
+    if (!fs19.existsSync(commandsDir)) {
       log("Slash commands missing \u2014 auto-scaffolding...");
       scaffoldSlashCommands(PROJECT_DIR);
     }
@@ -25223,7 +26675,7 @@ async function runSingleHeartbeat(beatNumber = 1) {
     if (SKIP_REASONING) {
       log("Skipping Claude reasoning step");
     }
-    const state = loadState();
+    const state = loadState2();
     const businessContext = loadBusinessContext();
     const heartbeatConfig = loadConfig();
     log(`Loaded state: ${state.ideas.length} ideas, ${state.goals.length} goals, ${state.sessions.length} sessions`);
@@ -25390,7 +26842,7 @@ async function runSingleHeartbeat(beatNumber = 1) {
     }
     if (!DRY_RUN) {
       const statusContent = generateStatusContent(state, alerts, taskToDo, reasoning, systemHealth);
-      fs15.writeFileSync(STATUS_FILE, statusContent);
+      fs19.writeFileSync(STATUS_FILE, statusContent);
       log("Updated STATUS.md");
     } else {
       log("[DRY RUN] Would update STATUS.md");
@@ -25505,7 +26957,7 @@ ${"=".repeat(60)}
 `);
 }
 function saveSessionToJson(summary) {
-  const sessionsFile = path14.join(DATA_DIR, "heartbeat-sessions.json");
+  const sessionsFile = path18.join(DATA_DIR, "heartbeat-sessions.json");
   const sessionsData = loadJson(sessionsFile, { sessions: [] });
   sessionsData.sessions.push(summary);
   if (sessionsData.sessions.length > 50) {