@heysummon/consumer-sdk 0.1.1 → 0.2.7

package/dist/cli.js

@@ -3,19 +3,17 @@
  * 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 { execSync } from "node:child_process";
+import { ExpertStore } from "./expert-store.js";
+import { generateEphemeralKeys, generatePersistentKeys } from "./crypto.js";
 import { existsSync } from "node:fs";
 // ---------------------------------------------------------------------------
 // Arg parsing helpers
@@ -40,148 +38,33 @@ function optEnv(name, fallback) {
 // ---------------------------------------------------------------------------
 // Commands
 // ---------------------------------------------------------------------------
-async function cmdSubmit(args) {
-    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;
-    let encryptPublicKey;
-    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 = [];
-    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, flag) {
+    return args.includes(flag);
 }
 async function cmdSubmitAndPoll(args) {
     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);
             }
         }
@@ -189,15 +72,14 @@ async function cmdSubmitAndPoll(args) {
             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 });
     process.stderr.write("HeySummon: Submitting request to human...\n");
@@ -211,25 +93,48 @@ async function cmdSubmitAndPoll(args) {
             // ignore
         }
     }
-    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 = {};
+            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) {
         process.stderr.write(`Failed to submit request: ${JSON.stringify(result)}\n`);
         process.exit(1);
     }
     const ref = result.refCode || result.requestId;
-    process.stderr.write(`Request submitted [${ref}] — waiting for human response...\n`);
+    // 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`);
     process.stderr.write(`   (timeout: ${timeout}s, polling every ${pollInterval}s)\n`);
     // Polling loop
     let elapsed = 0;
@@ -239,6 +144,14 @@ async function cmdSubmitAndPoll(args) {
         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) {
                 process.stderr.write(`\nHuman responded [${ref}]\n`);
@@ -247,15 +160,15 @@ async function cmdSubmitAndPoll(args) {
             }
             // Fallback: check messages for plaintext replies
             const { messages: msgs } = await client.getMessages(result.requestId);
-            const providerMsg = msgs.filter((m) => m.from === "provider").pop();
-            if (providerMsg) {
-                if (providerMsg.plaintext) {
+            const expertMsg = msgs.filter((m) => 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(() => { });
@@ -271,20 +184,22 @@ async function cmdSubmitAndPoll(args) {
             process.stderr.write(`   Still waiting... (${elapsed}s elapsed)\n`);
         }
     }
-    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`);
+    process.stdout.write(`TIMEOUT: No answer came back from the expert within the ${timeout}s timeout window. Request ref: ${ref}\n`);
 }
-async function cmdAddProvider(args) {
+async function cmdAddExpert(args) {
     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_")) {
@@ -292,44 +207,44 @@ async function cmdAddProvider(args) {
         process.exit(1);
     }
     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 || "";
-    if (!providerName) {
-        process.stderr.write("Could not fetch provider info. Is the key valid?\n");
+    const expertName = whoami.expert?.name || "";
+    const expertId = whoami.expert?.id || "";
+    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() {
-    const providersFile = optEnv("HEYSUMMON_PROVIDERS_FILE", "");
-    if (!providersFile || !existsSync(providersFile)) {
-        process.stdout.write("No providers registered yet.\n");
+async function cmdListExperts() {
+    const expertsFile = optEnv("HEYSUMMON_EXPERTS_FILE", "");
+    if (!expertsFile || !existsSync(expertsFile)) {
+        process.stdout.write("No experts registered yet.\n");
         return;
     }
-    const store = new ProviderStore(providersFile);
-    const providers = store.load();
-    if (providers.length === 0) {
-        process.stdout.write("No providers registered yet.\n");
+    const store = new ExpertStore(expertsFile);
+    const experts = store.load();
+    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];
-        const nameExtra = p.providerName !== p.name ? ` (provider: ${p.providerName})` : "";
-        process.stdout.write(`  ${i + 1}. ${p.name}${nameExtra} — key: ${p.apiKey.slice(0, 12)}...\n`);
+    process.stdout.write(`Registered experts (${experts.length}):\n`);
+    for (let i = 0; i < experts.length; i++) {
+        const p = experts[i];
+        const nameExtra = p.expertName !== p.name ? ` (expert: ${p.expertName})` : "";
+        process.stdout.write(`  ${i + 1}. ${p.name}${nameExtra} -- key: ${p.apiKey.slice(0, 12)}...\n`);
     }
 }
 async function cmdCheckStatus(args) {
@@ -344,14 +259,14 @@ async function cmdCheckStatus(args) {
     try {
         const data = await client.getRequestStatus(ref);
         const icons = {
-            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) {
@@ -363,192 +278,6 @@ async function cmdCheckStatus(args) {
         process.exit(1);
     }
 }
-async function cmdWatch(args) {
-    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();
-    // Track persistent auth errors per provider — auto-shutdown after 30 min
-    const AUTH_SHUTDOWN_MS = 30 * 60 * 1000; // 30 minutes
-    const authErrors = new Map();
-    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) => 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) {
     const dir = getArg(args, "--dir") || optEnv("HEYSUMMON_KEY_DIR", "");
     if (!dir) {
@@ -570,12 +299,10 @@ function sleep(ms) {
 // ---------------------------------------------------------------------------
 const [command, ...rest] = process.argv.slice(2);
 const commands = {
-    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,
 };
 if (!command || !commands[command]) {