vibebusiness 1.2.89 → 1.2.91

package/dist/scripts/heartbeat.js

@@ -105,8 +105,8 @@ var require_package = __commonJS({
 var require_main = __commonJS({
   "node_modules/dotenv/lib/main.js"(exports2, module2) {
     "use strict";
-    var fs36 = require("fs");
-    var path31 = require("path");
+    var fs43 = require("fs");
+    var path35 = require("path");
     var os3 = require("os");
     var crypto5 = require("crypto");
     var packageJson = require_package();
@@ -244,7 +244,7 @@ var require_main = __commonJS({
       if (options && options.path && options.path.length > 0) {
         if (Array.isArray(options.path)) {
           for (const filepath of options.path) {
-            if (fs36.existsSync(filepath)) {
+            if (fs43.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -252,15 +252,15 @@ var require_main = __commonJS({
           possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
         }
       } else {
-        possibleVaultPath = path31.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path35.resolve(process.cwd(), ".env.vault");
       }
-      if (fs36.existsSync(possibleVaultPath)) {
+      if (fs43.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path31.join(os3.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path35.join(os3.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
@@ -277,7 +277,7 @@ var require_main = __commonJS({
       return { parsed };
     }
     function configDotenv(options) {
-      const dotenvPath = path31.resolve(process.cwd(), ".env");
+      const dotenvPath = path35.resolve(process.cwd(), ".env");
       let encoding = "utf8";
       let processEnv = process.env;
       if (options && options.processEnv != null) {
@@ -305,13 +305,13 @@ var require_main = __commonJS({
       }
       let lastError;
       const parsedAll = {};
-      for (const path32 of optionPaths) {
+      for (const path36 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs36.readFileSync(path32, { encoding }));
+          const parsed = DotenvModule.parse(fs43.readFileSync(path36, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`Failed to load ${path32} ${e.message}`);
+            _debug(`Failed to load ${path36} ${e.message}`);
           }
           lastError = e;
         }
@@ -324,7 +324,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative = path31.relative(process.cwd(), filePath);
+            const relative = path35.relative(process.cwd(), filePath);
             shortPaths.push(relative);
           } catch (e) {
             if (debug) {
@@ -535,7 +535,7 @@ function findProjectRoot() {
   }
   return cwd;
 }
-var path2, fs3, PROJECT_DIR, DATA_DIR, STATUS_FILE, TODO_FILE, MEMORY_FILE, IDEAS_FILE, GOALS_FILE, SESSIONS_FILE, CONFIG_FILE, BUSINESS_CONTEXT_FILE, HYPOTHESES_FILE, IMPLEMENTATIONS_FILE, ROADMAP_FILE, COMPETITORS_FILE, POSITIONING_FILE, PAGES_FILE, PAYMENTS_FILE, POSTHOG_FILE, SOCIAL_FILE, TEMPLATES_DIR, COMMAND_TEMPLATES_DIR;
+var path2, fs3, PROJECT_DIR, DATA_DIR, STATUS_FILE, TODO_FILE, MEMORY_FILE, IDEAS_FILE, GOALS_FILE, SESSIONS_FILE, CONFIG_FILE, BUSINESS_CONTEXT_FILE, HYPOTHESES_FILE, IMPLEMENTATIONS_FILE, ROADMAP_FILE, PRODUCT_VISION_FILE, COMPETITORS_FILE, POSITIONING_FILE, PAGES_FILE, PAYMENTS_FILE, POSTHOG_FILE, SOCIAL_FILE, MARKETING_STRATEGIES_FILE, CAMPAIGNS_DIR, TEMPLATES_DIR, COMMAND_TEMPLATES_DIR;
 var init_paths = __esm({
   "scripts/lib/paths.ts"() {
     "use strict";
@@ -554,12 +554,15 @@ var init_paths = __esm({
     HYPOTHESES_FILE = path2.join(DATA_DIR, "hypotheses.json");
     IMPLEMENTATIONS_FILE = path2.join(DATA_DIR, "implementations.json");
     ROADMAP_FILE = path2.join(DATA_DIR, "roadmap.json");
+    PRODUCT_VISION_FILE = path2.join(DATA_DIR, "product-vision.json");
     COMPETITORS_FILE = path2.join(DATA_DIR, "competitors.json");
     POSITIONING_FILE = path2.join(DATA_DIR, "positioning.json");
     PAGES_FILE = path2.join(DATA_DIR, "pages.json");
     PAYMENTS_FILE = path2.join(DATA_DIR, "payments.json");
     POSTHOG_FILE = path2.join(DATA_DIR, "posthog.json");
     SOCIAL_FILE = path2.join(DATA_DIR, "social.json");
+    MARKETING_STRATEGIES_FILE = path2.join(DATA_DIR, "marketing-strategies.json");
+    CAMPAIGNS_DIR = path2.join(DATA_DIR, "campaigns");
     TEMPLATES_DIR = path2.join(__dirname, "..", "..", "templates");
     COMMAND_TEMPLATES_DIR = path2.join(TEMPLATES_DIR, "commands");
   }
@@ -3786,12 +3789,12 @@ var init_request_handler_helper = __esm({
         this.req.destroy(new Error("Request timeout."));
       }
       /* Response event handlers */
-      classicResponseHandler(resolve3, reject, res) {
+      classicResponseHandler(resolve4, reject, res) {
         this.res = res;
         const dataStream = this.getResponseDataStream(res);
         dataStream.on("data", (chunk) => this.responseData.push(chunk));
-        dataStream.on("end", this.onResponseEndHandler.bind(this, resolve3, reject));
-        dataStream.on("close", this.onResponseCloseHandler.bind(this, resolve3, reject));
+        dataStream.on("end", this.onResponseEndHandler.bind(this, resolve4, reject));
+        dataStream.on("close", this.onResponseCloseHandler.bind(this, resolve4, reject));
         if (this.requestData.requestEventDebugHandler) {
           this.requestData.requestEventDebugHandler("response", { res });
           res.on("aborted", (error) => this.requestData.requestEventDebugHandler("response-aborted", { error }));
@@ -3800,7 +3803,7 @@ var init_request_handler_helper = __esm({
           res.on("end", () => this.requestData.requestEventDebugHandler("response-end"));
         }
       }
-      onResponseEndHandler(resolve3, reject) {
+      onResponseEndHandler(resolve4, reject) {
         const rateLimit = this.getRateLimitFromResponse(this.res);
         let data;
         try {
@@ -3818,18 +3821,18 @@ var init_request_handler_helper = __esm({
           TwitterApiV2Settings.logger.log(`[${this.requestData.options.method} ${this.hrefPathname}]: Request succeeds with code ${this.res.statusCode}`);
           TwitterApiV2Settings.logger.log("Response body:", data);
         }
-        resolve3({
+        resolve4({
           data,
           headers: this.res.headers,
           rateLimit
         });
       }
-      onResponseCloseHandler(resolve3, reject) {
+      onResponseCloseHandler(resolve4, reject) {
         const res = this.res;
         if (res.aborted) {
           try {
             this.getParsedResponse(this.res);
-            return this.onResponseEndHandler(resolve3, reject);
+            return this.onResponseEndHandler(resolve4, reject);
           } catch (e) {
             return reject(this.createPartialResponseError(e, true));
           }
@@ -3838,14 +3841,14 @@ var init_request_handler_helper = __esm({
           return reject(this.createPartialResponseError(new Error("Response has been interrupted before response could be parsed."), true));
         }
       }
-      streamResponseHandler(resolve3, reject, res) {
+      streamResponseHandler(resolve4, reject, res) {
         const code = res.statusCode;
         if (code < 400) {
           if (TwitterApiV2Settings.debug) {
             TwitterApiV2Settings.logger.log(`[${this.requestData.options.method} ${this.hrefPathname}]: Request succeeds with code ${res.statusCode} (starting stream)`);
           }
           const dataStream = this.getResponseDataStream(res);
-          resolve3({ req: this.req, res: dataStream, originalResponse: res, requestData: this.requestData });
+          resolve4({ req: this.req, res: dataStream, originalResponse: res, requestData: this.requestData });
         } else {
           this.classicResponseHandler(() => void 0, reject, res);
         }
@@ -3903,7 +3906,7 @@ var init_request_handler_helper = __esm({
       makeRequest() {
         this.buildRequest();
         return new Promise((_resolve, _reject) => {
-          const resolve3 = (value) => {
+          const resolve4 = (value) => {
             cleanupListener.emit("complete");
             _resolve(value);
           };
@@ -3915,7 +3918,7 @@ var init_request_handler_helper = __esm({
           const req = this.req;
           req.on("error", this.requestErrorHandler.bind(this, reject));
           req.on("socket", this.onSocketEventHandler.bind(this, reject, cleanupListener));
-          req.on("response", this.classicResponseHandler.bind(this, resolve3, reject));
+          req.on("response", this.classicResponseHandler.bind(this, resolve4, reject));
           if (this.requestData.options.timeout) {
             req.on("timeout", this.timeoutErrorHandler.bind(this));
           }
@@ -3934,10 +3937,10 @@ var init_request_handler_helper = __esm({
       }
       makeRequestAndResolveWhenReady() {
         this.buildRequest();
-        return new Promise((resolve3, reject) => {
+        return new Promise((resolve4, reject) => {
           const req = this.req;
           req.on("error", this.requestErrorHandler.bind(this, reject));
-          req.on("response", this.streamResponseHandler.bind(this, resolve3, reject));
+          req.on("response", this.streamResponseHandler.bind(this, resolve4, reject));
           if (this.requestData.body) {
             req.write(this.requestData.body);
           }
@@ -6296,12 +6299,12 @@ var init_client_v1_read = __esm({
 async function readFileIntoBuffer(file) {
   const handle = await getFileHandle(file);
   if (typeof handle === "number") {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       fs13.readFile(handle, (err2, data) => {
         if (err2) {
           return reject(err2);
         }
-        resolve3(data);
+        resolve4(data);
       });
     });
   } else if (handle instanceof Buffer) {
@@ -6325,11 +6328,11 @@ function getFileHandle(file) {
 }
 async function getFileSizeFromFileHandle(fileHandle) {
   if (typeof fileHandle === "number") {
-    const stats = await new Promise((resolve3, reject) => {
+    const stats = await new Promise((resolve4, reject) => {
       fs13.fstat(fileHandle, (err2, stats2) => {
         if (err2)
           reject(err2);
-        resolve3(stats2);
+        resolve4(stats2);
       });
     });
     return stats.size;
@@ -6406,7 +6409,7 @@ function getMediaCategoryByMime(name, target) {
     return target === "tweet" ? "TweetImage" : "DmImage";
 }
 function sleepSecs(seconds) {
-  return new Promise((resolve3) => setTimeout(resolve3, seconds * 1e3));
+  return new Promise((resolve4) => setTimeout(resolve4, seconds * 1e3));
 }
 async function readNextPartOf(file, chunkLength, bufferOffset = 0, buffer) {
   if (file instanceof Buffer) {
@@ -6418,11 +6421,11 @@ async function readNextPartOf(file, chunkLength, bufferOffset = 0, buffer) {
   }
   let bytesRead;
   if (typeof file === "number") {
-    bytesRead = await new Promise((resolve3, reject) => {
+    bytesRead = await new Promise((resolve4, reject) => {
       fs13.read(file, buffer, 0, chunkLength, bufferOffset, (err2, nread) => {
         if (err2)
           reject(err2);
-        resolve3(nread);
+        resolve4(nread);
       });
     });
   } else {
@@ -8338,7 +8341,7 @@ var init_client_v2_read = __esm({
           if (runningJob.status === "expired" || runningJob.status === "failed") {
             throw new Error("Job failed to be completed.");
           }
-          await new Promise((resolve3) => setTimeout(resolve3, 3500));
+          await new Promise((resolve4) => setTimeout(resolve4, 3500));
           runningJob = (await this.complianceJob(job.id)).data;
         }
         const result = await this.get(job.download_url, void 0, {
@@ -8547,7 +8550,7 @@ var init_client_v2_write = __esm({
           case "in_progress": {
             const waitTime = info === null || info === void 0 ? void 0 : info.check_after_secs;
             if (waitTime && waitTime > 0) {
-              await new Promise((resolve3) => setTimeout(resolve3, waitTime * 1e3));
+              await new Promise((resolve4) => setTimeout(resolve4, waitTime * 1e3));
               await this.waitForMediaProcessing(mediaId);
             }
           }
@@ -9579,7 +9582,7 @@ function invokeClaudeCLI(options, claudePath) {
   }
   const startTime = Date.now();
   const timeoutMs = options.timeoutMs || 3e5;
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const child = (0, import_child_process6.spawn)(bin, args2, {
       cwd: options.cwd || process.cwd(),
       env: process.env,
@@ -9599,7 +9602,7 @@ function invokeClaudeCLI(options, claudePath) {
     }
     const timeout = setTimeout(() => {
       child.kill("SIGTERM");
-      resolve3({
+      resolve4({
         output: stdout,
         provider: "claude-cli",
         durationMs: Date.now() - startTime,
@@ -9608,7 +9611,7 @@ function invokeClaudeCLI(options, claudePath) {
     }, timeoutMs);
     child.on("close", (code) => {
       clearTimeout(timeout);
-      resolve3({
+      resolve4({
         output: stdout.trim(),
         provider: "claude-cli",
         durationMs: Date.now() - startTime,
@@ -9617,7 +9620,7 @@ function invokeClaudeCLI(options, claudePath) {
     });
     child.on("error", (err2) => {
       clearTimeout(timeout);
-      resolve3({
+      resolve4({
         output: "",
         provider: "claude-cli",
         durationMs: Date.now() - startTime,
@@ -9865,10 +9868,10 @@ __export(screenshot_exports, {
   captureIdeaScreenshot: () => captureIdeaScreenshot
 });
 async function captureIdeaScreenshot(ideaId, previewUrl, options) {
-  const outputDir = options?.outputDir ?? path28.join(DATA_DIR, "reports");
+  const outputDir = options?.outputDir ?? path32.join(DATA_DIR, "reports");
   const timeoutMs = options?.timeoutMs ?? 15e3;
-  const outputPath = path28.join(outputDir, `${ideaId}-screenshot.png`);
-  if (fs33.existsSync(outputPath)) return outputPath;
+  const outputPath = path32.join(outputDir, `${ideaId}-screenshot.png`);
+  if (fs40.existsSync(outputPath)) return outputPath;
   try {
     const controller = new AbortController();
     const probeTimeout = setTimeout(() => controller.abort(), 3e3);
@@ -9888,7 +9891,7 @@ async function captureIdeaScreenshot(ideaId, previewUrl, options) {
       });
       await page.goto(previewUrl, { waitUntil: "networkidle", timeout: timeoutMs });
       await page.waitForTimeout(500);
-      fs33.mkdirSync(outputDir, { recursive: true });
+      fs40.mkdirSync(outputDir, { recursive: true });
       await page.screenshot({ path: outputPath });
       return outputPath;
     } finally {
@@ -9898,12 +9901,12 @@ async function captureIdeaScreenshot(ideaId, previewUrl, options) {
     return null;
   }
 }
-var fs33, path28;
+var fs40, path32;
 var init_screenshot = __esm({
   "scripts/lib/screenshot.ts"() {
     "use strict";
-    fs33 = __toESM(require("fs"));
-    path28 = __toESM(require("path"));
+    fs40 = __toESM(require("fs"));
+    path32 = __toESM(require("path"));
     init_paths();
   }
 });
@@ -9915,10 +9918,10 @@ __export(marketing_integration_exports, {
   integrateMarketingPlanToUI: () => integrateMarketingPlanToUI
 });
 async function addMarketingIdeasToDashboard(plan, dataDir) {
-  const ideasPath = path29.join(dataDir, "ideas.json");
+  const ideasPath = path33.join(dataDir, "ideas.json");
   let ideasData = { ideas: [] };
-  if (fs34.existsSync(ideasPath)) {
-    ideasData = JSON.parse(fs34.readFileSync(ideasPath, "utf-8"));
+  if (fs41.existsSync(ideasPath)) {
+    ideasData = JSON.parse(fs41.readFileSync(ideasPath, "utf-8"));
   }
   const newIdeasPartial = generateIdeasFromPlan(plan);
   let added = 0;
@@ -9969,7 +9972,7 @@ async function addMarketingIdeasToDashboard(plan, dataDir) {
     ideasData.ideas.push(newIdea);
     added++;
   }
-  fs34.writeFileSync(ideasPath, JSON.stringify(ideasData, null, 2));
+  fs41.writeFileSync(ideasPath, JSON.stringify(ideasData, null, 2));
   return { added, skipped };
 }
 function generateIdeaId() {
@@ -9978,23 +9981,23 @@ function generateIdeaId() {
   return `idea-${timestamp}-${random}`;
 }
 async function integrateMarketingPlanToUI(planId, dataDir) {
-  const planPath = path29.join(dataDir, "marketing-plans", `${planId}.json`);
-  if (!fs34.existsSync(planPath)) {
+  const planPath = path33.join(dataDir, "marketing-plans", `${planId}.json`);
+  if (!fs41.existsSync(planPath)) {
     throw new Error(`Plan ${planId} not found`);
   }
-  const plan = JSON.parse(fs34.readFileSync(planPath, "utf-8"));
+  const plan = JSON.parse(fs41.readFileSync(planPath, "utf-8"));
   const result = await addMarketingIdeasToDashboard(plan, dataDir);
   console.log(`\u2713 Added ${result.added} marketing ideas to dashboard`);
   if (result.skipped > 0) {
     console.log(`  (Skipped ${result.skipped} duplicate ideas)`);
   }
 }
-var fs34, path29;
+var fs41, path33;
 var init_marketing_integration = __esm({
   "scripts/skills/marketing-integration.ts"() {
     "use strict";
-    fs34 = __toESM(require("fs"));
-    path29 = __toESM(require("path"));
+    fs41 = __toESM(require("fs"));
+    path33 = __toESM(require("path"));
     init_marketing_strategy();
   }
 });
@@ -10011,9 +10014,9 @@ var init_marketing_integration = __esm({
 })();
 
 // scripts/heartbeat.ts
-var fs35 = __toESM(require("fs"));
-var path30 = __toESM(require("path"));
-var import_child_process11 = require("child_process");
+var fs42 = __toESM(require("fs"));
+var path34 = __toESM(require("path"));
+var import_child_process13 = require("child_process");
 var import_util = require("util");
 
 // src/lib/kpi-adapters/rest-api.ts
@@ -13634,8 +13637,8 @@ function argument(predicate, message) {
   }
 }
 var check = { fail, argument, assert: argument };
-function getPathDefinition(glyph, path31) {
-  var _path = path31 || new Path();
+function getPathDefinition(glyph, path35) {
+  var _path = path35 || new Path();
   return {
     configurable: true,
     get: function() {
@@ -13858,9 +13861,9 @@ function ttfGlyphLoader(font, index, parseGlyph2, data, position, buildPath2) {
     var glyph = new Glyph({ index, font });
     glyph.path = function() {
       parseGlyph2(glyph, data, position);
-      var path31 = buildPath2(font.glyphs, glyph);
-      path31.unitsPerEm = font.unitsPerEm;
-      return path31;
+      var path35 = buildPath2(font.glyphs, glyph);
+      path35.unitsPerEm = font.unitsPerEm;
+      return path35;
     };
     defineDependentProperty(glyph, "xMin", "_xMin");
     defineDependentProperty(glyph, "xMax", "_xMax");
@@ -13873,9 +13876,9 @@ function cffGlyphLoader(font, index, parseCFFCharstring2, charstring) {
   return function() {
     var glyph = new Glyph({ index, font });
     glyph.path = function() {
-      var path31 = parseCFFCharstring2(font, glyph, charstring);
-      path31.unitsPerEm = font.unitsPerEm;
-      return path31;
+      var path35 = parseCFFCharstring2(font, glyph, charstring);
+      path35.unitsPerEm = font.unitsPerEm;
+      return path35;
     };
     return glyph;
   };
@@ -30994,8 +30997,8 @@ async function postTweet(client, text) {
   };
 }
 async function uploadMedia(client, filePath) {
-  const fs36 = require("fs");
-  if (!fs36.existsSync(filePath)) {
+  const fs43 = require("fs");
+  if (!fs43.existsSync(filePath)) {
     throw new Error(`Media file not found: ${filePath}`);
   }
   const mediaId = await client.v1.uploadMedia(filePath);
@@ -33662,7 +33665,7 @@ function readPromoVideoFreshness() {
 var fs23 = __toESM(require("fs"));
 var path17 = __toESM(require("path"));
 init_paths();
-var CAMPAIGNS_DIR = path17.join(DATA_DIR, "campaigns");
+var CAMPAIGNS_DIR2 = path17.join(DATA_DIR, "campaigns");
 var CAMPAIGN_PREFIXES = [
   "campaign-launch-",
   "campaign-milestone-",
@@ -33699,14 +33702,14 @@ function detectChannels(businessContext) {
   return channels;
 }
 function saveCampaign(campaign) {
-  fs23.mkdirSync(CAMPAIGNS_DIR, { recursive: true });
-  const filePath = path17.join(CAMPAIGNS_DIR, `${campaign.id}.json`);
+  fs23.mkdirSync(CAMPAIGNS_DIR2, { recursive: true });
+  const filePath = path17.join(CAMPAIGNS_DIR2, `${campaign.id}.json`);
   fs23.writeFileSync(filePath, JSON.stringify(campaign, null, 2) + "\n");
 }
 function loadCampaigns() {
-  if (!fs23.existsSync(CAMPAIGNS_DIR)) return [];
+  if (!fs23.existsSync(CAMPAIGNS_DIR2)) return [];
   try {
-    return fs23.readdirSync(CAMPAIGNS_DIR).filter((f) => f.endsWith(".json")).map((f) => JSON.parse(fs23.readFileSync(path17.join(CAMPAIGNS_DIR, f), "utf-8"))).sort((a, b) => b.created_at.localeCompare(a.created_at));
+    return fs23.readdirSync(CAMPAIGNS_DIR2).filter((f) => f.endsWith(".json")).map((f) => JSON.parse(fs23.readFileSync(path17.join(CAMPAIGNS_DIR2, f), "utf-8"))).sort((a, b) => b.created_at.localeCompare(a.created_at));
   } catch {
     return [];
   }
@@ -33970,16 +33973,1087 @@ function readCampaignFreshness() {
   };
 }
 
+// scripts/skills/growth-campaign.ts
+var fs26 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
+init_paths();
+init_ai_provider();
+
+// scripts/lib/growth/campaign-state.ts
+var fs24 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
+init_paths();
+function createGrowthCampaign(params) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const campaign = {
+    id: `growth-${params.ideaId}-${today}`,
+    type: "growth",
+    source_idea_id: params.ideaId,
+    source_idea_title: params.ideaTitle,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "researching",
+    product: params.product,
+    research: null,
+    channels: params.channels,
+    sub_tasks: params.subTasks,
+    utm_campaign: `growth-${params.ideaId}-${today}`
+  };
+  fs24.mkdirSync(CAMPAIGNS_DIR, { recursive: true });
+  const filePath = path18.join(CAMPAIGNS_DIR, `${campaign.id}.json`);
+  fs24.writeFileSync(filePath, JSON.stringify(campaign, null, 2) + "\n");
+  return campaign;
+}
+function loadGrowthCampaignByIdeaId(ideaId) {
+  const campaigns = listGrowthCampaigns();
+  return campaigns.find((c2) => c2.source_idea_id === ideaId) || null;
+}
+function updateGrowthCampaign(campaign) {
+  fs24.mkdirSync(CAMPAIGNS_DIR, { recursive: true });
+  const filePath = path18.join(CAMPAIGNS_DIR, `${campaign.id}.json`);
+  fs24.writeFileSync(filePath, JSON.stringify(campaign, null, 2) + "\n");
+}
+function listGrowthCampaigns() {
+  if (!fs24.existsSync(CAMPAIGNS_DIR)) return [];
+  try {
+    return fs24.readdirSync(CAMPAIGNS_DIR).filter((f) => f.startsWith("growth-") && f.endsWith(".json")).map((f) => JSON.parse(fs24.readFileSync(path18.join(CAMPAIGNS_DIR, f), "utf-8"))).sort((a, b) => b.created_at.localeCompare(a.created_at));
+  } catch {
+    return [];
+  }
+}
+function loadProductInfo() {
+  try {
+    if (!fs24.existsSync(POSITIONING_FILE)) return null;
+    const positioning = JSON.parse(fs24.readFileSync(POSITIONING_FILE, "utf-8"));
+    const current = positioning?.current;
+    if (!current) return null;
+    return {
+      name: current.product_name || current.name || "Unknown",
+      tagline: current.tagline || "",
+      value_proposition: current.value_proposition || current.positioning_statement || "",
+      differentiators: current.differentiators || current.key_differentiators || [],
+      target_audience: current.target_audience || current.ideal_customer || ""
+    };
+  } catch {
+    return null;
+  }
+}
+function loadCompetitors() {
+  try {
+    if (!fs24.existsSync(COMPETITORS_FILE)) return [];
+    const data = JSON.parse(fs24.readFileSync(COMPETITORS_FILE, "utf-8"));
+    return data?.competitors || data || [];
+  } catch {
+    return [];
+  }
+}
+function loadMarketingStrategies() {
+  try {
+    if (!fs24.existsSync(MARKETING_STRATEGIES_FILE)) return null;
+    return JSON.parse(fs24.readFileSync(MARKETING_STRATEGIES_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+var DEFAULT_CHANNELS = ["twitter_thread", "linkedin", "reddit"];
+var CHANNEL_SCHEDULE = {
+  twitter_thread: 0,
+  linkedin: 1,
+  reddit: 2,
+  indie_hackers: 3,
+  show_hn: 5,
+  devto: 7,
+  product_hunt: 7
+};
+function resolveChannels(ideaTags, marketingStrategies) {
+  const tagChannels = ideaTags.filter((t) => t.startsWith("channel:")).map((t) => t.replace("channel:", "")).filter((c2) => c2 in CHANNEL_SCHEDULE);
+  let channels = tagChannels.length > 0 ? tagChannels : DEFAULT_CHANNELS;
+  if (marketingStrategies) {
+    const excluded = marketingStrategies.excluded_channels || [];
+    const preferred = marketingStrategies.preferred_channels;
+    if (excluded.length > 0) {
+      channels = channels.filter((c2) => !excluded.includes(c2));
+    }
+    if (preferred && preferred.length > 0) {
+      channels.sort((a, b) => {
+        const aP = preferred.includes(a) ? 0 : 1;
+        const bP = preferred.includes(b) ? 0 : 1;
+        return aP - bP;
+      });
+    }
+  }
+  return channels;
+}
+function buildChannelDrafts(channels, ideaTags) {
+  return channels.map((channel) => {
+    const draft = {
+      channel,
+      status: "pending",
+      scheduled_day: CHANNEL_SCHEDULE[channel] ?? 0
+    };
+    if (channel === "reddit") {
+      const subTag = ideaTags.find((t) => t.startsWith("subreddit:"));
+      if (subTag) {
+        draft.subreddit = subTag.replace("subreddit:", "");
+      }
+    }
+    return draft;
+  });
+}
+
+// scripts/lib/growth/channel-adapters.ts
+function productContext(product) {
+  return `PRODUCT CONTEXT:
+- Name: ${product.name}
+- Tagline: ${product.tagline}
+- Value Proposition: ${product.value_proposition}
+- Differentiators: ${product.differentiators.join(", ")}
+- Target Audience: ${product.target_audience}`;
+}
+function researchContext(research) {
+  if (!research) return "RESEARCH: No research data available yet.";
+  const parts = ["RESEARCH DATA:"];
+  if (research.subreddit_research.length > 0) {
+    parts.push("\nSubreddits:");
+    for (const sub of research.subreddit_research) {
+      parts.push(`- r/${sub.name}: ${sub.subscribers ?? "?"} subscribers, self-promo: ${sub.self_promo_policy}`);
+      if (sub.top_post_patterns.length > 0) {
+        parts.push(`  Top patterns: ${sub.top_post_patterns.join("; ")}`);
+      }
+    }
+  }
+  if (research.keyword_research.length > 0) {
+    parts.push("\nKeywords:");
+    for (const kw of research.keyword_research) {
+      parts.push(`- "${kw.keyword}": volume=${kw.volume || "?"}, CPC=${kw.cpc || "?"}, competition=${kw.competition || "?"}`);
+    }
+  }
+  if (research.hn_research) {
+    parts.push("\nHacker News:");
+    parts.push(`- Similar posts: ${research.hn_research.successful_similar_posts.join("; ")}`);
+    parts.push(`- Upvote patterns: ${research.hn_research.upvote_patterns}`);
+  }
+  if (research.competitor_content.length > 0) {
+    parts.push("\nCompetitor Content:");
+    for (const cc of research.competitor_content) {
+      parts.push(`- ${cc.competitor}: ${cc.content_examples.slice(0, 2).join("; ")}`);
+    }
+  }
+  if (research.trending_topics.length > 0) {
+    parts.push(`
+Trending: ${research.trending_topics.join(", ")}`);
+  }
+  return parts.join("\n");
+}
+function buildShowHNPrompt(ctx) {
+  return `You are writing a Show HN post for Hacker News.
+
+${productContext(ctx.product)}
+
+IDEA CONTEXT:
+- Title: ${ctx.idea.title}
+- Summary: ${ctx.idea.summary}
+- Rationale: ${ctx.idea.rationale}
+
+${researchContext(ctx.research)}
+
+HACKER NEWS RULES (CRITICAL \u2014 follow exactly):
+1. Title MUST start with "Show HN: " followed by a concise description (max 80 chars total)
+2. The HN post body should be 2-4 short paragraphs explaining what you built and why
+3. Be technical and honest \u2014 HN readers detect and punish marketing speak instantly
+4. Acknowledge limitations openly \u2014 this builds trust
+5. Explain the technical approach briefly
+6. No exclamation marks, no superlatives, no "revolutionary/game-changing"
+7. End with a question to invite discussion (e.g., "Curious what you think about X approach")
+
+FIRST COMMENT (CRITICAL):
+- Write a 500-800 character "maker comment" that goes deeper
+- Share the backstory: why you built this, what problem you hit
+- Include one specific technical detail or metric
+- Be genuine and conversational
+
+OUTPUT FORMAT (respond with valid JSON only):
+{
+  "title": "Show HN: ...",
+  "body": "The HN post body text",
+  "first_comment": "The maker's first comment",
+  "cta": "A subtle link/reference, NOT a hard sell",
+  "utm_url": "${ctx.productUrl || "https://yoursite.com"}?utm_source=hackernews&utm_medium=show_hn&utm_campaign=${ctx.utmCampaign}",
+  "platform_constraints": "Title max 80 chars. No marketing speak. Technical honesty required."
+}`;
+}
+function buildRedditPrompt(ctx, subreddit) {
+  const subName = subreddit || "relevant subreddit";
+  const subResearch = ctx.research?.subreddit_research.find(
+    (s) => s.name.toLowerCase() === (subreddit || "").toLowerCase()
+  );
+  let subRules = "";
+  if (subResearch) {
+    subRules = `
+SUBREDDIT RESEARCH for r/${subResearch.name}:
+- Subscribers: ${subResearch.subscribers ?? "unknown"}
+- Self-promo policy: ${subResearch.self_promo_policy}
+- Rules: ${subResearch.rules_summary}
+- Top post patterns: ${subResearch.top_post_patterns.join("; ")}`;
+  }
+  return `You are writing a Reddit post for r/${subName}.
+
+${productContext(ctx.product)}
+
+IDEA CONTEXT:
+- Title: ${ctx.idea.title}
+- Summary: ${ctx.idea.summary}
+- Rationale: ${ctx.idea.rationale}
+
+${researchContext(ctx.research)}
+${subRules}
+
+REDDIT POST RULES (CRITICAL):
+1. Title should be a question or story hook \u2014 NOT a product announcement
+2. Lead with the problem/pain you experienced, not the solution
+3. Provide genuine value FIRST: share insights, data, or a useful approach
+4. Mention your product only once, near the end, as "I built X to solve this"
+5. Match the subreddit's culture \u2014 read the top posts for tone
+6. Use paragraphs (Reddit markdown), not walls of text
+7. If the subreddit bans self-promotion, frame as asking for feedback instead
+8. Be a community member first, promoter never
+
+OUTPUT FORMAT (respond with valid JSON only):
+{
+  "title": "Post title (question or story hook)",
+  "body": "Full post body with Reddit markdown formatting",
+  "cta": "Soft mention of the product, woven into the story",
+  "utm_url": "${ctx.productUrl || "https://yoursite.com"}?utm_source=reddit&utm_medium=r_${subreddit || "post"}&utm_campaign=${ctx.utmCampaign}",
+  "platform_constraints": "Community-first. Value before promotion. Match subreddit tone."
+}`;
+}
+function buildLinkedInPrompt(ctx) {
+  return `You are writing a LinkedIn post.
+
+${productContext(ctx.product)}
+
+IDEA CONTEXT:
+- Title: ${ctx.idea.title}
+- Summary: ${ctx.idea.summary}
+- Rationale: ${ctx.idea.rationale}
+
+${researchContext(ctx.research)}
+
+LINKEDIN ALGORITHM KNOWLEDGE (maximize reach):
+1. First line = hook \u2014 must stop the scroll. Use a bold claim, surprising stat, or contrarian take
+2. Use short paragraphs (1-2 sentences each) with blank lines between
+3. Whitespace is your friend \u2014 dense text gets scrolled past
+4. Total length: 1200-1500 characters (sweet spot for engagement)
+5. End with a question to drive comments (comments > likes for reach)
+6. No external links in the post body (kills reach by 50%)
+7. Put the link in the first comment instead
+8. Use "I" statements \u2014 personal stories outperform corporate announcements
+9. Optional: use a list format (numbered insights) for scanability
+10. No hashtags in the post (they look spammy and don't help anymore)
+
+OUTPUT FORMAT (respond with valid JSON only):
+{
+  "title": "Not used on LinkedIn, but store the hook line here",
+  "body": "The full LinkedIn post text, formatted with line breaks",
+  "cta": "Question to ask at the end + note to put link in first comment",
+  "utm_url": "${ctx.productUrl || "https://yoursite.com"}?utm_source=linkedin&utm_medium=post&utm_campaign=${ctx.utmCampaign}",
+  "platform_constraints": "No links in body. 1200-1500 chars. Hook first line. End with question."
+}`;
+}
+function buildTwitterThreadPrompt(ctx) {
+  return `You are writing a Twitter/X thread.
+
+${productContext(ctx.product)}
+
+IDEA CONTEXT:
+- Title: ${ctx.idea.title}
+- Summary: ${ctx.idea.summary}
+- Rationale: ${ctx.idea.rationale}
+
+${researchContext(ctx.research)}
+
+TWITTER THREAD RULES (maximize engagement):
+1. Tweet 1 (hook): Must be a standalone banger. Bold claim, surprising data, or contrarian take. Max 280 chars.
+2. Thread length: 5-7 tweets total (sweet spot \u2014 shorter feels thin, longer loses readers)
+3. Each tweet should be self-contained AND flow into the next
+4. Use numbers and data where possible \u2014 "We increased X by 47%" > "We improved X"
+5. Tweet structure: Hook \u2192 Problem \u2192 Insight 1 \u2192 Insight 2 \u2192 How \u2192 Result \u2192 CTA
+6. Last tweet = CTA with link. "If you want to try this: [link]" or "Follow me for more on X"
+7. No thread-style numbering (1/7, 2/7) \u2014 it looks robotic
+8. Use line breaks within tweets for readability
+9. Optional: one tweet can be an image/screenshot placeholder "[screenshot of dashboard]"
+
+OUTPUT FORMAT (respond with valid JSON only):
+{
+  "body": "Tweet 1 text (the hook)",
+  "thread_tweets": ["Tweet 2", "Tweet 3", "Tweet 4", "Tweet 5", "Tweet 6 (CTA)"],
+  "cta": "The CTA text from the last tweet",
+  "utm_url": "${ctx.productUrl || "https://yoursite.com"}?utm_source=twitter&utm_medium=thread&utm_campaign=${ctx.utmCampaign}",
+  "platform_constraints": "Max 280 chars per tweet. 5-7 tweets. Hook tweet must stand alone."
+}`;
+}
+function buildIndieHackersPrompt(ctx) {
+  return `You are writing an Indie Hackers post.
+
+${productContext(ctx.product)}
+
+IDEA CONTEXT:
+- Title: ${ctx.idea.title}
+- Summary: ${ctx.idea.summary}
+- Rationale: ${ctx.idea.rationale}
+
+${researchContext(ctx.research)}
+
+INDIE HACKERS RULES:
+1. IH audience = founders, solopreneurs, bootstrappers. They want REAL numbers.
+2. Use milestone format: "How I [achieved X] \u2014 the full breakdown"
+3. Share real metrics: revenue, users, conversion rates, time spent
+4. Be transparent about what DIDN'T work \u2014 this builds massive trust
+5. Structure: Background \u2192 What I tried \u2192 What worked \u2192 Metrics \u2192 Lessons \u2192 What's next
+6. Length: 1500-2500 words (IH readers love detail)
+7. End with specific lessons (numbered list) and a question for the community
+8. Don't be afraid to show vulnerability \u2014 "I almost gave up when..."
+
+OUTPUT FORMAT (respond with valid JSON only):
+{
+  "title": "How I [achieved result] \u2014 [compelling detail]",
+  "body": "Full post body with markdown formatting",
+  "cta": "Question for the community + soft product mention",
+  "utm_url": "${ctx.productUrl || "https://yoursite.com"}?utm_source=indiehackers&utm_medium=post&utm_campaign=${ctx.utmCampaign}",
+  "platform_constraints": "Milestone format. Real numbers required. 1500-2500 words. Transparency wins."
+}`;
+}
+function buildDevToPrompt(ctx) {
+  return `You are writing a Dev.to article.
+
+${productContext(ctx.product)}
+
+IDEA CONTEXT:
+- Title: ${ctx.idea.title}
+- Summary: ${ctx.idea.summary}
+- Rationale: ${ctx.idea.rationale}
+- Implementation plan: ${ctx.idea.implementation_plan}
+
+${researchContext(ctx.research)}
+
+DEV.TO RULES:
+1. Dev.to audience = developers. They want to LEARN something.
+2. Frame as a tutorial or technical deep-dive, not a product announcement
+3. Title format: "How to [solve problem] with [approach]" or "Building [thing]: [technical detail]"
+4. Length: 2000-3000 words with code examples
+5. Include architecture decisions and trade-offs ("We chose X over Y because...")
+6. Use proper markdown: headers, code blocks with syntax highlighting, lists
+7. Add a cover image suggestion and 3-4 relevant tags
+8. Front matter should include: title, published, description, tags, cover_image
+9. End with "Next Steps" and links to further reading
+
+OUTPUT FORMAT (respond with valid JSON only):
+{
+  "title": "How to [approach] \u2014 [benefit]",
+  "body": "Full article body with markdown, code blocks, and headers",
+  "cta": "Next steps section with product link woven in naturally",
+  "utm_url": "${ctx.productUrl || "https://yoursite.com"}?utm_source=devto&utm_medium=article&utm_campaign=${ctx.utmCampaign}",
+  "platform_constraints": "Tutorial format. 2000-3000 words. Code examples required. Dev audience."
+}`;
+}
+function buildProductHuntPrompt(ctx) {
+  return `You are preparing a Product Hunt launch.
+
+${productContext(ctx.product)}
+
+IDEA CONTEXT:
+- Title: ${ctx.idea.title}
+- Summary: ${ctx.idea.summary}
+- Rationale: ${ctx.idea.rationale}
+
+${researchContext(ctx.research)}
+
+PRODUCT HUNT RULES:
+1. Tagline: max 60 characters. Benefit-focused, not feature-focused.
+2. Description: max 260 characters. What it does + who it's for.
+3. First comment (maker comment): 500-800 chars. Story of why you built it.
+4. Suggest 5 gallery image concepts (screenshots, diagrams, before/after)
+5. Choose 3 topics/categories that fit
+6. Hunter's note: write as if someone else is featuring your product
+7. Timing: launch at 12:01 AM PST for maximum visibility
+
+OUTPUT FORMAT (respond with valid JSON only):
+{
+  "title": "${ctx.product.name}",
+  "body": "260-char description",
+  "first_comment": "Maker's first comment (500-800 chars)",
+  "cta": "60-char tagline",
+  "utm_url": "${ctx.productUrl || "https://yoursite.com"}?utm_source=producthunt&utm_medium=launch&utm_campaign=${ctx.utmCampaign}",
+  "platform_constraints": "Tagline max 60 chars. Description max 260 chars. Launch at 12:01 AM PST.",
+  "gallery_suggestions": ["Suggestion 1", "Suggestion 2", "Suggestion 3", "Suggestion 4", "Suggestion 5"],
+  "topics": ["Topic 1", "Topic 2", "Topic 3"]
+}`;
+}
+function getChannelPrompt(channel, ctx, subreddit) {
+  switch (channel) {
+    case "show_hn":
+      return buildShowHNPrompt(ctx);
+    case "reddit":
+      return buildRedditPrompt(ctx, subreddit);
+    case "linkedin":
+      return buildLinkedInPrompt(ctx);
+    case "twitter_thread":
+      return buildTwitterThreadPrompt(ctx);
+    case "indie_hackers":
+      return buildIndieHackersPrompt(ctx);
+    case "devto":
+      return buildDevToPrompt(ctx);
+    case "product_hunt":
+      return buildProductHuntPrompt(ctx);
+    default:
+      return buildLinkedInPrompt(ctx);
+  }
+}
+
+// scripts/lib/growth/research.ts
+var import_child_process10 = require("child_process");
+init_paths();
+function executeGrowthResearch(params) {
+  const channelNames = params.channels.map((c2) => c2.channel);
+  const subreddits = params.channels.filter((c2) => c2.channel === "reddit" && c2.subreddit).map((c2) => c2.subreddit);
+  const prompt = buildResearchPrompt({
+    product: params.product,
+    channels: channelNames,
+    subreddits,
+    ideaTitle: params.ideaTitle,
+    ideaSummary: params.ideaSummary,
+    competitors: params.competitors
+  });
+  const result = (0, import_child_process10.spawnSync)("claude", [
+    "--print",
+    "--dangerously-skip-permissions",
+    "--allowedTools",
+    "WebSearch WebFetch",
+    "--output-format",
+    "text"
+  ], {
+    cwd: PROJECT_DIR,
+    input: prompt,
+    encoding: "utf-8",
+    timeout: 3e5,
+    stdio: ["pipe", "pipe", "pipe"],
+    env: process.env
+  });
+  if (result.status !== 0) {
+    console.error(`[growth-research] Claude Code exited with code ${result.status}`);
+    console.error(`[growth-research] stderr: ${(result.stderr || "").slice(-500)}`);
+    return null;
+  }
+  const output = result.stdout || result.stderr || "";
+  const jsonMatch = output.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/) || [null, output];
+  const jsonStr = (jsonMatch[1] || output).trim();
+  try {
+    const parsed = JSON.parse(jsonStr);
+    parsed.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+    return parsed;
+  } catch {
+    const objMatch = output.match(/\{[\s\S]*\}/);
+    if (objMatch) {
+      try {
+        const parsed = JSON.parse(objMatch[0]);
+        parsed.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+        return parsed;
+      } catch {
+        console.error("[growth-research] Failed to parse research output as JSON");
+        console.error("[growth-research] Raw output:", output.slice(-1e3));
+        return null;
+      }
+    }
+    console.error("[growth-research] No JSON found in output");
+    return null;
+  }
+}
+function buildResearchPrompt(params) {
+  const parts = [];
+  parts.push(`You are a growth researcher. Gather REAL data using WebSearch for a marketing campaign.
+
+PRODUCT: ${params.product.name} \u2014 ${params.product.tagline}
+VALUE PROP: ${params.product.value_proposition}
+TARGET AUDIENCE: ${params.product.target_audience}
+
+CAMPAIGN IDEA: ${params.ideaTitle}
+${params.ideaSummary}
+
+TARGET CHANNELS: ${params.channels.join(", ")}
+`);
+  if (params.channels.includes("reddit") || params.subreddits.length > 0) {
+    const subs = params.subreddits.length > 0 ? params.subreddits.join(", ") : "Find 2-3 relevant subreddits for this product";
+    parts.push(`REDDIT RESEARCH:
+- Search for subreddits related to "${params.product.target_audience}"
+- Target subreddits: ${subs}
+- For each subreddit: find subscriber count, self-promotion rules, top post patterns
+- Search: "site:reddit.com ${params.product.name}" to see existing mentions`);
+  }
+  if (params.channels.includes("show_hn")) {
+    parts.push(`HACKER NEWS RESEARCH:
+- Search: "site:news.ycombinator.com Show HN ${params.product.name}" or similar products
+- Find 3-5 successful Show HN posts in the same category
+- Note their titles, upvote counts, and first comment patterns
+- Check what time of day successful posts were submitted`);
+  }
+  if (params.competitors.length > 0) {
+    const compNames = params.competitors.map((c2) => c2.name || String(c2)).slice(0, 5);
+    parts.push(`COMPETITOR RESEARCH:
+- Competitors: ${compNames.join(", ")}
+- Search for their recent social media posts and engagement
+- Find what content angles work for them`);
+  }
+  parts.push(`KEYWORD RESEARCH:
+- Find 3-5 keywords related to: "${params.ideaTitle}"
+- Look for search volume estimates, competition level
+- Identify high-intent keywords for this audience`);
+  parts.push(`TRENDING TOPICS:
+- Search for current trends related to: ${params.product.target_audience}
+- Find trending topics on Twitter/X, Reddit, HN that could be leveraged`);
+  parts.push(`OUTPUT FORMAT \u2014 respond with ONLY valid JSON, no other text:
+{
+  "completed_at": "${(/* @__PURE__ */ new Date()).toISOString()}",
+  "subreddit_research": [
+    {
+      "name": "subreddit_name",
+      "subscribers": 100000,
+      "rules_summary": "Key rules...",
+      "self_promo_policy": "Allowed on Saturdays / Never / With flair",
+      "top_post_patterns": ["Pattern 1", "Pattern 2"]
+    }
+  ],
+  "keyword_research": [
+    {
+      "keyword": "example keyword",
+      "volume": "1K-10K monthly",
+      "cpc": "$2.50",
+      "competition": "medium",
+      "intent": "commercial"
+    }
+  ],
+  "hn_research": {
+    "successful_similar_posts": ["Show HN: Product (500 pts)", "Show HN: Similar (200 pts)"],
+    "upvote_patterns": "Best posted Tue-Thu, 8-10am PST",
+    "first_comment_patterns": "Technical backstory + specific metrics"
+  },
+  "competitor_content": [
+    {
+      "competitor": "Competitor Name",
+      "content_examples": ["They posted X on LinkedIn (500 likes)", "Their blog on Y"],
+      "engagement_level": "high"
+    }
+  ],
+  "trending_topics": ["Topic 1 trending on X", "Topic 2 popular on HN"]
+}`);
+  return parts.join("\n\n");
+}
+
+// src/lib/social-storage.ts
+var import_fs = require("fs");
+var import_path = __toESM(require("path"));
+function getDataDir() {
+  return process.env.AI_ANALYST_DATA_DIR || import_path.default.join(process.cwd(), "data");
+}
+function getSocialFilePath() {
+  return import_path.default.join(getDataDir(), "social.json");
+}
+var EMPTY_STATE4 = {
+  last_updated: (/* @__PURE__ */ new Date()).toISOString(),
+  platform: "x",
+  username: null,
+  credentials_valid: false,
+  drafts: [],
+  metrics: {
+    followers_count: null,
+    post_streak_days: 0,
+    total_posts: 0,
+    last_post_date: null
+  }
+};
+async function readState() {
+  try {
+    const content = await import_fs.promises.readFile(getSocialFilePath(), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { ...EMPTY_STATE4, drafts: [], metrics: { ...EMPTY_STATE4.metrics } };
+  }
+}
+async function writeState(state) {
+  state.last_updated = (/* @__PURE__ */ new Date()).toISOString();
+  const dir = getDataDir();
+  try {
+    await import_fs.promises.access(dir);
+  } catch {
+    await import_fs.promises.mkdir(dir, { recursive: true });
+  }
+  await import_fs.promises.writeFile(getSocialFilePath(), JSON.stringify(state, null, 2), "utf-8");
+}
+async function createSocialDraft(text, opts) {
+  const state = await readState();
+  const isThread = !!(opts?.threadTweets && opts.threadTweets.length > 0);
+  const draft = {
+    id: `draft-${v4_default().slice(0, 8)}`,
+    text,
+    source: isThread ? "thread" : "manual",
+    source_ref: null,
+    status: "draft",
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    published_at: null,
+    tweet_id: null,
+    tweet_url: null,
+    is_thread: isThread,
+    thread_tweets: opts?.threadTweets
+  };
+  state.drafts.push(draft);
+  await writeState(state);
+  return draft;
+}
+
+// scripts/skills/growth-campaign.ts
+var GROWTH_PREFIXES = [
+  "growth-activate-",
+  "growth-research-",
+  "growth-draft-",
+  "growth-publish-",
+  "growth-check-status"
+];
+function isGrowthCampaignTask(taskId) {
+  return GROWTH_PREFIXES.some((prefix) => taskId.startsWith(prefix));
+}
+function appendToTodo2(tasks) {
+  let content = "";
+  if (fs26.existsSync(TODO_FILE)) {
+    content = fs26.readFileSync(TODO_FILE, "utf-8");
+  }
+  const newLines = tasks.map(
+    (t) => `- [ ] **${t.taskId}** \u2014 ${t.description}`
+  ).join("\n");
+  if (content.includes("## High Priority")) {
+    const idx = content.indexOf("## High Priority");
+    const nextSection = content.indexOf("\n## ", idx + 1);
+    const insertPos = nextSection > 0 ? nextSection : content.length;
+    content = content.slice(0, insertPos) + "\n" + newLines + "\n" + content.slice(insertPos);
+  } else {
+    content += `
+## High Priority
+${newLines}
+`;
+  }
+  fs26.writeFileSync(TODO_FILE, content);
+}
+async function executeGrowthCampaignTask(taskId, description, businessContext) {
+  try {
+    if (taskId.startsWith("growth-activate-")) {
+      const ideaId = taskId.replace("growth-activate-", "");
+      return executeActivate(ideaId);
+    }
+    if (taskId.startsWith("growth-research-")) {
+      const ideaId = taskId.replace("growth-research-", "");
+      return executeResearch(ideaId);
+    }
+    if (taskId.startsWith("growth-draft-")) {
+      const rest = taskId.replace("growth-draft-", "");
+      const dashIdx = rest.indexOf("-");
+      if (dashIdx === -1) return { success: false, output: `Invalid draft task ID: ${taskId}` };
+      const ideaId = rest.slice(0, dashIdx);
+      const channel = rest.slice(dashIdx + 1);
+      return await executeDraft(ideaId, channel);
+    }
+    if (taskId.startsWith("growth-publish-")) {
+      const rest = taskId.replace("growth-publish-", "");
+      const dashIdx = rest.indexOf("-");
+      if (dashIdx === -1) return { success: false, output: `Invalid publish task ID: ${taskId}` };
+      const ideaId = rest.slice(0, dashIdx);
+      const channel = rest.slice(dashIdx + 1);
+      return await executePublish2(ideaId, channel);
+    }
+    if (taskId === "growth-check-status") {
+      return executeCheckStatus6();
+    }
+    return { success: false, output: `Unknown growth campaign task: ${taskId}` };
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    return { success: false, output: `Growth campaign task failed: ${errMsg}` };
+  }
+}
+function executeActivate(ideaId) {
+  if (!ideaId) {
+    return { success: false, output: "No idea ID provided" };
+  }
+  let idea;
+  try {
+    const ideasData = JSON.parse(fs26.readFileSync(IDEAS_FILE, "utf-8"));
+    idea = ideasData.ideas.find((i) => i.id === ideaId);
+  } catch {
+    return { success: false, output: `Failed to load ideas from ${IDEAS_FILE}` };
+  }
+  if (!idea) {
+    return { success: false, output: `Idea not found: ${ideaId}` };
+  }
+  if (idea.category !== "growth") {
+    return { success: false, output: `Idea ${ideaId} is not a growth idea (category: ${idea.category})` };
+  }
+  if (idea.stage !== "approved") {
+    return { success: false, output: `Idea ${ideaId} is not approved (stage: ${idea.stage})` };
+  }
+  const existing = loadGrowthCampaignByIdeaId(ideaId);
+  if (existing && existing.status !== "completed") {
+    return { success: false, output: `Active growth campaign already exists for ${ideaId}: ${existing.id}` };
+  }
+  const product = loadProductInfo();
+  if (!product) {
+    return { success: false, output: 'No positioning data found. Run "vibebusiness analyze --type=research" first.' };
+  }
+  const marketingStrategies = loadMarketingStrategies();
+  const channels = resolveChannels(idea.tags, marketingStrategies);
+  if (channels.length === 0) {
+    return { success: false, output: "No target channels resolved. Add channel:xxx tags or configure marketing strategies." };
+  }
+  const channelDrafts = buildChannelDrafts(channels, idea.tags);
+  const subTasks = [];
+  subTasks.push({
+    task_id: `growth-research-${ideaId}`,
+    description: `Research channels and competitors for "${idea.title}"`,
+    status: "queued",
+    depends_on: []
+  });
+  for (const ch of channelDrafts) {
+    const channelLabel = ch.subreddit ? `${ch.channel}_${ch.subreddit}` : ch.channel;
+    subTasks.push({
+      task_id: `growth-draft-${ideaId}-${channelLabel}`,
+      description: `Draft ${ch.channel} content for "${idea.title}"`,
+      status: "queued",
+      depends_on: [`growth-research-${ideaId}`]
+    });
+  }
+  for (const ch of channelDrafts) {
+    const channelLabel = ch.subreddit ? `${ch.channel}_${ch.subreddit}` : ch.channel;
+    subTasks.push({
+      task_id: `growth-publish-${ideaId}-${channelLabel}`,
+      description: `Publish ${ch.channel} content for "${idea.title}" (Day ${ch.scheduled_day})`,
+      status: "queued",
+      depends_on: [`growth-draft-${ideaId}-${channelLabel}`]
+    });
+  }
+  const campaign = createGrowthCampaign({
+    ideaId,
+    ideaTitle: idea.title,
+    channels: channelDrafts,
+    subTasks,
+    product
+  });
+  try {
+    const ideasData = JSON.parse(fs26.readFileSync(IDEAS_FILE, "utf-8"));
+    const ideaIdx = ideasData.ideas.findIndex((i) => i.id === ideaId);
+    if (ideaIdx >= 0) {
+      ideasData.ideas[ideaIdx].stage = "in_progress";
+      ideasData.ideas[ideaIdx].updated_at = (/* @__PURE__ */ new Date()).toISOString();
+      fs26.writeFileSync(IDEAS_FILE, JSON.stringify(ideasData, null, 2) + "\n");
+    }
+  } catch {
+  }
+  appendToTodo2([
+    {
+      taskId: `growth-research-${ideaId}`,
+      description: `Research channels and competitors for "${idea.title}"`
+    }
+  ]);
+  const lines = [
+    `Growth campaign created: ${campaign.id}`,
+    `Channels: ${channels.join(", ")}`,
+    `Sub-tasks queued: ${subTasks.length}`,
+    "",
+    "Next: growth-research will run on the next heartbeat.",
+    "Then: drafts and publishing will follow on subsequent heartbeats."
+  ];
+  return { success: true, output: lines.join("\n") };
+}
+function executeResearch(ideaId) {
+  const campaign = loadGrowthCampaignByIdeaId(ideaId);
+  if (!campaign) {
+    return { success: false, output: `No growth campaign found for idea ${ideaId}` };
+  }
+  const competitors = loadCompetitors();
+  let idea;
+  try {
+    const ideasData = JSON.parse(fs26.readFileSync(IDEAS_FILE, "utf-8"));
+    idea = ideasData.ideas.find((i) => i.id === ideaId);
+  } catch {
+  }
+  const research = executeGrowthResearch({
+    product: campaign.product,
+    channels: campaign.channels,
+    ideaTitle: idea?.title || campaign.source_idea_title,
+    ideaSummary: idea?.summary || "",
+    competitors
+  });
+  if (!research) {
+    return { success: false, output: "Research failed \u2014 Claude Code did not return valid JSON." };
+  }
+  campaign.research = research;
+  campaign.status = "drafting";
+  const researchTask = campaign.sub_tasks.find((t) => t.task_id === `growth-research-${ideaId}`);
+  if (researchTask) researchTask.status = "completed";
+  updateGrowthCampaign(campaign);
+  const draftTasks = campaign.sub_tasks.filter((t) => t.task_id.startsWith(`growth-draft-${ideaId}`)).map((t) => ({ taskId: t.task_id, description: t.description }));
+  if (draftTasks.length > 0) {
+    appendToTodo2(draftTasks);
+  }
+  return {
+    success: true,
+    output: [
+      `Research completed for campaign ${campaign.id}`,
+      `Subreddits found: ${research.subreddit_research.length}`,
+      `Keywords found: ${research.keyword_research.length}`,
+      `Competitor insights: ${research.competitor_content.length}`,
+      `Trending topics: ${research.trending_topics.length}`,
+      "",
+      `Queued ${draftTasks.length} draft tasks for next heartbeats.`
+    ].join("\n")
+  };
+}
+async function executeDraft(ideaId, channel) {
+  const campaign = loadGrowthCampaignByIdeaId(ideaId);
+  if (!campaign) {
+    return { success: false, output: `No growth campaign found for idea ${ideaId}` };
+  }
+  const channelDraft = campaign.channels.find((c2) => {
+    const label = c2.subreddit ? `${c2.channel}_${c2.subreddit}` : c2.channel;
+    return label === channel;
+  });
+  if (!channelDraft) {
+    return { success: false, output: `Channel ${channel} not found in campaign ${campaign.id}` };
+  }
+  let idea;
+  try {
+    const ideasData = JSON.parse(fs26.readFileSync(IDEAS_FILE, "utf-8"));
+    idea = ideasData.ideas.find((i) => i.id === ideaId);
+  } catch {
+    return { success: false, output: `Failed to load ideas from ${IDEAS_FILE}` };
+  }
+  if (!idea) {
+    return { success: false, output: `Idea not found: ${ideaId}` };
+  }
+  const promptCtx = {
+    idea,
+    product: campaign.product,
+    research: campaign.research,
+    utmCampaign: campaign.utm_campaign
+  };
+  const prompt = getChannelPrompt(channelDraft.channel, promptCtx, channelDraft.subreddit);
+  const result = await invokeAI({
+    prompt,
+    timeoutMs: 12e4,
+    expectJson: true
+  });
+  if (result.error) {
+    return { success: false, output: `AI invocation failed for ${channel}: ${result.error}` };
+  }
+  let content;
+  try {
+    const jsonMatch = result.output.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/) || [null, result.output];
+    content = JSON.parse((jsonMatch[1] || result.output).trim());
+  } catch {
+    const objMatch = result.output.match(/\{[\s\S]*\}/);
+    if (objMatch) {
+      try {
+        content = JSON.parse(objMatch[0]);
+      } catch {
+        return { success: false, output: `Failed to parse AI output as JSON for ${channel}` };
+      }
+    } else {
+      return { success: false, output: `No JSON found in AI output for ${channel}` };
+    }
+  }
+  channelDraft.title = content.title || void 0;
+  channelDraft.body = content.body || "";
+  channelDraft.first_comment = content.first_comment || void 0;
+  channelDraft.cta = content.cta || void 0;
+  channelDraft.utm_url = content.utm_url || void 0;
+  channelDraft.platform_constraints = content.platform_constraints || void 0;
+  channelDraft.status = "drafted";
+  channelDraft.drafted_at = (/* @__PURE__ */ new Date()).toISOString();
+  const taskId = `growth-draft-${ideaId}-${channel}`;
+  const subTask = campaign.sub_tasks.find((t) => t.task_id === taskId);
+  if (subTask) subTask.status = "completed";
+  if (channelDraft.channel === "twitter_thread" && channelDraft.body) {
+    try {
+      const threadTweets = content.thread_tweets || [];
+      const draft = await createSocialDraft(channelDraft.body, {
+        threadTweets: threadTweets.length > 0 ? threadTweets : void 0
+      });
+      channelDraft.social_draft_id = draft.id;
+    } catch (err2) {
+      console.error("[growth-campaign] Failed to create social draft:", err2);
+    }
+  }
+  const allDrafted = campaign.channels.every((c2) => c2.status === "drafted" || c2.status === "published");
+  if (allDrafted) {
+    campaign.status = "publishing";
+  }
+  updateGrowthCampaign(campaign);
+  const publishTaskId = `growth-publish-${ideaId}-${channel}`;
+  const publishSubTask = campaign.sub_tasks.find((t) => t.task_id === publishTaskId);
+  if (publishSubTask) {
+    appendToTodo2([{
+      taskId: publishTaskId,
+      description: publishSubTask.description
+    }]);
+  }
+  return {
+    success: true,
+    output: [
+      `Draft generated for ${channelDraft.channel} (campaign ${campaign.id})`,
+      channelDraft.title ? `Title: ${channelDraft.title}` : "",
+      `Body length: ${channelDraft.body?.length || 0} chars`,
+      channelDraft.social_draft_id ? `Twitter draft: ${channelDraft.social_draft_id}` : ""
+    ].filter(Boolean).join("\n")
+  };
+}
+async function executePublish2(ideaId, channel) {
+  const campaign = loadGrowthCampaignByIdeaId(ideaId);
+  if (!campaign) {
+    return { success: false, output: `No growth campaign found for idea ${ideaId}` };
+  }
+  const channelDraft = campaign.channels.find((c2) => {
+    const label = c2.subreddit ? `${c2.channel}_${c2.subreddit}` : c2.channel;
+    return label === channel;
+  });
+  if (!channelDraft) {
+    return { success: false, output: `Channel ${channel} not found in campaign ${campaign.id}` };
+  }
+  if (channelDraft.status !== "drafted") {
+    return { success: false, output: `Channel ${channel} is not drafted yet (status: ${channelDraft.status})` };
+  }
+  if (channelDraft.channel === "twitter_thread" && channelDraft.social_draft_id) {
+    appendToTodo2([{
+      taskId: `social-publish-${channelDraft.social_draft_id}`,
+      description: `Publish Twitter thread for growth campaign "${campaign.source_idea_title}"`
+    }]);
+    channelDraft.status = "published";
+    channelDraft.published_at = (/* @__PURE__ */ new Date()).toISOString();
+    const publishTask2 = campaign.sub_tasks.find((t) => t.task_id === `growth-publish-${ideaId}-${channel}`);
+    if (publishTask2) publishTask2.status = "completed";
+    updateGrowthCampaign(campaign);
+    return {
+      success: true,
+      output: `Twitter publish delegated to social-publish-${channelDraft.social_draft_id}`
+    };
+  }
+  const outputDir = path20.join(DATA_DIR, "campaigns", "output");
+  fs26.mkdirSync(outputDir, { recursive: true });
+  const outputFile = path20.join(outputDir, `${campaign.id}-${channel}.md`);
+  const outputLines = [
+    `# ${channelDraft.channel.replace(/_/g, " ").toUpperCase()} \u2014 Ready to Publish`,
+    "",
+    `**Campaign:** ${campaign.source_idea_title}`,
+    `**Channel:** ${channelDraft.channel}`,
+    channelDraft.subreddit ? `**Subreddit:** r/${channelDraft.subreddit}` : "",
+    `**Generated:** ${channelDraft.drafted_at || "unknown"}`,
+    `**UTM URL:** ${channelDraft.utm_url || "N/A"}`,
+    "",
+    "---",
+    ""
+  ];
+  if (channelDraft.title) {
+    outputLines.push(`## Title
+
+${channelDraft.title}
+`);
+  }
+  if (channelDraft.body) {
+    outputLines.push(`## Content
+
+${channelDraft.body}
+`);
+  }
+  if (channelDraft.first_comment) {
+    outputLines.push(`## First Comment
+
+${channelDraft.first_comment}
+`);
+  }
+  if (channelDraft.cta) {
+    outputLines.push(`## CTA
+
+${channelDraft.cta}
+`);
+  }
+  if (channelDraft.platform_constraints) {
+    outputLines.push(`## Platform Notes
+
+${channelDraft.platform_constraints}
+`);
+  }
+  fs26.writeFileSync(outputFile, outputLines.filter((l2) => l2 !== "").join("\n") + "\n");
+  channelDraft.status = "published";
+  channelDraft.published_at = (/* @__PURE__ */ new Date()).toISOString();
+  const publishTask = campaign.sub_tasks.find((t) => t.task_id === `growth-publish-${ideaId}-${channel}`);
+  if (publishTask) publishTask.status = "completed";
+  const allPublished = campaign.channels.every((c2) => c2.status === "published");
+  if (allPublished) {
+    campaign.status = "completed";
+    try {
+      const ideasData = JSON.parse(fs26.readFileSync(IDEAS_FILE, "utf-8"));
+      const ideaIdx = ideasData.ideas.findIndex((i) => i.id === ideaId);
+      if (ideaIdx >= 0 && ideasData.ideas[ideaIdx].stage === "in_progress") {
+        ideasData.ideas[ideaIdx].stage = "testing";
+        ideasData.ideas[ideaIdx].updated_at = (/* @__PURE__ */ new Date()).toISOString();
+        fs26.writeFileSync(IDEAS_FILE, JSON.stringify(ideasData, null, 2) + "\n");
+      }
+    } catch {
+    }
+  }
+  updateGrowthCampaign(campaign);
+  return {
+    success: true,
+    output: [
+      `Content ready for ${channelDraft.channel}: ${outputFile}`,
+      allPublished ? "All channels published \u2014 campaign completed!" : ""
+    ].filter(Boolean).join("\n")
+  };
+}
+function executeCheckStatus6() {
+  const campaigns = listGrowthCampaigns();
+  if (campaigns.length === 0) {
+    return { success: true, output: "No growth campaigns found." };
+  }
+  const lines = ["## Growth Campaign Status\n"];
+  for (const campaign of campaigns.slice(0, 10)) {
+    const completed = campaign.sub_tasks.filter((t) => t.status === "completed").length;
+    const total = campaign.sub_tasks.length;
+    const pct = total > 0 ? Math.round(completed / total * 100) : 0;
+    lines.push(`### ${campaign.id} (${campaign.status})`);
+    lines.push(`- Idea: ${campaign.source_idea_title}`);
+    lines.push(`- Created: ${campaign.created_at.split("T")[0]}`);
+    lines.push(`- Channels: ${campaign.channels.map((c2) => c2.channel).join(", ")}`);
+    lines.push(`- Progress: ${completed}/${total} tasks (${pct}%)`);
+    lines.push(`- Research: ${campaign.research ? "completed" : "pending"}`);
+    for (const ch of campaign.channels) {
+      lines.push(`  - ${ch.channel}: ${ch.status}${ch.body ? ` (${ch.body.length} chars)` : ""}`);
+    }
+    lines.push("");
+  }
+  return { success: true, output: lines.join("\n") };
+}
+function readGrowthCampaignFreshness() {
+  const campaigns = listGrowthCampaigns();
+  return {
+    active_growth_campaigns: campaigns.filter((c2) => c2.status !== "completed").length,
+    completed_growth_campaigns: campaigns.filter((c2) => c2.status === "completed").length,
+    last_growth_campaign_date: campaigns.length > 0 ? campaigns[0].created_at.split("T")[0] : null
+  };
+}
+
 // scripts/heartbeat.ts
 init_marketing_strategy();
 init_ai_provider();
 
 // scripts/lib/run.ts
-var path18 = __toESM(require("path"));
+var path21 = __toESM(require("path"));
 function resolveScript(baseDir, scriptName) {
-  const isCompiled = path18.extname(__filename) === ".js";
+  const isCompiled = path21.extname(__filename) === ".js";
   const resolvedName = isCompiled ? scriptName.replace(/\.ts$/, ".js") : scriptName;
-  const scriptPath = path18.join(baseDir, resolvedName);
+  const scriptPath = path21.join(baseDir, resolvedName);
   return isCompiled ? { command: "node", args: [scriptPath] } : { command: "npx", args: ["tsx", scriptPath] };
 }
 
@@ -34033,8 +35107,8 @@ function groupTasksByConflicts(tasks) {
 }
 
 // scripts/lib/json-lock.ts
-var fs24 = __toESM(require("fs"));
-var path19 = __toESM(require("path"));
+var fs27 = __toESM(require("fs"));
+var path22 = __toESM(require("path"));
 var DEFAULT_MAX_WAIT_MS = 1e4;
 var BASE_BACKOFF_MS = 50;
 var MAX_BACKOFF_MS = 150;
@@ -34042,10 +35116,10 @@ function withFileLock(lockPath, fn, maxWaitMs = DEFAULT_MAX_WAIT_MS) {
   const startTime = Date.now();
   while (true) {
     try {
-      fs24.mkdirSync(lockPath, { recursive: false });
+      fs27.mkdirSync(lockPath, { recursive: false });
       try {
-        fs24.writeFileSync(
-          path19.join(lockPath, "owner"),
+        fs27.writeFileSync(
+          path22.join(lockPath, "owner"),
           JSON.stringify({ pid: process.pid, acquired: Date.now() })
         );
       } catch {
@@ -34074,16 +35148,16 @@ function withFileLock(lockPath, fn, maxWaitMs = DEFAULT_MAX_WAIT_MS) {
 }
 function atomicWriteFileSync(filePath, content) {
   const tmpPath = `${filePath}.${process.pid}.tmp`;
-  fs24.writeFileSync(tmpPath, content, "utf-8");
-  fs24.renameSync(tmpPath, filePath);
+  fs27.writeFileSync(tmpPath, content, "utf-8");
+  fs27.renameSync(tmpPath, filePath);
 }
 function releaseLock(lockPath) {
   try {
-    const ownerFile = path19.join(lockPath, "owner");
-    if (fs24.existsSync(ownerFile)) {
-      fs24.unlinkSync(ownerFile);
+    const ownerFile = path22.join(lockPath, "owner");
+    if (fs27.existsSync(ownerFile)) {
+      fs27.unlinkSync(ownerFile);
     }
-    fs24.rmdirSync(lockPath);
+    fs27.rmdirSync(lockPath);
   } catch {
   }
 }
@@ -34094,57 +35168,57 @@ function sleepSync(ms2) {
 }
 
 // scripts/lib/worktree.ts
-var fs26 = __toESM(require("fs"));
-var path21 = __toESM(require("path"));
+var fs29 = __toESM(require("fs"));
+var path24 = __toESM(require("path"));
 
 // scripts/lib/git-utils.ts
-var import_child_process10 = require("child_process");
-var fs25 = __toESM(require("fs"));
-var path20 = __toESM(require("path"));
+var import_child_process11 = require("child_process");
+var fs28 = __toESM(require("fs"));
+var path23 = __toESM(require("path"));
 function cleanGitState(workspacePath) {
-  if (!fs25.existsSync(workspacePath)) return;
-  const gitDir = path20.join(workspacePath, ".git");
-  if (!fs25.existsSync(gitDir)) return;
+  if (!fs28.existsSync(workspacePath)) return;
+  const gitDir = path23.join(workspacePath, ".git");
+  if (!fs28.existsSync(gitDir)) return;
   let actualGitDir = gitDir;
   try {
-    const stat = fs25.statSync(gitDir);
+    const stat = fs28.statSync(gitDir);
     if (stat.isFile()) {
-      const content = fs25.readFileSync(gitDir, "utf-8").trim();
+      const content = fs28.readFileSync(gitDir, "utf-8").trim();
       const match = content.match(/^gitdir:\s+(.+)$/);
       if (match) actualGitDir = match[1];
     }
   } catch {
     return;
   }
-  const lockFile = path20.join(actualGitDir, "index.lock");
-  if (fs25.existsSync(lockFile)) {
+  const lockFile = path23.join(actualGitDir, "index.lock");
+  if (fs28.existsSync(lockFile)) {
     try {
-      const result = (0, import_child_process10.execSync)(
+      const result = (0, import_child_process11.execSync)(
         `lsof "${lockFile}" 2>/dev/null || true`,
         { encoding: "utf-8", timeout: 5e3 }
       ).trim();
       if (!result) {
-        fs25.unlinkSync(lockFile);
+        fs28.unlinkSync(lockFile);
         console.log(`[pre-flight] Removed stale .git/index.lock in ${workspacePath}`);
       }
     } catch {
       try {
-        fs25.unlinkSync(lockFile);
+        fs28.unlinkSync(lockFile);
         console.log(`[pre-flight] Removed stale .git/index.lock in ${workspacePath}`);
       } catch {
       }
     }
   }
   const staleOps = [
-    { marker: path20.join(actualGitDir, "MERGE_HEAD"), abort: "git merge --abort" },
-    { marker: path20.join(actualGitDir, "rebase-merge"), abort: "git rebase --abort" },
-    { marker: path20.join(actualGitDir, "rebase-apply"), abort: "git rebase --abort" },
-    { marker: path20.join(actualGitDir, "CHERRY_PICK_HEAD"), abort: "git cherry-pick --abort" }
+    { marker: path23.join(actualGitDir, "MERGE_HEAD"), abort: "git merge --abort" },
+    { marker: path23.join(actualGitDir, "rebase-merge"), abort: "git rebase --abort" },
+    { marker: path23.join(actualGitDir, "rebase-apply"), abort: "git rebase --abort" },
+    { marker: path23.join(actualGitDir, "CHERRY_PICK_HEAD"), abort: "git cherry-pick --abort" }
   ];
   for (const { marker, abort } of staleOps) {
-    if (fs25.existsSync(marker)) {
+    if (fs28.existsSync(marker)) {
       try {
-        (0, import_child_process10.execSync)(abort, { cwd: workspacePath, encoding: "utf-8", timeout: 1e4, stdio: "pipe" });
+        (0, import_child_process11.execSync)(abort, { cwd: workspacePath, encoding: "utf-8", timeout: 1e4, stdio: "pipe" });
         console.log(`[pre-flight] Aborted stale operation: ${abort} in ${workspacePath}`);
       } catch {
       }
@@ -34153,7 +35227,7 @@ function cleanGitState(workspacePath) {
 }
 function execGit(args2, cwd, timeoutMs) {
   try {
-    return (0, import_child_process10.execFileSync)("git", args2, {
+    return (0, import_child_process11.execFileSync)("git", args2, {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
@@ -34216,8 +35290,8 @@ function sanitizeForCommitMessage(msg) {
 // scripts/lib/worktree.ts
 function getWorktreePaths(workspaceDir, repoName) {
   return {
-    baseClonePath: path21.join(workspaceDir, repoName),
-    worktreeContainerDir: path21.join(workspaceDir, `${repoName}-worktrees`)
+    baseClonePath: path24.join(workspaceDir, repoName),
+    worktreeContainerDir: path24.join(workspaceDir, `${repoName}-worktrees`)
   };
 }
 function syncBaseClone(baseClonePath, defaultBranch) {
@@ -34236,16 +35310,16 @@ function ensureIdeaBranch(baseClonePath, branchName, defaultBranch) {
   }
 }
 function createWorktree(baseClonePath, worktreeContainerDir, ideaBranch, groupIndex) {
-  if (!fs26.existsSync(worktreeContainerDir)) {
-    fs26.mkdirSync(worktreeContainerDir, { recursive: true });
+  if (!fs29.existsSync(worktreeContainerDir)) {
+    fs29.mkdirSync(worktreeContainerDir, { recursive: true });
   }
   const tempBranch = `wt/${ideaBranch}-g${groupIndex}`;
-  const worktreePath = path21.join(worktreeContainerDir, `${ideaBranch}-g${groupIndex}`);
-  if (fs26.existsSync(worktreePath)) {
+  const worktreePath = path24.join(worktreeContainerDir, `${ideaBranch}-g${groupIndex}`);
+  if (fs29.existsSync(worktreePath)) {
     try {
       execGit(["worktree", "remove", "--force", worktreePath], baseClonePath, 1e4);
     } catch {
-      fs26.rmSync(worktreePath, { recursive: true, force: true });
+      fs29.rmSync(worktreePath, { recursive: true, force: true });
     }
   }
   try {
@@ -34279,7 +35353,7 @@ function removeWorktree(baseClonePath, worktreePath, tempBranch) {
     execGit(["worktree", "remove", "--force", worktreePath], baseClonePath, 1e4);
   } catch {
     try {
-      fs26.rmSync(worktreePath, { recursive: true, force: true });
+      fs29.rmSync(worktreePath, { recursive: true, force: true });
     } catch {
     }
   }
@@ -34289,12 +35363,12 @@ function removeWorktree(baseClonePath, worktreePath, tempBranch) {
   }
 }
 function cleanupIdeaWorktrees(baseClonePath, worktreeContainerDir, ideaBranch) {
-  if (fs26.existsSync(worktreeContainerDir)) {
+  if (fs29.existsSync(worktreeContainerDir)) {
     try {
-      const entries = fs26.readdirSync(worktreeContainerDir);
+      const entries = fs29.readdirSync(worktreeContainerDir);
       for (const entry of entries) {
         if (entry.startsWith(`${ideaBranch}-g`)) {
-          const wtPath = path21.join(worktreeContainerDir, entry);
+          const wtPath = path24.join(worktreeContainerDir, entry);
           const groupMatch = entry.match(/-g(\d+)$/);
           const tempBranch = `wt/${ideaBranch}-g${groupMatch?.[1] ?? "0"}`;
           removeWorktree(baseClonePath, wtPath, tempBranch);
@@ -34308,9 +35382,9 @@ function cleanupIdeaWorktrees(baseClonePath, worktreeContainerDir, ideaBranch) {
   } catch {
   }
   try {
-    const remaining = fs26.readdirSync(worktreeContainerDir);
+    const remaining = fs29.readdirSync(worktreeContainerDir);
     if (remaining.length === 0) {
-      fs26.rmdirSync(worktreeContainerDir);
+      fs29.rmdirSync(worktreeContainerDir);
     }
   } catch {
   }
@@ -34320,24 +35394,24 @@ function getTempBranchName(ideaBranch, groupIndex) {
 }
 
 // scripts/lib/telemetry.ts
-var fs27 = __toESM(require("fs"));
-var path22 = __toESM(require("path"));
-var CONFIG_DIR2 = path22.join(
+var fs30 = __toESM(require("fs"));
+var path25 = __toESM(require("path"));
+var CONFIG_DIR2 = path25.join(
   process.env.HOME || process.env.USERPROFILE || "~",
   ".vibebusiness"
 );
-var TELEMETRY_CONFIG_FILE = path22.join(CONFIG_DIR2, "telemetry.json");
-var EVENTS_FILE = path22.join(CONFIG_DIR2, "events.jsonl");
+var TELEMETRY_CONFIG_FILE = path25.join(CONFIG_DIR2, "telemetry.json");
+var EVENTS_FILE = path25.join(CONFIG_DIR2, "events.jsonl");
 function getVersion() {
   try {
     let dir = __dirname;
     for (let i = 0; i < 4; i++) {
-      const pkgPath = path22.join(dir, "package.json");
-      if (fs27.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs27.readFileSync(pkgPath, "utf-8"));
+      const pkgPath = path25.join(dir, "package.json");
+      if (fs30.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs30.readFileSync(pkgPath, "utf-8"));
         return pkg.version || "0.0.0";
       }
-      dir = path22.dirname(dir);
+      dir = path25.dirname(dir);
     }
   } catch {
   }
@@ -34345,8 +35419,8 @@ function getVersion() {
 }
 function getTelemetryConfig() {
   try {
-    if (!fs27.existsSync(TELEMETRY_CONFIG_FILE)) return null;
-    return JSON.parse(fs27.readFileSync(TELEMETRY_CONFIG_FILE, "utf-8"));
+    if (!fs30.existsSync(TELEMETRY_CONFIG_FILE)) return null;
+    return JSON.parse(fs30.readFileSync(TELEMETRY_CONFIG_FILE, "utf-8"));
   } catch {
     return null;
   }
@@ -34367,31 +35441,31 @@ function trackEvent(event, properties = {}) {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       version: getVersion()
     };
-    fs27.mkdirSync(CONFIG_DIR2, { recursive: true });
-    fs27.appendFileSync(EVENTS_FILE, JSON.stringify(entry) + "\n");
+    fs30.mkdirSync(CONFIG_DIR2, { recursive: true });
+    fs30.appendFileSync(EVENTS_FILE, JSON.stringify(entry) + "\n");
   } catch {
   }
 }
 
 // src/lib/storage.ts
-var import_fs = require("fs");
-var import_path = __toESM(require("path"));
-function getDataDir() {
-  return process.env.AI_ANALYST_DATA_DIR || import_path.default.join(process.cwd(), "data");
+var import_fs2 = require("fs");
+var import_path2 = __toESM(require("path"));
+function getDataDir2() {
+  return process.env.AI_ANALYST_DATA_DIR || import_path2.default.join(process.cwd(), "data");
 }
 function getFilePath(filename) {
-  return import_path.default.join(getDataDir(), filename);
+  return import_path2.default.join(getDataDir2(), filename);
 }
 async function ensureDataDir() {
   try {
-    await import_fs.promises.access(getDataDir());
+    await import_fs2.promises.access(getDataDir2());
   } catch {
-    await import_fs.promises.mkdir(getDataDir(), { recursive: true });
+    await import_fs2.promises.mkdir(getDataDir2(), { recursive: true });
   }
 }
 async function readJsonFile(filePath, defaultValue) {
   try {
-    const content = await import_fs.promises.readFile(filePath, "utf-8");
+    const content = await import_fs2.promises.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return defaultValue;
@@ -34399,7 +35473,7 @@ async function readJsonFile(filePath, defaultValue) {
 }
 async function writeJsonFile(filePath, data) {
   await ensureDataDir();
-  await import_fs.promises.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+  await import_fs2.promises.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
 }
 async function getIdeas() {
   const store = await readJsonFile(getFilePath("ideas.json"), { ideas: [] });
@@ -34600,8 +35674,8 @@ async function suggestEpics(opts) {
 }
 
 // src/lib/social-hooks.ts
-var import_fs2 = require("fs");
-var import_path2 = __toESM(require("path"));
+var import_fs3 = require("fs");
+var import_path3 = __toESM(require("path"));
 
 // src/lib/social.ts
 function scoreDraft2(text) {
@@ -34641,10 +35715,10 @@ function emptySocialState() {
 }
 async function triggerSocialDraftForShip(ideaId, idea) {
   try {
-    const socialFile = import_path2.default.join(getDataDir(), "social.json");
+    const socialFile = import_path3.default.join(getDataDir2(), "social.json");
     let state;
     try {
-      const raw = await import_fs2.promises.readFile(socialFile, "utf-8");
+      const raw = await import_fs3.promises.readFile(socialFile, "utf-8");
       state = JSON.parse(raw);
     } catch {
       state = emptySocialState();
@@ -34677,8 +35751,8 @@ async function triggerSocialDraftForShip(ideaId, idea) {
     const draft = isHighPotential ? { ...draftBase, high_potential: true } : draftBase;
     state.drafts.push(draft);
     state.last_updated = now;
-    await import_fs2.promises.mkdir(import_path2.default.dirname(socialFile), { recursive: true });
-    await import_fs2.promises.writeFile(socialFile, JSON.stringify(state, null, 2), "utf-8");
+    await import_fs3.promises.mkdir(import_path3.default.dirname(socialFile), { recursive: true });
+    await import_fs3.promises.writeFile(socialFile, JSON.stringify(state, null, 2), "utf-8");
     console.log(`[social-hooks] ship draft created draft_id=${draftId} idea_id=${ideaId}`);
   } catch (err2) {
     const message = err2 instanceof Error ? err2.message : String(err2);
@@ -34687,22 +35761,22 @@ async function triggerSocialDraftForShip(ideaId, idea) {
 }
 
 // scripts/lib/scaffold.ts
-var fs30 = __toESM(require("fs"));
-var path25 = __toESM(require("path"));
+var fs33 = __toESM(require("fs"));
+var path28 = __toESM(require("path"));
 function scaffoldSlashCommands(rootDir) {
-  let templatesDir = path25.join(__dirname, "..", "..", "templates", "commands");
-  if (!fs30.existsSync(templatesDir)) {
-    templatesDir = path25.join(__dirname, "..", "..", "..", "templates", "commands");
-  }
-  if (!fs30.existsSync(templatesDir)) return;
-  const targetDir = path25.join(rootDir, ".claude", "commands");
-  fs30.mkdirSync(targetDir, { recursive: true });
-  const templates = fs30.readdirSync(templatesDir).filter((f) => f.endsWith(".md"));
+  let templatesDir = path28.join(__dirname, "..", "..", "templates", "commands");
+  if (!fs33.existsSync(templatesDir)) {
+    templatesDir = path28.join(__dirname, "..", "..", "..", "templates", "commands");
+  }
+  if (!fs33.existsSync(templatesDir)) return;
+  const targetDir = path28.join(rootDir, ".claude", "commands");
+  fs33.mkdirSync(targetDir, { recursive: true });
+  const templates = fs33.readdirSync(templatesDir).filter((f) => f.endsWith(".md"));
   let copied = 0;
   for (const file of templates) {
-    const src = path25.join(templatesDir, file);
-    const dest = path25.join(targetDir, file);
-    fs30.copyFileSync(src, dest);
+    const src = path28.join(templatesDir, file);
+    const dest = path28.join(targetDir, file);
+    fs33.copyFileSync(src, dest);
     copied++;
   }
   if (copied > 0) {
@@ -34711,23 +35785,23 @@ function scaffoldSlashCommands(rootDir) {
 }
 
 // scripts/lib/vibe-credits.ts
-var fs31 = __toESM(require("fs"));
-var path26 = __toESM(require("path"));
+var fs34 = __toESM(require("fs"));
+var path29 = __toESM(require("path"));
 var WORKER_URL = "https://vibe-credits.luis-e13.workers.dev";
-var CONFIG_DIR3 = path26.join(process.env.HOME || "", ".vibebusiness");
-var BUFFER_FILE = path26.join(CONFIG_DIR3, "vibe-buffer.json");
+var CONFIG_DIR3 = path29.join(process.env.HOME || "", ".vibebusiness");
+var BUFFER_FILE = path29.join(CONFIG_DIR3, "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 = path26.join(dir, "package.json");
-      if (fs31.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs31.readFileSync(pkgPath, "utf-8"));
+      const pkgPath = path29.join(dir, "package.json");
+      if (fs34.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs34.readFileSync(pkgPath, "utf-8"));
         return pkg.version || "0.0.0";
       }
-      dir = path26.dirname(dir);
+      dir = path29.dirname(dir);
     }
   } catch {
   }
@@ -34736,18 +35810,18 @@ function getClientVersion() {
 var CLIENT_VERSION = getClientVersion();
 function loadBuffer() {
   try {
-    if (fs31.existsSync(BUFFER_FILE)) {
-      return JSON.parse(fs31.readFileSync(BUFFER_FILE, "utf-8"));
+    if (fs34.existsSync(BUFFER_FILE)) {
+      return JSON.parse(fs34.readFileSync(BUFFER_FILE, "utf-8"));
     }
   } catch {
   }
   return { vibes: 0, last_synced: "" };
 }
 function saveBuffer(buffer) {
-  if (!fs31.existsSync(CONFIG_DIR3)) {
-    fs31.mkdirSync(CONFIG_DIR3, { recursive: true });
+  if (!fs34.existsSync(CONFIG_DIR3)) {
+    fs34.mkdirSync(CONFIG_DIR3, { recursive: true });
   }
-  fs31.writeFileSync(BUFFER_FILE, JSON.stringify(buffer, null, 2));
+  fs34.writeFileSync(BUFFER_FILE, JSON.stringify(buffer, null, 2));
 }
 function syncBuffer(vibesRemaining) {
   const buffered = Math.min(vibesRemaining, MAX_BUFFER);
@@ -34821,14 +35895,14 @@ async function consumeVibe(instanceId) {
 }
 
 // scripts/lib/license.ts
-var fs32 = __toESM(require("fs"));
-var path27 = __toESM(require("path"));
-var CONFIG_DIR4 = path27.join(process.env.HOME || "", ".vibebusiness");
-var LICENSE_FILE = path27.join(CONFIG_DIR4, "license.json");
+var fs35 = __toESM(require("fs"));
+var path30 = __toESM(require("path"));
+var CONFIG_DIR4 = path30.join(process.env.HOME || "", ".vibebusiness");
+var LICENSE_FILE = path30.join(CONFIG_DIR4, "license.json");
 function loadStoredLicense() {
   try {
-    if (fs32.existsSync(LICENSE_FILE)) {
-      return JSON.parse(fs32.readFileSync(LICENSE_FILE, "utf-8"));
+    if (fs35.existsSync(LICENSE_FILE)) {
+      return JSON.parse(fs35.readFileSync(LICENSE_FILE, "utf-8"));
     }
   } catch {
   }
@@ -34846,14 +35920,361 @@ function getInstanceId() {
   return generateInstanceId();
 }
 
+// scripts/lib/vision/validation.ts
+var fs38 = __toESM(require("fs"));
+init_paths();
+
+// scripts/lib/vision/define.ts
+var fs36 = __toESM(require("fs"));
+init_ai_provider();
+init_paths();
+var PROJECT_DIR2 = PRODUCT_VISION_FILE.replace(/\/data\/product-vision\.json$/, "");
+function loadProductVision() {
+  if (!fs36.existsSync(PRODUCT_VISION_FILE)) return null;
+  try {
+    return JSON.parse(fs36.readFileSync(PRODUCT_VISION_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+// scripts/lib/vision/hypotheses.ts
+var fs37 = __toESM(require("fs"));
+init_paths();
+function loadJson(filePath, defaultValue) {
+  try {
+    if (!fs37.existsSync(filePath)) return defaultValue;
+    return JSON.parse(fs37.readFileSync(filePath, "utf-8"));
+  } catch {
+    return defaultValue;
+  }
+}
+function saveJson(filePath, data) {
+  fs37.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+function updateHypothesisEvidence(hypothesisId, evidence, direction) {
+  const store = loadJson(HYPOTHESES_FILE, { hypotheses: [] });
+  const hypothesis = store.hypotheses.find((h3) => h3.id === hypothesisId);
+  if (!hypothesis) return false;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const entry = `[${now.split("T")[0]}] ${evidence}`;
+  if (direction === "for") {
+    hypothesis.evidence_for.push(entry);
+  } else {
+    hypothesis.evidence_against.push(entry);
+  }
+  const forCount = hypothesis.evidence_for.length;
+  const againstCount = hypothesis.evidence_against.length;
+  if (forCount >= 3 && againstCount === 0) {
+    hypothesis.status = "validated";
+  } else if (againstCount >= 2 && forCount <= againstCount) {
+    hypothesis.status = "invalidated";
+  } else if (forCount > 0 || againstCount > 0) {
+    hypothesis.status = "testing";
+  }
+  hypothesis.updated_at = now;
+  saveJson(HYPOTHESES_FILE, store);
+  return true;
+}
+
+// scripts/lib/vision/validation.ts
+function loadJson2(filePath, defaultValue) {
+  try {
+    if (!fs38.existsSync(filePath)) return defaultValue;
+    return JSON.parse(fs38.readFileSync(filePath, "utf-8"));
+  } catch {
+    return defaultValue;
+  }
+}
+function evaluateVisionHealth(vision, hypotheses) {
+  const v2 = vision || loadProductVision();
+  const store = loadJson2(HYPOTHESES_FILE, { hypotheses: [] });
+  const hyps = hypotheses || store.hypotheses;
+  if (!v2 || hyps.length === 0) {
+    return {
+      confidence: 0,
+      summary: v2 ? "No hypotheses to evaluate" : "No product vision defined",
+      breakdown: { stated: 0, testing: 0, validated: 0, invalidated: 0, deferred: 0 }
+    };
+  }
+  const breakdown = {
+    stated: 0,
+    testing: 0,
+    validated: 0,
+    invalidated: 0,
+    deferred: 0
+  };
+  for (const h3 of hyps) {
+    breakdown[h3.status] = (breakdown[h3.status] || 0) + 1;
+  }
+  const activeHyps = hyps.filter((h3) => h3.status !== "deferred");
+  if (activeHyps.length === 0) {
+    return { confidence: 50, summary: "All hypotheses deferred", breakdown };
+  }
+  const validated = breakdown.validated || 0;
+  const invalidated = breakdown.invalidated || 0;
+  const testing = breakdown.testing || 0;
+  const stated = breakdown.stated || 0;
+  const total = activeHyps.length;
+  const validatedRatio = validated / total;
+  const invalidatedRatio = invalidated / total;
+  const testedRatio = (validated + invalidated + testing) / total;
+  let confidence = 50;
+  confidence += Math.round(validatedRatio * 40);
+  confidence -= Math.round(invalidatedRatio * 30);
+  confidence += Math.round(testedRatio * 10);
+  confidence = Math.max(0, Math.min(100, confidence));
+  const parts = [];
+  if (validated > 0) parts.push(`${validated} validated`);
+  if (testing > 0) parts.push(`${testing} testing`);
+  if (stated > 0) parts.push(`${stated} untested`);
+  if (invalidated > 0) parts.push(`${invalidated} invalidated`);
+  const summary = `Vision confidence: ${confidence}/100 (${parts.join(", ")})`;
+  return { confidence, summary, breakdown };
+}
+function suggestVisionPivot(invalidatedHypotheses) {
+  if (invalidatedHypotheses.length === 0) {
+    return { pivot_areas: [], suggestions: [] };
+  }
+  const pivotAreas = /* @__PURE__ */ new Set();
+  const suggestions = [];
+  for (const h3 of invalidatedHypotheses) {
+    switch (h3.funnel_stage) {
+      case "acquisition":
+        pivotAreas.add("market_category");
+        pivotAreas.add("best_fit_customers");
+        suggestions.push(`Acquisition hypothesis "${h3.title}" failed \u2014 reconsider target audience or market category`);
+        break;
+      case "engagement":
+        pivotAreas.add("value_delivered");
+        pivotAreas.add("unique_attributes");
+        suggestions.push(`Engagement hypothesis "${h3.title}" failed \u2014 reconsider value proposition or unique attributes`);
+        break;
+      case "conversion":
+        pivotAreas.add("call_to_action");
+        pivotAreas.add("plan");
+        suggestions.push(`Conversion hypothesis "${h3.title}" failed \u2014 reconsider onboarding plan or CTA`);
+        break;
+      case "monetization":
+        pivotAreas.add("positioning_statement");
+        suggestions.push(`Monetization hypothesis "${h3.title}" failed \u2014 reconsider pricing or positioning`);
+        break;
+      default:
+        pivotAreas.add("general");
+        suggestions.push(`Hypothesis "${h3.title}" (${h3.funnel_stage}) failed \u2014 review vision alignment`);
+    }
+  }
+  return {
+    pivot_areas: Array.from(pivotAreas),
+    suggestions
+  };
+}
+function generateValidationReport() {
+  const vision = loadProductVision();
+  const store = loadJson2(HYPOTHESES_FILE, { hypotheses: [] });
+  const hyps = store.hypotheses;
+  const health = evaluateVisionHealth(vision, hyps);
+  const uncertain = hyps.filter((h3) => h3.status === "stated" || h3.status === "testing").sort((a, b) => {
+    const aEvidence = a.evidence_for.length + a.evidence_against.length;
+    const bEvidence = b.evidence_for.length + b.evidence_against.length;
+    return aEvidence - bEvidence;
+  }).slice(0, 3).map((h3) => ({ id: h3.id, title: h3.title, funnel_stage: h3.funnel_stage }));
+  const invalidated = hyps.filter((h3) => h3.status === "invalidated");
+  const pivot = suggestVisionPivot(invalidated);
+  return {
+    vision_exists: !!vision,
+    one_liner: vision?.one_liner || null,
+    focus_metric: vision?.focus_metric || null,
+    confidence_score: health.confidence,
+    hypotheses: {
+      total: hyps.length,
+      validated: health.breakdown.validated || 0,
+      invalidated: health.breakdown.invalidated || 0,
+      testing: health.breakdown.testing || 0,
+      untested: health.breakdown.stated || 0,
+      top_uncertain: uncertain
+    },
+    pivot_needed: invalidated.length >= 2,
+    pivot_suggestions: pivot.suggestions
+  };
+}
+function updateHypothesisFromEvaluation(hypothesisId, verificationStatus, evaluationSummary) {
+  if (!hypothesisId) return false;
+  const direction = verificationStatus === "validated" ? "for" : verificationStatus === "invalidated" ? "against" : verificationStatus === "needs_investigation" ? "against" : "for";
+  const evidence = `[${verificationStatus}] ${evaluationSummary.slice(0, 200)}`;
+  return updateHypothesisEvidence(hypothesisId, evidence, direction);
+}
+
+// scripts/lib/vision/acceptance-tests.ts
+var fs39 = __toESM(require("fs"));
+var path31 = __toESM(require("path"));
+var import_child_process12 = require("child_process");
+init_ai_provider();
+var PROJECT_DIR3 = path31.resolve(__dirname, "..", "..", "..");
+async function generateAcceptanceTests(idea, targetRepo) {
+  if (!idea.success_metrics || idea.success_metrics.length === 0) {
+    return { file: null, content: "", error: "No success metrics defined" };
+  }
+  const workspacePath = targetRepo.path;
+  let existingPatterns = "";
+  try {
+    const e2eDir = path31.join(workspacePath, "e2e");
+    const testsDir = path31.join(workspacePath, "tests");
+    const searchDir = fs39.existsSync(e2eDir) ? e2eDir : fs39.existsSync(testsDir) ? testsDir : null;
+    if (searchDir) {
+      const files = fs39.readdirSync(searchDir).filter((f) => f.endsWith(".spec.ts") || f.endsWith(".test.ts"));
+      if (files.length > 0) {
+        const sample = fs39.readFileSync(path31.join(searchDir, files[0]), "utf-8").slice(0, 2e3);
+        existingPatterns = `
+EXISTING TEST PATTERN (follow this style):
+\`\`\`typescript
+${sample}
+\`\`\``;
+      }
+    }
+  } catch {
+  }
+  const prompt = `You are a QA engineer. Generate Playwright acceptance tests for a feature.
+
+IDEA: ${idea.title}
+SUMMARY: ${idea.summary}
+
+SUCCESS METRICS (each must have at least one test):
+${idea.success_metrics.map((m2, i) => `${i + 1}. ${m2}`).join("\n")}
+
+IMPLEMENTATION PLAN:
+${idea.implementation_plan}
+${existingPatterns}
+
+Generate a complete Playwright test file. Requirements:
+- Use @playwright/test imports
+- Each success metric should map to at least one test
+- Use descriptive test names that reference the metric
+- Use page.goto(), locators, and expect() assertions
+- Tests should be independent (no shared state)
+- Include reasonable timeouts and waits
+- Use data-testid selectors when specific selectors are unknown
+
+Respond with ONLY the TypeScript code (no markdown code blocks, no explanation):`;
+  const aiResult = await invokeAI({
+    prompt,
+    cwd: PROJECT_DIR3,
+    timeoutMs: 12e4,
+    useStdin: true
+  });
+  if (aiResult.error || !aiResult.output.trim()) {
+    return { file: null, content: "", error: aiResult.error || "empty output" };
+  }
+  let content = aiResult.output.trim();
+  const codeMatch = content.match(/```(?:typescript|ts)?\s*([\s\S]*?)```/);
+  if (codeMatch) {
+    content = codeMatch[1].trim();
+  }
+  const slug = idea.id.replace(/^idea-/, "").replace(/[^a-z0-9-]/g, "-").slice(0, 40);
+  const fileName = `acceptance-${slug}.spec.ts`;
+  return { file: fileName, content };
+}
+function writeAcceptanceTests(testResult, targetRepoPath) {
+  if (!testResult.file || !testResult.content) return null;
+  const e2eDir = path31.join(targetRepoPath, "e2e");
+  if (!fs39.existsSync(e2eDir)) {
+    fs39.mkdirSync(e2eDir, { recursive: true });
+  }
+  const filePath = path31.join(e2eDir, testResult.file);
+  fs39.writeFileSync(filePath, testResult.content + "\n");
+  return filePath;
+}
+function runAcceptanceTests(testFile, workspacePath) {
+  const absolutePath = path31.isAbsolute(testFile) ? testFile : path31.join(workspacePath, testFile);
+  if (!fs39.existsSync(absolutePath)) {
+    return {
+      passed: false,
+      passCount: 0,
+      failCount: 0,
+      totalCount: 0,
+      output: `Test file not found: ${absolutePath}`
+    };
+  }
+  try {
+    const npxPath = path31.join(workspacePath, "node_modules", ".bin", "playwright");
+    const useLocalPlaywright = fs39.existsSync(npxPath);
+    const cmd = useLocalPlaywright ? `npx playwright test "${absolutePath}" --reporter=json` : `npx playwright test "${absolutePath}" --reporter=json`;
+    const output = (0, import_child_process12.execSync)(cmd, {
+      cwd: workspacePath,
+      encoding: "utf-8",
+      timeout: 3e5,
+      // 5 min timeout
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    try {
+      const report = JSON.parse(output);
+      const suites = report.suites || [];
+      let passCount = 0;
+      let failCount = 0;
+      const countTests = (suite) => {
+        for (const spec of suite.specs || []) {
+          for (const test of spec.tests || []) {
+            const lastResult = test.results?.[test.results.length - 1];
+            if (lastResult?.status === "passed") passCount++;
+            else failCount++;
+          }
+        }
+        for (const child of suite.suites || []) {
+          countTests(child);
+        }
+      };
+      for (const suite of suites) countTests(suite);
+      const totalCount = passCount + failCount;
+      return {
+        passed: failCount === 0 && totalCount > 0,
+        passCount,
+        failCount,
+        totalCount,
+        output: output.slice(-2e3)
+      };
+    } catch {
+      return {
+        passed: true,
+        passCount: 1,
+        failCount: 0,
+        totalCount: 1,
+        output: output.slice(-2e3)
+      };
+    }
+  } catch (error) {
+    const err2 = error;
+    const output = (err2.stdout || "") + "\n" + (err2.stderr || "");
+    let passCount = 0;
+    let failCount = 1;
+    const passMatch = output.match(/(\d+) passed/);
+    const failMatch = output.match(/(\d+) failed/);
+    if (passMatch) passCount = parseInt(passMatch[1]);
+    if (failMatch) failCount = parseInt(failMatch[1]);
+    const totalCount = passCount + failCount || 1;
+    return {
+      passed: false,
+      passCount,
+      failCount,
+      totalCount,
+      output: output.slice(-2e3)
+    };
+  }
+}
+async function generateAndWriteAcceptanceTests(idea, targetRepo, workspacePath) {
+  const result = await generateAcceptanceTests(idea, targetRepo);
+  if (!result.file) return result;
+  const writtenPath = writeAcceptanceTests(result, workspacePath);
+  return { ...result, writtenPath: writtenPath || void 0 };
+}
+
 // scripts/heartbeat.ts
 init_paths();
 var ROOT_DIR = PROJECT_DIR;
-var execAsync = (0, import_util.promisify)(import_child_process11.exec);
+var execAsync = (0, import_util.promisify)(import_child_process13.exec);
 var DEFAULT_MAX_DECOMP_ATTEMPTS = 2;
 function spawnAsync(cmd, args2, options) {
-  return new Promise((resolve3, reject) => {
-    const child = (0, import_child_process11.spawn)(cmd, args2, {
+  return new Promise((resolve4, reject) => {
+    const child = (0, import_child_process13.spawn)(cmd, args2, {
       cwd: options.cwd,
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -34899,7 +36320,7 @@ function spawnAsync(cmd, args2, options) {
         reject(err2);
         return;
       }
-      resolve3({ stdout, stderr });
+      resolve4({ stdout, stderr });
     });
   });
 }
@@ -34955,17 +36376,17 @@ function log(message) {
   }
 }
 function sleep(ms2) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms2));
+  return new Promise((resolve4) => setTimeout(resolve4, ms2));
 }
-function loadJson(filePath, defaultValue) {
+function loadJson3(filePath, defaultValue) {
   try {
-    const content = fs35.readFileSync(filePath, "utf-8");
+    const content = fs42.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return defaultValue;
   }
 }
-function saveJson(filePath, data) {
+function saveJson2(filePath, data) {
   atomicWriteFileSync(filePath, JSON.stringify(data, null, 2));
 }
 var HUMAN_TASK_PATTERNS = [
@@ -35014,7 +36435,7 @@ function isMetaTaskFalseCompletion(output) {
 }
 function reclassifyAsHumanDependent(taskId) {
   try {
-    let content = fs35.readFileSync(TODO_FILE, "utf-8");
+    let content = fs42.readFileSync(TODO_FILE, "utf-8");
     const taskPattern = new RegExp(`^- \\[[ x]\\] \`${taskId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\`.*$`, "m");
     const match = content.match(taskPattern);
     if (!match) return;
@@ -35027,7 +36448,7 @@ function reclassifyAsHumanDependent(taskId) {
       const insertIndex = content.indexOf("\n", blockedIndex) + 1;
       content = content.slice(0, insertIndex) + "\n" + uncheckedLine + content.slice(insertIndex);
     }
-    fs35.writeFileSync(TODO_FILE, content);
+    fs42.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"}`);
@@ -35035,7 +36456,7 @@ function reclassifyAsHumanDependent(taskId) {
 }
 function getMetaTaskFailureCount(taskId) {
   try {
-    const content = fs35.readFileSync(TODO_FILE, "utf-8");
+    const content = fs42.readFileSync(TODO_FILE, "utf-8");
     const escapedId = taskId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const match = content.match(new RegExp(`\`${escapedId}\`.*\\[failed:(\\d+)\\]`));
     return match ? parseInt(match[1], 10) : 0;
@@ -35045,7 +36466,7 @@ function getMetaTaskFailureCount(taskId) {
 }
 function incrementMetaTaskFailureCount(taskId) {
   try {
-    let content = fs35.readFileSync(TODO_FILE, "utf-8");
+    let content = fs42.readFileSync(TODO_FILE, "utf-8");
     const escapedId = taskId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const linePattern = new RegExp(`^(- \\[[ x]\\] \`${escapedId}\`.*)$`, "m");
     const lineMatch = content.match(linePattern);
@@ -35061,7 +36482,7 @@ function incrementMetaTaskFailureCount(taskId) {
       newLine = `${line} [failed:${newCount}]`;
     }
     content = content.replace(line, newLine);
-    fs35.writeFileSync(TODO_FILE, content);
+    fs42.writeFileSync(TODO_FILE, content);
     log(`Meta-task ${taskId} failure count: ${newCount}`);
     return newCount;
   } catch (error) {
@@ -35071,7 +36492,7 @@ function incrementMetaTaskFailureCount(taskId) {
 }
 function parseTodoFile() {
   try {
-    const content = fs35.readFileSync(TODO_FILE, "utf-8");
+    const content = fs42.readFileSync(TODO_FILE, "utf-8");
     const tasks = [];
     let currentSection = "high_priority";
     const lines = content.split("\n");
@@ -35103,9 +36524,9 @@ function parseTodoFile() {
   }
 }
 function loadState4() {
-  const ideasData = loadJson(IDEAS_FILE, { ideas: [] });
-  const goalsData = loadJson(GOALS_FILE, { goals: [] });
-  const sessionsData = loadJson(SESSIONS_FILE, { sessions: [] });
+  const ideasData = loadJson3(IDEAS_FILE, { ideas: [] });
+  const goalsData = loadJson3(GOALS_FILE, { goals: [] });
+  const sessionsData = loadJson3(SESSIONS_FILE, { sessions: [] });
   const todos = parseTodoFile();
   return {
     ideas: ideasData.ideas || [],
@@ -35129,12 +36550,12 @@ var DEFAULT_BUSINESS_CONTEXT = {
   key_constraints: []
 };
 function loadBusinessContext() {
-  return loadJson(BUSINESS_CONTEXT_FILE, DEFAULT_BUSINESS_CONTEXT);
+  return loadJson3(BUSINESS_CONTEXT_FILE, DEFAULT_BUSINESS_CONTEXT);
 }
 function updateBusinessContext(ctx, kpis) {
   updateFunnelStageStatuses(ctx, kpis);
   ctx.last_auto_update = (/* @__PURE__ */ new Date()).toISOString();
-  saveJson(BUSINESS_CONTEXT_FILE, ctx);
+  saveJson2(BUSINESS_CONTEXT_FILE, ctx);
 }
 function checkThreshold(threshold, kpiValue) {
   if (kpiValue === null || kpiValue === void 0) return false;
@@ -35221,10 +36642,10 @@ function captureGitDiffInfo(workspacePath) {
     has_uncommitted_changes: false
   };
   try {
-    const status = (0, import_child_process11.execSync)("git status --porcelain", { cwd: workspacePath, encoding: "utf-8" });
+    const status = (0, import_child_process13.execSync)("git status --porcelain", { cwd: workspacePath, encoding: "utf-8" });
     result.has_uncommitted_changes = status.trim().length > 0;
     try {
-      const diffStat = (0, import_child_process11.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_process13.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"
@@ -35312,7 +36733,7 @@ function checkAlerts(state) {
       }
     }
   }
-  const epics = loadJson(ROADMAP_FILE, { epics: [] }).epics || [];
+  const epics = loadJson3(ROADMAP_FILE, { epics: [] }).epics || [];
   for (const epic of epics) {
     if (epic.status === "active" && epic.target_end) {
       const daysOver = daysSince(epic.target_end);
@@ -35408,14 +36829,14 @@ function checkSystemHealth(state, maxRetries) {
     }
   }
   if (health.recovery_actions.some((a) => a.startsWith("STALE SUB-TASK"))) {
-    const ideasData = loadJson(IDEAS_FILE, { ideas: [] });
+    const ideasData = loadJson3(IDEAS_FILE, { ideas: [] });
     for (const idea of inProgressIdeas) {
       const stored = ideasData.ideas.find((i) => i.id === idea.id);
       if (stored) {
         stored.implementation.sub_tasks = idea.implementation.sub_tasks;
       }
     }
-    saveJson(IDEAS_FILE, ideasData);
+    saveJson2(IDEAS_FILE, ideasData);
     log(`Persisted stale sub-task recovery changes`);
   }
   if (inProgressIdeas.length > 0) {
@@ -35438,7 +36859,7 @@ function checkSystemHealth(state, maxRetries) {
 }
 function autoRecoverStuckIdeas(stuckIdeaIds) {
   if (stuckIdeaIds.length === 0) return;
-  const ideasData = loadJson(IDEAS_FILE, { ideas: [] });
+  const ideasData = loadJson3(IDEAS_FILE, { ideas: [] });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   for (const ideaId of stuckIdeaIds) {
     const idea = ideasData.ideas.find((i) => i.id === ideaId);
@@ -35455,10 +36876,10 @@ function autoRecoverStuckIdeas(stuckIdeaIds) {
     });
     log(`Auto-deferred stuck idea: ${ideaId} \u2014 ${idea.title}`);
   }
-  saveJson(IDEAS_FILE, ideasData);
+  saveJson2(IDEAS_FILE, ideasData);
 }
 function autoRecoverDeferredParseFailures() {
-  const ideasData = loadJson(IDEAS_FILE, { ideas: [] });
+  const ideasData = loadJson3(IDEAS_FILE, { ideas: [] });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   let recovered = 0;
   for (const idea of ideasData.ideas) {
@@ -35485,25 +36906,25 @@ function autoRecoverDeferredParseFailures() {
     recovered++;
   }
   if (recovered > 0) {
-    saveJson(IDEAS_FILE, ideasData);
+    saveJson2(IDEAS_FILE, ideasData);
     log(`Auto-recovered ${recovered} deferred idea(s) for retry`);
   }
 }
 async function generateMissingShipCards(ideas) {
   const shippedIdeas = ideas.filter((i) => i.stage === "shipped");
   if (shippedIdeas.length === 0) return;
-  const assetsDir = path30.join(__dirname, "assets");
-  const hasRegular = fs35.existsSync(path30.join(assetsDir, "Inter-Regular.ttf"));
-  const hasBold = fs35.existsSync(path30.join(assetsDir, "Inter-Bold.ttf"));
+  const assetsDir = path34.join(__dirname, "assets");
+  const hasRegular = fs42.existsSync(path34.join(assetsDir, "Inter-Regular.ttf"));
+  const hasBold = fs42.existsSync(path34.join(assetsDir, "Inter-Bold.ttf"));
   if (!hasRegular && !hasBold) return;
-  const visualsDir = path30.join(DATA_DIR, "reports", "visuals");
+  const visualsDir = path34.join(DATA_DIR, "reports", "visuals");
   let generated = 0;
   for (const idea of shippedIdeas) {
-    const cardPath = path30.join(visualsDir, `${idea.id}-card.png`);
-    if (fs35.existsSync(cardPath)) continue;
+    const cardPath = path34.join(visualsDir, `${idea.id}-card.png`);
+    if (fs42.existsSync(cardPath)) continue;
     if (idea.implementation?.preview_url) {
-      const screenshotPath = path30.join(DATA_DIR, "reports", `${idea.id}-screenshot.png`);
-      if (!fs35.existsSync(screenshotPath)) {
+      const screenshotPath = path34.join(DATA_DIR, "reports", `${idea.id}-screenshot.png`);
+      if (!fs42.existsSync(screenshotPath)) {
         try {
           const { captureIdeaScreenshot: captureIdeaScreenshot2 } = await Promise.resolve().then(() => (init_screenshot(), screenshot_exports));
           await captureIdeaScreenshot2(idea.id, idea.implementation.preview_url);
@@ -35551,7 +36972,7 @@ async function fetchLiveKPIs() {
   }
 }
 function updateGoalsWithKPIs(kpis) {
-  const goalsData = loadJson(GOALS_FILE, { goals: [] });
+  const goalsData = loadJson3(GOALS_FILE, { goals: [] });
   const today = formatDate(/* @__PURE__ */ new Date());
   for (const goal of goalsData.goals) {
     let kpisUpdated = 0;
@@ -35594,7 +37015,7 @@ function updateGoalsWithKPIs(kpis) {
       }
     }
   }
-  saveJson(GOALS_FILE, goalsData);
+  saveJson2(GOALS_FILE, goalsData);
   log("Updated goals.json with live KPIs");
 }
 function detectMarketingTriggersIfNeeded(goals) {
@@ -35606,17 +37027,17 @@ function detectMarketingTriggersIfNeeded(goals) {
 }
 async function syncMarketingPlansToIdeas() {
   const { addMarketingIdeasToDashboard: addMarketingIdeasToDashboard2 } = await Promise.resolve().then(() => (init_marketing_integration(), marketing_integration_exports));
-  const plansDir = path30.join(DATA_DIR, "marketing-plans");
-  if (!fs35.existsSync(plansDir)) {
+  const plansDir = path34.join(DATA_DIR, "marketing-plans");
+  if (!fs42.existsSync(plansDir)) {
     return;
   }
-  const planFiles = fs35.readdirSync(plansDir).filter((f) => f.endsWith(".json"));
+  const planFiles = fs42.readdirSync(plansDir).filter((f) => f.endsWith(".json"));
   let totalAdded = 0;
   let totalSkipped = 0;
   for (const file of planFiles) {
     try {
-      const planPath = path30.join(plansDir, file);
-      const plan = JSON.parse(fs35.readFileSync(planPath, "utf-8"));
+      const planPath = path34.join(plansDir, file);
+      const plan = JSON.parse(fs42.readFileSync(planPath, "utf-8"));
       if (plan.status === "approved" || plan.status === "active") {
         const result = await addMarketingIdeasToDashboard2(plan, DATA_DIR);
         totalAdded += result.added;
@@ -35631,10 +37052,10 @@ async function syncMarketingPlansToIdeas() {
   }
 }
 function loadCodebaseSnapshot() {
-  const snapshotPath = path30.join(DATA_DIR, "codebase-snapshot.json");
+  const snapshotPath = path34.join(DATA_DIR, "codebase-snapshot.json");
   try {
-    if (fs35.existsSync(snapshotPath)) {
-      return JSON.parse(fs35.readFileSync(snapshotPath, "utf-8"));
+    if (fs42.existsSync(snapshotPath)) {
+      return JSON.parse(fs42.readFileSync(snapshotPath, "utf-8"));
     }
   } catch {
   }
@@ -35642,8 +37063,8 @@ function loadCodebaseSnapshot() {
 }
 function buildContextForClaude(state, alerts, businessContext) {
   const codebaseSnapshot = loadCodebaseSnapshot();
-  const hypotheses = loadJson(HYPOTHESES_FILE, { hypotheses: [] }).hypotheses || [];
-  const epics = loadJson(ROADMAP_FILE, { epics: [] }).epics || [];
+  const hypotheses = loadJson3(HYPOTHESES_FILE, { hypotheses: [] }).hypotheses || [];
+  const epics = loadJson3(ROADMAP_FILE, { epics: [] }).epics || [];
   const deriveEpicStatus = (epic) => {
     if (epic.status_override) return epic.status;
     const childIdeas = state.ideas.filter((i) => epic.idea_ids.includes(i.id));
@@ -35794,9 +37215,18 @@ function buildContextForClaude(state, alerts, businessContext) {
     social: readSocialFreshness(),
     promo_copy: readPromoCopyFreshness(),
     promo_video: readPromoVideoFreshness(),
-    campaigns: readCampaignFreshness()
+    campaigns: readCampaignFreshness(),
+    growth_campaigns: readGrowthCampaignFreshness(),
+    product_vision: readVisionFreshness()
   };
 }
+function readVisionFreshness() {
+  try {
+    return generateValidationReport();
+  } catch {
+    return null;
+  }
+}
 function buildBusinessConstraints(businessContext) {
   if (!businessContext) {
     return `BUSINESS CONTEXT:
@@ -36101,6 +37531,17 @@ Rules:
 5. Ideas without prerequisites (tech debt, infrastructure) can proceed normally.
 6. For revenue ideas: "convert existing free users to paid" > "build new revenue streams" when the user base is tiny.
 
+PRODUCT VISION ALIGNMENT:
+The "product_vision" field shows the current product vision status (Obviously Awesome + StoryBrand).
+Rules:
+1. Prioritize ideas that test unvalidated hypotheses over new feature ideas.
+2. Every recommended idea must link to a hypothesis or explain why it doesn't need one.
+3. Quality gate: do not recommend implementing an idea without clear acceptance criteria (success_metrics).
+4. If product_vision.pivot_needed == true, prioritize a "vision-review" task to reassess the vision.
+5. If product_vision.vision_exists == false, recommend running "analyze --type=vision" before approving new ideas.
+6. If product_vision.confidence_score < 30, focus on hypothesis validation over new feature development.
+7. Monitor product_vision.hypotheses.top_uncertain \u2014 these represent the biggest unknowns to resolve.
+
 HYPOTHESIS VALIDATION:
 The "hypotheses" field contains business hypotheses that need validation through experiments.
 Rules:
@@ -36201,9 +37642,9 @@ Focus on actionable, specific recommendations. Be concise.`;
 }
 function addTasksToTodo(tasks) {
   if (tasks.length === 0) return;
-  if (!fs35.existsSync(TODO_FILE)) return;
+  if (!fs42.existsSync(TODO_FILE)) return;
   try {
-    let content = fs35.readFileSync(TODO_FILE, "utf-8");
+    let content = fs42.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");
@@ -36303,15 +37744,15 @@ function addTasksToTodo(tasks) {
       }
       log(`Added TODO: ${task.id} \u2014 ${task.description}`);
     }
-    fs35.writeFileSync(TODO_FILE, content);
+    fs42.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 (!fs35.existsSync(TODO_FILE)) return;
-    let content = fs35.readFileSync(TODO_FILE, "utf-8");
+    if (!fs42.existsSync(TODO_FILE)) return;
+    let content = fs42.readFileSync(TODO_FILE, "utf-8");
     const lines = content.split("\n");
     const completedLines = [];
     const newLines = [];
@@ -36337,7 +37778,7 @@ function archiveCompletedTodos() {
       const archiveBlock = completedLines.join("\n") + "\n";
       content = content.slice(0, insertIndex) + archiveBlock + content.slice(insertIndex);
     }
-    fs35.writeFileSync(TODO_FILE, content);
+    fs42.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"}`);
@@ -36345,8 +37786,8 @@ function archiveCompletedTodos() {
 }
 function pruneStaleScheduledTodos(state) {
   try {
-    if (!fs35.existsSync(TODO_FILE)) return;
-    const content = fs35.readFileSync(TODO_FILE, "utf-8");
+    if (!fs42.existsSync(TODO_FILE)) return;
+    const content = fs42.readFileSync(TODO_FILE, "utf-8");
     const lines = content.split("\n");
     const prunedIds = [];
     const terminalIdeaIds = new Set(
@@ -36382,7 +37823,7 @@ function pruneStaleScheduledTodos(state) {
       return true;
     });
     if (prunedIds.length === 0) return;
-    fs35.writeFileSync(TODO_FILE, newLines.join("\n"));
+    fs42.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"}`);
@@ -36390,8 +37831,8 @@ function pruneStaleScheduledTodos(state) {
 }
 function deduplicateActiveTodos() {
   try {
-    if (!fs35.existsSync(TODO_FILE)) return;
-    const content = fs35.readFileSync(TODO_FILE, "utf-8");
+    if (!fs42.existsSync(TODO_FILE)) return;
+    const content = fs42.readFileSync(TODO_FILE, "utf-8");
     const lines = content.split("\n");
     const removedIds = [];
     let currentSection = "";
@@ -36428,7 +37869,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");
-    fs35.writeFileSync(TODO_FILE, cleaned);
+    fs42.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"}`);
@@ -36436,8 +37877,8 @@ function deduplicateActiveTodos() {
 }
 function readMemoryContext() {
   try {
-    if (!fs35.existsSync(MEMORY_FILE)) return "";
-    const content = fs35.readFileSync(MEMORY_FILE, "utf-8");
+    if (!fs42.existsSync(MEMORY_FILE)) return "";
+    const content = fs42.readFileSync(MEMORY_FILE, "utf-8");
     const MAX_TOTAL_LINES = 100;
     const MIN_LEARNING_ENTRIES = 15;
     const learningsSplit = content.indexOf("### Heartbeat Learnings");
@@ -36458,14 +37899,14 @@ function readMemoryContext() {
 }
 function appendToMemory(learnings) {
   if (learnings.length === 0) return;
-  if (!fs35.existsSync(MEMORY_FILE)) return;
+  if (!fs42.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 = fs35.readFileSync(MEMORY_FILE, "utf-8");
+    let content = fs42.readFileSync(MEMORY_FILE, "utf-8");
     const existingLines = content.split("\n").filter((l2) => l2.match(/^- \*\*/));
     const KEY_PHRASE_PATTERN = /(?:idea-[a-f0-9]{8}|idea-[a-z0-9-]+|hyp-[a-z0-9-]+|goal-[a-z0-9-]+|pipeline starvation|critical path|batch triage|cooldown|decompos|timeout|inbox bloat|dedup|meta-task|heartbeat|autonomy gate|false completion)/gi;
     filtered = filtered.filter((learning) => {
@@ -36515,7 +37956,7 @@ function appendToMemory(learnings) {
         const subsectionEnd = subsectionEndMatch ? subsectionIndex + 22 + (subsectionEndMatch.index || 0) : insertPoint;
         content = content.slice(0, subsectionEnd) + newEntries + "\n" + content.slice(subsectionEnd);
       }
-      fs35.writeFileSync(MEMORY_FILE, content);
+      fs42.writeFileSync(MEMORY_FILE, content);
       log(`Added ${filtered.length} learning(s) to MEMORY.md`);
     }
   } catch (error) {
@@ -36524,8 +37965,8 @@ function appendToMemory(learnings) {
 }
 function pruneMemoryLearnings() {
   try {
-    if (!fs35.existsSync(MEMORY_FILE)) return;
-    const content = fs35.readFileSync(MEMORY_FILE, "utf-8");
+    if (!fs42.existsSync(MEMORY_FILE)) return;
+    const content = fs42.readFileSync(MEMORY_FILE, "utf-8");
     const learningsHeader = "### Heartbeat Learnings";
     const learningsIdx = content.indexOf(learningsHeader);
     if (learningsIdx === -1) return;
@@ -36561,7 +38002,7 @@ function pruneMemoryLearnings() {
     if (prunedCount === 0) return;
     const newLearningsBody = headerLine + "\n\n" + finalEntries.join("\n") + "\n";
     const newContent = beforeLearnings + newLearningsBody + afterLearnings;
-    fs35.writeFileSync(MEMORY_FILE, newContent);
+    fs42.writeFileSync(MEMORY_FILE, newContent);
     log(`Pruned ${prunedCount} duplicate/stale learnings (${entryLines.length} \u2192 ${finalEntries.length})`);
   } catch (error) {
     log(`Failed to prune memory learnings: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -36651,8 +38092,8 @@ function determineWork(state) {
         };
       }
     }
-    const hypotheses = loadJson(HYPOTHESES_FILE, { hypotheses: [] }).hypotheses || [];
-    const epicsForScoring = loadJson(ROADMAP_FILE, { epics: [] }).epics || [];
+    const hypotheses = loadJson3(HYPOTHESES_FILE, { hypotheses: [] }).hypotheses || [];
+    const epicsForScoring = loadJson3(ROADMAP_FILE, { epics: [] }).epics || [];
     const approvedIdeas = state.ideas.filter(
       (i) => i.stage === "approved" && (i.implementation?.decomposition_attempts || 0) < maxRetriesCheck
     ).sort((a, b) => scoreIdea(b, state.goals, hypotheses, epicsForScoring) - scoreIdea(a, state.goals, hypotheses, epicsForScoring));
@@ -36670,7 +38111,7 @@ function determineWork(state) {
   return null;
 }
 function loadConfig() {
-  return loadJson(CONFIG_FILE, {
+  return loadJson3(CONFIG_FILE, {
     repos: [],
     workspace_dir: "",
     schedules: {}
@@ -36680,7 +38121,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(path30.basename(repo.path))) {
+      if (file.includes(repo.name) || file.includes(path34.basename(repo.path))) {
         return repo;
       }
     }
@@ -36913,7 +38354,7 @@ Respond with JSON only (no markdown code blocks, just raw JSON):
   return [];
 }
 function deferIdeaWithComment(ideaId, reason) {
-  const ideasData = loadJson(IDEAS_FILE, { ideas: [] });
+  const ideasData = loadJson3(IDEAS_FILE, { ideas: [] });
   const idea = ideasData.ideas.find((i) => i.id === ideaId);
   if (!idea) return false;
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -36929,7 +38370,7 @@ function deferIdeaWithComment(ideaId, reason) {
   });
   const ideaIndex = ideasData.ideas.findIndex((i) => i.id === ideaId);
   ideasData.ideas[ideaIndex] = idea;
-  saveJson(IDEAS_FILE, ideasData);
+  saveJson2(IDEAS_FILE, ideasData);
   log(`Deferred idea ${ideaId}: ${reason}`);
   return false;
 }
@@ -36973,17 +38414,17 @@ function runTestsForRepo(workspacePath, testCommands, sourceRepoPath) {
   const allOutput = [];
   const env = { ...process.env };
   if (sourceRepoPath) {
-    const venvBin = path30.join(sourceRepoPath, ".venv", "bin");
-    if (fs35.existsSync(venvBin)) {
+    const venvBin = path34.join(sourceRepoPath, ".venv", "bin");
+    if (fs42.existsSync(venvBin)) {
       env.PATH = `${venvBin}:${env.PATH}`;
-      env.VIRTUAL_ENV = path30.join(sourceRepoPath, ".venv");
+      env.VIRTUAL_ENV = path34.join(sourceRepoPath, ".venv");
       log(`Using venv from ${sourceRepoPath}/.venv`);
     }
   }
   for (const cmd of testCommands) {
     log(`Running test: ${cmd}`);
     try {
-      const result = (0, import_child_process11.execSync)(cmd, {
+      const result = (0, import_child_process13.execSync)(cmd, {
         cwd: workspacePath,
         encoding: "utf-8",
         env,
@@ -37011,7 +38452,7 @@ async function executeSingleSubTask(subTask, ideaId, idea, ideasData, autonomy,
   subTask.started_at = (/* @__PURE__ */ new Date()).toISOString();
   const lockPath = IDEAS_FILE + ".lock";
   withFileLock(lockPath, () => {
-    const freshData = loadJson(IDEAS_FILE, { ideas: [] });
+    const freshData = loadJson3(IDEAS_FILE, { ideas: [] });
     const idx = freshData.ideas.findIndex((i) => i.id === ideaId);
     if (idx !== -1) {
       const st = freshData.ideas[idx].implementation.sub_tasks.find((s) => s.id === subTask.id);
@@ -37019,7 +38460,7 @@ async function executeSingleSubTask(subTask, ideaId, idea, ideasData, autonomy,
         st.status = "in_progress";
         st.started_at = subTask.started_at;
       }
-      saveJson(IDEAS_FILE, freshData);
+      saveJson2(IDEAS_FILE, freshData);
     }
   });
   const scopePayload = JSON.stringify({
@@ -37029,14 +38470,14 @@ 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 || path30.join(config.workspace_dir, targetRepo.name);
+  const workspacePath = options?.worktreePath || path34.join(config.workspace_dir, targetRepo.name);
   const executionStartTime = Date.now();
   const updateSubTaskWithDetails = (status, updateOpts = {}) => {
     const endTime = Date.now();
     const durationMs = endTime - executionStartTime;
     const gitInfo = captureGitDiffInfo(workspacePath);
     withFileLock(lockPath, () => {
-      const reloadedIdeas = loadJson(IDEAS_FILE, { ideas: [] });
+      const reloadedIdeas = loadJson3(IDEAS_FILE, { ideas: [] });
       const reloadedIndex = reloadedIdeas.ideas.findIndex((i) => i.id === ideaId);
       if (reloadedIndex !== -1) {
         const reloadedSubTask = reloadedIdeas.ideas[reloadedIndex].implementation.sub_tasks.find(
@@ -37062,7 +38503,7 @@ async function executeSingleSubTask(subTask, ideaId, idea, ideasData, autonomy,
           if (updateOpts.commitHash !== void 0) {
             reloadedSubTask.commit_hash = updateOpts.commitHash;
           }
-          saveJson(IDEAS_FILE, reloadedIdeas);
+          saveJson2(IDEAS_FILE, reloadedIdeas);
         }
       }
     });
@@ -37105,9 +38546,20 @@ async function executeSingleSubTask(subTask, ideaId, idea, ideasData, autonomy,
         return false;
       }
     }
+    if (idea.implementation.acceptance_test_file) {
+      try {
+        const acceptResult = runAcceptanceTests(
+          idea.implementation.acceptance_test_file,
+          workspacePath
+        );
+        log(`Acceptance test progress after ${subTask.id}: ${acceptResult.passCount}/${acceptResult.totalCount} passed`);
+      } catch (acceptError) {
+        log(`Acceptance test run skipped: ${acceptError instanceof Error ? acceptError.message : "Unknown"}`);
+      }
+    }
     let commitHash = null;
     try {
-      commitHash = (0, import_child_process11.execSync)("git rev-parse HEAD", { cwd: workspacePath, encoding: "utf-8" }).trim();
+      commitHash = (0, import_child_process13.execSync)("git rev-parse HEAD", { cwd: workspacePath, encoding: "utf-8" }).trim();
     } catch {
     }
     updateSubTaskWithDetails("completed", {
@@ -37151,7 +38603,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_process11.spawnSync)("claude", ["--print", "--model", "sonnet", "-p", errorContext], {
+    const spawnResult = (0, import_child_process13.spawnSync)("claude", ["--print", "--model", "sonnet", "-p", errorContext], {
       cwd: ROOT_DIR,
       encoding: "utf-8",
       timeout: 6e4,
@@ -37163,7 +38615,7 @@ async function analyzeAndRetrySubTask(subTask, ideaId, maxRetries) {
       log(`Retry analysis returned empty result for ${subTask.id}`);
       return false;
     }
-    const ideasData = loadJson(IDEAS_FILE, { ideas: [] });
+    const ideasData = loadJson3(IDEAS_FILE, { ideas: [] });
     const idea = ideasData.ideas.find((i) => i.id === ideaId);
     if (!idea) return false;
     const st = idea.implementation.sub_tasks.find((s) => s.id === subTask.id);
@@ -37176,20 +38628,20 @@ async function analyzeAndRetrySubTask(subTask, ideaId, maxRetries) {
     st.output_snippet = null;
     st.retry_count = currentRetries + 1;
     st.description = `[Retry ${currentRetries + 1}] ${result}`;
-    saveJson(IDEAS_FILE, ideasData);
+    saveJson2(IDEAS_FILE, ideasData);
     log(`Sub-task ${subTask.id} reset to pending for retry (attempt ${currentRetries + 1})`);
     return true;
   } catch (error) {
     log(`Retry analysis failed for ${subTask.id}: ${error instanceof Error ? error.message : "Unknown"}`);
     try {
-      const fallbackIdeas = loadJson(IDEAS_FILE, { ideas: [] });
+      const fallbackIdeas = loadJson3(IDEAS_FILE, { ideas: [] });
       const fallbackIdea = fallbackIdeas.ideas.find((i) => i.id === ideaId);
       if (fallbackIdea) {
         const fallbackSt = fallbackIdea.implementation.sub_tasks.find((s) => s.id === subTask.id);
         if (fallbackSt) {
           fallbackSt.retry_count = (fallbackSt.retry_count || 0) + 1;
           fallbackSt.error_message = `Retry analysis failed: ${error instanceof Error ? error.message : "Unknown"}`;
-          saveJson(IDEAS_FILE, fallbackIdeas);
+          saveJson2(IDEAS_FILE, fallbackIdeas);
           log(`Incremented retry_count to ${fallbackSt.retry_count} for ${subTask.id} after analysis failure`);
         }
       }
@@ -37209,7 +38661,7 @@ async function executeAutonomousImplementation(ideaId) {
     log(`Autonomy not enabled, skipping implementation for ${ideaId}`);
     return false;
   }
-  const ideasData = loadJson(IDEAS_FILE, { ideas: [] });
+  const ideasData = loadJson3(IDEAS_FILE, { ideas: [] });
   let idea = ideasData.ideas.find((i) => i.id === ideaId);
   if (!idea && !ideaId.startsWith("idea-")) {
     const prefixedId = `idea-${ideaId}`;
@@ -37236,7 +38688,7 @@ async function executeAutonomousImplementation(ideaId) {
     idea.implementation.decomposition_attempts = attempts + 1;
     const ideaIdx = ideasData.ideas.findIndex((i) => i.id === ideaId);
     ideasData.ideas[ideaIdx] = idea;
-    saveJson(IDEAS_FILE, ideasData);
+    saveJson2(IDEAS_FILE, ideasData);
     log(`Decomposition attempt ${attempts + 1}/${maxDecompAttempts} for ${ideaId}...`);
     const newSubTasks = await decomposeIdea(idea, config);
     if (newSubTasks.length === 0) {
@@ -37247,23 +38699,94 @@ async function executeAutonomousImplementation(ideaId) {
     subTasks = newSubTasks;
     const ideaIndex = ideasData.ideas.findIndex((i) => i.id === ideaId);
     ideasData.ideas[ideaIndex] = idea;
-    saveJson(IDEAS_FILE, ideasData);
+    saveJson2(IDEAS_FILE, ideasData);
     log(`Saved ${newSubTasks.length} sub-tasks for ${ideaId}, executing first sub-task now`);
   }
+  if (!idea.implementation.acceptance_tests_generated && idea.success_metrics?.length > 0) {
+    const targetRepoForTests = detectTargetRepo(idea, config);
+    if (targetRepoForTests) {
+      const workspacePath = path34.join(config.workspace_dir, targetRepoForTests.name);
+      try {
+        log(`Generating acceptance tests for ${ideaId}...`);
+        const testResult = await generateAndWriteAcceptanceTests(idea, targetRepoForTests, workspacePath);
+        if (testResult.file && testResult.writtenPath) {
+          idea.implementation.acceptance_test_file = testResult.writtenPath;
+          idea.implementation.acceptance_tests_generated = true;
+          const ideaIndex = ideasData.ideas.findIndex((i) => i.id === ideaId);
+          if (ideaIndex !== -1) {
+            ideasData.ideas[ideaIndex] = idea;
+            saveJson2(IDEAS_FILE, ideasData);
+          }
+          log(`Acceptance tests written to ${testResult.writtenPath}`);
+        } else {
+          log(`Acceptance test generation skipped: ${testResult.error || "no file generated"}`);
+        }
+      } catch (testGenError) {
+        log(`Acceptance test generation failed (non-blocking): ${testGenError instanceof Error ? testGenError.message : "Unknown"}`);
+      }
+    }
+  }
   const pendingTasks = subTasks.filter((st) => st.status === "pending");
   const completedTasks = subTasks.filter((st) => st.status === "completed");
   const failedTasks = subTasks.filter((st) => st.status === "failed");
   const inProgressTasks = subTasks.filter((st) => st.status === "in_progress");
   if (pendingTasks.length === 0 && inProgressTasks.length === 0 && failedTasks.length === 0) {
-    log(`All ${completedTasks.length} sub-tasks completed for ${ideaId}, creating PR...`);
+    log(`All ${completedTasks.length} sub-tasks completed for ${ideaId}, running quality gate...`);
     const targetRepo2 = detectTargetRepo(idea, config);
     if (!targetRepo2) {
       log("Could not determine target repo");
       return false;
     }
+    if (idea.implementation.acceptance_test_file) {
+      const workspacePath = path34.join(config.workspace_dir, targetRepo2.name);
+      try {
+        const finalResult = runAcceptanceTests(
+          idea.implementation.acceptance_test_file,
+          workspacePath
+        );
+        const qgIdeas = loadJson3(IDEAS_FILE, { ideas: [] });
+        const qgIdx = qgIdeas.ideas.findIndex((i) => i.id === ideaId);
+        if (qgIdx !== -1) {
+          qgIdeas.ideas[qgIdx].implementation.acceptance_test_results = {
+            passed: finalResult.passCount,
+            failed: finalResult.failCount,
+            last_run: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          saveJson2(IDEAS_FILE, qgIdeas);
+        }
+        if (!finalResult.passed) {
+          log(`QUALITY GATE BLOCKED: ${finalResult.passCount}/${finalResult.totalCount} acceptance tests passed`);
+          const fixTask = {
+            id: `st-fix-acceptance-${Date.now().toString(36)}`,
+            title: "Fix failing acceptance tests",
+            description: `Acceptance tests failed (${finalResult.failCount} failures). Fix the implementation to pass all tests in ${idea.implementation.acceptance_test_file}.
+
+Failures:
+${finalResult.output.slice(-1500)}`,
+            files_to_modify: [],
+            status: "pending",
+            started_at: null,
+            completed_at: null,
+            error_message: null,
+            commit_hash: null
+          };
+          const fixIdeas = loadJson3(IDEAS_FILE, { ideas: [] });
+          const fixIdx = fixIdeas.ideas.findIndex((i) => i.id === ideaId);
+          if (fixIdx !== -1) {
+            fixIdeas.ideas[fixIdx].implementation.sub_tasks.push(fixTask);
+            saveJson2(IDEAS_FILE, fixIdeas);
+          }
+          log(`Queued fix-tests sub-task. Next heartbeat will attempt the fix.`);
+          return false;
+        }
+        log(`QUALITY GATE PASSED: ${finalResult.totalCount}/${finalResult.totalCount} acceptance tests passed`);
+      } catch (qgError) {
+        log(`Quality gate check failed (proceeding with PR): ${qgError instanceof Error ? qgError.message : "Unknown"}`);
+      }
+    }
     try {
       const { command, args: args2 } = resolveScript(__dirname, "implement.ts");
-      (0, import_child_process11.execSync)(
+      (0, import_child_process13.execSync)(
         [command, ...args2, `--idea=${ideaId}`, `--repo=${targetRepo2.name}`, "--create-pr-only"].join(" "),
         { cwd: ROOT_DIR, encoding: "utf-8", stdio: "inherit", timeout: 12e4 }
       );
@@ -37271,27 +38794,27 @@ async function executeAutonomousImplementation(ideaId) {
       if (autonomy.auto_merge) {
         const branchName2 = idea.implementation.branch_name;
         const defaultBranch2 = targetRepo2.default_branch || "main";
-        const workspacePath = path30.join(config.workspace_dir, targetRepo2.name);
+        const workspacePath = path34.join(config.workspace_dir, targetRepo2.name);
         if (branchName2) {
           try {
             log(`Auto-merging branch ${branchName2} into ${defaultBranch2}...`);
-            (0, import_child_process11.execFileSync)("git", ["checkout", validateBranchName(defaultBranch2)], { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
-            (0, import_child_process11.execFileSync)("git", ["merge", validateBranchName(branchName2), "--squash", "--no-edit"], { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
-            (0, import_child_process11.execFileSync)("git", ["commit", "-m", `feat: ${sanitizeForCommitMessage(idea.title)} (auto-merged from ${validateBranchName(branchName2)})`], { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
+            (0, import_child_process13.execFileSync)("git", ["checkout", validateBranchName(defaultBranch2)], { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
+            (0, import_child_process13.execFileSync)("git", ["merge", validateBranchName(branchName2), "--squash", "--no-edit"], { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
+            (0, import_child_process13.execFileSync)("git", ["commit", "-m", `feat: ${sanitizeForCommitMessage(idea.title)} (auto-merged from ${validateBranchName(branchName2)})`], { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
             log(`Successfully merged ${branchName2} into ${defaultBranch2}`);
             try {
-              (0, import_child_process11.execFileSync)("git", ["branch", "-d", validateBranchName(branchName2)], { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
+              (0, import_child_process13.execFileSync)("git", ["branch", "-d", validateBranchName(branchName2)], { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
               log(`Deleted branch ${branchName2}`);
             } catch {
               log(`Could not delete branch ${branchName2} (may need force delete)`);
             }
-            const mergedIdeas = loadJson(IDEAS_FILE, { ideas: [] });
+            const mergedIdeas = loadJson3(IDEAS_FILE, { ideas: [] });
             const mergedIndex = mergedIdeas.ideas.findIndex((i) => i.id === ideaId);
             if (mergedIndex !== -1) {
               mergedIdeas.ideas[mergedIndex].stage = "shipped";
               mergedIdeas.ideas[mergedIndex].updated_at = (/* @__PURE__ */ new Date()).toISOString();
               mergedIdeas.ideas[mergedIndex].implementation.completed_at = (/* @__PURE__ */ new Date()).toISOString();
-              saveJson(IDEAS_FILE, mergedIdeas);
+              saveJson2(IDEAS_FILE, mergedIdeas);
               log(`Idea ${ideaId} moved to shipped stage`);
               try {
                 const visualResult = await executeMarketingVisualTask(`generate-visual-${ideaId}`, "");
@@ -37312,25 +38835,25 @@ async function executeAutonomousImplementation(ideaId) {
           } catch (mergeError) {
             log(`Auto-merge failed (likely conflicts): ${mergeError instanceof Error ? mergeError.message : "Unknown"}`);
             try {
-              (0, import_child_process11.execFileSync)("git", ["merge", "--abort"], { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
-              (0, import_child_process11.execFileSync)("git", ["checkout", validateBranchName(branchName2)], { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
+              (0, import_child_process13.execFileSync)("git", ["merge", "--abort"], { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
+              (0, import_child_process13.execFileSync)("git", ["checkout", validateBranchName(branchName2)], { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
             } catch {
             }
             log(`Left idea ${ideaId} in testing stage for manual merge`);
           }
         }
       }
-      const reloadedIdeas = loadJson(IDEAS_FILE, { ideas: [] });
+      const reloadedIdeas = loadJson3(IDEAS_FILE, { ideas: [] });
       const reloadedIndex = reloadedIdeas.ideas.findIndex((i) => i.id === ideaId);
       if (reloadedIndex !== -1 && reloadedIdeas.ideas[reloadedIndex].stage !== "shipped") {
         reloadedIdeas.ideas[reloadedIndex].stage = "testing";
         reloadedIdeas.ideas[reloadedIndex].updated_at = (/* @__PURE__ */ new Date()).toISOString();
-        saveJson(IDEAS_FILE, reloadedIdeas);
+        saveJson2(IDEAS_FILE, reloadedIdeas);
       }
       return true;
     } catch (error) {
       log(`PR creation failed: ${error instanceof Error ? error.message : "Unknown"}`);
-      const prIdeas = loadJson(IDEAS_FILE, { ideas: [] });
+      const prIdeas = loadJson3(IDEAS_FILE, { ideas: [] });
       const prIdx = prIdeas.ideas.findIndex((i) => i.id === ideaId);
       if (prIdx !== -1) {
         const attempts = (prIdeas.ideas[prIdx].implementation.pr_creation_attempts || 0) + 1;
@@ -37349,7 +38872,7 @@ async function executeAutonomousImplementation(ideaId) {
             created_at: (/* @__PURE__ */ new Date()).toISOString()
           });
         }
-        saveJson(IDEAS_FILE, prIdeas);
+        saveJson2(IDEAS_FILE, prIdeas);
       }
       return false;
     }
@@ -37369,11 +38892,11 @@ async function executeAutonomousImplementation(ideaId) {
         if (targetRepo2) {
           try {
             const { command, args: args2 } = resolveScript(__dirname, "implement.ts");
-            (0, import_child_process11.execSync)(
+            (0, import_child_process13.execSync)(
               [command, ...args2, `--idea=${ideaId}`, `--repo=${targetRepo2.name}`, "--create-pr-only"].join(" "),
               { cwd: ROOT_DIR, encoding: "utf-8", stdio: "inherit", timeout: 12e4 }
             );
-            const partialIdeas = loadJson(IDEAS_FILE, { ideas: [] });
+            const partialIdeas = loadJson3(IDEAS_FILE, { ideas: [] });
             const partialIdx = partialIdeas.ideas.findIndex((i) => i.id === ideaId);
             if (partialIdx !== -1) {
               const failedList = exhaustedTasks.map((st) => `- ${st.title} (${st.error_message || "unknown error"})`).join("\n");
@@ -37388,7 +38911,7 @@ ${failedList}`,
               });
               partialIdeas.ideas[partialIdx].stage = "testing";
               partialIdeas.ideas[partialIdx].updated_at = (/* @__PURE__ */ new Date()).toISOString();
-              saveJson(IDEAS_FILE, partialIdeas);
+              saveJson2(IDEAS_FILE, partialIdeas);
             }
             return true;
           } catch (prError) {
@@ -37410,7 +38933,7 @@ ${failedList}`,
       }
     }
     if (anyRetried) {
-      const retriedIdeas = loadJson(IDEAS_FILE, { ideas: [] });
+      const retriedIdeas = loadJson3(IDEAS_FILE, { ideas: [] });
       const retriedIdea = retriedIdeas.ideas.find((i) => i.id === ideaId);
       if (!retriedIdea) return false;
       const retriedPending = retriedIdea.implementation.sub_tasks.filter((st) => st.status === "pending");
@@ -37460,7 +38983,7 @@ ${failedList}`,
     const ideaIndex = ideasData.ideas.findIndex((i) => i.id === ideaId);
     if (ideaIndex !== -1) {
       ideasData.ideas[ideaIndex] = idea;
-      saveJson(IDEAS_FILE, ideasData);
+      saveJson2(IDEAS_FILE, ideasData);
     }
   }
   log(`${groups.length} conflict groups, executing in parallel via worktrees`);
@@ -37587,8 +39110,8 @@ ${allowedFiles.map((f) => `- ${f}`).join("\n")}
 6. When modifying TODO.md, preserve the markdown checkbox format: - [ ] or - [x]
 7. Be direct \u2014 read the file, make the edit, done
 `;
-  return new Promise((resolve3) => {
-    const claude = (0, import_child_process11.spawn)("claude", [
+  return new Promise((resolve4) => {
+    const claude = (0, import_child_process13.spawn)("claude", [
       "--print",
       "--dangerously-skip-permissions",
       "--model",
@@ -37616,7 +39139,7 @@ ${allowedFiles.map((f) => `- ${f}`).join("\n")}
           } catch {
           }
         }, 5e3);
-        resolve3(false);
+        resolve4(false);
       }
     }, timeoutMs);
     claude.stdout.on("data", (data) => {
@@ -37634,14 +39157,14 @@ ${allowedFiles.map((f) => `- ${f}`).join("\n")}
           log(`Meta-task false completion detected: ${taskId} \u2014 output indicates blocked state`);
           log(`  Output: ${output.substring(0, 200)}`);
           reclassifyAsHumanDependent(taskId);
-          resolve3(false);
+          resolve4(false);
           return;
         }
         log(`Meta-task completed: ${output.substring(0, 200)}`);
-        resolve3(true);
+        resolve4(true);
       } else {
         log(`Meta-task failed (exit ${code})`);
-        resolve3(false);
+        resolve4(false);
       }
     });
     claude.on("error", (err2) => {
@@ -37649,7 +39172,7 @@ ${allowedFiles.map((f) => `- ${f}`).join("\n")}
       isResolved = true;
       clearTimeout(timeout);
       log(`Meta-task error: ${err2.message}`);
-      resolve3(false);
+      resolve4(false);
     });
   });
 }
@@ -37657,7 +39180,7 @@ async function executeResearchTask(taskId, description) {
   const topicSlug = taskId.replace("research-", "").replace(/-/g, " ");
   const topic = description || topicSlug;
   log(`Executing research task: ${topic}`);
-  const goalsData = loadJson(GOALS_FILE, { goals: [] });
+  const goalsData = loadJson3(GOALS_FILE, { goals: [] });
   const goalsContext = goalsData.goals.map((g2) => {
     const kpiLines = g2.kpis.map(
       (k) => `  - ${k.name}: ${k.current_value ?? "N/A"} / ${k.target_value} ${k.unit}`
@@ -37671,9 +39194,9 @@ ${kpiLines}`;
     goals: goalsContext
   });
   const contextBase64 = Buffer.from(contextPayload).toString("base64");
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const { command: analyzeCmd, args: analyzeArgs } = resolveScript(__dirname, "analyze.ts");
-    const childProcess = (0, import_child_process11.spawn)(analyzeCmd, [
+    const childProcess = (0, import_child_process13.spawn)(analyzeCmd, [
       ...analyzeArgs,
       `--type=research`,
       `--topic=${topic}`,
@@ -37685,22 +39208,22 @@ ${kpiLines}`;
     const timeout = setTimeout(() => {
       childProcess.kill("SIGTERM");
       log("Research task timed out after 15 minutes");
-      resolve3(false);
+      resolve4(false);
     }, 9e5);
     childProcess.on("close", (code) => {
       clearTimeout(timeout);
       if (code === 0) {
         log("Research task completed successfully");
-        resolve3(true);
+        resolve4(true);
       } else {
         log(`Research task failed with code ${code}`);
-        resolve3(false);
+        resolve4(false);
       }
     });
     childProcess.on("error", (error) => {
       clearTimeout(timeout);
       log(`Research task error: ${error.message}`);
-      resolve3(false);
+      resolve4(false);
     });
   });
 }
@@ -37726,7 +39249,7 @@ function buildGoalGapPrompt(goal, existingIdeas, liveKPIs, config, businessConte
     const funnelSummary = businessContext.funnels.map(
       (f) => `- **${f.name}** (${f.status}): ${f.key_insight}`
     ).join("\n");
-    const goalsForHealth = loadJson(GOALS_FILE, { goals: [] }).goals;
+    const goalsForHealth = loadJson3(GOALS_FILE, { goals: [] }).goals;
     const health = computeFunnelHealth(businessContext, goalsForHealth);
     const earliestBroken = health.earliest_broken_stage || "unknown";
     const activeLawyers = businessContext.funnels.reduce((sum, f) => sum + (f.active_lawyers?.length || 0), 0);
@@ -37823,7 +39346,7 @@ async function executeGoalGapResearch(goalId) {
     return false;
   }
   log(`Executing goal-gap research for ${goalId}...`);
-  const goalsData = loadJson(GOALS_FILE, { goals: [] });
+  const goalsData = loadJson3(GOALS_FILE, { goals: [] });
   const goal = goalsData.goals.find((g2) => g2.id === goalId);
   if (!goal) {
     log(`Goal ${goalId} not found`);
@@ -37833,17 +39356,17 @@ async function executeGoalGapResearch(goalId) {
     log(`Goal ${goalId} is not behind or at_risk (status: ${goal.status}), skipping`);
     return false;
   }
-  const ideasData = loadJson(IDEAS_FILE, { ideas: [] });
+  const ideasData = loadJson3(IDEAS_FILE, { ideas: [] });
   const existingIdeas = ideasData.ideas.filter((i) => i.goal_id === goalId);
   const liveKPIs = await fetchLiveKPIs();
   const config = loadConfig();
   const businessContext = loadBusinessContext();
   const prompt = buildGoalGapPrompt(goal, existingIdeas, liveKPIs, config, businessContext);
   log(`Goal-gap prompt built (${prompt.length} chars), spawning Claude Code...`);
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const TIMEOUT_MS = 9e5;
     const startTime = Date.now();
-    const claude = (0, import_child_process11.spawn)("claude", [
+    const claude = (0, import_child_process13.spawn)("claude", [
       "--print",
       "--dangerously-skip-permissions"
     ], {
@@ -37867,7 +39390,7 @@ async function executeGoalGapResearch(goalId) {
         clearInterval(progressInterval);
         claude.kill("SIGTERM");
         log("Goal-gap research timed out after 15 minutes");
-        resolve3(false);
+        resolve4(false);
       }
     }, TIMEOUT_MS);
     claude.stdout.on("data", (data) => {
@@ -37887,7 +39410,7 @@ async function executeGoalGapResearch(goalId) {
       const elapsed = Math.round((Date.now() - startTime) / 1e3);
       if (code !== 0) {
         log(`Goal-gap research failed with code ${code} after ${elapsed}s`);
-        resolve3(false);
+        resolve4(false);
         return;
       }
       log(`Goal-gap research completed in ${elapsed}s, parsing ideas...`);
@@ -37895,7 +39418,7 @@ async function executeGoalGapResearch(goalId) {
       const jsonMatch = sanitized.match(/\[\s*\{[\s\S]*\}\s*\]/);
       if (!jsonMatch) {
         log("No JSON array found in goal-gap research response");
-        resolve3(false);
+        resolve4(false);
         return;
       }
       try {
@@ -37937,27 +39460,27 @@ async function executeGoalGapResearch(goalId) {
         }));
         if (newIdeas.length === 0) {
           log("No ideas parsed from goal-gap research");
-          resolve3(false);
+          resolve4(false);
           return;
         }
-        const freshIdeasData = loadJson(IDEAS_FILE, { ideas: [] });
+        const freshIdeasData = loadJson3(IDEAS_FILE, { ideas: [] });
         freshIdeasData.ideas.push(...newIdeas);
-        saveJson(IDEAS_FILE, freshIdeasData);
-        const freshGoalsData = loadJson(GOALS_FILE, { goals: [] });
+        saveJson2(IDEAS_FILE, freshIdeasData);
+        const freshGoalsData = loadJson3(GOALS_FILE, { goals: [] });
         const freshGoal = freshGoalsData.goals.find((g2) => g2.id === goalId);
         if (freshGoal) {
           if (!freshGoal.related_ideas) freshGoal.related_ideas = [];
           freshGoal.related_ideas.push(...newIdeas.map((i) => i.id));
-          saveJson(GOALS_FILE, freshGoalsData);
+          saveJson2(GOALS_FILE, freshGoalsData);
         }
         log(`Goal-gap research generated ${newIdeas.length} ideas for ${goalId}:`);
         newIdeas.forEach((idea, i) => {
           log(`  ${i + 1}. ${idea.title}`);
         });
-        resolve3(true);
+        resolve4(true);
       } catch (error) {
         log(`Failed to parse goal-gap research ideas: ${error instanceof Error ? error.message : "Unknown"}`);
-        resolve3(false);
+        resolve4(false);
       }
     });
     claude.on("error", (error) => {
@@ -37966,7 +39489,7 @@ async function executeGoalGapResearch(goalId) {
         clearInterval(progressInterval);
         clearTimeout(timeout);
         log(`Goal-gap research error: ${error.message}`);
-        resolve3(false);
+        resolve4(false);
       }
     });
   });
@@ -38067,7 +39590,7 @@ Respond with JSON only (no markdown code blocks):
 }
 async function executeShippedEvaluation(ideaId) {
   log(`Starting post-ship evaluation for idea: ${ideaId}`);
-  const ideasData = loadJson(IDEAS_FILE, { ideas: [] });
+  const ideasData = loadJson3(IDEAS_FILE, { ideas: [] });
   const idea = ideasData.ideas.find((i) => i.id === ideaId);
   if (!idea) {
     log(`Idea not found: ${ideaId}`);
@@ -38080,7 +39603,7 @@ async function executeShippedEvaluation(ideaId) {
   const daysShipped = daysSince(idea.implementation?.completed_at || idea.updated_at);
   let goal = null;
   if (idea.goal_id) {
-    const goalsData = loadJson(GOALS_FILE, { goals: [] });
+    const goalsData = loadJson3(GOALS_FILE, { goals: [] });
     goal = goalsData.goals.find((g2) => g2.id === idea.goal_id) || null;
   }
   const liveKPIs = await fetchLiveKPIs();
@@ -38222,8 +39745,22 @@ ${result.metric_evaluations.map((m2) => `- ${m2.status.toUpperCase()}: ${m2.metr
     });
     ideasData.ideas[ideaIndex].comments = comments;
   }
-  saveJson(IDEAS_FILE, ideasData);
+  saveJson2(IDEAS_FILE, ideasData);
   log(`Evaluation saved for ${ideaId}: status=${result.status}, next_eval=${nextEvalDate.toISOString().split("T")[0]}`);
+  if (idea.hypothesis_id) {
+    try {
+      const updated = updateHypothesisFromEvaluation(
+        idea.hypothesis_id,
+        result.status,
+        result.summary || ""
+      );
+      if (updated) {
+        log(`Hypothesis ${idea.hypothesis_id} evidence updated (${result.status})`);
+      }
+    } catch (hypError) {
+      log(`Hypothesis update failed (non-fatal): ${hypError instanceof Error ? hypError.message : "Unknown"}`);
+    }
+  }
   return true;
 }
 function generateResearchTasks(idea, config, businessContext) {
@@ -38466,8 +40003,8 @@ async function executeSingleResearchTask(task) {
   log(`  Starting research task: ${task.type} - ${task.topic}`);
   task.status = "running";
   task.started_at = (/* @__PURE__ */ new Date()).toISOString();
-  return new Promise((resolve3) => {
-    const claude = (0, import_child_process11.spawn)("claude", ["--print", "--dangerously-skip-permissions"], {
+  return new Promise((resolve4) => {
+    const claude = (0, import_child_process13.spawn)("claude", ["--print", "--dangerously-skip-permissions"], {
       cwd: ROOT_DIR,
       env: process.env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -38482,7 +40019,7 @@ async function executeSingleResearchTask(task) {
       task.completed_at = (/* @__PURE__ */ new Date()).toISOString();
       task.error_message = "Timed out after 5 minutes";
       log(`  Research task timed out: ${task.type}`);
-      resolve3(task);
+      resolve4(task);
     }, TIMEOUT_MS);
     claude.stdout.on("data", (data) => {
       output += data.toString();
@@ -38511,7 +40048,7 @@ async function executeSingleResearchTask(task) {
         task.error_message = errorOutput || `Exited with code ${code}`;
         log(`  Research task failed: ${task.type} - ${task.error_message}`);
       }
-      resolve3(task);
+      resolve4(task);
     });
     claude.on("error", (error) => {
       clearTimeout(timeout);
@@ -38519,7 +40056,7 @@ async function executeSingleResearchTask(task) {
       task.completed_at = (/* @__PURE__ */ new Date()).toISOString();
       task.error_message = error.message;
       log(`  Research task error: ${task.type} - ${error.message}`);
-      resolve3(task);
+      resolve4(task);
     });
   });
 }
@@ -38609,7 +40146,7 @@ ${parsed.risks_identified?.map((r) => `- ${r}`).join("\n") || "None identified"}
 }
 async function executeIdeaResearch(ideaId, config, businessContext) {
   log(`Executing parallel research for idea: ${ideaId}`);
-  const ideasData = loadJson(IDEAS_FILE, { ideas: [] });
+  const ideasData = loadJson3(IDEAS_FILE, { ideas: [] });
   const idea = ideasData.ideas.find((i) => i.id === ideaId);
   if (!idea) {
     log(`Idea not found: ${ideaId}`);
@@ -38620,7 +40157,7 @@ async function executeIdeaResearch(ideaId, config, businessContext) {
       log(`Auto-transitioning idea ${ideaId} from inbox to under_review for research`);
       idea.stage = "under_review";
       idea.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-      saveJson(IDEAS_FILE, ideasData);
+      saveJson2(IDEAS_FILE, ideasData);
     } else {
       log(`Idea ${ideaId} is not in under_review stage (current: ${idea.stage})`);
       return false;
@@ -38663,7 +40200,7 @@ ${research.summary}
     });
     idea.comments = comments;
   }
-  saveJson(IDEAS_FILE, ideasData);
+  saveJson2(IDEAS_FILE, ideasData);
   log(`Research saved for idea ${ideaId}: recommendation = ${research.recommendation}`);
   return true;
 }
@@ -38704,7 +40241,7 @@ async function executeTask(task, config, businessContext) {
           const ideaId = taskId.replace("evaluate-shipped-", "");
           if (!ideaId.startsWith("idea-")) {
             log(`Batch evaluation requested (parsed "${ideaId}" from task "${taskId}")`);
-            const batchIdeas = loadJson(IDEAS_FILE, { ideas: [] });
+            const batchIdeas = loadJson3(IDEAS_FILE, { ideas: [] });
             const shippedReady = batchIdeas.ideas.filter((i) => {
               if (i.stage !== "shipped") return false;
               const v2 = i.verification;
@@ -38800,6 +40337,12 @@ async function executeTask(task, config, businessContext) {
           trackEvent("heartbeat_task", { taskType: taskTypePrefix, success: result.success });
           return result.success;
         }
+        if (isGrowthCampaignTask(taskId)) {
+          const result = await executeGrowthCampaignTask(taskId, taskDesc, businessContext);
+          log(`Growth campaign task: ${result.success ? "SUCCESS" : "FAILED"} \u2014 ${result.output.slice(0, 200)}`);
+          trackEvent("heartbeat_task", { taskType: taskTypePrefix, success: result.success });
+          return result.success;
+        }
         if (isLaunchCampaignTask(taskId)) {
           const result = await executeLaunchCampaignTask(taskId, taskDesc, businessContext);
           log(`Campaign task: ${result.success ? "SUCCESS" : "FAILED"} \u2014 ${result.output.slice(0, 200)}`);
@@ -38828,7 +40371,7 @@ async function executeTask(task, config, businessContext) {
   }
 }
 async function executeReviewInbox() {
-  const ideasData = loadJson(IDEAS_FILE, { ideas: [] });
+  const ideasData = loadJson3(IDEAS_FILE, { ideas: [] });
   const inboxIdeas = ideasData.ideas.filter((i) => i.stage === "inbox");
   if (inboxIdeas.length === 0) {
     log("No ideas in inbox to review");
@@ -38842,17 +40385,17 @@ async function executeReviewInbox() {
   log("Inbox review complete (manual prioritization needed)");
 }
 async function runAnalysis(type) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     log(`Running ${type} analysis...`);
     const { command: runCmd, args: runArgs } = resolveScript(__dirname, "analyze.ts");
-    const childProcess = (0, import_child_process11.spawn)(runCmd, [...runArgs, `--type=${type}`], {
+    const childProcess = (0, import_child_process13.spawn)(runCmd, [...runArgs, `--type=${type}`], {
       cwd: ROOT_DIR,
       stdio: "inherit"
     });
     childProcess.on("close", (code) => {
       if (code === 0) {
         log(`${type} analysis completed successfully`);
-        resolve3();
+        resolve4();
       } else {
         reject(new Error(`Analysis exited with code ${code}`));
       }
@@ -38864,7 +40407,7 @@ async function runAnalysis(type) {
 }
 function updateTodoFile(taskId, completed) {
   try {
-    let content = fs35.readFileSync(TODO_FILE, "utf-8");
+    let content = fs42.readFileSync(TODO_FILE, "utf-8");
     const uncheckedPattern = new RegExp(`- \\[ \\] \`${taskId}\``, "g");
     const checkedPattern = new RegExp(`- \\[x\\] \`${taskId}\``, "g");
     if (completed) {
@@ -38872,7 +40415,7 @@ function updateTodoFile(taskId, completed) {
     } else {
       content = content.replace(checkedPattern, `- [ ] \`${taskId}\``);
     }
-    fs35.writeFileSync(TODO_FILE, content);
+    fs42.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"}`);
@@ -38991,8 +40534,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 = path30.join(PROJECT_DIR, ".claude", "commands");
-    if (!fs35.existsSync(commandsDir)) {
+    const commandsDir = path34.join(PROJECT_DIR, ".claude", "commands");
+    if (!fs42.existsSync(commandsDir)) {
       log("Slash commands missing \u2014 auto-scaffolding...");
       scaffoldSlashCommands(PROJECT_DIR);
     }
@@ -39029,7 +40572,7 @@ async function runSingleHeartbeat(beatNumber = 1) {
     if (systemHealth.all_stuck && !DRY_RUN) {
       log(`Auto-recovering: deferring ${systemHealth.stuck_idea_ids.length} stuck idea(s)...`);
       autoRecoverStuckIdeas(systemHealth.stuck_idea_ids);
-      const reloadedIdeas = loadJson(IDEAS_FILE, { ideas: [] });
+      const reloadedIdeas = loadJson3(IDEAS_FILE, { ideas: [] });
       state.ideas = reloadedIdeas.ideas;
     }
     const liveKPIs = await fetchLiveKPIs();
@@ -39040,7 +40583,7 @@ async function runSingleHeartbeat(beatNumber = 1) {
     };
     if (liveKPIs && !DRY_RUN) {
       updateGoalsWithKPIs(liveKPIs);
-      const updatedGoals = loadJson(GOALS_FILE, { goals: [] });
+      const updatedGoals = loadJson3(GOALS_FILE, { goals: [] });
       state.goals = updatedGoals.goals;
       updateBusinessContext(businessContext, liveKPIs);
       log("Updated business context with live KPIs");
@@ -39176,8 +40719,8 @@ async function runSingleHeartbeat(beatNumber = 1) {
             }
           }
           if (!inProgressIdeas.some((i) => (i.implementation.sub_tasks || []).some((st) => st.status === "pending"))) {
-            const fallbackHypotheses = loadJson(HYPOTHESES_FILE, { hypotheses: [] }).hypotheses || [];
-            const fallbackEpics = loadJson(ROADMAP_FILE, { epics: [] }).epics || [];
+            const fallbackHypotheses = loadJson3(HYPOTHESES_FILE, { hypotheses: [] }).hypotheses || [];
+            const fallbackEpics = loadJson3(ROADMAP_FILE, { epics: [] }).epics || [];
             const approvedIdeas = state.ideas.filter(
               (i) => i.stage === "approved" && (i.implementation?.decomposition_attempts || 0) < fallbackMaxRetries
             ).sort((a, b) => scoreIdea(b, state.goals, fallbackHypotheses, fallbackEpics) - scoreIdea(a, state.goals, fallbackHypotheses, fallbackEpics));
@@ -39205,7 +40748,7 @@ async function runSingleHeartbeat(beatNumber = 1) {
     }
     if (!DRY_RUN) {
       const statusContent = generateStatusContent(state, alerts, taskToDo, reasoning, systemHealth);
-      fs35.writeFileSync(STATUS_FILE, statusContent);
+      fs42.writeFileSync(STATUS_FILE, statusContent);
       log("Updated STATUS.md");
     } else {
       log("[DRY RUN] Would update STATUS.md");
@@ -39320,13 +40863,13 @@ ${"=".repeat(60)}
 `);
 }
 function saveSessionToJson(summary) {
-  const sessionsFile = path30.join(DATA_DIR, "heartbeat-sessions.json");
-  const sessionsData = loadJson(sessionsFile, { sessions: [] });
+  const sessionsFile = path34.join(DATA_DIR, "heartbeat-sessions.json");
+  const sessionsData = loadJson3(sessionsFile, { sessions: [] });
   sessionsData.sessions.push(summary);
   if (sessionsData.sessions.length > 50) {
     sessionsData.sessions = sessionsData.sessions.slice(-50);
   }
-  saveJson(sessionsFile, sessionsData);
+  saveJson2(sessionsFile, sessionsData);
   log(`Session saved to ${sessionsFile}`);
 }
 async function runContinuousSession() {