vibebusiness 1.2.11

package/dist/scripts/heartbeat.js

@@ -0,0 +1,3562 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// scripts/heartbeat.ts
+var fs6 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
+var import_child_process3 = require("child_process");
+
+// scripts/lib/api.ts
+var API_URL = process.env.NEXT_PUBLIC_API_URL || "http://localhost:8001";
+var INTERNAL_API_KEY = process.env.INTERNAL_API_KEY;
+async function apiRequest(endpoint, options = {}) {
+  const url = `${API_URL}${endpoint}`;
+  const headers = {
+    "Content-Type": "application/json",
+    ...options.headers
+  };
+  if (INTERNAL_API_KEY) {
+    headers["X-Internal-API-Key"] = INTERNAL_API_KEY;
+  }
+  const response = await fetch(url, {
+    ...options,
+    headers
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`API request failed: ${response.status} ${response.statusText} - ${errorText}`);
+  }
+  return response.json();
+}
+async function fetchLawyerSuccessKPIs(startDate, endDate) {
+  const params = new URLSearchParams();
+  if (startDate) {
+    params.append("start_date", startDate.toISOString());
+  }
+  if (endDate) {
+    params.append("end_date", endDate.toISOString());
+  }
+  const queryString = params.toString();
+  const endpoint = `/api/v1/analytics/internal/lawyer-success-kpis${queryString ? `?${queryString}` : ""}`;
+  return apiRequest(endpoint);
+}
+async function checkBackendHealth() {
+  try {
+    const response = await fetch(`${API_URL}/health`, { method: "GET" });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function hasInternalApiKey() {
+  return !!INTERNAL_API_KEY;
+}
+
+// src/lib/prompts.ts
+function buildBaseContext(businessConfig) {
+  if (!businessConfig) {
+    return `You are an AI Business Analyst.
+
+Your role is to analyze the codebase and generate actionable improvement ideas.`;
+  }
+  const { product } = businessConfig;
+  let architectureSection = "";
+  if (product.architecture && product.architecture.length > 0) {
+    const components = product.architecture.map((c, i) => {
+      const techLine = c.tech_stack.length > 0 ? `
+   Tech: ${c.tech_stack.join(", ")}` : "";
+      return `${i + 1}. **${c.name} (${c.repo_name})**: ${c.description}${techLine}`;
+    }).join("\n\n");
+    architectureSection = `
+
+The product consists of:
+${components}`;
+  }
+  return `You are an AI Business Analyst for ${product.name}, ${product.summary}.${architectureSection}
+
+Your role is to analyze the codebase and generate actionable improvement ideas.`;
+}
+
+// scripts/skills/content-marketing.ts
+var import_child_process = require("child_process");
+var fs = __toESM(require("fs"));
+var CONTENT_TASK_PREFIX = "content-";
+function isContentTask(taskId) {
+  return taskId.startsWith(CONTENT_TASK_PREFIX);
+}
+function extractActionKey(taskId) {
+  const withoutPrefix = taskId.replace(CONTENT_TASK_PREFIX, "");
+  const knownActions = [
+    "discover-keywords",
+    "track-rankings",
+    "analyze-gaps",
+    "generate-blog",
+    "generate-carousels",
+    "generate-nurture"
+  ];
+  for (const action of knownActions) {
+    if (withoutPrefix.startsWith(action)) {
+      return action;
+    }
+  }
+  return null;
+}
+function extractParams(description) {
+  const params = {};
+  const patterns = [
+    /seed[=: ]*"([^"]+)"/i,
+    /term[=: ]*"([^"]+)"/i,
+    /category[=: ]*"([^"]+)"/i,
+    /topic[=: ]*"([^"]+)"/i,
+    /keyword[=: ]*"([^"]+)"/i
+  ];
+  for (const pattern of patterns) {
+    const match = description.match(pattern);
+    if (match) {
+      if (pattern.source.startsWith("seed")) params.seed = match[1];
+      else if (pattern.source.startsWith("term")) params.term = match[1];
+      else if (pattern.source.startsWith("category")) params.category = match[1];
+      else if (pattern.source.startsWith("topic")) params.topic = match[1];
+      else if (pattern.source.startsWith("keyword")) params.seed = match[1];
+    }
+  }
+  return params;
+}
+async function executeContentTask(taskId, description, contentflowConfig) {
+  const actionKey = extractActionKey(taskId);
+  if (!actionKey) {
+    return {
+      success: false,
+      output: `Unknown content action in task: ${taskId}`
+    };
+  }
+  const repoPath = contentflowConfig?.repo_path;
+  if (!repoPath || !fs.existsSync(repoPath)) {
+    return {
+      success: false,
+      output: `ContentFlow repo not found at: ${repoPath || "(not configured)"}`
+    };
+  }
+  const commandConfig = contentflowConfig?.commands?.[actionKey];
+  if (!commandConfig) {
+    return {
+      success: false,
+      output: `No command configured for action: ${actionKey}`
+    };
+  }
+  const params = extractParams(description);
+  const suffix = taskId.replace(CONTENT_TASK_PREFIX, "").replace(actionKey, "").replace(/^-/, "");
+  if (suffix && !params.seed && !params.term && !params.category && !params.topic) {
+    if (commandConfig.command.includes("{seed}")) params.seed = suffix;
+    else if (commandConfig.command.includes("{term}")) params.term = suffix;
+    else if (commandConfig.command.includes("{category}")) params.category = suffix;
+    else if (commandConfig.command.includes("{topic}")) params.topic = suffix;
+  }
+  let command = commandConfig.command;
+  for (const [key, value] of Object.entries(params)) {
+    command = command.replace(`{${key}}`, value);
+  }
+  command = command.replace(/\{[^}]+\}/g, "");
+  console.log(`[ContentFlow] Executing: ${command} in ${repoPath}`);
+  try {
+    const output = (0, import_child_process.execSync)(command, {
+      cwd: repoPath,
+      encoding: "utf-8",
+      timeout: 3e5,
+      // 5 minute timeout
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return {
+      success: true,
+      output: output.slice(-2e3)
+      // Last 2000 chars
+    };
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      output: `ContentFlow command failed: ${errMsg.slice(-1e3)}`
+    };
+  }
+}
+
+// scripts/skills/business-intelligence.ts
+var import_child_process2 = require("child_process");
+var fs3 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+
+// scripts/lib/paths.ts
+var path = __toESM(require("path"));
+var fs2 = __toESM(require("fs"));
+function findProjectRoot() {
+  const cwd = process.cwd();
+  if (fs2.existsSync(path.join(cwd, "data", "config.json"))) {
+    return cwd;
+  }
+  try {
+    const entries = fs2.readdirSync(cwd, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const candidate = path.join(cwd, entry.name, "data", "config.json");
+        if (fs2.existsSync(candidate)) {
+          return path.join(cwd, entry.name);
+        }
+      }
+    }
+  } catch {
+  }
+  let dir = cwd;
+  for (let i = 0; i < 5; i++) {
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    if (fs2.existsSync(path.join(parent, "data", "config.json"))) {
+      return parent;
+    }
+    dir = parent;
+  }
+  return cwd;
+}
+var PROJECT_DIR = findProjectRoot();
+var DATA_DIR = path.join(PROJECT_DIR, "data");
+var STATUS_FILE = path.join(PROJECT_DIR, "STATUS.md");
+var TODO_FILE = path.join(PROJECT_DIR, "TODO.md");
+var MEMORY_FILE = path.join(PROJECT_DIR, "MEMORY.md");
+var IDEAS_FILE = path.join(DATA_DIR, "ideas.json");
+var GOALS_FILE = path.join(DATA_DIR, "goals.json");
+var SESSIONS_FILE = path.join(DATA_DIR, "sessions.json");
+var CONFIG_FILE = path.join(DATA_DIR, "config.json");
+var BUSINESS_CONTEXT_FILE = path.join(DATA_DIR, "business-context.json");
+var HYPOTHESES_FILE = path.join(DATA_DIR, "hypotheses.json");
+var IMPLEMENTATIONS_FILE = path.join(DATA_DIR, "implementations.json");
+var COMPETITORS_FILE = path.join(DATA_DIR, "competitors.json");
+var POSITIONING_FILE = path.join(DATA_DIR, "positioning.json");
+var PAGES_FILE = path.join(DATA_DIR, "pages.json");
+var TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates");
+var COMMAND_TEMPLATES_DIR = path.join(TEMPLATES_DIR, "commands");
+
+// scripts/skills/business-intelligence.ts
+var BI_PREFIXES = [
+  "competitor-research",
+  "positioning-refresh",
+  "positioning-copy-bank",
+  "build-page-",
+  "measure-page-",
+  "growth-audit",
+  "pricing-analysis",
+  "validate-idea-"
+];
+function isBusinessIntelTask(taskId) {
+  return BI_PREFIXES.some((prefix) => taskId.startsWith(prefix));
+}
+function parseTaskToCommand(taskId, description) {
+  if (taskId === "competitor-research") {
+    return { command: "research-competitors", args: "" };
+  }
+  if (taskId === "competitor-research-discover") {
+    return { command: "research-competitors", args: "discover" };
+  }
+  if (taskId === "competitor-research-refresh") {
+    return { command: "research-competitors", args: "refresh" };
+  }
+  if (taskId.startsWith("competitor-research-")) {
+    const name = taskId.replace("competitor-research-", "");
+    return { command: "research-competitors", args: name };
+  }
+  if (taskId === "positioning-refresh") {
+    return { command: "positioning", args: "refresh" };
+  }
+  if (taskId === "positioning-copy-bank") {
+    return { command: "positioning", args: "copy-bank" };
+  }
+  if (taskId.startsWith("build-page-")) {
+    return { command: "build-page", args: description };
+  }
+  if (taskId.startsWith("measure-page-")) {
+    const slug = taskId.replace("measure-page-", "");
+    return { command: "measure-page", args: slug };
+  }
+  if (taskId === "growth-audit") {
+    return { command: "growth-audit", args: "" };
+  }
+  if (taskId.startsWith("growth-audit-")) {
+    const channel = taskId.replace("growth-audit-", "");
+    return { command: "growth-audit", args: channel };
+  }
+  if (taskId === "pricing-analysis") {
+    return { command: "pricing-analysis", args: "" };
+  }
+  if (taskId.startsWith("validate-idea-")) {
+    return { command: "validate-idea", args: description };
+  }
+  return null;
+}
+async function executeBusinessIntelTask(taskId, description, businessContext) {
+  const parsed = parseTaskToCommand(taskId, description);
+  if (!parsed) {
+    return {
+      success: false,
+      output: `Unknown business intelligence task: ${taskId}`
+    };
+  }
+  const { command, args: args2 } = parsed;
+  const commandFile = path2.join(PROJECT_DIR, ".claude", "commands", `${command}.md`);
+  if (!fs3.existsSync(commandFile)) {
+    return {
+      success: false,
+      output: `Slash command template not found: ${commandFile}. Run 'init' to scaffold commands.`
+    };
+  }
+  const template = fs3.readFileSync(commandFile, "utf-8");
+  const prompt = args2 ? `${template}
+
+---
+
+$ARGUMENTS: ${args2}
+
+Execute this command now.` : `${template}
+
+---
+
+Execute this command now with no arguments (use defaults).`;
+  console.log(`[BusinessIntel] Executing: /${command} ${args2} (task: ${taskId})`);
+  try {
+    const result = (0, import_child_process2.spawnSync)("claude", [
+      "--print",
+      "--dangerously-skip-permissions",
+      "--allowedTools",
+      "Read Write Edit Bash Glob Grep WebSearch WebFetch"
+    ], {
+      cwd: PROJECT_DIR,
+      input: prompt,
+      encoding: "utf-8",
+      timeout: 6e5,
+      // 10 minute timeout for web research tasks
+      stdio: ["pipe", "pipe", "pipe"],
+      env: process.env
+    });
+    if (result.status !== 0) {
+      const errorOutput = result.stderr || result.stdout || "Unknown error";
+      return {
+        success: false,
+        output: `Claude Code exited with code ${result.status}: ${errorOutput.slice(-1e3)}`
+      };
+    }
+    return {
+      success: true,
+      output: (result.stdout || "").slice(-2e3)
+      // Last 2000 chars
+    };
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      output: `Business intelligence task failed: ${errMsg.slice(-1e3)}`
+    };
+  }
+}
+function readBusinessIntelFreshness() {
+  const result = {
+    competitors: { count: 0, lastUpdated: null, staleDays: null },
+    positioning: { exists: false, lastUpdated: null, staleDays: null },
+    pages: { count: 0, livePagesWithoutMetrics: 0 }
+  };
+  if (fs3.existsSync(COMPETITORS_FILE)) {
+    try {
+      const data = JSON.parse(fs3.readFileSync(COMPETITORS_FILE, "utf-8"));
+      result.competitors.count = data.competitors?.length || 0;
+      result.competitors.lastUpdated = data.last_updated || null;
+      if (data.last_updated) {
+        const daysSince2 = Math.floor((Date.now() - new Date(data.last_updated).getTime()) / 864e5);
+        result.competitors.staleDays = daysSince2;
+      }
+    } catch {
+    }
+  }
+  if (fs3.existsSync(POSITIONING_FILE)) {
+    try {
+      const data = JSON.parse(fs3.readFileSync(POSITIONING_FILE, "utf-8"));
+      result.positioning.exists = !!data.current;
+      result.positioning.lastUpdated = data.last_updated || null;
+      if (data.last_updated) {
+        const daysSince2 = Math.floor((Date.now() - new Date(data.last_updated).getTime()) / 864e5);
+        result.positioning.staleDays = daysSince2;
+      }
+    } catch {
+    }
+  }
+  if (fs3.existsSync(PAGES_FILE)) {
+    try {
+      const data = JSON.parse(fs3.readFileSync(PAGES_FILE, "utf-8"));
+      result.pages.count = data.pages?.length || 0;
+      result.pages.livePagesWithoutMetrics = (data.pages || []).filter(
+        (p) => p.status === "live" && p.metrics.conversion_rate === null
+      ).length;
+    } catch {
+    }
+  }
+  return result;
+}
+
+// scripts/lib/run.ts
+var path3 = __toESM(require("path"));
+function resolveScript(baseDir, scriptName) {
+  const isCompiled = path3.extname(__filename) === ".js";
+  const resolvedName = isCompiled ? scriptName.replace(/\.ts$/, ".js") : scriptName;
+  const scriptPath = path3.join(baseDir, resolvedName);
+  return isCompiled ? { command: "node", args: [scriptPath] } : { command: "npx", args: ["tsx", scriptPath] };
+}
+
+// scripts/lib/telemetry.ts
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var CONFIG_DIR = path4.join(
+  process.env.HOME || process.env.USERPROFILE || "~",
+  ".vibebusiness"
+);
+var TELEMETRY_CONFIG_FILE = path4.join(CONFIG_DIR, "telemetry.json");
+var EVENTS_FILE = path4.join(CONFIG_DIR, "events.jsonl");
+function getVersion() {
+  try {
+    let dir = __dirname;
+    for (let i = 0; i < 4; i++) {
+      const pkgPath = path4.join(dir, "package.json");
+      if (fs4.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+        return pkg.version || "0.0.0";
+      }
+      dir = path4.dirname(dir);
+    }
+  } catch {
+  }
+  return "0.0.0";
+}
+function getTelemetryConfig() {
+  try {
+    if (!fs4.existsSync(TELEMETRY_CONFIG_FILE)) return null;
+    return JSON.parse(fs4.readFileSync(TELEMETRY_CONFIG_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function isTelemetryEnabled() {
+  const config = getTelemetryConfig();
+  return config?.enabled === true;
+}
+function trackEvent(event, properties = {}) {
+  try {
+    if (!isTelemetryEnabled()) return;
+    const config = getTelemetryConfig();
+    if (!config) return;
+    const entry = {
+      event,
+      properties,
+      id: config.id,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      version: getVersion()
+    };
+    fs4.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs4.appendFileSync(EVENTS_FILE, JSON.stringify(entry) + "\n");
+  } catch {
+  }
+}
+
+// scripts/lib/scaffold.ts
+var fs5 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+function scaffoldSlashCommands(rootDir) {
+  let templatesDir = path5.join(__dirname, "..", "..", "templates", "commands");
+  if (!fs5.existsSync(templatesDir)) {
+    templatesDir = path5.join(__dirname, "..", "..", "..", "templates", "commands");
+  }
+  if (!fs5.existsSync(templatesDir)) return;
+  const targetDir = path5.join(rootDir, ".claude", "commands");
+  fs5.mkdirSync(targetDir, { recursive: true });
+  const templates = fs5.readdirSync(templatesDir).filter((f) => f.endsWith(".md"));
+  let copied = 0;
+  for (const file of templates) {
+    const src = path5.join(templatesDir, file);
+    const dest = path5.join(targetDir, file);
+    fs5.copyFileSync(src, dest);
+    copied++;
+  }
+  if (copied > 0) {
+    console.log(`  \u2713 Scaffolded ${copied} slash commands into .claude/commands/`);
+  }
+}
+
+// scripts/heartbeat.ts
+var ROOT_DIR = PROJECT_DIR;
+var args = process.argv.slice(2);
+var DRY_RUN = args.includes("--dry-run");
+var SKIP_REASONING = args.includes("--skip-reasoning");
+var SESSION_MODE = args.includes("--session");
+var DURATION_MINUTES = parseInt(args.find((a) => a.startsWith("--duration="))?.split("=")[1] || "30");
+var INTERVAL_MINUTES = parseInt(args.find((a) => a.startsWith("--interval="))?.split("=")[1] || "5");
+var HEARTBEAT_COUNT = parseInt(args.find((a) => a.startsWith("--count="))?.split("=")[1] || "0");
+var capturedLogs = [];
+var isCapturingLogs = false;
+function log(message) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const logLine = `[${timestamp}] ${message}`;
+  console.log(logLine);
+  if (isCapturingLogs) {
+    capturedLogs.push(logLine);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function loadJson(filePath, defaultValue) {
+  try {
+    const content = fs6.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return defaultValue;
+  }
+}
+function saveJson(filePath, data) {
+  fs6.writeFileSync(filePath, JSON.stringify(data, null, 2));
+}
+function parseTodoFile() {
+  try {
+    const content = fs6.readFileSync(TODO_FILE, "utf-8");
+    const tasks = [];
+    let currentSection = "high_priority";
+    const lines = content.split("\n");
+    for (const line of lines) {
+      if (line.includes("## High Priority")) {
+        currentSection = "high_priority";
+      } else if (line.includes("## Scheduled")) {
+        currentSection = "scheduled";
+      } else if (line.includes("## Blocked")) {
+        currentSection = "blocked";
+      } else if (line.includes("## Completed")) {
+        currentSection = "completed";
+      }
+      const taskMatch = line.match(/^- \[([ x])\] `([^`]+)` — (.+)$/);
+      if (taskMatch) {
+        tasks.push({
+          id: taskMatch[2],
+          description: taskMatch[3],
+          completed: taskMatch[1] === "x",
+          section: currentSection
+        });
+      }
+    }
+    return tasks;
+  } catch {
+    return [];
+  }
+}
+function loadState() {
+  const ideasData = loadJson(IDEAS_FILE, { ideas: [] });
+  const goalsData = loadJson(GOALS_FILE, { goals: [] });
+  const sessionsData = loadJson(SESSIONS_FILE, { sessions: [] });
+  const todos = parseTodoFile();
+  return {
+    ideas: ideasData.ideas || [],
+    goals: goalsData.goals || [],
+    sessions: sessionsData.sessions || [],
+    todos
+  };
+}
+var DEFAULT_BUSINESS_CONTEXT = {
+  last_manual_update: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+  last_auto_update: null,
+  product: { name: process.env.NEXT_PUBLIC_PRODUCT_NAME || "My Product", summary: "" },
+  funnels: [],
+  monetization: {
+    current_mrr: 0,
+    paying_lawyers: 0,
+    immediate_opportunity: "",
+    revenue_streams: []
+  },
+  funnel_stages: { description: "", stages: {} },
+  key_constraints: []
+};
+function loadBusinessContext() {
+  return loadJson(BUSINESS_CONTEXT_FILE, DEFAULT_BUSINESS_CONTEXT);
+}
+function updateBusinessContext(ctx, kpis) {
+  const marketplace = ctx.funnels.find((f) => f.id === "marketplace");
+  if (marketplace) {
+    marketplace.metrics = {
+      leads_per_lawyer_per_week: kpis.leads_per_lawyer_per_week ?? 0,
+      total_active_lawyers: kpis.total_active_lawyers ?? 0
+    };
+  }
+  updateFunnelStageStatuses(ctx, kpis);
+  ctx.last_auto_update = (/* @__PURE__ */ new Date()).toISOString();
+  saveJson(BUSINESS_CONTEXT_FILE, ctx);
+}
+function checkThreshold(threshold, kpiValue) {
+  if (kpiValue === null || kpiValue === void 0) return false;
+  if (threshold.operator === "gte") return kpiValue >= threshold.value;
+  if (threshold.operator === "lte") return kpiValue <= threshold.value;
+  return false;
+}
+function getKpiValueById(kpiId, kpis) {
+  const mapping = {
+    "kpi-001": kpis.first_response_rate,
+    "kpi-002": kpis.avg_response_time_hours,
+    "kpi-003": kpis.conversation_rate,
+    "kpi-004": kpis.contract_rate,
+    "kpi-005": kpis.leads_per_lawyer_per_week
+  };
+  return mapping[kpiId] ?? null;
+}
+function updateFunnelStageStatuses(ctx, kpis) {
+  for (const [, stage] of Object.entries(ctx.funnel_stages.stages)) {
+    const thresholds = [];
+    if (stage.healthy_threshold) thresholds.push(stage.healthy_threshold);
+    if (stage.healthy_thresholds) thresholds.push(...stage.healthy_thresholds);
+    if (thresholds.length === 0) {
+      continue;
+    }
+    const allMet = thresholds.every((t) => {
+      const val = getKpiValueById(t.kpi_id, kpis);
+      return checkThreshold(t, val);
+    });
+    const anyHaveData = thresholds.some((t) => {
+      const val = getKpiValueById(t.kpi_id, kpis);
+      return val !== null && val !== void 0;
+    });
+    if (!anyHaveData) {
+      stage.current_status = "not_started";
+    } else {
+      stage.current_status = allMet ? "healthy" : "broken";
+    }
+  }
+}
+var FUNNEL_STAGE_ORDER = ["acquisition", "engagement", "conversion", "monetization"];
+function computeFunnelHealth(ctx, goals) {
+  const stages = ctx.funnel_stages.stages;
+  let earliestBroken = null;
+  const health = {};
+  for (const stageName of FUNNEL_STAGE_ORDER) {
+    const stage = stages[stageName];
+    if (!stage) continue;
+    health[stageName] = {
+      status: stage.current_status,
+      question: stage.question
+    };
+    if (!earliestBroken && stage.current_status === "broken") {
+      earliestBroken = stageName;
+    }
+  }
+  return {
+    ...health,
+    earliest_broken_stage: earliestBroken
+  };
+}
+function evaluatePrerequisites(prerequisites, goals) {
+  const kpiValues = {};
+  for (const goal of goals) {
+    for (const kpi of goal.kpis) {
+      kpiValues[kpi.id] = kpi.current_value;
+    }
+  }
+  return prerequisites.conditions.every((condition) => {
+    const val = kpiValues[condition.kpi_id];
+    return checkThreshold(condition, val);
+  });
+}
+function daysSince(dateString) {
+  const date = new Date(dateString);
+  const now = /* @__PURE__ */ new Date();
+  const diffTime = Math.abs(now.getTime() - date.getTime());
+  return Math.floor(diffTime / (1e3 * 60 * 60 * 24));
+}
+function formatDate(date) {
+  return date.toISOString().split("T")[0];
+}
+function formatDateTime(date) {
+  return date.toISOString();
+}
+function captureGitDiffInfo(workspacePath) {
+  const result = {
+    files_changed: [],
+    lines_added: 0,
+    lines_removed: 0,
+    has_uncommitted_changes: false
+  };
+  try {
+    const status = (0, import_child_process3.execSync)("git status --porcelain", { cwd: workspacePath, encoding: "utf-8" });
+    result.has_uncommitted_changes = status.trim().length > 0;
+    try {
+      const diffStat = (0, import_child_process3.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"
+      });
+      const lines = diffStat.trim().split("\n");
+      for (const line of lines) {
+        const fileMatch = line.match(/^\s*(.+?)\s+\|\s+\d+/);
+        if (fileMatch) {
+          result.files_changed.push(fileMatch[1].trim());
+        }
+        const summaryMatch = line.match(/(\d+) insertion[s]?\(\+\)/);
+        const deletionsMatch = line.match(/(\d+) deletion[s]?\(-\)/);
+        if (summaryMatch) {
+          result.lines_added = parseInt(summaryMatch[1], 10);
+        }
+        if (deletionsMatch) {
+          result.lines_removed = parseInt(deletionsMatch[1], 10);
+        }
+      }
+    } catch {
+      if (status.trim()) {
+        const statusLines = status.trim().split("\n");
+        for (const line of statusLines) {
+          const parts = line.trim().split(/\s+/);
+          if (parts.length >= 2) {
+            result.files_changed.push(parts.slice(1).join(" "));
+          }
+        }
+      }
+    }
+  } catch (error) {
+    log(`Failed to capture git diff info: ${error instanceof Error ? error.message : "Unknown"}`);
+  }
+  return result;
+}
+function checkAlerts(state) {
+  const alerts = [];
+  const inboxIdeas = state.ideas.filter((i) => i.stage === "inbox");
+  for (const idea of inboxIdeas) {
+    const days = daysSince(idea.created_at);
+    if (days > 7) {
+      alerts.push(`Idea "${idea.title}" has been in inbox for ${days} days`);
+    }
+  }
+  const inProgressIdeas = state.ideas.filter((i) => i.stage === "in_progress");
+  for (const idea of inProgressIdeas) {
+    const days = daysSince(idea.updated_at);
+    if (days > 14) {
+      alerts.push(`Idea "${idea.title}" has been in progress for ${days} days`);
+    }
+  }
+  for (const goal of state.goals) {
+    if (goal.status === "at_risk") {
+      alerts.push(`Goal "${goal.title}" is at risk`);
+    } else if (goal.status === "behind") {
+      alerts.push(`Goal "${goal.title}" is behind schedule`);
+    }
+  }
+  const shippedIdeas = state.ideas.filter((i) => i.stage === "shipped");
+  for (const idea of shippedIdeas) {
+    const daysShipped = daysSince(idea.implementation?.completed_at || idea.updated_at);
+    const v = idea.verification;
+    if (daysShipped > 7 && (!v || v.evaluation_count === 0)) {
+      alerts.push(`Shipped idea "${idea.title}" has never been evaluated (${daysShipped} days since ship)`);
+    }
+    if (v?.status === "needs_investigation") {
+      alerts.push(`Shipped idea "${idea.title}" needs investigation \u2014 metrics not met`);
+    }
+    if (v?.requires_human_review) {
+      alerts.push(`Shipped idea "${idea.title}" requires human review: ${v.human_review_reason || "unspecified reason"}`);
+    }
+  }
+  for (const goal of state.goals) {
+    for (const kpi of goal.kpis) {
+      if (kpi.history.length > 0) {
+        const lastEntry = kpi.history[kpi.history.length - 1];
+        const days = daysSince(lastEntry.date);
+        if (days > 7) {
+          alerts.push(`KPI "${kpi.name}" hasn't been updated in ${days} days`);
+        }
+      } else if (kpi.current_value === null) {
+        alerts.push(`KPI "${kpi.name}" has never been measured`);
+      }
+    }
+  }
+  return alerts;
+}
+async function fetchLiveKPIs() {
+  try {
+    if (!hasInternalApiKey()) {
+      log("No INTERNAL_API_KEY configured, skipping KPI fetch");
+      return null;
+    }
+    log("Fetching live KPIs from backend...");
+    const isHealthy = await checkBackendHealth();
+    if (!isHealthy) {
+      log("Backend not reachable, skipping KPI fetch");
+      return null;
+    }
+    const endDate = /* @__PURE__ */ new Date();
+    const startDate = /* @__PURE__ */ new Date();
+    startDate.setDate(startDate.getDate() - 30);
+    const kpis = await fetchLawyerSuccessKPIs(startDate, endDate);
+    log(`Fetched KPIs: first_response_rate=${kpis.first_response_rate}, contract_rate=${kpis.contract_rate}`);
+    return kpis;
+  } catch (error) {
+    log(`Failed to fetch KPIs: ${error instanceof Error ? error.message : "Unknown error"}`);
+    return null;
+  }
+}
+function updateGoalsWithKPIs(kpis) {
+  const goalsData = loadJson(GOALS_FILE, { goals: [] });
+  const today = formatDate(/* @__PURE__ */ new Date());
+  const lawyerSuccessGoal = goalsData.goals.find((g) => g.id === "goal-001");
+  if (!lawyerSuccessGoal) {
+    log("Lawyer Success goal (goal-001) not found");
+    return;
+  }
+  const kpiMapping = {
+    "kpi-001": "first_response_rate",
+    "kpi-002": "avg_response_time_hours",
+    "kpi-003": "conversation_rate",
+    "kpi-004": "contract_rate",
+    "kpi-005": "leads_per_lawyer_per_week"
+  };
+  for (const kpi of lawyerSuccessGoal.kpis) {
+    const apiKey = kpiMapping[kpi.id];
+    if (apiKey && kpis[apiKey] !== null && kpis[apiKey] !== void 0) {
+      let value = kpis[apiKey];
+      if (["first_response_rate", "conversation_rate", "contract_rate"].includes(apiKey)) {
+        value = value * 100;
+      }
+      value = Math.round(value * 100) / 100;
+      kpi.current_value = value;
+      const existingEntry = kpi.history.find((h) => h.date === today);
+      if (existingEntry) {
+        existingEntry.value = value;
+      } else {
+        kpi.history.push({ date: today, value });
+        if (kpi.history.length > 90) {
+          kpi.history = kpi.history.slice(-90);
+        }
+      }
+      log(`Updated KPI "${kpi.name}": ${value}${kpi.unit}`);
+    }
+  }
+  const contractRateKPI = lawyerSuccessGoal.kpis.find((k) => k.id === "kpi-004");
+  if (contractRateKPI && contractRateKPI.current_value !== null) {
+    lawyerSuccessGoal.current_value = contractRateKPI.current_value;
+  }
+  if (lawyerSuccessGoal.current_value !== null) {
+    const progress = lawyerSuccessGoal.current_value / lawyerSuccessGoal.target_value;
+    if (progress >= 0.9) {
+      lawyerSuccessGoal.status = "on_track";
+    } else if (progress >= 0.6) {
+      lawyerSuccessGoal.status = "at_risk";
+    } else {
+      lawyerSuccessGoal.status = "behind";
+    }
+  }
+  saveJson(GOALS_FILE, goalsData);
+  log("Updated goals.json with live KPIs");
+}
+function loadCodebaseSnapshot() {
+  const snapshotPath = path6.join(DATA_DIR, "codebase-snapshot.json");
+  try {
+    if (fs6.existsSync(snapshotPath)) {
+      return JSON.parse(fs6.readFileSync(snapshotPath, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function buildContextForClaude(state, alerts, businessContext) {
+  const codebaseSnapshot = loadCodebaseSnapshot();
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    alerts,
+    codebase_context: codebaseSnapshot,
+    business_context: businessContext ? {
+      funnels: businessContext.funnels.map((f) => ({
+        id: f.id,
+        name: f.name,
+        status: f.status,
+        key_insight: f.key_insight,
+        metrics: f.metrics
+      })),
+      monetization: {
+        current_mrr: businessContext.monetization.current_mrr,
+        paying_lawyers: businessContext.monetization.paying_lawyers,
+        immediate_opportunity: businessContext.monetization.immediate_opportunity,
+        revenue_streams: businessContext.monetization.revenue_streams
+      },
+      key_constraints: businessContext.key_constraints
+    } : null,
+    funnel_health: businessContext ? computeFunnelHealth(businessContext, state.goals) : null,
+    hypotheses: (loadJson(HYPOTHESES_FILE, { hypotheses: [] }).hypotheses || []).map((h) => ({
+      id: h.id,
+      title: h.title,
+      statement: h.statement,
+      funnel_stage: h.funnel_stage,
+      priority: h.priority,
+      status: h.status,
+      validation_ideas: h.validation_ideas,
+      effort_to_test: h.effort_to_test
+    })),
+    goals: state.goals.map((g) => ({
+      id: g.id,
+      title: g.title,
+      status: g.status,
+      current_value: g.current_value,
+      target_value: g.target_value,
+      target_unit: g.target_unit,
+      kpis: g.kpis.map((k) => ({
+        name: k.name,
+        current_value: k.current_value,
+        target_value: k.target_value,
+        unit: k.unit,
+        direction: k.direction,
+        last_updated: k.history.length > 0 ? k.history[k.history.length - 1].date : null
+      }))
+    })),
+    ideas: {
+      inbox: state.ideas.filter((i) => i.stage === "inbox").map((i) => ({
+        id: i.id,
+        title: i.title,
+        days_in_inbox: daysSince(i.created_at),
+        prerequisites_met: i.prerequisites ? evaluatePrerequisites(i.prerequisites, state.goals) : null,
+        funnel_stage: i.prerequisites?.funnel_stage ?? null,
+        prerequisites_summary: i.prerequisites?.description ?? null
+      })),
+      approved: state.ideas.filter((i) => i.stage === "approved").map((i) => ({
+        id: i.id,
+        title: i.title,
+        category: i.category,
+        days_since_approval: daysSince(i.updated_at)
+      })),
+      in_progress: state.ideas.filter((i) => i.stage === "in_progress").map((i) => {
+        const subTasks = i.implementation.sub_tasks || [];
+        const completed = subTasks.filter((st) => st.status === "completed").length;
+        const failed = subTasks.filter((st) => st.status === "failed").length;
+        return {
+          id: i.id,
+          title: i.title,
+          days_in_progress: daysSince(i.updated_at),
+          branch: i.implementation.branch_name,
+          sub_task_progress: subTasks.length > 0 ? `${completed}/${subTasks.length} done${failed > 0 ? `, ${failed} failed` : ""}` : null
+        };
+      }),
+      shipped: state.ideas.filter((i) => i.stage === "shipped").map((i) => ({
+        id: i.id,
+        title: i.title,
+        days_since_shipped: daysSince(i.implementation?.completed_at || i.updated_at),
+        goal_id: i.goal_id || null,
+        success_metrics: i.success_metrics,
+        verification_status: i.verification?.status || "pending",
+        last_evaluated: i.verification?.last_evaluated_at || null,
+        ready_for_evaluation: !i.verification?.next_evaluation_after || new Date(i.verification.next_evaluation_after) <= /* @__PURE__ */ new Date()
+      })),
+      total_count: state.ideas.length
+    },
+    todos: {
+      high_priority: state.todos.filter((t) => t.section === "high_priority" && !t.completed),
+      scheduled: state.todos.filter((t) => t.section === "scheduled"),
+      blocked: state.todos.filter((t) => t.section === "blocked")
+    },
+    live_data: state.liveData ? {
+      backend_healthy: state.liveData.backendHealthy,
+      kpis: state.liveData.kpis ? {
+        first_response_rate: state.liveData.kpis.first_response_rate,
+        avg_response_time_hours: state.liveData.kpis.avg_response_time_hours,
+        conversation_rate: state.liveData.kpis.conversation_rate,
+        contract_rate: state.liveData.kpis.contract_rate,
+        leads_per_lawyer_per_week: state.liveData.kpis.leads_per_lawyer_per_week,
+        total_leads: state.liveData.kpis.total_leads,
+        total_active_lawyers: state.liveData.kpis.total_active_lawyers
+      } : null
+    } : null,
+    recent_sessions: state.sessions.slice(-5).map((s) => ({
+      type: s.type,
+      status: s.status,
+      date: s.completed_at || s.created_at,
+      ideas_generated: s.ideas_generated.length
+    })),
+    business_intelligence: readBusinessIntelFreshness()
+  };
+}
+function buildBusinessConstraints(businessContext) {
+  if (!businessContext) {
+    return `BUSINESS CONTEXT:
+No business context configured yet. Focus on competitor research and foundational setup.`;
+  }
+  const lines = ["BUSINESS CONTEXT:"];
+  const productName = businessContext.product?.name || "Unknown product";
+  const productSummary = businessContext.product?.summary || "";
+  lines.push(`Product: ${productName}${productSummary ? ` \u2014 ${productSummary}` : ""}`);
+  if (businessContext.funnels?.length > 0) {
+    const funnelSummaries = businessContext.funnels.map((f) => {
+      const parts = [f.name];
+      if (f.status) parts.push(`(${f.status})`);
+      if (f.active_lawyers?.length) parts.push(`\u2014 ${f.active_lawyers.length} active lawyers`);
+      return parts.join(" ");
+    });
+    lines.push(`Funnels: ${funnelSummaries.join("; ")}`);
+  }
+  if (businessContext.monetization) {
+    const m = businessContext.monetization;
+    const parts = [];
+    if (m.current_mrr !== void 0) parts.push(`MRR: R$${m.current_mrr}`);
+    if (m.paying_lawyers !== void 0) parts.push(`${m.paying_lawyers} paying lawyers`);
+    if (m.revenue_streams?.length > 0) {
+      const streams = m.revenue_streams.map((s) => `${s.name} (${s.status})`).join(", ");
+      parts.push(`streams: ${streams}`);
+    }
+    if (m.immediate_opportunity) parts.push(`opportunity: ${m.immediate_opportunity}`);
+    if (parts.length > 0) lines.push(`Monetization: ${parts.join(", ")}`);
+  }
+  if (businessContext.key_constraints?.length > 0) {
+    lines.push("");
+    lines.push("KEY CONSTRAINTS (from business-context.json):");
+    for (const c of businessContext.key_constraints) {
+      lines.push(`- ${c}`);
+    }
+  }
+  if ((businessContext.regulatory?.length ?? 0) > 0) {
+    lines.push("");
+    lines.push("REGULATORY:");
+    for (const r of businessContext.regulatory) {
+      lines.push(`- ${r}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function runClaudeReasoning(state, alerts, businessContext) {
+  const context = buildContextForClaude(state, alerts, businessContext);
+  const TIMEOUT_MS = 12e4;
+  const productName = businessContext?.product?.name || process.env.NEXT_PUBLIC_PRODUCT_NAME || "this product";
+  const productSummary = businessContext?.product?.summary ? `, ${businessContext.product.summary}` : "";
+  const prompt = `You are the AI Business Analyst for ${productName}${productSummary}.
+
+CURRENT STATE:
+${JSON.stringify(context, null, 2)}
+
+Your job is to analyze this state and recommend the next action. Consider:
+1. Are there critical alerts that need immediate attention?
+2. Are KPIs trending in the right direction?
+3. Are there ideas stuck that need to be moved forward?
+4. What should be prioritized next?
+5. Are there approved ideas ready for autonomous implementation? If so, recommend task_id "implement-{ideaId}" to trigger it.
+6. Are there in_progress ideas with sub-tasks? Check their progress.
+
+DATA FRESHNESS CHECK:
+Before acting on any TODO or idea description, verify its assumptions against live_data:
+- If a TODO references a specific KPI value (e.g., "-27.17h", "86.34h") that differs from the current live_data.kpis value, the TODO's assumption is STALE
+- If an idea's motivation is to "fix" a metric that live_data shows is already at a reasonable (non-negative, non-zero) value, deprioritize it
+- When you detect stale assumptions, recommend a meta-task to update the TODO/idea descriptions rather than implementing the stale fix
+- Learnings in MEMORY that reference specific numbers should be validated against live_data before acting on them
+
+IMPLEMENTATION TASKS:
+- To trigger autonomous implementation of an approved idea, use task_id format: "implement-{ideaId}"
+  Example: "implement-idea-abc123"
+- The system will decompose the idea into sub-tasks, execute them one at a time, run tests, and create a PR
+- Only recommend implementation for ideas in "approved" stage
+
+META-TASKS:
+- You can recommend ANY task_id for operations on the analyst's own data files
+- The system will execute your task using Claude Code with access to: TODO.md, MEMORY.md, data/ideas.json, data/goals.json
+- Examples of valid meta-tasks:
+  - "consolidate-todos" \u2014 Clean up duplicate/completed items in TODO.md
+  - "create-idea-{slug}" \u2014 Create a new idea in data/ideas.json
+  - "update-goal-{slug}" \u2014 Modify goal targets or KPIs in data/goals.json
+  - "batch-cleanup" \u2014 Multiple cleanup operations in one pass
+- Use descriptive task_id names and detailed descriptions so the executor knows exactly what to do
+- The description field is critical \u2014 it's the full instruction set for the executor
+
+EVALUATION TASKS:
+- To evaluate a shipped idea's success metrics, use task_id: "evaluate-shipped-{ideaId}"
+- Only evaluate ideas in "shipped" stage with ready_for_evaluation=true
+- Consider the timeline in success_metrics \u2014 don't evaluate too early
+- After evaluation, the system may generate follow-up ideas for unmet metrics
+
+RESEARCH TASKS:
+There are TWO types of research tasks:
+
+1. TOPIC-BASED RESEARCH (for exploring new problems):
+   - Task ID format: "research-{slug}" (e.g., "research-response-time-optimization")
+   - Spawns a single Claude Code session with web search + codebase access
+   - Generates a deeply-researched idea grounded in evidence
+   - Use when you need to investigate a problem before creating an idea
+
+2. PARALLEL IDEA RESEARCH (for validating ideas before implementation):
+   - Task ID format: "research-idea-{ideaId}" (e.g., "research-idea-emergency-001")
+   - Triggers PARALLEL research agents that run simultaneously:
+     * Competitor Analysis (how competitors solve the problem)
+     * Codebase Verification (verify assumptions against actual code)
+     * Risk Assessment (identify technical, business, security risks)
+     * Alternative Approaches (explore different solutions)
+   - Results are aggregated into a recommendation: proceed, revise, or reject
+   - Use when an idea is in "under_review" stage before approving for implementation
+   - RECOMMENDED before implementing any medium+ effort ideas
+
+Best practice workflow:
+1. Create idea \u2192 inbox
+2. Move to under_review \u2192 trigger "research-idea-{id}" for parallel validation
+3. Review research findings \u2192 approve or revise
+4. Approved \u2192 trigger "implement-{id}" for autonomous implementation
+
+GOAL-GAP RESEARCH:
+- To research ideas for an underperforming goal, use task_id: "goal-gap-research-{goalId}"
+- Use when a goal is "behind" or "at_risk" AND has few/no active ideas working toward it
+- The system will spawn a focused research session that generates goal-aligned ideas
+- Example: "goal-gap-research-goal-003" for the Increase Revenue goal
+
+BUSINESS INTELLIGENCE TASKS:
+The "business_intelligence" field in CURRENT STATE shows freshness of competitor/positioning/page data.
+These tasks invoke slash commands via Claude Code for market research and page building.
+
+Task prefixes:
+- "competitor-research" \u2192 Discover + research all competitors (zero-input, auto-discovers from product description)
+- "competitor-research-discover" \u2192 Only discover new competitors
+- "competitor-research-refresh" \u2192 Re-research all existing competitors
+- "competitor-research-{name}" \u2192 Deep-dive on a single competitor
+- "positioning-refresh" \u2192 Regenerate positioning from fresh competitor data
+- "positioning-copy-bank" \u2192 Regenerate copy variations using existing positioning
+- "build-page-{slug}" \u2192 Build a landing/pricing/comparison page (description should specify page type + audience)
+- "measure-page-{slug}" \u2192 Measure a live page's performance
+- "growth-audit" \u2192 Audit growth channels vs. competitors
+- "growth-audit-{channel}" \u2192 Deep-dive on specific channel (seo, paid, content, referral)
+- "pricing-analysis" \u2192 Analyze pricing strategy vs. competitors
+- "validate-idea-{slug}" \u2192 Pre-build validation of an idea (description should contain the idea)
+
+When to recommend BI tasks:
+1. If business_intelligence.competitors.count == 0 \u2192 suggest "competitor-research" (high priority for new projects)
+2. If business_intelligence.competitors.staleDays > 14 \u2192 suggest "competitor-research-refresh"
+3. If business_intelligence.positioning.exists == false AND competitors.count > 0 \u2192 suggest "positioning-refresh"
+4. If business_intelligence.positioning.staleDays > 30 \u2192 suggest "positioning-refresh"
+5. If business_intelligence.pages.livePagesWithoutMetrics > 0 \u2192 suggest "measure-page-{id}"
+6. These form a natural chain: research competitors \u2192 develop positioning \u2192 generate copy \u2192 build pages \u2192 measure results
+
+- Use codebase_context (if present) to understand what services/integrations actually exist before proposing solutions
+
+${buildBusinessConstraints(businessContext)}
+
+The "business_context", "key_constraints", and "funnel_health" fields in CURRENT STATE describe the actual product, active funnels, constraints, and current business state. USE THIS for all decision-making. Do NOT assume facts not present in the data.
+
+FUNNEL REASONING:
+The business funnel is: Acquisition \u2192 Engagement \u2192 Conversion \u2192 Monetization.
+See "funnel_health" for which stages are broken.
+
+Rules:
+1. Inbox ideas with prerequisites_met=false \u2192 recommend DEFERRING, not approving.
+2. When recommending goal-gap research, prefer the EARLIEST broken funnel stage.
+3. Monetization ideas are premature if acquisition or engagement is broken.
+4. Focus energy on the "earliest_broken_stage".
+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.
+
+HYPOTHESIS VALIDATION:
+The "hypotheses" field contains business hypotheses that need validation through experiments.
+Rules:
+1. When generating ideas or research tasks, PREFER ideas that validate an active hypothesis (status="stated" or "testing").
+2. For each hypothesis, consider: What is the cheapest experiment to validate/invalidate it?
+3. Prioritize hypotheses that address the earliest broken funnel stage.
+4. When recommending research, reference the hypothesis ID (e.g., "research-validate-hyp-003").
+5. Track which ideas map to which hypothesis \u2014 set "hypothesis_id" in the idea JSON (e.g., "hypothesis_id": "hyp-003"). This auto-links the idea to the hypothesis.
+6. When hypotheses have "effort_to_test" data, prefer the lowest-effort hypothesis when tie-breaking.
+
+Respond with JSON only (no markdown code blocks, just raw JSON):
+{
+  "analysis": "Your 1-2 sentence analysis of the current situation",
+  "critical_issue": "The most important problem to address (or null if none)",
+  "next_action": {
+    "task_id": "existing task ID to execute, or a new task ID",
+    "description": "What specifically to do"
+  },
+  "new_todos": [
+    {
+      "id": "unique-task-id",
+      "description": "Task description",
+      "priority": "high_priority or scheduled"
+    }
+  ],
+  "learnings": ["Any patterns or insights to remember for future heartbeats"]
+}
+
+If there's nothing urgent, set next_action to null and new_todos to an empty array.
+Focus on actionable, specific recommendations. Be concise.`;
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+    const promptSize = prompt.length;
+    log(`Running Claude reasoning (prompt: ${promptSize} chars)...`);
+    const claude = (0, import_child_process3.spawn)("claude", ["--print"], {
+      cwd: ROOT_DIR,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    log(`  Claude process started (PID: ${claude.pid})`);
+    claude.stdin.write(prompt);
+    claude.stdin.end();
+    log(`  Prompt sent via stdin`);
+    let output = "";
+    let errorOutput = "";
+    let isResolved = false;
+    const progressInterval = setInterval(() => {
+      if (!isResolved) {
+        const elapsed = Math.round((Date.now() - startTime) / 1e3);
+        log(`  ...Claude thinking (${elapsed}s elapsed)`);
+      }
+    }, 1e4);
+    const timeout = setTimeout(() => {
+      if (!isResolved) {
+        isResolved = true;
+        clearInterval(progressInterval);
+        claude.kill("SIGTERM");
+        const elapsed = Math.round((Date.now() - startTime) / 1e3);
+        log(`Claude reasoning timed out after ${elapsed}s`);
+        resolve(null);
+      }
+    }, TIMEOUT_MS);
+    claude.stdout.on("data", (data) => {
+      const chunk = data.toString();
+      output += chunk;
+      if (output.length === chunk.length) {
+        log(`  Claude is responding...`);
+      }
+    });
+    claude.stderr.on("data", (data) => {
+      const text = data.toString();
+      errorOutput += text;
+      if (text.trim()) {
+        log(`  [Claude stderr]: ${text.trim().substring(0, 200)}`);
+      }
+    });
+    claude.on("close", (code) => {
+      if (isResolved) return;
+      isResolved = true;
+      clearInterval(progressInterval);
+      clearTimeout(timeout);
+      const elapsed = Math.round((Date.now() - startTime) / 1e3);
+      if (code === 0) {
+        try {
+          let jsonStr = output.trim();
+          const jsonMatch = jsonStr.match(/```(?:json)?\s*([\s\S]*?)```/);
+          if (jsonMatch) {
+            jsonStr = jsonMatch[1].trim();
+          }
+          const objectMatch = jsonStr.match(/\{[\s\S]*\}/);
+          if (objectMatch) {
+            const result = JSON.parse(objectMatch[0]);
+            log(`Claude completed in ${elapsed}s: ${result.analysis}`);
+            resolve(result);
+          } else {
+            log(`Claude completed in ${elapsed}s but no valid JSON found`);
+            resolve(null);
+          }
+        } catch (error) {
+          log(`Claude completed in ${elapsed}s but failed to parse: ${error instanceof Error ? error.message : "Unknown error"}`);
+          log(`Raw output: ${output.substring(0, 500)}`);
+          resolve(null);
+        }
+      } else {
+        log(`Claude exited with code ${code} after ${elapsed}s: ${errorOutput}`);
+        resolve(null);
+      }
+    });
+    claude.on("error", (error) => {
+      if (isResolved) return;
+      isResolved = true;
+      clearInterval(progressInterval);
+      clearTimeout(timeout);
+      log(`Claude spawn error: ${error.message}`);
+      resolve(null);
+    });
+  });
+}
+function addTasksToTodo(tasks) {
+  if (tasks.length === 0) return;
+  if (!fs6.existsSync(TODO_FILE)) return;
+  try {
+    let content = fs6.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");
+      if (scheduledIdx !== -1) {
+        content = content.slice(0, scheduledIdx) + "## High Priority (Do Now)\n\n" + content.slice(scheduledIdx);
+      } else {
+        content += "\n## High Priority (Do Now)\n\n";
+      }
+    }
+    if (!content.includes("## Scheduled")) {
+      log('TODO.md missing "## Scheduled" section \u2014 creating it');
+      content += "\n## Scheduled\n\n";
+    }
+    if (!content.includes("## Completed This Week")) {
+      content += "\n## Completed This Week\n\n";
+    }
+    const existingTodoLines = content.split("\n").filter((l) => l.startsWith("- [ ]"));
+    for (const task of tasks) {
+      if (content.includes(`\`${task.id}\``)) {
+        log(`Skipped duplicate TODO: ${task.id}`);
+        continue;
+      }
+      const entityPattern = /(?:idea-[a-f0-9]{8}|idea-[a-z0-9-]+|PR #\d+|hyp-\d{3}|goal-\d{3})/gi;
+      const newEntities = task.description.match(entityPattern) || [];
+      if (newEntities.length > 0) {
+        const coveredEntity = newEntities.find(
+          (entity) => existingTodoLines.some((line) => line.toLowerCase().includes(entity.toLowerCase()))
+        );
+        if (coveredEntity) {
+          log(`Skipped semantically duplicate TODO: ${task.id} (${coveredEntity} already in existing TODO)`);
+          continue;
+        }
+      }
+      if (task.priority === "high_priority") {
+        const highPriorityCount = content.split("\n").filter(
+          (l) => l.startsWith("- [ ]") && content.indexOf(l) > content.indexOf("## High Priority") && content.indexOf(l) < (content.indexOf("## Scheduled") || content.length)
+        ).length;
+        if (highPriorityCount >= 5) {
+          log(`Downgraded TODO ${task.id} to scheduled (high_priority cap of 5 reached)`);
+          task.priority = "scheduled";
+        }
+      }
+      const taskLine = `- [ ] \`${task.id}\` \u2014 ${task.description}`;
+      if (task.priority === "high_priority") {
+        const marker = "## High Priority (Do Now)";
+        const markerIndex = content.indexOf(marker);
+        if (markerIndex !== -1) {
+          const insertIndex = content.indexOf("\n", markerIndex) + 1;
+          content = content.slice(0, insertIndex) + "\n" + taskLine + content.slice(insertIndex);
+        }
+      } else {
+        const marker = "## Scheduled";
+        const markerIndex = content.indexOf(marker);
+        if (markerIndex !== -1) {
+          const insertIndex = content.indexOf("\n", markerIndex) + 1;
+          content = content.slice(0, insertIndex) + "\n" + taskLine + content.slice(insertIndex);
+        }
+      }
+      log(`Added TODO: ${task.id} \u2014 ${task.description}`);
+    }
+    fs6.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 (!fs6.existsSync(TODO_FILE)) return;
+    let content = fs6.readFileSync(TODO_FILE, "utf-8");
+    const lines = content.split("\n");
+    const completedLines = [];
+    const newLines = [];
+    let currentSection = "";
+    for (const line of lines) {
+      if (line.includes("## High Priority")) currentSection = "high_priority";
+      else if (line.includes("## Scheduled")) currentSection = "scheduled";
+      else if (line.includes("## Blocked")) currentSection = "blocked";
+      else if (line.includes("## Completed")) currentSection = "completed";
+      const isCheckedTask = /^- \[x\] /.test(line);
+      if (isCheckedTask && (currentSection === "high_priority" || currentSection === "scheduled")) {
+        completedLines.push(line);
+      } else {
+        newLines.push(line);
+      }
+    }
+    if (completedLines.length === 0) return;
+    content = newLines.join("\n");
+    const completedMarker = "## Completed This Week";
+    const markerIndex = content.indexOf(completedMarker);
+    if (markerIndex !== -1) {
+      const insertIndex = content.indexOf("\n", markerIndex) + 1;
+      const archiveBlock = completedLines.join("\n") + "\n";
+      content = content.slice(0, insertIndex) + archiveBlock + content.slice(insertIndex);
+    }
+    fs6.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"}`);
+  }
+}
+function pruneStaleScheduledTodos(state) {
+  try {
+    if (!fs6.existsSync(TODO_FILE)) return;
+    const content = fs6.readFileSync(TODO_FILE, "utf-8");
+    const lines = content.split("\n");
+    const prunedIds = [];
+    const terminalIdeaIds = new Set(
+      state.ideas.filter((i) => ["shipped", "rejected", "rolled_back"].includes(i.stage)).map((i) => i.id)
+    );
+    if (terminalIdeaIds.size === 0) return;
+    let currentSection = "";
+    const newLines = lines.filter((line) => {
+      if (line.includes("## High Priority")) currentSection = "high_priority";
+      else if (line.includes("## Scheduled")) currentSection = "scheduled";
+      else if (line.includes("## Blocked")) currentSection = "blocked";
+      else if (line.includes("## Completed")) currentSection = "completed";
+      if (currentSection !== "scheduled") return true;
+      const taskMatch = line.match(/^- \[ \] `([^`]+)`/);
+      if (!taskMatch) return true;
+      const taskId = taskMatch[1];
+      const ideaRefMatch = taskId.match(/(?:implement|research)-idea-(.+)/);
+      if (!ideaRefMatch) return true;
+      const ideaId = `idea-${ideaRefMatch[1]}`;
+      if (terminalIdeaIds.has(ideaId)) {
+        prunedIds.push(taskId);
+        return false;
+      }
+      return true;
+    });
+    if (prunedIds.length === 0) return;
+    fs6.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"}`);
+  }
+}
+function appendToMemory(learnings) {
+  if (learnings.length === 0) return;
+  if (!fs6.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 = fs6.readFileSync(MEMORY_FILE, "utf-8");
+    const existingLines = content.split("\n").filter((l) => l.match(/^- \*\*/));
+    filtered = filtered.filter((learning) => {
+      const words = learning.toLowerCase().split(/\s+/).filter((w) => w.length > 4);
+      if (words.length === 0) return true;
+      const isDuplicate = existingLines.some((existing) => {
+        const existingLower = existing.toLowerCase();
+        const overlapCount = words.filter((w) => existingLower.includes(w)).length;
+        return overlapCount / words.length > 0.6;
+      });
+      if (isDuplicate) {
+        log(`Skipped duplicate learning: "${learning.slice(0, 60)}..."`);
+      }
+      return !isDuplicate;
+    });
+    if (filtered.length === 0) {
+      log(`All learnings deduplicated \u2014 nothing new to add`);
+      return;
+    }
+    const section = "## Learned Patterns";
+    let sectionIndex = content.indexOf(section);
+    if (sectionIndex === -1) {
+      log('MEMORY.md missing "## Learned Patterns" section \u2014 creating it');
+      content += "\n" + section + "\n";
+      sectionIndex = content.indexOf(section);
+    }
+    if (sectionIndex !== -1) {
+      const nextSectionMatch = content.slice(sectionIndex + section.length).match(/\n## /);
+      const insertPoint = nextSectionMatch ? sectionIndex + section.length + (nextSectionMatch.index || 0) : content.length;
+      const today = formatDate(/* @__PURE__ */ new Date());
+      const newEntries = filtered.map((l) => `- **${today}:** ${l}`).join("\n");
+      const beforeSection = content.slice(0, insertPoint);
+      const afterSection = content.slice(insertPoint);
+      if (!beforeSection.includes("### Heartbeat Learnings")) {
+        content = beforeSection + "\n\n### Heartbeat Learnings\n\n" + newEntries + "\n" + afterSection;
+      } else {
+        const subsectionIndex = content.indexOf("### Heartbeat Learnings");
+        const subsectionEndMatch = content.slice(subsectionIndex + 22).match(/\n###/);
+        const subsectionEnd = subsectionEndMatch ? subsectionIndex + 22 + (subsectionEndMatch.index || 0) : insertPoint;
+        content = content.slice(0, subsectionEnd) + newEntries + "\n" + content.slice(subsectionEnd);
+      }
+      fs6.writeFileSync(MEMORY_FILE, content);
+      log(`Added ${filtered.length} learning(s) to MEMORY.md`);
+    }
+  } catch (error) {
+    log(`Failed to append to MEMORY.md: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+function determineWork(state) {
+  const highPriorityTasks = state.todos.filter(
+    (t) => t.section === "high_priority" && !t.completed
+  );
+  if (highPriorityTasks.length > 0) {
+    return highPriorityTasks[0];
+  }
+  const now = /* @__PURE__ */ new Date();
+  const hour = now.getHours();
+  const dayOfWeek = now.getDay();
+  const dayOfMonth = now.getDate();
+  const scheduledTasks = state.todos.filter(
+    (t) => t.section === "scheduled" && !t.completed
+  );
+  for (const task of scheduledTasks) {
+    if (task.id === "quick-analysis" && hour >= 6 && hour < 7) {
+      return task;
+    }
+    if (task.id === "deep-analysis" && dayOfWeek === 0 && hour >= 3 && hour < 4) {
+      return task;
+    }
+    if (task.id === "metrics-analysis" && dayOfWeek === 1 && hour >= 8 && hour < 9) {
+      return task;
+    }
+    if (task.id === "seo-audit" && (dayOfMonth === 1 || dayOfMonth === 15) && hour >= 4 && hour < 5) {
+      return task;
+    }
+  }
+  const shippedIdeas = state.ideas.filter((i) => i.stage === "shipped");
+  for (const idea of shippedIdeas) {
+    const v = idea.verification;
+    const ready = !v?.next_evaluation_after || new Date(v.next_evaluation_after) <= /* @__PURE__ */ new Date();
+    const daysShipped = daysSince(idea.implementation?.completed_at || idea.updated_at);
+    if (ready && daysShipped >= 7) {
+      return {
+        id: `evaluate-shipped-${idea.id}`,
+        description: `Evaluate shipped idea: ${idea.title}`,
+        completed: false,
+        section: "scheduled"
+      };
+    }
+  }
+  for (const goal of state.goals) {
+    if (goal.status !== "behind" && goal.status !== "at_risk") continue;
+    const activeIdeasForGoal = state.ideas.filter(
+      (i) => i.goal_id === goal.id && ["inbox", "under_review", "approved", "in_progress", "testing"].includes(i.stage)
+    );
+    if (activeIdeasForGoal.length === 0) {
+      return {
+        id: `goal-gap-research-${goal.id}`,
+        description: `Research ideas for behind goal: ${goal.title}`,
+        completed: false,
+        section: "high_priority"
+      };
+    }
+  }
+  const config = loadConfig();
+  if (config.autonomy?.enabled) {
+    const inProgressIdeas = state.ideas.filter((i) => i.stage === "in_progress");
+    for (const idea of inProgressIdeas) {
+      const subTasks = idea.implementation.sub_tasks || [];
+      const hasPending = subTasks.some((st) => st.status === "pending");
+      const hasFailed = subTasks.some((st) => st.status === "failed");
+      if (hasPending && !hasFailed) {
+        return {
+          id: `implement-${idea.id}`,
+          description: `Continue autonomous implementation: ${idea.title}`,
+          completed: false,
+          section: "high_priority"
+        };
+      }
+    }
+    const approvedIdeas = state.ideas.filter((i) => i.stage === "approved");
+    if (approvedIdeas.length > 0) {
+      const idea = approvedIdeas[0];
+      return {
+        id: `implement-${idea.id}`,
+        description: `Start autonomous implementation: ${idea.title}`,
+        completed: false,
+        section: "high_priority"
+      };
+    }
+  }
+  return null;
+}
+function loadConfig() {
+  return loadJson(CONFIG_FILE, {
+    repos: [],
+    workspace_dir: "",
+    schedules: {}
+  });
+}
+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(path6.basename(repo.path))) {
+        return repo;
+      }
+    }
+  }
+  if (idea.category === "security" || idea.category === "performance") {
+    return config.repos.find((r) => r.type === "fastapi") || config.repos[0];
+  }
+  if (idea.category === "ux_design") {
+    return config.repos.find((r) => r.type === "nextjs") || config.repos[0];
+  }
+  return config.repos[0];
+}
+async function decomposeIdea(idea, config) {
+  const maxSubTasks = config.autonomy?.max_sub_tasks_per_idea || 10;
+  const prompt = `You are decomposing a feature into small, implementable sub-tasks for an AI coding agent.
+
+## Feature: ${idea.title}
+
+${idea.summary}
+
+## Implementation Plan
+
+${idea.implementation_plan}
+
+## Rules
+
+1. Each sub-task should modify 1-3 files maximum
+2. Order by dependency: foundation first, integration last
+3. Maximum ${maxSubTasks} sub-tasks
+4. Each sub-task must have specific instructions: file paths, function names, what to add/change
+5. Sub-tasks should be small enough to fit in a single Claude Code session
+6. Include the exact file paths that need to be modified
+7. **IMPORTANT: Each sub-task MUST include writing tests.** For every new function/service created, include instructions to write corresponding tests. Example: "Create lawyer_service.py with X function, AND write tests in tests/test_lawyer_service.py that verify Y behavior." Tests should cover: happy path, error cases, and edge cases.
+8. **Monitoring/Observability**: Each sub-task that creates or modifies a service/endpoint MUST specify:
+   - Logging: "Add structured logs at [points] using the project's logger"
+   - Error handling: "Wrap [operation] in try/except, log error with [context variables]"
+   - Metrics: "Track [metric_name] for [operation]" (if performance-critical)
+9. **Final sub-task should be verification**: The last sub-task should verify the feature works end-to-end, including that logs/metrics are emitted correctly. Example: "Write integration test that verifies [endpoint] returns 200, logs [event], and handles [error case] gracefully."
+10. **Error paths are first-class**: Don't just implement the happy path. Each sub-task description must mention how errors are handled and logged.
+
+Respond with JSON only (no markdown code blocks, just raw JSON):
+{
+  "sub_tasks": [
+    {
+      "id": "st-001",
+      "title": "Short descriptive title",
+      "description": "Detailed instructions for Claude Code: what files to modify, what functions to add/change, specific implementation details. MUST include: 'Also write tests in tests/test_X.py that verify [specific behaviors].'",
+      "files_to_modify": ["src/path/to/file.ts", "tests/test_file.ts"],
+      "observability": "Brief description of logging/metrics/error handling this sub-task adds"
+    }
+  ]
+}`;
+  return new Promise((resolve) => {
+    const TIMEOUT_MS = 3e5;
+    log("Decomposing idea into sub-tasks via Claude reasoning...");
+    const claude = (0, import_child_process3.spawn)("claude", ["--print"], {
+      cwd: ROOT_DIR,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    claude.stdin.write(prompt);
+    claude.stdin.end();
+    let output = "";
+    let isResolved = false;
+    const timeout = setTimeout(() => {
+      if (!isResolved) {
+        isResolved = true;
+        claude.kill("SIGTERM");
+        log("Decomposition timed out");
+        resolve([]);
+      }
+    }, TIMEOUT_MS);
+    claude.stdout.on("data", (data) => {
+      output += data.toString();
+    });
+    claude.on("close", (code) => {
+      if (isResolved) return;
+      isResolved = true;
+      clearTimeout(timeout);
+      if (code === 0) {
+        try {
+          let jsonStr = output.trim();
+          const jsonMatch = jsonStr.match(/```(?:json)?\s*([\s\S]*?)```/);
+          if (jsonMatch) jsonStr = jsonMatch[1].trim();
+          const objectMatch = jsonStr.match(/\{[\s\S]*\}/);
+          if (objectMatch) {
+            const parsed = JSON.parse(objectMatch[0]);
+            const subTasks = parsed.sub_tasks.slice(0, maxSubTasks).map((st, i) => ({
+              id: st.id || `st-${String(i + 1).padStart(3, "0")}`,
+              title: st.title,
+              description: st.description,
+              files_to_modify: st.files_to_modify || [],
+              observability: st.observability || void 0,
+              status: "pending",
+              started_at: null,
+              completed_at: null,
+              error_message: null,
+              commit_hash: null
+            }));
+            log(`Decomposed into ${subTasks.length} sub-tasks`);
+            resolve(subTasks);
+            return;
+          }
+        } catch (error) {
+          log(`Failed to parse decomposition: ${error instanceof Error ? error.message : "Unknown"}`);
+        }
+      }
+      resolve([]);
+    });
+    claude.on("error", () => {
+      if (!isResolved) {
+        isResolved = true;
+        clearTimeout(timeout);
+        resolve([]);
+      }
+    });
+  });
+}
+function runTestsForRepo(workspacePath, testCommands, sourceRepoPath) {
+  const allOutput = [];
+  const env = { ...process.env };
+  if (sourceRepoPath) {
+    const venvBin = path6.join(sourceRepoPath, ".venv", "bin");
+    if (fs6.existsSync(venvBin)) {
+      env.PATH = `${venvBin}:${env.PATH}`;
+      env.VIRTUAL_ENV = path6.join(sourceRepoPath, ".venv");
+      log(`Using venv from ${sourceRepoPath}/.venv`);
+    }
+  }
+  for (const cmd of testCommands) {
+    log(`Running test: ${cmd}`);
+    try {
+      const result = (0, import_child_process3.execSync)(cmd, {
+        cwd: workspacePath,
+        encoding: "utf-8",
+        env,
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 12e4
+        // 2 min per test command
+      });
+      allOutput.push(`[PASS] ${cmd}
+${result}`);
+    } catch (error) {
+      const execError = error;
+      const errorOutput = execError.stderr || execError.stdout || execError.message;
+      allOutput.push(`[FAIL] ${cmd}
+${errorOutput}`);
+      log(`Test failed: ${cmd}`);
+      return { passed: false, output: allOutput.join("\n\n") };
+    }
+  }
+  log("All tests passed");
+  return { passed: true, output: allOutput.join("\n\n") };
+}
+async function executeAutonomousImplementation(ideaId) {
+  const config = loadConfig();
+  const autonomy = config.autonomy;
+  if (!autonomy?.enabled) {
+    log(`Autonomy not enabled, skipping implementation for ${ideaId}`);
+    return false;
+  }
+  const ideasData = loadJson(IDEAS_FILE, { ideas: [] });
+  const idea = ideasData.ideas.find((i) => i.id === ideaId);
+  if (!idea) {
+    log(`Idea not found: ${ideaId}`);
+    return false;
+  }
+  const subTasks = idea.implementation.sub_tasks || [];
+  if (subTasks.length === 0) {
+    log(`No sub-tasks for ${ideaId}, decomposing...`);
+    const newSubTasks = await decomposeIdea(idea, config);
+    if (newSubTasks.length === 0) {
+      log(`Decomposition failed for ${ideaId}`);
+      return false;
+    }
+    idea.implementation.sub_tasks = newSubTasks;
+    const ideaIndex2 = ideasData.ideas.findIndex((i) => i.id === ideaId);
+    ideasData.ideas[ideaIndex2] = idea;
+    saveJson(IDEAS_FILE, ideasData);
+    log(`Saved ${newSubTasks.length} sub-tasks for ${ideaId}`);
+    return true;
+  }
+  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...`);
+    const targetRepo2 = detectTargetRepo(idea, config);
+    if (!targetRepo2) {
+      log("Could not determine target repo");
+      return false;
+    }
+    try {
+      const { command, args: args2 } = resolveScript(__dirname, "implement.ts");
+      (0, import_child_process3.execSync)(
+        [command, ...args2, `--idea=${ideaId}`, `--repo=${targetRepo2.name}`, "--create-pr-only"].join(" "),
+        { cwd: ROOT_DIR, encoding: "utf-8", stdio: "inherit", timeout: 12e4 }
+      );
+      log(`PR created for ${ideaId}`);
+      const reloadedIdeas = loadJson(IDEAS_FILE, { ideas: [] });
+      const reloadedIndex = reloadedIdeas.ideas.findIndex((i) => i.id === ideaId);
+      if (reloadedIndex !== -1) {
+        reloadedIdeas.ideas[reloadedIndex].stage = "testing";
+        reloadedIdeas.ideas[reloadedIndex].updated_at = (/* @__PURE__ */ new Date()).toISOString();
+        saveJson(IDEAS_FILE, reloadedIdeas);
+      }
+      return true;
+    } catch (error) {
+      log(`PR creation failed: ${error instanceof Error ? error.message : "Unknown"}`);
+      return false;
+    }
+  }
+  if (failedTasks.length > 0) {
+    log(`${failedTasks.length} sub-task(s) failed for ${ideaId}, manual intervention needed`);
+    for (const st of failedTasks) {
+      log(`  Failed: ${st.id} \u2014 ${st.title}: ${st.error_message || "Unknown error"}`);
+    }
+    return false;
+  }
+  const nextTask = pendingTasks[0];
+  if (!nextTask) {
+    log(`No pending sub-tasks for ${ideaId}`);
+    return false;
+  }
+  log(`Executing sub-task ${nextTask.id}: ${nextTask.title}`);
+  nextTask.status = "in_progress";
+  nextTask.started_at = (/* @__PURE__ */ new Date()).toISOString();
+  const ideaIndex = ideasData.ideas.findIndex((i) => i.id === ideaId);
+  ideasData.ideas[ideaIndex] = idea;
+  saveJson(IDEAS_FILE, ideasData);
+  const targetRepo = detectTargetRepo(idea, config);
+  if (!targetRepo) {
+    log("Could not determine target repo");
+    nextTask.status = "failed";
+    nextTask.error_message = "Could not determine target repository";
+    saveJson(IDEAS_FILE, ideasData);
+    return false;
+  }
+  const scopePayload = JSON.stringify({
+    description: nextTask.description,
+    files_to_modify: nextTask.files_to_modify || [],
+    observability: nextTask.observability || void 0
+  });
+  const scopeBase64 = Buffer.from(scopePayload).toString("base64");
+  const timeoutMs = autonomy.max_sub_task_timeout_ms || 3e5;
+  const workspacePath = path6.join(config.workspace_dir, targetRepo.name);
+  const executionStartTime = Date.now();
+  const updateSubTaskWithDetails = (status, options = {}) => {
+    const endTime = Date.now();
+    const durationMs = endTime - executionStartTime;
+    const gitInfo = captureGitDiffInfo(workspacePath);
+    const reloadedIdeas = loadJson(IDEAS_FILE, { ideas: [] });
+    const reloadedIndex = reloadedIdeas.ideas.findIndex((i) => i.id === ideaId);
+    if (reloadedIndex !== -1) {
+      const reloadedSubTask = reloadedIdeas.ideas[reloadedIndex].implementation.sub_tasks.find(
+        (st) => st.id === nextTask.id
+      );
+      if (reloadedSubTask) {
+        reloadedSubTask.status = status;
+        reloadedSubTask.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+        reloadedSubTask.duration_ms = durationMs;
+        reloadedSubTask.files_changed = gitInfo.files_changed;
+        reloadedSubTask.lines_added = gitInfo.lines_added;
+        reloadedSubTask.lines_removed = gitInfo.lines_removed;
+        reloadedSubTask.has_uncommitted_changes = gitInfo.has_uncommitted_changes;
+        if (options.failureType !== void 0) {
+          reloadedSubTask.failure_type = options.failureType;
+        }
+        if (options.errorMessage !== void 0) {
+          reloadedSubTask.error_message = options.errorMessage?.substring(0, 2e3) || null;
+        }
+        if (options.outputSnippet !== void 0) {
+          reloadedSubTask.output_snippet = options.outputSnippet?.substring(0, 2e3) || null;
+        }
+        if (options.commitHash !== void 0) {
+          reloadedSubTask.commit_hash = options.commitHash;
+        }
+        saveJson(IDEAS_FILE, reloadedIdeas);
+      }
+    }
+  };
+  let outputBuffer = "";
+  let timedOut = false;
+  try {
+    const { command: implCmd, args: implArgs } = resolveScript(__dirname, "implement.ts");
+    try {
+      outputBuffer = (0, import_child_process3.execSync)(
+        [implCmd, ...implArgs, `--idea=${ideaId}`, `--repo=${targetRepo.name}`, `--scope=${scopeBase64}`, "--skip-pr", `--timeout=${timeoutMs}`, "--model=sonnet"].join(" "),
+        { cwd: ROOT_DIR, encoding: "utf-8", timeout: timeoutMs + 3e4 }
+      );
+    } catch (execError) {
+      if (execError instanceof Error && "killed" in execError) {
+        const errWithSignal = execError;
+        if (errWithSignal.signal === "SIGTERM") {
+          timedOut = true;
+        }
+      }
+      throw execError;
+    }
+    const testCommands = targetRepo.test_commands || [];
+    if (testCommands.length > 0) {
+      log(`Running tests for ${targetRepo.name}...`);
+      const testResult = runTestsForRepo(workspacePath, testCommands, targetRepo.path);
+      if (!testResult.passed) {
+        log(`Tests failed after sub-task ${nextTask.id}`);
+        updateSubTaskWithDetails("failed", {
+          failureType: "tests_failed",
+          errorMessage: `Tests failed: ${testResult.output}`,
+          outputSnippet: outputBuffer.slice(-2e3)
+        });
+        return false;
+      }
+    }
+    let commitHash = null;
+    try {
+      commitHash = (0, import_child_process3.execSync)("git rev-parse HEAD", { cwd: workspacePath, encoding: "utf-8" }).trim();
+    } catch {
+    }
+    updateSubTaskWithDetails("completed", {
+      failureType: null,
+      commitHash,
+      outputSnippet: outputBuffer.slice(-2e3)
+    });
+    log(`Sub-task ${nextTask.id} completed successfully`);
+    return true;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    log(`Sub-task ${nextTask.id} failed: ${errorMessage}`);
+    let failureType = "error";
+    if (timedOut) {
+      failureType = "timeout";
+    }
+    updateSubTaskWithDetails("failed", {
+      failureType,
+      errorMessage,
+      outputSnippet: outputBuffer.slice(-2e3) || null
+    });
+    return false;
+  }
+}
+async function executeMetaTask(taskId, description, businessContext) {
+  log(`Executing meta-task via Claude Code: ${taskId}`);
+  const allowedFiles = [
+    "TODO.md",
+    "MEMORY.md",
+    "data/ideas.json",
+    "data/goals.json"
+  ];
+  const metaProductName = businessContext?.product?.name || process.env.NEXT_PUBLIC_PRODUCT_NAME || "this product";
+  const prompt = `You are the AI Business Analyst for ${metaProductName}.
+
+## Task: ${taskId}
+
+${description}
+
+## Allowed Files
+
+You may ONLY read and modify these files:
+${allowedFiles.map((f) => `- ${f}`).join("\n")}
+
+## Rules
+
+1. Make the changes described above \u2014 be precise and thorough
+2. Do NOT modify any files outside the allowed list
+3. Do NOT modify scripts/, src/, or any code files
+4. Do NOT run any shell commands
+5. When modifying JSON files, preserve valid JSON structure
+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((resolve) => {
+    const claude = (0, import_child_process3.spawn)("claude", [
+      "--print",
+      "--dangerously-skip-permissions",
+      "--model",
+      "sonnet",
+      "--allowedTools",
+      "Read Edit Write",
+      "-p",
+      prompt
+    ], {
+      cwd: ROOT_DIR,
+      env: { ...process.env },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let output = "";
+    let isResolved = false;
+    const timeout = setTimeout(() => {
+      if (!isResolved) {
+        isResolved = true;
+        log(`Meta-task timed out after 240s`);
+        claude.kill("SIGTERM");
+        setTimeout(() => {
+          try {
+            claude.kill("SIGKILL");
+          } catch {
+          }
+        }, 5e3);
+        resolve(false);
+      }
+    }, 24e4);
+    claude.stdout.on("data", (data) => {
+      output += data.toString();
+    });
+    claude.stderr.on("data", (data) => {
+      process.stderr.write(data.toString());
+    });
+    claude.on("close", (code) => {
+      if (isResolved) return;
+      isResolved = true;
+      clearTimeout(timeout);
+      if (code === 0) {
+        log(`Meta-task completed: ${output.substring(0, 200)}`);
+        resolve(true);
+      } else {
+        log(`Meta-task failed (exit ${code})`);
+        resolve(false);
+      }
+    });
+    claude.on("error", (err) => {
+      if (isResolved) return;
+      isResolved = true;
+      clearTimeout(timeout);
+      log(`Meta-task error: ${err.message}`);
+      resolve(false);
+    });
+  });
+}
+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 goalsContext = goalsData.goals.map((g) => {
+    const kpiLines = g.kpis.map(
+      (k) => `  - ${k.name}: ${k.current_value ?? "N/A"} / ${k.target_value} ${k.unit}`
+    ).join("\n");
+    return `${g.id}: ${g.title} (${g.status}) \u2014 ${g.current_value ?? 0}/${g.target_value} ${g.target_unit}
+${kpiLines}`;
+  }).join("\n\n");
+  const contextPayload = JSON.stringify({
+    trigger: description,
+    codebase_snapshot: loadCodebaseSnapshot(),
+    goals: goalsContext
+  });
+  const contextBase64 = Buffer.from(contextPayload).toString("base64");
+  return new Promise((resolve) => {
+    const { command: analyzeCmd, args: analyzeArgs } = resolveScript(__dirname, "analyze.ts");
+    const childProcess = (0, import_child_process3.spawn)(analyzeCmd, [
+      ...analyzeArgs,
+      `--type=research`,
+      `--topic=${topic}`,
+      `--context=${contextBase64}`
+    ], {
+      cwd: ROOT_DIR,
+      stdio: "inherit"
+    });
+    const timeout = setTimeout(() => {
+      childProcess.kill("SIGTERM");
+      log("Research task timed out after 15 minutes");
+      resolve(false);
+    }, 9e5);
+    childProcess.on("close", (code) => {
+      clearTimeout(timeout);
+      if (code === 0) {
+        log("Research task completed successfully");
+        resolve(true);
+      } else {
+        log(`Research task failed with code ${code}`);
+        resolve(false);
+      }
+    });
+    childProcess.on("error", (error) => {
+      clearTimeout(timeout);
+      log(`Research task error: ${error.message}`);
+      resolve(false);
+    });
+  });
+}
+function buildGoalGapPrompt(goal, existingIdeas, liveKPIs, config, businessContext) {
+  const repoList = config.repos.map((r) => `- ${r.name}: ${r.path} (${r.type})`).join("\n");
+  const kpiLines = goal.kpis.map((k) => {
+    const progress = k.target_value && k.current_value !== null ? `${Math.round(k.current_value / k.target_value * 100)}%` : "0%";
+    const trend = k.history.length >= 2 ? k.history[k.history.length - 1].value > k.history[k.history.length - 2].value ? "UP" : "DOWN" : "N/A";
+    return `- **${k.name}**: ${k.current_value ?? 0} / ${k.target_value} ${k.unit} (${progress} complete, trend: ${trend})`;
+  }).join("\n");
+  let existingIdeasContext = "No existing ideas for this goal.";
+  if (existingIdeas.length > 0) {
+    existingIdeasContext = existingIdeas.map(
+      (i) => `- "${i.title}" \u2014 Stage: ${i.stage}, Created: ${i.created_at.split("T")[0]}`
+    ).join("\n");
+  }
+  let liveKPIContext = "Backend KPIs not available.";
+  if (liveKPIs) {
+    liveKPIContext = `Live KPIs: first_response_rate=${liveKPIs.first_response_rate}, contract_rate=${liveKPIs.contract_rate}, active_lawyers=${liveKPIs.total_active_lawyers}, total_leads=${liveKPIs.total_leads}`;
+  }
+  let funnelContextSection = "";
+  if (businessContext) {
+    const funnelSummary = businessContext.funnels.map(
+      (f) => `- **${f.name}** (${f.status}): ${f.key_insight}`
+    ).join("\n");
+    const goalsForHealth = loadJson(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);
+    const payingLawyers = businessContext.monetization.paying_lawyers;
+    funnelContextSection = `
+### Business & Funnel Context
+${funnelSummary}
+
+The platform currently has ${activeLawyers} active lawyers, ${payingLawyers} paying. The earliest broken funnel stage is **${earliestBroken}**.
+
+Key constraints:
+${businessContext.key_constraints.map((c) => `- ${c}`).join("\n")}
+
+Rules:
+1. At least HALF of ideas must target the earliest broken stage, even if the goal is about a later stage.
+2. For the Revenue goal: if only ${activeLawyers} lawyers are active and ${payingLawyers} are paying, prioritize "convert free \u2192 paid" over "build new revenue features".
+3. Later-stage ideas MUST include a "prerequisites" object: { "description": "...", "funnel_stage": "...", "conditions": [{ "kpi_id": "...", "operator": "gte"|"lte", "value": N, "label": "..." }] }
+4. Don't propose per-lead fees when lead volume is < 3/lawyer/week.
+`;
+  }
+  const baseContextStr = buildBaseContext(businessContext);
+  const constraintsSection = businessContext?.key_constraints?.length ? businessContext.key_constraints.map((c) => `- ${c}`).join("\n") : "- Review business constraints before proposing changes";
+  return `${baseContextStr}
+
+## GOAL-GAP RESEARCH
+
+A business goal is **behind schedule** and needs ideas to close the gap.
+
+### Goal: ${goal.title}
+**ID:** ${goal.id}
+**Description:** ${goal.description || goal.title}
+**Status:** ${goal.status}
+**Progress:** ${goal.current_value ?? 0} / ${goal.target_value} ${goal.target_unit}
+**Deadline:** ${goal.deadline || "Not set"}
+
+### KPI Breakdown
+${kpiLines}
+
+### What's Already Been Tried
+${existingIdeasContext}
+
+### Live Backend Data
+${liveKPIContext}
+${funnelContextSection}
+### Repositories Available
+${repoList}
+
+## Business Model Constraints
+${constraintsSection}
+
+## Your Task
+
+Research and generate **2-5 actionable ideas** that directly move this goal's KPIs forward.
+
+### Requirements for Each Idea
+1. **Codebase grounded**: Use Glob/Grep/Read to verify what exists before proposing changes
+2. **Web researched**: Use WebSearch for best practices, competitor analysis, Brazil-specific context
+3. **Goal-aligned**: Must have \`goal_id\` set to "${goal.id}"
+4. **Measurable**: success_metrics must be in "baseline \u2192 target \u2192 timeline" format tied to goal KPIs
+5. **Tagged**: Include tag "goal-gap-${goal.id}"
+6. **Funnel-aware**: Growth/revenue ideas targeting later funnel stages must include a "prerequisites" object
+
+### Output Format
+
+Return a JSON array of ideas:
+\`\`\`json
+[
+  {
+    "title": "string - Clear, actionable title (max 80 chars)",
+    "summary": "string - One sentence describing the improvement",
+    "category": "product | ux_design | growth | performance | tech_debt | security | infrastructure | content | analytics | integration",
+    "priority": "critical | high | medium | low",
+    "effort": "xs | s | m | l | xl",
+    "impact": "xs | s | m | l | xl",
+    "context": "string - What triggered this idea (observations, data)",
+    "rationale": "string - Why this matters for the business",
+    "implementation_plan": "string - Step-by-step implementation (markdown ok)",
+    "success_metrics": ["array of measurable outcomes in baseline\u2192target\u2192timeline format"],
+    "tags": ["array of relevant tags including goal-gap-${goal.id}"],
+    "files_analyzed": ["array of relevant file paths"],
+    "goal_id": "${goal.id}",
+    "prerequisites": "optional - { description, funnel_stage, conditions: [{ kpi_id, operator, value, label }] }"
+  }
+]
+\`\`\`
+
+Only output the JSON array, no other text.`;
+}
+async function executeGoalGapResearch(goalId) {
+  log(`Executing goal-gap research for ${goalId}...`);
+  const goalsData = loadJson(GOALS_FILE, { goals: [] });
+  const goal = goalsData.goals.find((g) => g.id === goalId);
+  if (!goal) {
+    log(`Goal ${goalId} not found`);
+    return false;
+  }
+  if (goal.status !== "behind" && goal.status !== "at_risk") {
+    log(`Goal ${goalId} is not behind or at_risk (status: ${goal.status}), skipping`);
+    return false;
+  }
+  const ideasData = loadJson(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((resolve) => {
+    const TIMEOUT_MS = 9e5;
+    const startTime = Date.now();
+    const claude = (0, import_child_process3.spawn)("claude", [
+      "--print",
+      "--dangerously-skip-permissions"
+    ], {
+      cwd: config.repos[0]?.path || ROOT_DIR,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    claude.stdin.write(prompt);
+    claude.stdin.end();
+    let output = "";
+    let isResolved = false;
+    const progressInterval = setInterval(() => {
+      if (!isResolved) {
+        const elapsed = Math.round((Date.now() - startTime) / 1e3);
+        log(`  ...Goal-gap research working (${elapsed}s elapsed, ${output.length} chars)`);
+      }
+    }, 3e4);
+    const timeout = setTimeout(() => {
+      if (!isResolved) {
+        isResolved = true;
+        clearInterval(progressInterval);
+        claude.kill("SIGTERM");
+        log("Goal-gap research timed out after 15 minutes");
+        resolve(false);
+      }
+    }, TIMEOUT_MS);
+    claude.stdout.on("data", (data) => {
+      output += data.toString();
+    });
+    claude.stderr.on("data", (data) => {
+      const text = data.toString();
+      if (text.trim()) {
+        log(`  [Goal-gap stderr]: ${text.trim().substring(0, 200)}`);
+      }
+    });
+    claude.on("close", (code) => {
+      if (isResolved) return;
+      isResolved = true;
+      clearInterval(progressInterval);
+      clearTimeout(timeout);
+      const elapsed = Math.round((Date.now() - startTime) / 1e3);
+      if (code !== 0) {
+        log(`Goal-gap research failed with code ${code} after ${elapsed}s`);
+        resolve(false);
+        return;
+      }
+      log(`Goal-gap research completed in ${elapsed}s, parsing ideas...`);
+      const jsonMatch = output.match(/\[\s*\{[\s\S]*\}\s*\]/);
+      if (!jsonMatch) {
+        log("No JSON array found in goal-gap research response");
+        resolve(false);
+        return;
+      }
+      try {
+        const rawIdeas = JSON.parse(jsonMatch[0]);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const newIdeas = rawIdeas.map((idea) => ({
+          id: `idea-${Math.random().toString(36).substring(2, 10)}`,
+          title: idea.title || "Untitled Idea",
+          summary: idea.summary || "",
+          context: idea.context || "",
+          rationale: idea.rationale || "",
+          stage: "inbox",
+          category: idea.category || "product",
+          effort: idea.effort || "m",
+          created_at: now,
+          updated_at: now,
+          implementation_plan: idea.implementation_plan || "",
+          success_metrics: idea.success_metrics || [],
+          source: {
+            type: "metrics_review",
+            files_analyzed: idea.files_analyzed
+          },
+          implementation: {
+            branch_name: null,
+            sub_tasks: []
+          },
+          goal_id: goalId,
+          tags: [...idea.tags || [], `goal-gap-${goalId}`],
+          comments: [{
+            id: `comment-${Math.random().toString(36).substring(2, 10)}`,
+            created_at: now,
+            author: "system",
+            author_name: "Goal-Gap Research",
+            content: `Auto-generated to address goal "${goal.title}" (${goal.status}). Current progress: ${goal.current_value ?? 0}/${goal.target_value} ${goal.target_unit}.`
+          }],
+          related_ideas: []
+        }));
+        if (newIdeas.length === 0) {
+          log("No ideas parsed from goal-gap research");
+          resolve(false);
+          return;
+        }
+        const freshIdeasData = loadJson(IDEAS_FILE, { ideas: [] });
+        freshIdeasData.ideas.push(...newIdeas);
+        saveJson(IDEAS_FILE, freshIdeasData);
+        const freshGoalsData = loadJson(GOALS_FILE, { goals: [] });
+        const freshGoal = freshGoalsData.goals.find((g) => g.id === goalId);
+        if (freshGoal) {
+          if (!freshGoal.related_ideas) freshGoal.related_ideas = [];
+          freshGoal.related_ideas.push(...newIdeas.map((i) => i.id));
+          saveJson(GOALS_FILE, freshGoalsData);
+        }
+        log(`Goal-gap research generated ${newIdeas.length} ideas for ${goalId}:`);
+        newIdeas.forEach((idea, i) => {
+          log(`  ${i + 1}. ${idea.title}`);
+        });
+        resolve(true);
+      } catch (error) {
+        log(`Failed to parse goal-gap research ideas: ${error instanceof Error ? error.message : "Unknown"}`);
+        resolve(false);
+      }
+    });
+    claude.on("error", (error) => {
+      if (!isResolved) {
+        isResolved = true;
+        clearInterval(progressInterval);
+        clearTimeout(timeout);
+        log(`Goal-gap research error: ${error.message}`);
+        resolve(false);
+      }
+    });
+  });
+}
+function buildEvaluationPrompt(idea, goal, liveKPIs, daysShipped) {
+  let kpiComparison = "No KPI snapshot available at ship time.";
+  if (idea.verification?.kpi_snapshot_at_ship && idea.verification.kpi_snapshot_at_ship.length > 0) {
+    const rows = idea.verification.kpi_snapshot_at_ship.map((snap) => {
+      const currentKPI = goal?.kpis.find((k) => k.id === snap.kpi_id);
+      const currentVal = currentKPI?.current_value ?? "N/A";
+      const trend = currentKPI?.history && currentKPI.history.length >= 2 ? currentKPI.history[currentKPI.history.length - 1].value > currentKPI.history[currentKPI.history.length - 2].value ? "UP" : "DOWN" : "N/A";
+      return `| ${snap.kpi_name} | ${snap.value ?? "N/A"} | ${currentVal} | ${trend} |`;
+    }).join("\n");
+    kpiComparison = `| KPI | At Ship | Current | Trend |
+|-----|---------|---------|-------|
+${rows}`;
+  }
+  let goalContext = "No linked goal.";
+  if (goal) {
+    goalContext = `Goal: "${goal.title}" \u2014 Status: ${goal.status}, Current: ${goal.current_value ?? "N/A"} / Target: ${goal.target_value} ${goal.target_unit}`;
+  }
+  let liveKPIContext = "Backend KPIs not available.";
+  if (liveKPIs) {
+    liveKPIContext = `Live KPIs: first_response_rate=${liveKPIs.first_response_rate}, contract_rate=${liveKPIs.contract_rate}, conversation_rate=${liveKPIs.conversation_rate}, leads_per_lawyer_per_week=${liveKPIs.leads_per_lawyer_per_week}`;
+  }
+  return `You are evaluating whether a shipped product improvement achieved its intended results.
+
+## Shipped Idea
+
+**Title:** ${idea.title}
+**Summary:** ${idea.summary}
+**Days Since Ship:** ${daysShipped}
+
+## Success Metrics (defined at creation)
+
+${idea.success_metrics.map((m, i) => `${i + 1}. ${m}`).join("\n")}
+
+## KPI Comparison (At Ship vs Current)
+
+${kpiComparison}
+
+## Goal Context
+
+${goalContext}
+
+## Live Backend KPIs
+
+${liveKPIContext}
+
+## Judgment Rules
+
+For each success_metric:
+1. Try to parse "baseline \u2192 target \u2192 timeline" format (e.g., "Increase X from 10% to 20% within 30 days")
+2. If the timeline hasn't elapsed yet \u2192 status = "no_data"
+3. If KPI data is stale (>7 days old) \u2192 note "low" confidence
+4. Compare at-ship value to current value against the metric's target
+
+Overall status mapping:
+- "validated" = majority of metrics are "met" or "partially_met" with positive trends
+- "needs_investigation" = majority of metrics are "not_met" despite sufficient time elapsed
+- "inconclusive" = not enough data, or timeline not yet elapsed for most metrics
+- "invalidated" = clear negative evidence (KPIs moved in wrong direction) \u2014 rare, requires strong proof
+
+Set requires_human_review=true if:
+- Metrics show contradictory signals (some improving, some declining)
+- Confidence is "low" across the board
+- The idea may have caused a regression
+
+## Follow-Up Ideas
+
+If metrics are "not_met" or "needs_investigation", propose 0-2 follow-up ideas to address the gap. Each should be actionable and specific.
+
+## Response Format
+
+Respond with JSON only (no markdown code blocks):
+{
+  "status": "validated|needs_investigation|inconclusive|invalidated",
+  "summary": "2-3 sentence judgment of the evaluation results",
+  "confidence": "high|medium|low",
+  "metric_evaluations": [
+    {
+      "metric": "The original metric text",
+      "status": "met|partially_met|not_met|no_data",
+      "evidence": "What data supports this judgment"
+    }
+  ],
+  "requires_human_review": false,
+  "human_review_reason": null,
+  "follow_up_ideas": [
+    {
+      "title": "Short title",
+      "summary": "What to do and why",
+      "category": "product|growth|performance|etc",
+      "priority": "high|medium|low"
+    }
+  ]
+}`;
+}
+async function executeShippedEvaluation(ideaId) {
+  log(`Starting post-ship evaluation for idea: ${ideaId}`);
+  const ideasData = loadJson(IDEAS_FILE, { ideas: [] });
+  const idea = ideasData.ideas.find((i) => i.id === ideaId);
+  if (!idea) {
+    log(`Idea not found: ${ideaId}`);
+    return false;
+  }
+  if (idea.stage !== "shipped") {
+    log(`Idea ${ideaId} is not in shipped stage (current: ${idea.stage})`);
+    return false;
+  }
+  const daysShipped = daysSince(idea.implementation?.completed_at || idea.updated_at);
+  let goal = null;
+  if (idea.goal_id) {
+    const goalsData = loadJson(GOALS_FILE, { goals: [] });
+    goal = goalsData.goals.find((g) => g.id === idea.goal_id) || null;
+  }
+  const liveKPIs = await fetchLiveKPIs();
+  const prompt = buildEvaluationPrompt(idea, goal, liveKPIs, daysShipped);
+  const TIMEOUT_MS = 12e4;
+  const result = await new Promise((resolve) => {
+    const claude = (0, import_child_process3.spawn)("claude", ["--print"], {
+      cwd: ROOT_DIR,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    claude.stdin.write(prompt);
+    claude.stdin.end();
+    let output = "";
+    let isResolved = false;
+    const timeout = setTimeout(() => {
+      if (!isResolved) {
+        isResolved = true;
+        claude.kill("SIGTERM");
+        log("Evaluation timed out");
+        resolve(null);
+      }
+    }, TIMEOUT_MS);
+    claude.stdout.on("data", (data) => {
+      output += data.toString();
+    });
+    claude.on("close", (code) => {
+      if (isResolved) return;
+      isResolved = true;
+      clearTimeout(timeout);
+      if (code === 0 && output.trim()) {
+        try {
+          let jsonStr = output.trim();
+          const jsonMatch = jsonStr.match(/```(?:json)?\s*([\s\S]*?)```/);
+          if (jsonMatch) jsonStr = jsonMatch[1].trim();
+          const objectMatch = jsonStr.match(/\{[\s\S]*\}/);
+          if (objectMatch) {
+            const parsed = JSON.parse(objectMatch[0]);
+            log(`Evaluation complete: status=${parsed.status}, confidence=${parsed.confidence}`);
+            resolve(parsed);
+            return;
+          }
+        } catch (error) {
+          log(`Failed to parse evaluation: ${error instanceof Error ? error.message : "Unknown"}`);
+        }
+      }
+      resolve(null);
+    });
+    claude.on("error", () => {
+      if (!isResolved) {
+        isResolved = true;
+        clearTimeout(timeout);
+        resolve(null);
+      }
+    });
+  });
+  if (!result) {
+    log(`Evaluation failed for ${ideaId}`);
+    return false;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existingVerification = idea.verification || {
+    status: "pending",
+    first_evaluated_at: null,
+    last_evaluated_at: null,
+    evaluation_count: 0,
+    next_evaluation_after: null,
+    summary: null,
+    metric_evaluations: [],
+    confidence: null,
+    follow_up_idea_ids: [],
+    requires_human_review: false,
+    human_review_reason: null,
+    kpi_snapshot_at_ship: []
+  };
+  let nextEvaluationDays;
+  switch (result.status) {
+    case "validated":
+      nextEvaluationDays = 30;
+      break;
+    case "needs_investigation":
+      nextEvaluationDays = 14;
+      break;
+    case "inconclusive":
+      nextEvaluationDays = 7;
+      break;
+    case "invalidated":
+      nextEvaluationDays = 30;
+      break;
+    default:
+      nextEvaluationDays = 14;
+  }
+  const nextEvalDate = /* @__PURE__ */ new Date();
+  nextEvalDate.setDate(nextEvalDate.getDate() + nextEvaluationDays);
+  const updatedVerification = {
+    ...existingVerification,
+    status: result.status,
+    first_evaluated_at: existingVerification.first_evaluated_at || now,
+    last_evaluated_at: now,
+    evaluation_count: existingVerification.evaluation_count + 1,
+    next_evaluation_after: nextEvalDate.toISOString(),
+    summary: result.summary,
+    metric_evaluations: result.metric_evaluations,
+    confidence: result.confidence,
+    requires_human_review: result.requires_human_review,
+    human_review_reason: result.human_review_reason
+  };
+  const followUpIds = [];
+  if (result.follow_up_ideas && result.follow_up_ideas.length > 0) {
+    for (const followUp of result.follow_up_ideas) {
+      const followUpId = `idea-eval-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+      const newIdea = {
+        id: followUpId,
+        title: followUp.title,
+        summary: followUp.summary,
+        context: `Follow-up from post-ship evaluation of "${idea.title}" (${ideaId})`,
+        rationale: `Evaluation found metrics not met for shipped idea. This follow-up addresses the gap.`,
+        stage: "inbox",
+        category: followUp.category || "product",
+        effort: "s",
+        created_at: now,
+        updated_at: now,
+        implementation_plan: "",
+        success_metrics: [],
+        source: {
+          type: "metrics_review",
+          files_analyzed: []
+        },
+        implementation: {
+          branch_name: null,
+          completed_at: null,
+          sub_tasks: []
+        },
+        goal_id: idea.goal_id || null,
+        comments: [],
+        tags: ["follow-up", `evaluation-${ideaId}`],
+        related_ideas: [ideaId]
+      };
+      ideasData.ideas.push(newIdea);
+      followUpIds.push(followUpId);
+      log(`Created follow-up idea: ${followUpId} \u2014 "${followUp.title}"`);
+    }
+  }
+  updatedVerification.follow_up_idea_ids = [
+    ...existingVerification.follow_up_idea_ids,
+    ...followUpIds
+  ];
+  const ideaIndex = ideasData.ideas.findIndex((i) => i.id === ideaId);
+  if (ideaIndex !== -1) {
+    ideasData.ideas[ideaIndex].verification = updatedVerification;
+    ideasData.ideas[ideaIndex].updated_at = now;
+    const comments = ideasData.ideas[ideaIndex].comments || [];
+    comments.push({
+      id: `comment-eval-${Date.now().toString(36)}`,
+      created_at: now,
+      author: "ai",
+      author_name: "Evaluation Agent",
+      content: `**Post-Ship Evaluation #${updatedVerification.evaluation_count}**
+
+**Status:** ${result.status.toUpperCase()}
+**Confidence:** ${result.confidence}
+
+${result.summary}
+
+**Metric Results:**
+${result.metric_evaluations.map((m) => `- ${m.status.toUpperCase()}: ${m.metric} \u2014 ${m.evidence}`).join("\n")}${followUpIds.length > 0 ? `
+
+**Follow-up ideas created:** ${followUpIds.join(", ")}` : ""}
+
+**Next evaluation:** ${nextEvalDate.toISOString().split("T")[0]}`
+    });
+    ideasData.ideas[ideaIndex].comments = comments;
+  }
+  saveJson(IDEAS_FILE, ideasData);
+  log(`Evaluation saved for ${ideaId}: status=${result.status}, next_eval=${nextEvalDate.toISOString().split("T")[0]}`);
+  return true;
+}
+function generateResearchTasks(idea, config, businessContext) {
+  const tasks = [];
+  const ideaContext = `
+Title: ${idea.title}
+Summary: ${idea.summary}
+Category: ${idea.category}
+Context: ${idea.context || "N/A"}
+Rationale: ${idea.rationale || "N/A"}
+Implementation Plan: ${idea.implementation_plan}
+`;
+  const competitors = businessContext?.competitors?.join(", ") || "industry competitors";
+  const locale = businessContext?.product?.locale;
+  const searchLang = locale?.startsWith("pt") ? "Search in both English and Portuguese for Brazil-specific approaches" : "Search for market-specific approaches";
+  const repoList = config?.repos?.map((r) => `- ${r.path} (${r.name}, ${r.type})`).join("\n") || "- Check available codebases";
+  const regulatory = businessContext?.regulatory;
+  const regulatorySection = regulatory?.length ? regulatory.map((r) => `- ${r}`).join("\n") : "- Consider regulatory and compliance requirements for this domain";
+  tasks.push({
+    id: "rt-001",
+    type: "competitor_analysis",
+    topic: `How do competitors solve: ${idea.title}`,
+    prompt: `You are researching competitor approaches to inform a product decision.
+
+## Idea Under Review
+${ideaContext}
+
+## Your Task
+Use WebSearch to research:
+1. How do competitors (${competitors}) solve this problem?
+2. What are industry best practices for this type of feature?
+3. ${searchLang}
+
+Respond with JSON only:
+{
+  "competitors_researched": ["name1", "name2"],
+  "findings": "Detailed markdown summary of what you found",
+  "best_practices": ["practice1", "practice2"],
+  "confidence": "high|medium|low",
+  "recommendation": "What we should learn from competitors"
+}`,
+    status: "pending",
+    started_at: null,
+    completed_at: null,
+    findings: null,
+    confidence: null,
+    error_message: null
+  });
+  tasks.push({
+    id: "rt-002",
+    type: "codebase_verification",
+    topic: `Verify codebase state for: ${idea.title}`,
+    prompt: `You are verifying assumptions about the codebase before implementing a feature.
+
+## Idea Under Review
+${ideaContext}
+
+## Your Task
+Use Glob, Grep, and Read tools to verify:
+1. Do the files/services mentioned in the implementation plan actually exist?
+2. What is the current state of related functionality?
+3. Are there any existing implementations we'd be duplicating?
+4. What dependencies or patterns should we follow?
+
+Check these codebases:
+${repoList}
+
+Respond with JSON only:
+{
+  "files_verified": ["path1", "path2"],
+  "existing_implementations": "What already exists",
+  "gaps_identified": "What's missing that we need",
+  "patterns_to_follow": ["pattern1", "pattern2"],
+  "confidence": "high|medium|low",
+  "recommendation": "Whether implementation plan is accurate"
+}`,
+    status: "pending",
+    started_at: null,
+    completed_at: null,
+    findings: null,
+    confidence: null,
+    error_message: null
+  });
+  tasks.push({
+    id: "rt-003",
+    type: "risk_assessment",
+    topic: `Identify risks for: ${idea.title}`,
+    prompt: `You are a risk analyst reviewing a product feature before implementation.
+
+## Idea Under Review
+${ideaContext}
+
+## Your Task
+Analyze potential risks:
+1. Technical risks (scalability, reliability, dependencies)
+2. Business risks (user adoption, cost, regulatory compliance)
+3. Security risks (data exposure, abuse potential)
+4. Operational risks (maintenance burden, monitoring needs)
+5. What could go wrong during implementation?
+
+Regulatory & compliance considerations:
+${regulatorySection}
+
+Respond with JSON only:
+{
+  "technical_risks": [{"risk": "...", "severity": "high|medium|low", "mitigation": "..."}],
+  "business_risks": [{"risk": "...", "severity": "high|medium|low", "mitigation": "..."}],
+  "security_risks": [{"risk": "...", "severity": "high|medium|low", "mitigation": "..."}],
+  "confidence": "high|medium|low",
+  "overall_risk_level": "high|medium|low",
+  "recommendation": "proceed|revise|reject with reasoning"
+}`,
+    status: "pending",
+    started_at: null,
+    completed_at: null,
+    findings: null,
+    confidence: null,
+    error_message: null
+  });
+  if (idea.effort === "m" || idea.effort === "l" || idea.effort === "xl") {
+    tasks.push({
+      id: "rt-004",
+      type: "alternative_approaches",
+      topic: `Alternative solutions for: ${idea.title}`,
+      prompt: `You are exploring alternative approaches to solve a problem.
+
+## Idea Under Review
+${ideaContext}
+
+## Your Task
+Research and propose 2-3 alternative approaches:
+1. What are different ways to solve this problem?
+2. What are the trade-offs of each approach?
+3. Is the proposed solution the best one, or is there a simpler/better way?
+
+Consider:
+- Build vs Buy (existing services, APIs)
+- Simpler MVP versions
+- Different technical approaches
+- Quick wins vs comprehensive solutions
+
+Respond with JSON only:
+{
+  "current_approach_summary": "Brief summary of proposed solution",
+  "alternatives": [
+    {
+      "name": "Alternative name",
+      "description": "How it works",
+      "pros": ["pro1", "pro2"],
+      "cons": ["con1", "con2"],
+      "effort_estimate": "xs|s|m|l|xl"
+    }
+  ],
+  "confidence": "high|medium|low",
+  "recommendation": "Which approach to pursue and why"
+}`,
+      status: "pending",
+      started_at: null,
+      completed_at: null,
+      findings: null,
+      confidence: null,
+      error_message: null
+    });
+  }
+  const searchPaths = (config?.repos || []).map((r) => {
+    if (r.type === "nextjs") return `Search in ${r.path}:
+- ${r.path}/src/app/**/*{keyword}*/**/*.tsx
+- ${r.path}/src/components/**/*{keyword}*.tsx
+- ${r.path}/src/lib/**/*{keyword}*.ts`;
+    if (r.type === "fastapi") return `Search in ${r.path}:
+- ${r.path}/app/**/*{keyword}*.py
+- Grep for function names, route decorators, service classes`;
+    return `Search in ${r.path}:
+- ${r.path}/**/*{keyword}*`;
+  }).join("\n\n");
+  tasks.push({
+    id: "rt-005",
+    type: "duplicate_detection",
+    topic: `Check if already implemented: ${idea.title}`,
+    prompt: `You are checking whether a proposed feature already exists in the codebase. This prevents wasting effort on duplicate implementations.
+
+## Idea Under Review
+${ideaContext}
+
+## Your Task
+
+### Step 1: Extract Keywords
+Extract keywords from the title and summary. Generate search variations:
+- Singular/plural forms
+- With/without hyphens and case variations
+- Abbreviations
+
+### Step 2: Search Codebases
+${searchPaths || "Search available codebases for matching files and patterns."}
+
+### Step 3: Functionality Search
+Use Grep to find related code patterns:
+- Hook names, function names, type definitions
+- API client methods
+- Check recent git log for commits that may have shipped this feature
+
+### Step 4: Verdict
+Assess overlap percentage (0-100%) and classify:
+- **PROCEED** (0-20% overlap): No duplicates found. Safe to implement.
+- **EXTEND** (20-70% overlap): Found existing code that partially does this. Recommend extending.
+- **INVESTIGATE** (70-90% overlap): Very similar implementation exists. Clarify scope first.
+- **STOP** (90-100% overlap): Feature already exists. Do not implement.
+
+Respond with JSON only:
+{
+  "keywords_searched": ["keyword1", "keyword2"],
+  "existing_routes": [{"path": "/route", "file": "...", "purpose": "..."}],
+  "existing_components": [{"name": "Component", "file": "...", "purpose": "..."}],
+  "existing_functions": [{"name": "functionName", "file": "...", "purpose": "..."}],
+  "backend_matches": [{"name": "service/endpoint", "file": "...", "purpose": "..."}],
+  "overlap_percentage": 0,
+  "verdict": "proceed|extend|investigate|stop",
+  "confidence": "high|medium|low",
+  "recommendation": "Detailed explanation of what exists and what's genuinely new"
+}`,
+    status: "pending",
+    started_at: null,
+    completed_at: null,
+    findings: null,
+    confidence: null,
+    error_message: null
+  });
+  return tasks;
+}
+async function executeSingleResearchTask(task) {
+  const TIMEOUT_MS = 3e5;
+  log(`  Starting research task: ${task.type} - ${task.topic}`);
+  task.status = "running";
+  task.started_at = (/* @__PURE__ */ new Date()).toISOString();
+  return new Promise((resolve) => {
+    const claude = (0, import_child_process3.spawn)("claude", ["--print", "--dangerously-skip-permissions"], {
+      cwd: ROOT_DIR,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    claude.stdin.write(task.prompt);
+    claude.stdin.end();
+    let output = "";
+    let errorOutput = "";
+    const timeout = setTimeout(() => {
+      claude.kill("SIGTERM");
+      task.status = "failed";
+      task.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+      task.error_message = "Timed out after 5 minutes";
+      log(`  Research task timed out: ${task.type}`);
+      resolve(task);
+    }, TIMEOUT_MS);
+    claude.stdout.on("data", (data) => {
+      output += data.toString();
+    });
+    claude.stderr.on("data", (data) => {
+      errorOutput += data.toString();
+    });
+    claude.on("close", (code) => {
+      clearTimeout(timeout);
+      task.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+      if (code === 0 && output.trim()) {
+        try {
+          let jsonStr = output.trim();
+          const jsonMatch = jsonStr.match(/```(?:json)?\s*([\s\S]*?)```/);
+          if (jsonMatch) jsonStr = jsonMatch[1].trim();
+          const objectMatch = jsonStr.match(/\{[\s\S]*\}/);
+          if (objectMatch) {
+            const parsed = JSON.parse(objectMatch[0]);
+            task.status = "completed";
+            task.findings = JSON.stringify(parsed, null, 2);
+            task.confidence = parsed.confidence || "medium";
+            log(`  Research task completed: ${task.type} (confidence: ${task.confidence})`);
+          } else {
+            task.status = "completed";
+            task.findings = output.trim();
+            task.confidence = "low";
+            log(`  Research task completed (raw output): ${task.type}`);
+          }
+        } catch {
+          task.status = "completed";
+          task.findings = output.trim();
+          task.confidence = "low";
+          log(`  Research task completed (parse error): ${task.type}`);
+        }
+      } else {
+        task.status = "failed";
+        task.error_message = errorOutput || `Exited with code ${code}`;
+        log(`  Research task failed: ${task.type} - ${task.error_message}`);
+      }
+      resolve(task);
+    });
+    claude.on("error", (error) => {
+      clearTimeout(timeout);
+      task.status = "failed";
+      task.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+      task.error_message = error.message;
+      log(`  Research task error: ${task.type} - ${error.message}`);
+      resolve(task);
+    });
+  });
+}
+async function executeParallelResearch(idea, config, businessContext) {
+  log(`Starting parallel research for idea: ${idea.id}`);
+  const research = {
+    started_at: (/* @__PURE__ */ new Date()).toISOString(),
+    completed_at: null,
+    tasks: generateResearchTasks(idea, config, businessContext),
+    summary: null,
+    recommendation: null
+  };
+  log(`Generated ${research.tasks.length} research tasks, executing in parallel...`);
+  const completedTasks = await Promise.all(
+    research.tasks.map((task) => executeSingleResearchTask(task))
+  );
+  research.tasks = completedTasks;
+  research.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+  const successfulTasks = completedTasks.filter((t) => t.status === "completed");
+  const failedTasks = completedTasks.filter((t) => t.status === "failed");
+  log(`Research complete: ${successfulTasks.length}/${completedTasks.length} tasks succeeded`);
+  if (successfulTasks.length > 0) {
+    await aggregateResearchFindings(research);
+  }
+  if (failedTasks.length === completedTasks.length) {
+    research.recommendation = "revise";
+    research.summary = "All research tasks failed. Manual review required.";
+  }
+  return research;
+}
+async function aggregateResearchFindings(research) {
+  const TIMEOUT_MS = 12e4;
+  const findingsSummary = research.tasks.filter((t) => t.status === "completed" && t.findings).map((t) => `### ${t.type}
+${t.findings}`).join("\n\n");
+  const prompt = `You are synthesizing research findings to make a recommendation.
+
+## Research Findings
+
+${findingsSummary}
+
+## Your Task
+
+Synthesize these findings into:
+1. A brief executive summary (2-3 sentences)
+2. Key insights from each research track
+3. An overall recommendation: proceed, revise, or reject
+
+IMPORTANT: If the duplicate_detection task found significant overlap (verdict: "stop" or "investigate"), you MUST recommend "reject" and explain what already exists. Only recommend "proceed" if duplicate detection confirms no significant overlap.
+
+Respond with JSON only:
+{
+  "executive_summary": "2-3 sentence summary",
+  "key_insights": ["insight1", "insight2", "insight3"],
+  "risks_identified": ["risk1", "risk2"],
+  "recommendation": "proceed|revise|reject",
+  "recommendation_reasoning": "Why this recommendation"
+}`;
+  return new Promise((resolve) => {
+    const claude = (0, import_child_process3.spawn)("claude", ["--print"], {
+      cwd: ROOT_DIR,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    claude.stdin.write(prompt);
+    claude.stdin.end();
+    let output = "";
+    const timeout = setTimeout(() => {
+      claude.kill("SIGTERM");
+      research.summary = findingsSummary;
+      research.recommendation = "revise";
+      resolve();
+    }, TIMEOUT_MS);
+    claude.stdout.on("data", (data) => {
+      output += data.toString();
+    });
+    claude.on("close", (code) => {
+      clearTimeout(timeout);
+      if (code === 0 && output.trim()) {
+        try {
+          let jsonStr = output.trim();
+          const jsonMatch = jsonStr.match(/```(?:json)?\s*([\s\S]*?)```/);
+          if (jsonMatch) jsonStr = jsonMatch[1].trim();
+          const objectMatch = jsonStr.match(/\{[\s\S]*\}/);
+          if (objectMatch) {
+            const parsed = JSON.parse(objectMatch[0]);
+            research.summary = `**Executive Summary:** ${parsed.executive_summary}
+
+**Key Insights:**
+${parsed.key_insights.map((i) => `- ${i}`).join("\n")}
+
+**Risks:**
+${parsed.risks_identified?.map((r) => `- ${r}`).join("\n") || "None identified"}
+
+**Reasoning:** ${parsed.recommendation_reasoning}`;
+            research.recommendation = parsed.recommendation;
+            log(`Research aggregation complete: ${research.recommendation}`);
+          }
+        } catch {
+          research.summary = findingsSummary;
+          research.recommendation = "revise";
+        }
+      } else {
+        research.summary = findingsSummary;
+        research.recommendation = "revise";
+      }
+      resolve();
+    });
+    claude.on("error", () => {
+      clearTimeout(timeout);
+      research.summary = findingsSummary;
+      research.recommendation = "revise";
+      resolve();
+    });
+  });
+}
+async function executeIdeaResearch(ideaId, config, businessContext) {
+  log(`Executing parallel research for idea: ${ideaId}`);
+  const ideasData = loadJson(IDEAS_FILE, { ideas: [] });
+  const idea = ideasData.ideas.find((i) => i.id === ideaId);
+  if (!idea) {
+    log(`Idea not found: ${ideaId}`);
+    return false;
+  }
+  if (idea.stage !== "under_review") {
+    if (idea.stage === "inbox") {
+      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);
+    } else {
+      log(`Idea ${ideaId} is not in under_review stage (current: ${idea.stage})`);
+      return false;
+    }
+  }
+  if (idea.research?.completed_at) {
+    log(`Research already completed for idea ${ideaId}`);
+    return true;
+  }
+  const research = await executeParallelResearch(idea, config, businessContext);
+  idea.research = research;
+  idea.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+  const dupTask = research.tasks.find((t) => t.type === "duplicate_detection" && t.status === "completed" && t.findings);
+  if (dupTask?.findings) {
+    try {
+      let jsonStr = dupTask.findings;
+      const objectMatch = jsonStr.match(/\{[\s\S]*\}/);
+      if (objectMatch) {
+        const parsed = JSON.parse(objectMatch[0]);
+        const verdict = parsed.verdict;
+        if (["proceed", "extend", "investigate", "stop"].includes(verdict)) {
+          idea.verification_status = verdict;
+          log(`Duplicate detection verdict for ${ideaId}: ${verdict} (${parsed.overlap_percentage}% overlap)`);
+        }
+      }
+    } catch {
+      log(`Failed to parse duplicate detection findings for ${ideaId}`);
+    }
+  }
+  if (research.summary) {
+    const comments = idea.comments || [];
+    comments.push({
+      id: `comment-research-${Date.now().toString(36)}`,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      author: "ai",
+      author_name: "Research Agent",
+      content: `**Parallel Research Complete**
+
+${research.summary}
+
+**Recommendation:** ${research.recommendation?.toUpperCase() || "REVIEW NEEDED"}`
+    });
+    idea.comments = comments;
+  }
+  saveJson(IDEAS_FILE, ideasData);
+  log(`Research saved for idea ${ideaId}: recommendation = ${research.recommendation}`);
+  return true;
+}
+async function executeTask(task, config, businessContext) {
+  const taskId = "task_id" in task ? task.task_id : task.id;
+  const taskDesc = "task_id" in task ? task.description : task.description;
+  log(`Executing task: ${taskId} \u2014 ${taskDesc}`);
+  const taskTypePrefix = taskId.split("-").slice(0, 2).join("-");
+  if (DRY_RUN) {
+    log("[DRY RUN] Would execute task but skipping");
+    return true;
+  }
+  try {
+    switch (taskId) {
+      case "review-inbox":
+        await executeReviewInbox();
+        return true;
+      case "refresh-kpis":
+        log("KPIs already refreshed in this heartbeat");
+        return true;
+      case "quick-analysis":
+        await runAnalysis("quick");
+        return true;
+      case "deep-analysis":
+        await runAnalysis("deep");
+        return true;
+      case "metrics-analysis":
+        await runAnalysis("metrics");
+        return true;
+      case "seo-audit":
+        await runAnalysis("seo");
+        return true;
+      default:
+        if (taskId.startsWith("evaluate-shipped-")) {
+          const ideaId = taskId.replace("evaluate-shipped-", "");
+          return await executeShippedEvaluation(ideaId);
+        }
+        if (taskId.startsWith("implement-")) {
+          const ideaId = taskId.replace("implement-", "");
+          return await executeAutonomousImplementation(ideaId);
+        }
+        if (taskId.startsWith("goal-gap-research-")) {
+          const goalId = taskId.replace("goal-gap-research-", "");
+          return await executeGoalGapResearch(goalId);
+        }
+        if (taskId.startsWith("research-idea-")) {
+          const ideaId = taskId.replace("research-idea-", "");
+          return await executeIdeaResearch(ideaId, config, businessContext);
+        }
+        if (taskId.startsWith("research-")) {
+          return await executeResearchTask(taskId, taskDesc);
+        }
+        if (isBusinessIntelTask(taskId)) {
+          const result = await executeBusinessIntelTask(taskId, taskDesc, businessContext);
+          log(`Business intel task result: ${result.success ? "SUCCESS" : "FAILED"} \u2014 ${result.output.slice(0, 200)}`);
+          trackEvent("heartbeat_task", { taskType: taskTypePrefix, success: result.success });
+          return result.success;
+        }
+        if (isContentTask(taskId)) {
+          const contentflowConfig = businessContext?.contentflow;
+          const result = await executeContentTask(taskId, taskDesc, contentflowConfig);
+          log(`Content task result: ${result.success ? "SUCCESS" : "FAILED"} \u2014 ${result.output.slice(0, 200)}`);
+          trackEvent("heartbeat_task", { taskType: taskTypePrefix, success: result.success });
+          return result.success;
+        }
+        return await executeMetaTask(taskId, taskDesc, businessContext);
+    }
+  } catch (error) {
+    log(`Task failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    trackEvent("heartbeat_task", { taskType: taskTypePrefix, success: false, errorType: error instanceof Error ? error.constructor.name : "unknown" });
+    return false;
+  }
+}
+async function executeReviewInbox() {
+  const ideasData = loadJson(IDEAS_FILE, { ideas: [] });
+  const inboxIdeas = ideasData.ideas.filter((i) => i.stage === "inbox");
+  if (inboxIdeas.length === 0) {
+    log("No ideas in inbox to review");
+    return;
+  }
+  log(`Reviewing ${inboxIdeas.length} ideas in inbox...`);
+  for (const idea of inboxIdeas) {
+    const days = daysSince(idea.created_at);
+    log(`  - ${idea.id}: "${idea.title}" (${days} days old)`);
+  }
+  log("Inbox review complete (manual prioritization needed)");
+}
+async function runAnalysis(type) {
+  return new Promise((resolve, reject) => {
+    log(`Running ${type} analysis...`);
+    const { command: runCmd, args: runArgs } = resolveScript(__dirname, "analyze.ts");
+    const childProcess = (0, import_child_process3.spawn)(runCmd, [...runArgs, `--type=${type}`], {
+      cwd: ROOT_DIR,
+      stdio: "inherit"
+    });
+    childProcess.on("close", (code) => {
+      if (code === 0) {
+        log(`${type} analysis completed successfully`);
+        resolve();
+      } else {
+        reject(new Error(`Analysis exited with code ${code}`));
+      }
+    });
+    childProcess.on("error", (error) => {
+      reject(error);
+    });
+  });
+}
+function updateTodoFile(taskId, completed) {
+  try {
+    let content = fs6.readFileSync(TODO_FILE, "utf-8");
+    const uncheckedPattern = new RegExp(`- \\[ \\] \`${taskId}\``, "g");
+    const checkedPattern = new RegExp(`- \\[x\\] \`${taskId}\``, "g");
+    if (completed) {
+      content = content.replace(uncheckedPattern, `- [x] \`${taskId}\``);
+    } else {
+      content = content.replace(checkedPattern, `- [ ] \`${taskId}\``);
+    }
+    fs6.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"}`);
+  }
+}
+function generateStatusContent(state, alerts, nextTask, reasoning) {
+  const now = /* @__PURE__ */ new Date();
+  const currentGoal = state.goals[0];
+  const goalSection = currentGoal ? `- **Goal:** ${currentGoal.title} (${currentGoal.target_value}${currentGoal.target_unit} by Q2 2026)
+- **Status:** ${currentGoal.status}
+- **Current Value:** ${currentGoal.current_value !== null ? `${currentGoal.current_value}${currentGoal.target_unit}` : "Not yet measured"}
+- **Progress:** ${currentGoal.current_value !== null ? `${Math.round(currentGoal.current_value / currentGoal.target_value * 100)}%` : "N/A"}` : "- No active goals";
+  const kpiRows = currentGoal?.kpis.map((k) => {
+    const status = k.current_value !== null && k.target_value !== null ? k.direction === "higher_is_better" ? k.current_value >= k.target_value ? "\u2705" : "\u26A0\uFE0F" : k.current_value <= k.target_value ? "\u2705" : "\u26A0\uFE0F" : "\u2014";
+    return `| ${k.name} | ${k.current_value ?? "\u2014"} | ${k.target_value ?? "\u2014"} | ${k.unit} | ${status} |`;
+  }).join("\n") || "| \u2014 | \u2014 | \u2014 | \u2014 | \u2014 |";
+  const activeIdeas = state.ideas.filter((i) => i.stage === "in_progress");
+  const activeWorkRows = activeIdeas.length > 0 ? activeIdeas.map((i) => `| ${i.id} | ${i.title} | in_progress | ${i.implementation.branch_name || "\u2014"} |`).join("\n") : "| \u2014 | No active work | \u2014 | \u2014 |";
+  const inboxIdeas = state.ideas.filter((i) => i.stage === "inbox");
+  const pendingRows = inboxIdeas.length > 0 ? inboxIdeas.map((i) => `| ${i.id} | ${i.title} | ${daysSince(i.created_at)} |`).join("\n") : "| \u2014 | No ideas pending review | \u2014 |";
+  const alertsSection = alerts.length > 0 ? alerts.map((a) => `- ${a}`).join("\n") : "- None";
+  const analysisSection = reasoning ? `**Analysis:** ${reasoning.analysis}
+
+**Critical Issue:** ${reasoning.critical_issue || "None identified"}
+
+**Recommended Action:** ${reasoning.next_action ? `${reasoning.next_action.task_id} \u2014 ${reasoning.next_action.description}` : "None"}` : "*Claude reasoning was skipped*";
+  const recentSessions = state.sessions.filter((s) => s.status === "completed").slice(-5).reverse();
+  const activityRows = [
+    `| ${formatDate(now)} | Heartbeat check-in |`,
+    ...recentSessions.map(
+      (s) => `| ${formatDate(new Date(s.completed_at || s.created_at))} | ${s.type} analysis completed (${s.ideas_generated.length} ideas) |`
+    )
+  ].join("\n");
+  const nextScheduled = nextTask ? `${nextTask.description}` : "No scheduled tasks pending";
+  return `# Analyst Status
+
+**Last Heartbeat:** ${formatDateTime(now)}
+**Next Scheduled:** ${nextScheduled}
+
+## Current Focus
+
+${goalSection}
+
+## KPI Dashboard
+
+| KPI | Current | Target | Unit | Status |
+|-----|---------|--------|------|--------|
+${kpiRows}
+
+## AI Analysis
+
+${analysisSection}
+
+## Active Work
+
+| ID | Title | Stage | Branch |
+|----|-------|-------|--------|
+${activeWorkRows}
+
+## Pending Review
+
+| ID | Title | Days in Inbox |
+|----|-------|---------------|
+${pendingRows}
+
+## Alerts
+
+${alertsSection}
+
+## Recent Activity
+
+| Date | Event |
+|------|-------|
+${activityRows}
+
+---
+
+*This file is updated automatically by the heartbeat script.*
+`;
+}
+async function runSingleHeartbeat(beatNumber = 1) {
+  const startTime = Date.now();
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  capturedLogs = [];
+  isCapturingLogs = true;
+  try {
+    log("=== Heartbeat Check-in Started ===");
+    const commandsDir = path6.join(PROJECT_DIR, ".claude", "commands");
+    if (!fs6.existsSync(commandsDir)) {
+      log("Slash commands missing \u2014 auto-scaffolding...");
+      scaffoldSlashCommands(PROJECT_DIR);
+    }
+    if (DRY_RUN) {
+      log("Running in DRY RUN mode \u2014 no changes will be made");
+    }
+    if (SKIP_REASONING) {
+      log("Skipping Claude reasoning step");
+    }
+    const state = loadState();
+    const businessContext = loadBusinessContext();
+    const heartbeatConfig = loadConfig();
+    log(`Loaded state: ${state.ideas.length} ideas, ${state.goals.length} goals, ${state.sessions.length} sessions`);
+    if (!DRY_RUN) {
+      archiveCompletedTodos();
+      pruneStaleScheduledTodos(state);
+    }
+    const alerts = checkAlerts(state);
+    if (alerts.length > 0) {
+      log(`Found ${alerts.length} alert(s):`);
+      alerts.forEach((a) => log(`  - ${a}`));
+    } else {
+      log("No alerts");
+    }
+    const backendHealthy = await checkBackendHealth();
+    const liveKPIs = backendHealthy ? await fetchLiveKPIs() : null;
+    state.liveData = {
+      kpis: liveKPIs,
+      backendHealthy
+    };
+    if (liveKPIs && !DRY_RUN) {
+      updateGoalsWithKPIs(liveKPIs);
+      const updatedGoals = loadJson(GOALS_FILE, { goals: [] });
+      state.goals = updatedGoals.goals;
+      updateBusinessContext(businessContext, liveKPIs);
+      log("Updated business context with live KPIs");
+    }
+    let reasoning = null;
+    if (!SKIP_REASONING) {
+      reasoning = await runClaudeReasoning(state, alerts, businessContext);
+    }
+    let taskToDo = null;
+    if (reasoning?.next_action) {
+      log(`Claude recommends: ${reasoning.next_action.task_id} \u2014 ${reasoning.next_action.description}`);
+      const existingTask = state.todos.find((t) => t.id === reasoning.next_action.task_id);
+      if (existingTask) {
+        taskToDo = existingTask;
+      } else {
+        const success = await executeTask(reasoning.next_action, heartbeatConfig, businessContext);
+        if (!success) {
+          taskToDo = determineWork(state);
+        }
+      }
+    } else {
+      taskToDo = determineWork(state);
+    }
+    if (taskToDo) {
+      log(`Task to do: ${taskToDo.id} \u2014 ${taskToDo.description}`);
+      const success = await executeTask(taskToDo, heartbeatConfig, businessContext);
+      if (success && !DRY_RUN) {
+        if (!["quick-analysis", "deep-analysis", "metrics-analysis", "seo-audit"].includes(taskToDo.id)) {
+          updateTodoFile(taskToDo.id, true);
+        }
+      } else if (!success && !taskToDo.id.startsWith("implement-")) {
+        const config = loadConfig();
+        if (config.autonomy?.enabled) {
+          const inProgressIdeas = state.ideas.filter((i) => i.stage === "in_progress");
+          for (const idea of inProgressIdeas) {
+            const subTasks = idea.implementation.sub_tasks || [];
+            const hasPending = subTasks.some((st) => st.status === "pending");
+            const hasFailed = subTasks.some((st) => st.status === "failed");
+            if ((subTasks.length === 0 || hasPending) && !hasFailed) {
+              log(`Falling through to autonomy: implement-${idea.id}`);
+              await executeAutonomousImplementation(idea.id);
+              break;
+            }
+          }
+          if (!inProgressIdeas.some((i) => (i.implementation.sub_tasks || []).some((st) => st.status === "pending"))) {
+            const approvedIdeas = state.ideas.filter((i) => i.stage === "approved");
+            if (approvedIdeas.length > 0) {
+              log(`Falling through to autonomy: implement-${approvedIdeas[0].id}`);
+              await executeAutonomousImplementation(approvedIdeas[0].id);
+            }
+          }
+        }
+      }
+    } else {
+      log("No tasks to do right now");
+    }
+    if (reasoning?.new_todos && reasoning.new_todos.length > 0 && !DRY_RUN) {
+      addTasksToTodo(reasoning.new_todos);
+    }
+    if (reasoning?.learnings && reasoning.learnings.length > 0 && !DRY_RUN) {
+      appendToMemory(reasoning.learnings);
+    }
+    if (!DRY_RUN) {
+      const statusContent = generateStatusContent(state, alerts, taskToDo, reasoning);
+      fs6.writeFileSync(STATUS_FILE, statusContent);
+      log("Updated STATUS.md");
+    } else {
+      log("[DRY RUN] Would update STATUS.md");
+    }
+    log("=== Heartbeat Check-in Complete ===");
+    isCapturingLogs = false;
+    return {
+      heartbeat_number: beatNumber,
+      started_at: startedAt,
+      completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+      duration_ms: Date.now() - startTime,
+      alerts_count: alerts.length,
+      kpis_updated: !!liveKPIs,
+      claude_analysis: reasoning?.analysis || null,
+      task_executed: taskToDo?.id || null,
+      todos_added: reasoning?.new_todos?.length || 0,
+      learnings_added: reasoning?.learnings?.length || 0,
+      success: true,
+      error_message: null,
+      logs: [...capturedLogs]
+    };
+  } catch (error) {
+    isCapturingLogs = false;
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    log(`ERROR: Heartbeat failed \u2014 ${errorMessage}`);
+    if (error instanceof Error && error.stack) {
+      log(error.stack);
+    }
+    return {
+      heartbeat_number: beatNumber,
+      started_at: startedAt,
+      completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+      duration_ms: Date.now() - startTime,
+      alerts_count: 0,
+      kpis_updated: false,
+      claude_analysis: null,
+      task_executed: null,
+      todos_added: 0,
+      learnings_added: 0,
+      success: false,
+      error_message: errorMessage,
+      logs: [...capturedLogs]
+    };
+  }
+}
+function generateSessionSummary(sessionId, startedAt, heartbeats) {
+  const completedAt = /* @__PURE__ */ new Date();
+  const durations = heartbeats.map((h) => h.duration_ms);
+  return {
+    id: sessionId,
+    started_at: startedAt.toISOString(),
+    completed_at: completedAt.toISOString(),
+    duration_seconds: Math.round((completedAt.getTime() - startedAt.getTime()) / 1e3),
+    interval_minutes: INTERVAL_MINUTES,
+    total_heartbeats: heartbeats.length,
+    successful_heartbeats: heartbeats.filter((h) => h.success).length,
+    failed_heartbeats: heartbeats.filter((h) => !h.success).length,
+    total_alerts: heartbeats.reduce((sum, h) => sum + h.alerts_count, 0),
+    total_kpi_updates: heartbeats.filter((h) => h.kpis_updated).length,
+    total_todos_added: heartbeats.reduce((sum, h) => sum + h.todos_added, 0),
+    total_learnings: heartbeats.reduce((sum, h) => sum + h.learnings_added, 0),
+    tasks_executed: heartbeats.map((h) => h.task_executed).filter(Boolean),
+    key_insights: heartbeats.map((h) => h.claude_analysis).filter(Boolean),
+    avg_heartbeat_ms: durations.length > 0 ? Math.round(durations.reduce((a, b) => a + b, 0) / durations.length) : 0,
+    min_heartbeat_ms: durations.length > 0 ? Math.min(...durations) : 0,
+    max_heartbeat_ms: durations.length > 0 ? Math.max(...durations) : 0,
+    heartbeats
+  };
+}
+function printSessionSummary(summary) {
+  console.log(`
+${"=".repeat(60)}`);
+  console.log(`  SESSION COMPLETE: ${summary.id}`);
+  console.log(`${"=".repeat(60)}`);
+  console.log(`
+Duration:     ${Math.round(summary.duration_seconds / 60)} minutes
+Heartbeats:   ${summary.successful_heartbeats}/${summary.total_heartbeats} successful
+
+ACTIVITY:
+  - Alerts detected:    ${summary.total_alerts}
+  - KPI updates:        ${summary.total_kpi_updates}
+  - TODOs added:        ${summary.total_todos_added}
+  - Learnings recorded: ${summary.total_learnings}
+  - Tasks executed:     ${summary.tasks_executed.length}
+
+TIMING:
+  - Avg heartbeat: ${Math.round(summary.avg_heartbeat_ms / 1e3)}s
+  - Min heartbeat: ${Math.round(summary.min_heartbeat_ms / 1e3)}s
+  - Max heartbeat: ${Math.round(summary.max_heartbeat_ms / 1e3)}s`);
+  if (summary.key_insights.length > 0) {
+    console.log("\nKEY INSIGHTS:");
+    summary.key_insights.forEach((insight, i) => {
+      const truncated = insight.length > 100 ? insight.substring(0, 100) + "..." : insight;
+      console.log(`  ${i + 1}. ${truncated}`);
+    });
+  }
+  if (summary.tasks_executed.length > 0) {
+    console.log("\nTASKS EXECUTED:");
+    summary.tasks_executed.forEach((task) => {
+      console.log(`  - ${task}`);
+    });
+  }
+  const failedBeats = summary.heartbeats.filter((h) => !h.success);
+  if (failedBeats.length > 0) {
+    console.log("\nFAILED HEARTBEATS:");
+    failedBeats.forEach((h) => {
+      console.log(`  - #${h.heartbeat_number}: ${h.error_message}`);
+    });
+  }
+  console.log(`
+${"=".repeat(60)}
+`);
+}
+function saveSessionToJson(summary) {
+  const sessionsFile = path6.join(DATA_DIR, "heartbeat-sessions.json");
+  const sessionsData = loadJson(sessionsFile, { sessions: [] });
+  sessionsData.sessions.push(summary);
+  if (sessionsData.sessions.length > 50) {
+    sessionsData.sessions = sessionsData.sessions.slice(-50);
+  }
+  saveJson(sessionsFile, sessionsData);
+  log(`Session saved to ${sessionsFile}`);
+}
+async function runContinuousSession() {
+  const sessionId = `session-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+  const startedAt = /* @__PURE__ */ new Date();
+  const durationMs = DURATION_MINUTES * 60 * 1e3;
+  const intervalMs = INTERVAL_MINUTES * 60 * 1e3;
+  const endTime = HEARTBEAT_COUNT > 0 ? Infinity : startedAt.getTime() + durationMs;
+  const maxBeats = HEARTBEAT_COUNT > 0 ? HEARTBEAT_COUNT : Math.ceil(DURATION_MINUTES / INTERVAL_MINUTES);
+  console.log(`
+${"=".repeat(60)}`);
+  console.log(`  CONTINUOUS SESSION: ${sessionId}`);
+  if (HEARTBEAT_COUNT > 0) {
+    console.log(`  Count: ${HEARTBEAT_COUNT} heartbeats | Interval: ${INTERVAL_MINUTES} minutes`);
+  } else {
+    console.log(`  Duration: ${DURATION_MINUTES} minutes | Interval: ${INTERVAL_MINUTES} minutes`);
+  }
+  console.log(`  Max heartbeats: ${maxBeats}`);
+  console.log(`${"=".repeat(60)}
+`);
+  const heartbeats = [];
+  let beatNumber = 0;
+  while (Date.now() < endTime && (HEARTBEAT_COUNT === 0 || beatNumber < HEARTBEAT_COUNT)) {
+    beatNumber++;
+    const beatStart = Date.now();
+    console.log(`
+--- Heartbeat #${beatNumber} ---
+`);
+    const result = await runSingleHeartbeat(beatNumber);
+    heartbeats.push(result);
+    if (!result.success) {
+      log(`Heartbeat #${beatNumber} failed: ${result.error_message}`);
+    }
+    const isLastBeat = HEARTBEAT_COUNT > 0 ? beatNumber >= HEARTBEAT_COUNT : Date.now() + intervalMs > endTime;
+    if (!isLastBeat) {
+      const elapsed = Date.now() - beatStart;
+      const waitTime = Math.max(0, intervalMs - elapsed);
+      if (waitTime > 0) {
+        const nextBeatAt = new Date(Date.now() + waitTime);
+        console.log(`
+[SESSION] Next heartbeat in ${Math.round(waitTime / 1e3)}s (${nextBeatAt.toLocaleTimeString()})`);
+        await sleep(waitTime);
+      }
+    }
+  }
+  const summary = generateSessionSummary(sessionId, startedAt, heartbeats);
+  saveSessionToJson(summary);
+  printSessionSummary(summary);
+  return summary;
+}
+async function main() {
+  if (SESSION_MODE) {
+    await runContinuousSession();
+  } else {
+    await runSingleHeartbeat();
+  }
+}
+main().catch((error) => {
+  console.error("Heartbeat failed:", error);
+  process.exit(1);
+});