@heysummon/consumer-sdk 0.1.1 → 0.2.7

package/src/cli.ts

@@ -3,25 +3,19 @@
  * HeySummon Consumer SDK CLI
  *
  * Shared CLI entry point used by both Claude Code and OpenClaw skill scripts.
- * Subcommands: submit, submit-and-poll, add-provider, list-providers,
- *              check-status, watch, keygen
+ * Subcommands: submit-and-poll, add-expert, list-experts,
+ *              check-status, keygen
  *
  * All config comes from environment variables (set by the calling bash wrapper):
- *   HEYSUMMON_BASE_URL, HEYSUMMON_API_KEY, HEYSUMMON_PROVIDERS_FILE,
- *   HEYSUMMON_KEY_DIR, HEYSUMMON_REQUESTS_DIR, HEYSUMMON_TIMEOUT,
+ *   HEYSUMMON_BASE_URL, HEYSUMMON_API_KEY, HEYSUMMON_EXPERTS_FILE,
+ *   HEYSUMMON_TIMEOUT,
  *   HEYSUMMON_POLL_INTERVAL
  */
 
 import { HeySummonClient, HeySummonHttpError } from "./client.js";
-import { ProviderStore } from "./provider-store.js";
-import { RequestTracker } from "./request-tracker.js";
-import {
-  generateEphemeralKeys,
-  generatePersistentKeys,
-  loadPublicKeys,
-} from "./crypto.js";
-import type { PendingEvent, Message } from "./types.js";
-import { execSync } from "node:child_process";
+import { ExpertStore } from "./expert-store.js";
+import { generateEphemeralKeys, generatePersistentKeys } from "./crypto.js";
+import type { DecryptedMessage } from "./types.js";
 import { existsSync } from "node:fs";
 
 // ---------------------------------------------------------------------------
@@ -51,177 +45,52 @@ function optEnv(name: string, fallback: string): string {
 // Commands
 // ---------------------------------------------------------------------------
 
-async function cmdSubmit(args: string[]): Promise<void> {
-  const question = getArg(args, "--question");
-  if (!question) {
-    process.stderr.write("Usage: cli submit --question <q> [--provider <name>] [--context <json>]\n");
-    process.exit(1);
-  }
-
-  const providerArg = getArg(args, "--provider");
-  const contextArg = getArg(args, "--context");
-  const baseUrl = requireEnv("HEYSUMMON_BASE_URL");
-  const providersFile = optEnv("HEYSUMMON_PROVIDERS_FILE", "");
-  const keyDir = optEnv("HEYSUMMON_KEY_DIR", "");
-  const requestsDir = optEnv("HEYSUMMON_REQUESTS_DIR", "");
-
-  // Resolve API key from provider store or env
-  let apiKey = process.env.HEYSUMMON_API_KEY || "";
-  let resolvedProvider = "";
-
-  if (providersFile && existsSync(providersFile)) {
-    const store = new ProviderStore(providersFile);
-
-    if (providerArg) {
-      const match = store.findByName(providerArg);
-      if (match) {
-        apiKey = match.apiKey;
-        resolvedProvider = match.name;
-      } else {
-        process.stderr.write(`Provider '${providerArg}' not found.\n`);
-        const all = store.load();
-        if (all.length) {
-          process.stderr.write("Available:\n");
-          for (const p of all) {
-            process.stderr.write(`  - ${p.name} (${p.providerName})\n`);
-          }
-        }
-        process.exit(1);
-      }
-    } else if (!apiKey) {
-      const def = store.getDefault();
-      if (def) {
-        apiKey = def.apiKey;
-        resolvedProvider = def.name;
-      }
-    }
-  }
-
-  if (!apiKey) {
-    process.stderr.write("No API key. Set HEYSUMMON_API_KEY or register a provider.\n");
-    process.exit(1);
-  }
-
-  // Generate or load keys
-  let signPublicKey: string;
-  let encryptPublicKey: string;
-
-  if (keyDir && existsSync(`${keyDir}/sign_public.pem`)) {
-    const keys = loadPublicKeys(keyDir);
-    signPublicKey = keys.signPublicKey;
-    encryptPublicKey = keys.encryptPublicKey;
-  } else if (keyDir) {
-    process.stderr.write(`Generating keypairs in ${keyDir}...\n`);
-    const keys = generatePersistentKeys(keyDir);
-    signPublicKey = keys.signPublicKey;
-    encryptPublicKey = keys.encryptPublicKey;
-  } else {
-    const keys = generateEphemeralKeys();
-    signPublicKey = keys.signPublicKey;
-    encryptPublicKey = keys.encryptPublicKey;
-  }
-
-  // Parse context messages
-  let messages: Array<{ role: string; content: string }> = [];
-  if (contextArg) {
-    try {
-      messages = JSON.parse(contextArg);
-    } catch {
-      // ignore parse errors
-    }
-  }
-
-  const client = new HeySummonClient({ baseUrl, apiKey });
-
-  if (resolvedProvider) {
-    process.stderr.write(`Provider: ${resolvedProvider}\n`);
-  }
-
-  const result = await client.submitRequest({
-    question,
-    messages: messages.length > 0 ? messages : undefined,
-    signPublicKey,
-    encryptPublicKey,
-    providerName: providerArg || undefined,
-  });
-
-  if (!result.requestId) {
-    process.stderr.write(`Request failed: ${JSON.stringify(result)}\n`);
-    process.exit(1);
-  }
-
-  // Track request
-  if (requestsDir) {
-    const tracker = new RequestTracker(requestsDir);
-    tracker.track(result.requestId, result.refCode, resolvedProvider || undefined);
-  }
-
-  // Sync provider name
-  if (providersFile && existsSync(providersFile) && apiKey) {
-    try {
-      const whoami = await client.whoami();
-      const pName = whoami.provider?.name || "";
-      if (pName) {
-        const store = new ProviderStore(providersFile);
-        const entry = store.findByKey(apiKey);
-        if (entry && entry.providerName !== pName) {
-          store.add({ ...entry, providerName: pName });
-          process.stderr.write(`Provider name updated: ${pName}\n`);
-        }
-      }
-    } catch {
-      // non-fatal
-    }
-  }
-
-  // Output result as JSON
-  process.stdout.write(JSON.stringify(result) + "\n");
+function hasFlag(args: string[], flag: string): boolean {
+  return args.includes(flag);
 }
 
 async function cmdSubmitAndPoll(args: string[]): Promise<void> {
   const question = getArg(args, "--question");
   if (!question) {
-    process.stderr.write("Usage: cli submit-and-poll --question <q> [--provider <name>] [--context <json>]\n");
+    process.stderr.write("Usage: cli submit-and-poll --question <q> [--expert <name>] [--context <json>] [--requires-approval]\n");
     process.exit(1);
   }
 
-  const providerArg = getArg(args, "--provider");
+  const expertArg = getArg(args, "--expert");
   const contextArg = getArg(args, "--context");
+  const requiresApproval = hasFlag(args, "--requires-approval");
   const baseUrl = requireEnv("HEYSUMMON_BASE_URL");
   const timeout = parseInt(optEnv("HEYSUMMON_TIMEOUT", "900"), 10);
   const pollInterval = parseInt(optEnv("HEYSUMMON_POLL_INTERVAL", "3"), 10);
-  const providersFile = optEnv("HEYSUMMON_PROVIDERS_FILE", "");
+  const expertsFile = optEnv("HEYSUMMON_EXPERTS_FILE", "");
 
   // Resolve API key
   let apiKey = process.env.HEYSUMMON_API_KEY || "";
-  let resolvedProvider = "";
 
-  if (providersFile && existsSync(providersFile)) {
-    const store = new ProviderStore(providersFile);
-    if (providerArg) {
-      const match = store.findByName(providerArg);
+  if (expertsFile && existsSync(expertsFile)) {
+    const store = new ExpertStore(expertsFile);
+    if (expertArg) {
+      const match = store.findByName(expertArg);
       if (match) {
         apiKey = match.apiKey;
-        resolvedProvider = match.name;
       } else {
-        process.stderr.write(`Provider '${providerArg}' not found.\n`);
+        process.stderr.write(`Expert '${expertArg}' not found.\n`);
         process.exit(1);
       }
     } else if (!apiKey) {
       const def = store.getDefault();
       if (def) {
         apiKey = def.apiKey;
-        resolvedProvider = def.name;
       }
     }
   }
 
   if (!apiKey) {
-    process.stderr.write("No API key. Set HEYSUMMON_API_KEY or register a provider.\n");
+    process.stderr.write("No API key. Set HEYSUMMON_API_KEY or register an expert.\n");
     process.exit(1);
   }
 
-  // Generate ephemeral keys (Claude Code style — no persistence needed)
+  // Generate ephemeral keys (Claude Code style -- no persistence needed)
   const keys = generateEphemeralKeys();
   const client = new HeySummonClient({ baseUrl, apiKey });
 
@@ -237,21 +106,33 @@ async function cmdSubmitAndPoll(args: string[]): Promise<void> {
     }
   }
 
-  const result = await client.submitRequest({
-    question,
-    messages: messages.length > 0 ? messages : undefined,
-    signPublicKey: keys.signPublicKey,
-    encryptPublicKey: keys.encryptPublicKey,
-    providerName: providerArg || undefined,
-  });
-
-  if (result.providerUnavailable) {
-    const next = result.nextAvailableAt
-      ? ` (available at ${new Date(result.nextAvailableAt).toLocaleTimeString()})`
-      : "";
-    process.stderr.write(
-      `Provider currently unavailable${next} — request queued, waiting for response...\n`
-    );
+  let result;
+  try {
+    result = await client.submitRequest({
+      question,
+      messages: messages.length > 0 ? messages : undefined,
+      signPublicKey: keys.signPublicKey,
+      encryptPublicKey: keys.encryptPublicKey,
+      expertName: expertArg || undefined,
+      requiresApproval: requiresApproval || undefined,
+    });
+  } catch (err) {
+    if (err instanceof HeySummonHttpError && err.status === 403) {
+      let parsed: { error?: string; hint?: string; ip?: string } = {};
+      try { parsed = JSON.parse(err.body); } catch { /* ignore */ }
+
+      const ip = parsed.ip || "unknown";
+      const hint = parsed.hint || "";
+      process.stderr.write(
+        `IP address ${ip} is not authorized for this API key.\n` +
+        `${hint ? hint + "\n" : ""}` +
+        `Your expert needs to allow this IP address in the HeySummon dashboard under Clients > IP Security.\n` +
+        `Once allowed, re-run this command.\n`
+      );
+      process.stdout.write(`IP_NOT_ALLOWED: IP address ${ip} is not authorized. Ask your expert to allow it in their HeySummon dashboard.\n`);
+      return;
+    }
+    throw err;
   }
 
   if (!result.requestId) {
@@ -260,8 +141,19 @@ async function cmdSubmitAndPoll(args: string[]): Promise<void> {
   }
 
   const ref = result.refCode || result.requestId;
+
+  // When expert is unavailable, the platform rejects the request
+  if (result.rejected) {
+    const msg = result.message || "Expert is not available right now.";
+    process.stderr.write(`${msg}\n`);
+    process.stdout.write(
+      `EXPERT_UNAVAILABLE: ${msg}${result.nextAvailableAt ? ` Next available: ${result.nextAvailableAt}` : ""}\n`
+    );
+    return;
+  }
+
   process.stderr.write(
-    `Request submitted [${ref}] — waiting for human response...\n`
+    `Request submitted [${ref}] -- waiting for human response...\n`
   );
   process.stderr.write(
     `   (timeout: ${timeout}s, polling every ${pollInterval}s)\n`
@@ -276,6 +168,18 @@ async function cmdSubmitAndPoll(args: string[]): Promise<void> {
     try {
       // Check status endpoint
       const status = await client.getRequestStatus(result.requestId);
+
+      // Approval decision (Approve/Deny buttons)
+      if (
+        (status.status === "responded" || status.status === "closed") &&
+        status.approvalDecision
+      ) {
+        process.stderr.write(`\nHuman responded [${ref}] -- decision: ${status.approvalDecision}\n`);
+        process.stdout.write(`${status.approvalDecision.toUpperCase()}\n`);
+        await client.ackEvent(result.requestId).catch(() => {});
+        return;
+      }
+
       if (
         (status.status === "responded" || status.status === "closed") &&
         status.response
@@ -287,15 +191,15 @@ async function cmdSubmitAndPoll(args: string[]): Promise<void> {
 
       // Fallback: check messages for plaintext replies
       const { messages: msgs } = await client.getMessages(result.requestId);
-      const providerMsg = msgs.filter((m: Message) => m.from === "provider").pop();
-      if (providerMsg) {
-        if (providerMsg.plaintext) {
+      const expertMsg = msgs.filter((m: DecryptedMessage) => m.from === "expert").pop();
+      if (expertMsg) {
+        if (expertMsg.plaintext) {
           process.stderr.write(`\nHuman responded [${ref}]\n`);
-          process.stdout.write(providerMsg.plaintext + "\n");
+          process.stdout.write(expertMsg.plaintext + "\n");
           await client.ackEvent(result.requestId).catch(() => {});
           return;
         }
-        if (providerMsg.ciphertext) {
+        if (expertMsg.ciphertext) {
           process.stderr.write(`\nHuman responded [${ref}]\n`);
           process.stdout.write("(encrypted response received)\n");
           await client.ackEvent(result.requestId).catch(() => {});
@@ -312,25 +216,28 @@ async function cmdSubmitAndPoll(args: string[]): Promise<void> {
     }
   }
 
-  process.stderr.write(`\nTimeout after ${timeout}s — no response received.\n`);
+  // Report timeout to server (notifies expert, records timestamp)
+  await client.reportTimeout(result.requestId).catch(() => {});
+
+  process.stderr.write(`\nTimeout after ${timeout}s -- no response received.\n`);
   process.stderr.write(`   Request ref: ${ref}\n`);
   process.stdout.write(
-    `TIMEOUT: No response received after ${timeout}s for request ${ref}. The provider may still respond later.\n`
+    `TIMEOUT: No answer came back from the expert within the ${timeout}s timeout window. Request ref: ${ref}\n`
   );
 }
 
-async function cmdAddProvider(args: string[]): Promise<void> {
+async function cmdAddExpert(args: string[]): Promise<void> {
   const key = getArg(args, "--key");
   const alias = getArg(args, "--alias");
 
   if (!key) {
-    process.stderr.write("Usage: cli add-provider --key <api-key> [--alias <name>]\n");
+    process.stderr.write("Usage: cli add-expert --key <api-key> [--alias <name>]\n");
     process.exit(1);
   }
 
   // Validate key prefix
-  if (key.startsWith("hs_prov_") || key.startsWith("htl_prov_")) {
-    process.stderr.write("This is a provider key. Use a CLIENT key (hs_cli_... or htl_...).\n");
+  if (key.startsWith("hs_exp_") || key.startsWith("htl_exp_")) {
+    process.stderr.write("This is an expert key. Use a CLIENT key (hs_cli_... or htl_...).\n");
     process.exit(1);
   }
   if (!key.startsWith("hs_cli_") && !key.startsWith("htl_")) {
@@ -339,56 +246,56 @@ async function cmdAddProvider(args: string[]): Promise<void> {
   }
 
   const baseUrl = requireEnv("HEYSUMMON_BASE_URL");
-  const providersFile = requireEnv("HEYSUMMON_PROVIDERS_FILE");
+  const expertsFile = requireEnv("HEYSUMMON_EXPERTS_FILE");
 
   const client = new HeySummonClient({ baseUrl, apiKey: key });
   const whoami = await client.whoami();
 
-  const providerName = whoami.provider?.name || "";
-  const providerId = whoami.provider?.id || "";
+  const expertName = whoami.expert?.name || "";
+  const expertId = whoami.expert?.id || "";
 
-  if (!providerName) {
-    process.stderr.write("Could not fetch provider info. Is the key valid?\n");
+  if (!expertName) {
+    process.stderr.write("Could not fetch expert info. Is the key valid?\n");
     process.exit(1);
   }
 
-  const name = alias || providerName;
-  const store = new ProviderStore(providersFile);
+  const name = alias || expertName;
+  const store = new ExpertStore(expertsFile);
   store.add({
     name,
     apiKey: key,
-    providerId,
-    providerName,
+    expertId,
+    expertName,
   });
 
   const count = store.load().length;
-  process.stdout.write(`Provider added: ${name} (${providerName})\n`);
-  process.stdout.write(`Providers registered: ${count}\n`);
+  process.stdout.write(`Expert added: ${name} (${expertName})\n`);
+  process.stdout.write(`Experts registered: ${count}\n`);
 }
 
-async function cmdListProviders(): Promise<void> {
-  const providersFile = optEnv("HEYSUMMON_PROVIDERS_FILE", "");
+async function cmdListExperts(): Promise<void> {
+  const expertsFile = optEnv("HEYSUMMON_EXPERTS_FILE", "");
 
-  if (!providersFile || !existsSync(providersFile)) {
-    process.stdout.write("No providers registered yet.\n");
+  if (!expertsFile || !existsSync(expertsFile)) {
+    process.stdout.write("No experts registered yet.\n");
     return;
   }
 
-  const store = new ProviderStore(providersFile);
-  const providers = store.load();
+  const store = new ExpertStore(expertsFile);
+  const experts = store.load();
 
-  if (providers.length === 0) {
-    process.stdout.write("No providers registered yet.\n");
+  if (experts.length === 0) {
+    process.stdout.write("No experts registered yet.\n");
     return;
   }
 
-  process.stdout.write(`Registered providers (${providers.length}):\n`);
-  for (let i = 0; i < providers.length; i++) {
-    const p = providers[i];
+  process.stdout.write(`Registered experts (${experts.length}):\n`);
+  for (let i = 0; i < experts.length; i++) {
+    const p = experts[i];
     const nameExtra =
-      p.providerName !== p.name ? ` (provider: ${p.providerName})` : "";
+      p.expertName !== p.name ? ` (expert: ${p.expertName})` : "";
     process.stdout.write(
-      `  ${i + 1}. ${p.name}${nameExtra} — key: ${p.apiKey.slice(0, 12)}...\n`
+      `  ${i + 1}. ${p.name}${nameExtra} -- key: ${p.apiKey.slice(0, 12)}...\n`
     );
   }
 }
@@ -408,14 +315,14 @@ async function cmdCheckStatus(args: string[]): Promise<void> {
   try {
     const data = await client.getRequestStatus(ref);
     const icons: Record<string, string> = {
-      pending: "⏳",
-      responded: "✅",
-      resolved: "✅",
-      expired: "⏰",
-      cancelled: "❌",
+      pending: "...",
+      responded: "[ok]",
+      resolved: "[ok]",
+      expired: "[expired]",
+      cancelled: "[cancelled]",
     };
     const status = data.status || "unknown";
-    process.stdout.write(`${icons[status] || "•"} Status: ${status}\n`);
+    process.stdout.write(`${icons[status] || "-"} Status: ${status}\n`);
     if (data.refCode) process.stdout.write(`  Ref: ${data.refCode}\n`);
     if (data.response || data.lastMessage) {
       process.stdout.write(`  Response: ${data.response || data.lastMessage}\n`);
@@ -426,211 +333,6 @@ async function cmdCheckStatus(args: string[]): Promise<void> {
   }
 }
 
-async function cmdWatch(args: string[]): Promise<void> {
-  const notifyScript = getArg(args, "--notify-script");
-  const baseUrl = requireEnv("HEYSUMMON_BASE_URL");
-  const providersFile = requireEnv("HEYSUMMON_PROVIDERS_FILE");
-  const requestsDir = optEnv("HEYSUMMON_REQUESTS_DIR", "");
-  const pollInterval = parseInt(optEnv("HEYSUMMON_POLL_INTERVAL", "5"), 10);
-
-  const store = new ProviderStore(providersFile);
-  const tracker = requestsDir ? new RequestTracker(requestsDir) : null;
-
-  // In-memory dedup set
-  const seen = new Set<string>();
-
-  // Track persistent auth errors per provider — auto-shutdown after 30 min
-  const AUTH_SHUTDOWN_MS = 30 * 60 * 1000; // 30 minutes
-  const authErrors = new Map<string, { firstAt: number; count: number }>();
-
-  process.stderr.write(`Platform watcher started (pid ${process.pid})\n`);
-  process.stderr.write(`   Polling every ${pollInterval}s\n`);
-
-  // Write PID file for signaling
-  if (requestsDir) {
-    const { writeFileSync } = await import("node:fs");
-    const { join } = await import("node:path");
-    writeFileSync(join(requestsDir, ".watcher.pid"), String(process.pid));
-  }
-
-  while (true) {
-    const providers = store.load();
-    if (providers.length === 0) {
-      process.stderr.write("No providers registered.\n");
-      await sleep(pollInterval * 1000);
-      continue;
-    }
-
-    for (const provider of providers) {
-      try {
-        const client = new HeySummonClient({
-          baseUrl,
-          apiKey: provider.apiKey,
-        });
-        const { events } = await client.getPendingEvents();
-
-        for (const event of events) {
-          const from = event.from || "unknown";
-          const dedupKey = `${event.type}:${from}:${event.requestId}`;
-
-          // Stale check (>30 min)
-          if (event.createdAt) {
-            const age =
-              (Date.now() - new Date(event.createdAt).getTime()) / 1000 / 60;
-            if (age > 30) {
-              seen.add(dedupKey);
-              continue;
-            }
-          }
-
-          if (seen.has(dedupKey)) continue;
-          seen.add(dedupKey);
-
-          // Fetch response text for provider messages
-          let responseText = "";
-          if (
-            event.type === "new_message" &&
-            event.from === "provider" &&
-            event.requestId
-          ) {
-            try {
-              const { messages } = await client.getMessages(event.requestId);
-              const last = messages
-                .filter((m: Message) => m.from === "provider")
-                .pop();
-              if (last?.plaintext) {
-                responseText = last.plaintext;
-              } else if (last?.ciphertext) {
-                responseText = "(encrypted)";
-              }
-            } catch {
-              // non-fatal
-            }
-          }
-
-          // Build notification
-          const fileRef = tracker?.getRefCode(event.requestId) || "";
-          const ref = event.refCode || fileRef || event.requestId || "?";
-
-          let msg = "";
-          switch (event.type) {
-            case "keys_exchanged":
-              msg = `Key exchange completed for ${ref} — provider connected`;
-              break;
-            case "new_message":
-              if (event.from === "provider") {
-                msg = `New response from provider for ${ref}`;
-                if (responseText) msg += `\n${responseText}`;
-              }
-              break;
-            case "responded":
-              msg = `Provider responded to ${ref}`;
-              break;
-            case "closed":
-              msg = `Conversation ${ref} closed`;
-              if (tracker) tracker.remove(event.requestId);
-              break;
-            default:
-              msg = `HeySummon event (${event.type}) for ${ref}`;
-          }
-
-          if (!msg) continue;
-
-          // Build wake text with original question context
-          let wakeText = msg;
-          if (responseText && event.requestId) {
-            try {
-              const reqData = await client.getRequestByRef(fileRef || event.requestId);
-              const origQuestion = reqData.question || "";
-              const provName =
-                reqData.provider?.name || reqData.providerName || "the provider";
-
-              wakeText = `${ref} — ${provName} responded!`;
-              if (origQuestion)
-                wakeText += `\n\nYour question was: ${origQuestion}`;
-              wakeText += `\n\nAnswer: ${responseText}`;
-              wakeText += `\n\nProceed based on this answer.`;
-            } catch {
-              // non-fatal, use plain msg
-            }
-          }
-
-          // Deliver notification
-          if (notifyScript) {
-            try {
-              const eventJson = JSON.stringify({
-                event,
-                msg,
-                wakeText,
-                responseText,
-                ref,
-              });
-              execSync(`bash "${notifyScript}"`, {
-                input: eventJson,
-                stdio: ["pipe", "inherit", "inherit"],
-                timeout: 30_000,
-              });
-            } catch {
-              process.stderr.write(`Notify script failed for ${ref}\n`);
-            }
-          } else {
-            process.stdout.write(`${msg}\n`);
-          }
-
-          // ACK the event
-          await client.ackEvent(event.requestId).catch(() => {});
-        }
-      } catch (err) {
-        const isAuth = err instanceof HeySummonHttpError && err.isAuthError;
-
-        if (isAuth) {
-          const key = provider.apiKey;
-          const existing = authErrors.get(key);
-          if (!existing) {
-            authErrors.set(key, { firstAt: Date.now(), count: 1 });
-            process.stderr.write(
-              `Auth error for "${provider.name}" (${err instanceof HeySummonHttpError ? `HTTP ${err.status}` : "unknown"}). Will retry...\n`
-            );
-          } else {
-            existing.count++;
-            const elapsed = Date.now() - existing.firstAt;
-            if (elapsed >= AUTH_SHUTDOWN_MS) {
-              const status = err instanceof HeySummonHttpError ? err.status : "?";
-              const detail = err instanceof HeySummonHttpError ? err.body : String(err);
-              process.stderr.write(
-                `\n` +
-                `══════════════════════════════════════════════════════\n` +
-                `  HeySummon watcher shutting down\n` +
-                `\n` +
-                `  Provider "${provider.name}" has returned HTTP ${status}\n` +
-                `  for ${Math.round(elapsed / 60000)} minutes (${existing.count} attempts).\n` +
-                `\n` +
-                `  This usually means the API key was deleted or\n` +
-                `  deactivated on the HeySummon platform.\n` +
-                `\n` +
-                `  Detail: ${detail}\n` +
-                `\n` +
-                `  To fix: ask your provider for a new setup link,\n` +
-                `  then re-run the setup to get fresh credentials.\n` +
-                `══════════════════════════════════════════════════════\n`
-              );
-              process.exit(1);
-            }
-          }
-        } else {
-          // Clear auth error streak on non-auth errors (network issues etc.)
-          authErrors.delete(provider.apiKey);
-          process.stderr.write(
-            `Poll error for ${provider.name}: ${err instanceof Error ? err.message : String(err)}\n`
-          );
-        }
-      }
-    }
-
-    await sleep(pollInterval * 1000);
-  }
-}
-
 async function cmdKeygen(args: string[]): Promise<void> {
   const dir = getArg(args, "--dir") || optEnv("HEYSUMMON_KEY_DIR", "");
 
@@ -659,12 +361,10 @@ function sleep(ms: number): Promise<void> {
 const [command, ...rest] = process.argv.slice(2);
 
 const commands: Record<string, (args: string[]) => Promise<void>> = {
-  submit: cmdSubmit,
   "submit-and-poll": cmdSubmitAndPoll,
-  "add-provider": cmdAddProvider,
-  "list-providers": cmdListProviders,
+  "add-expert": cmdAddExpert,
+  "list-experts": cmdListExperts,
   "check-status": cmdCheckStatus,
-  watch: cmdWatch,
   keygen: cmdKeygen,
 };