@samboyd/bep-cli 0.1.0 → 0.1.1

package/dist/cli.js

@@ -1,54 +1,23 @@
 #!/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");
+import path15 from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
 
 // src/fs/init.ts
-var import_promises2 = require("fs/promises");
-var import_node_path2 = __toESM(require("path"));
+import { access, mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import path2 from "path";
 
 // src/providers/config.ts
-var import_promises = require("fs/promises");
-var import_node_path = __toESM(require("path"));
+import { readFile } from "fs/promises";
+import path from "path";
 var PROVIDER_CONFIG_PATH = ".bep.providers.json";
 async function readProviderConfig(rootDir) {
-  const configPath = import_node_path.default.join(rootDir, PROVIDER_CONFIG_PATH);
+  const configPath = path.join(rootDir, PROVIDER_CONFIG_PATH);
   let raw;
   try {
-    raw = await (0, import_promises.readFile)(configPath, "utf8");
+    raw = await readFile(configPath, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return {
@@ -102,9 +71,9 @@ function getMixpanelServiceAccountCreds(config) {
 
 // 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 LOGS_DIR = path2.join(BETS_DIR, "_logs");
+var EVIDENCE_DIR = path2.join(BETS_DIR, "_evidence");
+var STATE_PATH = path2.join(BETS_DIR, "_state.json");
 var GITIGNORE_PATH = ".gitignore";
 var PROVIDER_GITIGNORE_ENTRY = ".bep.providers.json";
 var DEFAULT_STATE = {
@@ -118,7 +87,7 @@ var DEFAULT_PROVIDER_CONFIG = {
 var REQUIRED_INIT_PATHS = [BETS_DIR, LOGS_DIR, EVIDENCE_DIR, STATE_PATH];
 async function pathExists(filePath) {
   try {
-    await (0, import_promises2.access)(filePath);
+    await access(filePath);
     return true;
   } catch {
     return false;
@@ -127,24 +96,24 @@ async function pathExists(filePath) {
 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 absoluteDir = path2.join(rootDir, relativeDir);
     const existed = await pathExists(absoluteDir);
-    await (0, import_promises2.mkdir)(absoluteDir, { recursive: true });
+    await mkdir(absoluteDir, { recursive: true });
     if (!existed) {
       createdPaths.push(relativeDir);
     }
   }
-  const statePath = import_node_path2.default.join(rootDir, STATE_PATH);
+  const statePath = path2.join(rootDir, STATE_PATH);
   const stateExists = await pathExists(statePath);
   if (!stateExists) {
-    await (0, import_promises2.writeFile)(statePath, `${JSON.stringify(DEFAULT_STATE, null, 2)}
+    await 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 providerConfigPath = path2.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)}
+    await writeFile(providerConfigPath, `${JSON.stringify(DEFAULT_PROVIDER_CONFIG, null, 2)}
 `, "utf8");
     createdPaths.push(PROVIDER_CONFIG_PATH);
   }
@@ -158,12 +127,12 @@ async function initRepo(rootDir) {
   };
 }
 async function findGitRepoRoot(startDir) {
-  let currentDir = import_node_path2.default.resolve(startDir);
+  let currentDir = path2.resolve(startDir);
   while (true) {
-    if (await pathExists(import_node_path2.default.join(currentDir, ".git"))) {
+    if (await pathExists(path2.join(currentDir, ".git"))) {
       return currentDir;
     }
-    const parentDir = import_node_path2.default.dirname(currentDir);
+    const parentDir = path2.dirname(currentDir);
     if (parentDir === currentDir) {
       return null;
     }
@@ -171,26 +140,26 @@ async function findGitRepoRoot(startDir) {
   }
 }
 async function ensureGitignoreEntry(gitRoot, createdPaths) {
-  const gitignorePath = import_node_path2.default.join(gitRoot, GITIGNORE_PATH);
+  const gitignorePath = path2.join(gitRoot, GITIGNORE_PATH);
   const exists = await pathExists(gitignorePath);
   if (!exists) {
-    await (0, import_promises2.writeFile)(gitignorePath, `${PROVIDER_GITIGNORE_ENTRY}
+    await writeFile(gitignorePath, `${PROVIDER_GITIGNORE_ENTRY}
 `, "utf8");
     createdPaths.push(GITIGNORE_PATH);
     return;
   }
-  const raw = await (0, import_promises2.readFile)(gitignorePath, "utf8");
+  const raw = await readFile2(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}
+  await 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);
+    const absolutePath = path2.join(candidateRootDir, relativePath);
     if (!await pathExists(absolutePath)) {
       return false;
     }
@@ -198,15 +167,15 @@ async function isInitializedRepoRoot(candidateRootDir) {
   return true;
 }
 async function findInitializedRepo(startDir) {
-  let currentDir = import_node_path2.default.resolve(startDir);
+  let currentDir = path2.resolve(startDir);
   while (true) {
     if (await isInitializedRepoRoot(currentDir)) {
       return {
         rootDir: currentDir,
-        betsDir: import_node_path2.default.join(currentDir, BETS_DIR)
+        betsDir: path2.join(currentDir, BETS_DIR)
       };
     }
-    const parentDir = import_node_path2.default.dirname(currentDir);
+    const parentDir = path2.dirname(currentDir);
     if (parentDir === currentDir) {
       return null;
     }
@@ -222,23 +191,23 @@ async function ensureInitializedRepo(startDir) {
 }
 
 // src/hooks/install.ts
-var import_node_path5 = __toESM(require("path"));
+import path5 from "path";
 
 // src/hooks/discovery.ts
-var import_promises3 = require("fs/promises");
-var import_node_path3 = __toESM(require("path"));
+import { stat } from "fs/promises";
+import path3 from "path";
 async function findNearestClaudeDir(startDir) {
-  let currentDir = import_node_path3.default.resolve(startDir);
+  let currentDir = path3.resolve(startDir);
   while (true) {
-    const candidate = import_node_path3.default.join(currentDir, ".claude");
+    const candidate = path3.join(currentDir, ".claude");
     try {
-      const stats = await (0, import_promises3.stat)(candidate);
+      const stats = await stat(candidate);
       if (stats.isDirectory()) {
         return candidate;
       }
     } catch {
     }
-    const parentDir = import_node_path3.default.dirname(currentDir);
+    const parentDir = path3.dirname(currentDir);
     if (parentDir === currentDir) {
       return null;
     }
@@ -247,8 +216,8 @@ async function findNearestClaudeDir(startDir) {
 }
 
 // src/hooks/claude.ts
-var import_promises4 = require("fs/promises");
-var import_node_path4 = __toESM(require("path"));
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import path4 from "path";
 var CLAUDE_SETTINGS_FILE = "settings.json";
 var HOOK_EVENTS = [
   { event: "UserPromptSubmit", suffix: "user-prompt-submit" },
@@ -297,10 +266,10 @@ function ensureCommand(settings, event, command) {
   return true;
 }
 async function installClaudeCodeHooks(claudeDir, hookCommandBase) {
-  const settingsPath = import_node_path4.default.join(claudeDir, CLAUDE_SETTINGS_FILE);
+  const settingsPath = path4.join(claudeDir, CLAUDE_SETTINGS_FILE);
   let settings = {};
   try {
-    const raw = await (0, import_promises4.readFile)(settingsPath, "utf8");
+    const raw = await readFile3(settingsPath, "utf8");
     settings = parseSettings(raw);
   } catch (error) {
     const code = error.code;
@@ -315,7 +284,7 @@ async function installClaudeCodeHooks(claudeDir, hookCommandBase) {
       addedCommands += 1;
     }
   }
-  await (0, import_promises4.writeFile)(settingsPath, `${JSON.stringify(settings, null, 2)}
+  await writeFile2(settingsPath, `${JSON.stringify(settings, null, 2)}
 `, "utf8");
   return {
     claudeDir,
@@ -373,7 +342,7 @@ function resolveHookCommandBase(startDir) {
   if (!argv1) {
     return "bep";
   }
-  const resolved = import_node_path5.default.isAbsolute(argv1) ? argv1 : import_node_path5.default.resolve(startDir, argv1);
+  const resolved = path5.isAbsolute(argv1) ? argv1 : path5.resolve(startDir, argv1);
   return quoteShellArg(resolved);
 }
 async function installAgentHooks(startDir, agent) {
@@ -390,7 +359,7 @@ async function installAgentHooks(startDir, agent) {
   }
   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);
+  const settingsPathRelative = path5.relative(startDir, installed.settingsPath) || path5.basename(installed.settingsPath);
   return {
     ok: true,
     agent: resolved.value,
@@ -400,7 +369,7 @@ async function installAgentHooks(startDir, agent) {
 }
 
 // src/ui/initHooks.ts
-var import_prompts = require("@clack/prompts");
+import { confirm, isCancel, select } from "@clack/prompts";
 var COMING_SOON_AGENTS = ["cursor", "codex", "windsurf"];
 async function runInitHookPrompt(client = createInitHookPromptClient()) {
   const shouldInstall = await client.promptInstallNow();
@@ -424,17 +393,17 @@ async function runInitHookPrompt(client = createInitHookPromptClient()) {
 function createInitHookPromptClient() {
   return {
     async promptInstallNow() {
-      const value = await (0, import_prompts.confirm)({
+      const value = await confirm({
         message: "Install agent tracking hooks now?",
         initialValue: true
       });
-      if ((0, import_prompts.isCancel)(value)) {
+      if (isCancel(value)) {
         return "cancel";
       }
       return value;
     },
     async promptAgent() {
-      const value = await (0, import_prompts.select)({
+      const value = await select({
         message: "Choose an agent",
         options: [
           { label: "Claude Code", value: "claude-code" },
@@ -444,7 +413,7 @@ function createInitHookPromptClient() {
         ],
         initialValue: "claude-code"
       });
-      if ((0, import_prompts.isCancel)(value)) {
+      if (isCancel(value)) {
         return "cancel";
       }
       return value;
@@ -509,9 +478,9 @@ async function runInit(options = {}) {
 }
 
 // src/commands/check.ts
-var import_promises6 = require("fs/promises");
-var import_node_path7 = __toESM(require("path"));
-var import_prompts5 = require("@clack/prompts");
+import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import path7 from "path";
+import { isCancel as isCancel3, select as select2 } from "@clack/prompts";
 
 // src/bep/id.ts
 var BET_ID_REGEX = /^[a-z0-9]+(?:[-_][a-z0-9]+)*$/;
@@ -525,19 +494,19 @@ function normalizeValidationStatus(value) {
 }
 
 // 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"));
+import { access as access2, readdir, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import path6 from "path";
+import matter from "gray-matter";
 function getBetRelativePath(idOrFileName) {
   const fileName = idOrFileName.endsWith(".md") ? idOrFileName : `${idOrFileName}.md`;
-  return import_node_path6.default.join(BETS_DIR, fileName);
+  return path6.join(BETS_DIR, fileName);
 }
 function getBetAbsolutePath(rootDir, idOrFileName) {
-  return import_node_path6.default.join(rootDir, getBetRelativePath(idOrFileName));
+  return path6.join(rootDir, getBetRelativePath(idOrFileName));
 }
 async function pathExists2(filePath) {
   try {
-    await (0, import_promises5.access)(filePath);
+    await access2(filePath);
     return true;
   } catch {
     return false;
@@ -548,13 +517,13 @@ async function readBetFile(rootDir, idOrFileName) {
   const absolutePath = getBetAbsolutePath(rootDir, idOrFileName);
   let markdown;
   try {
-    markdown = await (0, import_promises5.readFile)(absolutePath, "utf8");
+    markdown = await readFile4(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);
+    parsed = matter(markdown);
   } catch (error) {
     throw new Error(`Failed to parse BEP file at ${relativePath}: ${error.message}`);
   }
@@ -569,24 +538,21 @@ async function readBetFile(rootDir, idOrFileName) {
   };
 }
 async function listBetMarkdownFiles(rootDir) {
-  const betsDir = import_node_path6.default.join(rootDir, BETS_DIR);
-  const entries = await (0, import_promises5.readdir)(betsDir, { withFileTypes: true });
+  const betsDir = path6.join(rootDir, BETS_DIR);
+  const entries = await 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");
+  await writeFile3(absolutePath, matter.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");
+import { isCancel as isCancel2, text } from "@clack/prompts";
 function createClackCheckPromptClient() {
   return {
     async promptObservedValue() {
-      return (0, import_prompts2.text)({
+      return text({
         message: "Observed value (required, numeric)",
         validate(rawValue) {
           const trimmed = rawValue.trim();
@@ -597,7 +563,7 @@ function createClackCheckPromptClient() {
       });
     },
     async promptNotes() {
-      return (0, import_prompts2.text)({
+      return text({
         message: "Notes (optional)"
       });
     }
@@ -605,11 +571,11 @@ function createClackCheckPromptClient() {
 }
 async function runCheckPrompt(client = createClackCheckPromptClient()) {
   const observed = await client.promptObservedValue();
-  if ((0, import_prompts2.isCancel)(observed)) {
+  if (isCancel2(observed)) {
     return { cancelled: true };
   }
   const notes = await client.promptNotes();
-  if ((0, import_prompts2.isCancel)(notes)) {
+  if (isCancel2(notes)) {
     return { cancelled: true };
   }
   const observedValue = Number(observed.trim());
@@ -622,9 +588,6 @@ async function runCheckPrompt(client = createClackCheckPromptClient()) {
 }
 
 // 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";
 }
@@ -681,58 +644,6 @@ function formatManualComparisonOperator(operator) {
   }
   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) {
@@ -750,81 +661,13 @@ var manualAdapter = {
     };
   }
 };
-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
+  adapter: manualAdapter
 };
 
 // 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";
+import { Buffer } from "buffer";
 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";
 }
@@ -863,139 +706,6 @@ function parseMixpanelLeadingIndicator(input) {
     }
   };
 }
-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];
@@ -1060,7 +770,7 @@ var mixpanelAdapter = {
       bookmark_id: indicator.bookmark_id
     });
     const url = `${MIXPANEL_REPORT_ENDPOINT}?${params.toString()}`;
-    const encodedCreds = import_node_buffer.Buffer.from(credsResult.value, "utf8").toString("base64");
+    const encodedCreds = Buffer.from(credsResult.value, "utf8").toString("base64");
     let response;
     try {
       response = await fetch(url, {
@@ -1103,116 +813,8 @@ var mixpanelAdapter = {
     };
   }
 };
-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
+  adapter: mixpanelAdapter
 };
 
 // src/providers/registry.ts
@@ -1258,13 +860,13 @@ function hasPassedStatusInFrontmatter(markdown) {
   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`);
+  const evidencePath = path7.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"));
+    parsed = JSON.parse(await readFile5(evidencePath, "utf8"));
   } catch {
     return false;
   }
@@ -1277,7 +879,7 @@ function isInteractiveTty2() {
   return process.stdin.isTTY === true && process.stdout.isTTY === true;
 }
 async function maybePromptUnpass(id) {
-  const value = await (0, import_prompts5.select)({
+  const value = await select2({
     message: `Bet '${id}' is currently status: passed, but the forced check FAILED. Update status?`,
     options: [
       { label: "Keep status: passed", value: "keep" },
@@ -1285,7 +887,7 @@ async function maybePromptUnpass(id) {
     ],
     initialValue: "keep"
   });
-  if ((0, import_prompts5.isCancel)(value)) {
+  if (isCancel3(value)) {
     return "cancel";
   }
   return value;
@@ -1338,22 +940,22 @@ async function runCheck(id, options = {}) {
     console.error("Bet has invalid leading_indicator: missing string field 'type'.");
     return 1;
   }
-  const module2 = resolveProviderModule(leadingIndicatorType);
-  if (!module2) {
+  const module = resolveProviderModule(leadingIndicatorType);
+  if (!module) {
     const knownTypes = listRegisteredProviderTypes().join(", ");
     console.error(
       `Bet has unsupported leading_indicator.type '${leadingIndicatorType}'. Supported types: ${knownTypes}.`
     );
     return 1;
   }
-  const parsedIndicator = module2.adapter.parseIndicator(rawLeadingIndicator);
+  const parsedIndicator = module.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, {
+    checkResult = await module.adapter.runCheck(parsedIndicator.value, {
       rootDir,
       betId: id,
       nowIso: (/* @__PURE__ */ new Date()).toISOString()
@@ -1376,10 +978,10 @@ async function runCheck(id, options = {}) {
     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);
+  const relativeEvidencePath = path7.join(EVIDENCE_DIR, `${id}.json`);
+  const absoluteEvidencePath = path7.join(rootDir, relativeEvidencePath);
   try {
-    await (0, import_promises6.writeFile)(absoluteEvidencePath, `${JSON.stringify(snapshot, null, 2)}
+    await writeFile4(absoluteEvidencePath, `${JSON.stringify(snapshot, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`Failed to write evidence at ${relativeEvidencePath}: ${error.message}`);
@@ -1427,11 +1029,12 @@ async function runCheck(id, options = {}) {
 }
 
 // src/commands/new.ts
-var import_promises7 = require("fs/promises");
-var import_node_path8 = __toESM(require("path"));
+import { existsSync } from "fs";
+import { writeFile as writeFile5 } from "fs/promises";
+import path8 from "path";
 
 // src/bep/template.ts
-var import_gray_matter2 = __toESM(require("gray-matter"));
+import matter2 from "gray-matter";
 function renderNewBetMarkdown(input) {
   const frontmatter = {
     id: input.id,
@@ -1452,446 +1055,900 @@ function renderNewBetMarkdown(input) {
     "",
     input.primaryAssumption,
     "",
-    "## 2. Rationale",
-    "",
-    input.rationale,
-    "",
-    "## 3. Validation Plan",
+    "## 2. Validation Plan",
     "",
     input.validationPlan,
     "",
-    "## 4. Notes",
+    "## 3. Notes",
     "",
     input.notes,
     ""
   ].join("\n");
-  return `${import_gray_matter2.default.stringify(body, frontmatter)}`;
+  return `${matter2.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" };
+// src/ui/ink/newWizard/renderNewWizardInk.tsx
+import { render } from "ink";
+import { createElement } from "react";
+
+// src/ui/ink/newWizard/betCardPreview.ts
+var EMPTY_VALUE = "\u2014";
+var EMPTY_TEXT = "Not entered yet";
+function isSelectPrompt(prompt) {
+  return "options" in prompt;
+}
+function getHighlightedSelectValue(prompt, uiState) {
+  if (!isSelectPrompt(prompt)) {
+    return void 0;
   }
-  if (result.kind === "back") {
-    return { kind: "back" };
+  const option = prompt.options[uiState.selectIndex];
+  return option?.value;
+}
+function normalizePreviewText(value) {
+  if (value === void 0) {
+    return void 0;
   }
-  onValue(result.value);
-  return { kind: "next" };
+  return value.length > 0 ? value : void 0;
+}
+function buildEffectivePreviewState(draft, step, prompt, uiState) {
+  const highlightedValue = getHighlightedSelectValue(prompt, uiState);
+  const effective = {
+    betName: draft.betName,
+    primaryAssumption: draft.primaryAssumption,
+    validationPlan: draft.validationPlan,
+    leadingIndicatorType: draft.leadingIndicatorType,
+    capType: draft.capType,
+    capValueText: draft.capValue === void 0 ? void 0 : String(draft.capValue),
+    manualOperator: draft.manualOperator,
+    manualTargetText: draft.manualTarget === void 0 ? void 0 : String(draft.manualTarget),
+    mixpanelProjectId: draft.mixpanelProjectId,
+    mixpanelWorkspaceId: draft.mixpanelWorkspaceId,
+    mixpanelBookmarkId: draft.mixpanelBookmarkId,
+    mixpanelOperator: draft.mixpanelOperator,
+    mixpanelTargetText: draft.mixpanelTarget === void 0 ? void 0 : String(draft.mixpanelTarget)
+  };
+  if (step === "bet_name" && !isSelectPrompt(prompt)) {
+    effective.betName = normalizePreviewText(uiState.textValue);
+  } else if (step === "primary_assumption" && !isSelectPrompt(prompt)) {
+    effective.primaryAssumption = normalizePreviewText(uiState.textValue);
+  } else if (step === "validation_plan" && !isSelectPrompt(prompt)) {
+    effective.validationPlan = normalizePreviewText(uiState.textValue);
+  } else if (step === "leading_indicator_type" && highlightedValue) {
+    if (highlightedValue === "manual" || highlightedValue === "mixpanel") {
+      effective.leadingIndicatorType = highlightedValue;
+    }
+  } else if (step === "cap_type" && highlightedValue) {
+    if (highlightedValue === "max_hours" || highlightedValue === "max_calendar_days") {
+      effective.capType = highlightedValue;
+    }
+  } else if (step === "cap_value" && !isSelectPrompt(prompt)) {
+    effective.capValueText = normalizePreviewText(uiState.textValue);
+  } else if (step === "manual_operator" && highlightedValue) {
+    if (isComparisonOperator(highlightedValue)) {
+      effective.manualOperator = highlightedValue;
+    }
+  } else if (step === "manual_target" && !isSelectPrompt(prompt)) {
+    effective.manualTargetText = normalizePreviewText(uiState.textValue);
+  } else if (step === "mixpanel_project_id" && !isSelectPrompt(prompt)) {
+    effective.mixpanelProjectId = normalizePreviewText(uiState.textValue);
+  } else if (step === "mixpanel_workspace_id" && !isSelectPrompt(prompt)) {
+    effective.mixpanelWorkspaceId = normalizePreviewText(uiState.textValue);
+  } else if (step === "mixpanel_bookmark_id" && !isSelectPrompt(prompt)) {
+    effective.mixpanelBookmarkId = normalizePreviewText(uiState.textValue);
+  } else if (step === "mixpanel_operator" && highlightedValue) {
+    if (isComparisonOperator(highlightedValue)) {
+      effective.mixpanelOperator = highlightedValue;
+    }
+  } else if (step === "mixpanel_target" && !isSelectPrompt(prompt)) {
+    effective.mixpanelTargetText = normalizePreviewText(uiState.textValue);
+  }
+  return effective;
+}
+function isComparisonOperator(value) {
+  return value === "lt" || value === "lte" || value === "eq" || value === "gte" || value === "gt";
 }
-function finalizeWizardValues(values) {
-  if (!values.capType || typeof values.capValue !== "number" || !values.leadingIndicator || !values.primaryAssumption || !values.rationale || !values.validationPlan || values.notes === void 0) {
-    return null;
+function valueField(value) {
+  if (!value) {
+    return { value: EMPTY_TEXT, empty: true };
+  }
+  return { value, empty: false };
+}
+function inlineValue(value) {
+  return value && value.length > 0 ? value : EMPTY_VALUE;
+}
+function providerLabel(type) {
+  if (type === "mixpanel") {
+    return "Mixpanel";
+  }
+  if (type === "manual") {
+    return "Manual";
+  }
+  return type;
+}
+function buildValidationRuleSummary(effective) {
+  if (effective.leadingIndicatorType === "mixpanel") {
+    const operator = effective.mixpanelOperator ? formatManualComparisonOperator(effective.mixpanelOperator) : EMPTY_VALUE;
+    const target = inlineValue(effective.mixpanelTargetText);
+    return `Mixpanel metric ${operator} ${target}`;
+  }
+  if (effective.leadingIndicatorType === "manual") {
+    const operator = effective.manualOperator ? formatManualComparisonOperator(effective.manualOperator) : EMPTY_VALUE;
+    const target = inlineValue(effective.manualTargetText);
+    return `Manual observed value ${operator} ${target}`;
+  }
+  return "Select a provider to define validation rule";
+}
+function buildCapSummary(effective) {
+  const capValue = effective.capValueText;
+  if (!effective.capType || !capValue) {
+    return "Set time cap type and value";
+  }
+  return effective.capType === "max_calendar_days" ? `${capValue} calendar day${capValue === "1" ? "" : "s"}` : `${capValue} hour${capValue === "1" ? "" : "s"}`;
+}
+function buildProviderConfig(effective) {
+  if (effective.leadingIndicatorType === "mixpanel") {
+    return {
+      title: "Mixpanel config",
+      fields: [
+        {
+          label: "workspace id",
+          ...valueField(effective.mixpanelWorkspaceId)
+        },
+        {
+          label: "project id",
+          ...valueField(effective.mixpanelProjectId)
+        },
+        {
+          label: "bookmark id",
+          ...valueField(effective.mixpanelBookmarkId)
+        }
+      ]
+    };
+  }
+  if (effective.leadingIndicatorType === "manual") {
+    return {
+      title: "Manual config",
+      fields: [
+        {
+          label: "operator",
+          value: effective.manualOperator ? formatManualComparisonOperator(effective.manualOperator) : EMPTY_VALUE,
+          empty: !effective.manualOperator
+        },
+        {
+          label: "target",
+          value: inlineValue(effective.manualTargetText),
+          empty: !effective.manualTargetText
+        }
+      ]
+    };
   }
-  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
+    title: "Config",
+    fields: [
+      {
+        label: "provider",
+        value: "Select a provider",
+        empty: true
+      }
+    ]
   };
 }
-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;
+function buildBetCardPreviewModel(args) {
+  const effective = buildEffectivePreviewState(args.draft, args.step, args.prompt, args.uiState);
+  const providerConfig = buildProviderConfig(effective);
+  return {
+    betName: {
+      label: "Bet name",
+      ...valueField(effective.betName)
+    },
+    primaryAssumption: valueField(effective.primaryAssumption),
+    validationPlan: valueField(effective.validationPlan),
+    providers: args.providerTypes.map((type) => ({
+      type,
+      label: providerLabel(type),
+      selected: type === effective.leadingIndicatorType
+    })),
+    selectedProviderType: effective.leadingIndicatorType,
+    providerConfigTitle: providerConfig.title,
+    providerConfigFields: providerConfig.fields,
+    validationRuleSummary: buildValidationRuleSummary(effective),
+    capSummary: buildCapSummary(effective)
+  };
+}
+
+// src/ui/ink/newWizard/components/BetCard.tsx
+import { Box, Text, measureElement } from "ink";
+import { useEffect, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function useMeasuredSize() {
+  const ref = useRef(null);
+  const [size, setSize] = useState({ width: 0, height: 0 });
+  useEffect(() => {
+    const node = ref.current;
+    if (!node) {
+      return;
+    }
+    const update = () => {
+      const next = measureElement(node);
+      setSize(
+        (previous) => previous.width === next.width && previous.height === next.height ? previous : next
+      );
+    };
+    update();
+    node.onRender = update;
+    return () => {
+      if (node.onRender === update) {
+        node.onRender = void 0;
       }
-    });
-  },
-  async cap_value({ client, values, stepIndex }) {
-    if (!values.capType) {
-      return { kind: "cancel" };
+    };
+  }, []);
+  return { ref, size };
+}
+function HorizontalDivider() {
+  const { ref, size } = useMeasuredSize();
+  const width = Math.max(1, size.width);
+  return /* @__PURE__ */ jsx(Box, { ref, width: "100%", overflow: "hidden", children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: Array.from({ length: width }, () => "\u2500").join("") }) });
+}
+function VerticalDivider() {
+  const { ref, size } = useMeasuredSize();
+  const height = Math.max(1, size.height);
+  return /* @__PURE__ */ jsx(Box, { ref, height: "100%", alignSelf: "stretch", flexDirection: "column", overflow: "hidden", children: Array.from({ length: height }, (_, index) => /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }, index)) });
+}
+function Section({
+  title,
+  children,
+  flexGrow,
+  width
+}) {
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      paddingX: 1,
+      paddingY: 1,
+      flexGrow,
+      width,
+      children: [
+        title && title !== "" ? /* @__PURE__ */ jsx(Text, { bold: true, children: title }) : null,
+        /* @__PURE__ */ jsx(Box, { flexDirection: "column", children })
+      ]
     }
-    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;
+  );
+}
+function FieldLine({ label, value, empty }) {
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      label,
+      ": "
+    ] }),
+    empty ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: value }) : value
+  ] });
+}
+function BetCard({ model }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", paddingX: 1, paddingY: 0, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, children: "Bet Card Preview" }),
+    /* @__PURE__ */ jsx(Section, { children: model.betName.empty ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: model.betName.value }) : /* @__PURE__ */ jsx(Text, { children: model.betName.value }) }),
+    /* @__PURE__ */ jsx(HorizontalDivider, {}),
+    /* @__PURE__ */ jsxs(Section, { children: [
+      /* @__PURE__ */ jsx(FieldLine, { label: "Assumption", value: model.primaryAssumption.value, empty: model.primaryAssumption.empty }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(FieldLine, { label: "Validation plan", value: model.validationPlan.value, empty: model.validationPlan.empty }) })
+    ] }),
+    /* @__PURE__ */ jsx(HorizontalDivider, {}),
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx(Box, { marginRight: 1, children: /* @__PURE__ */ jsx(Section, { title: "Providers", width: 24, children: model.providers.map((provider) => /* @__PURE__ */ jsxs(Text, { inverse: provider.selected, color: provider.selected ? "cyan" : void 0, children: [
+        provider.selected ? "\u203A" : " ",
+        " ",
+        provider.label
+      ] }, provider.type)) }) }),
+      /* @__PURE__ */ jsx(VerticalDivider, {}),
+      /* @__PURE__ */ jsxs(Section, { title: model.providerConfigTitle, flexGrow: 1, children: [
+        /* @__PURE__ */ jsx(Box, { marginTop: 1, flexDirection: "column", children: model.providerConfigFields.map((field) => /* @__PURE__ */ jsx(FieldLine, { label: field.label, value: field.value, empty: field.empty }, field.label)) }),
+        /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Validation passes when:" }),
+          /* @__PURE__ */ jsx(Text, { children: model.validationRuleSummary })
+        ] }),
+        /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Time cap:" }),
+          /* @__PURE__ */ jsx(Text, { children: model.capSummary })
+        ] })
+      ] })
+    ] })
+  ] });
+}
+
+// src/ui/ink/newWizard/components/WizardFrame.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function WizardFrame({
+  title,
+  helpText,
+  error,
+  children
+}) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", paddingX: 2, paddingY: 0, children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, children: title }),
+    helpText ? /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: helpText }) : null,
+    /* @__PURE__ */ jsx2(Box2, { marginTop: 1, flexDirection: "column", children }),
+    error ? /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsxs2(Text2, { color: "red", children: [
+      "Error: ",
+      error
+    ] }) }) : null
+  ] });
+}
+
+// src/ui/ink/newWizard/components/SelectStep.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function SelectStep({
+  prompt,
+  selectedIndex
+}) {
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    prompt.options.map((option, index) => {
+      const selected = index === selectedIndex;
+      return /* @__PURE__ */ jsxs3(Text3, { color: selected ? "cyan" : void 0, inverse: selected, children: [
+        selected ? "\u203A" : " ",
+        " ",
+        option.label
+      ] }, option.value);
+    }),
+    /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Up/Down: move selection" }) })
+  ] });
+}
+
+// src/ui/ink/newWizard/components/TextStep.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function TextStep({
+  prompt,
+  value
+}) {
+  const showPlaceholder = value.length === 0 && Boolean(prompt.placeholder);
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: ">" }),
+      " ",
+      value,
+      /* @__PURE__ */ jsx4(Text4, { inverse: true, children: " " }),
+      showPlaceholder ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: prompt.placeholder }) : null
+    ] }),
+    prompt.optional ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Optional field." }) : null
+  ] });
+}
+
+// src/ui/ink/newWizard/useWizardInput.ts
+import { useInput } from "ink";
+function useWizardInput(prompt, uiState, actions) {
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      actions.cancel();
+      return;
+    }
+    if (key.escape) {
+      actions.goBack();
+      return;
+    }
+    if ("options" in prompt) {
+      if (key.downArrow || input === "j") {
+        actions.setUiState((previous) => ({
+          ...previous,
+          selectIndex: Math.min(prompt.options.length - 1, previous.selectIndex + 1),
+          error: void 0
+        }));
+        return;
       }
-      values.leadingIndicatorType = value;
-    });
-  },
-  async leading_indicator_setup({ client, values, stepIndex }) {
-    if (!values.leadingIndicatorType) {
-      return { kind: "cancel" };
+      if (key.upArrow || input === "k") {
+        actions.setUiState((previous) => ({
+          ...previous,
+          selectIndex: Math.max(0, previous.selectIndex - 1),
+          error: void 0
+        }));
+        return;
+      }
+      if (key.return) {
+        const option = prompt.options[uiState.selectIndex];
+        if (option) {
+          actions.submitSelect(option.value);
+        }
+      }
+      return;
     }
-    const module2 = resolveProviderModule(values.leadingIndicatorType);
-    if (!module2 || !module2.setup) {
-      return { kind: "cancel" };
+    if (key.return) {
+      actions.submitText();
+      return;
     }
-    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;
-    });
+    if (key.backspace || key.delete) {
+      actions.setUiState((previous) => ({
+        ...previous,
+        textValue: previous.textValue.slice(0, -1),
+        error: void 0
+      }));
+      return;
+    }
+    if (input.length > 0 && !key.tab) {
+      actions.setUiState((previous) => ({
+        ...previous,
+        textValue: previous.textValue + input,
+        error: void 0
+      }));
+    }
+  });
+}
+
+// src/ui/ink/newWizard/useWizardState.ts
+import { useEffect as useEffect2, useMemo, useState as useState2 } from "react";
+
+// src/ui/newBetName.ts
+function normalizeBetName(value) {
+  return value.trim().replace(/\s+/g, "_").toLowerCase();
+}
+
+// src/ui/ink/newWizard/flow.ts
+function createInitialWizardDraft() {
+  return {};
+}
+function getWizardSteps(providerType) {
+  const steps = ["bet_name", "primary_assumption", "validation_plan", "leading_indicator_type"];
+  if (providerType === "manual") {
+    steps.push("manual_operator", "manual_target");
+  } else if (providerType === "mixpanel") {
+    steps.push("mixpanel_workspace_id", "mixpanel_project_id", "mixpanel_bookmark_id", "mixpanel_operator", "mixpanel_target");
+  }
+  steps.push("cap_type", "cap_value", "notes");
+  return steps;
+}
+function applySelectStepValue(draft, step, value) {
+  if (step === "cap_type") {
+    const nextCapType = value;
+    return {
+      ...draft,
+      capType: nextCapType,
+      capValue: draft.capType !== nextCapType ? void 0 : draft.capValue
+    };
   }
-};
-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 (step === "leading_indicator_type") {
+    const nextProviderType = value;
+    if (draft.leadingIndicatorType === nextProviderType) {
+      return { ...draft, leadingIndicatorType: nextProviderType };
     }
-    if (flow.kind === "back") {
-      stepIndex = Math.max(0, stepIndex - 1);
-      continue;
+    return {
+      ...draft,
+      leadingIndicatorType: nextProviderType,
+      manualOperator: void 0,
+      manualTarget: void 0,
+      mixpanelProjectId: void 0,
+      mixpanelWorkspaceId: void 0,
+      mixpanelBookmarkId: void 0,
+      mixpanelOperator: void 0,
+      mixpanelTarget: void 0
+    };
+  }
+  if (step === "manual_operator") {
+    return { ...draft, manualOperator: value };
+  }
+  if (step === "mixpanel_operator") {
+    return { ...draft, mixpanelOperator: value };
+  }
+  return draft;
+}
+function applyTextStepValue(draft, step, rawValue) {
+  if (step === "bet_name") {
+    return { ...draft, betName: normalizeBetName(rawValue) };
+  }
+  if (step === "cap_value") {
+    return { ...draft, capValue: Number(rawValue.trim()) };
+  }
+  if (step === "manual_target") {
+    return { ...draft, manualTarget: Number(rawValue.trim()) };
+  }
+  if (step === "mixpanel_target") {
+    return { ...draft, mixpanelTarget: Number(rawValue.trim()) };
+  }
+  if (step === "mixpanel_project_id") {
+    return { ...draft, mixpanelProjectId: rawValue.trim() };
+  }
+  if (step === "mixpanel_workspace_id") {
+    return { ...draft, mixpanelWorkspaceId: rawValue.trim() };
+  }
+  if (step === "mixpanel_bookmark_id") {
+    return { ...draft, mixpanelBookmarkId: rawValue.trim() };
+  }
+  if (step === "primary_assumption") {
+    return { ...draft, primaryAssumption: rawValue.trim() };
+  }
+  if (step === "validation_plan") {
+    return { ...draft, validationPlan: rawValue.trim() };
+  }
+  if (step === "notes") {
+    return { ...draft, notes: rawValue.trim() };
+  }
+  return draft;
+}
+function buildLeadingIndicatorFromDraft(draft) {
+  if (draft.leadingIndicatorType === "manual") {
+    if (!draft.manualOperator || typeof draft.manualTarget !== "number") {
+      return null;
+    }
+    return {
+      type: "manual",
+      operator: draft.manualOperator,
+      target: draft.manualTarget
+    };
+  }
+  if (draft.leadingIndicatorType === "mixpanel") {
+    if (!draft.mixpanelProjectId || !draft.mixpanelWorkspaceId || !draft.mixpanelBookmarkId || !draft.mixpanelOperator || typeof draft.mixpanelTarget !== "number") {
+      return null;
     }
-    stepIndex += 1;
+    return {
+      type: "mixpanel",
+      project_id: draft.mixpanelProjectId,
+      workspace_id: draft.mixpanelWorkspaceId,
+      bookmark_id: draft.mixpanelBookmarkId,
+      operator: draft.mixpanelOperator,
+      target: draft.mixpanelTarget
+    };
   }
-  const finalizedValues = finalizeWizardValues(values);
-  if (!finalizedValues) {
-    return { cancelled: true };
+  return null;
+}
+function finalizeWizardDraft(draft) {
+  if (!draft.betName || !draft.capType || typeof draft.capValue !== "number") {
+    return null;
+  }
+  const leadingIndicator = buildLeadingIndicatorFromDraft(draft);
+  if (!leadingIndicator) {
+    return null;
+  }
+  if (!draft.primaryAssumption || !draft.validationPlan || draft.notes === void 0) {
+    return null;
   }
   return {
-    cancelled: false,
-    values: finalizedValues
+    betName: draft.betName,
+    maxHours: draft.capType === "max_hours" ? draft.capValue : void 0,
+    maxCalendarDays: draft.capType === "max_calendar_days" ? draft.capValue : void 0,
+    leadingIndicator,
+    primaryAssumption: draft.primaryAssumption,
+    validationPlan: draft.validationPlan,
+    notes: draft.notes
   };
 }
-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" };
+
+// src/ui/ink/newWizard/promptUtils.ts
+function getInitialSelectIndex(options, initialValue) {
+  if (!initialValue) {
+    return 0;
+  }
+  const index = options.findIndex((option) => option.value === initialValue);
+  return index >= 0 ? index : 0;
+}
+function classifyTextSubmission(rawValue, options) {
+  const error = options.validate?.(rawValue);
+  if (error) {
+    return { kind: "invalid", message: error };
+  }
+  return { kind: "value", value: rawValue };
+}
+
+// src/ui/ink/newWizard/useWizardState.ts
+var BACK_OPTION = "__back__";
+var MIXPANEL_URL_HINT = "Values come from report URL: /project/<PROJECT_ID>/view/<WORKSPACE_ID>/...#...report-<BOOKMARK_ID>.";
+var WIZARD_GUIDANCE_COPY = {
+  primary_assumption: {
+    title: "What must be true for this bet to work?",
+    helpText: "Write the core assumption you are betting on. Focus on one claim that could be proven wrong.",
+    placeholder: "Example: Users who start onboarding from the pricing page convert better because they already understand the value."
+  },
+  validation_plan: {
+    title: "How will you validate whether the bet worked?",
+    helpText: "Describe the metric(s), comparison, and decision rule you will use. Include what outcome would count as success or failure.",
+    placeholder: "Example: Compare signup-to-activation rate for users exposed to variant B vs control for 14 days; consider the bet validated if activation improves by >=10% with no drop in trial starts."
+  }
+};
+function isProviderType(value) {
+  return value === "manual" || value === "mixpanel";
+}
+function buildPrompt(step, draft, options) {
+  const requiredText = (title, initialValue, emptyMessage, helpText, placeholder) => ({
+    title,
+    initialValue,
+    helpText,
+    placeholder,
+    validate(rawValue) {
+      if (rawValue.trim().length === 0) {
+        return emptyMessage;
       }
-      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.";
-          }
+      return void 0;
+    }
+  });
+  if (step === "bet_name") {
+    return {
+      title: "Bet name (required).",
+      initialValue: draft.betName ?? options.initialBetName,
+      validate(rawValue) {
+        const normalizedName = normalizeBetName(rawValue);
+        if (normalizedName.length === 0) {
+          return "Enter a bet name.";
         }
-      });
-      if ((0, import_prompts6.isCancel)(value)) {
-        return { kind: "cancel" };
+        return options.validateBetName(normalizedName);
       }
-      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" };
+    };
+  }
+  if (step === "cap_type") {
+    return {
+      title: "Choose your time cap type",
+      initialValue: draft.capType,
+      helpText: "Set the maximum amount of time you will allow this bet to run before you must stop, evaluate, or extend it.",
+      options: [
+        { label: "Cap by hours", value: "max_hours" },
+        { label: "Cap by calendar days", value: "max_calendar_days" }
+      ]
+    };
+  }
+  if (step === "cap_value") {
+    return {
+      title: `${draft.capType === "max_calendar_days" ? "Max calendar days" : "Max hours"} (required).`,
+      helpText: draft.capType === "max_calendar_days" ? "Enter the maximum number of calendar days this bet is allowed to run before review." : "Enter the maximum number of hours this bet is allowed to run before review.",
+      initialValue: typeof draft.capValue === "number" ? String(draft.capValue) : void 0,
+      validate(rawValue) {
+        const trimmed = rawValue.trim();
+        if (trimmed.length === 0) {
+          return "Enter a positive number.";
+        }
+        const parsed = Number(trimmed);
+        if (!Number.isFinite(parsed) || parsed <= 0) {
+          return "Enter a positive number.";
+        }
+        return void 0;
       }
-      return { kind: "value", value };
-    },
-    async promptManualOperator({ initialValue, allowBack }) {
-      const options = [
+    };
+  }
+  if (step === "leading_indicator_type") {
+    return {
+      title: "Leading indicator provider type",
+      initialValue: draft.leadingIndicatorType,
+      options: listRegisteredProviderTypes().filter(isProviderType).map((type) => ({ label: type, value: type }))
+    };
+  }
+  if (step === "manual_operator") {
+    return {
+      title: "Leading indicator comparison operator",
+      initialValue: draft.manualOperator,
+      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 (step === "manual_target") {
+    return {
+      title: "Leading indicator numeric target (required).",
+      initialValue: typeof draft.manualTarget === "number" ? String(draft.manualTarget) : void 0,
+      validate(rawValue) {
+        const trimmed = rawValue.trim();
+        if (trimmed.length === 0 || !Number.isFinite(Number(trimmed))) {
+          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 void 0;
       }
-      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 (step === "mixpanel_project_id") {
+    return requiredText("Mixpanel project id (required).", draft.mixpanelProjectId, "Enter a project id.", MIXPANEL_URL_HINT);
+  }
+  if (step === "mixpanel_workspace_id") {
+    return requiredText(
+      "Mixpanel workspace id (required).",
+      draft.mixpanelWorkspaceId,
+      "Enter a workspace id.",
+      MIXPANEL_URL_HINT
+    );
+  }
+  if (step === "mixpanel_bookmark_id") {
+    return requiredText(
+      "Mixpanel bookmark id (required).",
+      draft.mixpanelBookmarkId,
+      "Enter a bookmark id.",
+      MIXPANEL_URL_HINT
+    );
+  }
+  if (step === "mixpanel_operator") {
+    return {
+      title: "Mixpanel comparison operator",
+      initialValue: draft.mixpanelOperator,
+      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 (step === "mixpanel_target") {
+    return {
+      title: "Mixpanel target value (required).",
+      initialValue: typeof draft.mixpanelTarget === "number" ? String(draft.mixpanelTarget) : void 0,
+      validate(rawValue) {
+        const trimmed = rawValue.trim();
+        if (trimmed.length === 0 || !Number.isFinite(Number(trimmed))) {
+          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 void 0;
       }
-      return { kind: "value", value: trimmed };
-    }
+    };
+  }
+  if (step === "primary_assumption") {
+    return requiredText(
+      WIZARD_GUIDANCE_COPY.primary_assumption.title,
+      draft.primaryAssumption,
+      "Enter a value.",
+      WIZARD_GUIDANCE_COPY.primary_assumption.helpText,
+      WIZARD_GUIDANCE_COPY.primary_assumption.placeholder
+    );
+  }
+  if (step === "validation_plan") {
+    return requiredText(
+      WIZARD_GUIDANCE_COPY.validation_plan.title,
+      draft.validationPlan,
+      "Enter a value.",
+      WIZARD_GUIDANCE_COPY.validation_plan.helpText,
+      WIZARD_GUIDANCE_COPY.validation_plan.placeholder
+    );
+  }
+  return {
+    title: "Notes (optional).",
+    initialValue: draft.notes,
+    optional: true,
+    validate: () => void 0
   };
 }
-
-// src/ui/newBetName.ts
-var import_prompts7 = require("@clack/prompts");
-function normalizeBetName(value) {
-  return value.trim().replace(/\s+/g, "_").toLowerCase();
+function buildUiState(prompt) {
+  if ("options" in prompt) {
+    return {
+      textValue: "",
+      selectIndex: getInitialSelectIndex(prompt.options, prompt.initialValue),
+      error: void 0
+    };
+  }
+  return {
+    textValue: prompt.initialValue ?? "",
+    selectIndex: 0,
+    error: void 0
+  };
 }
-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.";
+function useWizardState(onComplete, options) {
+  const [draft, setDraft] = useState2(() => createInitialWizardDraft());
+  const [stepIndex, setStepIndex] = useState2(0);
+  const [uiState, setUiState] = useState2({ textValue: "", selectIndex: 0 });
+  const steps = useMemo(() => getWizardSteps(draft.leadingIndicatorType), [draft.leadingIndicatorType]);
+  const safeStepIndex = Math.min(stepIndex, Math.max(0, steps.length - 1));
+  const step = steps[safeStepIndex] ?? steps[0];
+  const prompt = useMemo(() => buildPrompt(step, draft, options), [step, draft, options]);
+  useEffect2(() => {
+    if (safeStepIndex !== stepIndex) {
+      setStepIndex(safeStepIndex);
+    }
+  }, [safeStepIndex, stepIndex]);
+  useEffect2(() => {
+    setUiState(buildUiState(prompt));
+  }, [step]);
+  const completeIfDone = (nextDraft, nextStepIndex) => {
+    const nextSteps = getWizardSteps(nextDraft.leadingIndicatorType);
+    if (nextStepIndex < nextSteps.length) {
+      return false;
     }
-  });
-  if ((0, import_prompts7.isCancel)(response)) {
-    return { cancelled: true };
-  }
+    const finalized = finalizeWizardDraft(nextDraft);
+    onComplete(finalized ? { cancelled: false, values: finalized } : { cancelled: true });
+    return true;
+  };
+  const goBack = () => {
+    setUiState((previous) => ({ ...previous, error: void 0 }));
+    setStepIndex((previous) => Math.max(0, previous - 1));
+  };
+  const submitSelect = (selectedValue) => {
+    if (selectedValue === BACK_OPTION) {
+      goBack();
+      return;
+    }
+    const nextStep = safeStepIndex + 1;
+    const nextDraft = applySelectStepValue(draft, step, selectedValue);
+    setDraft(nextDraft);
+    if (!completeIfDone(nextDraft, nextStep)) {
+      setStepIndex(nextStep);
+    }
+  };
+  const submitText = () => {
+    if ("options" in prompt) {
+      return;
+    }
+    const submission = classifyTextSubmission(uiState.textValue, {
+      validate: prompt.validate
+    });
+    if (submission.kind === "invalid") {
+      setUiState((previous) => ({ ...previous, error: submission.message }));
+      return;
+    }
+    if (submission.kind === "back") {
+      goBack();
+      return;
+    }
+    const nextStep = safeStepIndex + 1;
+    const nextDraft = applyTextStepValue(draft, step, submission.value);
+    setDraft(nextDraft);
+    if (!completeIfDone(nextDraft, nextStep)) {
+      setStepIndex(nextStep);
+    }
+  };
+  const cancel = () => {
+    onComplete({ cancelled: true });
+  };
   return {
-    cancelled: false,
-    value: normalizeBetName(response)
+    prompt,
+    step,
+    draft,
+    uiState,
+    actions: { goBack, submitSelect, submitText, cancel, setUiState }
   };
 }
 
-// src/commands/new.ts
-async function pathExists3(filePath) {
-  try {
-    await (0, import_promises7.access)(filePath);
-    return true;
-  } catch {
-    return false;
-  }
+// src/ui/ink/newWizard/App.tsx
+import { Text as Text5 } from "ink";
+import { Fragment, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function InkNewWizardApp({
+  onComplete,
+  options
+}) {
+  const { prompt, step, draft, uiState, actions } = useWizardState(onComplete, options);
+  useWizardInput(prompt, uiState, actions);
+  const betCardModel = buildBetCardPreviewModel({
+    draft,
+    step,
+    prompt,
+    uiState,
+    providerTypes: listRegisteredProviderTypes()
+  });
+  return /* @__PURE__ */ jsxs5(Fragment, { children: [
+    /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Create a new bet:" }),
+    /* @__PURE__ */ jsx5(BetCard, { model: betCardModel }),
+    /* @__PURE__ */ jsx5(WizardFrame, { title: prompt.title, helpText: prompt.helpText, error: uiState.error, children: "options" in prompt ? /* @__PURE__ */ jsx5(SelectStep, { prompt, selectedIndex: uiState.selectIndex }) : /* @__PURE__ */ jsx5(TextStep, { prompt, value: uiState.textValue }) })
+  ] });
 }
+
+// src/ui/ink/newWizard/renderNewWizardInk.tsx
+async function renderNewWizardInk(options) {
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    const app = render(
+      createElement(InkNewWizardApp, {
+        options,
+        onComplete(result) {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          resolve(result);
+          app.unmount();
+        }
+      })
+    );
+    app.waitUntilExit().catch((error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      reject(error);
+    });
+  });
+}
+
+// src/ui/newWizard.ts
+async function runNewWizard(options) {
+  return renderNewWizardInk(options);
+}
+
+// src/commands/new.ts
 function isInteractiveTty3() {
   return process.stdin.isTTY === true && process.stdout.isTTY === true;
 }
@@ -1899,21 +1956,9 @@ 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));
+  const initialBetName = rawId ? normalizeBetName(rawId) : void 0;
+  if (!initialBetName && !isInteractiveTty3()) {
+    console.error("Missing bet name. Run 'bep new <name>' or use an interactive terminal.");
     return 1;
   }
   let rootDir;
@@ -1924,17 +1969,28 @@ async function runNew(rawId) {
     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();
+  const validateBetName = (normalizedName) => {
+    if (!isValidBetId(normalizedName)) {
+      return invalidIdError(normalizedName);
+    }
+    const relativePath2 = path8.join(BETS_DIR, `${normalizedName}.md`);
+    const absolutePath2 = path8.join(rootDir, relativePath2);
+    if (existsSync(absolutePath2)) {
+      return `Bet '${normalizedName}' already exists at ${relativePath2}. Choose a unique id.`;
+    }
+    return void 0;
+  };
+  const wizardResult = await runNewWizard({
+    initialBetName,
+    validateBetName
+  });
   if (wizardResult.cancelled) {
     console.error("Cancelled. No files were created.");
     return 1;
   }
+  const id = wizardResult.values.betName;
+  const relativePath = path8.join(BETS_DIR, `${id}.md`);
+  const absolutePath = path8.join(rootDir, relativePath);
   const markdown = renderNewBetMarkdown({
     id,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1942,12 +1998,11 @@ async function runNew(rawId) {
     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" });
+    await writeFile5(absolutePath, markdown, { encoding: "utf8", flag: "wx" });
   } catch (error) {
     if (error.code === "EEXIST") {
       console.error(`Bet '${id}' already exists at ${relativePath}. Choose a unique id.`);
@@ -1961,8 +2016,8 @@ Created ${relativePath}.`);
 }
 
 // src/state/state.ts
-var import_promises8 = require("fs/promises");
-var import_node_path9 = __toESM(require("path"));
+import { readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
+import path9 from "path";
 function isValidActiveSession(value) {
   if (!value || typeof value !== "object") {
     return false;
@@ -1987,13 +2042,13 @@ function parseState(raw) {
   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");
+  const statePath = path9.join(rootDir, STATE_PATH);
+  const raw = await readFile6(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)}
+  const statePath = path9.join(rootDir, STATE_PATH);
+  await writeFile6(statePath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
 function addActiveSession(state, id, startedAt) {
@@ -2071,8 +2126,8 @@ async function runStart(id) {
 }
 
 // src/commands/stop.ts
-var import_promises9 = require("fs/promises");
-var import_node_path10 = __toESM(require("path"));
+import { appendFile } from "fs/promises";
+import path10 from "path";
 async function runStop(id) {
   if (!isValidBetId(id)) {
     console.error(`Invalid bet id '${id}'. Use lowercase id format like 'landing-page' or 'landing_page'.`);
@@ -2126,10 +2181,10 @@ async function runStop(id) {
       return 1;
     }
   }
-  const logPath = import_node_path10.default.join(rootDir, LOGS_DIR, `${id}.jsonl`);
+  const logPath = path10.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 appendFile(logPath, serializedLogs, "utf8");
     await writeState(rootDir, next.state);
   } catch (error) {
     console.error(`Failed to stop bet '${id}': ${error.message}`);
@@ -2143,8 +2198,8 @@ async function runStop(id) {
 }
 
 // src/commands/status.ts
-var import_promises10 = require("fs/promises");
-var import_node_path11 = __toESM(require("path"));
+import { readFile as readFile7, readdir as readdir2 } from "fs/promises";
+import path11 from "path";
 var STATUS_COLUMNS = [
   "id",
   "status",
@@ -2218,12 +2273,12 @@ function formatValidation(snapshot) {
   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);
+  const relativePath = path11.join(LOGS_DIR, `${id}.jsonl`);
+  const absolutePath = path11.join(rootDir, relativePath);
   if (!await pathExists2(absolutePath)) {
     return 0;
   }
-  const raw = await (0, import_promises10.readFile)(absolutePath, "utf8");
+  const raw = await readFile7(absolutePath, "utf8");
   if (raw.trim().length === 0) {
     return 0;
   }
@@ -2250,14 +2305,14 @@ async function sumLoggedExposureSeconds(rootDir, id) {
   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);
+  const relativePath = path11.join(EVIDENCE_DIR, `${id}.json`);
+  const absolutePath = path11.join(rootDir, relativePath);
   if (!await pathExists2(absolutePath)) {
     return "N/A";
   }
   let parsed;
   try {
-    parsed = JSON.parse(await (0, import_promises10.readFile)(absolutePath, "utf8"));
+    parsed = JSON.parse(await readFile7(absolutePath, "utf8"));
   } catch (error) {
     throw new Error(`Failed to parse evidence file at ${relativePath}: ${error.message}`);
   }
@@ -2286,10 +2341,10 @@ async function runStatus() {
     console.error(error.message);
     return 1;
   }
-  const betDir = import_node_path11.default.join(rootDir, BETS_DIR);
+  const betDir = path11.join(rootDir, BETS_DIR);
   let dirEntries;
   try {
-    dirEntries = await (0, import_promises10.readdir)(betDir, { withFileTypes: true });
+    dirEntries = await readdir2(betDir, { withFileTypes: true });
   } catch (error) {
     console.error(`Failed to read bets directory at ${BETS_DIR}: ${error.message}`);
     return 1;
@@ -2367,8 +2422,8 @@ async function runStatus() {
 }
 
 // src/commands/hook.ts
-var import_promises14 = require("fs/promises");
-var import_node_path14 = __toESM(require("path"));
+import { appendFile as appendFile3 } from "fs/promises";
+import path14 from "path";
 
 // src/hooks/events.ts
 var MAX_FIELD_LENGTH = 2e3;
@@ -2446,8 +2501,8 @@ async function readHookStdin() {
 }
 
 // src/tracking/context.ts
-var import_promises11 = require("fs/promises");
-var import_node_path12 = __toESM(require("path"));
+import { readFile as readFile8 } from "fs/promises";
+import path12 from "path";
 var MAX_BET_SUMMARY_CHARS = 800;
 var MAX_HISTORY_ENTRIES = 20;
 function summarizeContent(content) {
@@ -2465,6 +2520,15 @@ function extractSection(content, heading) {
   }
   return summarizeContent(match[1]);
 }
+function extractSectionAny(content, headings) {
+  for (const heading of headings) {
+    const value = extractSection(content, heading);
+    if (value) {
+      return value;
+    }
+  }
+  return void 0;
+}
 async function readBetCatalog(rootDir) {
   const files = await listBetMarkdownFiles(rootDir);
   const result = [];
@@ -2478,9 +2542,8 @@ async function readBetCatalog(rootDir) {
         id,
         status,
         assumption: extractSection(content, "1\\. Primary Assumption"),
-        rationale: extractSection(content, "2\\. Rationale"),
-        validationPlan: extractSection(content, "3\\. Validation Plan"),
-        notes: extractSection(content, "4\\. Notes"),
+        validationPlan: extractSectionAny(content, ["2\\. Validation Plan", "3\\. Validation Plan"]),
+        notes: extractSectionAny(content, ["3\\. Notes", "4\\. Notes"]),
         summary: summarizeContent(content)
       });
     } catch {
@@ -2489,10 +2552,10 @@ async function readBetCatalog(rootDir) {
   return result;
 }
 async function readRecentAttribution(rootDir) {
-  const filePath = import_node_path12.default.join(rootDir, LOGS_DIR, "agent-attribution.jsonl");
+  const filePath = path12.join(rootDir, LOGS_DIR, "agent-attribution.jsonl");
   let raw;
   try {
-    raw = await (0, import_promises11.readFile)(filePath, "utf8");
+    raw = await readFile8(filePath, "utf8");
   } catch {
     return [];
   }
@@ -2640,8 +2703,8 @@ async function applySelectionDecision(context, rawDecision, deps = defaultDeps)
 }
 
 // src/tracking/enforcement.ts
-var import_promises12 = require("fs/promises");
-var import_node_path13 = __toESM(require("path"));
+import { readFile as readFile9 } from "fs/promises";
+import path13 from "path";
 function parsePositiveNumber(value) {
   if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
     return null;
@@ -2663,12 +2726,12 @@ function parseCreatedAtMs2(value) {
   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);
+  const relativePath = path13.join(LOGS_DIR, `${betId}.jsonl`);
+  const absolutePath = path13.join(rootDir, relativePath);
   if (!await pathExists2(absolutePath)) {
     return 0;
   }
-  const raw = await (0, import_promises12.readFile)(absolutePath, "utf8");
+  const raw = await readFile9(absolutePath, "utf8");
   if (raw.trim().length === 0) {
     return 0;
   }
@@ -2802,9 +2865,9 @@ async function evaluateCapGate(rootDir, context, decision) {
 }
 
 // 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"));
+import { spawn } from "child_process";
+import { appendFile as appendFile2 } from "fs/promises";
+import os from "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.";
@@ -2822,7 +2885,7 @@ async function writeDebug(debugLogPath, entry) {
     return;
   }
   try {
-    await (0, import_promises13.appendFile)(
+    await appendFile2(
       debugLogPath,
       `${JSON.stringify({
         ...entry,
@@ -2849,14 +2912,14 @@ async function defaultRunClaude({ prompt, timeoutMs, onDebug }) {
     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(),
+      cwd: os.tmpdir(),
       timeoutMs
     });
-    const child = (0, import_node_child_process.spawn)(
+    const child = spawn(
       "claude",
       ["--print", "--output-format", "json", "--model", "sonnet", "--setting-sources", ""],
       {
-        cwd: import_node_os.default.tmpdir(),
+        cwd: os.tmpdir(),
         env: stripGitEnv(process.env),
         stdio: ["pipe", "pipe", "pipe"]
       }
@@ -2959,12 +3022,11 @@ function toDecision(raw, knownIds) {
     reason: reason.trim()
   };
 }
-function buildPrompt(context) {
+function buildPrompt2(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
@@ -3056,7 +3118,7 @@ async function selectBetWithClaude(context, runClaudeOrOptions = defaultRunClaud
       rawText: ""
     };
   }
-  const prompt = buildPrompt(context);
+  const prompt = buildPrompt2(context);
   await debugLog("build_prompt", "Built Claude selector prompt.", {
     prompt,
     activeBetIds: context.activeBetIds,
@@ -3172,7 +3234,7 @@ var defaultDeps2 = {
   readInput: readHookStdin,
   select: selectBetWithClaude,
   apply: applySelectionDecision,
-  append: import_promises14.appendFile,
+  append: appendFile3,
   writeOutput: (output) => process.stdout.write(output)
 };
 function isHookEvent(value) {
@@ -3218,7 +3280,7 @@ async function runHook(agent, event, deps = defaultDeps2) {
   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");
+    const debugLogPath = path14.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);
@@ -3278,9 +3340,9 @@ async function runHook(agent, event, deps = defaultDeps2) {
     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");
+  const attributionPath = path14.join(found.rootDir, LOGS_DIR, "agent-attribution.jsonl");
+  const sessionPath = path14.join(found.rootDir, LOGS_DIR, "agent-sessions.jsonl");
+  const blocksPath = path14.join(found.rootDir, LOGS_DIR, "agent-blocks.jsonl");
   if (blockLine) {
     await deps.append(blocksPath, `${JSON.stringify(blockLine)}
 `, "utf8");
@@ -3303,7 +3365,7 @@ async function runHook(agent, event, deps = defaultDeps2) {
 
 // src/cli.ts
 async function main(argv) {
-  const program = new import_commander.Command();
+  const program = new 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({
@@ -3312,8 +3374,8 @@ async function main(argv) {
     });
     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;
+  program.command("new [id...]").description("Create a new BEP markdown file").action(async (args) => {
+    const id = args && args.length > 0 ? [...args].join(" ") : void 0;
     const exitCode = await runNew(id);
     process.exitCode = exitCode;
   });
@@ -3339,11 +3401,18 @@ async function main(argv) {
   });
   await program.parseAsync(argv);
 }
-if (require.main === module) {
+function isEntrypoint() {
+  const argvPath = process.argv[1];
+  if (!argvPath) {
+    return false;
+  }
+  const modulePath = fileURLToPath(import.meta.url);
+  return path15.resolve(argvPath) === path15.resolve(modulePath);
+}
+if (isEntrypoint()) {
   void main(process.argv);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   main
-});
+};
 //# sourceMappingURL=cli.js.map