@samboyd/bep-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,3349 @@
+#!/usr/bin/env node
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(cli_exports);
+var import_commander = require("commander");
+
+// src/fs/init.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"));
+
+// src/providers/config.ts
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"));
+var PROVIDER_CONFIG_PATH = ".bep.providers.json";
+async function readProviderConfig(rootDir) {
+  const configPath = import_node_path.default.join(rootDir, PROVIDER_CONFIG_PATH);
+  let raw;
+  try {
+    raw = await (0, import_promises.readFile)(configPath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return {
+        ok: false,
+        error: `Missing provider config at ${PROVIDER_CONFIG_PATH}. Run 'bep init' to scaffold it.`
+      };
+    }
+    return {
+      ok: false,
+      error: `Failed to read provider config at ${PROVIDER_CONFIG_PATH}: ${error.message}`
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    return {
+      ok: false,
+      error: `Invalid JSON in ${PROVIDER_CONFIG_PATH}: ${error.message}`
+    };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { ok: false, error: `${PROVIDER_CONFIG_PATH} must contain a JSON object.` };
+  }
+  const config = parsed;
+  return { ok: true, value: config };
+}
+function getMixpanelServiceAccountCreds(config) {
+  if (!config.mixpanel || typeof config.mixpanel !== "object") {
+    return {
+      ok: false,
+      error: `Missing "mixpanel" object in ${PROVIDER_CONFIG_PATH}.`
+    };
+  }
+  if (typeof config.mixpanel.service_account_creds !== "string" || config.mixpanel.service_account_creds.trim().length === 0) {
+    return {
+      ok: false,
+      error: `Missing non-empty "mixpanel.service_account_creds" in ${PROVIDER_CONFIG_PATH}.`
+    };
+  }
+  const creds = config.mixpanel.service_account_creds.trim();
+  const colonIndex = creds.indexOf(":");
+  if (colonIndex <= 0 || colonIndex !== creds.lastIndexOf(":") || colonIndex === creds.length - 1) {
+    return {
+      ok: false,
+      error: `Invalid "mixpanel.service_account_creds" in ${PROVIDER_CONFIG_PATH}. Expected "<serviceaccount_username>:<serviceaccount_secret>".`
+    };
+  }
+  return { ok: true, value: creds };
+}
+
+// src/fs/init.ts
+var BETS_DIR = "bets";
+var LOGS_DIR = import_node_path2.default.join(BETS_DIR, "_logs");
+var EVIDENCE_DIR = import_node_path2.default.join(BETS_DIR, "_evidence");
+var STATE_PATH = import_node_path2.default.join(BETS_DIR, "_state.json");
+var GITIGNORE_PATH = ".gitignore";
+var PROVIDER_GITIGNORE_ENTRY = ".bep.providers.json";
+var DEFAULT_STATE = {
+  active: []
+};
+var DEFAULT_PROVIDER_CONFIG = {
+  mixpanel: {
+    service_account_creds: "<serviceaccount_username>:<serviceaccount_secret>"
+  }
+};
+var REQUIRED_INIT_PATHS = [BETS_DIR, LOGS_DIR, EVIDENCE_DIR, STATE_PATH];
+async function pathExists(filePath) {
+  try {
+    await (0, import_promises2.access)(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function initRepo(rootDir) {
+  const createdPaths = [];
+  for (const relativeDir of [BETS_DIR, LOGS_DIR, EVIDENCE_DIR]) {
+    const absoluteDir = import_node_path2.default.join(rootDir, relativeDir);
+    const existed = await pathExists(absoluteDir);
+    await (0, import_promises2.mkdir)(absoluteDir, { recursive: true });
+    if (!existed) {
+      createdPaths.push(relativeDir);
+    }
+  }
+  const statePath = import_node_path2.default.join(rootDir, STATE_PATH);
+  const stateExists = await pathExists(statePath);
+  if (!stateExists) {
+    await (0, import_promises2.writeFile)(statePath, `${JSON.stringify(DEFAULT_STATE, null, 2)}
+`, "utf8");
+    createdPaths.push(STATE_PATH);
+  }
+  const providerConfigPath = import_node_path2.default.join(rootDir, PROVIDER_CONFIG_PATH);
+  const providerConfigExists = await pathExists(providerConfigPath);
+  if (!providerConfigExists) {
+    await (0, import_promises2.writeFile)(providerConfigPath, `${JSON.stringify(DEFAULT_PROVIDER_CONFIG, null, 2)}
+`, "utf8");
+    createdPaths.push(PROVIDER_CONFIG_PATH);
+  }
+  const gitRoot = await findGitRepoRoot(rootDir);
+  if (gitRoot) {
+    await ensureGitignoreEntry(gitRoot, createdPaths);
+  }
+  return {
+    createdPaths,
+    alreadyInitialized: createdPaths.length === 0
+  };
+}
+async function findGitRepoRoot(startDir) {
+  let currentDir = import_node_path2.default.resolve(startDir);
+  while (true) {
+    if (await pathExists(import_node_path2.default.join(currentDir, ".git"))) {
+      return currentDir;
+    }
+    const parentDir = import_node_path2.default.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+async function ensureGitignoreEntry(gitRoot, createdPaths) {
+  const gitignorePath = import_node_path2.default.join(gitRoot, GITIGNORE_PATH);
+  const exists = await pathExists(gitignorePath);
+  if (!exists) {
+    await (0, import_promises2.writeFile)(gitignorePath, `${PROVIDER_GITIGNORE_ENTRY}
+`, "utf8");
+    createdPaths.push(GITIGNORE_PATH);
+    return;
+  }
+  const raw = await (0, import_promises2.readFile)(gitignorePath, "utf8");
+  const lines = raw.split(/\r?\n/);
+  if (lines.includes(PROVIDER_GITIGNORE_ENTRY)) {
+    return;
+  }
+  const suffix = raw.length === 0 || raw.endsWith("\n") ? "" : "\n";
+  await (0, import_promises2.writeFile)(gitignorePath, `${raw}${suffix}${PROVIDER_GITIGNORE_ENTRY}
+`, "utf8");
+}
+async function isInitializedRepoRoot(candidateRootDir) {
+  for (const relativePath of REQUIRED_INIT_PATHS) {
+    const absolutePath = import_node_path2.default.join(candidateRootDir, relativePath);
+    if (!await pathExists(absolutePath)) {
+      return false;
+    }
+  }
+  return true;
+}
+async function findInitializedRepo(startDir) {
+  let currentDir = import_node_path2.default.resolve(startDir);
+  while (true) {
+    if (await isInitializedRepoRoot(currentDir)) {
+      return {
+        rootDir: currentDir,
+        betsDir: import_node_path2.default.join(currentDir, BETS_DIR)
+      };
+    }
+    const parentDir = import_node_path2.default.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+async function ensureInitializedRepo(startDir) {
+  const found = await findInitializedRepo(startDir);
+  if (!found) {
+    throw new Error("fatal: not a bep repository (or any of the parent directories): bets");
+  }
+  return found;
+}
+
+// src/hooks/install.ts
+var import_node_path5 = __toESM(require("path"));
+
+// src/hooks/discovery.ts
+var import_promises3 = require("fs/promises");
+var import_node_path3 = __toESM(require("path"));
+async function findNearestClaudeDir(startDir) {
+  let currentDir = import_node_path3.default.resolve(startDir);
+  while (true) {
+    const candidate = import_node_path3.default.join(currentDir, ".claude");
+    try {
+      const stats = await (0, import_promises3.stat)(candidate);
+      if (stats.isDirectory()) {
+        return candidate;
+      }
+    } catch {
+    }
+    const parentDir = import_node_path3.default.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+
+// src/hooks/claude.ts
+var import_promises4 = require("fs/promises");
+var import_node_path4 = __toESM(require("path"));
+var CLAUDE_SETTINGS_FILE = "settings.json";
+var HOOK_EVENTS = [
+  { event: "UserPromptSubmit", suffix: "user-prompt-submit" },
+  { event: "PostToolUse", suffix: "post-tool-use" },
+  { event: "PostToolUseFailure", suffix: "post-tool-use-failure" },
+  { event: "SessionEnd", suffix: "session-end" }
+];
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function parseSettings(raw) {
+  const parsed = JSON.parse(raw);
+  if (!isObject(parsed)) {
+    throw new Error(".claude/settings.json must be a JSON object.");
+  }
+  return parsed;
+}
+function ensureCommand(settings, event, command) {
+  if (!isObject(settings.hooks)) {
+    settings.hooks = {};
+  }
+  const hooksByEvent = settings.hooks;
+  const rawMatchers = hooksByEvent[event];
+  if (!Array.isArray(rawMatchers)) {
+    const entry = {
+      matcher: "",
+      hooks: [{ type: "command", command }]
+    };
+    hooksByEvent[event] = [entry];
+    return true;
+  }
+  let target = rawMatchers.find(
+    (matcher) => isObject(matcher) && typeof matcher.matcher === "string" && matcher.matcher.length === 0 && Array.isArray(matcher.hooks)
+  );
+  if (!target) {
+    target = { matcher: "", hooks: [] };
+    rawMatchers.push(target);
+  }
+  const exists = target.hooks.some(
+    (candidate) => candidate && candidate.type === "command" && candidate.command === command
+  );
+  if (exists) {
+    return false;
+  }
+  target.hooks.push({ type: "command", command });
+  return true;
+}
+async function installClaudeCodeHooks(claudeDir, hookCommandBase) {
+  const settingsPath = import_node_path4.default.join(claudeDir, CLAUDE_SETTINGS_FILE);
+  let settings = {};
+  try {
+    const raw = await (0, import_promises4.readFile)(settingsPath, "utf8");
+    settings = parseSettings(raw);
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ENOENT") {
+      throw error;
+    }
+  }
+  let addedCommands = 0;
+  for (const hook of HOOK_EVENTS) {
+    const command = `${hookCommandBase} hook claude-code ${hook.suffix}`;
+    if (ensureCommand(settings, hook.event, command)) {
+      addedCommands += 1;
+    }
+  }
+  await (0, import_promises4.writeFile)(settingsPath, `${JSON.stringify(settings, null, 2)}
+`, "utf8");
+  return {
+    claudeDir,
+    settingsPath,
+    addedCommands
+  };
+}
+
+// src/hooks/types.ts
+var SUPPORTED_HOOK_AGENT = "claude-code";
+var AGENT_CHOICES = ["claude-code", "cursor", "codex", "windsurf"];
+function isHookAgent(value) {
+  return AGENT_CHOICES.includes(value);
+}
+function isSupportedHookAgent(value) {
+  return value === SUPPORTED_HOOK_AGENT;
+}
+function formatAgentLabel(agent) {
+  switch (agent) {
+    case "claude-code":
+      return "Claude Code";
+    case "cursor":
+      return "Cursor";
+    case "codex":
+      return "Codex";
+    case "windsurf":
+      return "Windsurf";
+  }
+}
+
+// src/hooks/install.ts
+function resolveAgent(agent) {
+  if (!isHookAgent(agent)) {
+    return {
+      ok: false,
+      error: `Unknown agent '${agent}'. Valid values: claude-code, cursor, codex, windsurf.`
+    };
+  }
+  if (!isSupportedHookAgent(agent)) {
+    return {
+      ok: false,
+      error: `${formatAgentLabel(agent)} hook installation is not supported yet. Choose 'claude-code'.`
+    };
+  }
+  return { ok: true, value: agent };
+}
+function quoteShellArg(value) {
+  if (/^[A-Za-z0-9_./:@-]+$/.test(value)) {
+    return value;
+  }
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function resolveHookCommandBase(startDir) {
+  const argv1 = process.argv[1]?.trim();
+  if (!argv1) {
+    return "bep";
+  }
+  const resolved = import_node_path5.default.isAbsolute(argv1) ? argv1 : import_node_path5.default.resolve(startDir, argv1);
+  return quoteShellArg(resolved);
+}
+async function installAgentHooks(startDir, agent) {
+  const resolved = resolveAgent(agent);
+  if (!resolved.ok) {
+    return resolved;
+  }
+  const claudeDir = await findNearestClaudeDir(startDir);
+  if (!claudeDir) {
+    return {
+      ok: false,
+      error: "No .claude directory found in the current directory or any parent directory. Create one first, then rerun 'bep init --install-hooks --agent claude-code'."
+    };
+  }
+  const hookCommandBase = resolveHookCommandBase(startDir);
+  const installed = await installClaudeCodeHooks(claudeDir, hookCommandBase);
+  const settingsPathRelative = import_node_path5.default.relative(startDir, installed.settingsPath) || import_node_path5.default.basename(installed.settingsPath);
+  return {
+    ok: true,
+    agent: resolved.value,
+    settingsPathRelative,
+    alreadyInstalled: installed.addedCommands === 0
+  };
+}
+
+// src/ui/initHooks.ts
+var import_prompts = require("@clack/prompts");
+var COMING_SOON_AGENTS = ["cursor", "codex", "windsurf"];
+async function runInitHookPrompt(client = createInitHookPromptClient()) {
+  const shouldInstall = await client.promptInstallNow();
+  if (shouldInstall === "cancel") {
+    return { kind: "cancel" };
+  }
+  if (!shouldInstall) {
+    return { kind: "skip" };
+  }
+  while (true) {
+    const selected = await client.promptAgent();
+    if (selected === "cancel") {
+      return { kind: "cancel" };
+    }
+    if (selected === "claude-code") {
+      return { kind: "install", agent: selected };
+    }
+    client.showComingSoon(selected);
+  }
+}
+function createInitHookPromptClient() {
+  return {
+    async promptInstallNow() {
+      const value = await (0, import_prompts.confirm)({
+        message: "Install agent tracking hooks now?",
+        initialValue: true
+      });
+      if ((0, import_prompts.isCancel)(value)) {
+        return "cancel";
+      }
+      return value;
+    },
+    async promptAgent() {
+      const value = await (0, import_prompts.select)({
+        message: "Choose an agent",
+        options: [
+          { label: "Claude Code", value: "claude-code" },
+          { label: "Cursor", value: "cursor", hint: "coming soon" },
+          { label: "Codex", value: "codex", hint: "coming soon" },
+          { label: "Windsurf", value: "windsurf", hint: "coming soon" }
+        ],
+        initialValue: "claude-code"
+      });
+      if ((0, import_prompts.isCancel)(value)) {
+        return "cancel";
+      }
+      return value;
+    },
+    showComingSoon(agent) {
+      if (COMING_SOON_AGENTS.includes(agent)) {
+        console.log(`${formatAgentLabel(agent)} support is coming soon. Choose Claude Code for now.`);
+      }
+    }
+  };
+}
+
+// src/commands/init.ts
+function isInteractiveTty() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+async function runInit(options = {}) {
+  const cwd = process.cwd();
+  const result = await initRepo(cwd);
+  if (result.alreadyInitialized) {
+    console.log("BEP is already initialized.");
+  } else {
+    console.log(`Initialized BEP in this repository (${result.createdPaths.length} items created).`);
+  }
+  let shouldInstallHooks = options.installHooks;
+  if (shouldInstallHooks === void 0 && options.agent !== void 0) {
+    shouldInstallHooks = true;
+  }
+  if (shouldInstallHooks === false && options.agent) {
+    console.error("Cannot use --agent with --no-install-hooks.");
+    return 1;
+  }
+  if (shouldInstallHooks === false) {
+    return 0;
+  }
+  let selectedAgent = options.agent;
+  if (shouldInstallHooks === void 0 && isInteractiveTty()) {
+    const promptResult = await runInitHookPrompt();
+    if (promptResult.kind === "cancel") {
+      console.error("Cancelled hook setup.");
+      return 1;
+    }
+    if (promptResult.kind === "skip") {
+      return 0;
+    }
+    selectedAgent = promptResult.agent;
+  }
+  if (shouldInstallHooks === void 0 && !selectedAgent) {
+    return 0;
+  }
+  const installResult = await installAgentHooks(cwd, selectedAgent ?? "claude-code");
+  if (!installResult.ok) {
+    console.error(installResult.error);
+    return 1;
+  }
+  if (installResult.alreadyInstalled) {
+    console.log(`Claude Code tracking hooks are already installed (${installResult.settingsPathRelative}).`);
+    return 0;
+  }
+  console.log(`Installed Claude Code tracking hooks in ${installResult.settingsPathRelative}.`);
+  return 0;
+}
+
+// src/commands/check.ts
+var import_promises6 = require("fs/promises");
+var import_node_path7 = __toESM(require("path"));
+var import_prompts5 = require("@clack/prompts");
+
+// src/bep/id.ts
+var BET_ID_REGEX = /^[a-z0-9]+(?:[-_][a-z0-9]+)*$/;
+function isValidBetId(id) {
+  return BET_ID_REGEX.test(id);
+}
+
+// src/bep/status.ts
+function normalizeValidationStatus(value) {
+  return value === "passed" ? "passed" : "pending";
+}
+
+// src/fs/bets.ts
+var import_promises5 = require("fs/promises");
+var import_node_path6 = __toESM(require("path"));
+var import_gray_matter = __toESM(require("gray-matter"));
+function getBetRelativePath(idOrFileName) {
+  const fileName = idOrFileName.endsWith(".md") ? idOrFileName : `${idOrFileName}.md`;
+  return import_node_path6.default.join(BETS_DIR, fileName);
+}
+function getBetAbsolutePath(rootDir, idOrFileName) {
+  return import_node_path6.default.join(rootDir, getBetRelativePath(idOrFileName));
+}
+async function pathExists2(filePath) {
+  try {
+    await (0, import_promises5.access)(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readBetFile(rootDir, idOrFileName) {
+  const relativePath = getBetRelativePath(idOrFileName);
+  const absolutePath = getBetAbsolutePath(rootDir, idOrFileName);
+  let markdown;
+  try {
+    markdown = await (0, import_promises5.readFile)(absolutePath, "utf8");
+  } catch (error) {
+    throw new Error(`Failed to parse BEP file at ${relativePath}: ${error.message}`);
+  }
+  let parsed;
+  try {
+    parsed = (0, import_gray_matter.default)(markdown);
+  } catch (error) {
+    throw new Error(`Failed to parse BEP file at ${relativePath}: ${error.message}`);
+  }
+  return {
+    relativePath,
+    absolutePath,
+    markdown,
+    bet: {
+      content: parsed.content,
+      data: parsed.data
+    }
+  };
+}
+async function listBetMarkdownFiles(rootDir) {
+  const betsDir = import_node_path6.default.join(rootDir, BETS_DIR);
+  const entries = await (0, import_promises5.readdir)(betsDir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md") && !entry.name.startsWith("_")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+}
+async function writeBetFile(rootDir, idOrFileName, bet) {
+  const absolutePath = getBetAbsolutePath(rootDir, idOrFileName);
+  await (0, import_promises5.writeFile)(absolutePath, import_gray_matter.default.stringify(bet.content, bet.data), "utf8");
+}
+
+// src/providers/manual.ts
+var import_prompts3 = require("@clack/prompts");
+
+// src/ui/checkPrompt.ts
+var import_prompts2 = require("@clack/prompts");
+function createClackCheckPromptClient() {
+  return {
+    async promptObservedValue() {
+      return (0, import_prompts2.text)({
+        message: "Observed value (required, numeric)",
+        validate(rawValue) {
+          const trimmed = rawValue.trim();
+          if (trimmed.length === 0 || !Number.isFinite(Number(trimmed))) {
+            return "Enter a valid number.";
+          }
+        }
+      });
+    },
+    async promptNotes() {
+      return (0, import_prompts2.text)({
+        message: "Notes (optional)"
+      });
+    }
+  };
+}
+async function runCheckPrompt(client = createClackCheckPromptClient()) {
+  const observed = await client.promptObservedValue();
+  if ((0, import_prompts2.isCancel)(observed)) {
+    return { cancelled: true };
+  }
+  const notes = await client.promptNotes();
+  if ((0, import_prompts2.isCancel)(notes)) {
+    return { cancelled: true };
+  }
+  const observedValue = Number(observed.trim());
+  const trimmedNotes = (notes || "").trim();
+  return {
+    cancelled: false,
+    observedValue,
+    notes: trimmedNotes.length > 0 ? trimmedNotes : void 0
+  };
+}
+
+// src/providers/manual.ts
+var BACK_VALUE = "__back__";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+function isManualComparisonOperator(value) {
+  return value === "lt" || value === "lte" || value === "eq" || value === "gte" || value === "gt";
+}
+function parseManualLeadingIndicator(input) {
+  if (!input || typeof input !== "object") {
+    return { ok: false, error: "leading_indicator must be an object." };
+  }
+  const candidate = input;
+  if (candidate.type !== "manual") {
+    return { ok: false, error: 'leading_indicator.type must equal "manual".' };
+  }
+  if (!isManualComparisonOperator(candidate.operator)) {
+    return { ok: false, error: 'leading_indicator.operator must be one of "lt", "lte", "eq", "gte", "gt".' };
+  }
+  if (typeof candidate.target !== "number" || !Number.isFinite(candidate.target)) {
+    return { ok: false, error: "leading_indicator.target must be a finite number." };
+  }
+  return {
+    ok: true,
+    value: {
+      type: "manual",
+      operator: candidate.operator,
+      target: candidate.target
+    }
+  };
+}
+function evaluateManualComparison(observedValue, operator, target) {
+  if (operator === "lt") {
+    return observedValue < target;
+  }
+  if (operator === "lte") {
+    return observedValue <= target;
+  }
+  if (operator === "eq") {
+    return observedValue === target;
+  }
+  if (operator === "gte") {
+    return observedValue >= target;
+  }
+  return observedValue > target;
+}
+function formatManualComparisonOperator(operator) {
+  if (operator === "lt") {
+    return "<";
+  }
+  if (operator === "lte") {
+    return "<=";
+  }
+  if (operator === "eq") {
+    return "=";
+  }
+  if (operator === "gte") {
+    return ">=";
+  }
+  return ">";
+}
+function createClackManualSetupPromptClient() {
+  return {
+    async promptManualOperator({ initialValue, allowBack }) {
+      const options = [
+        { label: "lt (less than)", value: "lt" },
+        { label: "lte (less than or equal)", value: "lte" },
+        { label: "eq (equal)", value: "eq" },
+        { label: "gte (greater than or equal)", value: "gte" },
+        { label: "gt (greater than)", value: "gt" }
+      ];
+      if (allowBack) {
+        options.unshift({ label: "Back", value: BACK_VALUE });
+      }
+      const value = await (0, import_prompts3.select)({
+        message: "Leading indicator comparison operator",
+        options,
+        initialValue
+      });
+      if ((0, import_prompts3.isCancel)(value)) {
+        return { kind: "cancel" };
+      }
+      if (value === BACK_VALUE) {
+        return { kind: "back" };
+      }
+      return { kind: "value", value };
+    },
+    async promptManualTarget({ initialValue, allowBack }) {
+      const backHint = allowBack ? ` ${DIM}(type b to go back)${RESET}` : "";
+      const value = await (0, import_prompts3.text)({
+        message: `Leading indicator numeric target (required).${backHint}`,
+        initialValue: typeof initialValue === "number" ? String(initialValue) : void 0,
+        validate(rawValue) {
+          const trimmed2 = rawValue.trim();
+          if (allowBack && trimmed2.toLowerCase() === "b") {
+            return;
+          }
+          if (trimmed2.length === 0 || !Number.isFinite(Number(trimmed2))) {
+            return "Enter a valid number.";
+          }
+        }
+      });
+      if ((0, import_prompts3.isCancel)(value)) {
+        return { kind: "cancel" };
+      }
+      const trimmed = value.trim();
+      if (allowBack && trimmed.toLowerCase() === "b") {
+        return { kind: "back" };
+      }
+      return { kind: "value", value: Number(trimmed) };
+    }
+  };
+}
+var manualAdapter = {
+  type: "manual",
+  parseIndicator(input) {
+    return parseManualLeadingIndicator(input);
+  },
+  async runCheck(indicator) {
+    const promptResult = await runCheckPrompt();
+    if (promptResult.cancelled) {
+      return { cancelled: true };
+    }
+    return {
+      observedValue: promptResult.observedValue,
+      meetsTarget: evaluateManualComparison(promptResult.observedValue, indicator.operator, indicator.target),
+      notes: promptResult.notes
+    };
+  }
+};
+function getManualSetupClient(ctx) {
+  if (ctx.client && typeof ctx.client === "object") {
+    const candidate = ctx.client;
+    if (typeof candidate.promptManualOperator === "function" && typeof candidate.promptManualTarget === "function") {
+      return candidate;
+    }
+  }
+  return createClackManualSetupPromptClient();
+}
+var manualSetup = {
+  type: "manual",
+  async collectNewWizardInput(ctx) {
+    const client = getManualSetupClient(ctx);
+    let stepIndex = 0;
+    const values = {
+      type: "manual",
+      operator: ctx.initialValue?.operator,
+      target: ctx.initialValue?.target
+    };
+    while (stepIndex < 2) {
+      if (stepIndex === 0) {
+        const result2 = await client.promptManualOperator({
+          initialValue: values.operator,
+          allowBack: ctx.allowBack
+        });
+        if (result2.kind === "cancel") {
+          return { kind: "cancel" };
+        }
+        if (result2.kind === "back") {
+          return { kind: "back" };
+        }
+        values.operator = result2.value;
+        stepIndex += 1;
+        continue;
+      }
+      const result = await client.promptManualTarget({
+        initialValue: values.target,
+        allowBack: true
+      });
+      if (result.kind === "cancel") {
+        return { kind: "cancel" };
+      }
+      if (result.kind === "back") {
+        stepIndex = Math.max(0, stepIndex - 1);
+        continue;
+      }
+      values.target = result.value;
+      stepIndex += 1;
+    }
+    if (!values.operator || typeof values.target !== "number") {
+      return { kind: "cancel" };
+    }
+    return {
+      kind: "value",
+      value: {
+        type: "manual",
+        operator: values.operator,
+        target: values.target
+      }
+    };
+  }
+};
+var manualProviderModule = {
+  adapter: manualAdapter,
+  setup: manualSetup
+};
+
+// src/providers/mixpanel.ts
+var import_node_buffer = require("buffer");
+var import_prompts4 = require("@clack/prompts");
+var BACK_VALUE2 = "__back__";
+var DIM2 = "\x1B[2m";
+var RESET2 = "\x1B[0m";
+var MIXPANEL_REPORT_ENDPOINT = "https://mixpanel.com/api/query/insights";
+var MIXPANEL_URL_HINT = "Values come from report URL: /project/<PROJECT_ID>/view/<WORKSPACE_ID>/...#...report-<BOOKMARK_ID>.";
+function isManualComparisonOperator2(value) {
+  return value === "lt" || value === "lte" || value === "eq" || value === "gte" || value === "gt";
+}
+function parseMixpanelLeadingIndicator(input) {
+  if (!input || typeof input !== "object") {
+    return { ok: false, error: "leading_indicator must be an object." };
+  }
+  const candidate = input;
+  if (candidate.type !== "mixpanel") {
+    return { ok: false, error: 'leading_indicator.type must equal "mixpanel".' };
+  }
+  if (typeof candidate.project_id !== "string" || candidate.project_id.trim().length === 0) {
+    return { ok: false, error: "leading_indicator.project_id must be a non-empty string." };
+  }
+  if (typeof candidate.workspace_id !== "string" || candidate.workspace_id.trim().length === 0) {
+    return { ok: false, error: "leading_indicator.workspace_id must be a non-empty string." };
+  }
+  if (typeof candidate.bookmark_id !== "string" || candidate.bookmark_id.trim().length === 0) {
+    return { ok: false, error: "leading_indicator.bookmark_id must be a non-empty string." };
+  }
+  if (!isManualComparisonOperator2(candidate.operator)) {
+    return { ok: false, error: 'leading_indicator.operator must be one of "lt", "lte", "eq", "gte", "gt".' };
+  }
+  if (typeof candidate.target !== "number" || !Number.isFinite(candidate.target)) {
+    return { ok: false, error: "leading_indicator.target must be a finite number." };
+  }
+  return {
+    ok: true,
+    value: {
+      type: "mixpanel",
+      project_id: candidate.project_id.trim(),
+      workspace_id: candidate.workspace_id.trim(),
+      bookmark_id: candidate.bookmark_id.trim(),
+      operator: candidate.operator,
+      target: candidate.target
+    }
+  };
+}
+function getMixpanelSetupClient(ctx) {
+  if (ctx.client && typeof ctx.client === "object") {
+    const candidate = ctx.client;
+    if (typeof candidate.promptMixpanelProjectId === "function" && typeof candidate.promptMixpanelWorkspaceId === "function" && typeof candidate.promptMixpanelBookmarkId === "function" && typeof candidate.promptMixpanelOperator === "function" && typeof candidate.promptMixpanelTarget === "function") {
+      return candidate;
+    }
+  }
+  return createClackMixpanelSetupPromptClient();
+}
+function createClackMixpanelSetupPromptClient() {
+  return {
+    async promptMixpanelProjectId({ initialValue, allowBack }) {
+      const backHint = allowBack ? ` ${DIM2}(type b to go back)${RESET2}` : "";
+      const value = await (0, import_prompts4.text)({
+        message: `Mixpanel project id (required). ${MIXPANEL_URL_HINT}${backHint}`,
+        initialValue,
+        validate(rawValue) {
+          const trimmed2 = rawValue.trim();
+          if (allowBack && trimmed2.toLowerCase() === "b") {
+            return;
+          }
+          if (trimmed2.length === 0) {
+            return "Enter a project id.";
+          }
+        }
+      });
+      if ((0, import_prompts4.isCancel)(value)) {
+        return { kind: "cancel" };
+      }
+      const trimmed = value.trim();
+      if (allowBack && trimmed.toLowerCase() === "b") {
+        return { kind: "back" };
+      }
+      return { kind: "value", value: trimmed };
+    },
+    async promptMixpanelWorkspaceId({ initialValue, allowBack }) {
+      const backHint = allowBack ? ` ${DIM2}(type b to go back)${RESET2}` : "";
+      const value = await (0, import_prompts4.text)({
+        message: `Mixpanel workspace id (required). ${MIXPANEL_URL_HINT}${backHint}`,
+        initialValue,
+        validate(rawValue) {
+          const trimmed2 = rawValue.trim();
+          if (allowBack && trimmed2.toLowerCase() === "b") {
+            return;
+          }
+          if (trimmed2.length === 0) {
+            return "Enter a workspace id.";
+          }
+        }
+      });
+      if ((0, import_prompts4.isCancel)(value)) {
+        return { kind: "cancel" };
+      }
+      const trimmed = value.trim();
+      if (allowBack && trimmed.toLowerCase() === "b") {
+        return { kind: "back" };
+      }
+      return { kind: "value", value: trimmed };
+    },
+    async promptMixpanelBookmarkId({ initialValue, allowBack }) {
+      const backHint = allowBack ? ` ${DIM2}(type b to go back)${RESET2}` : "";
+      const value = await (0, import_prompts4.text)({
+        message: `Mixpanel bookmark id (required). ${MIXPANEL_URL_HINT}${backHint}`,
+        initialValue,
+        validate(rawValue) {
+          const trimmed2 = rawValue.trim();
+          if (allowBack && trimmed2.toLowerCase() === "b") {
+            return;
+          }
+          if (trimmed2.length === 0) {
+            return "Enter a bookmark id.";
+          }
+        }
+      });
+      if ((0, import_prompts4.isCancel)(value)) {
+        return { kind: "cancel" };
+      }
+      const trimmed = value.trim();
+      if (allowBack && trimmed.toLowerCase() === "b") {
+        return { kind: "back" };
+      }
+      return { kind: "value", value: trimmed };
+    },
+    async promptMixpanelOperator({ initialValue, allowBack }) {
+      const options = [
+        { label: "lt (less than)", value: "lt" },
+        { label: "lte (less than or equal)", value: "lte" },
+        { label: "eq (equal)", value: "eq" },
+        { label: "gte (greater than or equal)", value: "gte" },
+        { label: "gt (greater than)", value: "gt" }
+      ];
+      if (allowBack) {
+        options.unshift({ label: "Back", value: BACK_VALUE2 });
+      }
+      const value = await (0, import_prompts4.select)({
+        message: "Mixpanel comparison operator",
+        options,
+        initialValue
+      });
+      if ((0, import_prompts4.isCancel)(value)) {
+        return { kind: "cancel" };
+      }
+      if (value === BACK_VALUE2) {
+        return { kind: "back" };
+      }
+      return { kind: "value", value };
+    },
+    async promptMixpanelTarget({ initialValue, allowBack }) {
+      const backHint = allowBack ? ` ${DIM2}(type b to go back)${RESET2}` : "";
+      const value = await (0, import_prompts4.text)({
+        message: `Mixpanel target value (required).${backHint}`,
+        initialValue: typeof initialValue === "number" ? String(initialValue) : void 0,
+        validate(rawValue) {
+          const trimmed2 = rawValue.trim();
+          if (allowBack && trimmed2.toLowerCase() === "b") {
+            return;
+          }
+          if (trimmed2.length === 0 || !Number.isFinite(Number(trimmed2))) {
+            return "Enter a valid number.";
+          }
+        }
+      });
+      if ((0, import_prompts4.isCancel)(value)) {
+        return { kind: "cancel" };
+      }
+      const trimmed = value.trim();
+      if (allowBack && trimmed.toLowerCase() === "b") {
+        return { kind: "back" };
+      }
+      return { kind: "value", value: Number(trimmed) };
+    }
+  };
+}
+function collectNumericLeaves(value) {
+  const numbers = [];
+  const stack = [value];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (typeof current === "number" && Number.isFinite(current)) {
+      numbers.push(current);
+      continue;
+    }
+    if (!current || typeof current !== "object") {
+      continue;
+    }
+    for (const nested of Object.values(current)) {
+      stack.push(nested);
+    }
+  }
+  return numbers;
+}
+function parseObservedValue(payload) {
+  if (!payload || typeof payload !== "object") {
+    return { value: null, seriesNumericLeafCount: null };
+  }
+  const candidate = payload;
+  if (typeof candidate.value === "number" && Number.isFinite(candidate.value)) {
+    return { value: candidate.value, seriesNumericLeafCount: null };
+  }
+  if (candidate.result && typeof candidate.result === "object") {
+    const maybeResult = candidate.result;
+    if (typeof maybeResult.value === "number" && Number.isFinite(maybeResult.value)) {
+      return { value: maybeResult.value, seriesNumericLeafCount: null };
+    }
+  }
+  if (candidate.series && typeof candidate.series === "object") {
+    const numericLeaves = collectNumericLeaves(candidate.series);
+    if (numericLeaves.length === 1) {
+      return { value: numericLeaves[0], seriesNumericLeafCount: 1 };
+    }
+    return {
+      value: null,
+      seriesNumericLeafCount: numericLeaves.length
+    };
+  }
+  return { value: null, seriesNumericLeafCount: null };
+}
+var mixpanelAdapter = {
+  type: "mixpanel",
+  parseIndicator(input) {
+    return parseMixpanelLeadingIndicator(input);
+  },
+  async runCheck(indicator, ctx) {
+    const configResult = await readProviderConfig(ctx.rootDir);
+    if (!configResult.ok) {
+      throw new Error(configResult.error);
+    }
+    const credsResult = getMixpanelServiceAccountCreds(configResult.value);
+    if (!credsResult.ok) {
+      throw new Error(credsResult.error);
+    }
+    const params = new URLSearchParams({
+      project_id: indicator.project_id,
+      workspace_id: indicator.workspace_id,
+      bookmark_id: indicator.bookmark_id
+    });
+    const url = `${MIXPANEL_REPORT_ENDPOINT}?${params.toString()}`;
+    const encodedCreds = import_node_buffer.Buffer.from(credsResult.value, "utf8").toString("base64");
+    let response;
+    try {
+      response = await fetch(url, {
+        headers: {
+          authorization: `Basic ${encodedCreds}`,
+          accept: "application/json"
+        }
+      });
+    } catch (error) {
+      throw new Error(`Failed to query Mixpanel insights API: ${error.message}`);
+    }
+    if (!response.ok) {
+      throw new Error(`Mixpanel insights API returned ${response.status} ${response.statusText}.`);
+    }
+    let payload;
+    try {
+      payload = await response.json();
+    } catch (error) {
+      throw new Error(`Failed to parse Mixpanel response JSON: ${error.message}`);
+    }
+    const observed = parseObservedValue(payload);
+    if (observed.value === null) {
+      if (observed.seriesNumericLeafCount !== null) {
+        throw new Error(
+          observed.seriesNumericLeafCount === 0 ? "Mixpanel response series must contain exactly one numeric value; found 0." : `Mixpanel response series must contain exactly one numeric value; found ${observed.seriesNumericLeafCount}. Use a single-value insight/report.`
+        );
+      }
+      throw new Error("Mixpanel response did not include a numeric value field.");
+    }
+    const observedValue = observed.value;
+    return {
+      observedValue,
+      meetsTarget: evaluateManualComparison(observedValue, indicator.operator, indicator.target),
+      meta: {
+        provider: "mixpanel",
+        project_id: indicator.project_id,
+        workspace_id: indicator.workspace_id,
+        bookmark_id: indicator.bookmark_id
+      }
+    };
+  }
+};
+var mixpanelSetup = {
+  type: "mixpanel",
+  async collectNewWizardInput(ctx) {
+    const client = getMixpanelSetupClient(ctx);
+    let stepIndex = 0;
+    const values = {
+      type: "mixpanel",
+      project_id: ctx.initialValue?.project_id,
+      workspace_id: ctx.initialValue?.workspace_id,
+      bookmark_id: ctx.initialValue?.bookmark_id,
+      operator: ctx.initialValue?.operator,
+      target: ctx.initialValue?.target
+    };
+    while (stepIndex < 5) {
+      if (stepIndex === 0) {
+        const result2 = await client.promptMixpanelProjectId({
+          initialValue: values.project_id,
+          allowBack: ctx.allowBack
+        });
+        if (result2.kind === "cancel") {
+          return { kind: "cancel" };
+        }
+        if (result2.kind === "back") {
+          return { kind: "back" };
+        }
+        values.project_id = result2.value;
+        stepIndex += 1;
+        continue;
+      }
+      if (stepIndex === 1) {
+        const result2 = await client.promptMixpanelWorkspaceId({
+          initialValue: values.workspace_id,
+          allowBack: true
+        });
+        if (result2.kind === "cancel") {
+          return { kind: "cancel" };
+        }
+        if (result2.kind === "back") {
+          stepIndex = Math.max(0, stepIndex - 1);
+          continue;
+        }
+        values.workspace_id = result2.value;
+        stepIndex += 1;
+        continue;
+      }
+      if (stepIndex === 2) {
+        const result2 = await client.promptMixpanelBookmarkId({
+          initialValue: values.bookmark_id,
+          allowBack: true
+        });
+        if (result2.kind === "cancel") {
+          return { kind: "cancel" };
+        }
+        if (result2.kind === "back") {
+          stepIndex = Math.max(0, stepIndex - 1);
+          continue;
+        }
+        values.bookmark_id = result2.value;
+        stepIndex += 1;
+        continue;
+      }
+      if (stepIndex === 3) {
+        const result2 = await client.promptMixpanelOperator({
+          initialValue: values.operator,
+          allowBack: true
+        });
+        if (result2.kind === "cancel") {
+          return { kind: "cancel" };
+        }
+        if (result2.kind === "back") {
+          stepIndex = Math.max(0, stepIndex - 1);
+          continue;
+        }
+        values.operator = result2.value;
+        stepIndex += 1;
+        continue;
+      }
+      const result = await client.promptMixpanelTarget({
+        initialValue: values.target,
+        allowBack: true
+      });
+      if (result.kind === "cancel") {
+        return { kind: "cancel" };
+      }
+      if (result.kind === "back") {
+        stepIndex = Math.max(0, stepIndex - 1);
+        continue;
+      }
+      values.target = result.value;
+      stepIndex += 1;
+    }
+    if (!values.project_id || !values.workspace_id || !values.bookmark_id || !values.operator || typeof values.target !== "number") {
+      return { kind: "cancel" };
+    }
+    return {
+      kind: "value",
+      value: {
+        type: "mixpanel",
+        project_id: values.project_id,
+        workspace_id: values.workspace_id,
+        bookmark_id: values.bookmark_id,
+        operator: values.operator,
+        target: values.target
+      }
+    };
+  }
+};
+var mixpanelProviderModule = {
+  adapter: mixpanelAdapter,
+  setup: mixpanelSetup
+};
+
+// src/providers/registry.ts
+var providerRegistry = {
+  manual: manualProviderModule,
+  mixpanel: mixpanelProviderModule
+};
+function resolveProviderModule(type) {
+  return providerRegistry[type];
+}
+function listRegisteredProviderTypes() {
+  return Object.keys(providerRegistry);
+}
+
+// src/commands/check.ts
+function getLeadingIndicatorType(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const type = value.type;
+  return typeof type === "string" && type.length > 0 ? type : null;
+}
+function formatComparisonLabel(indicator, observedValue) {
+  if (indicator.type === "manual" || indicator.type === "mixpanel") {
+    return `${observedValue} ${formatManualComparisonOperator(indicator.operator)} ${indicator.target}`;
+  }
+  return String(observedValue);
+}
+function hasPassedStatusInFrontmatter(markdown) {
+  const trimmed = markdown.trimStart();
+  if (!trimmed.startsWith("---")) {
+    return false;
+  }
+  const lines = trimmed.split(/\r?\n/);
+  if (lines.length < 3 || lines[0]?.trim() !== "---") {
+    return false;
+  }
+  const endIndex = lines.slice(1).findIndex((line) => line.trim() === "---");
+  if (endIndex === -1) {
+    return false;
+  }
+  const frontmatterLines = lines.slice(1, endIndex + 1);
+  return frontmatterLines.some((line) => /^status:\s*passed\s*$/i.test(line.trim()));
+}
+async function hasPassingEvidence(rootDir, id) {
+  const evidencePath = import_node_path7.default.join(rootDir, EVIDENCE_DIR, `${id}.json`);
+  if (!await pathExists2(evidencePath)) {
+    return false;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(await (0, import_promises6.readFile)(evidencePath, "utf8"));
+  } catch {
+    return false;
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return false;
+  }
+  return parsed.meets_target === true;
+}
+function isInteractiveTty2() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+async function maybePromptUnpass(id) {
+  const value = await (0, import_prompts5.select)({
+    message: `Bet '${id}' is currently status: passed, but the forced check FAILED. Update status?`,
+    options: [
+      { label: "Keep status: passed", value: "keep" },
+      { label: "Set status: pending", value: "unpass" }
+    ],
+    initialValue: "keep"
+  });
+  if ((0, import_prompts5.isCancel)(value)) {
+    return "cancel";
+  }
+  return value;
+}
+async function runCheck(id, options = {}) {
+  if (!isValidBetId(id)) {
+    console.error(`Invalid bet id '${id}'. Use lowercase id format like 'landing-page' or 'landing_page'.`);
+    return 1;
+  }
+  let rootDir;
+  try {
+    if (options.rootDir) {
+      const ensured = await ensureInitializedRepo(options.rootDir);
+      if (ensured.rootDir !== options.rootDir) {
+        throw new Error(`Expected BEP repo root at ${options.rootDir}, found ${ensured.rootDir}.`);
+      }
+      rootDir = ensured.rootDir;
+    } else {
+      const cwd = process.cwd();
+      ({ rootDir } = await ensureInitializedRepo(cwd));
+    }
+  } catch (error) {
+    console.error(error.message);
+    return 1;
+  }
+  const relativeBetPath = getBetRelativePath(id);
+  const absoluteBetPath = getBetAbsolutePath(rootDir, id);
+  if (!await pathExists2(absoluteBetPath)) {
+    console.error(`Bet '${id}' does not exist at ${relativeBetPath}. Run 'bep new ${id}' first.`);
+    return 1;
+  }
+  let bet;
+  try {
+    bet = await readBetFile(rootDir, id);
+  } catch (error) {
+    console.error(error.message);
+    return 1;
+  }
+  const validationStatus = normalizeValidationStatus(bet.bet.data.status);
+  const isPassed = hasPassedStatusInFrontmatter(bet.markdown) || validationStatus === "passed";
+  if (isPassed && !options.force) {
+    if (await hasPassingEvidence(rootDir, id)) {
+      console.log(`Bet '${id}' is status: passed; skipping validation check.`);
+      return 0;
+    }
+  }
+  const rawLeadingIndicator = bet.bet.data.leading_indicator;
+  const leadingIndicatorType = getLeadingIndicatorType(rawLeadingIndicator);
+  if (!leadingIndicatorType) {
+    console.error("Bet has invalid leading_indicator: missing string field 'type'.");
+    return 1;
+  }
+  const module2 = resolveProviderModule(leadingIndicatorType);
+  if (!module2) {
+    const knownTypes = listRegisteredProviderTypes().join(", ");
+    console.error(
+      `Bet has unsupported leading_indicator.type '${leadingIndicatorType}'. Supported types: ${knownTypes}.`
+    );
+    return 1;
+  }
+  const parsedIndicator = module2.adapter.parseIndicator(rawLeadingIndicator);
+  if (!parsedIndicator.ok) {
+    console.error(`Bet '${id}' has invalid leading_indicator: ${parsedIndicator.error}`);
+    return 1;
+  }
+  let checkResult;
+  try {
+    checkResult = await module2.adapter.runCheck(parsedIndicator.value, {
+      rootDir,
+      betId: id,
+      nowIso: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  } catch (error) {
+    console.error(error.message);
+    return 1;
+  }
+  if ("cancelled" in checkResult) {
+    console.error("Cancelled. No evidence was written.");
+    return 1;
+  }
+  const snapshot = {
+    id,
+    checked_at: (/* @__PURE__ */ new Date()).toISOString(),
+    mode: parsedIndicator.value.type,
+    leading_indicator: parsedIndicator.value,
+    observed_value: checkResult.observedValue,
+    meets_target: checkResult.meetsTarget,
+    notes: checkResult.notes,
+    meta: checkResult.meta
+  };
+  const relativeEvidencePath = import_node_path7.default.join(EVIDENCE_DIR, `${id}.json`);
+  const absoluteEvidencePath = import_node_path7.default.join(rootDir, relativeEvidencePath);
+  try {
+    await (0, import_promises6.writeFile)(absoluteEvidencePath, `${JSON.stringify(snapshot, null, 2)}
+`, "utf8");
+  } catch (error) {
+    console.error(`Failed to write evidence at ${relativeEvidencePath}: ${error.message}`);
+    return 1;
+  }
+  const comparisonLabel = formatComparisonLabel(parsedIndicator.value, checkResult.observedValue);
+  console.log(
+    `Captured ${parsedIndicator.value.type} evidence for '${id}' at ${relativeEvidencePath}. Result: ${checkResult.meetsTarget ? "PASS" : "FAIL"} (${comparisonLabel}).`
+  );
+  if (checkResult.meetsTarget) {
+    bet.bet.data.status = "passed";
+    try {
+      await writeBetFile(rootDir, id, bet.bet);
+    } catch (error) {
+      console.error(`Failed to mark bet '${id}' as passed: ${error.message}`);
+      return 1;
+    }
+    console.log(`Marked bet '${id}' as status: passed.`);
+    return 0;
+  }
+  if (options.force && isPassed) {
+    if (!isInteractiveTty2()) {
+      console.log(
+        `Note: Bet '${id}' remains status: passed. To unpass, edit bets/${id}.md and set status: pending.`
+      );
+      return 0;
+    }
+    const result = await maybePromptUnpass(id);
+    if (result === "cancel") {
+      console.log(`Cancelled; bet '${id}' remains status: passed.`);
+      return 0;
+    }
+    if (result === "unpass") {
+      bet.bet.data.status = "pending";
+      try {
+        await writeBetFile(rootDir, id, bet.bet);
+      } catch (error) {
+        console.error(`Failed to update bet '${id}' status: ${error.message}`);
+        return 1;
+      }
+      console.log(`Updated bet '${id}' to status: pending.`);
+    }
+  }
+  return 0;
+}
+
+// src/commands/new.ts
+var import_promises7 = require("fs/promises");
+var import_node_path8 = __toESM(require("path"));
+
+// src/bep/template.ts
+var import_gray_matter2 = __toESM(require("gray-matter"));
+function renderNewBetMarkdown(input) {
+  const frontmatter = {
+    id: input.id,
+    status: "pending",
+    created_at: input.createdAt,
+    leading_indicator: input.leadingIndicator
+  };
+  if (typeof input.maxHours === "number") {
+    frontmatter.max_hours = input.maxHours;
+  }
+  if (typeof input.maxCalendarDays === "number") {
+    frontmatter.max_calendar_days = input.maxCalendarDays;
+  }
+  const body = [
+    "# Budgeted Engineering Proposal",
+    "",
+    "## 1. Primary Assumption",
+    "",
+    input.primaryAssumption,
+    "",
+    "## 2. Rationale",
+    "",
+    input.rationale,
+    "",
+    "## 3. Validation Plan",
+    "",
+    input.validationPlan,
+    "",
+    "## 4. Notes",
+    "",
+    input.notes,
+    ""
+  ].join("\n");
+  return `${import_gray_matter2.default.stringify(body, frontmatter)}`;
+}
+
+// src/ui/newWizard.ts
+var import_prompts6 = require("@clack/prompts");
+var BACK_VALUE3 = "__back__";
+var DIM3 = "\x1B[2m";
+var RESET3 = "\x1B[0m";
+var STEP_ORDER = [
+  "cap_type",
+  "cap_value",
+  "leading_indicator_type",
+  "leading_indicator_setup",
+  "primary_assumption",
+  "rationale",
+  "validation_plan",
+  "notes"
+];
+function applyPromptResult(result, onValue) {
+  if (result.kind === "cancel") {
+    return { kind: "cancel" };
+  }
+  if (result.kind === "back") {
+    return { kind: "back" };
+  }
+  onValue(result.value);
+  return { kind: "next" };
+}
+function finalizeWizardValues(values) {
+  if (!values.capType || typeof values.capValue !== "number" || !values.leadingIndicator || !values.primaryAssumption || !values.rationale || !values.validationPlan || values.notes === void 0) {
+    return null;
+  }
+  const maxHours = values.capType === "max_hours" ? values.capValue : void 0;
+  const maxCalendarDays = values.capType === "max_calendar_days" ? values.capValue : void 0;
+  return {
+    maxHours,
+    maxCalendarDays,
+    leadingIndicator: values.leadingIndicator,
+    primaryAssumption: values.primaryAssumption,
+    rationale: values.rationale,
+    validationPlan: values.validationPlan,
+    notes: values.notes
+  };
+}
+var STEP_HANDLERS = {
+  async cap_type({ client, values, stepIndex }) {
+    const result = await client.promptCapType({
+      initialValue: values.capType,
+      allowBack: stepIndex > 0
+    });
+    return applyPromptResult(result, (value) => {
+      const previousCapType = values.capType;
+      values.capType = value;
+      if (previousCapType !== value) {
+        values.capValue = void 0;
+      }
+    });
+  },
+  async cap_value({ client, values, stepIndex }) {
+    if (!values.capType) {
+      return { kind: "cancel" };
+    }
+    const result = await client.promptCapValue({
+      field: values.capType,
+      initialValue: values.capValue,
+      allowBack: stepIndex > 0
+    });
+    return applyPromptResult(result, (value) => {
+      values.capValue = value;
+    });
+  },
+  async leading_indicator_type({ client, values, stepIndex }) {
+    const result = await client.promptLeadingIndicatorType({
+      initialValue: values.leadingIndicatorType,
+      allowBack: stepIndex > 0
+    });
+    return applyPromptResult(result, (value) => {
+      if (values.leadingIndicatorType !== value) {
+        values.leadingIndicator = void 0;
+      }
+      values.leadingIndicatorType = value;
+    });
+  },
+  async leading_indicator_setup({ client, values, stepIndex }) {
+    if (!values.leadingIndicatorType) {
+      return { kind: "cancel" };
+    }
+    const module2 = resolveProviderModule(values.leadingIndicatorType);
+    if (!module2 || !module2.setup) {
+      return { kind: "cancel" };
+    }
+    const setupResult = await module2.setup.collectNewWizardInput({
+      allowBack: stepIndex > 0,
+      initialValue: values.leadingIndicator && values.leadingIndicator.type === values.leadingIndicatorType ? values.leadingIndicator : void 0,
+      client
+    });
+    return applyPromptResult(setupResult, (value) => {
+      values.leadingIndicator = value;
+    });
+  },
+  async primary_assumption({ client, values, stepIndex }) {
+    const result = await client.promptPrimaryAssumption({
+      initialValue: values.primaryAssumption,
+      allowBack: stepIndex > 0
+    });
+    return applyPromptResult(result, (value) => {
+      values.primaryAssumption = value;
+    });
+  },
+  async rationale({ client, values, stepIndex }) {
+    const result = await client.promptRationale({
+      initialValue: values.rationale,
+      allowBack: stepIndex > 0
+    });
+    return applyPromptResult(result, (value) => {
+      values.rationale = value;
+    });
+  },
+  async validation_plan({ client, values, stepIndex }) {
+    const result = await client.promptValidationPlan({
+      initialValue: values.validationPlan,
+      allowBack: stepIndex > 0
+    });
+    return applyPromptResult(result, (value) => {
+      values.validationPlan = value;
+    });
+  },
+  async notes({ client, values, stepIndex }) {
+    const result = await client.promptNotes({
+      initialValue: values.notes,
+      allowBack: stepIndex > 0
+    });
+    return applyPromptResult(result, (value) => {
+      values.notes = value;
+    });
+  }
+};
+async function runNewWizard(client = createClackPromptClient(), log = console.log) {
+  let stepIndex = 0;
+  const values = {};
+  while (stepIndex < STEP_ORDER.length) {
+    const step = STEP_ORDER[stepIndex];
+    const handler = STEP_HANDLERS[step];
+    if (!handler) {
+      throw new Error(`No wizard step handler registered for '${step}'.`);
+    }
+    const flow = await handler({ client, values, stepIndex });
+    if (flow.kind === "cancel") {
+      return { cancelled: true };
+    }
+    if (flow.kind === "back") {
+      stepIndex = Math.max(0, stepIndex - 1);
+      continue;
+    }
+    stepIndex += 1;
+  }
+  const finalizedValues = finalizeWizardValues(values);
+  if (!finalizedValues) {
+    return { cancelled: true };
+  }
+  return {
+    cancelled: false,
+    values: finalizedValues
+  };
+}
+function createClackPromptClient() {
+  const mixpanelPromptClient = createClackMixpanelSetupPromptClient();
+  return {
+    async promptCapType({ initialValue, allowBack }) {
+      const options = [
+        { label: "Cap by hours", value: "max_hours" },
+        { label: "Cap by calendar days", value: "max_calendar_days" }
+      ];
+      if (allowBack) {
+        options.unshift({ label: "Back", value: BACK_VALUE3 });
+      }
+      const value = await (0, import_prompts6.select)({
+        message: "Choose your exposure cap type",
+        options,
+        initialValue
+      });
+      if ((0, import_prompts6.isCancel)(value)) {
+        return { kind: "cancel" };
+      }
+      if (value === BACK_VALUE3) {
+        return { kind: "back" };
+      }
+      return { kind: "value", value };
+    },
+    async promptCapValue({ field, initialValue, allowBack }) {
+      const label = field === "max_hours" ? "Max hours" : "Max calendar days";
+      const backHint = allowBack ? ` ${DIM3}(type b to go back)${RESET3}` : "";
+      const value = await (0, import_prompts6.text)({
+        message: `${label} (required).${backHint}`,
+        initialValue: typeof initialValue === "number" ? String(initialValue) : void 0,
+        validate(rawValue) {
+          const trimmed2 = rawValue.trim();
+          if (allowBack && trimmed2.toLowerCase() === "b") {
+            return;
+          }
+          if (trimmed2.length === 0) {
+            return "Enter a positive number.";
+          }
+          const parsed = Number(trimmed2);
+          if (!Number.isFinite(parsed) || parsed <= 0) {
+            return "Enter a positive number.";
+          }
+        }
+      });
+      if ((0, import_prompts6.isCancel)(value)) {
+        return { kind: "cancel" };
+      }
+      const trimmed = value.trim();
+      if (allowBack && trimmed.toLowerCase() === "b") {
+        return { kind: "back" };
+      }
+      return { kind: "value", value: Number(trimmed) };
+    },
+    async promptLeadingIndicatorType({ initialValue, allowBack }) {
+      const options = listRegisteredProviderTypes().map((type) => ({ label: type, value: type }));
+      if (allowBack) {
+        options.unshift({ label: "Back", value: BACK_VALUE3 });
+      }
+      const value = await (0, import_prompts6.select)({
+        message: "Leading indicator provider type",
+        options,
+        initialValue
+      });
+      if ((0, import_prompts6.isCancel)(value)) {
+        return { kind: "cancel" };
+      }
+      if (value === BACK_VALUE3) {
+        return { kind: "back" };
+      }
+      return { kind: "value", value };
+    },
+    async promptManualOperator({ initialValue, allowBack }) {
+      const options = [
+        { label: "lt (less than)", value: "lt" },
+        { label: "lte (less than or equal)", value: "lte" },
+        { label: "eq (equal)", value: "eq" },
+        { label: "gte (greater than or equal)", value: "gte" },
+        { label: "gt (greater than)", value: "gt" }
+      ];
+      if (allowBack) {
+        options.unshift({ label: "Back", value: BACK_VALUE3 });
+      }
+      const value = await (0, import_prompts6.select)({
+        message: "Leading indicator comparison operator",
+        options,
+        initialValue
+      });
+      if ((0, import_prompts6.isCancel)(value)) {
+        return { kind: "cancel" };
+      }
+      if (value === BACK_VALUE3) {
+        return { kind: "back" };
+      }
+      return { kind: "value", value };
+    },
+    async promptManualTarget({ initialValue, allowBack }) {
+      const backHint = allowBack ? ` ${DIM3}(type b to go back)${RESET3}` : "";
+      const value = await (0, import_prompts6.text)({
+        message: `Leading indicator numeric target (required).${backHint}`,
+        initialValue: typeof initialValue === "number" ? String(initialValue) : void 0,
+        validate(rawValue) {
+          const trimmed2 = rawValue.trim();
+          if (allowBack && trimmed2.toLowerCase() === "b") {
+            return;
+          }
+          if (trimmed2.length === 0 || !Number.isFinite(Number(trimmed2))) {
+            return "Enter a valid number.";
+          }
+        }
+      });
+      if ((0, import_prompts6.isCancel)(value)) {
+        return { kind: "cancel" };
+      }
+      const trimmed = value.trim();
+      if (allowBack && trimmed.toLowerCase() === "b") {
+        return { kind: "back" };
+      }
+      return { kind: "value", value: Number(trimmed) };
+    },
+    async promptMixpanelProjectId({ initialValue, allowBack }) {
+      return mixpanelPromptClient.promptMixpanelProjectId({ initialValue, allowBack });
+    },
+    async promptMixpanelWorkspaceId({ initialValue, allowBack }) {
+      return mixpanelPromptClient.promptMixpanelWorkspaceId({ initialValue, allowBack });
+    },
+    async promptMixpanelBookmarkId({ initialValue, allowBack }) {
+      return mixpanelPromptClient.promptMixpanelBookmarkId({ initialValue, allowBack });
+    },
+    async promptMixpanelOperator({ initialValue, allowBack }) {
+      return mixpanelPromptClient.promptMixpanelOperator({ initialValue, allowBack });
+    },
+    async promptMixpanelTarget({ initialValue, allowBack }) {
+      return mixpanelPromptClient.promptMixpanelTarget({ initialValue, allowBack });
+    },
+    async promptPrimaryAssumption({ initialValue, allowBack }) {
+      const backHint = allowBack ? ` ${DIM3}(type b to go back)${RESET3}` : "";
+      const value = await (0, import_prompts6.text)({
+        message: `Primary assumption (required).${backHint}`,
+        initialValue,
+        validate(rawValue) {
+          const trimmed2 = rawValue.trim();
+          if (allowBack && trimmed2.toLowerCase() === "b") {
+            return;
+          }
+          if (trimmed2.length === 0) {
+            return "Enter a value.";
+          }
+        }
+      });
+      if ((0, import_prompts6.isCancel)(value)) {
+        return { kind: "cancel" };
+      }
+      const trimmed = value.trim();
+      if (allowBack && trimmed.toLowerCase() === "b") {
+        return { kind: "back" };
+      }
+      return { kind: "value", value: trimmed };
+    },
+    async promptRationale({ initialValue, allowBack }) {
+      const backHint = allowBack ? ` ${DIM3}(type b to go back)${RESET3}` : "";
+      const value = await (0, import_prompts6.text)({
+        message: `Rationale (required).${backHint}`,
+        initialValue,
+        validate(rawValue) {
+          const trimmed2 = rawValue.trim();
+          if (allowBack && trimmed2.toLowerCase() === "b") {
+            return;
+          }
+          if (trimmed2.length === 0) {
+            return "Enter a value.";
+          }
+        }
+      });
+      if ((0, import_prompts6.isCancel)(value)) {
+        return { kind: "cancel" };
+      }
+      const trimmed = value.trim();
+      if (allowBack && trimmed.toLowerCase() === "b") {
+        return { kind: "back" };
+      }
+      return { kind: "value", value: trimmed };
+    },
+    async promptValidationPlan({ initialValue, allowBack }) {
+      const backHint = allowBack ? ` ${DIM3}(type b to go back)${RESET3}` : "";
+      const value = await (0, import_prompts6.text)({
+        message: `Validation plan (required).${backHint}`,
+        initialValue,
+        validate(rawValue) {
+          const trimmed2 = rawValue.trim();
+          if (allowBack && trimmed2.toLowerCase() === "b") {
+            return;
+          }
+          if (trimmed2.length === 0) {
+            return "Enter a value.";
+          }
+        }
+      });
+      if ((0, import_prompts6.isCancel)(value)) {
+        return { kind: "cancel" };
+      }
+      const trimmed = value.trim();
+      if (allowBack && trimmed.toLowerCase() === "b") {
+        return { kind: "back" };
+      }
+      return { kind: "value", value: trimmed };
+    },
+    async promptNotes({ initialValue, allowBack }) {
+      const backHint = allowBack ? ` ${DIM3}(type b to go back)${RESET3}` : "";
+      const value = await (0, import_prompts6.text)({
+        message: `Notes (optional).${backHint}`,
+        initialValue,
+        validate(rawValue) {
+          const trimmed2 = (rawValue || "").trim();
+          if (allowBack && trimmed2.toLowerCase() === "b") {
+            return;
+          }
+          return void 0;
+        }
+      });
+      if ((0, import_prompts6.isCancel)(value)) {
+        return { kind: "cancel" };
+      }
+      const trimmed = (value || "").trim();
+      if (allowBack && trimmed.toLowerCase() === "b") {
+        return { kind: "back" };
+      }
+      return { kind: "value", value: trimmed };
+    }
+  };
+}
+
+// src/ui/newBetName.ts
+var import_prompts7 = require("@clack/prompts");
+function normalizeBetName(value) {
+  return value.trim().replace(/\s+/g, "_").toLowerCase();
+}
+async function promptNewBetName() {
+  const response = await (0, import_prompts7.text)({
+    message: "Bet name",
+    placeholder: "Landing page iteration",
+    validate(input) {
+      return input.trim().length > 0 ? void 0 : "Bet name is required.";
+    }
+  });
+  if ((0, import_prompts7.isCancel)(response)) {
+    return { cancelled: true };
+  }
+  return {
+    cancelled: false,
+    value: normalizeBetName(response)
+  };
+}
+
+// src/commands/new.ts
+async function pathExists3(filePath) {
+  try {
+    await (0, import_promises7.access)(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isInteractiveTty3() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function invalidIdError(id) {
+  return `Invalid bet id '${id}'. Use id format like 'landing-page' or 'landing_page'.`;
+}
+async function runNew(rawId) {
+  let id = rawId ? normalizeBetName(rawId) : void 0;
+  if (!id) {
+    if (!isInteractiveTty3()) {
+      console.error("Missing bet name. Run 'bep new <name>' or use an interactive terminal.");
+      return 1;
+    }
+    const nameResult = await promptNewBetName();
+    if (nameResult.cancelled) {
+      console.error("Cancelled. No files were created.");
+      return 1;
+    }
+    id = normalizeBetName(nameResult.value);
+  }
+  if (!isValidBetId(id)) {
+    console.error(invalidIdError(id));
+    return 1;
+  }
+  let rootDir;
+  try {
+    const cwd = process.cwd();
+    ({ rootDir } = await ensureInitializedRepo(cwd));
+  } catch (error) {
+    console.error(error.message);
+    return 1;
+  }
+  const relativePath = import_node_path8.default.join(BETS_DIR, `${id}.md`);
+  const absolutePath = import_node_path8.default.join(rootDir, relativePath);
+  if (await pathExists3(absolutePath)) {
+    console.error(`Bet '${id}' already exists at ${relativePath}. Choose a unique id.`);
+    return 1;
+  }
+  const wizardResult = await runNewWizard();
+  if (wizardResult.cancelled) {
+    console.error("Cancelled. No files were created.");
+    return 1;
+  }
+  const markdown = renderNewBetMarkdown({
+    id,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    leadingIndicator: wizardResult.values.leadingIndicator,
+    maxHours: wizardResult.values.maxHours,
+    maxCalendarDays: wizardResult.values.maxCalendarDays,
+    primaryAssumption: wizardResult.values.primaryAssumption,
+    rationale: wizardResult.values.rationale,
+    validationPlan: wizardResult.values.validationPlan,
+    notes: wizardResult.values.notes
+  });
+  try {
+    await (0, import_promises7.writeFile)(absolutePath, markdown, { encoding: "utf8", flag: "wx" });
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      console.error(`Bet '${id}' already exists at ${relativePath}. Choose a unique id.`);
+      return 1;
+    }
+    throw error;
+  }
+  console.log(`
+Created ${relativePath}.`);
+  return 0;
+}
+
+// src/state/state.ts
+var import_promises8 = require("fs/promises");
+var import_node_path9 = __toESM(require("path"));
+function isValidActiveSession(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.id === "string" && candidate.id.length > 0 && typeof candidate.started_at === "string";
+}
+function parseState(raw) {
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("State file must contain a JSON object.");
+  }
+  const active = parsed.active;
+  if (!Array.isArray(active)) {
+    throw new Error("State file field 'active' must be an array.");
+  }
+  for (const [index, session] of active.entries()) {
+    if (!isValidActiveSession(session)) {
+      throw new Error(`State file has invalid active session at index ${index}.`);
+    }
+  }
+  return { active };
+}
+async function readState(rootDir) {
+  const statePath = import_node_path9.default.join(rootDir, STATE_PATH);
+  const raw = await (0, import_promises8.readFile)(statePath, "utf8");
+  return parseState(raw);
+}
+async function writeState(rootDir, state) {
+  const statePath = import_node_path9.default.join(rootDir, STATE_PATH);
+  await (0, import_promises8.writeFile)(statePath, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+}
+function addActiveSession(state, id, startedAt) {
+  const alreadyActive = state.active.some((session) => session.id === id);
+  if (alreadyActive) {
+    return { state, alreadyActive: true };
+  }
+  return {
+    alreadyActive: false,
+    state: {
+      active: [...state.active, { id, started_at: startedAt }]
+    }
+  };
+}
+function removeActiveSessions(state, id) {
+  const removed = state.active.filter((session) => session.id === id);
+  if (removed.length === 0) {
+    return { state, removed };
+  }
+  return {
+    removed,
+    state: {
+      active: state.active.filter((session) => session.id !== id)
+    }
+  };
+}
+
+// src/commands/start.ts
+async function runStart(id) {
+  if (!isValidBetId(id)) {
+    console.error(`Invalid bet id '${id}'. Use lowercase id format like 'landing-page' or 'landing_page'.`);
+    return 1;
+  }
+  let rootDir;
+  try {
+    const cwd = process.cwd();
+    ({ rootDir } = await ensureInitializedRepo(cwd));
+  } catch (error) {
+    console.error(error.message);
+    return 1;
+  }
+  const relativePath = getBetRelativePath(id);
+  const absolutePath = getBetAbsolutePath(rootDir, id);
+  if (!await pathExists2(absolutePath)) {
+    console.error(`Bet '${id}' does not exist at ${relativePath}. Run 'bep new ${id}' first.`);
+    return 1;
+  }
+  try {
+    await readBetFile(rootDir, id);
+  } catch (error) {
+    console.error(error.message);
+    return 1;
+  }
+  let state;
+  try {
+    state = await readState(rootDir);
+  } catch (error) {
+    console.error(`Failed to read state file at bets/_state.json: ${error.message}`);
+    return 1;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const next = addActiveSession(state, id, now);
+  if (next.alreadyActive) {
+    console.log(`Bet '${id}' is already active.`);
+    return 0;
+  }
+  try {
+    await writeState(rootDir, next.state);
+  } catch (error) {
+    console.error(`Failed to start bet '${id}': ${error.message}`);
+    return 1;
+  }
+  console.log(`Started bet '${id}'.`);
+  return 0;
+}
+
+// src/commands/stop.ts
+var import_promises9 = require("fs/promises");
+var import_node_path10 = __toESM(require("path"));
+async function runStop(id) {
+  if (!isValidBetId(id)) {
+    console.error(`Invalid bet id '${id}'. Use lowercase id format like 'landing-page' or 'landing_page'.`);
+    return 1;
+  }
+  let rootDir;
+  try {
+    const cwd = process.cwd();
+    ({ rootDir } = await ensureInitializedRepo(cwd));
+  } catch (error) {
+    console.error(error.message);
+    return 1;
+  }
+  let state;
+  try {
+    state = await readState(rootDir);
+  } catch (error) {
+    console.error(`Failed to read state file at bets/_state.json: ${error.message}`);
+    return 1;
+  }
+  const next = removeActiveSessions(state, id);
+  if (next.removed.length === 0) {
+    console.log(`Bet '${id}' is not active.`);
+    return 0;
+  }
+  const stoppedAt = /* @__PURE__ */ new Date();
+  const stoppedAtIso = stoppedAt.toISOString();
+  const logs = [];
+  for (const session of next.removed) {
+    const startedMs = Date.parse(session.started_at);
+    if (Number.isNaN(startedMs)) {
+      console.error(`Active session for '${id}' has invalid started_at: '${session.started_at}'.`);
+      return 1;
+    }
+    const durationSeconds = Math.max(0, Math.floor((stoppedAt.getTime() - startedMs) / 1e3));
+    logs.push({
+      id,
+      started_at: session.started_at,
+      stopped_at: stoppedAtIso,
+      duration_seconds: durationSeconds
+    });
+  }
+  const relativeBetPath = getBetRelativePath(id);
+  const absoluteBetPath = getBetAbsolutePath(rootDir, id);
+  const hasBetFile = await pathExists2(absoluteBetPath);
+  if (hasBetFile) {
+    try {
+      await readBetFile(rootDir, id);
+    } catch (error) {
+      console.error(error.message);
+      return 1;
+    }
+  }
+  const logPath = import_node_path10.default.join(rootDir, LOGS_DIR, `${id}.jsonl`);
+  const serializedLogs = logs.map((line) => JSON.stringify(line)).join("\n").concat("\n");
+  try {
+    await (0, import_promises9.appendFile)(logPath, serializedLogs, "utf8");
+    await writeState(rootDir, next.state);
+  } catch (error) {
+    console.error(`Failed to stop bet '${id}': ${error.message}`);
+    return 1;
+  }
+  if (!hasBetFile) {
+    console.error(`Warning: Bet file '${relativeBetPath}' is missing. Session was stopped and logged.`);
+  }
+  console.log(`Stopped bet '${id}' (${next.removed.length} session(s) logged).`);
+  return 0;
+}
+
+// src/commands/status.ts
+var import_promises10 = require("fs/promises");
+var import_node_path11 = __toESM(require("path"));
+var STATUS_COLUMNS = [
+  "id",
+  "status",
+  "active",
+  "exposureHours",
+  "cap",
+  "capPercent",
+  "warning",
+  "validation"
+];
+var STATUS_HEADERS = {
+  id: "id",
+  status: "status",
+  active: "active",
+  exposureHours: "time_h",
+  cap: "cap",
+  capPercent: "cap_%",
+  warning: "warning",
+  validation: "validation"
+};
+function formatHours(value) {
+  return value.toFixed(2);
+}
+function formatPercent(value) {
+  return `${value.toFixed(2)}%`;
+}
+function parseMaxHours(frontmatter) {
+  const value = frontmatter.max_hours;
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return null;
+  }
+  return value;
+}
+function parseMaxCalendarDays(frontmatter) {
+  const value = frontmatter.max_calendar_days;
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return null;
+  }
+  return value;
+}
+function parseCreatedAtMs(frontmatter) {
+  const value = frontmatter.created_at;
+  if (value instanceof Date) {
+    const millis2 = value.getTime();
+    return Number.isNaN(millis2) ? null : millis2;
+  }
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return null;
+  }
+  const millis = Date.parse(value);
+  if (Number.isNaN(millis)) {
+    return null;
+  }
+  return millis;
+}
+function formatValidation(snapshot) {
+  const meetsTarget = snapshot.meets_target;
+  const observedValue = snapshot.observed_value;
+  const leadingIndicator = snapshot.leading_indicator;
+  if (typeof meetsTarget !== "boolean" || typeof observedValue !== "number" || !Number.isFinite(observedValue)) {
+    return "N/A";
+  }
+  const resultLabel = meetsTarget ? "PASS" : "FAIL";
+  if (!leadingIndicator || typeof leadingIndicator !== "object") {
+    return `${resultLabel} ${observedValue}`;
+  }
+  const candidate = leadingIndicator;
+  if ((candidate.type === "manual" || candidate.type === "mixpanel") && typeof candidate.target === "number" && Number.isFinite(candidate.target) && (candidate.operator === "lt" || candidate.operator === "lte" || candidate.operator === "eq" || candidate.operator === "gte" || candidate.operator === "gt")) {
+    return `${resultLabel} ${observedValue} ${formatManualComparisonOperator(candidate.operator)} ${candidate.target}`;
+  }
+  return `${resultLabel} ${observedValue}`;
+}
+async function sumLoggedExposureSeconds(rootDir, id) {
+  const relativePath = import_node_path11.default.join(LOGS_DIR, `${id}.jsonl`);
+  const absolutePath = import_node_path11.default.join(rootDir, relativePath);
+  if (!await pathExists2(absolutePath)) {
+    return 0;
+  }
+  const raw = await (0, import_promises10.readFile)(absolutePath, "utf8");
+  if (raw.trim().length === 0) {
+    return 0;
+  }
+  let total = 0;
+  const lines = raw.split(/\r?\n/);
+  for (const [index, line] of lines.entries()) {
+    if (line.trim().length === 0) {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      throw new Error(`Failed to parse log file at ${relativePath}: invalid JSON on line ${index + 1}.`);
+    }
+    const duration = parsed.duration_seconds;
+    if (typeof duration !== "number" || !Number.isFinite(duration) || duration < 0) {
+      throw new Error(
+        `Failed to parse log file at ${relativePath}: missing numeric duration_seconds on line ${index + 1}.`
+      );
+    }
+    total += duration;
+  }
+  return total;
+}
+async function readValidationLabel(rootDir, id) {
+  const relativePath = import_node_path11.default.join(EVIDENCE_DIR, `${id}.json`);
+  const absolutePath = import_node_path11.default.join(rootDir, relativePath);
+  if (!await pathExists2(absolutePath)) {
+    return "N/A";
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(await (0, import_promises10.readFile)(absolutePath, "utf8"));
+  } catch (error) {
+    throw new Error(`Failed to parse evidence file at ${relativePath}: ${error.message}`);
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return "N/A";
+  }
+  return formatValidation(parsed);
+}
+function renderStatusTable(rows) {
+  const matrix = [
+    STATUS_COLUMNS.map((column) => STATUS_HEADERS[column]),
+    ...rows.map((row) => STATUS_COLUMNS.map((column) => row[column]))
+  ];
+  const widths = STATUS_COLUMNS.map(
+    (_column, columnIndex) => matrix.reduce((max, currentRow) => Math.max(max, currentRow[columnIndex].length), 0)
+  );
+  const rendered = matrix.map((row) => row.map((cell, index) => cell.padEnd(widths[index])).join("  "));
+  return rendered.join("\n");
+}
+async function runStatus() {
+  let rootDir;
+  try {
+    const cwd = process.cwd();
+    ({ rootDir } = await ensureInitializedRepo(cwd));
+  } catch (error) {
+    console.error(error.message);
+    return 1;
+  }
+  const betDir = import_node_path11.default.join(rootDir, BETS_DIR);
+  let dirEntries;
+  try {
+    dirEntries = await (0, import_promises10.readdir)(betDir, { withFileTypes: true });
+  } catch (error) {
+    console.error(`Failed to read bets directory at ${BETS_DIR}: ${error.message}`);
+    return 1;
+  }
+  const betFiles = dirEntries.filter((entry) => entry.isFile() && entry.name.endsWith(".md") && !entry.name.startsWith("_")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+  if (betFiles.length === 0) {
+    console.log("No bets found.");
+    return 0;
+  }
+  let activeBetIds;
+  try {
+    const state = await readState(rootDir);
+    activeBetIds = new Set(state.active.map((session) => session.id));
+  } catch (error) {
+    console.error(`Failed to read state file at bets/_state.json: ${error.message}`);
+    return 1;
+  }
+  const rows = [];
+  const nowMs = Date.now();
+  for (const fileName of betFiles) {
+    const id = fileName.slice(0, -".md".length);
+    let bet;
+    try {
+      bet = (await readBetFile(rootDir, fileName)).bet;
+    } catch (error) {
+      console.error(error.message);
+      return 1;
+    }
+    let exposureSeconds;
+    try {
+      exposureSeconds = await sumLoggedExposureSeconds(rootDir, id);
+    } catch (error) {
+      console.error(error.message);
+      return 1;
+    }
+    let validationLabel;
+    try {
+      validationLabel = await readValidationLabel(rootDir, id);
+    } catch (error) {
+      console.error(error.message);
+      return 1;
+    }
+    const frontmatter = bet.data;
+    const status = normalizeValidationStatus(frontmatter.status);
+    const maxHours = parseMaxHours(frontmatter);
+    const maxCalendarDays = maxHours === null ? parseMaxCalendarDays(frontmatter) : null;
+    const createdAtMs = maxCalendarDays === null ? null : parseCreatedAtMs(frontmatter);
+    const exposureHours = exposureSeconds / 3600;
+    let cap = "-";
+    let capPercent = null;
+    if (maxHours !== null) {
+      cap = `${formatHours(maxHours)}h`;
+      capPercent = exposureHours / maxHours * 100;
+    } else if (maxCalendarDays !== null) {
+      cap = `${maxCalendarDays.toFixed(2)}d`;
+      if (createdAtMs !== null) {
+        const elapsedCalendarDays = Math.max(0, (nowMs - createdAtMs) / (24 * 60 * 60 * 1e3));
+        capPercent = elapsedCalendarDays / maxCalendarDays * 100;
+      }
+    }
+    const warning = capPercent === null ? "-" : capPercent >= 100 ? "AT_CAP" : capPercent >= 70 ? "NEARING_CAP" : "-";
+    rows.push({
+      id,
+      status,
+      active: activeBetIds.has(id) ? "yes" : "no",
+      exposureHours: formatHours(exposureHours),
+      cap,
+      capPercent: capPercent === null ? "-" : formatPercent(capPercent),
+      warning,
+      validation: validationLabel
+    });
+  }
+  console.log(renderStatusTable(rows));
+  return 0;
+}
+
+// src/commands/hook.ts
+var import_promises14 = require("fs/promises");
+var import_node_path14 = __toESM(require("path"));
+
+// src/hooks/events.ts
+var MAX_FIELD_LENGTH = 2e3;
+function truncate(value) {
+  if (!value) {
+    return void 0;
+  }
+  return value.length > MAX_FIELD_LENGTH ? `${value.slice(0, MAX_FIELD_LENGTH)}...` : value;
+}
+function pickString(source, keys) {
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function stringifyJson(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === void 0) {
+    return void 0;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return void 0;
+  }
+}
+function parseHookStdin(raw, event) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return null;
+  }
+  const source = parsed;
+  const prompt = event === "user-prompt-submit" ? pickString(source, ["prompt", "user_prompt", "message"]) ?? stringifyJson(source["prompt"]) : void 0;
+  const toolName = event === "post-tool-use" || event === "post-tool-use-failure" ? pickString(source, ["tool_name", "toolName", "tool"]) ?? pickString(source, ["matcher"]) : void 0;
+  const toolInput = event === "post-tool-use" || event === "post-tool-use-failure" ? stringifyJson(source["tool_input"] ?? source["input"] ?? source["toolInput"]) : void 0;
+  const toolOutput = event === "post-tool-use" || event === "post-tool-use-failure" ? stringifyJson(source["tool_output"] ?? source["output"] ?? source["toolOutput"] ?? source["error"]) : void 0;
+  return {
+    sessionId: pickString(source, ["session_id", "sessionId"]),
+    prompt: truncate(prompt),
+    toolName: truncate(toolName),
+    toolInput: truncate(toolInput),
+    toolOutput: truncate(toolOutput),
+    transcriptPath: truncate(pickString(source, ["transcript_path", "transcriptPath"])),
+    cwd: truncate(pickString(source, ["cwd", "working_directory", "workingDirectory"])),
+    raw: source
+  };
+}
+async function readHookStdin() {
+  if (process.stdin.isTTY) {
+    return "";
+  }
+  return new Promise((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.on("error", (error) => reject(error));
+  });
+}
+
+// src/tracking/context.ts
+var import_promises11 = require("fs/promises");
+var import_node_path12 = __toESM(require("path"));
+var MAX_BET_SUMMARY_CHARS = 800;
+var MAX_HISTORY_ENTRIES = 20;
+function summarizeContent(content) {
+  const compact = content.replace(/\s+/g, " ").trim();
+  if (compact.length <= MAX_BET_SUMMARY_CHARS) {
+    return compact;
+  }
+  return `${compact.slice(0, MAX_BET_SUMMARY_CHARS)}...`;
+}
+function extractSection(content, heading) {
+  const pattern = new RegExp(`##\\s*${heading}\\s*\\n([\\s\\S]*?)(?=\\n##\\s|$)`, "i");
+  const match = content.match(pattern);
+  if (!match || !match[1]) {
+    return void 0;
+  }
+  return summarizeContent(match[1]);
+}
+async function readBetCatalog(rootDir) {
+  const files = await listBetMarkdownFiles(rootDir);
+  const result = [];
+  for (const fileName of files) {
+    try {
+      const parsed = await readBetFile(rootDir, fileName);
+      const id = String(parsed.bet.data.id ?? fileName.replace(/\.md$/, ""));
+      const status = normalizeValidationStatus(parsed.bet.data.status);
+      const content = parsed.bet.content || "";
+      result.push({
+        id,
+        status,
+        assumption: extractSection(content, "1\\. Primary Assumption"),
+        rationale: extractSection(content, "2\\. Rationale"),
+        validationPlan: extractSection(content, "3\\. Validation Plan"),
+        notes: extractSection(content, "4\\. Notes"),
+        summary: summarizeContent(content)
+      });
+    } catch {
+    }
+  }
+  return result;
+}
+async function readRecentAttribution(rootDir) {
+  const filePath = import_node_path12.default.join(rootDir, LOGS_DIR, "agent-attribution.jsonl");
+  let raw;
+  try {
+    raw = await (0, import_promises11.readFile)(filePath, "utf8");
+  } catch {
+    return [];
+  }
+  const lines = raw.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+  const recent = lines.slice(-MAX_HISTORY_ENTRIES);
+  const parsed = [];
+  for (const line of recent) {
+    try {
+      const value = JSON.parse(line);
+      parsed.push(value);
+    } catch {
+    }
+  }
+  return parsed;
+}
+async function buildBetSelectionContext(rootDir, event, payload) {
+  const [state, bets, recentAttribution] = await Promise.all([
+    readState(rootDir),
+    readBetCatalog(rootDir),
+    readRecentAttribution(rootDir)
+  ]);
+  return {
+    event,
+    payload,
+    activeBetIds: state.active.map((session) => session.id),
+    bets,
+    recentAttribution
+  };
+}
+
+// src/tracking/decision.ts
+var DEFAULT_CONFIDENCE_THRESHOLD = 0.75;
+var defaultDeps = {
+  start: runStart,
+  stop: runStop
+};
+function noOp(decision) {
+  return {
+    applied: false,
+    appliedSteps: [],
+    decision
+  };
+}
+function hasValidBet(decision, knownBetIds, key) {
+  const id = decision[key];
+  if (!id) {
+    return false;
+  }
+  return isValidBetId(id) && knownBetIds.has(id);
+}
+async function applySelectionDecision(context, rawDecision, deps = defaultDeps) {
+  const confidence = Number.isFinite(rawDecision.confidence) ? rawDecision.confidence : 0;
+  const decision = {
+    ...rawDecision,
+    confidence
+  };
+  const knownBetIds = new Set(context.bets.map((bet) => bet.id));
+  if (decision.confidence < DEFAULT_CONFIDENCE_THRESHOLD) {
+    return noOp({
+      ...decision,
+      action: "none",
+      reason: `${decision.reason} (below confidence threshold)`
+    });
+  }
+  if (decision.action === "none" || decision.action === "keep") {
+    return noOp(decision);
+  }
+  if (decision.action === "start") {
+    if (!hasValidBet(decision, knownBetIds, "bet_id")) {
+      return noOp({ ...decision, action: "none", reason: `${decision.reason} (invalid start bet)` });
+    }
+    const code = await deps.start(decision.bet_id);
+    if (code !== 0) {
+      return {
+        applied: false,
+        appliedSteps: [],
+        decision,
+        error: `Failed to start bet '${decision.bet_id}'.`
+      };
+    }
+    return {
+      applied: true,
+      appliedSteps: [`start:${decision.bet_id}`],
+      decision
+    };
+  }
+  if (decision.action === "stop") {
+    if (!hasValidBet(decision, knownBetIds, "bet_id")) {
+      return noOp({ ...decision, action: "none", reason: `${decision.reason} (invalid stop bet)` });
+    }
+    const code = await deps.stop(decision.bet_id);
+    if (code !== 0) {
+      return {
+        applied: false,
+        appliedSteps: [],
+        decision,
+        error: `Failed to stop bet '${decision.bet_id}'.`
+      };
+    }
+    return {
+      applied: true,
+      appliedSteps: [`stop:${decision.bet_id}`],
+      decision
+    };
+  }
+  if (decision.action === "switch") {
+    const hasStart = hasValidBet(decision, knownBetIds, "bet_id");
+    if (!hasStart) {
+      return noOp({ ...decision, action: "none", reason: `${decision.reason} (invalid switch target)` });
+    }
+    const stopId = hasValidBet(decision, knownBetIds, "stop_bet_id") ? decision.stop_bet_id : context.activeBetIds.find((id) => id !== decision.bet_id);
+    if (stopId && stopId === decision.bet_id) {
+      return noOp({ ...decision, action: "keep", reason: `${decision.reason} (switch target already active)` });
+    }
+    const appliedSteps = [];
+    if (stopId) {
+      const stopCode = await deps.stop(stopId);
+      if (stopCode !== 0) {
+        return {
+          applied: false,
+          appliedSteps,
+          decision,
+          error: `Failed to stop bet '${stopId}' during switch.`
+        };
+      }
+      appliedSteps.push(`stop:${stopId}`);
+    }
+    const startCode = await deps.start(decision.bet_id);
+    if (startCode !== 0) {
+      return {
+        applied: false,
+        appliedSteps,
+        decision,
+        error: `Failed to start bet '${decision.bet_id}' during switch.`
+      };
+    }
+    appliedSteps.push(`start:${decision.bet_id}`);
+    return {
+      applied: true,
+      appliedSteps,
+      decision
+    };
+  }
+  return noOp({ ...decision, action: "none", reason: `${decision.reason} (unsupported action)` });
+}
+
+// src/tracking/enforcement.ts
+var import_promises12 = require("fs/promises");
+var import_node_path13 = __toESM(require("path"));
+function parsePositiveNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return null;
+  }
+  return value;
+}
+function parseCreatedAtMs2(value) {
+  if (value instanceof Date) {
+    const millis2 = value.getTime();
+    return Number.isNaN(millis2) ? null : millis2;
+  }
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return null;
+  }
+  const millis = Date.parse(value);
+  if (Number.isNaN(millis)) {
+    return null;
+  }
+  return millis;
+}
+async function sumLoggedExposureSeconds2(rootDir, betId) {
+  const relativePath = import_node_path13.default.join(LOGS_DIR, `${betId}.jsonl`);
+  const absolutePath = import_node_path13.default.join(rootDir, relativePath);
+  if (!await pathExists2(absolutePath)) {
+    return 0;
+  }
+  const raw = await (0, import_promises12.readFile)(absolutePath, "utf8");
+  if (raw.trim().length === 0) {
+    return 0;
+  }
+  let total = 0;
+  const lines = raw.split(/\r?\n/);
+  for (const [index, line] of lines.entries()) {
+    if (line.trim().length === 0) {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      throw new Error(`invalid_json_line_${index + 1}`);
+    }
+    const duration = parsed.duration_seconds;
+    if (typeof duration !== "number" || !Number.isFinite(duration) || duration < 0) {
+      throw new Error(`invalid_duration_line_${index + 1}`);
+    }
+    total += duration;
+  }
+  return total;
+}
+async function calculateExposureForBet(rootDir, betId, createdAt) {
+  const seconds = await sumLoggedExposureSeconds2(rootDir, betId);
+  const hours = seconds / 3600;
+  const createdAtMs = parseCreatedAtMs2(createdAt);
+  if (createdAtMs === null) {
+    return {
+      hours,
+      calendarDays: null
+    };
+  }
+  const calendarDays = Math.max(0, (Date.now() - createdAtMs) / (24 * 60 * 60 * 1e3));
+  return {
+    hours,
+    calendarDays
+  };
+}
+function selectGateTargetBet(context, decision) {
+  if (decision.bet_id && isValidBetId(decision.bet_id)) {
+    return decision.bet_id;
+  }
+  if (decision.action === "switch" && decision.bet_id && isValidBetId(decision.bet_id)) {
+    return decision.bet_id;
+  }
+  if (context.activeBetIds.length === 1) {
+    const active = context.activeBetIds[0];
+    return isValidBetId(active) ? active : null;
+  }
+  return null;
+}
+async function evaluateCapGate(rootDir, context, decision) {
+  const targetBetId = selectGateTargetBet(context, decision);
+  if (!targetBetId) {
+    return {
+      overCap: false,
+      reason: "no_target_bet"
+    };
+  }
+  const catalogEntry = context.bets.find((bet2) => bet2.id === targetBetId);
+  if (catalogEntry?.status === "passed") {
+    return {
+      targetBetId,
+      overCap: false,
+      reason: "bet_passed"
+    };
+  }
+  let bet;
+  try {
+    bet = (await readBetFile(rootDir, targetBetId)).bet;
+  } catch {
+    return {
+      targetBetId,
+      overCap: false,
+      reason: "target_bet_unreadable"
+    };
+  }
+  const maxHours = parsePositiveNumber(bet.data.max_hours);
+  const maxCalendarDays = maxHours === null ? parsePositiveNumber(bet.data.max_calendar_days) : null;
+  if (maxHours === null && maxCalendarDays === null) {
+    return {
+      targetBetId,
+      overCap: false,
+      reason: "no_cap_configured"
+    };
+  }
+  let exposure;
+  try {
+    exposure = await calculateExposureForBet(rootDir, targetBetId, bet.data.created_at);
+  } catch (error) {
+    return {
+      targetBetId,
+      overCap: false,
+      reason: `cap_eval_failed:${error.message}`
+    };
+  }
+  if (maxHours !== null) {
+    const usedValue2 = exposure.hours;
+    const percentUsed2 = usedValue2 / maxHours * 100;
+    return {
+      targetBetId,
+      capType: "max_hours",
+      capValue: maxHours,
+      usedValue: usedValue2,
+      percentUsed: percentUsed2,
+      overCap: percentUsed2 >= 100,
+      reason: percentUsed2 >= 100 ? "at_or_over_cap" : "under_cap"
+    };
+  }
+  const usedValue = exposure.calendarDays;
+  if (usedValue === null || maxCalendarDays === null) {
+    return {
+      targetBetId,
+      capType: "max_calendar_days",
+      capValue: maxCalendarDays ?? void 0,
+      overCap: false,
+      reason: "calendar_cap_missing_created_at"
+    };
+  }
+  const percentUsed = usedValue / maxCalendarDays * 100;
+  return {
+    targetBetId,
+    capType: "max_calendar_days",
+    capValue: maxCalendarDays,
+    usedValue,
+    percentUsed,
+    overCap: percentUsed >= 100,
+    reason: percentUsed >= 100 ? "at_or_over_cap" : "under_cap"
+  };
+}
+
+// src/tracking/selector.ts
+var import_node_child_process = require("child_process");
+var import_promises13 = require("fs/promises");
+var import_node_os = __toESM(require("os"));
+var DEBUG = true;
+var SELECTION_TIMEOUT_MS = 6e4;
+var OUTPUT_FORMAT_INSTRUCTION = "Return only one JSON object. Do not include markdown fences, commentary, or extra keys.";
+function sanitizeForJson(value) {
+  if (value instanceof Error) {
+    return { name: value.name, message: value.message, stack: value.stack };
+  }
+  if (typeof value === "bigint") {
+    return String(value);
+  }
+  return value;
+}
+async function writeDebug(debugLogPath, entry) {
+  if (!DEBUG || !debugLogPath) {
+    return;
+  }
+  try {
+    await (0, import_promises13.appendFile)(
+      debugLogPath,
+      `${JSON.stringify({
+        ...entry,
+        data: entry.data ? Object.fromEntries(Object.entries(entry.data).map(([key, value]) => [key, sanitizeForJson(value)])) : void 0
+      })}
+`,
+      "utf8"
+    );
+  } catch {
+  }
+}
+function stripGitEnv(env) {
+  const next = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (key.startsWith("GIT_")) {
+      continue;
+    }
+    next[key] = value;
+  }
+  return next;
+}
+async function defaultRunClaude({ prompt, timeoutMs, onDebug }) {
+  return new Promise((resolve, reject) => {
+    void onDebug?.("spawn_start", "Starting claude selector subprocess.", {
+      command: "claude",
+      args: ["--print", "--output-format", "json", "--model", "sonnet", "--setting-sources", ""],
+      cwd: import_node_os.default.tmpdir(),
+      timeoutMs
+    });
+    const child = (0, import_node_child_process.spawn)(
+      "claude",
+      ["--print", "--output-format", "json", "--model", "sonnet", "--setting-sources", ""],
+      {
+        cwd: import_node_os.default.tmpdir(),
+        env: stripGitEnv(process.env),
+        stdio: ["pipe", "pipe", "pipe"]
+      }
+    );
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+    }, timeoutMs);
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+      void onDebug?.("spawn_stdout_chunk", "Received stdout chunk from claude selector.", { chunk });
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+      void onDebug?.("spawn_stderr_chunk", "Received stderr chunk from claude selector.", { chunk });
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      void onDebug?.("spawn_close", "Claude selector subprocess closed.", { code, timedOut, stderr });
+      if (timedOut) {
+        reject(new Error(`Claude selector timed out after ${timeoutMs}ms.`));
+        return;
+      }
+      if (code !== 0) {
+        reject(new Error(`Claude selector failed with exit code ${code}: ${stderr.trim()}`));
+        return;
+      }
+      resolve(stdout);
+    });
+    child.stdin.end(prompt);
+  });
+}
+function maybeExtractJsonFromMarkdown(value) {
+  const trimmed = value.trim();
+  const match = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  if (match && match[1]) {
+    return match[1].trim();
+  }
+  return trimmed;
+}
+function extractDecisionFromArrayEnvelope(events) {
+  const typed = events.filter((entry) => entry && typeof entry === "object");
+  const resultEvent = typed.find((entry) => entry.type === "result" && typeof entry.result === "string");
+  if (resultEvent && typeof resultEvent.result === "string") {
+    const body = maybeExtractJsonFromMarkdown(resultEvent.result);
+    return JSON.parse(body);
+  }
+  const assistantEvent = typed.find((entry) => entry.type === "assistant" && Array.isArray(entry.message?.content));
+  if (!assistantEvent || !Array.isArray(assistantEvent.message?.content)) {
+    return null;
+  }
+  for (const block of assistantEvent.message.content) {
+    if (block?.type !== "text" || typeof block.text !== "string") {
+      continue;
+    }
+    const body = maybeExtractJsonFromMarkdown(block.text);
+    return JSON.parse(body);
+  }
+  return null;
+}
+function toDecision(raw, knownIds) {
+  if (!raw || typeof raw !== "object") {
+    return null;
+  }
+  const candidate = raw;
+  const action = candidate.action;
+  const confidence = candidate.confidence;
+  const reason = candidate.reason;
+  if (action !== "start" && action !== "stop" && action !== "switch" && action !== "keep" && action !== "none") {
+    return null;
+  }
+  if (typeof confidence !== "number" || !Number.isFinite(confidence)) {
+    return null;
+  }
+  if (typeof reason !== "string" || reason.trim().length === 0) {
+    return null;
+  }
+  const betId = typeof candidate.bet_id === "string" ? candidate.bet_id : void 0;
+  const stopBetId = typeof candidate.stop_bet_id === "string" ? candidate.stop_bet_id : void 0;
+  if (betId && (!isValidBetId(betId) || !knownIds.has(betId))) {
+    return null;
+  }
+  if (stopBetId && (!isValidBetId(stopBetId) || !knownIds.has(stopBetId))) {
+    return null;
+  }
+  return {
+    action,
+    bet_id: betId,
+    stop_bet_id: stopBetId,
+    confidence,
+    reason: reason.trim()
+  };
+}
+function buildPrompt(context) {
+  const bets = context.bets.map((bet) => ({
+    id: bet.id,
+    status: bet.status,
+    assumption: bet.assumption,
+    rationale: bet.rationale,
+    validation_plan: bet.validationPlan,
+    notes: bet.notes,
+    summary: bet.summary
+  })).slice(0, 50);
+  const payload = context.payload ? {
+    session_id: context.payload.sessionId,
+    prompt: context.payload.prompt,
+    tool_name: context.payload.toolName,
+    tool_input: context.payload.toolInput,
+    tool_output: context.payload.toolOutput,
+    transcript_path: context.payload.transcriptPath,
+    cwd: context.payload.cwd
+  } : null;
+  const recent = context.recentAttribution.map((entry) => ({
+    at: entry.at,
+    event: entry.event,
+    session_id: entry.session_id,
+    decision: entry.decision
+  }));
+  const eventSpecificPolicy = context.event === "session-end" ? [
+    "Event-specific policy for session-end:",
+    "- If an active bet exists, prefer action 'stop' for the current/inferred active bet.",
+    "- Action 'keep' is generally incorrect at session end unless there is a strong explicit reason.",
+    "- Use action 'none' only when no active/inferable bet can be identified."
+  ] : context.event === "user-prompt-submit" ? [
+    "Event-specific policy for user-prompt-submit:",
+    "- Use 'start' or 'switch' only when intent is explicit or strongly inferred.",
+    "- Prefer 'none' when intent is weak or ambiguous."
+  ] : [
+    "Event-specific policy for tool events:",
+    "- Treat tool events as reinforcement signals, not sole evidence for high-confidence switches.",
+    "- Prefer 'none' when evidence is insufficient."
+  ];
+  return [
+    "You are selecting BEP bet attribution actions for a coding session.",
+    "Constraints:",
+    "- Choose only bet IDs listed in provided bets.",
+    "- Prefer action 'none' when uncertain.",
+    "- Never invent bet IDs.",
+    "- Output must follow the required JSON schema.",
+    OUTPUT_FORMAT_INSTRUCTION,
+    "",
+    "Action semantics:",
+    "- start: begin tracking a specific bet.",
+    "- stop: pause tracking a specific active bet.",
+    "- switch: stop old bet and start new bet when shift is clear.",
+    "- keep: tracking should remain unchanged (discouraged for session-end).",
+    "- none: insufficient evidence or no valid target.",
+    "",
+    ...eventSpecificPolicy,
+    "",
+    "Required JSON schema:",
+    '{"action":"start|stop|switch|keep|none","bet_id":"optional","stop_bet_id":"optional","confidence":0-1,"reason":"short"}',
+    "",
+    "Context JSON:",
+    JSON.stringify(
+      {
+        event: context.event,
+        active_bets: context.activeBetIds,
+        payload,
+        bets,
+        recent_attribution: recent
+      },
+      null,
+      2
+    )
+  ].join("\n");
+}
+async function selectBetWithClaude(context, runClaudeOrOptions = defaultRunClaude, maybeOptions = {}) {
+  const runClaude = typeof runClaudeOrOptions === "function" ? runClaudeOrOptions : defaultRunClaude;
+  const options = typeof runClaudeOrOptions === "function" ? maybeOptions : runClaudeOrOptions;
+  const debugLog = (stage, message, data) => writeDebug(options.debugLogPath, {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    stage,
+    event: context.event,
+    session_id: context.payload?.sessionId,
+    message,
+    data
+  });
+  if (context.bets.length === 0) {
+    await debugLog("return_ok", "No bets available. Returning no-op decision.");
+    return {
+      ok: true,
+      decision: {
+        action: "none",
+        confidence: 1,
+        reason: "No bets available for attribution."
+      },
+      rawText: ""
+    };
+  }
+  const prompt = buildPrompt(context);
+  await debugLog("build_prompt", "Built Claude selector prompt.", {
+    prompt,
+    activeBetIds: context.activeBetIds,
+    betIds: context.bets.map((bet) => bet.id)
+  });
+  let rawText = "";
+  try {
+    rawText = await runClaude({
+      prompt,
+      timeoutMs: SELECTION_TIMEOUT_MS,
+      onDebug: (stage, message, data) => {
+        void debugLog(stage, message, data);
+      }
+    });
+  } catch (error) {
+    await debugLog("return_error", "Claude selector subprocess failed.", {
+      error
+    });
+    return {
+      ok: false,
+      error: `Failed to run Claude selector: ${error.message}`
+    };
+  }
+  const trimmed = rawText.trim();
+  if (trimmed.length === 0) {
+    await debugLog("return_error", "Claude selector returned empty output.");
+    return {
+      ok: false,
+      error: "Claude selector returned empty output.",
+      rawText
+    };
+  }
+  let outer;
+  try {
+    await debugLog("parse_outer_json", "Parsing outer Claude output JSON.", { rawText });
+    outer = JSON.parse(trimmed);
+  } catch {
+    await debugLog("return_error", "Failed to parse outer Claude output as JSON.", { rawText });
+    return {
+      ok: false,
+      error: "Claude selector returned non-JSON output.",
+      rawText
+    };
+  }
+  let decisionValue = outer;
+  if (Array.isArray(outer)) {
+    try {
+      await debugLog("parse_result_json", "Parsing Claude array envelope.", { eventCount: outer.length });
+      decisionValue = extractDecisionFromArrayEnvelope(outer);
+    } catch {
+      await debugLog("return_error", "Failed to parse decision from Claude array envelope.", { rawText });
+      return {
+        ok: false,
+        error: "Claude selector array envelope did not contain valid JSON decision.",
+        rawText
+      };
+    }
+    if (!decisionValue) {
+      await debugLog("return_error", "Claude array envelope missing decision payload.", { rawText });
+      return {
+        ok: false,
+        error: "Claude selector array envelope did not include a decision payload.",
+        rawText
+      };
+    }
+  } else if (outer && typeof outer === "object" && typeof outer.result === "string") {
+    const body = maybeExtractJsonFromMarkdown(outer.result ?? "");
+    try {
+      await debugLog("parse_result_json", "Parsing Claude envelope result JSON.", { body });
+      decisionValue = JSON.parse(body);
+    } catch {
+      await debugLog("return_error", "Failed to parse Claude envelope result JSON.", { body, rawText });
+      return {
+        ok: false,
+        error: "Claude selector result field did not contain valid JSON decision.",
+        rawText
+      };
+    }
+  }
+  const knownIds = new Set(context.bets.map((bet) => bet.id));
+  const parsedDecision = toDecision(decisionValue, knownIds);
+  await debugLog("validate_decision", "Validating selector decision schema.", {
+    decisionValue,
+    knownIds: Array.from(knownIds),
+    valid: parsedDecision !== null
+  });
+  if (!parsedDecision) {
+    await debugLog("return_error", "Selector decision failed schema validation.", { decisionValue, rawText });
+    return {
+      ok: false,
+      error: "Claude selector decision failed schema validation.",
+      rawText
+    };
+  }
+  if (context.event === "session-end" && parsedDecision.action === "keep") {
+    await debugLog("validate_decision", "Session-end returned keep; this conflicts with preferred stop policy.", {
+      decision: parsedDecision,
+      activeBetIds: context.activeBetIds
+    });
+  }
+  await debugLog("return_ok", "Selector decision parsed successfully.", {
+    decision: parsedDecision
+  });
+  return {
+    ok: true,
+    decision: parsedDecision,
+    rawText
+  };
+}
+
+// src/commands/hook.ts
+var defaultDeps2 = {
+  readInput: readHookStdin,
+  select: selectBetWithClaude,
+  apply: applySelectionDecision,
+  append: import_promises14.appendFile,
+  writeOutput: (output) => process.stdout.write(output)
+};
+function isHookEvent(value) {
+  return value === "user-prompt-submit" || value === "post-tool-use" || value === "post-tool-use-failure" || value === "session-end";
+}
+function selectLogDecision(selection, applied) {
+  if (applied) {
+    return applied.decision;
+  }
+  if (selection.ok) {
+    return selection.decision;
+  }
+  return {
+    action: "none",
+    confidence: 0,
+    reason: selection.error
+  };
+}
+async function runHook(agent, event, deps = defaultDeps2) {
+  if (!isSupportedHookAgent(agent)) {
+    console.error(`Unsupported hook agent '${agent}'. Only 'claude-code' is supported.`);
+    return 1;
+  }
+  if (!isHookEvent(event)) {
+    console.error(
+      `Unsupported hook event '${event}'. Use one of: user-prompt-submit, post-tool-use, post-tool-use-failure, session-end.`
+    );
+    return 1;
+  }
+  const found = await findInitializedRepo(process.cwd());
+  if (!found) {
+    return 0;
+  }
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const writeOutput = deps.writeOutput ?? defaultDeps2.writeOutput;
+  const rawInput = await deps.readInput().catch(() => "");
+  const payload = parseHookStdin(rawInput, event);
+  let selection;
+  let applied = null;
+  let error = null;
+  let promptDenied = false;
+  let promptDenyReason = null;
+  let blockLine = null;
+  try {
+    const context = await buildBetSelectionContext(found.rootDir, event, payload);
+    const debugLogPath = import_node_path14.default.join(found.rootDir, LOGS_DIR, "hook_debug.log");
+    selection = await deps.select(context, { debugLogPath });
+    if (selection.ok) {
+      const gate = await evaluateCapGate(found.rootDir, context, selection.decision);
+      if (gate.overCap) {
+        blockLine = {
+          at,
+          agent,
+          event,
+          session_id: payload?.sessionId,
+          bet_id: gate.targetBetId,
+          cap_type: gate.capType,
+          cap_value: gate.capValue,
+          used_value: gate.usedValue,
+          percent_used: gate.percentUsed,
+          over_cap: true,
+          enforced: event === "user-prompt-submit",
+          reason: gate.reason
+        };
+      }
+      if (event === "user-prompt-submit" && gate.overCap) {
+        promptDenied = true;
+        promptDenyReason = `Bet '${gate.targetBetId ?? "unknown"}' is at cap (${(gate.usedValue ?? 0).toFixed(2)} ${gate.capType === "max_calendar_days" ? "days" : "hours"} / ${(gate.capValue ?? 0).toFixed(2)} ${gate.capType === "max_calendar_days" ? "days" : "hours"}, ${(gate.percentUsed ?? 0).toFixed(2)}%). Update bets/${gate.targetBetId}.md to extend cap or change status before continuing.`;
+      } else {
+        applied = await deps.apply(context, selection.decision);
+        if (applied.error) {
+          error = applied.error;
+        }
+      }
+    } else {
+      error = selection.error;
+    }
+  } catch (caught) {
+    const message = caught.message;
+    selection = {
+      ok: false,
+      error: `Hook attribution failed: ${message}`
+    };
+    error = selection.error;
+  }
+  const decision = selectLogDecision(selection, applied);
+  const attributionLine = {
+    at,
+    agent,
+    event,
+    session_id: payload?.sessionId,
+    decision,
+    applied: applied?.applied ?? false,
+    applied_steps: applied?.appliedSteps ?? [],
+    error
+  };
+  const sessionLine = {
+    agent,
+    event,
+    at,
+    session_id: payload?.sessionId,
+    bet_id: decision.bet_id,
+    confidence: decision.confidence,
+    applied: applied?.applied ?? false
+  };
+  const attributionPath = import_node_path14.default.join(found.rootDir, LOGS_DIR, "agent-attribution.jsonl");
+  const sessionPath = import_node_path14.default.join(found.rootDir, LOGS_DIR, "agent-sessions.jsonl");
+  const blocksPath = import_node_path14.default.join(found.rootDir, LOGS_DIR, "agent-blocks.jsonl");
+  if (blockLine) {
+    await deps.append(blocksPath, `${JSON.stringify(blockLine)}
+`, "utf8");
+  }
+  await deps.append(attributionPath, `${JSON.stringify(attributionLine)}
+`, "utf8");
+  await deps.append(sessionPath, `${JSON.stringify(sessionLine)}
+`, "utf8");
+  if (event === "user-prompt-submit" && promptDenied) {
+    writeOutput?.(JSON.stringify({ continue: false, stopReason: promptDenyReason ?? "Bet is hard-blocked at cap." }));
+    return 0;
+  }
+  if (event === "user-prompt-submit") {
+    writeOutput?.(JSON.stringify({ continue: true }));
+    return 0;
+  }
+  writeOutput?.(JSON.stringify({ continue: true }));
+  return 0;
+}
+
+// src/cli.ts
+async function main(argv) {
+  const program = new import_commander.Command();
+  program.name("bep").description("Budgeted Engineering Proposals CLI");
+  program.command("init").description("Initialize BEP directories in the current repository").option("--install-hooks", "Install agent tracking hooks").option("--no-install-hooks", "Skip agent tracking hook setup").option("--agent <agent>", "Agent target for hook setup (currently: claude-code)").action(async (options) => {
+    const exitCode = await runInit({
+      installHooks: options.installHooks,
+      agent: options.agent
+    });
+    process.exitCode = exitCode;
+  });
+  program.command("new [id...]").description("Create a new BEP markdown file").action(async (idParts) => {
+    const id = idParts && idParts.length > 0 ? ["new", ...idParts].join(" ") : void 0;
+    const exitCode = await runNew(id);
+    process.exitCode = exitCode;
+  });
+  program.command("start <id>").description("Start work on an existing BEP").action(async (id) => {
+    const exitCode = await runStart(id);
+    process.exitCode = exitCode;
+  });
+  program.command("stop <id>").description("Stop work on an active BEP and log session exposure").action(async (id) => {
+    const exitCode = await runStop(id);
+    process.exitCode = exitCode;
+  });
+  program.command("status").description("Show status for current bets").action(async () => {
+    const exitCode = await runStatus();
+    process.exitCode = exitCode;
+  });
+  program.command("check <id>").description("Capture validation evidence for a BEP").option("-f, --force", "Re-run provider check even if bet status is passed").action(async (id, options) => {
+    const exitCode = await runCheck(id, { force: options.force });
+    process.exitCode = exitCode;
+  });
+  program.command("hook <agent> <event>").description("Internal command used by agent hook integrations").action(async (agent, event) => {
+    const exitCode = await runHook(agent, event);
+    process.exitCode = exitCode;
+  });
+  await program.parseAsync(argv);
+}
+if (require.main === module) {
+  void main(process.argv);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});
+//# sourceMappingURL=cli.js.map