vibebusiness 1.2.73 → 1.2.77

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 fs33 = require("fs");
-    var path28 = require("path");
+    var fs34 = require("fs");
+    var path29 = 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 (fs33.existsSync(filepath)) {
+            if (fs34.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 = path28.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path29.resolve(process.cwd(), ".env.vault");
       }
-      if (fs33.existsSync(possibleVaultPath)) {
+      if (fs34.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path28.join(os3.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path29.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 = path28.resolve(process.cwd(), ".env");
+      const dotenvPath = path29.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 path29 of optionPaths) {
+      for (const path30 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs33.readFileSync(path29, { encoding }));
+          const parsed = DotenvModule.parse(fs34.readFileSync(path30, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`Failed to load ${path29} ${e.message}`);
+            _debug(`Failed to load ${path30} ${e.message}`);
           }
           lastError = e;
         }
@@ -324,7 +324,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative = path28.relative(process.cwd(), filePath);
+            const relative = path29.relative(process.cwd(), filePath);
             shortPaths.push(relative);
           } catch (e) {
             if (debug) {
@@ -3756,12 +3756,12 @@ var init_request_handler_helper = __esm({
         this.req.destroy(new Error("Request timeout."));
       }
       /* Response event handlers */
-      classicResponseHandler(resolve2, reject, res) {
+      classicResponseHandler(resolve3, 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, resolve2, reject));
-        dataStream.on("close", this.onResponseCloseHandler.bind(this, resolve2, reject));
+        dataStream.on("end", this.onResponseEndHandler.bind(this, resolve3, reject));
+        dataStream.on("close", this.onResponseCloseHandler.bind(this, resolve3, reject));
         if (this.requestData.requestEventDebugHandler) {
           this.requestData.requestEventDebugHandler("response", { res });
           res.on("aborted", (error) => this.requestData.requestEventDebugHandler("response-aborted", { error }));
@@ -3770,7 +3770,7 @@ var init_request_handler_helper = __esm({
           res.on("end", () => this.requestData.requestEventDebugHandler("response-end"));
         }
       }
-      onResponseEndHandler(resolve2, reject) {
+      onResponseEndHandler(resolve3, reject) {
         const rateLimit = this.getRateLimitFromResponse(this.res);
         let data;
         try {
@@ -3788,18 +3788,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);
         }
-        resolve2({
+        resolve3({
           data,
           headers: this.res.headers,
           rateLimit
         });
       }
-      onResponseCloseHandler(resolve2, reject) {
+      onResponseCloseHandler(resolve3, reject) {
         const res = this.res;
         if (res.aborted) {
           try {
             this.getParsedResponse(this.res);
-            return this.onResponseEndHandler(resolve2, reject);
+            return this.onResponseEndHandler(resolve3, reject);
           } catch (e) {
             return reject(this.createPartialResponseError(e, true));
           }
@@ -3808,14 +3808,14 @@ var init_request_handler_helper = __esm({
           return reject(this.createPartialResponseError(new Error("Response has been interrupted before response could be parsed."), true));
         }
       }
-      streamResponseHandler(resolve2, reject, res) {
+      streamResponseHandler(resolve3, 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);
-          resolve2({ req: this.req, res: dataStream, originalResponse: res, requestData: this.requestData });
+          resolve3({ req: this.req, res: dataStream, originalResponse: res, requestData: this.requestData });
         } else {
           this.classicResponseHandler(() => void 0, reject, res);
         }
@@ -3873,7 +3873,7 @@ var init_request_handler_helper = __esm({
       makeRequest() {
         this.buildRequest();
         return new Promise((_resolve, _reject) => {
-          const resolve2 = (value) => {
+          const resolve3 = (value) => {
             cleanupListener.emit("complete");
             _resolve(value);
           };
@@ -3885,7 +3885,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, resolve2, reject));
+          req.on("response", this.classicResponseHandler.bind(this, resolve3, reject));
           if (this.requestData.options.timeout) {
             req.on("timeout", this.timeoutErrorHandler.bind(this));
           }
@@ -3904,10 +3904,10 @@ var init_request_handler_helper = __esm({
       }
       makeRequestAndResolveWhenReady() {
         this.buildRequest();
-        return new Promise((resolve2, reject) => {
+        return new Promise((resolve3, reject) => {
           const req = this.req;
           req.on("error", this.requestErrorHandler.bind(this, reject));
-          req.on("response", this.streamResponseHandler.bind(this, resolve2, reject));
+          req.on("response", this.streamResponseHandler.bind(this, resolve3, reject));
           if (this.requestData.body) {
             req.write(this.requestData.body);
           }
@@ -6266,12 +6266,12 @@ var init_client_v1_read = __esm({
 async function readFileIntoBuffer(file) {
   const handle = await getFileHandle(file);
   if (typeof handle === "number") {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       fs13.readFile(handle, (err2, data) => {
         if (err2) {
           return reject(err2);
         }
-        resolve2(data);
+        resolve3(data);
       });
     });
   } else if (handle instanceof Buffer) {
@@ -6295,11 +6295,11 @@ function getFileHandle(file) {
 }
 async function getFileSizeFromFileHandle(fileHandle) {
   if (typeof fileHandle === "number") {
-    const stats = await new Promise((resolve2, reject) => {
+    const stats = await new Promise((resolve3, reject) => {
       fs13.fstat(fileHandle, (err2, stats2) => {
         if (err2)
           reject(err2);
-        resolve2(stats2);
+        resolve3(stats2);
       });
     });
     return stats.size;
@@ -6376,7 +6376,7 @@ function getMediaCategoryByMime(name, target) {
     return target === "tweet" ? "TweetImage" : "DmImage";
 }
 function sleepSecs(seconds) {
-  return new Promise((resolve2) => setTimeout(resolve2, seconds * 1e3));
+  return new Promise((resolve3) => setTimeout(resolve3, seconds * 1e3));
 }
 async function readNextPartOf(file, chunkLength, bufferOffset = 0, buffer) {
   if (file instanceof Buffer) {
@@ -6388,11 +6388,11 @@ async function readNextPartOf(file, chunkLength, bufferOffset = 0, buffer) {
   }
   let bytesRead;
   if (typeof file === "number") {
-    bytesRead = await new Promise((resolve2, reject) => {
+    bytesRead = await new Promise((resolve3, reject) => {
       fs13.read(file, buffer, 0, chunkLength, bufferOffset, (err2, nread) => {
         if (err2)
           reject(err2);
-        resolve2(nread);
+        resolve3(nread);
       });
     });
   } else {
@@ -8308,7 +8308,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((resolve2) => setTimeout(resolve2, 3500));
+          await new Promise((resolve3) => setTimeout(resolve3, 3500));
           runningJob = (await this.complianceJob(job.id)).data;
         }
         const result = await this.get(job.download_url, void 0, {
@@ -8517,7 +8517,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((resolve2) => setTimeout(resolve2, waitTime * 1e3));
+              await new Promise((resolve3) => setTimeout(resolve3, waitTime * 1e3));
               await this.waitForMediaProcessing(mediaId);
             }
           }
@@ -9434,10 +9434,10 @@ __export(screenshot_exports, {
   captureIdeaScreenshot: () => captureIdeaScreenshot
 });
 async function captureIdeaScreenshot(ideaId, previewUrl, options) {
-  const outputDir = options?.outputDir ?? path26.join(DATA_DIR, "reports");
+  const outputDir = options?.outputDir ?? path27.join(DATA_DIR, "reports");
   const timeoutMs = options?.timeoutMs ?? 15e3;
-  const outputPath = path26.join(outputDir, `${ideaId}-screenshot.png`);
-  if (fs31.existsSync(outputPath)) return outputPath;
+  const outputPath = path27.join(outputDir, `${ideaId}-screenshot.png`);
+  if (fs32.existsSync(outputPath)) return outputPath;
   try {
     const controller = new AbortController();
     const probeTimeout = setTimeout(() => controller.abort(), 3e3);
@@ -9457,7 +9457,7 @@ async function captureIdeaScreenshot(ideaId, previewUrl, options) {
       });
       await page.goto(previewUrl, { waitUntil: "networkidle", timeout: timeoutMs });
       await page.waitForTimeout(500);
-      fs31.mkdirSync(outputDir, { recursive: true });
+      fs32.mkdirSync(outputDir, { recursive: true });
       await page.screenshot({ path: outputPath });
       return outputPath;
     } finally {
@@ -9467,12 +9467,12 @@ async function captureIdeaScreenshot(ideaId, previewUrl, options) {
     return null;
   }
 }
-var fs31, path26;
+var fs32, path27;
 var init_screenshot = __esm({
   "scripts/lib/screenshot.ts"() {
     "use strict";
-    fs31 = __toESM(require("fs"));
-    path26 = __toESM(require("path"));
+    fs32 = __toESM(require("fs"));
+    path27 = __toESM(require("path"));
     init_paths();
   }
 });
@@ -9489,9 +9489,9 @@ var init_screenshot = __esm({
 })();
 
 // scripts/heartbeat.ts
-var fs32 = __toESM(require("fs"));
-var path27 = __toESM(require("path"));
-var import_child_process10 = require("child_process");
+var fs33 = __toESM(require("fs"));
+var path28 = __toESM(require("path"));
+var import_child_process11 = require("child_process");
 var import_util = require("util");
 
 // src/lib/kpi-adapters/rest-api.ts
@@ -13134,8 +13134,8 @@ function argument(predicate, message) {
   }
 }
 var check = { fail, argument, assert: argument };
-function getPathDefinition(glyph, path28) {
-  var _path = path28 || new Path();
+function getPathDefinition(glyph, path29) {
+  var _path = path29 || new Path();
   return {
     configurable: true,
     get: function() {
@@ -13358,9 +13358,9 @@ function ttfGlyphLoader(font, index, parseGlyph2, data, position, buildPath2) {
     var glyph = new Glyph({ index, font });
     glyph.path = function() {
       parseGlyph2(glyph, data, position);
-      var path28 = buildPath2(font.glyphs, glyph);
-      path28.unitsPerEm = font.unitsPerEm;
-      return path28;
+      var path29 = buildPath2(font.glyphs, glyph);
+      path29.unitsPerEm = font.unitsPerEm;
+      return path29;
     };
     defineDependentProperty(glyph, "xMin", "_xMin");
     defineDependentProperty(glyph, "xMax", "_xMax");
@@ -13373,9 +13373,9 @@ function cffGlyphLoader(font, index, parseCFFCharstring2, charstring) {
   return function() {
     var glyph = new Glyph({ index, font });
     glyph.path = function() {
-      var path28 = parseCFFCharstring2(font, glyph, charstring);
-      path28.unitsPerEm = font.unitsPerEm;
-      return path28;
+      var path29 = parseCFFCharstring2(font, glyph, charstring);
+      path29.unitsPerEm = font.unitsPerEm;
+      return path29;
     };
     return glyph;
   };
@@ -30494,8 +30494,8 @@ async function postTweet(client, text) {
   };
 }
 async function uploadMedia(client, filePath) {
-  const fs33 = require("fs");
-  if (!fs33.existsSync(filePath)) {
+  const fs34 = require("fs");
+  if (!fs34.existsSync(filePath)) {
     throw new Error(`Media file not found: ${filePath}`);
   }
   const mediaId = await client.v1.uploadMedia(filePath);
@@ -30875,7 +30875,7 @@ function invokeClaudeCLI(options, claudePath) {
   }
   const startTime = Date.now();
   const timeoutMs = options.timeoutMs || 3e5;
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const child = (0, import_child_process6.spawn)(bin, args2, {
       cwd: options.cwd || process.cwd(),
       env: process.env,
@@ -30895,7 +30895,7 @@ function invokeClaudeCLI(options, claudePath) {
     }
     const timeout = setTimeout(() => {
       child.kill("SIGTERM");
-      resolve2({
+      resolve3({
         output: stdout,
         provider: "claude-cli",
         durationMs: Date.now() - startTime,
@@ -30904,7 +30904,7 @@ function invokeClaudeCLI(options, claudePath) {
     }, timeoutMs);
     child.on("close", (code) => {
       clearTimeout(timeout);
-      resolve2({
+      resolve3({
         output: stdout.trim(),
         provider: "claude-cli",
         durationMs: Date.now() - startTime,
@@ -30913,7 +30913,7 @@ function invokeClaudeCLI(options, claudePath) {
     });
     child.on("error", (err2) => {
       clearTimeout(timeout);
-      resolve2({
+      resolve3({
         output: "",
         provider: "claude-cli",
         durationMs: Date.now() - startTime,
@@ -32980,20 +32980,103 @@ function readPromoCopyFreshness() {
 }
 
 // scripts/skills/promo-video.ts
-var fs21 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var fs22 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
+var import_child_process9 = require("child_process");
 init_paths();
 
 // scripts/lib/video/render-bridge.ts
 var import_child_process8 = require("child_process");
-var fs20 = __toESM(require("fs"));
+var fs21 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
+
+// scripts/lib/video/renderer.ts
 var path14 = __toESM(require("path"));
+var fs20 = __toESM(require("fs"));
+var bundleCache = null;
+function findCompositionsEntry() {
+  const devPath = path14.resolve(__dirname, "compositions", "Root.tsx");
+  if (fs20.existsSync(devPath)) return devPath;
+  const installedPath = path14.resolve(
+    __dirname,
+    "../../scripts/lib/video/compositions/Root.tsx"
+  );
+  if (fs20.existsSync(installedPath)) return installedPath;
+  throw new Error(
+    `Remotion compositions entry not found.
+Checked:
+  ${devPath}
+  ${installedPath}`
+  );
+}
+function getCompositionId(slideCount, format) {
+  const isAd = slideCount <= 5;
+  if (isAd) return format === "reels" ? "AdReels" : "AdFeed";
+  return format === "reels" ? "ShipReels" : "ShipFeed";
+}
+function loadRemotionDeps() {
+  const { bundle } = require("@remotion/bundler");
+  const { selectComposition, renderMedia } = require("@remotion/renderer");
+  return { bundle, selectComposition, renderMedia };
+}
+async function renderCarousel(carousel, format, outputPath, _depsOverride) {
+  try {
+    const { bundle, selectComposition, renderMedia } = _depsOverride ?? loadRemotionDeps();
+    const entryPoint = findCompositionsEntry();
+    const compositionId = getCompositionId(carousel.slides.length, format);
+    if (!bundleCache) {
+      console.log(
+        "[Renderer] Bundling Remotion compositions (first render \u2014 may take ~1-2 min)..."
+      );
+      bundleCache = await bundle({ entryPoint });
+      console.log("[Renderer] Bundle complete.");
+    }
+    const inputProps = { slides: carousel.slides, format };
+    const composition = await selectComposition({
+      serveUrl: bundleCache,
+      id: compositionId,
+      inputProps
+    });
+    fs20.mkdirSync(path14.dirname(outputPath), { recursive: true });
+    await renderMedia({
+      composition,
+      serveUrl: bundleCache,
+      codec: "h264",
+      outputLocation: outputPath,
+      inputProps
+    });
+    const sizeKb = Math.round(fs20.statSync(outputPath).size / 1024);
+    return {
+      success: true,
+      videoPath: outputPath,
+      output: `Video rendered: ${outputPath} (${sizeKb}KB)`
+    };
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      output: `Self-contained render failed: ${errMsg.slice(0, 1e3)}`
+    };
+  }
+}
+function isSelfContainedRendererAvailable() {
+  try {
+    require.resolve("@remotion/bundler");
+    require.resolve("@remotion/renderer");
+    findCompositionsEntry();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// scripts/lib/video/render-bridge.ts
 function isContentFlowAvailable(repoPath) {
-  if (!repoPath || !fs20.existsSync(repoPath)) return false;
-  const pkgPath = path14.join(repoPath, "package.json");
-  if (!fs20.existsSync(pkgPath)) return false;
+  if (!repoPath || !fs21.existsSync(repoPath)) return false;
+  const pkgPath = path15.join(repoPath, "package.json");
+  if (!fs21.existsSync(pkgPath)) return false;
   try {
-    const pkg = JSON.parse(fs20.readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(fs21.readFileSync(pkgPath, "utf-8"));
     return !!(pkg.scripts?.["render-video"] || pkg.scripts?.["render-carousels"]);
   } catch {
     return false;
@@ -33057,47 +33140,64 @@ function generateCarouselJson(idea) {
     }
   };
 }
-function renderVideo(repoPath, carouselJsonPath, format = "reels", outputDir) {
+async function renderVideo(repoPath, carouselJsonPath, format = "reels", outputDir) {
+  const slug = path15.basename(carouselJsonPath, ".json");
+  const finalOutputPath = outputDir ? path15.join(outputDir, `${slug}.mp4`) : `${carouselJsonPath.replace(/\.json$/, "")}.mp4`;
+  if (isSelfContainedRendererAvailable()) {
+    let carousel;
+    try {
+      carousel = JSON.parse(fs21.readFileSync(carouselJsonPath, "utf-8"));
+    } catch {
+      return { success: false, videoPath: null, output: `Failed to read carousel JSON: ${carouselJsonPath}` };
+    }
+    if (outputDir) {
+      fs21.mkdirSync(outputDir, { recursive: true });
+    }
+    const result = await renderCarousel(carousel, format, finalOutputPath);
+    if (result.success) {
+      return { success: true, videoPath: result.videoPath ?? null, output: result.output };
+    }
+    console.warn(`[RenderBridge] Self-contained renderer failed: ${result.output}`);
+    console.warn("[RenderBridge] Falling back to ContentFlow...");
+  }
   if (!isContentFlowAvailable(repoPath)) {
     return {
       success: false,
       videoPath: null,
-      output: `ContentFlow repo not available at: ${repoPath}`
+      output: `Self-contained render unavailable and ContentFlow repo not found at: ${repoPath}`
     };
   }
-  const slug = path14.basename(carouselJsonPath, ".json");
   try {
     const command = `npm run render-video -- --input "${carouselJsonPath}" --format ${format}`;
-    console.log(`[RenderBridge] Running: ${command} in ${repoPath}`);
+    console.log(`[RenderBridge] ContentFlow fallback: ${command} in ${repoPath}`);
     const output = (0, import_child_process8.execSync)(command, {
       cwd: repoPath,
       encoding: "utf-8",
       timeout: 3e5,
-      // 5 minute timeout for rendering
       stdio: ["pipe", "pipe", "pipe"]
     });
-    const contentVideosDir = path14.join(repoPath, "content", "videos");
+    const contentVideosDir = path15.join(repoPath, "content", "videos");
     const possibleOutputs = [
-      path14.join(contentVideosDir, `${slug}.mp4`),
-      path14.join(contentVideosDir, `${slug}-${format}.mp4`)
+      path15.join(contentVideosDir, `${slug}.mp4`),
+      path15.join(contentVideosDir, `${slug}-${format}.mp4`)
     ];
     let videoPath = null;
     for (const candidate of possibleOutputs) {
-      if (fs20.existsSync(candidate)) {
+      if (fs21.existsSync(candidate)) {
         videoPath = candidate;
         break;
       }
     }
     if (videoPath && outputDir) {
-      fs20.mkdirSync(outputDir, { recursive: true });
-      const destPath = path14.join(outputDir, path14.basename(videoPath));
-      fs20.copyFileSync(videoPath, destPath);
+      fs21.mkdirSync(outputDir, { recursive: true });
+      const destPath = path15.join(outputDir, path15.basename(videoPath));
+      fs21.copyFileSync(videoPath, destPath);
       videoPath = destPath;
     }
     return {
       success: !!videoPath,
       videoPath,
-      output: videoPath ? `Video rendered: ${videoPath} (${Math.round(fs20.statSync(videoPath).size / 1024)}KB)` : `Render completed but output not found. CLI output: ${output.slice(-500)}`
+      output: videoPath ? `Video rendered via ContentFlow: ${videoPath} (${Math.round(fs21.statSync(videoPath).size / 1024)}KB)` : `ContentFlow render completed but output not found. CLI output: ${output.slice(-500)}`
     };
   } catch (error) {
     const errMsg = error instanceof Error ? error.message : String(error);
@@ -33110,8 +33210,8 @@ function renderVideo(repoPath, carouselJsonPath, format = "reels", outputDir) {
 }
 
 // scripts/skills/promo-video.ts
-var VIDEOS_DIR = path15.join(DATA_DIR, "videos");
-var CAROUSEL_STAGING_DIR = path15.join(DATA_DIR, "videos", "staging");
+var VIDEOS_DIR = path16.join(DATA_DIR, "videos");
+var CAROUSEL_STAGING_DIR = path16.join(DATA_DIR, "videos", "staging");
 var VIDEO_PREFIXES = [
   "video-render-ship-",
   "video-render-ad-",
@@ -33139,20 +33239,13 @@ async function executePromoVideoTask(taskId, description, businessContext) {
     return { success: false, output: `Video task failed: ${errMsg}` };
   }
 }
-function executeRenderShip(ideaId, businessContext) {
+async function executeRenderShip(ideaId, businessContext) {
   if (!ideaId) {
     return { success: false, output: "No idea ID provided" };
   }
-  const repoPath = businessContext?.contentflow?.repo_path;
-  if (!repoPath || !isContentFlowAvailable(repoPath)) {
-    return {
-      success: false,
-      output: `ContentFlow repo not available at: ${repoPath || "(not configured)"}. Set contentflow.repo_path in business-context.json.`
-    };
-  }
   let idea;
   try {
-    const ideasData = JSON.parse(fs21.readFileSync(IDEAS_FILE, "utf-8"));
+    const ideasData = JSON.parse(fs22.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}` };
@@ -33160,42 +33253,93 @@ function executeRenderShip(ideaId, businessContext) {
   if (!idea) {
     return { success: false, output: `Idea not found: ${ideaId}` };
   }
-  const outputPath = path15.join(VIDEOS_DIR, `${ideaId}-ship.mp4`);
-  if (fs21.existsSync(outputPath)) {
-    return { success: true, output: `Ship video already exists: ${outputPath}` };
+  const finalPath = path16.join(VIDEOS_DIR, `${ideaId}-ship.mp4`);
+  if (fs22.existsSync(finalPath)) {
+    return { success: true, output: `Ship video already exists: ${finalPath}` };
   }
   const carouselData = generateCarouselJson(idea);
-  fs21.mkdirSync(CAROUSEL_STAGING_DIR, { recursive: true });
-  const carouselPath = path15.join(CAROUSEL_STAGING_DIR, `${ideaId}-ship.json`);
-  fs21.writeFileSync(carouselPath, JSON.stringify(carouselData, null, 2));
-  const result = renderVideo(repoPath, carouselPath, "reels", VIDEOS_DIR);
+  fs22.mkdirSync(CAROUSEL_STAGING_DIR, { recursive: true });
+  const carouselPath = path16.join(CAROUSEL_STAGING_DIR, `${ideaId}-ship.json`);
+  fs22.writeFileSync(carouselPath, JSON.stringify(carouselData, null, 2));
+  const repoPath = businessContext?.contentflow?.repo_path ?? "";
+  const result = await renderVideo(repoPath, carouselPath, "reels", VIDEOS_DIR);
   if (result.success && result.videoPath) {
-    const finalPath = path15.join(VIDEOS_DIR, `${ideaId}-ship.mp4`);
     if (result.videoPath !== finalPath) {
-      fs21.renameSync(result.videoPath, finalPath);
+      fs22.renameSync(result.videoPath, finalPath);
     }
-    return {
-      success: true,
-      output: `Ship video rendered: ${finalPath}`
-    };
+    return { success: true, output: `Ship video rendered: ${finalPath}` };
   }
-  return {
-    success: false,
-    output: result.output
-  };
+  return { success: false, output: result.output };
 }
-function executeRenderAd(topic, businessContext) {
-  if (!topic) {
-    return { success: false, output: "No topic provided" };
+async function generateAdCarouselWithClaude(topic, _businessContext) {
+  let positioning = {};
+  try {
+    if (fs22.existsSync(POSITIONING_FILE)) {
+      positioning = JSON.parse(fs22.readFileSync(POSITIONING_FILE, "utf-8"));
+    }
+  } catch {
   }
-  const repoPath = businessContext?.contentflow?.repo_path;
-  if (!repoPath || !isContentFlowAvailable(repoPath)) {
-    return {
-      success: false,
-      output: `ContentFlow repo not available at: ${repoPath || "(not configured)"}. Set contentflow.repo_path in business-context.json.`
-    };
+  const copyBank = positioning?.copy_bank ?? {};
+  const current = positioning?.current ?? {};
+  const prompt = `You are a conversion copywriter for VibeBusiness, an autonomous AI product manager CLI targeting indie hackers and solo technical founders.
+
+Generate a short ad video carousel (5-7 slides) for the angle/hook: "${topic}"
+
+## Audience
+${JSON.stringify(current?.target_audience ?? {}, null, 2)}
+
+## Available copy bank (use this \u2014 do not invent):
+Pain points: ${JSON.stringify(copyBank?.pain_points ?? [], null, 2)}
+Headlines: ${JSON.stringify(copyBank?.headlines ?? [], null, 2)}
+Subheadlines: ${JSON.stringify(copyBank?.subheadlines ?? [], null, 2)}
+CTAs: ${JSON.stringify(copyBank?.ctas ?? [], null, 2)}
+Social proof: ${JSON.stringify(copyBank?.social_proof ?? [], null, 2)}
+Objection handlers: ${JSON.stringify(copyBank?.objection_handlers ?? [], null, 2)}
+
+## Slide types and their required/optional props:
+- cover: title (required), subtitle (optional), background_style ("gradient"|"dark"|"light")
+- key_point: title (required), content (required \u2014 max 15 words, punchy)
+- steps: title (required), items (required \u2014 array of 3 short steps, max 6 words each)
+- statistic: title (required), value (required \u2014 bold number/stat), label (required \u2014 what it measures)
+- quote: title (optional), content (required \u2014 max 20 words), author (optional)
+- cta: title (required), subtitle (optional), cta_text (required \u2014 action verb phrase)
+
+## Framework
+Use PAS (Problem \u2192 Agitate \u2192 Solution) or AIDA. Start with a hook that names the pain, build tension, present the solution, close with a high-contrast CTA. Each slide displays for ~3 seconds \u2014 text must be short and punchy.
+
+## Output format
+Return ONLY valid JSON matching this exact schema (no markdown, no explanation):
+{
+  "slug": "ad-${topic}",
+  "title": "<angle title>",
+  "variation": "v1",
+  "slides": [
+    { "type": "<slide_type>", ...slide_props }
+  ],
+  "theme": {
+    "background_style": "gradient",
+    "primary_color": "#6366f1",
+    "text_color": "#ffffff"
+  }
+}`;
+  try {
+    const result = (0, import_child_process9.spawnSync)("claude", ["--print", "--model", "sonnet", "-p", prompt], {
+      cwd: PROJECT_DIR,
+      encoding: "utf-8",
+      timeout: 9e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (result.status === 0 && result.stdout) {
+      const raw = result.stdout.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/, "");
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed.slides) && parsed.slides.length > 0) {
+        return parsed;
+      }
+    }
+  } catch {
   }
-  const adCarousel = {
+  console.error(`[promo-video] Claude unavailable or returned invalid JSON for topic "${topic}" \u2014 using hardcoded fallback`);
+  return {
     slug: `ad-${topic}`,
     title: topic,
     variation: "v1",
@@ -33208,58 +33352,62 @@ function executeRenderAd(topic, businessContext) {
     ],
     theme: { background_style: "gradient", primary_color: "#6366f1", text_color: "#ffffff" }
   };
-  fs21.mkdirSync(CAROUSEL_STAGING_DIR, { recursive: true });
-  const carouselPath = path15.join(CAROUSEL_STAGING_DIR, `ad-${topic}.json`);
-  fs21.writeFileSync(carouselPath, JSON.stringify(adCarousel, null, 2));
-  fs21.mkdirSync(VIDEOS_DIR, { recursive: true });
-  const result = renderVideo(repoPath, carouselPath, "reels", VIDEOS_DIR);
+}
+async function executeRenderAd(topic, businessContext) {
+  if (!topic) {
+    return { success: false, output: "No topic provided" };
+  }
+  const adCarousel = await generateAdCarouselWithClaude(topic, businessContext);
+  fs22.mkdirSync(CAROUSEL_STAGING_DIR, { recursive: true });
+  const carouselPath = path16.join(CAROUSEL_STAGING_DIR, `ad-${topic}.json`);
+  fs22.writeFileSync(carouselPath, JSON.stringify(adCarousel, null, 2));
+  fs22.mkdirSync(VIDEOS_DIR, { recursive: true });
+  const repoPath = businessContext?.contentflow?.repo_path ?? "";
+  const result = await renderVideo(repoPath, carouselPath, "reels", VIDEOS_DIR);
   if (result.success && result.videoPath) {
-    return {
-      success: true,
-      output: `Ad video rendered: ${result.videoPath}`
-    };
+    return { success: true, output: `Ad video rendered: ${result.videoPath}` };
   }
-  return {
-    success: false,
-    output: result.output
-  };
+  return { success: false, output: result.output };
 }
 function executeCheckStatus4(businessContext) {
   const lines = ["## Promo Video Status\n"];
+  const selfContained = isSelfContainedRendererAvailable();
+  lines.push(`- Self-contained renderer: ${selfContained ? "ready" : "unavailable (run: npm install remotion @remotion/bundler @remotion/renderer)"}`);
   const repoPath = businessContext?.contentflow?.repo_path;
   if (!repoPath) {
-    lines.push("- ContentFlow: not configured (set contentflow.repo_path in business-context.json)");
+    lines.push("- ContentFlow fallback: not configured (optional)");
   } else if (!isContentFlowAvailable(repoPath)) {
-    lines.push(`- ContentFlow: not found at ${repoPath}`);
+    lines.push(`- ContentFlow fallback: not found at ${repoPath}`);
   } else {
-    lines.push(`- ContentFlow: available at ${repoPath}`);
+    lines.push(`- ContentFlow fallback: available at ${repoPath}`);
   }
-  if (fs21.existsSync(VIDEOS_DIR)) {
-    const videos = fs21.readdirSync(VIDEOS_DIR).filter((f) => f.endsWith(".mp4"));
+  if (fs22.existsSync(VIDEOS_DIR)) {
+    const videos = fs22.readdirSync(VIDEOS_DIR).filter((f) => f.endsWith(".mp4"));
     lines.push(`- Rendered videos: ${videos.length}`);
     for (const video of videos.slice(0, 10)) {
-      const stat = fs21.statSync(path15.join(VIDEOS_DIR, video));
+      const stat = fs22.statSync(path16.join(VIDEOS_DIR, video));
       lines.push(`  - ${video} (${Math.round(stat.size / 1024)}KB)`);
     }
   } else {
     lines.push("- Rendered videos: 0");
   }
-  if (fs21.existsSync(CAROUSEL_STAGING_DIR)) {
-    const staging = fs21.readdirSync(CAROUSEL_STAGING_DIR).filter((f) => f.endsWith(".json"));
+  if (fs22.existsSync(CAROUSEL_STAGING_DIR)) {
+    const staging = fs22.readdirSync(CAROUSEL_STAGING_DIR).filter((f) => f.endsWith(".json"));
     lines.push(`- Staging carousel JSONs: ${staging.length}`);
   }
   return { success: true, output: lines.join("\n") };
 }
 function readPromoVideoFreshness() {
   const result = {
+    self_contained_renderer: isSelfContainedRendererAvailable(),
     contentflow_available: false,
     video_count: 0,
     last_video: null
   };
   try {
-    const contextPath = path15.join(DATA_DIR, "business-context.json");
-    if (fs21.existsSync(contextPath)) {
-      const ctx = JSON.parse(fs21.readFileSync(contextPath, "utf-8"));
+    const contextPath = path16.join(DATA_DIR, "business-context.json");
+    if (fs22.existsSync(contextPath)) {
+      const ctx = JSON.parse(fs22.readFileSync(contextPath, "utf-8"));
       const repoPath = ctx?.contentflow?.repo_path;
       if (repoPath) {
         result.contentflow_available = isContentFlowAvailable(repoPath);
@@ -33267,9 +33415,9 @@ function readPromoVideoFreshness() {
     }
   } catch {
   }
-  if (fs21.existsSync(VIDEOS_DIR)) {
+  if (fs22.existsSync(VIDEOS_DIR)) {
     try {
-      const videos = fs21.readdirSync(VIDEOS_DIR).filter((f) => f.endsWith(".mp4"));
+      const videos = fs22.readdirSync(VIDEOS_DIR).filter((f) => f.endsWith(".mp4"));
       result.video_count = videos.length;
       if (videos.length > 0) {
         result.last_video = videos.sort().reverse()[0];
@@ -33281,10 +33429,10 @@ function readPromoVideoFreshness() {
 }
 
 // scripts/skills/launch-campaign.ts
-var fs22 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var fs23 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
 init_paths();
-var CAMPAIGNS_DIR = path16.join(DATA_DIR, "campaigns");
+var CAMPAIGNS_DIR = path17.join(DATA_DIR, "campaigns");
 var CAMPAIGN_PREFIXES = [
   "campaign-launch-",
   "campaign-milestone-",
@@ -33301,42 +33449,42 @@ function detectChannels(businessContext) {
     contentflow: false
   };
   try {
-    if (fs22.existsSync(SOCIAL_FILE)) {
-      const social = JSON.parse(fs22.readFileSync(SOCIAL_FILE, "utf-8"));
+    if (fs23.existsSync(SOCIAL_FILE)) {
+      const social = JSON.parse(fs23.readFileSync(SOCIAL_FILE, "utf-8"));
       channels.social = social.credentials_valid;
     }
   } catch {
   }
   channels.email = !!process.env.LOOPS_API_KEY;
   try {
-    if (fs22.existsSync(POSITIONING_FILE)) {
-      const pos = JSON.parse(fs22.readFileSync(POSITIONING_FILE, "utf-8"));
+    if (fs23.existsSync(POSITIONING_FILE)) {
+      const pos = JSON.parse(fs23.readFileSync(POSITIONING_FILE, "utf-8"));
       channels.positioning = !!pos?.current?.tagline;
     }
   } catch {
   }
   if (businessContext?.contentflow?.repo_path) {
-    channels.contentflow = fs22.existsSync(businessContext.contentflow.repo_path);
+    channels.contentflow = fs23.existsSync(businessContext.contentflow.repo_path);
   }
   return channels;
 }
 function saveCampaign(campaign) {
-  fs22.mkdirSync(CAMPAIGNS_DIR, { recursive: true });
-  const filePath = path16.join(CAMPAIGNS_DIR, `${campaign.id}.json`);
-  fs22.writeFileSync(filePath, JSON.stringify(campaign, null, 2) + "\n");
+  fs23.mkdirSync(CAMPAIGNS_DIR, { recursive: true });
+  const filePath = path17.join(CAMPAIGNS_DIR, `${campaign.id}.json`);
+  fs23.writeFileSync(filePath, JSON.stringify(campaign, null, 2) + "\n");
 }
 function loadCampaigns() {
-  if (!fs22.existsSync(CAMPAIGNS_DIR)) return [];
+  if (!fs23.existsSync(CAMPAIGNS_DIR)) return [];
   try {
-    return fs22.readdirSync(CAMPAIGNS_DIR).filter((f) => f.endsWith(".json")).map((f) => JSON.parse(fs22.readFileSync(path16.join(CAMPAIGNS_DIR, f), "utf-8"))).sort((a, b) => b.created_at.localeCompare(a.created_at));
+    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));
   } catch {
     return [];
   }
 }
 function appendToTodo(tasks) {
   let content = "";
-  if (fs22.existsSync(TODO_FILE)) {
-    content = fs22.readFileSync(TODO_FILE, "utf-8");
+  if (fs23.existsSync(TODO_FILE)) {
+    content = fs23.readFileSync(TODO_FILE, "utf-8");
   }
   const newLines = tasks.map(
     (t) => `- [ ] **${t.taskId}** \u2014 ${t.description}`
@@ -33352,7 +33500,7 @@ function appendToTodo(tasks) {
 ${newLines}
 `;
   }
-  fs22.writeFileSync(TODO_FILE, content);
+  fs23.writeFileSync(TODO_FILE, content);
 }
 async function executeLaunchCampaignTask(taskId, description, businessContext) {
   try {
@@ -33379,7 +33527,7 @@ function executeLaunchShip(ideaId, businessContext) {
   }
   let idea;
   try {
-    const ideasData = JSON.parse(fs22.readFileSync(IDEAS_FILE, "utf-8"));
+    const ideasData = JSON.parse(fs23.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}` };
@@ -33400,8 +33548,8 @@ function executeLaunchShip(ideaId, businessContext) {
   const channels = detectChannels(businessContext);
   const activeChannels = [];
   const subTasks = [];
-  const cardPath = path16.join(DATA_DIR, "reports", "visuals", `${ideaId}-card.png`);
-  if (!fs22.existsSync(cardPath)) {
+  const cardPath = path17.join(DATA_DIR, "reports", "visuals", `${ideaId}-card.png`);
+  if (!fs23.existsSync(cardPath)) {
     subTasks.push({
       task_id: `generate-visual-${ideaId}`,
       description: `Generate ship card PNG for "${idea.title}"`,
@@ -33492,8 +33640,8 @@ function executeLaunchMilestone(kpiId, businessContext) {
   }
   let kpiName = kpiId;
   try {
-    if (fs22.existsSync(GOALS_FILE)) {
-      const goalsData = JSON.parse(fs22.readFileSync(GOALS_FILE, "utf-8"));
+    if (fs23.existsSync(GOALS_FILE)) {
+      const goalsData = JSON.parse(fs23.readFileSync(GOALS_FILE, "utf-8"));
       for (const goal of goalsData.goals) {
         const kpi = goal.kpis.find((k) => k.id === kpiId);
         if (kpi) {
@@ -33592,12 +33740,89 @@ function readCampaignFreshness() {
   };
 }
 
+// scripts/skills/marketing-strategy.ts
+var STAGNATION_WINDOW_DAYS = 14;
+function detectMarketingTriggers(goals, previousGoals) {
+  const triggers = [];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  goals.forEach((goal) => {
+    if (goal.status === "achieved") {
+      return;
+    }
+    goal.kpis.forEach((kpi) => {
+      const stagnation = detectKPIStagnation(kpi, STAGNATION_WINDOW_DAYS);
+      if (stagnation && goal.status === "behind") {
+        triggers.push({
+          id: `trigger-stagnation-${goal.id}-${kpi.id}`,
+          type: "kpi_stagnation",
+          severity: "urgent",
+          description: `KPI "${kpi.name}" has been stagnant at ${kpi.current_value} for ${stagnation.days} days while goal "${goal.title}" is behind schedule`,
+          affected_goal_ids: [goal.id],
+          suggested_action: `Launch marketing campaign to move ${kpi.name} from ${kpi.current_value} toward target of ${kpi.target_value}`,
+          detected_at: now
+        });
+      }
+    });
+    if (previousGoals) {
+      const previousGoal = previousGoals.find((g2) => g2.id === goal.id);
+      if (previousGoal && previousGoal.status === "on_track" && goal.status === "behind") {
+        triggers.push({
+          id: `trigger-regression-${goal.id}`,
+          type: "goal_regression",
+          severity: "high",
+          description: `Goal "${goal.title}" regressed from "on_track" to "behind" schedule`,
+          affected_goal_ids: [goal.id],
+          suggested_action: `Analyze why goal regressed and launch recovery campaign`,
+          detected_at: now
+        });
+      }
+    }
+  });
+  return triggers;
+}
+function detectKPIStagnation(kpi, windowDays) {
+  if (kpi.history.length < 2) {
+    return null;
+  }
+  const sortedHistory = [...kpi.history].sort(
+    (a, b) => new Date(b.date).getTime() - new Date(a.date).getTime()
+  );
+  const latestValue = sortedHistory[0].value;
+  const latestDate = new Date(sortedHistory[0].date);
+  const windowStart = /* @__PURE__ */ new Date();
+  windowStart.setDate(windowStart.getDate() - windowDays);
+  let isStagnant = true;
+  let lastChangeDate = sortedHistory[0].date;
+  for (let i = 0; i < sortedHistory.length; i++) {
+    const entry = sortedHistory[i];
+    const entryDate = new Date(entry.date);
+    if (entryDate < windowStart) {
+      break;
+    }
+    if (entry.value !== latestValue) {
+      isStagnant = false;
+      lastChangeDate = sortedHistory[i - 1]?.date || entry.date;
+      break;
+    }
+  }
+  if (isStagnant && latestDate > windowStart) {
+    const daysDiff = Math.floor(
+      (Date.now() - new Date(lastChangeDate).getTime()) / (1e3 * 60 * 60 * 24)
+    );
+    return {
+      days: daysDiff,
+      last_change_date: lastChangeDate
+    };
+  }
+  return null;
+}
+
 // scripts/lib/run.ts
-var path17 = __toESM(require("path"));
+var path18 = __toESM(require("path"));
 function resolveScript(baseDir, scriptName) {
-  const isCompiled = path17.extname(__filename) === ".js";
+  const isCompiled = path18.extname(__filename) === ".js";
   const resolvedName = isCompiled ? scriptName.replace(/\.ts$/, ".js") : scriptName;
-  const scriptPath = path17.join(baseDir, resolvedName);
+  const scriptPath = path18.join(baseDir, resolvedName);
   return isCompiled ? { command: "node", args: [scriptPath] } : { command: "npx", args: ["tsx", scriptPath] };
 }
 
@@ -33651,8 +33876,8 @@ function groupTasksByConflicts(tasks) {
 }
 
 // scripts/lib/json-lock.ts
-var fs23 = __toESM(require("fs"));
-var path18 = __toESM(require("path"));
+var fs24 = __toESM(require("fs"));
+var path19 = __toESM(require("path"));
 var DEFAULT_MAX_WAIT_MS = 1e4;
 var BASE_BACKOFF_MS = 50;
 var MAX_BACKOFF_MS = 150;
@@ -33660,10 +33885,10 @@ function withFileLock(lockPath, fn, maxWaitMs = DEFAULT_MAX_WAIT_MS) {
   const startTime = Date.now();
   while (true) {
     try {
-      fs23.mkdirSync(lockPath, { recursive: false });
+      fs24.mkdirSync(lockPath, { recursive: false });
       try {
-        fs23.writeFileSync(
-          path18.join(lockPath, "owner"),
+        fs24.writeFileSync(
+          path19.join(lockPath, "owner"),
           JSON.stringify({ pid: process.pid, acquired: Date.now() })
         );
       } catch {
@@ -33692,16 +33917,16 @@ function withFileLock(lockPath, fn, maxWaitMs = DEFAULT_MAX_WAIT_MS) {
 }
 function atomicWriteFileSync(filePath, content) {
   const tmpPath = `${filePath}.${process.pid}.tmp`;
-  fs23.writeFileSync(tmpPath, content, "utf-8");
-  fs23.renameSync(tmpPath, filePath);
+  fs24.writeFileSync(tmpPath, content, "utf-8");
+  fs24.renameSync(tmpPath, filePath);
 }
 function releaseLock(lockPath) {
   try {
-    const ownerFile = path18.join(lockPath, "owner");
-    if (fs23.existsSync(ownerFile)) {
-      fs23.unlinkSync(ownerFile);
+    const ownerFile = path19.join(lockPath, "owner");
+    if (fs24.existsSync(ownerFile)) {
+      fs24.unlinkSync(ownerFile);
     }
-    fs23.rmdirSync(lockPath);
+    fs24.rmdirSync(lockPath);
   } catch {
   }
 }
@@ -33712,57 +33937,57 @@ function sleepSync(ms2) {
 }
 
 // scripts/lib/worktree.ts
-var fs25 = __toESM(require("fs"));
-var path20 = __toESM(require("path"));
+var fs26 = __toESM(require("fs"));
+var path21 = __toESM(require("path"));
 
 // scripts/lib/git-utils.ts
-var import_child_process9 = require("child_process");
-var fs24 = __toESM(require("fs"));
-var path19 = __toESM(require("path"));
+var import_child_process10 = require("child_process");
+var fs25 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
 function cleanGitState(workspacePath) {
-  if (!fs24.existsSync(workspacePath)) return;
-  const gitDir = path19.join(workspacePath, ".git");
-  if (!fs24.existsSync(gitDir)) return;
+  if (!fs25.existsSync(workspacePath)) return;
+  const gitDir = path20.join(workspacePath, ".git");
+  if (!fs25.existsSync(gitDir)) return;
   let actualGitDir = gitDir;
   try {
-    const stat = fs24.statSync(gitDir);
+    const stat = fs25.statSync(gitDir);
     if (stat.isFile()) {
-      const content = fs24.readFileSync(gitDir, "utf-8").trim();
+      const content = fs25.readFileSync(gitDir, "utf-8").trim();
       const match = content.match(/^gitdir:\s+(.+)$/);
       if (match) actualGitDir = match[1];
     }
   } catch {
     return;
   }
-  const lockFile = path19.join(actualGitDir, "index.lock");
-  if (fs24.existsSync(lockFile)) {
+  const lockFile = path20.join(actualGitDir, "index.lock");
+  if (fs25.existsSync(lockFile)) {
     try {
-      const result = (0, import_child_process9.execSync)(
+      const result = (0, import_child_process10.execSync)(
         `lsof "${lockFile}" 2>/dev/null || true`,
         { encoding: "utf-8", timeout: 5e3 }
       ).trim();
       if (!result) {
-        fs24.unlinkSync(lockFile);
+        fs25.unlinkSync(lockFile);
         console.log(`[pre-flight] Removed stale .git/index.lock in ${workspacePath}`);
       }
     } catch {
       try {
-        fs24.unlinkSync(lockFile);
+        fs25.unlinkSync(lockFile);
         console.log(`[pre-flight] Removed stale .git/index.lock in ${workspacePath}`);
       } catch {
       }
     }
   }
   const staleOps = [
-    { marker: path19.join(actualGitDir, "MERGE_HEAD"), abort: "git merge --abort" },
-    { marker: path19.join(actualGitDir, "rebase-merge"), abort: "git rebase --abort" },
-    { marker: path19.join(actualGitDir, "rebase-apply"), abort: "git rebase --abort" },
-    { marker: path19.join(actualGitDir, "CHERRY_PICK_HEAD"), abort: "git cherry-pick --abort" }
+    { 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" }
   ];
   for (const { marker, abort } of staleOps) {
-    if (fs24.existsSync(marker)) {
+    if (fs25.existsSync(marker)) {
       try {
-        (0, import_child_process9.execSync)(abort, { cwd: workspacePath, encoding: "utf-8", timeout: 1e4, stdio: "pipe" });
+        (0, import_child_process10.execSync)(abort, { cwd: workspacePath, encoding: "utf-8", timeout: 1e4, stdio: "pipe" });
         console.log(`[pre-flight] Aborted stale operation: ${abort} in ${workspacePath}`);
       } catch {
       }
@@ -33771,7 +33996,7 @@ function cleanGitState(workspacePath) {
 }
 function execGit(args2, cwd, timeoutMs) {
   try {
-    return (0, import_child_process9.execFileSync)("git", args2, {
+    return (0, import_child_process10.execFileSync)("git", args2, {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
@@ -33834,8 +34059,8 @@ function sanitizeForCommitMessage(msg) {
 // scripts/lib/worktree.ts
 function getWorktreePaths(workspaceDir, repoName) {
   return {
-    baseClonePath: path20.join(workspaceDir, repoName),
-    worktreeContainerDir: path20.join(workspaceDir, `${repoName}-worktrees`)
+    baseClonePath: path21.join(workspaceDir, repoName),
+    worktreeContainerDir: path21.join(workspaceDir, `${repoName}-worktrees`)
   };
 }
 function syncBaseClone(baseClonePath, defaultBranch) {
@@ -33854,16 +34079,16 @@ function ensureIdeaBranch(baseClonePath, branchName, defaultBranch) {
   }
 }
 function createWorktree(baseClonePath, worktreeContainerDir, ideaBranch, groupIndex) {
-  if (!fs25.existsSync(worktreeContainerDir)) {
-    fs25.mkdirSync(worktreeContainerDir, { recursive: true });
+  if (!fs26.existsSync(worktreeContainerDir)) {
+    fs26.mkdirSync(worktreeContainerDir, { recursive: true });
   }
   const tempBranch = `wt/${ideaBranch}-g${groupIndex}`;
-  const worktreePath = path20.join(worktreeContainerDir, `${ideaBranch}-g${groupIndex}`);
-  if (fs25.existsSync(worktreePath)) {
+  const worktreePath = path21.join(worktreeContainerDir, `${ideaBranch}-g${groupIndex}`);
+  if (fs26.existsSync(worktreePath)) {
     try {
       execGit(["worktree", "remove", "--force", worktreePath], baseClonePath, 1e4);
     } catch {
-      fs25.rmSync(worktreePath, { recursive: true, force: true });
+      fs26.rmSync(worktreePath, { recursive: true, force: true });
     }
   }
   try {
@@ -33897,7 +34122,7 @@ function removeWorktree(baseClonePath, worktreePath, tempBranch) {
     execGit(["worktree", "remove", "--force", worktreePath], baseClonePath, 1e4);
   } catch {
     try {
-      fs25.rmSync(worktreePath, { recursive: true, force: true });
+      fs26.rmSync(worktreePath, { recursive: true, force: true });
     } catch {
     }
   }
@@ -33907,12 +34132,12 @@ function removeWorktree(baseClonePath, worktreePath, tempBranch) {
   }
 }
 function cleanupIdeaWorktrees(baseClonePath, worktreeContainerDir, ideaBranch) {
-  if (fs25.existsSync(worktreeContainerDir)) {
+  if (fs26.existsSync(worktreeContainerDir)) {
     try {
-      const entries = fs25.readdirSync(worktreeContainerDir);
+      const entries = fs26.readdirSync(worktreeContainerDir);
       for (const entry of entries) {
         if (entry.startsWith(`${ideaBranch}-g`)) {
-          const wtPath = path20.join(worktreeContainerDir, entry);
+          const wtPath = path21.join(worktreeContainerDir, entry);
           const groupMatch = entry.match(/-g(\d+)$/);
           const tempBranch = `wt/${ideaBranch}-g${groupMatch?.[1] ?? "0"}`;
           removeWorktree(baseClonePath, wtPath, tempBranch);
@@ -33926,9 +34151,9 @@ function cleanupIdeaWorktrees(baseClonePath, worktreeContainerDir, ideaBranch) {
   } catch {
   }
   try {
-    const remaining = fs25.readdirSync(worktreeContainerDir);
+    const remaining = fs26.readdirSync(worktreeContainerDir);
     if (remaining.length === 0) {
-      fs25.rmdirSync(worktreeContainerDir);
+      fs26.rmdirSync(worktreeContainerDir);
     }
   } catch {
   }
@@ -33938,24 +34163,24 @@ function getTempBranchName(ideaBranch, groupIndex) {
 }
 
 // scripts/lib/telemetry.ts
-var fs26 = __toESM(require("fs"));
-var path21 = __toESM(require("path"));
-var CONFIG_DIR2 = path21.join(
+var fs27 = __toESM(require("fs"));
+var path22 = __toESM(require("path"));
+var CONFIG_DIR2 = path22.join(
   process.env.HOME || process.env.USERPROFILE || "~",
   ".vibebusiness"
 );
-var TELEMETRY_CONFIG_FILE = path21.join(CONFIG_DIR2, "telemetry.json");
-var EVENTS_FILE = path21.join(CONFIG_DIR2, "events.jsonl");
+var TELEMETRY_CONFIG_FILE = path22.join(CONFIG_DIR2, "telemetry.json");
+var EVENTS_FILE = path22.join(CONFIG_DIR2, "events.jsonl");
 function getVersion() {
   try {
     let dir = __dirname;
     for (let i = 0; i < 4; i++) {
-      const pkgPath = path21.join(dir, "package.json");
-      if (fs26.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs26.readFileSync(pkgPath, "utf-8"));
+      const pkgPath = path22.join(dir, "package.json");
+      if (fs27.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs27.readFileSync(pkgPath, "utf-8"));
         return pkg.version || "0.0.0";
       }
-      dir = path21.dirname(dir);
+      dir = path22.dirname(dir);
     }
   } catch {
   }
@@ -33963,8 +34188,8 @@ function getVersion() {
 }
 function getTelemetryConfig() {
   try {
-    if (!fs26.existsSync(TELEMETRY_CONFIG_FILE)) return null;
-    return JSON.parse(fs26.readFileSync(TELEMETRY_CONFIG_FILE, "utf-8"));
+    if (!fs27.existsSync(TELEMETRY_CONFIG_FILE)) return null;
+    return JSON.parse(fs27.readFileSync(TELEMETRY_CONFIG_FILE, "utf-8"));
   } catch {
     return null;
   }
@@ -33985,8 +34210,8 @@ function trackEvent(event, properties = {}) {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       version: getVersion()
     };
-    fs26.mkdirSync(CONFIG_DIR2, { recursive: true });
-    fs26.appendFileSync(EVENTS_FILE, JSON.stringify(entry) + "\n");
+    fs27.mkdirSync(CONFIG_DIR2, { recursive: true });
+    fs27.appendFileSync(EVENTS_FILE, JSON.stringify(entry) + "\n");
   } catch {
   }
 }
@@ -34217,22 +34442,22 @@ async function suggestEpics(opts) {
 }
 
 // scripts/lib/scaffold.ts
-var fs28 = __toESM(require("fs"));
-var path23 = __toESM(require("path"));
+var fs29 = __toESM(require("fs"));
+var path24 = __toESM(require("path"));
 function scaffoldSlashCommands(rootDir) {
-  let templatesDir = path23.join(__dirname, "..", "..", "templates", "commands");
-  if (!fs28.existsSync(templatesDir)) {
-    templatesDir = path23.join(__dirname, "..", "..", "..", "templates", "commands");
-  }
-  if (!fs28.existsSync(templatesDir)) return;
-  const targetDir = path23.join(rootDir, ".claude", "commands");
-  fs28.mkdirSync(targetDir, { recursive: true });
-  const templates = fs28.readdirSync(templatesDir).filter((f) => f.endsWith(".md"));
+  let templatesDir = path24.join(__dirname, "..", "..", "templates", "commands");
+  if (!fs29.existsSync(templatesDir)) {
+    templatesDir = path24.join(__dirname, "..", "..", "..", "templates", "commands");
+  }
+  if (!fs29.existsSync(templatesDir)) return;
+  const targetDir = path24.join(rootDir, ".claude", "commands");
+  fs29.mkdirSync(targetDir, { recursive: true });
+  const templates = fs29.readdirSync(templatesDir).filter((f) => f.endsWith(".md"));
   let copied = 0;
   for (const file of templates) {
-    const src = path23.join(templatesDir, file);
-    const dest = path23.join(targetDir, file);
-    fs28.copyFileSync(src, dest);
+    const src = path24.join(templatesDir, file);
+    const dest = path24.join(targetDir, file);
+    fs29.copyFileSync(src, dest);
     copied++;
   }
   if (copied > 0) {
@@ -34241,23 +34466,23 @@ function scaffoldSlashCommands(rootDir) {
 }
 
 // scripts/lib/vibe-credits.ts
-var fs29 = __toESM(require("fs"));
-var path24 = __toESM(require("path"));
+var fs30 = __toESM(require("fs"));
+var path25 = __toESM(require("path"));
 var WORKER_URL = "https://vibe-credits.luis-e13.workers.dev";
-var CONFIG_DIR3 = path24.join(process.env.HOME || "", ".vibebusiness");
-var BUFFER_FILE = path24.join(CONFIG_DIR3, "vibe-buffer.json");
+var CONFIG_DIR3 = path25.join(process.env.HOME || "", ".vibebusiness");
+var BUFFER_FILE = path25.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 = path24.join(dir, "package.json");
-      if (fs29.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs29.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 = path24.dirname(dir);
+      dir = path25.dirname(dir);
     }
   } catch {
   }
@@ -34266,18 +34491,18 @@ function getClientVersion() {
 var CLIENT_VERSION = getClientVersion();
 function loadBuffer() {
   try {
-    if (fs29.existsSync(BUFFER_FILE)) {
-      return JSON.parse(fs29.readFileSync(BUFFER_FILE, "utf-8"));
+    if (fs30.existsSync(BUFFER_FILE)) {
+      return JSON.parse(fs30.readFileSync(BUFFER_FILE, "utf-8"));
     }
   } catch {
   }
   return { vibes: 0, last_synced: "" };
 }
 function saveBuffer(buffer) {
-  if (!fs29.existsSync(CONFIG_DIR3)) {
-    fs29.mkdirSync(CONFIG_DIR3, { recursive: true });
+  if (!fs30.existsSync(CONFIG_DIR3)) {
+    fs30.mkdirSync(CONFIG_DIR3, { recursive: true });
   }
-  fs29.writeFileSync(BUFFER_FILE, JSON.stringify(buffer, null, 2));
+  fs30.writeFileSync(BUFFER_FILE, JSON.stringify(buffer, null, 2));
 }
 function syncBuffer(vibesRemaining) {
   const buffered = Math.min(vibesRemaining, MAX_BUFFER);
@@ -34351,14 +34576,14 @@ async function consumeVibe(instanceId) {
 }
 
 // scripts/lib/license.ts
-var fs30 = __toESM(require("fs"));
-var path25 = __toESM(require("path"));
-var CONFIG_DIR4 = path25.join(process.env.HOME || "", ".vibebusiness");
-var LICENSE_FILE = path25.join(CONFIG_DIR4, "license.json");
+var fs31 = __toESM(require("fs"));
+var path26 = __toESM(require("path"));
+var CONFIG_DIR4 = path26.join(process.env.HOME || "", ".vibebusiness");
+var LICENSE_FILE = path26.join(CONFIG_DIR4, "license.json");
 function loadStoredLicense() {
   try {
-    if (fs30.existsSync(LICENSE_FILE)) {
-      return JSON.parse(fs30.readFileSync(LICENSE_FILE, "utf-8"));
+    if (fs31.existsSync(LICENSE_FILE)) {
+      return JSON.parse(fs31.readFileSync(LICENSE_FILE, "utf-8"));
     }
   } catch {
   }
@@ -34379,11 +34604,11 @@ function getInstanceId() {
 // scripts/heartbeat.ts
 init_paths();
 var ROOT_DIR = PROJECT_DIR;
-var execAsync = (0, import_util.promisify)(import_child_process10.exec);
+var execAsync = (0, import_util.promisify)(import_child_process11.exec);
 var DEFAULT_MAX_DECOMP_ATTEMPTS = 2;
 function spawnAsync(cmd, args2, options) {
-  return new Promise((resolve2, reject) => {
-    const child = (0, import_child_process10.spawn)(cmd, args2, {
+  return new Promise((resolve3, reject) => {
+    const child = (0, import_child_process11.spawn)(cmd, args2, {
       cwd: options.cwd,
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -34429,7 +34654,7 @@ function spawnAsync(cmd, args2, options) {
         reject(err2);
         return;
       }
-      resolve2({ stdout, stderr });
+      resolve3({ stdout, stderr });
     });
   });
 }
@@ -34485,11 +34710,11 @@ function log(message) {
   }
 }
 function sleep(ms2) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms2));
+  return new Promise((resolve3) => setTimeout(resolve3, ms2));
 }
 function loadJson(filePath, defaultValue) {
   try {
-    const content = fs32.readFileSync(filePath, "utf-8");
+    const content = fs33.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return defaultValue;
@@ -34544,7 +34769,7 @@ function isMetaTaskFalseCompletion(output) {
 }
 function reclassifyAsHumanDependent(taskId) {
   try {
-    let content = fs32.readFileSync(TODO_FILE, "utf-8");
+    let content = fs33.readFileSync(TODO_FILE, "utf-8");
     const taskPattern = new RegExp(`^- \\[[ x]\\] \`${taskId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\`.*$`, "m");
     const match = content.match(taskPattern);
     if (!match) return;
@@ -34557,7 +34782,7 @@ function reclassifyAsHumanDependent(taskId) {
       const insertIndex = content.indexOf("\n", blockedIndex) + 1;
       content = content.slice(0, insertIndex) + "\n" + uncheckedLine + content.slice(insertIndex);
     }
-    fs32.writeFileSync(TODO_FILE, content);
+    fs33.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"}`);
@@ -34565,7 +34790,7 @@ function reclassifyAsHumanDependent(taskId) {
 }
 function getMetaTaskFailureCount(taskId) {
   try {
-    const content = fs32.readFileSync(TODO_FILE, "utf-8");
+    const content = fs33.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;
@@ -34575,7 +34800,7 @@ function getMetaTaskFailureCount(taskId) {
 }
 function incrementMetaTaskFailureCount(taskId) {
   try {
-    let content = fs32.readFileSync(TODO_FILE, "utf-8");
+    let content = fs33.readFileSync(TODO_FILE, "utf-8");
     const escapedId = taskId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const linePattern = new RegExp(`^(- \\[[ x]\\] \`${escapedId}\`.*)$`, "m");
     const lineMatch = content.match(linePattern);
@@ -34591,7 +34816,7 @@ function incrementMetaTaskFailureCount(taskId) {
       newLine = `${line} [failed:${newCount}]`;
     }
     content = content.replace(line, newLine);
-    fs32.writeFileSync(TODO_FILE, content);
+    fs33.writeFileSync(TODO_FILE, content);
     log(`Meta-task ${taskId} failure count: ${newCount}`);
     return newCount;
   } catch (error) {
@@ -34601,7 +34826,7 @@ function incrementMetaTaskFailureCount(taskId) {
 }
 function parseTodoFile() {
   try {
-    const content = fs32.readFileSync(TODO_FILE, "utf-8");
+    const content = fs33.readFileSync(TODO_FILE, "utf-8");
     const tasks = [];
     let currentSection = "high_priority";
     const lines = content.split("\n");
@@ -34751,10 +34976,10 @@ function captureGitDiffInfo(workspacePath) {
     has_uncommitted_changes: false
   };
   try {
-    const status = (0, import_child_process10.execSync)("git status --porcelain", { cwd: workspacePath, encoding: "utf-8" });
+    const status = (0, import_child_process11.execSync)("git status --porcelain", { cwd: workspacePath, encoding: "utf-8" });
     result.has_uncommitted_changes = status.trim().length > 0;
     try {
-      const diffStat = (0, import_child_process10.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_process11.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"
@@ -35022,18 +35247,18 @@ function autoRecoverDeferredParseFailures() {
 async function generateMissingShipCards(ideas) {
   const shippedIdeas = ideas.filter((i) => i.stage === "shipped");
   if (shippedIdeas.length === 0) return;
-  const assetsDir = path27.join(__dirname, "assets");
-  const hasRegular = fs32.existsSync(path27.join(assetsDir, "Inter-Regular.ttf"));
-  const hasBold = fs32.existsSync(path27.join(assetsDir, "Inter-Bold.ttf"));
+  const assetsDir = path28.join(__dirname, "assets");
+  const hasRegular = fs33.existsSync(path28.join(assetsDir, "Inter-Regular.ttf"));
+  const hasBold = fs33.existsSync(path28.join(assetsDir, "Inter-Bold.ttf"));
   if (!hasRegular && !hasBold) return;
-  const visualsDir = path27.join(DATA_DIR, "reports", "visuals");
+  const visualsDir = path28.join(DATA_DIR, "reports", "visuals");
   let generated = 0;
   for (const idea of shippedIdeas) {
-    const cardPath = path27.join(visualsDir, `${idea.id}-card.png`);
-    if (fs32.existsSync(cardPath)) continue;
+    const cardPath = path28.join(visualsDir, `${idea.id}-card.png`);
+    if (fs33.existsSync(cardPath)) continue;
     if (idea.implementation?.preview_url) {
-      const screenshotPath = path27.join(DATA_DIR, "reports", `${idea.id}-screenshot.png`);
-      if (!fs32.existsSync(screenshotPath)) {
+      const screenshotPath = path28.join(DATA_DIR, "reports", `${idea.id}-screenshot.png`);
+      if (!fs33.existsSync(screenshotPath)) {
         try {
           const { captureIdeaScreenshot: captureIdeaScreenshot2 } = await Promise.resolve().then(() => (init_screenshot(), screenshot_exports));
           await captureIdeaScreenshot2(idea.id, idea.implementation.preview_url);
@@ -35127,11 +35352,18 @@ function updateGoalsWithKPIs(kpis) {
   saveJson(GOALS_FILE, goalsData);
   log("Updated goals.json with live KPIs");
 }
+function detectMarketingTriggersIfNeeded(goals) {
+  const hasBehindGoals = goals.some((g2) => g2.status === "behind");
+  if (!hasBehindGoals) {
+    return [];
+  }
+  return detectMarketingTriggers(goals);
+}
 function loadCodebaseSnapshot() {
-  const snapshotPath = path27.join(DATA_DIR, "codebase-snapshot.json");
+  const snapshotPath = path28.join(DATA_DIR, "codebase-snapshot.json");
   try {
-    if (fs32.existsSync(snapshotPath)) {
-      return JSON.parse(fs32.readFileSync(snapshotPath, "utf-8"));
+    if (fs33.existsSync(snapshotPath)) {
+      return JSON.parse(fs33.readFileSync(snapshotPath, "utf-8"));
     }
   } catch {
   }
@@ -35686,9 +35918,9 @@ Focus on actionable, specific recommendations. Be concise.`;
 }
 function addTasksToTodo(tasks) {
   if (tasks.length === 0) return;
-  if (!fs32.existsSync(TODO_FILE)) return;
+  if (!fs33.existsSync(TODO_FILE)) return;
   try {
-    let content = fs32.readFileSync(TODO_FILE, "utf-8");
+    let content = fs33.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");
@@ -35788,15 +36020,15 @@ function addTasksToTodo(tasks) {
       }
       log(`Added TODO: ${task.id} \u2014 ${task.description}`);
     }
-    fs32.writeFileSync(TODO_FILE, content);
+    fs33.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 (!fs32.existsSync(TODO_FILE)) return;
-    let content = fs32.readFileSync(TODO_FILE, "utf-8");
+    if (!fs33.existsSync(TODO_FILE)) return;
+    let content = fs33.readFileSync(TODO_FILE, "utf-8");
     const lines = content.split("\n");
     const completedLines = [];
     const newLines = [];
@@ -35822,7 +36054,7 @@ function archiveCompletedTodos() {
       const archiveBlock = completedLines.join("\n") + "\n";
       content = content.slice(0, insertIndex) + archiveBlock + content.slice(insertIndex);
     }
-    fs32.writeFileSync(TODO_FILE, content);
+    fs33.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"}`);
@@ -35830,8 +36062,8 @@ function archiveCompletedTodos() {
 }
 function pruneStaleScheduledTodos(state) {
   try {
-    if (!fs32.existsSync(TODO_FILE)) return;
-    const content = fs32.readFileSync(TODO_FILE, "utf-8");
+    if (!fs33.existsSync(TODO_FILE)) return;
+    const content = fs33.readFileSync(TODO_FILE, "utf-8");
     const lines = content.split("\n");
     const prunedIds = [];
     const terminalIdeaIds = new Set(
@@ -35867,7 +36099,7 @@ function pruneStaleScheduledTodos(state) {
       return true;
     });
     if (prunedIds.length === 0) return;
-    fs32.writeFileSync(TODO_FILE, newLines.join("\n"));
+    fs33.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"}`);
@@ -35875,8 +36107,8 @@ function pruneStaleScheduledTodos(state) {
 }
 function deduplicateActiveTodos() {
   try {
-    if (!fs32.existsSync(TODO_FILE)) return;
-    const content = fs32.readFileSync(TODO_FILE, "utf-8");
+    if (!fs33.existsSync(TODO_FILE)) return;
+    const content = fs33.readFileSync(TODO_FILE, "utf-8");
     const lines = content.split("\n");
     const removedIds = [];
     let currentSection = "";
@@ -35913,7 +36145,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");
-    fs32.writeFileSync(TODO_FILE, cleaned);
+    fs33.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"}`);
@@ -35921,8 +36153,8 @@ function deduplicateActiveTodos() {
 }
 function readMemoryContext() {
   try {
-    if (!fs32.existsSync(MEMORY_FILE)) return "";
-    const content = fs32.readFileSync(MEMORY_FILE, "utf-8");
+    if (!fs33.existsSync(MEMORY_FILE)) return "";
+    const content = fs33.readFileSync(MEMORY_FILE, "utf-8");
     const MAX_TOTAL_LINES = 100;
     const MIN_LEARNING_ENTRIES = 15;
     const learningsSplit = content.indexOf("### Heartbeat Learnings");
@@ -35943,14 +36175,14 @@ function readMemoryContext() {
 }
 function appendToMemory(learnings) {
   if (learnings.length === 0) return;
-  if (!fs32.existsSync(MEMORY_FILE)) return;
+  if (!fs33.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 = fs32.readFileSync(MEMORY_FILE, "utf-8");
+    let content = fs33.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) => {
@@ -36000,7 +36232,7 @@ function appendToMemory(learnings) {
         const subsectionEnd = subsectionEndMatch ? subsectionIndex + 22 + (subsectionEndMatch.index || 0) : insertPoint;
         content = content.slice(0, subsectionEnd) + newEntries + "\n" + content.slice(subsectionEnd);
       }
-      fs32.writeFileSync(MEMORY_FILE, content);
+      fs33.writeFileSync(MEMORY_FILE, content);
       log(`Added ${filtered.length} learning(s) to MEMORY.md`);
     }
   } catch (error) {
@@ -36009,8 +36241,8 @@ function appendToMemory(learnings) {
 }
 function pruneMemoryLearnings() {
   try {
-    if (!fs32.existsSync(MEMORY_FILE)) return;
-    const content = fs32.readFileSync(MEMORY_FILE, "utf-8");
+    if (!fs33.existsSync(MEMORY_FILE)) return;
+    const content = fs33.readFileSync(MEMORY_FILE, "utf-8");
     const learningsHeader = "### Heartbeat Learnings";
     const learningsIdx = content.indexOf(learningsHeader);
     if (learningsIdx === -1) return;
@@ -36046,7 +36278,7 @@ function pruneMemoryLearnings() {
     if (prunedCount === 0) return;
     const newLearningsBody = headerLine + "\n\n" + finalEntries.join("\n") + "\n";
     const newContent = beforeLearnings + newLearningsBody + afterLearnings;
-    fs32.writeFileSync(MEMORY_FILE, newContent);
+    fs33.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"}`);
@@ -36165,7 +36397,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(path27.basename(repo.path))) {
+      if (file.includes(repo.name) || file.includes(path28.basename(repo.path))) {
         return repo;
       }
     }
@@ -36458,17 +36690,17 @@ function runTestsForRepo(workspacePath, testCommands, sourceRepoPath) {
   const allOutput = [];
   const env = { ...process.env };
   if (sourceRepoPath) {
-    const venvBin = path27.join(sourceRepoPath, ".venv", "bin");
-    if (fs32.existsSync(venvBin)) {
+    const venvBin = path28.join(sourceRepoPath, ".venv", "bin");
+    if (fs33.existsSync(venvBin)) {
       env.PATH = `${venvBin}:${env.PATH}`;
-      env.VIRTUAL_ENV = path27.join(sourceRepoPath, ".venv");
+      env.VIRTUAL_ENV = path28.join(sourceRepoPath, ".venv");
       log(`Using venv from ${sourceRepoPath}/.venv`);
     }
   }
   for (const cmd of testCommands) {
     log(`Running test: ${cmd}`);
     try {
-      const result = (0, import_child_process10.execSync)(cmd, {
+      const result = (0, import_child_process11.execSync)(cmd, {
         cwd: workspacePath,
         encoding: "utf-8",
         env,
@@ -36514,7 +36746,7 @@ async function executeSingleSubTask(subTask, ideaId, idea, ideasData, autonomy,
   });
   const scopeBase64 = Buffer.from(scopePayload).toString("base64");
   const timeoutMs = autonomy.max_sub_task_timeout_ms || 3e5;
-  const workspacePath = options?.worktreePath || path27.join(config.workspace_dir, targetRepo.name);
+  const workspacePath = options?.worktreePath || path28.join(config.workspace_dir, targetRepo.name);
   const executionStartTime = Date.now();
   const updateSubTaskWithDetails = (status, updateOpts = {}) => {
     const endTime = Date.now();
@@ -36592,7 +36824,7 @@ async function executeSingleSubTask(subTask, ideaId, idea, ideasData, autonomy,
     }
     let commitHash = null;
     try {
-      commitHash = (0, import_child_process10.execSync)("git rev-parse HEAD", { cwd: workspacePath, encoding: "utf-8" }).trim();
+      commitHash = (0, import_child_process11.execSync)("git rev-parse HEAD", { cwd: workspacePath, encoding: "utf-8" }).trim();
     } catch {
     }
     updateSubTaskWithDetails("completed", {
@@ -36636,7 +36868,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_process10.spawnSync)("claude", ["--print", "--model", "sonnet", "-p", errorContext], {
+    const spawnResult = (0, import_child_process11.spawnSync)("claude", ["--print", "--model", "sonnet", "-p", errorContext], {
       cwd: ROOT_DIR,
       encoding: "utf-8",
       timeout: 6e4,
@@ -36748,7 +36980,7 @@ async function executeAutonomousImplementation(ideaId) {
     }
     try {
       const { command, args: args2 } = resolveScript(__dirname, "implement.ts");
-      (0, import_child_process10.execSync)(
+      (0, import_child_process11.execSync)(
         [command, ...args2, `--idea=${ideaId}`, `--repo=${targetRepo2.name}`, "--create-pr-only"].join(" "),
         { cwd: ROOT_DIR, encoding: "utf-8", stdio: "inherit", timeout: 12e4 }
       );
@@ -36756,16 +36988,16 @@ async function executeAutonomousImplementation(ideaId) {
       if (autonomy.auto_merge) {
         const branchName2 = idea.implementation.branch_name;
         const defaultBranch2 = targetRepo2.default_branch || "main";
-        const workspacePath = path27.join(config.workspace_dir, targetRepo2.name);
+        const workspacePath = path28.join(config.workspace_dir, targetRepo2.name);
         if (branchName2) {
           try {
             log(`Auto-merging branch ${branchName2} into ${defaultBranch2}...`);
-            (0, import_child_process10.execFileSync)("git", ["checkout", validateBranchName(defaultBranch2)], { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
-            (0, import_child_process10.execFileSync)("git", ["merge", validateBranchName(branchName2), "--squash", "--no-edit"], { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
-            (0, import_child_process10.execFileSync)("git", ["commit", "-m", `feat: ${sanitizeForCommitMessage(idea.title)} (auto-merged from ${validateBranchName(branchName2)})`], { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
+            (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" });
             log(`Successfully merged ${branchName2} into ${defaultBranch2}`);
             try {
-              (0, import_child_process10.execFileSync)("git", ["branch", "-d", validateBranchName(branchName2)], { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
+              (0, import_child_process11.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)`);
@@ -36790,8 +37022,8 @@ async function executeAutonomousImplementation(ideaId) {
           } catch (mergeError) {
             log(`Auto-merge failed (likely conflicts): ${mergeError instanceof Error ? mergeError.message : "Unknown"}`);
             try {
-              (0, import_child_process10.execFileSync)("git", ["merge", "--abort"], { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
-              (0, import_child_process10.execFileSync)("git", ["checkout", validateBranchName(branchName2)], { cwd: workspacePath, encoding: "utf-8", stdio: "pipe" });
+              (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" });
             } catch {
             }
             log(`Left idea ${ideaId} in testing stage for manual merge`);
@@ -36847,7 +37079,7 @@ async function executeAutonomousImplementation(ideaId) {
         if (targetRepo2) {
           try {
             const { command, args: args2 } = resolveScript(__dirname, "implement.ts");
-            (0, import_child_process10.execSync)(
+            (0, import_child_process11.execSync)(
               [command, ...args2, `--idea=${ideaId}`, `--repo=${targetRepo2.name}`, "--create-pr-only"].join(" "),
               { cwd: ROOT_DIR, encoding: "utf-8", stdio: "inherit", timeout: 12e4 }
             );
@@ -37065,8 +37297,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((resolve2) => {
-    const claude = (0, import_child_process10.spawn)("claude", [
+  return new Promise((resolve3) => {
+    const claude = (0, import_child_process11.spawn)("claude", [
       "--print",
       "--dangerously-skip-permissions",
       "--model",
@@ -37094,7 +37326,7 @@ ${allowedFiles.map((f) => `- ${f}`).join("\n")}
           } catch {
           }
         }, 5e3);
-        resolve2(false);
+        resolve3(false);
       }
     }, timeoutMs);
     claude.stdout.on("data", (data) => {
@@ -37112,14 +37344,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);
-          resolve2(false);
+          resolve3(false);
           return;
         }
         log(`Meta-task completed: ${output.substring(0, 200)}`);
-        resolve2(true);
+        resolve3(true);
       } else {
         log(`Meta-task failed (exit ${code})`);
-        resolve2(false);
+        resolve3(false);
       }
     });
     claude.on("error", (err2) => {
@@ -37127,7 +37359,7 @@ ${allowedFiles.map((f) => `- ${f}`).join("\n")}
       isResolved = true;
       clearTimeout(timeout);
       log(`Meta-task error: ${err2.message}`);
-      resolve2(false);
+      resolve3(false);
     });
   });
 }
@@ -37149,9 +37381,9 @@ ${kpiLines}`;
     goals: goalsContext
   });
   const contextBase64 = Buffer.from(contextPayload).toString("base64");
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const { command: analyzeCmd, args: analyzeArgs } = resolveScript(__dirname, "analyze.ts");
-    const childProcess = (0, import_child_process10.spawn)(analyzeCmd, [
+    const childProcess = (0, import_child_process11.spawn)(analyzeCmd, [
       ...analyzeArgs,
       `--type=research`,
       `--topic=${topic}`,
@@ -37163,22 +37395,22 @@ ${kpiLines}`;
     const timeout = setTimeout(() => {
       childProcess.kill("SIGTERM");
       log("Research task timed out after 15 minutes");
-      resolve2(false);
+      resolve3(false);
     }, 9e5);
     childProcess.on("close", (code) => {
       clearTimeout(timeout);
       if (code === 0) {
         log("Research task completed successfully");
-        resolve2(true);
+        resolve3(true);
       } else {
         log(`Research task failed with code ${code}`);
-        resolve2(false);
+        resolve3(false);
       }
     });
     childProcess.on("error", (error) => {
       clearTimeout(timeout);
       log(`Research task error: ${error.message}`);
-      resolve2(false);
+      resolve3(false);
     });
   });
 }
@@ -37318,10 +37550,10 @@ async function executeGoalGapResearch(goalId) {
   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((resolve2) => {
+  return new Promise((resolve3) => {
     const TIMEOUT_MS = 9e5;
     const startTime = Date.now();
-    const claude = (0, import_child_process10.spawn)("claude", [
+    const claude = (0, import_child_process11.spawn)("claude", [
       "--print",
       "--dangerously-skip-permissions"
     ], {
@@ -37345,7 +37577,7 @@ async function executeGoalGapResearch(goalId) {
         clearInterval(progressInterval);
         claude.kill("SIGTERM");
         log("Goal-gap research timed out after 15 minutes");
-        resolve2(false);
+        resolve3(false);
       }
     }, TIMEOUT_MS);
     claude.stdout.on("data", (data) => {
@@ -37365,7 +37597,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`);
-        resolve2(false);
+        resolve3(false);
         return;
       }
       log(`Goal-gap research completed in ${elapsed}s, parsing ideas...`);
@@ -37373,7 +37605,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");
-        resolve2(false);
+        resolve3(false);
         return;
       }
       try {
@@ -37415,7 +37647,7 @@ async function executeGoalGapResearch(goalId) {
         }));
         if (newIdeas.length === 0) {
           log("No ideas parsed from goal-gap research");
-          resolve2(false);
+          resolve3(false);
           return;
         }
         const freshIdeasData = loadJson(IDEAS_FILE, { ideas: [] });
@@ -37432,10 +37664,10 @@ async function executeGoalGapResearch(goalId) {
         newIdeas.forEach((idea, i) => {
           log(`  ${i + 1}. ${idea.title}`);
         });
-        resolve2(true);
+        resolve3(true);
       } catch (error) {
         log(`Failed to parse goal-gap research ideas: ${error instanceof Error ? error.message : "Unknown"}`);
-        resolve2(false);
+        resolve3(false);
       }
     });
     claude.on("error", (error) => {
@@ -37444,7 +37676,7 @@ async function executeGoalGapResearch(goalId) {
         clearInterval(progressInterval);
         clearTimeout(timeout);
         log(`Goal-gap research error: ${error.message}`);
-        resolve2(false);
+        resolve3(false);
       }
     });
   });
@@ -37944,8 +38176,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((resolve2) => {
-    const claude = (0, import_child_process10.spawn)("claude", ["--print", "--dangerously-skip-permissions"], {
+  return new Promise((resolve3) => {
+    const claude = (0, import_child_process11.spawn)("claude", ["--print", "--dangerously-skip-permissions"], {
       cwd: ROOT_DIR,
       env: process.env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -37960,7 +38192,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}`);
-      resolve2(task);
+      resolve3(task);
     }, TIMEOUT_MS);
     claude.stdout.on("data", (data) => {
       output += data.toString();
@@ -37989,7 +38221,7 @@ async function executeSingleResearchTask(task) {
         task.error_message = errorOutput || `Exited with code ${code}`;
         log(`  Research task failed: ${task.type} - ${task.error_message}`);
       }
-      resolve2(task);
+      resolve3(task);
     });
     claude.on("error", (error) => {
       clearTimeout(timeout);
@@ -37997,7 +38229,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}`);
-      resolve2(task);
+      resolve3(task);
     });
   });
 }
@@ -38317,17 +38549,17 @@ async function executeReviewInbox() {
   log("Inbox review complete (manual prioritization needed)");
 }
 async function runAnalysis(type) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     log(`Running ${type} analysis...`);
     const { command: runCmd, args: runArgs } = resolveScript(__dirname, "analyze.ts");
-    const childProcess = (0, import_child_process10.spawn)(runCmd, [...runArgs, `--type=${type}`], {
+    const childProcess = (0, import_child_process11.spawn)(runCmd, [...runArgs, `--type=${type}`], {
       cwd: ROOT_DIR,
       stdio: "inherit"
     });
     childProcess.on("close", (code) => {
       if (code === 0) {
         log(`${type} analysis completed successfully`);
-        resolve2();
+        resolve3();
       } else {
         reject(new Error(`Analysis exited with code ${code}`));
       }
@@ -38339,7 +38571,7 @@ async function runAnalysis(type) {
 }
 function updateTodoFile(taskId, completed) {
   try {
-    let content = fs32.readFileSync(TODO_FILE, "utf-8");
+    let content = fs33.readFileSync(TODO_FILE, "utf-8");
     const uncheckedPattern = new RegExp(`- \\[ \\] \`${taskId}\``, "g");
     const checkedPattern = new RegExp(`- \\[x\\] \`${taskId}\``, "g");
     if (completed) {
@@ -38347,7 +38579,7 @@ function updateTodoFile(taskId, completed) {
     } else {
       content = content.replace(checkedPattern, `- [ ] \`${taskId}\``);
     }
-    fs32.writeFileSync(TODO_FILE, content);
+    fs33.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"}`);
@@ -38466,8 +38698,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 = path27.join(PROJECT_DIR, ".claude", "commands");
-    if (!fs32.existsSync(commandsDir)) {
+    const commandsDir = path28.join(PROJECT_DIR, ".claude", "commands");
+    if (!fs33.existsSync(commandsDir)) {
       log("Slash commands missing \u2014 auto-scaffolding...");
       scaffoldSlashCommands(PROJECT_DIR);
     }
@@ -38520,6 +38752,14 @@ async function runSingleHeartbeat(beatNumber = 1) {
       updateBusinessContext(businessContext, liveKPIs);
       log("Updated business context with live KPIs");
     }
+    const marketingTriggers = detectMarketingTriggersIfNeeded(state.goals);
+    if (marketingTriggers.length > 0) {
+      log(`Detected ${marketingTriggers.length} marketing trigger(s):`);
+      marketingTriggers.forEach((t) => {
+        log(`  - [${t.severity.toUpperCase()}] ${t.description}`);
+        alerts.push(`MARKETING: ${t.description}`);
+      });
+    }
     if (!DRY_RUN) {
       await generateMissingShipCards(state.ideas);
     }
@@ -38669,7 +38909,7 @@ async function runSingleHeartbeat(beatNumber = 1) {
     }
     if (!DRY_RUN) {
       const statusContent = generateStatusContent(state, alerts, taskToDo, reasoning, systemHealth);
-      fs32.writeFileSync(STATUS_FILE, statusContent);
+      fs33.writeFileSync(STATUS_FILE, statusContent);
       log("Updated STATUS.md");
     } else {
       log("[DRY RUN] Would update STATUS.md");
@@ -38784,7 +39024,7 @@ ${"=".repeat(60)}
 `);
 }
 function saveSessionToJson(summary) {
-  const sessionsFile = path27.join(DATA_DIR, "heartbeat-sessions.json");
+  const sessionsFile = path28.join(DATA_DIR, "heartbeat-sessions.json");
   const sessionsData = loadJson(sessionsFile, { sessions: [] });
   sessionsData.sessions.push(summary);
   if (sessionsData.sessions.length > 50) {