@openbat/cli 0.2.2 → 0.3.0

package/dist/index.js

@@ -32,7 +32,7 @@ var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
 // src/index.ts
-var import_commander8 = require("commander");
+var import_commander10 = require("commander");
 
 // src/commands/config.ts
 var import_commander = require("commander");
@@ -163,7 +163,7 @@ function configPath() {
 
 // src/api-client.ts
 var import_node_url = require("url");
-var CLI_VERSION = "0.2.2";
+var CLI_VERSION = "0.3.0";
 var KEY_REGEX = /ob_(?:live|read|admin|pat)_[0-9a-f]{32}/g;
 function redact(s) {
   return s.replace(KEY_REGEX, (k) => `${k.slice(0, 16)}\u2026<hidden>`);
@@ -433,12 +433,24 @@ function configCommand() {
   cmd.command("show").description("Show the current resolved config (key prefix only)").action(async () => {
     const cfg = await resolveConfig({});
     const keyDisplay = cfg.apiKey ? `${cfg.apiKey.slice(0, 16)}\u2026<hidden>` : "(not set)";
+    let activeChatbot = cfg.activeChatbotId ?? "(not set)";
+    if (cfg.apiKey && cfg.activeChatbotId) {
+      try {
+        const api = new ApiClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl });
+        const list = await api.get("/api/v1/chatbots");
+        const hit = (list.chatbots ?? []).find(
+          (c) => c.id === cfg.activeChatbotId
+        );
+        if (hit) activeChatbot = `${hit.name} (${hit.id})`;
+      } catch {
+      }
+    }
     emit({
       apiKey: keyDisplay,
       apiKeySource: cfg.apiKeySource,
       baseUrl: cfg.baseUrl,
       baseUrlSource: cfg.baseUrlSource,
-      activeChatbotId: cfg.activeChatbotId ?? "(not set)",
+      activeChatbot,
       activeChatbotIdSource: cfg.activeChatbotIdSource,
       configFile: configPath()
     });
@@ -493,9 +505,46 @@ async function resolveTargetChatbotId(target) {
   }
   return matches[0].id;
 }
+async function showCurrentAndOptions() {
+  const cfg = await resolveConfig({});
+  if (!cfg.apiKey) {
+    fatal("No API key configured. Run `openbat config set-key` first.");
+  }
+  const api = new ApiClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl });
+  const list = await api.get(
+    "/api/v1/chatbots"
+  );
+  const chatbots = list.chatbots ?? [];
+  if (cfg.activeChatbotId) {
+    const hit = chatbots.find((c) => c.id === cfg.activeChatbotId);
+    process.stdout.write(
+      hit ? `Active chatbot: ${hit.name} (${hit.id})
+
+` : `Active chatbot: ${cfg.activeChatbotId} (not in reachable set)
+
+`
+    );
+  } else {
+    process.stdout.write("No active chatbot set.\n\n");
+  }
+  if (chatbots.length === 0) {
+    process.stdout.write("No chatbots reachable by this key.\n");
+    return;
+  }
+  process.stdout.write("Reachable chatbots \u2014 pin one with `openbat use <id>`:\n");
+  for (const c of chatbots) {
+    const marker = c.id === cfg.activeChatbotId ? "\u25CF" : "\u25CB";
+    process.stdout.write(`  ${marker} ${c.name}   ${c.id}
+`);
+  }
+}
 function useCommand() {
-  return new import_commander.Command("use").argument("<id-or-name>", "Chatbot UUID or exact name").description("Set the default chatbot for this CLI (shortcut for `config use-chatbot`)").action(async (target) => {
+  return new import_commander.Command("use").argument("[id-or-name]", "Chatbot UUID or exact name (omit to show current + options)").description("Set the active chatbot for this CLI (omit the arg to see current + options)").action(async (target) => {
     try {
+      if (!target) {
+        await showCurrentAndOptions();
+        return;
+      }
       const id = await resolveTargetChatbotId(target);
       await setActiveChatbotId(id);
       process.stdout.write(`Active chatbot saved: ${id}
@@ -525,6 +574,10 @@ async function client(globals) {
   };
 }
 var UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function announceScope(name, id) {
+  process.stderr.write(`\u2192 chatbot: ${name} (${id})
+`);
+}
 async function resolveChatbotId(api, chatbotFlag) {
   const list = await api.get(
     "/api/v1/chatbots"
@@ -543,6 +596,7 @@ async function resolveChatbotId(api, chatbotFlag) {
           `Chatbot ${chatbotFlag} is not reachable by this API key. Run \`openbat chatbot list\` to see what is.`
         );
       }
+      announceScope(hit.name, hit.id);
       return hit.id;
     }
     const lower = chatbotFlag.toLowerCase();
@@ -557,9 +611,13 @@ async function resolveChatbotId(api, chatbotFlag) {
         `Multiple chatbots named "${chatbotFlag}". Use the UUID instead \u2014 list them with \`openbat chatbot list\`.`
       );
     }
+    announceScope(matches[0].name, matches[0].id);
     return matches[0].id;
   }
-  if (chatbots.length === 1) return chatbots[0].id;
+  if (chatbots.length === 1) {
+    announceScope(chatbots[0].name, chatbots[0].id);
+    return chatbots[0].id;
+  }
   const lines = chatbots.map((c) => `  \u2022 ${c.name}   ${c.id}`).join("\n");
   fatal(
     `This API key targets multiple chatbots. Pick one with \`openbat use <id>\` (persistent) or \`--chatbot <id>\` (one-off):
@@ -687,9 +745,10 @@ function exportCommand() {
         `/api/v1/export/${id}?format=${format}`
       );
       if (opts.out) {
-        const { createWriteStream } = await import("fs");
-        const { Writable } = await import("stream");
-        const { Readable } = await import("stream");
+        const [{ createWriteStream }, { Writable, Readable }] = await Promise.all([
+          import("fs"),
+          import("stream")
+        ]);
         const file = createWriteStream(opts.out);
         const nodeReadable = Readable.fromWeb(
           body
@@ -724,6 +783,13 @@ function detectKind(apiKey) {
   if (apiKey.startsWith("ob_pat_")) return "pat";
   return "unknown";
 }
+function activeChatbotDisplay(activeId, chatbots) {
+  if (!activeId) {
+    return chatbots.length > 1 ? `(not pinned \u2014 ${chatbots.length} reachable; run \`openbat use <id>\`)` : "(not pinned)";
+  }
+  const hit = chatbots.find((c) => c.id === activeId);
+  return hit ? `${hit.name} (${hit.id})` : `${activeId} (not in reachable set)`;
+}
 function authCommand() {
   const cmd = new import_commander3.Command("auth").description(
     "Inspect the current credential's scope and audit history"
@@ -747,6 +813,10 @@ function authCommand() {
           {
             kind,
             keyPrefix: `${cfg.apiKey.slice(0, 16)}\u2026<hidden>`,
+            activeChatbot: activeChatbotDisplay(
+              cfg.activeChatbotId,
+              chatbots.chatbots
+            ),
             orgs: orgs.orgs,
             chatbots: chatbots.chatbots
           },
@@ -760,6 +830,10 @@ function authCommand() {
           {
             kind,
             keyPrefix: `${cfg.apiKey.slice(0, 16)}\u2026<hidden>`,
+            activeChatbot: activeChatbotDisplay(
+              cfg.activeChatbotId,
+              chatbots.chatbots
+            ),
             chatbots: chatbots.chatbots
           },
           { json: !!globals.json }
@@ -772,8 +846,178 @@ function authCommand() {
   return cmd;
 }
 
-// src/commands/login.ts
+// src/commands/review.ts
 var import_commander4 = require("commander");
+function parseSinceToMinutes(s) {
+  const match = /^(\d+)\s*(m|h|d)?$/.exec(s.trim().toLowerCase());
+  if (!match) {
+    fatal(`Invalid --since "${s}". Use e.g. 45m, 6h, or 7d.`);
+  }
+  const n = Number(match[1]);
+  const unit = match[2] ?? "m";
+  const minutes = unit === "d" ? n * 1440 : unit === "h" ? n * 60 : n;
+  if (minutes < 1) fatal("--since must be at least 1 minute.");
+  if (minutes > 43200) fatal("--since cannot exceed 30 days (43200m / 720h / 30d).");
+  return minutes;
+}
+var arrow = (t) => t === "up" ? "\u25B2" : t === "down" ? "\u25BC" : "=";
+var pctDelta = (d) => d === null ? "(new)" : `${arrow(d >= 0 ? "up" : "down")} ${d >= 0 ? "+" : ""}${d}%`;
+var ptsDelta = (d) => `${arrow(d >= 0 ? "up" : "down")} ${d >= 0 ? "+" : ""}${d} pts`;
+function renderReview(r) {
+  const L = [];
+  const h = r.headline;
+  L.push(`OpenBat review \xB7 last ${r.window.since} \xB7 vs prior ${r.window.since}`);
+  L.push("");
+  L.push(`  Conversations  ${h.conversations.value}  ${pctDelta(h.conversations.delta_pct)}`);
+  L.push(`  Messages       ${h.messages.value}`);
+  L.push(`  Resolved       ${h.outcomes.resolved.pct}%  ${ptsDelta(h.outcomes.resolved.delta_pts)}`);
+  L.push(`  Partial        ${h.outcomes.partially_resolved.pct}%  ${ptsDelta(h.outcomes.partially_resolved.delta_pts)}`);
+  L.push(`  Failed         ${h.outcomes.failed.pct}%  ${ptsDelta(h.outcomes.failed.delta_pts)}`);
+  const sent = h.avg_sentiment.value ?? "\u2014";
+  const sentDelta = h.avg_sentiment.delta === null ? "" : `  ${arrow(h.avg_sentiment.delta >= 0 ? "up" : "down")} ${h.avg_sentiment.delta >= 0 ? "+" : ""}${h.avg_sentiment.delta}`;
+  L.push(`  Avg sentiment  ${sent}${sentDelta}`);
+  L.push(`  Flagged        ${h.flagged}`);
+  if (r.clusters.issues.length) {
+    L.push("");
+    L.push("Top issues");
+    for (const i of r.clusters.issues) {
+      const ans = i.answer_available.true + i.answer_available.false;
+      const ansStr = ans > 0 ? `  answer_available ${i.answer_available.true}/${ans}` : "";
+      L.push(
+        `  ${i.type}  ${i.count} ${arrow(i.trend)}  high ${i.severity.high} \xB7 med ${i.severity.medium} \xB7 low ${i.severity.low}${ansStr}`
+      );
+    }
+  }
+  if (r.clusters.flags.length) {
+    L.push("");
+    L.push(`Top flags      ${r.clusters.flags.map((f) => `${f.value} ${f.count} ${arrow(f.trend)}`).join(" \xB7 ")}`);
+  }
+  if (r.clusters.intents.length) {
+    L.push(`Top intents    ${r.clusters.intents.map((i) => `${i.value} ${i.count} ${arrow(i.trend)}`).join(" \xB7 ")}`);
+  }
+  const reps = [
+    ...r.clusters.issues.flatMap((i) => i.representatives),
+    ...r.clusters.failedOutcomes
+  ];
+  if (reps.length) {
+    L.push("");
+    L.push("Representative failures");
+    for (const rep of reps.slice(0, 8)) {
+      const tag = rep.type ? `[${rep.type} \xB7 ${rep.severity ?? "?"} \xB7 answer_available=${rep.answer_available ?? "?"} \xB7 source=${rep.verification_source ?? "?"}]` : `[failed outcome]`;
+      L.push(`  ${tag}`);
+      L.push(`    conv ${rep.conversationId ?? "?"} msg ${rep.messageId}`);
+      if (rep.reasoning) L.push(`    why: ${rep.reasoning}`);
+    }
+  }
+  L.push("");
+  L.push("Drill in: openbat conversations show <id>   \xB7   Fix: openbat-optimize skill");
+  return L.join("\n");
+}
+function reviewCommand() {
+  return new import_commander4.Command("review").description(
+    "Daily eval digest for the active chatbot \u2014 flags, issues, outcomes + reasonings"
+  ).option(
+    "--since <duration>",
+    "Look-back window: 45m, 6h, 7d (max 30d)",
+    "24h"
+  ).action(async function(opts) {
+    try {
+      const windowMinutes = parseSinceToMinutes(opts.since);
+      const globals = this.optsWithGlobals();
+      const { api, chatbotFlag } = await client(globals);
+      const id = await resolveChatbotId(api, chatbotFlag);
+      const params = new URLSearchParams({
+        windowMinutes: String(windowMinutes)
+      });
+      const result = await api.get(
+        `/api/v1/chatbots/${id}/review?${params}`
+      );
+      if (this.optsWithGlobals().json) {
+        emit(result, { json: true });
+      } else {
+        process.stdout.write(renderReview(result) + "\n");
+      }
+    } catch (err) {
+      fatal(err instanceof Error ? err.message : String(err));
+    }
+  });
+}
+
+// src/commands/prompts.ts
+var import_commander5 = require("commander");
+var import_node_fs2 = require("fs");
+function promptsCommand() {
+  const cmd = new import_commander5.Command("prompts").description(
+    "Manage the live published system prompt (list / publish / activate / kill-switch)"
+  );
+  cmd.command("list").description("List system-prompt versions + live controls (active version, kill switch)").action(async function() {
+    try {
+      const { api, chatbotFlag } = await client(this.optsWithGlobals());
+      const id = await resolveChatbotId(api, chatbotFlag);
+      const result = await api.get(
+        `/api/v1/chatbots/${id}/prompts`
+      );
+      emit(result, { json: !!this.optsWithGlobals().json });
+    } catch (err) {
+      fatal(err instanceof Error ? err.message : String(err));
+    }
+  });
+  cmd.command("publish").description("Publish a template as the LIVE prompt (from --file or --text)").option("--file <path>", "Read the template text from a file").option("--text <text>", "Inline template text (prefer --file for long prompts)").action(async function(opts) {
+    try {
+      let templateText = opts.text;
+      if (opts.file) templateText = await import_node_fs2.promises.readFile(opts.file, "utf8");
+      if (!templateText || !templateText.trim()) {
+        fatal("Provide the prompt text via --file <path> or --text <text>.");
+      }
+      const { api, chatbotFlag } = await client(this.optsWithGlobals());
+      const id = await resolveChatbotId(api, chatbotFlag);
+      const result = await api.post(
+        `/api/v1/chatbots/${id}/prompts`,
+        { templateText }
+      );
+      emit(result, { json: !!this.optsWithGlobals().json });
+      process.stderr.write(
+        "\nPublished. Live within ~60s for chatbots that fetch their prompt from OpenBat.\n"
+      );
+    } catch (err) {
+      fatal(err instanceof Error ? err.message : String(err));
+    }
+  });
+  cmd.command("activate <versionId>").description("Point the live prompt at an existing version id (roll back/forward)").action(async function(versionId) {
+    try {
+      const { api, chatbotFlag } = await client(this.optsWithGlobals());
+      const id = await resolveChatbotId(api, chatbotFlag);
+      const result = await api.post(
+        `/api/v1/chatbots/${id}/prompts/activate`,
+        { versionId }
+      );
+      emit(result, { json: !!this.optsWithGlobals().json });
+    } catch (err) {
+      fatal(err instanceof Error ? err.message : String(err));
+    }
+  });
+  cmd.command("kill-switch").description("Toggle the remote prompt kill switch (--on / --off)").option("--on", "Enable: SDK falls back to its hardcoded prompt").option("--off", "Disable: SDK serves the active published prompt again").action(async function(opts) {
+    try {
+      if (!!opts.on === !!opts.off) {
+        fatal("Pass exactly one of --on or --off.");
+      }
+      const enabled = !!opts.on;
+      const { api, chatbotFlag } = await client(this.optsWithGlobals());
+      const id = await resolveChatbotId(api, chatbotFlag);
+      const result = await api.post(
+        `/api/v1/chatbots/${id}/prompts/kill-switch`,
+        { enabled }
+      );
+      emit(result, { json: !!this.optsWithGlobals().json });
+    } catch (err) {
+      fatal(err instanceof Error ? err.message : String(err));
+    }
+  });
+  return cmd;
+}
+
+// src/commands/login.ts
+var import_commander6 = require("commander");
 var import_node_os2 = __toESM(require("os"));
 var import_node_readline = __toESM(require("readline"));
 
@@ -916,7 +1160,7 @@ async function runLoopbackServer(opts) {
 // src/commands/login.ts
 var HOSTNAME = import_node_os2.default.hostname();
 function loginCommand() {
-  return new import_commander4.Command("login").description("Sign in via browser and install an API key on this device").option("--device", "Use the device-code flow (for SSH / headless machines)").option(
+  return new import_commander6.Command("login").description("Sign in via browser and install an API key on this device").option("--device", "Use the device-code flow (for SSH / headless machines)").option(
     "--use <key>",
     "Skip the browser; install a PAT plaintext you already have"
   ).action(async function(opts) {
@@ -1106,9 +1350,9 @@ You have ${chatbots.length} chatbots. Pick one later with \`openbat use <id>\`.
 }
 
 // src/commands/logout.ts
-var import_commander5 = require("commander");
+var import_commander7 = require("commander");
 function logoutCommand() {
-  return new import_commander5.Command("logout").description("Revoke the stored API key and clear ~/.openbatrc").action(async function() {
+  return new import_commander7.Command("logout").description("Revoke the stored API key and clear ~/.openbatrc").action(async function() {
     try {
       const globals = this.optsWithGlobals();
       const cfg = await resolveConfig({
@@ -1143,7 +1387,7 @@ function logoutCommand() {
 }
 
 // src/commands/org.ts
-var import_commander6 = require("commander");
+var import_commander8 = require("commander");
 async function client2(globals) {
   const cfg = await resolveConfig({
     apiKeyFlag: globals.apiKey ?? null,
@@ -1158,7 +1402,7 @@ async function client2(globals) {
   return new ApiClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl });
 }
 function orgCommand() {
-  const cmd = new import_commander6.Command("org").description(
+  const cmd = new import_commander8.Command("org").description(
     "Manage the OpenBat tenant org (rename, members, invitations). Requires PAT."
   );
   cmd.command("list").description("List orgs the current PAT's user belongs to").action(async function() {
@@ -1266,7 +1510,7 @@ function orgCommand() {
 }
 
 // src/commands/write.ts
-var import_commander7 = require("commander");
+var import_commander9 = require("commander");
 async function client3(globals) {
   const cfg = await resolveConfig({
     apiKeyFlag: globals.apiKey ?? null,
@@ -1277,6 +1521,15 @@ async function client3(globals) {
   }
   return new ApiClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl });
 }
+function requireChatbotId(cmd) {
+  const globals = cmd.optsWithGlobals();
+  if (!globals.chatbot) {
+    fatal(
+      "--chatbot <id> is required. Pass it inline or set a default with `openbat use <id>`."
+    );
+  }
+  return globals.chatbot;
+}
 function surfacePlaintext(plaintext, label) {
   process.stderr.write(
     `
@@ -1290,7 +1543,7 @@ function surfacePlaintext(plaintext, label) {
   );
 }
 function chatbotsCommand() {
-  const cmd = new import_commander7.Command("chatbots").description(
+  const cmd = new import_commander9.Command("chatbots").description(
     "List, create, delete chatbots in the current scope"
   );
   cmd.command("list").description("List every chatbot the credential can reach").action(async function() {
@@ -1338,24 +1591,26 @@ function chatbotsCommand() {
   return cmd;
 }
 function webhooksCommand() {
-  const cmd = new import_commander7.Command("webhooks").description("Manage webhooks for a chatbot");
-  cmd.command("list").requiredOption("--chatbot <id>", "Chatbot id").action(async function(opts) {
+  const cmd = new import_commander9.Command("webhooks").description("Manage webhooks for a chatbot");
+  cmd.command("list").action(async function() {
     try {
+      const chatbotId = requireChatbotId(this);
       const globals = this.optsWithGlobals();
       const c = await client3(globals);
       const result = await c.get(
-        `/api/v1/chatbots/${opts.chatbot}/webhooks`
+        `/api/v1/chatbots/${chatbotId}/webhooks`
       );
       emit(result.webhooks, { json: !!globals.json });
     } catch (err) {
       fatal(err instanceof Error ? err.message : String(err));
     }
   });
-  cmd.command("create").requiredOption("--chatbot <id>", "Chatbot id").requiredOption("--name <name>").requiredOption("--url <url>").option("--type <type>", "discord | slack | custom", "custom").action(async function(opts) {
+  cmd.command("create").requiredOption("--name <name>").requiredOption("--url <url>").option("--type <type>", "discord | slack | custom", "custom").action(async function(opts) {
     try {
+      const chatbotId = requireChatbotId(this);
       const globals = this.optsWithGlobals();
       const c = await client3(globals);
-      const result = await c.post(`/api/v1/chatbots/${opts.chatbot}/webhooks`, {
+      const result = await c.post(`/api/v1/chatbots/${chatbotId}/webhooks`, {
         name: opts.name,
         url: opts.url,
         type: opts.type
@@ -1366,11 +1621,12 @@ function webhooksCommand() {
       fatal(err instanceof Error ? err.message : String(err));
     }
   });
-  cmd.command("delete").requiredOption("--chatbot <id>", "Chatbot id").requiredOption("--webhook <id>", "Webhook id").action(async function(opts) {
+  cmd.command("delete").requiredOption("--webhook <id>", "Webhook id").action(async function(opts) {
     try {
+      const chatbotId = requireChatbotId(this);
       const globals = this.optsWithGlobals();
       const c = await client3(globals);
-      await c.delete(`/api/v1/chatbots/${opts.chatbot}/webhooks/${opts.webhook}`);
+      await c.delete(`/api/v1/chatbots/${chatbotId}/webhooks/${opts.webhook}`);
       emit({ ok: true, deleted: opts.webhook }, { json: !!globals.json });
     } catch (err) {
       fatal(err instanceof Error ? err.message : String(err));
@@ -1379,16 +1635,17 @@ function webhooksCommand() {
   return cmd;
 }
 function settingsCommand() {
-  const cmd = new import_commander7.Command("settings").description(
+  const cmd = new import_commander9.Command("settings").description(
     "Manage chatbot settings + per-chatbot keys"
   );
   const keys = cmd.command("keys").description("Manage API keys for a chatbot");
-  keys.command("rotate-ingest").requiredOption("--chatbot <id>", "Chatbot id").action(async function(opts) {
+  keys.command("rotate-ingest").action(async function() {
     try {
+      const chatbotId = requireChatbotId(this);
       const globals = this.optsWithGlobals();
       const c = await client3(globals);
       const result = await c.post(
-        `/api/v1/chatbots/${opts.chatbot}/keys/ingest/rotate`,
+        `/api/v1/chatbots/${chatbotId}/keys/ingest/rotate`,
         {}
       );
       surfacePlaintext(result.plaintext, "New ingest key (ob_live_*)");
@@ -1397,12 +1654,13 @@ function settingsCommand() {
       fatal(err instanceof Error ? err.message : String(err));
     }
   });
-  keys.command("generate-read").requiredOption("--chatbot <id>", "Chatbot id").action(async function(opts) {
+  keys.command("generate-read").action(async function() {
     try {
+      const chatbotId = requireChatbotId(this);
       const globals = this.optsWithGlobals();
       const c = await client3(globals);
       const result = await c.post(
-        `/api/v1/chatbots/${opts.chatbot}/keys/read`,
+        `/api/v1/chatbots/${chatbotId}/keys/read`,
         {}
       );
       surfacePlaintext(result.plaintext, "New read key (ob_read_*)");
@@ -1411,11 +1669,12 @@ function settingsCommand() {
       fatal(err instanceof Error ? err.message : String(err));
     }
   });
-  keys.command("generate-admin").requiredOption("--chatbot <id>", "Chatbot id").requiredOption("--name <name>", "Human-friendly name (e.g. 'CI key')").option("--expires-in-days <n>", "Auto-expire after N days").action(async function(opts) {
+  keys.command("generate-admin").requiredOption("--name <name>", "Human-friendly name (e.g. 'CI key')").option("--expires-in-days <n>", "Auto-expire after N days").action(async function(opts) {
     try {
+      const chatbotId = requireChatbotId(this);
       const globals = this.optsWithGlobals();
       const c = await client3(globals);
-      const result = await c.post(`/api/v1/chatbots/${opts.chatbot}/admin-keys`, {
+      const result = await c.post(`/api/v1/chatbots/${chatbotId}/admin-keys`, {
         name: opts.name,
         expiresInDays: opts.expiresInDays ? Number(opts.expiresInDays) : void 0
       });
@@ -1425,30 +1684,33 @@ function settingsCommand() {
       fatal(err instanceof Error ? err.message : String(err));
     }
   });
-  keys.command("list-admin").requiredOption("--chatbot <id>", "Chatbot id").action(async function(opts) {
+  keys.command("list-admin").action(async function() {
     try {
+      const chatbotId = requireChatbotId(this);
       const globals = this.optsWithGlobals();
       const c = await client3(globals);
       const result = await c.get(
-        `/api/v1/chatbots/${opts.chatbot}/admin-keys`
+        `/api/v1/chatbots/${chatbotId}/admin-keys`
       );
       emit(result.keys, { json: !!globals.json });
     } catch (err) {
       fatal(err instanceof Error ? err.message : String(err));
     }
   });
-  keys.command("revoke-admin").requiredOption("--chatbot <id>", "Chatbot id").requiredOption("--key <keyId>", "Admin key id").action(async function(opts) {
+  keys.command("revoke-admin").requiredOption("--key <keyId>", "Admin key id").action(async function(opts) {
     try {
+      const chatbotId = requireChatbotId(this);
       const globals = this.optsWithGlobals();
       const c = await client3(globals);
-      await c.delete(`/api/v1/chatbots/${opts.chatbot}/admin-keys/${opts.key}`);
+      await c.delete(`/api/v1/chatbots/${chatbotId}/admin-keys/${opts.key}`);
       emit({ ok: true, revoked: opts.key }, { json: !!globals.json });
     } catch (err) {
       fatal(err instanceof Error ? err.message : String(err));
     }
   });
-  cmd.command("update").description("Patch a chatbot's settings JSONB").requiredOption("--chatbot <id>", "Chatbot id").option("--description <text>").option("--website-url <url>").option("--language <code>").action(async function(opts) {
+  cmd.command("update").description("Patch a chatbot's settings JSONB").option("--description <text>").option("--website-url <url>").option("--language <code>").action(async function(opts) {
     try {
+      const chatbotId = requireChatbotId(this);
       const settings = {};
       if (opts.description) settings.description = opts.description;
       if (opts.websiteUrl) settings.website_url = opts.websiteUrl;
@@ -1458,7 +1720,7 @@ function settingsCommand() {
       }
       const globals = this.optsWithGlobals();
       const c = await client3(globals);
-      await c.patch(`/api/v1/chatbots/${opts.chatbot}/settings`, { settings });
+      await c.patch(`/api/v1/chatbots/${chatbotId}/settings`, { settings });
       emit({ ok: true }, { json: !!globals.json });
     } catch (err) {
       fatal(err instanceof Error ? err.message : String(err));
@@ -1467,20 +1729,21 @@ function settingsCommand() {
   return cmd;
 }
 function workflowsCommand() {
-  const cmd = new import_commander7.Command("workflows").description("Manage workflows");
-  cmd.command("list").requiredOption("--chatbot <id>", "Chatbot id").action(async function(opts) {
+  const cmd = new import_commander9.Command("workflows").description("Manage workflows");
+  cmd.command("list").action(async function() {
     try {
+      const chatbotId = requireChatbotId(this);
       const globals = this.optsWithGlobals();
       const c = await client3(globals);
       const result = await c.get(
-        `/api/v1/chatbots/${opts.chatbot}/workflows`
+        `/api/v1/chatbots/${chatbotId}/workflows`
       );
       emit(result.workflows, { json: !!globals.json });
     } catch (err) {
       fatal(err instanceof Error ? err.message : String(err));
     }
   });
-  cmd.command("create").description("Create a workflow from a built-in template").requiredOption("--chatbot <id>", "Chatbot id").requiredOption("--name <name>").requiredOption(
+  cmd.command("create").description("Create a workflow from a built-in template").requiredOption("--name <name>").requiredOption(
     "--template <name>",
     "flag-to-webhook | outcome-to-webhook | sentiment-drop-to-webhook"
   ).requiredOption(
@@ -1488,9 +1751,10 @@ function workflowsCommand() {
     "Flag value / outcome value / sentiment threshold"
   ).requiredOption("--webhook <id>", "Webhook id to fire").option("--message <tpl>", "Message template (supports {{user.id}}, etc.)").action(async function(opts) {
     try {
+      const chatbotId = requireChatbotId(this);
       const globals = this.optsWithGlobals();
       const c = await client3(globals);
-      const result = await c.post(`/api/v1/chatbots/${opts.chatbot}/workflows`, {
+      const result = await c.post(`/api/v1/chatbots/${chatbotId}/workflows`, {
         name: opts.name,
         template: opts.template,
         triggerValue: opts.triggerValue,
@@ -1505,24 +1769,26 @@ function workflowsCommand() {
   return cmd;
 }
 function reportsCommand() {
-  const cmd = new import_commander7.Command("reports").description("Manage AI reports");
-  cmd.command("list").requiredOption("--chatbot <id>", "Chatbot id").action(async function(opts) {
+  const cmd = new import_commander9.Command("reports").description("Manage AI reports");
+  cmd.command("list").action(async function() {
     try {
+      const chatbotId = requireChatbotId(this);
       const globals = this.optsWithGlobals();
       const c = await client3(globals);
       const result = await c.get(
-        `/api/v1/chatbots/${opts.chatbot}/reports`
+        `/api/v1/chatbots/${chatbotId}/reports`
       );
       emit(result.reports, { json: !!globals.json });
     } catch (err) {
       fatal(err instanceof Error ? err.message : String(err));
     }
   });
-  cmd.command("create").description("Create a new AI report; returns the org-private dashboard URL").requiredOption("--chatbot <id>", "Chatbot id").option("--name <name>", "Report name", "Untitled Report").action(async function(opts) {
+  cmd.command("create").description("Create a new AI report; returns the org-private dashboard URL").option("--name <name>", "Report name", "Untitled Report").action(async function(opts) {
     try {
+      const chatbotId = requireChatbotId(this);
       const globals = this.optsWithGlobals();
       const c = await client3(globals);
-      const result = await c.post(`/api/v1/chatbots/${opts.chatbot}/reports`, { name: opts.name });
+      const result = await c.post(`/api/v1/chatbots/${chatbotId}/reports`, { name: opts.name });
       process.stderr.write(
         `
 Created report. View it (org members only):
@@ -1541,31 +1807,33 @@ Created report. View it (org members only):
   return cmd;
 }
 function analysisCommand() {
-  const cmd = new import_commander7.Command("analysis").description("Manage analysis definitions");
-  cmd.command("list").requiredOption("--chatbot <id>", "Chatbot id").option("--type <t>", "intent | flag | assistant_outcome | assistant_issue").option("--pending", "Include pending suggestions").action(async function(opts) {
+  const cmd = new import_commander9.Command("analysis").description("Manage analysis definitions");
+  cmd.command("list").option("--type <t>", "intent | flag | assistant_outcome | assistant_issue").option("--pending", "Include pending suggestions").action(async function(opts) {
     try {
+      const chatbotId = requireChatbotId(this);
       const globals = this.optsWithGlobals();
       const c = await client3(globals);
       const qs = new URLSearchParams();
       if (opts.type) qs.set("type", opts.type);
       if (opts.pending) qs.set("pending", "true");
       const result = await c.get(
-        `/api/v1/chatbots/${opts.chatbot}/analysis-definitions${qs.size ? `?${qs}` : ""}`
+        `/api/v1/chatbots/${chatbotId}/analysis-definitions${qs.size ? `?${qs}` : ""}`
       );
       emit(result.definitions, { json: !!globals.json });
     } catch (err) {
       fatal(err instanceof Error ? err.message : String(err));
     }
   });
-  cmd.command("add").requiredOption("--chatbot <id>", "Chatbot id").requiredOption(
+  cmd.command("add").requiredOption(
     "--type <t>",
     "intent | flag | assistant_outcome | assistant_issue"
   ).requiredOption("--name <slug>", "snake_case slug").requiredOption("--display-name <text>").requiredOption("--description <text>").action(async function(opts) {
     try {
+      const chatbotId = requireChatbotId(this);
       const globals = this.optsWithGlobals();
       const c = await client3(globals);
       const result = await c.post(
-        `/api/v1/chatbots/${opts.chatbot}/analysis-definitions`,
+        `/api/v1/chatbots/${chatbotId}/analysis-definitions`,
         {
           analysisType: opts.type,
           name: opts.name,
@@ -1581,11 +1849,12 @@ function analysisCommand() {
   return cmd;
 }
 function usersCommand() {
-  const cmd = new import_commander7.Command("users").description(
+  const cmd = new import_commander9.Command("users").description(
     "List external users (chatbot customers) with health metrics"
   );
-  cmd.command("list").requiredOption("--chatbot <id>", "Chatbot id").option("--from <iso>").option("--to <iso>").option("--days <n>", "Convenience: last N days").option("--search <q>").option("--limit <n>", "Page size", "20").action(async function(opts) {
+  cmd.command("list").option("--from <iso>").option("--to <iso>").option("--days <n>", "Convenience: last N days").option("--search <q>").option("--limit <n>", "Page size", "20").action(async function(opts) {
     try {
+      const chatbotId = requireChatbotId(this);
       const globals = this.optsWithGlobals();
       const c = await client3(globals);
       const qs = new URLSearchParams();
@@ -1600,7 +1869,7 @@ function usersCommand() {
       if (opts.search) qs.set("search", opts.search);
       qs.set("limit", opts.limit);
       const result = await c.get(
-        `/api/v1/chatbots/${opts.chatbot}/external-users?${qs}`
+        `/api/v1/chatbots/${chatbotId}/external-users?${qs}`
       );
       emit(result.users, { json: !!globals.json });
       process.stderr.write(`
@@ -1613,7 +1882,7 @@ Total: ${result.total}
   return cmd;
 }
 function sdkCommand() {
-  const cmd = new import_commander7.Command("sdk").description(
+  const cmd = new import_commander9.Command("sdk").description(
     "Help install and verify the OpenBat SDK in a target project"
   );
   cmd.command("install-instructions").description("Print markdown the calling agent can follow").option(
@@ -1675,18 +1944,22 @@ function sdkCommand() {
     const out = opts.framework === "vercel-ai-sdk" ? snippetWrapper : snippetNext;
     process.stdout.write(out);
   });
-  cmd.command("verify").description("Check whether any event has arrived for the chatbot yet").requiredOption("--chatbot <id>", "Chatbot id").option("--timeout <n>", "Seconds to wait (default: 60)", "60").action(async function(opts) {
+  cmd.command("verify").description("Check whether any event has arrived for the chatbot yet").option("--timeout <n>", "Seconds to wait (default: 60)", "60").action(async function(opts) {
     try {
       const globals = this.optsWithGlobals();
+      const chatbotId = globals.chatbot;
+      if (!chatbotId) {
+        fatal("--chatbot <id> is required (also accepts the persisted active chatbot).");
+      }
       const c = await client3(globals);
       const timeoutSec = Number(opts.timeout);
       const deadline = Date.now() + timeoutSec * 1e3;
       const params = new URLSearchParams({
-        chatbotId: opts.chatbot,
+        chatbotId,
         limit: "1"
       });
       process.stderr.write(
-        `Waiting for first event on chatbot ${opts.chatbot} (timeout ${timeoutSec}s)\u2026
+        `Waiting for first event on chatbot ${chatbotId} (timeout ${timeoutSec}s)\u2026
 `
       );
       let lastTick = Date.now();
@@ -1719,10 +1992,10 @@ Timed out after ${timeoutSec}s \u2014 no events yet. Confirm OPENBAT_API_KEY and
 }
 
 // src/index.ts
-var program = new import_commander8.Command();
+var program = new import_commander10.Command();
 program.name("openbat").description(
   "Query OpenBat chatbot data \u2014 conversations, sentiment, analytics, exports."
-).version("0.2.2").option("--api-key <key>", "Override the stored Read API key (footgun \u2014 leaks into shell history)").option(
+).version("0.3.0").option("--api-key <key>", "Override the stored Read API key (footgun \u2014 leaks into shell history)").option(
   "--base-url <url>",
   "Override the OpenBat API base URL (defaults to ~/.openbatrc or https://openbat.dev)"
 ).option(
@@ -1741,6 +2014,8 @@ program.addCommand(orgCommand());
 program.addCommand(chatbotCommand());
 program.addCommand(chatbotsCommand());
 program.addCommand(conversationsCommand());
+program.addCommand(reviewCommand());
+program.addCommand(promptsCommand());
 program.addCommand(usersCommand());
 program.addCommand(settingsCommand());
 program.addCommand(webhooksCommand());