@delegance/cli 0.2.0

package/dist/index.js

@@ -0,0 +1,4373 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CLI_VERSION: () => CLI_VERSION,
+  clearConfig: () => clearConfig,
+  clearCredentials: () => clearCredentials,
+  createAppetiteCommand: () => createAppetiteCommand,
+  createAuthCommand: () => createAuthCommand,
+  createCOICommand: () => createCOICommand,
+  createChatCommand: () => createChatCommand,
+  createCompanyCommand: () => createCompanyCommand,
+  createConfigCommand: () => createConfigCommand,
+  createDocumentCommand: () => createDocumentCommand,
+  createKeysCommand: () => createKeysCommand,
+  createKnowledgeCommand: () => createKnowledgeCommand,
+  createLeadCommand: () => createLeadCommand,
+  createOnboardingCommand: () => createOnboardingCommand,
+  createPolicyCommand: () => createPolicyCommand,
+  createProgram: () => createProgram,
+  createQuoteCommand: () => createQuoteCommand,
+  createSOVCommand: () => createSOVCommand,
+  createUsageCommand: () => createUsageCommand,
+  getAllConfig: () => getAllConfig,
+  getApiKey: () => getApiKey,
+  getBaseUrl: () => getBaseUrl,
+  getConfig: () => getConfig,
+  getConfigPath: () => getConfigPath,
+  isAuthenticated: () => isAuthenticated,
+  maskApiKey: () => maskApiKey,
+  output: () => output_exports,
+  setConfig: () => setConfig,
+  storeApiKey: () => storeApiKey
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/commands/auth.ts
+var os4 = __toESM(require("os"));
+var import_commander2 = require("commander");
+var import_inquirer2 = __toESM(require("inquirer"));
+var import_ora2 = __toESM(require("ora"));
+var import_sdk3 = require("@delegance/sdk");
+
+// src/utils/config.ts
+var import_conf = __toESM(require("conf"));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+
+// src/version.ts
+var CLI_VERSION = "0.2.0";
+
+// src/utils/config.ts
+var CONFIG_DIR = path.join(os.homedir(), ".delegance");
+var CREDENTIALS_FILE = path.join(CONFIG_DIR, "credentials");
+var API_KEY_REGEX = /^dlg_[a-zA-Z0-9]{8}_sk_[a-zA-Z0-9]{32}$/;
+var DEFAULT_BASE_URL = "https://portal.delegancebrokerage.com";
+var config = new import_conf.default({
+  projectName: "delegance",
+  projectVersion: CLI_VERSION,
+  // Owner-only, even though the key no longer lives here.
+  configFileMode: 384,
+  defaults: {
+    baseUrl: DEFAULT_BASE_URL,
+    outputFormat: "table"
+  }
+});
+function getConfig() {
+  return config;
+}
+function getConfigValue(key) {
+  return config.get(key);
+}
+function setConfig(key, value) {
+  config.set(key, value);
+}
+function getAllConfig() {
+  return config.store;
+}
+function clearConfig() {
+  config.clear();
+}
+function getConfigPath() {
+  return config.path;
+}
+function getCredentialsPath() {
+  return CREDENTIALS_FILE;
+}
+function writeCredentialsFile(apiKey) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  try {
+    fs.chmodSync(CONFIG_DIR, 448);
+  } catch {
+  }
+  try {
+    if (fs.lstatSync(CREDENTIALS_FILE).isSymbolicLink()) {
+      throw new Error(`${CREDENTIALS_FILE} is a symlink; refusing to write the API key there`);
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const tmp = `${CREDENTIALS_FILE}.${process.pid}.${Date.now()}.tmp`;
+  const fd = fs.openSync(tmp, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 384);
+  try {
+    fs.writeSync(fd, apiKey);
+  } finally {
+    fs.closeSync(fd);
+  }
+  fs.renameSync(tmp, CREDENTIALS_FILE);
+}
+function readCredentialsFile() {
+  try {
+    const key = fs.readFileSync(CREDENTIALS_FILE, "utf-8").trim();
+    return key || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function storeApiKey(apiKey, meta = {}) {
+  writeCredentialsFile(apiKey);
+  config.delete("apiKey");
+  config.set("apiKeyHint", maskApiKey(apiKey));
+  if (meta.expiresAt) config.set("apiKeyExpiresAt", meta.expiresAt);
+  else config.delete("apiKeyExpiresAt");
+}
+function setStoredKeyExpiry(expiresAt) {
+  if (expiresAt) config.set("apiKeyExpiresAt", expiresAt);
+  else config.delete("apiKeyExpiresAt");
+}
+function migrateLegacyConfigKey(log = (l) => process.stderr.write(`${l}
+`)) {
+  try {
+    if (fs.existsSync(CREDENTIALS_FILE) && (fs.statSync(CREDENTIALS_FILE).mode & 63) !== 0) {
+      fs.chmodSync(CREDENTIALS_FILE, 384);
+    }
+  } catch {
+  }
+  const legacy = config.get("apiKey");
+  if (typeof legacy !== "string" || !legacy) return "none";
+  if (!API_KEY_REGEX.test(legacy.trim())) {
+    config.delete("apiKey");
+    return "none";
+  }
+  const existing = readCredentialsFile();
+  if (existing) {
+    config.delete("apiKey");
+    config.set("apiKeyHint", maskApiKey(existing));
+    log(`Removed a plaintext copy of your API key from ${config.path}; the key in ${CREDENTIALS_FILE} is unchanged.`);
+    return "dropped_duplicate";
+  }
+  try {
+    writeCredentialsFile(legacy.trim());
+  } catch (err) {
+    log(`Your API key is still stored in ${config.path}. Could not move it to ${CREDENTIALS_FILE}: ${err.message}`);
+    return "failed";
+  }
+  config.delete("apiKey");
+  config.set("apiKeyHint", maskApiKey(legacy.trim()));
+  log(`Moved your API key from ${config.path} into ${CREDENTIALS_FILE} (readable only by you).`);
+  return "moved";
+}
+function getApiKey() {
+  if (process.env.DELEGANCE_API_KEY) {
+    return process.env.DELEGANCE_API_KEY;
+  }
+  const stored = readCredentialsFile();
+  if (stored) return stored;
+  const legacy = config.get("apiKey");
+  return typeof legacy === "string" && API_KEY_REGEX.test(legacy.trim()) ? legacy.trim() : void 0;
+}
+function isAuthenticated() {
+  return !!getApiKey();
+}
+function clearCredentials() {
+  config.delete("apiKey");
+  config.delete("apiKeyHint");
+  config.delete("apiKeyExpiresAt");
+  if (fs.existsSync(CREDENTIALS_FILE)) {
+    fs.unlinkSync(CREDENTIALS_FILE);
+  }
+}
+function getBaseUrl() {
+  return process.env.DELEGANCE_BASE_URL || config.get("baseUrl") || DEFAULT_BASE_URL;
+}
+function maskApiKey(apiKey) {
+  if (!apiKey || apiKey.length < 20) {
+    return "***";
+  }
+  const prefix = apiKey.substring(0, 12);
+  const suffix = apiKey.substring(apiKey.length - 4);
+  return `${prefix}...${suffix}`;
+}
+
+// src/utils/client.ts
+var import_sdk = require("@delegance/sdk");
+
+// src/utils/output.ts
+var output_exports = {};
+__export(output_exports, {
+  debug: () => debug,
+  error: () => error,
+  formatCurrency: () => formatCurrency,
+  formatDate: () => formatDate,
+  formatFileSize: () => formatFileSize,
+  formatStatus: () => formatStatus,
+  header: () => header,
+  info: () => info,
+  json: () => json,
+  keyValue: () => keyValue,
+  output: () => output,
+  success: () => success,
+  table: () => table,
+  warn: () => warn
+});
+var import_chalk = __toESM(require("chalk"));
+var import_cli_table3 = __toESM(require("cli-table3"));
+var import_figures = __toESM(require("figures"));
+function success(message) {
+  console.log(import_chalk.default.green(`${import_figures.default.tick} ${message}`));
+}
+function error(message, details) {
+  console.error(import_chalk.default.red(`${import_figures.default.cross} ${message}`));
+  if (details) {
+    console.error(import_chalk.default.gray(`  ${details}`));
+  }
+}
+function warn(message) {
+  console.log(import_chalk.default.yellow(`${import_figures.default.warning} ${message}`));
+}
+function info(message) {
+  console.log(import_chalk.default.blue(`${import_figures.default.info} ${message}`));
+}
+function debug(message) {
+  if (process.env.DEBUG || process.env.VERBOSE) {
+    console.log(import_chalk.default.gray(`${import_figures.default.pointer} ${message}`));
+  }
+}
+function header(text) {
+  console.log();
+  console.log(import_chalk.default.bold.cyan(text));
+  console.log(import_chalk.default.gray("\u2500".repeat(text.length)));
+}
+function keyValue(keyOrData, value) {
+  if (typeof keyOrData === "string") {
+    console.log(`  ${import_chalk.default.gray(keyOrData.padEnd(15))}  ${formatValue(value)}`);
+  } else {
+    const data = keyOrData;
+    const maxKeyLength = Math.max(...Object.keys(data).map((k) => k.length));
+    for (const [key, val] of Object.entries(data)) {
+      const paddedKey = key.padEnd(maxKeyLength);
+      console.log(`  ${import_chalk.default.gray(paddedKey)}  ${formatValue(val)}`);
+    }
+  }
+}
+function formatValue(value) {
+  if (value === null || value === void 0) {
+    return import_chalk.default.gray("(none)");
+  }
+  if (typeof value === "boolean") {
+    return value ? import_chalk.default.green("yes") : import_chalk.default.red("no");
+  }
+  if (typeof value === "number") {
+    return import_chalk.default.yellow(String(value));
+  }
+  if (value instanceof Date) {
+    return import_chalk.default.cyan(value.toISOString());
+  }
+  if (Array.isArray(value)) {
+    return import_chalk.default.cyan(value.join(", "));
+  }
+  return String(value);
+}
+function table(headers, rows, options = {}) {
+  const tbl = new import_cli_table3.default({
+    head: headers.map((h) => import_chalk.default.bold(h)),
+    style: {
+      head: ["cyan"],
+      compact: options.compact
+    }
+  });
+  for (const row of rows) {
+    tbl.push(row.map((cell) => formatValue(cell)));
+  }
+  console.log(tbl.toString());
+}
+function json(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function output(data, format = "table") {
+  if (format === "json") {
+    json(data);
+    return;
+  }
+  if (Array.isArray(data) && data.length > 0) {
+    const headers = Object.keys(data[0]);
+    const rows = data.map((item) => headers.map((h) => item[h]));
+    table(headers, rows);
+  } else if (typeof data === "object" && data !== null) {
+    keyValue(data);
+  } else {
+    console.log(data);
+  }
+}
+function formatDate(dateStr) {
+  if (!dateStr) return import_chalk.default.gray("(none)");
+  const date = new Date(dateStr);
+  return date.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+function formatFileSize(bytes) {
+  if (bytes === void 0) return import_chalk.default.gray("(unknown)");
+  const units = ["B", "KB", "MB", "GB"];
+  let size = bytes;
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  return `${size.toFixed(1)} ${units[unitIndex]}`;
+}
+function formatStatus(status) {
+  switch (status) {
+    case "completed":
+    case "processed":
+      return import_chalk.default.green(status);
+    case "pending":
+      return import_chalk.default.yellow(status);
+    case "processing":
+      return import_chalk.default.blue(status);
+    case "error":
+    case "failed":
+      return import_chalk.default.red(status);
+    default:
+      return status;
+  }
+}
+function formatCurrency(amount) {
+  if (amount === void 0 || amount === null) return import_chalk.default.gray("(none)");
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD",
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0
+  }).format(amount);
+}
+
+// src/utils/last-command.ts
+var fs2 = __toESM(require("fs"));
+var os2 = __toESM(require("os"));
+var path2 = __toESM(require("path"));
+var COMMAND_RE = /^[a-z][a-z0-9-]*(?: [a-z][a-z0-9-]*){0,3}$/;
+var TRACE_RE = /^[0-9a-fA-F-]{8,64}$/;
+var ISO_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+function lastCommandPath() {
+  return path2.join(os2.homedir(), ".delegance", "last-command.json");
+}
+function sanitizeLastCommand(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const r = raw;
+  if (typeof r.command !== "string" || r.command.length > 60 || !COMMAND_RE.test(r.command)) return null;
+  if (typeof r.exitCode !== "number" || !Number.isInteger(r.exitCode) || r.exitCode < -1 || r.exitCode > 255) return null;
+  if (typeof r.at !== "string" || !ISO_RE.test(r.at)) return null;
+  const out = { command: r.command, exitCode: r.exitCode, at: r.at };
+  if (typeof r.traceId === "string" && TRACE_RE.test(r.traceId)) out.traceId = r.traceId;
+  return out;
+}
+function readLastCommand() {
+  try {
+    return sanitizeLastCommand(JSON.parse(fs2.readFileSync(lastCommandPath(), "utf8")));
+  } catch {
+    return null;
+  }
+}
+var current = null;
+function noteTraceId(traceId) {
+  if (current && typeof traceId === "string" && TRACE_RE.test(traceId)) current.traceId = traceId;
+}
+
+// src/utils/client.ts
+var PORTAL_URL = "https://portal.delegancebrokerage.com";
+function getClient() {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    error("Not authenticated");
+    info('New to Delegance? Run "delegance signup" to create an account.');
+    info('Have an API key? Run "delegance auth login", or set DELEGANCE_API_KEY.');
+    process.exit(1);
+  }
+  return new import_sdk.DeleganceClient({
+    apiKey,
+    baseUrl: getBaseUrl()
+  });
+}
+function getCompanyId(options) {
+  const companyId = options.company || getConfigValue("defaultCompanyId");
+  if (!companyId) {
+    error("No company specified");
+    info('Use --company <id> or set a default with "delegance company use <id>"');
+    process.exit(1);
+  }
+  return companyId;
+}
+function describeApiError(err) {
+  const traceSuffix = err instanceof import_sdk.DeleganceError && err.traceId ? ` (trace ${err.traceId})` : "";
+  if (err instanceof import_sdk.NotImplementedError) {
+    return { message: `${err.message}${traceSuffix}`, hint: `This is not available over the API yet. Use the portal: ${PORTAL_URL}` };
+  }
+  if (err instanceof import_sdk.AuthenticationError) {
+    if (err.reason === "key_expired" || err.reason === "key_membership_revoked") {
+      return { message: `${err.message}${traceSuffix}`, hint: 'Run "delegance auth login" to sign in again.' };
+    }
+    return { message: `${err.message}${traceSuffix}`, hint: 'Check your key with "delegance auth status", or log in again.' };
+  }
+  if (err instanceof import_sdk.ForbiddenError) {
+    return { message: `${err.message}${traceSuffix}`, hint: "Your API key lacks the scope for this command. Create a key with the right scope in the portal." };
+  }
+  if (err instanceof import_sdk.RateLimitError) {
+    const wait = err.retryAfter ? ` Retry in ${err.retryAfter}s.` : "";
+    return { message: `${err.message}${traceSuffix}`, hint: `Rate limited.${wait}` };
+  }
+  if (err instanceof import_sdk.NotFoundError) {
+    return { message: `${err.message}${traceSuffix}` };
+  }
+  if (err instanceof Error) {
+    return { message: `${err.message}${traceSuffix}` };
+  }
+  return { message: String(err) };
+}
+function failWith(label, err) {
+  if (err instanceof import_sdk.DeleganceError) noteTraceId(err.traceId);
+  const { message, hint } = describeApiError(err);
+  error(label, message);
+  if (hint) info(hint);
+  process.exit(1);
+}
+function positiveInt(value, flag) {
+  const n = Number(value);
+  if (!Number.isInteger(n) || n <= 0) {
+    error(`${flag} must be a positive whole number, got "${value}"`);
+    process.exit(1);
+  }
+  return n;
+}
+
+// src/utils/browser.ts
+var import_child_process = require("child_process");
+function openerFor(platform) {
+  if (platform === "darwin") return { cmd: "open", args: [] };
+  if (platform === "win32") return { cmd: "rundll32", args: ["url.dll,FileProtocolHandler"] };
+  return { cmd: "xdg-open", args: [] };
+}
+function openInBrowser(url, platform = process.platform) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return false;
+  const { cmd, args } = openerFor(platform);
+  try {
+    const child = (0, import_child_process.spawn)(cmd, [...args, parsed.toString()], { stdio: "ignore", detached: true });
+    child.on("error", () => void 0);
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/signup.ts
+var import_crypto = require("crypto");
+var import_commander = require("commander");
+var import_inquirer = __toESM(require("inquirer"));
+var import_ora = __toESM(require("ora"));
+var import_sdk2 = require("@delegance/sdk");
+
+// src/utils/pending-signup.ts
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var os3 = __toESM(require("os"));
+function pendingSignupPath(home = os3.homedir()) {
+  return path3.join(home, ".delegance", "pending-signup.json");
+}
+function savePendingSignup(p, home) {
+  const file = pendingSignupPath(home);
+  fs3.mkdirSync(path3.dirname(file), { recursive: true, mode: 448 });
+  try {
+    if (fs3.lstatSync(file).isSymbolicLink()) throw new Error(`${file} is a symlink; refusing to write the signup secret there`);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  const fd = fs3.openSync(tmp, fs3.constants.O_WRONLY | fs3.constants.O_CREAT | fs3.constants.O_EXCL, 384);
+  try {
+    fs3.writeSync(fd, JSON.stringify(p, null, 2));
+  } finally {
+    fs3.closeSync(fd);
+  }
+  fs3.renameSync(tmp, file);
+}
+function loadPendingSignup(home) {
+  try {
+    const parsed = JSON.parse(fs3.readFileSync(pendingSignupPath(home), "utf8"));
+    return parsed && typeof parsed.enrollmentId === "string" && typeof parsed.deviceSecret === "string" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function clearPendingSignup(home) {
+  try {
+    fs3.unlinkSync(pendingSignupPath(home));
+  } catch {
+  }
+}
+
+// src/commands/signup.ts
+var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var COMPANY_SIZES = ["0", "1", "2-10", "11-25", "26-50", "51-100", "100-499", "500+"];
+var REQUIRED_FLAGS = [
+  ["email", "--email"],
+  ["business", "--business"],
+  ["first", "--first"],
+  ["last", "--last"],
+  ["industry", "--industry"],
+  ["size", "--size"],
+  ["street", "--street"],
+  ["city", "--city"],
+  ["state", "--state"],
+  ["zip", "--zip"]
+];
+function missingSignupFields(options) {
+  return REQUIRED_FLAGS.filter(([k]) => !String(options[k] ?? "").trim()).map(([, flag]) => flag);
+}
+function addressProblem(a) {
+  if (!a.street.trim() || !a.city.trim()) return "Street and city are required.";
+  if (!/^[A-Za-z]{2}$/.test(a.state.trim())) return "State must be the 2-letter code, e.g. TX.";
+  if (!/^\d{5}(-\d{4})?$/.test(a.zip.trim())) return "ZIP must be 5 digits (or ZIP+4).";
+  return null;
+}
+function exchangeRefusal(err) {
+  if (!(err instanceof import_sdk2.DeleganceError)) return null;
+  switch (err.reason) {
+    case "account_exists":
+      return `This email already has a Delegance account, so signup did not attach it to a new one. Sign in and create a key at ${PORTAL_URL}/portal/settings/api-keys`;
+    case "already_collected":
+      return `The key for this signup was already collected. If you lost it, create a new key at ${PORTAL_URL}/portal/settings/api-keys`;
+    case "expired":
+      return 'This signup expired (24 hours). Run "delegance signup" again.';
+    default:
+      return null;
+  }
+}
+async function ensureEnrolled(pending) {
+  if (pending.enrollmentId) return pending;
+  const signup = (0, import_sdk2.createSignup)({ baseUrl: pending.baseUrl });
+  const hash = (0, import_crypto.createHash)("sha256").update(pending.deviceSecret).digest("hex");
+  const enrollment = await signup.enroll(pending.bootstrapKey, {
+    deviceSecretHash: hash,
+    firstName: pending.firstName ?? "",
+    lastName: pending.lastName ?? ""
+  });
+  const next = { ...pending, enrollmentId: enrollment.enrollmentId, verificationSent: false };
+  savePendingSignup(next);
+  return sendVerification(next);
+}
+async function sendVerification(pending) {
+  await (0, import_sdk2.createSignup)({ baseUrl: pending.baseUrl }).requestVerification(pending.bootstrapKey);
+  const next = { ...pending, verificationSent: true };
+  savePendingSignup(next);
+  return next;
+}
+function storeOrPrintKey(apiKey, store = storeApiKey) {
+  try {
+    store(apiKey);
+    return true;
+  } catch (err) {
+    error(`Could not save the key to ~/.delegance/credentials: ${err.message}`);
+    warn('Your key is below. It is shown once. Save it now, then run "delegance auth login --key <key>".');
+    console.log(apiKey);
+    return false;
+  }
+}
+async function waitAndStore(pending, timeoutMs) {
+  const signup = (0, import_sdk2.createSignup)({ baseUrl: pending.baseUrl });
+  const spinner = (0, import_ora.default)(`Waiting for you to click the link sent to ${pending.email} (Ctrl-C is safe: resume with "delegance verify")`).start();
+  const started = Date.now();
+  try {
+    const result = await signup.waitForKey(pending.enrollmentId, pending.deviceSecret, {
+      timeoutMs,
+      intervalMs: 5e3,
+      onPoll: () => {
+        spinner.text = `Waiting for the email confirmation (${Math.round((Date.now() - started) / 1e3)}s). Check ${pending.email}.`;
+      }
+    });
+    if (result.status !== "ready") {
+      spinner.warn("Still waiting on the email confirmation.");
+      info('Run "delegance verify" after you click the link.');
+      return;
+    }
+    spinner.stop();
+    const stored = storeOrPrintKey(result.apiKey);
+    setConfig("defaultCompanyId", result.companyId);
+    clearPendingSignup();
+    if (stored) success(`Verified. API key ${maskApiKey(result.apiKey)} saved to ~/.delegance/credentials`);
+    success("You can quote now: delegance quote start --coverage gl");
+  } catch (err) {
+    spinner.stop();
+    const why = exchangeRefusal(err);
+    if (why) {
+      if (err.reason !== "already_collected") clearPendingSignup();
+      error(why);
+      process.exit(1);
+    }
+    failWith("Could not collect the key", err);
+  }
+}
+function signupPrompts(options, interactive) {
+  if (!interactive) return [];
+  const all = [
+    { type: "input", name: "email", message: "Work email:", when: !options.email, validate: (v) => EMAIL_RE.test(v) || "Enter an email address" },
+    { type: "input", name: "business", message: "Business name:", when: !options.business, validate: (v) => !!v.trim() || "Required" },
+    { type: "input", name: "first", message: "Your first name:", when: !options.first, validate: (v) => !!v.trim() || "Required" },
+    { type: "input", name: "last", message: "Your last name:", when: !options.last, validate: (v) => !!v.trim() || "Required" },
+    { type: "input", name: "industry", message: "What does the business do?", when: !options.industry, validate: (v) => !!v.trim() || "Required" },
+    { type: "list", name: "size", message: "Employees:", choices: COMPANY_SIZES, when: !options.size },
+    { type: "input", name: "street", message: "Business street address:", when: !options.street, validate: (v) => !!v.trim() || "Required" },
+    { type: "input", name: "city", message: "City:", when: !options.city, validate: (v) => !!v.trim() || "Required" },
+    { type: "input", name: "state", message: "State (2 letters):", when: !options.state, validate: (v) => /^[A-Za-z]{2}$/.test(v.trim()) || "Use the 2-letter code, e.g. TX" },
+    { type: "input", name: "zip", message: "ZIP:", when: !options.zip, validate: (v) => /^\d{5}(-\d{4})?$/.test(v.trim()) || "5 digits" },
+    { type: "input", name: "description", message: "In a sentence, what does the business do? (optional)", when: !options.description }
+  ];
+  return all.filter((q) => q.when !== false).map(({ when: _when, ...q }) => q);
+}
+function createSignupCommand() {
+  return new import_commander.Command("signup").description("Create a Delegance account and get an API key, from the terminal").option("-e, --email <email>", "Your work email (the confirm link goes here)").option("-b, --business <name>", "Business name").option("--first <name>", "Your first name").option("--last <name>", "Your last name").option("-i, --industry <industry>", 'What the business does, e.g. "commercial bakery"').option("--size <size>", `Employees: ${COMPANY_SIZES.join(", ")}`).option("-w, --website <url>", "Website (full URL)").option("--street <street>", "Business street address").option("--city <city>", "City").option("--state <state>", "State, 2-letter code (carriers quote by state)").option("--zip <zip>", "ZIP code").option("-d, --description <text>", "A sentence on what the business does (helps carriers classify it)").option("--timeout <minutes>", "How long to wait for the email click", "15").option("--no-wait", 'Send the email and exit; collect later with "delegance verify"').action(async (options) => {
+    const existing = loadPendingSignup();
+    if (existing) {
+      warn(`A signup for ${existing.email} is already waiting for its email confirmation.`);
+      info('Run "delegance verify" to finish it, or "delegance verify --cancel" to start over.');
+      process.exit(1);
+    }
+    if (!(process.stdin.isTTY && process.stdout.isTTY)) {
+      const missing = missingSignupFields(options);
+      if (missing.length) {
+        error(`No terminal to ask in. Missing: ${missing.join(" ")}`);
+        process.exit(1);
+      }
+    }
+    const answers = await import_inquirer.default.prompt(signupPrompts(options, Boolean(process.stdin.isTTY && process.stdout.isTTY)));
+    const address = {
+      street: String(options.street ?? answers.street).trim(),
+      city: String(options.city ?? answers.city).trim(),
+      state: String(options.state ?? answers.state).trim().toUpperCase(),
+      zip: String(options.zip ?? answers.zip).trim()
+    };
+    const badAddress = addressProblem(address);
+    if (badAddress) {
+      error(badAddress);
+      process.exit(1);
+    }
+    const description = String(options.description ?? answers.description ?? "").trim();
+    const email = String(options.email ?? answers.email).trim().toLowerCase();
+    if (!EMAIL_RE.test(email)) {
+      error("Enter a valid email with --email");
+      process.exit(1);
+    }
+    const size = String(options.size ?? answers.size);
+    if (!COMPANY_SIZES.includes(size)) {
+      error(`--size must be one of: ${COMPANY_SIZES.join(", ")}`);
+      process.exit(1);
+    }
+    const baseUrl = getBaseUrl();
+    const signup = (0, import_sdk2.createSignup)({ baseUrl });
+    const spinner = (0, import_ora.default)("Creating your account...").start();
+    try {
+      const account = await signup.createAccount({
+        name: String(options.business ?? answers.business).trim(),
+        contactEmail: email,
+        industry: String(options.industry ?? answers.industry).trim(),
+        companySize: size,
+        address,
+        ...description ? { description } : {},
+        ...options.website ? { website: options.website } : {}
+      });
+      const device = (0, import_sdk2.newDeviceSecret)();
+      let pending = {
+        enrollmentId: "",
+        deviceSecret: device.secret,
+        bootstrapKey: account.bootstrapKey,
+        companyId: account.companyId,
+        email,
+        firstName: String(options.first ?? answers.first).trim(),
+        lastName: String(options.last ?? answers.last).trim(),
+        baseUrl,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      savePendingSignup(pending);
+      pending = await ensureEnrolled(pending);
+      spinner.succeed(`Account created. We emailed a confirm link to ${email}.`);
+      if (account.warnings?.includes("address_not_saved")) {
+        warn("We could not save your business address. Add it in the portal before quoting, or carriers cannot price you.");
+      }
+      if (options.wait === false) {
+        info('After you click it, run "delegance verify" to collect your API key.');
+        return;
+      }
+      await waitAndStore(pending, Number(options.timeout) * 6e4 || 15 * 6e4);
+    } catch (err) {
+      spinner.stop();
+      failWith("Signup failed", err);
+    }
+  });
+}
+function resendFailureMessage(err) {
+  if (err instanceof import_sdk2.DeleganceError && (err.statusCode === 401 || err.statusCode === 403)) {
+    return "Your email is already confirmed, so there is nothing to re-send. Collecting your key now.";
+  }
+  const why = err instanceof Error ? err.message : String(err);
+  return `Could not re-send the email (${why}). Still waiting for the link you already have.`;
+}
+function createVerifyCommand() {
+  return new import_commander.Command("verify").description("Finish a signup: wait for the email click and store your API key").option("--resend", "Send the confirm email again").option("--cancel", "Forget the in-progress signup on this machine").option("--timeout <minutes>", "How long to wait", "15").action(async (options) => {
+    const pending = loadPendingSignup();
+    if (!pending) {
+      info('No signup is waiting on this machine. Start one with "delegance signup".');
+      return;
+    }
+    if (options.cancel) {
+      clearPendingSignup();
+      success(`Forgot the signup for ${pending.email}.`);
+      return;
+    }
+    let resumed = pending;
+    if (pending.enrollmentId && pending.verificationSent === false) {
+      try {
+        resumed = await sendVerification(pending);
+        success(`Sent the confirm link to ${pending.email}.`);
+      } catch (err) {
+        failWith("Could not send the confirm email", err);
+      }
+    } else if (!pending.enrollmentId) {
+      try {
+        resumed = await ensureEnrolled(pending);
+        success(`Finished setting up the signup. We emailed a confirm link to ${pending.email}.`);
+      } catch (err) {
+        failWith("Could not finish the signup", err);
+      }
+    }
+    if (options.resend && resumed === pending) {
+      try {
+        await (0, import_sdk2.createSignup)({ baseUrl: pending.baseUrl }).requestVerification(pending.bootstrapKey);
+        success(`Sent the confirm link to ${pending.email} again.`);
+      } catch (err) {
+        info(resendFailureMessage(err));
+      }
+    }
+    await waitAndStore(resumed, Number(options.timeout) * 6e4 || 15 * 6e4);
+  });
+}
+
+// src/commands/auth.ts
+var KEY_FORMAT_HINT = "Expected format: dlg_xxxxxxxx_sk_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
+function defaultDeviceName() {
+  let user = "";
+  try {
+    user = os4.userInfo().username;
+  } catch {
+  }
+  const host = os4.hostname() || "terminal";
+  return (user ? `${host} (${user})` : host).slice(0, 64);
+}
+function describeExpiry(expiresAt, now = /* @__PURE__ */ new Date()) {
+  if (!expiresAt) return "Never";
+  const at = Date.parse(expiresAt);
+  if (!Number.isFinite(at)) return "Unknown";
+  const date = new Date(at).toLocaleDateString("en-US", { year: "numeric", month: "short", day: "numeric" });
+  const days = Math.ceil((at - now.getTime()) / (24 * 60 * 60 * 1e3));
+  if (days <= 0) return `${date} (expired)`;
+  return `${date} (in ${days} day${days === 1 ? "" : "s"})`;
+}
+function deviceLoginRefusal(err) {
+  if (!(err instanceof import_sdk3.DeleganceError)) return null;
+  switch (err.reason) {
+    case "access_denied":
+      return "The request was denied in the portal. Nothing was stored.";
+    case "expired":
+      return 'The code expired before it was approved. Run "delegance auth login" again.';
+    case "already_collected":
+      return 'This login was already used. Run "delegance auth login" again.';
+    default:
+      return null;
+  }
+}
+function notAvailable(err) {
+  return err instanceof import_sdk3.DeleganceError && (err.statusCode === 404 || err.reason === "not_available");
+}
+function pasteFallbackHint() {
+  info(`Create a key at ${PORTAL_URL}/portal/settings/api-keys, then run "delegance auth login --key <key>".`);
+}
+async function readKeyInfo(apiKey, timeoutMs = 5e3) {
+  try {
+    const client = new import_sdk3.DeleganceClient({ apiKey, baseUrl: getBaseUrl(), timeout: timeoutMs, retries: 0 });
+    return await client.auth.keyInfo();
+  } catch {
+    return null;
+  }
+}
+async function loginWithKey(apiKey, skipVerify) {
+  if (!API_KEY_REGEX.test(apiKey)) {
+    error("Invalid API key format");
+    info(KEY_FORMAT_HINT);
+    process.exit(1);
+  }
+  if (skipVerify) {
+    storeApiKey(apiKey);
+    success("API key stored (verification skipped)");
+    info(`API key stored in ${getCredentialsPath()}`);
+    warn("Key will be verified on first API call");
+    return;
+  }
+  const spinner = (0, import_ora2.default)("Verifying API key...").start();
+  try {
+    const client = new import_sdk3.DeleganceClient({ apiKey, baseUrl: getBaseUrl() });
+    const isValid = await client.verifyApiKey();
+    if (!isValid) {
+      spinner.fail("API key verification failed");
+      error("The API key is invalid or expired");
+      info("Use --skip-verify to store anyway");
+      process.exit(1);
+    }
+    const keyInfo = await readKeyInfo(apiKey);
+    storeApiKey(apiKey, { expiresAt: keyInfo?.expiresAt ?? null });
+    spinner.succeed("API key verified");
+    success("Successfully authenticated!");
+    info(`API key stored in ${getCredentialsPath()}`);
+  } catch (err) {
+    spinner.fail("Failed to verify API key");
+    error("Could not connect to Delegance API", err.message);
+    info("Use --skip-verify to store anyway, or check DELEGANCE_BASE_URL");
+    process.exit(1);
+  }
+}
+async function loginWithBrowser(openBrowser) {
+  const login = (0, import_sdk3.createDeviceLogin)({ baseUrl: getBaseUrl() });
+  const device = (0, import_sdk3.newDeviceSecret)();
+  let start;
+  try {
+    start = await login.start({ deviceSecretHash: device.hash, deviceName: defaultDeviceName() });
+  } catch (err) {
+    if (notAvailable(err)) {
+      error("Browser login is not available on this server yet.");
+      pasteFallbackHint();
+      process.exit(1);
+    }
+    failWith("Could not start the login", err);
+  }
+  console.log();
+  info("Approve this terminal in the Delegance portal:");
+  console.log(`  ${start.verificationUriComplete}`);
+  console.log();
+  info(`Check that the page shows this code: ${start.userCode}`);
+  info("If the portal asks you to sign in first, open the link again after you sign in.");
+  if (openBrowser && process.stdout.isTTY) openInBrowser(start.verificationUriComplete);
+  console.log();
+  const spinner = (0, import_ora2.default)("Waiting for approval in the portal (Ctrl-C to cancel)...").start();
+  try {
+    const expiresIn = Date.parse(start.expiresAt) - Date.now();
+    const result = await login.waitForKey(start.loginId, device.secret, {
+      // The code waits 10 minutes; an approval then waits 5 more for this poll.
+      timeoutMs: Math.max(6e4, (Number.isFinite(expiresIn) ? expiresIn : 6e5) + 6e4),
+      intervalMs: Math.max(1, start.interval || 5) * 1e3
+    });
+    if (result.status !== "ready") {
+      spinner.fail("The code expired before it was approved.");
+      info('Run "delegance auth login" again.');
+      process.exit(1);
+    }
+    spinner.stop();
+    const stored = storeOrPrintKey(result.apiKey, (k) => storeApiKey(k, { expiresAt: result.expiresAt }));
+    setConfig("defaultCompanyId", result.companyId);
+    if (stored) success(`Signed in. API key ${maskApiKey(result.apiKey)} saved to ${getCredentialsPath()}`);
+    keyValue({
+      Company: result.companyId,
+      Access: result.scopes.join(", ") || "read",
+      Expires: describeExpiry(result.expiresAt)
+    });
+    info("The key stays valid while you use it; 90 days without use and it expires.");
+  } catch (err) {
+    spinner.stop();
+    const why = deviceLoginRefusal(err);
+    if (why) {
+      error(why);
+      process.exit(1);
+    }
+    failWith("Login failed", err);
+  }
+}
+function createAuthCommand() {
+  const auth = new import_commander2.Command("auth").description("Manage authentication");
+  auth.command("login").description("Sign in: approve this terminal in the portal, or store an API key").option("-k, --key <apiKey>", "Store this API key instead of signing in with the browser").option("--paste", "Prompt for an API key instead of signing in with the browser").option("--no-browser", "Print the approval link without opening a browser").option("--skip-verify", "With --key or --paste: store without verification (useful when API is not reachable)").action(async (options) => {
+    try {
+      if (options.key) {
+        await loginWithKey(String(options.key).trim(), Boolean(options.skipVerify));
+        return;
+      }
+      if (options.paste) {
+        const answers = await import_inquirer2.default.prompt([
+          {
+            type: "password",
+            name: "apiKey",
+            message: "Enter your API key:",
+            mask: "*",
+            validate: (input) => {
+              if (!input) return "API key is required";
+              if (!API_KEY_REGEX.test(input)) return `Invalid API key format. ${KEY_FORMAT_HINT}`;
+              return true;
+            }
+          }
+        ]);
+        await loginWithKey(answers.apiKey, Boolean(options.skipVerify));
+        return;
+      }
+      await loginWithBrowser(options.browser !== false);
+    } catch (err) {
+      failWith("Authentication failed", err);
+    }
+  });
+  auth.command("status").description("Show the stored key, where it lives, and when it expires").action(async () => {
+    header("Authentication Status");
+    if (!isAuthenticated()) {
+      warn("Not authenticated");
+      info('Run "delegance auth login" to sign in, or "delegance signup" to create an account');
+      return;
+    }
+    const apiKey = getApiKey() || "";
+    const fromEnv = Boolean(process.env.DELEGANCE_API_KEY);
+    const cached = fromEnv ? void 0 : getConfigValue("apiKeyExpiresAt");
+    let expiryLine = cached ? `${describeExpiry(cached)} (last known)` : "Unknown (could not reach the server)";
+    let origin = null;
+    let refused = null;
+    try {
+      const client = new import_sdk3.DeleganceClient({ apiKey, baseUrl: getBaseUrl(), timeout: 5e3, retries: 0 });
+      const keyInfo = await client.auth.keyInfo();
+      origin = keyInfo.origin;
+      expiryLine = describeExpiry(keyInfo.expiresAt);
+      if (!fromEnv) setStoredKeyExpiry(keyInfo.expiresAt);
+    } catch (err) {
+      if (err instanceof import_sdk3.DeleganceError && err.statusCode === 401) {
+        refused = err.reason === "key_expired" ? "Your API key expired" : err.reason === "key_membership_revoked" ? "Your API key was revoked: its user is no longer an active member of the company" : "Your API key was rejected by the server";
+        expiryLine = err.reason === "key_expired" ? "Expired" : "Not valid";
+      }
+    }
+    if (refused) {
+      warn(refused);
+      info('Run "delegance auth login" to sign in again.');
+    } else {
+      success("Authenticated");
+    }
+    console.log();
+    keyValue({
+      "API Key": maskApiKey(apiKey),
+      "Source": fromEnv ? "DELEGANCE_API_KEY" : getCredentialsPath(),
+      ...origin ? { "Created by": origin === "cli_login" ? "browser login" : origin === "cli_signup" ? "CLI signup" : origin } : {},
+      "Expires": expiryLine,
+      "Base URL": getBaseUrl(),
+      "Config File": getConfigPath()
+    });
+  });
+  auth.command("refresh").description("Extend a CLI key to 90 days from now").action(async () => {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+      error("Not authenticated");
+      info('Run "delegance auth login" to sign in');
+      process.exit(1);
+    }
+    const spinner = (0, import_ora2.default)("Refreshing your key...").start();
+    try {
+      const client = new import_sdk3.DeleganceClient({ apiKey, baseUrl: getBaseUrl() });
+      const { expiresAt } = await client.auth.refresh();
+      if (!process.env.DELEGANCE_API_KEY) setStoredKeyExpiry(expiresAt);
+      spinner.succeed(`Key refreshed. Expires ${describeExpiry(expiresAt)}.`);
+    } catch (err) {
+      spinner.stop();
+      if (err instanceof import_sdk3.DeleganceError && err.reason === "not_refreshable") {
+        info("This key came from the portal and keeps the expiry it was created with. Nothing changed.");
+        return;
+      }
+      if (notAvailable(err)) {
+        error("Key refresh is not available on this server yet.");
+        process.exit(1);
+      }
+      failWith("Could not refresh the key", err);
+    }
+  });
+  auth.command("logout").description("Remove stored credentials").option("-f, --force", "Skip confirmation").action(async (options) => {
+    if (!isAuthenticated()) {
+      info("Not currently authenticated");
+      return;
+    }
+    if (!options.force) {
+      const { confirm } = await import_inquirer2.default.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: "Are you sure you want to remove your credentials?",
+          default: false
+        }
+      ]);
+      if (!confirm) {
+        info("Logout cancelled");
+        return;
+      }
+    }
+    clearCredentials();
+    success("Successfully logged out");
+    info("API key removed from local storage");
+  });
+  auth.command("whoami").description("Show current authenticated identity").action(async () => {
+    if (!isAuthenticated()) {
+      error("Not authenticated");
+      info('Run "delegance auth login" to authenticate');
+      process.exit(1);
+    }
+    const apiKey = getApiKey();
+    if (!apiKey) {
+      error("No API key found");
+      process.exit(1);
+    }
+    const spinner = (0, import_ora2.default)("Fetching account info...").start();
+    try {
+      const client = new import_sdk3.DeleganceClient({
+        apiKey,
+        baseUrl: getBaseUrl()
+      });
+      const companies = await client.companies.list();
+      spinner.succeed("Account info retrieved");
+      console.log();
+      if (companies.length > 0) {
+        const company = companies[0];
+        keyValue({
+          "Company": company.name,
+          "Company ID": company.id,
+          "Industry": company.industry,
+          "Contact": company.contactEmail,
+          "API Key": maskApiKey(apiKey)
+        });
+      } else {
+        warn("No company found for this API key");
+      }
+    } catch (err) {
+      spinner.fail("Failed to fetch account info");
+      failWith("API request failed", err);
+    }
+  });
+  return auth;
+}
+
+// src/commands/company.ts
+var import_commander3 = require("commander");
+var import_inquirer3 = __toESM(require("inquirer"));
+var import_ora3 = __toESM(require("ora"));
+function createCompanyCommand() {
+  const company = new import_commander3.Command("company").alias("companies").description("Manage companies");
+  company.command("list").description("List companies").option("--include-created", "Include companies created via this API key").option("--json", "Output as JSON").action(async (options) => {
+    const client = getClient();
+    const spinner = (0, import_ora3.default)("Fetching companies...").start();
+    try {
+      const companies = await client.companies.list({
+        includeCreated: options.includeCreated
+      });
+      spinner.succeed(`Found ${companies.length} companies`);
+      if (companies.length === 0) {
+        info("No companies found");
+        return;
+      }
+      if (options.json) {
+        json(companies);
+      } else {
+        console.log();
+        table(
+          ["ID", "Name", "Industry", "Size", "Created"],
+          companies.map((c) => [
+            `${c.id.substring(0, 8)}...`,
+            c.name,
+            c.industry,
+            c.companySize,
+            formatDate(c.createdAt)
+          ])
+        );
+      }
+    } catch (err) {
+      spinner.fail("Failed to list companies");
+      failWith("API error", err);
+    }
+  });
+  company.command("create").description("Create a new company").option("-n, --name <name>", "Company name").option("-i, --industry <industry>", "Industry").option("-s, --size <size>", "Company size (1, 2-10, 11-25, 26-50, 51-100, 100-499, 500+)").option("-e, --email <email>", "Contact email").option("--fein <fein>", "FEIN (XX-XXXXXXX)").option("--website <url>", "Website URL").option("--external-id <id>", "External ID for deduplication").option("--interactive", "Interactive mode with prompts").option("--json", "Output as JSON").action(async (options) => {
+    let companyData;
+    if (options.interactive || !options.name && !options.industry) {
+      const answers = await import_inquirer3.default.prompt([
+        {
+          type: "input",
+          name: "name",
+          message: "Company name:",
+          default: options.name,
+          validate: (input) => input.length > 0 || "Name is required"
+        },
+        {
+          type: "input",
+          name: "industry",
+          message: "Industry:",
+          default: options.industry,
+          validate: (input) => input.length > 0 || "Industry is required"
+        },
+        {
+          type: "list",
+          name: "companySize",
+          message: "Company size:",
+          choices: ["1", "2-10", "11-25", "26-50", "51-100", "100-499", "500+"],
+          default: options.size
+        },
+        {
+          type: "input",
+          name: "contactEmail",
+          message: "Contact email:",
+          default: options.email,
+          validate: (input) => {
+            if (!input) return "Email is required";
+            if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(input)) return "Invalid email format";
+            return true;
+          }
+        },
+        {
+          type: "input",
+          name: "fein",
+          message: "FEIN (XX-XXXXXXX, optional):",
+          default: options.fein
+        },
+        {
+          type: "input",
+          name: "website",
+          message: "Website (optional):",
+          default: options.website
+        }
+      ]);
+      companyData = {
+        name: answers.name,
+        industry: answers.industry,
+        companySize: answers.companySize,
+        contactEmail: answers.contactEmail,
+        fein: answers.fein || void 0,
+        website: answers.website || void 0,
+        externalId: options.externalId
+      };
+    } else {
+      if (!options.name || !options.industry || !options.size || !options.email) {
+        error("Missing required options");
+        info("Required: --name, --industry, --size, --email");
+        info("Or use --interactive for guided input");
+        process.exit(1);
+      }
+      companyData = {
+        name: options.name,
+        industry: options.industry,
+        companySize: options.size,
+        contactEmail: options.email,
+        fein: options.fein,
+        website: options.website,
+        externalId: options.externalId
+      };
+    }
+    const client = getClient();
+    const spinner = (0, import_ora3.default)("Creating company...").start();
+    try {
+      const company2 = await client.companies.create(companyData);
+      spinner.succeed("Company created");
+      if (options.json) {
+        json(company2);
+      } else {
+        console.log();
+        success(`Created company: ${company2.name}`);
+        keyValue({
+          "ID": company2.id,
+          "Name": company2.name,
+          "Industry": company2.industry,
+          "Size": company2.companySize,
+          "Contact": company2.contactEmail,
+          "Created": formatDate(company2.createdAt)
+        });
+      }
+    } catch (err) {
+      spinner.fail("Failed to create company");
+      failWith("API error", err);
+    }
+  });
+  company.command("use <companyId>").description("Set default company for subsequent commands").action(async (companyId) => {
+    const client = getClient();
+    const spinner = (0, import_ora3.default)("Verifying company...").start();
+    try {
+      const companies = await client.companies.list({ includeCreated: true });
+      const found = companies.find((c) => c.id === companyId || c.id.startsWith(companyId));
+      if (!found) {
+        spinner.fail("Company not found");
+        error(`No company found with ID starting with: ${companyId}`);
+        process.exit(1);
+      }
+      setConfig("defaultCompanyId", found.id);
+      spinner.succeed(`Default company set to: ${found.name}`);
+    } catch (err) {
+      spinner.fail("Failed to verify company");
+      failWith("API error", err);
+    }
+  });
+  company.command("current").description("Show current default company").action(async () => {
+    const companyId = getConfigValue("defaultCompanyId");
+    if (!companyId) {
+      info("No default company set");
+      info('Use "delegance company use <id>" to set one');
+      return;
+    }
+    const client = getClient();
+    const spinner = (0, import_ora3.default)("Fetching company details...").start();
+    try {
+      const companies = await client.companies.list({ includeCreated: true });
+      const company2 = companies.find((c) => c.id === companyId);
+      if (!company2) {
+        spinner.warn("Default company no longer accessible");
+        return;
+      }
+      spinner.succeed("Current default company");
+      console.log();
+      keyValue({
+        "ID": company2.id,
+        "Name": company2.name,
+        "Industry": company2.industry
+      });
+    } catch (err) {
+      spinner.fail("Failed to fetch company");
+      failWith("API error", err);
+    }
+  });
+  return company;
+}
+
+// src/commands/document.ts
+var import_commander4 = require("commander");
+var import_ora4 = __toESM(require("ora"));
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var import_glob = require("glob");
+function extractionOutcome(status) {
+  if (status === "completed" || status === "processed") return "done";
+  if (status === "error" || status === "failed") return "failed";
+  return "pending";
+}
+function createDocumentCommand() {
+  const doc = new import_commander4.Command("doc").alias("docs").alias("document").alias("documents").description("Manage documents");
+  doc.command("upload <files...>").description("Upload one or more documents").option("-c, --company <id>", "Company ID (or use default)").option("-t, --type <type>", "Document type (policy, loss_run, financial_statement, sov, application, certificate, endorsement, bor, other)").option("--external-id <id>", "External ID for reference").option("-w, --wait", "Wait for extraction to complete").option("--timeout <ms>", "Timeout for waiting (default: 120000)", "120000").option("--json", "Output as JSON").action(async (filePatterns, options) => {
+    const companyId = getCompanyId(options);
+    const client = getClient();
+    let files = [];
+    for (const pattern of filePatterns) {
+      if (pattern.includes("*")) {
+        const matches = await (0, import_glob.glob)(pattern);
+        files.push(...matches);
+      } else {
+        files.push(pattern);
+      }
+    }
+    files = files.filter((f) => {
+      if (!fs4.existsSync(f)) {
+        warn(`File not found: ${f}`);
+        return false;
+      }
+      if (fs4.statSync(f).isDirectory()) {
+        warn(`Skipping directory: ${f}`);
+        return false;
+      }
+      return true;
+    });
+    if (files.length === 0) {
+      error("No valid files to upload");
+      process.exit(1);
+    }
+    info(`Uploading ${files.length} file(s) to company ${companyId.substring(0, 8)}...`);
+    console.log();
+    const results = [];
+    for (const filePath of files) {
+      const fileName = path4.basename(filePath);
+      const spinner = (0, import_ora4.default)(`Uploading ${fileName}...`).start();
+      try {
+        const fileBuffer = fs4.readFileSync(filePath);
+        const document = await client.documents.upload({
+          companyId,
+          file: fileBuffer,
+          fileName,
+          documentType: options.type,
+          externalId: options.externalId
+        });
+        spinner.succeed(`Uploaded ${fileName} (${document.id.substring(0, 8)}...)`);
+        results.push({ file: fileName, docId: document.id, status: "uploaded" });
+        if (options.wait) {
+          const waitSpinner = (0, import_ora4.default)(`  Processing ${fileName}...`).start();
+          try {
+            const result = await client.documents.waitForExtraction(document.id, {
+              timeoutMs: parseInt(options.timeout),
+              onStatusChange: (status) => {
+                waitSpinner.text = `  Processing ${fileName}: ${status}`;
+              }
+            });
+            if (result.status === "completed" || result.status === "processed") {
+              waitSpinner.succeed(`  Processed ${fileName}: ${result.extraction?.policies.length || 0} policies found`);
+              results[results.length - 1].status = "completed";
+            } else {
+              waitSpinner.warn(`  Processing ${fileName}: ${result.status}`);
+              results[results.length - 1].status = result.status;
+            }
+          } catch (waitErr) {
+            waitSpinner.fail(`  Processing failed: ${waitErr.message}`);
+            results[results.length - 1].status = "error";
+            results[results.length - 1].error = waitErr.message;
+          }
+        }
+      } catch (err) {
+        spinner.fail(`Failed to upload ${fileName}`);
+        results.push({ file: fileName, status: "error", error: err.message });
+      }
+    }
+    console.log();
+    const successCount = results.filter((r) => r.status !== "error").length;
+    const errorCount = results.filter((r) => r.status === "error").length;
+    if (errorCount === 0) {
+      success(`Successfully uploaded ${successCount} file(s)`);
+    } else {
+      warn(`Uploaded ${successCount} file(s), ${errorCount} failed`);
+    }
+    if (options.json) {
+      json(results);
+    }
+  });
+  doc.command("list").description("List documents").option("-c, --company <id>", "Company ID (or use default)").option("-t, --type <type>", "Filter by document type").option("-s, --status <status>", "Filter by status").option("-l, --limit <n>", "Maximum results (default: 50)", "50").option("--json", "Output as JSON").action(async (options) => {
+    const companyId = getCompanyId(options);
+    const client = getClient();
+    const spinner = (0, import_ora4.default)("Fetching documents...").start();
+    try {
+      const { documents, pagination } = await client.documents.list({
+        companyId,
+        documentType: options.type,
+        status: options.status,
+        limit: parseInt(options.limit)
+      });
+      spinner.succeed(`Found ${pagination.total} documents`);
+      if (documents.length === 0) {
+        info("No documents found");
+        return;
+      }
+      if (options.json) {
+        json({ documents, pagination });
+      } else {
+        console.log();
+        table(
+          ["ID", "File Name", "Type", "Status", "Size", "Created"],
+          documents.map((d) => [
+            `${d.id.substring(0, 8)}...`,
+            d.fileName.length > 30 ? `${d.fileName.substring(0, 27)}...` : d.fileName,
+            d.documentType || "-",
+            formatStatus(d.status),
+            formatFileSize(d.fileSize),
+            formatDate(d.createdAt)
+          ])
+        );
+        if (pagination.hasMore) {
+          console.log();
+          info(`Showing ${documents.length} of ${pagination.total}. Use --limit to see more.`);
+        }
+      }
+    } catch (err) {
+      spinner.fail("Failed to list documents");
+      failWith("API error", err);
+    }
+  });
+  doc.command("status <documentId>").alias("get").description("Get document details and extraction status").option("--json", "Output as JSON").action(async (documentId, options) => {
+    const client = getClient();
+    const spinner = (0, import_ora4.default)("Fetching document...").start();
+    try {
+      const document = await client.documents.get(documentId);
+      spinner.succeed("Document retrieved");
+      if (options.json) {
+        json(document);
+      } else {
+        console.log();
+        header("Document Details");
+        keyValue({
+          "ID": document.id,
+          "File Name": document.fileName,
+          "Type": document.documentType || "(not classified)",
+          "Status": formatStatus(document.status),
+          "Size": formatFileSize(document.fileSize),
+          "Created": formatDate(document.createdAt),
+          "Updated": formatDate(document.updatedAt)
+        });
+        if (document.extraction) {
+          console.log();
+          header("Extraction Results");
+          keyValue({
+            "Has Text": document.extraction.hasText,
+            "Text Length": document.extraction.textLength,
+            "Policies Found": document.extraction.policies.length
+          });
+          if (document.extraction.policies.length > 0) {
+            console.log();
+            info("Extracted Policies:");
+            table(
+              ["ID", "Type", "Number", "Carrier", "Effective", "Expiration"],
+              document.extraction.policies.map((p) => [
+                `${p.id.substring(0, 8)}...`,
+                p.policyType,
+                p.policyNumber || "-",
+                p.carrierName || "-",
+                p.effectiveDate || "-",
+                p.expirationDate || "-"
+              ])
+            );
+          }
+        }
+        if (document.processing) {
+          console.log();
+          info(document.processing.message);
+        }
+        if (document.error) {
+          console.log();
+          error("Processing Error", document.error.message);
+        }
+      }
+    } catch (err) {
+      spinner.fail("Failed to get document");
+      failWith("API error", err);
+    }
+  });
+  doc.command("wait <documentId>").description("Wait for document processing to complete").option("--timeout <ms>", "Timeout in milliseconds (default: 120000)", "120000").option("--json", "Output as JSON").action(async (documentId, options) => {
+    const client = getClient();
+    const spinner = (0, import_ora4.default)("Waiting for processing...").start();
+    try {
+      const result = await client.documents.waitForExtraction(documentId, {
+        timeoutMs: parseInt(options.timeout),
+        onStatusChange: (status) => {
+          spinner.text = `Processing: ${status}`;
+        }
+      });
+      const outcome = extractionOutcome(result.status);
+      if (outcome === "done") {
+        spinner.succeed("Processing complete");
+        if (options.json) {
+          json(result);
+        } else {
+          info(`Found ${result.extraction?.policies.length || 0} policies`);
+        }
+      } else if (outcome === "failed") {
+        spinner.fail("Processing failed");
+        error(result.error?.message || "Unknown error");
+        process.exit(1);
+      } else {
+        spinner.warn(`Processing status: ${result.status}`);
+        info("Document is still being processed. Try again later.");
+      }
+    } catch (err) {
+      spinner.fail("Wait failed");
+      failWith("Error", err);
+    }
+  });
+  doc.command("reprocess <documentId>").description("Re-run extraction on a document (limited retries per day)").option("-w, --wait", "Wait for extraction to complete").option("--timeout <ms>", "Timeout for waiting (default: 120000)", "120000").option("--json", "Output as JSON").action(async (documentId, options) => {
+    const client = getClient();
+    const spinner = (0, import_ora4.default)("Requesting reprocess...").start();
+    try {
+      const result = await client.documents.reprocess(documentId);
+      spinner.succeed(result.message);
+      if (options.wait) {
+        const waitSpinner = (0, import_ora4.default)("Waiting for extraction...").start();
+        const finished = await client.documents.waitForExtraction(documentId, {
+          timeoutMs: parseInt(options.timeout)
+        });
+        const outcome = extractionOutcome(finished.status);
+        if (options.json) json({ ...result, document: finished });
+        if (outcome === "done") {
+          waitSpinner.succeed(`Extraction ${finished.status}`);
+        } else if (outcome === "failed") {
+          waitSpinner.fail(`Extraction ${finished.status}`);
+          if (!options.json) error(finished.error?.message || "Unknown error");
+          process.exit(1);
+        } else {
+          waitSpinner.warn(`Extraction still ${finished.status}`);
+          if (!options.json) info(`Run "delegance doc wait ${documentId}" to keep following it`);
+        }
+        return;
+      }
+      if (options.json) {
+        json(result);
+      } else {
+        info(`${result.reprocessesRemaining} reprocess attempts left today`);
+        info(`Run "delegance doc wait ${documentId}" to follow it`);
+      }
+    } catch (err) {
+      spinner.fail("Failed to reprocess document");
+      failWith("API error", err);
+    }
+  });
+  doc.command("archive <documentId>").description("Archive a document (hide it from lists and answers)").option("--json", "Output as JSON").action(async (documentId, options) => {
+    const client = getClient();
+    const spinner = (0, import_ora4.default)("Archiving document...").start();
+    try {
+      const result = await client.documents.archive(documentId);
+      spinner.succeed(result.message || "Document archived");
+      if (options.json) json(result);
+    } catch (err) {
+      spinner.fail("Failed to archive document");
+      failWith("API error", err);
+    }
+  });
+  doc.command("unarchive <documentId>").description("Restore an archived document").option("--json", "Output as JSON").action(async (documentId, options) => {
+    const client = getClient();
+    const spinner = (0, import_ora4.default)("Restoring document...").start();
+    try {
+      const result = await client.documents.unarchive(documentId);
+      spinner.succeed(result.message || "Document restored");
+      if (options.json) json(result);
+    } catch (err) {
+      spinner.fail("Failed to restore document");
+      failWith("API error", err);
+    }
+  });
+  return doc;
+}
+
+// src/commands/chat.ts
+var import_commander5 = require("commander");
+var import_ora5 = __toESM(require("ora"));
+var import_inquirer4 = __toESM(require("inquirer"));
+function createChatCommand() {
+  const chat = new import_commander5.Command("ask").alias("chat").description("Ask the Orin insurance assistant a question");
+  chat.command("query <question...>").alias("q").description("Ask a single question").option("-c, --conversation <id>", "Continue a previous conversation").option("--json", "Output as JSON").action(async (questionParts, options) => {
+    const question = questionParts.join(" ");
+    const client = getClient();
+    const spinner = (0, import_ora5.default)("Thinking...").start();
+    try {
+      const response = await client.chat.ask(question, {
+        conversationId: options.conversation
+      });
+      spinner.succeed("Response received");
+      if (options.json) {
+        json(response);
+      } else {
+        console.log();
+        const cleanResponse = response.response.replace(/<[^>]*>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+        console.log(cleanResponse);
+        if (response.sources && response.sources.length > 0) {
+          console.log();
+          info(`Sources: ${response.sources.map((s) => s.fileName).join(", ")}`);
+        }
+        console.log();
+        info(`Conversation ID: ${response.conversationId}`);
+        info("Use --conversation flag to continue this conversation");
+      }
+    } catch (err) {
+      spinner.fail("Failed to get response");
+      failWith("API error", err);
+    }
+  });
+  chat.command("session").alias("interactive").alias("i").description("Start an interactive chat session").action(async () => {
+    const client = getClient();
+    let conversationId;
+    header("Orin Insurance Assistant");
+    console.log('Type your questions. Enter "exit" or "quit" to end the session.');
+    console.log();
+    while (true) {
+      const { question } = await import_inquirer4.default.prompt([
+        {
+          type: "input",
+          name: "question",
+          message: "You:",
+          validate: (input) => input.length > 0 || "Please enter a question"
+        }
+      ]);
+      const lowerQuestion = question.toLowerCase().trim();
+      if (lowerQuestion === "exit" || lowerQuestion === "quit" || lowerQuestion === "q") {
+        info("Ending session. Goodbye!");
+        break;
+      }
+      const spinner = (0, import_ora5.default)("Thinking...").start();
+      try {
+        const response = await client.chat.ask(question, {
+          conversationId
+        });
+        conversationId = response.conversationId;
+        spinner.stop();
+        console.log();
+        const cleanResponse = response.response.replace(/<[^>]*>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+        console.log(`Orin: ${cleanResponse}`);
+        console.log();
+      } catch (err) {
+        spinner.fail("Failed to get response");
+        error("Error", err.message);
+        console.log();
+      }
+    }
+  });
+  chat.arguments("[question...]").action(async (questionParts, options) => {
+    if (!questionParts || questionParts.length === 0) {
+      chat.outputHelp();
+      return;
+    }
+    const question = questionParts.join(" ");
+    const client = getClient();
+    const spinner = (0, import_ora5.default)("Thinking...").start();
+    try {
+      const response = await client.chat.ask(question);
+      spinner.succeed("Response received");
+      console.log();
+      const cleanResponse = response.response.replace(/<[^>]*>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+      console.log(cleanResponse);
+      if (response.sources && response.sources.length > 0) {
+        console.log();
+        info(`Sources: ${response.sources.map((s) => s.fileName).join(", ")}`);
+      }
+      console.log();
+      info(`Conversation ID: ${response.conversationId}`);
+    } catch (err) {
+      spinner.fail("Failed to get response");
+      failWith("API error", err);
+    }
+  });
+  return chat;
+}
+
+// src/commands/quote.ts
+var import_commander6 = require("commander");
+var import_ora7 = __toESM(require("ora"));
+var import_inquirer6 = __toESM(require("inquirer"));
+var import_sdk5 = require("@delegance/sdk");
+
+// src/commands/instant-quote.ts
+var fs5 = __toESM(require("fs"));
+var import_crypto2 = require("crypto");
+var import_chalk2 = __toESM(require("chalk"));
+var import_inquirer5 = __toESM(require("inquirer"));
+var import_ora6 = __toESM(require("ora"));
+var import_sdk4 = require("@delegance/sdk");
+
+// src/commerce/questions.ts
+var COVERAGE_ALIASES = {
+  gl: "general_liability",
+  "general-liability": "general_liability",
+  wc: "workers_comp",
+  "workers-comp": "workers_comp",
+  bop: "business_owners",
+  cyber: "cyber",
+  pl: "professional_liability",
+  eo: "professional_liability",
+  "e&o": "professional_liability",
+  mpl: "professional_liability",
+  "tech-eo": "tech_eo",
+  auto: "commercial_auto",
+  property: "commercial_property",
+  umbrella: "umbrella",
+  excess: "umbrella"
+};
+function parseCoverages(raw) {
+  const ids = raw.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean).map((s) => COVERAGE_ALIASES[s] ?? s.replace(/-/g, "_"));
+  return [...new Set(ids)];
+}
+function isVisible(q, answers) {
+  const rule = q.showIf;
+  if (!rule || !rule.questionId || !Array.isArray(rule.equals)) return true;
+  const a = answers[rule.questionId];
+  if (a === void 0 || a === null) return false;
+  return rule.equals.map(String).includes(String(a));
+}
+function isRequired(q, answers) {
+  return q.required === true || q.requiredIfShown === true && isVisible(q, answers);
+}
+function coerceAnswer(q, raw) {
+  if (raw === void 0 || raw === null || raw === "") return { ok: true, value: void 0 };
+  const text = String(raw).trim();
+  switch (q.type) {
+    case "number":
+    case "currency":
+    case "percentage": {
+      const n = Number(text.replace(/[$,%\s]/g, ""));
+      return Number.isFinite(n) ? { ok: true, value: n } : { ok: false, message: "Enter a number." };
+    }
+    case "yes_no": {
+      const t = text.toLowerCase();
+      if (["y", "yes", "true", "1"].includes(t)) return { ok: true, value: "yes" };
+      if (["n", "no", "false", "0"].includes(t)) return { ok: true, value: "no" };
+      return { ok: false, message: "Answer yes or no." };
+    }
+    case "select": {
+      const opts = q.options ?? [];
+      const hit = opts.find((o) => o.value === text) ?? opts.find((o) => o.label.toLowerCase() === text.toLowerCase());
+      return hit ? { ok: true, value: hit.value } : { ok: false, message: `Choose one of: ${opts.map((o) => o.value).join(", ")}` };
+    }
+    default:
+      return { ok: true, value: text };
+  }
+}
+function validateAnswers(questions, provided) {
+  const answers = {};
+  const invalid = /* @__PURE__ */ new Map();
+  for (const q of questions) {
+    const raw = provided[q.id] ?? q.prefill;
+    const c = coerceAnswer(q, raw);
+    if (!c.ok) invalid.set(q.id, c.message);
+    else if (c.value !== void 0) answers[q.id] = c.value;
+  }
+  const problems = [];
+  for (const q of questions) {
+    if (!isVisible(q, answers)) {
+      delete answers[q.id];
+      continue;
+    }
+    const bad = invalid.get(q.id);
+    if (bad) problems.push(`${q.id}: ${bad}`);
+    else if (isRequired(q, answers) && answers[q.id] === void 0) problems.push(`${q.id}: required ("${q.label}")`);
+  }
+  return { answers, problems };
+}
+function sortQuoteRows(quotes) {
+  return quotes.map((q) => ({
+    carrier: q.carrierName || q.carrierId,
+    coverage: q.coverage ?? "",
+    premium: q.premium,
+    status: q.marketStatus || q.state,
+    bindable: q.bindable === true && q.state === "QUOTED",
+    opportunityId: q.opportunityId
+  })).sort((a, b) => {
+    if (a.bindable !== b.bindable) return a.bindable ? -1 : 1;
+    if (a.premium === null && b.premium === null) return 0;
+    if (a.premium === null) return 1;
+    if (b.premium === null) return -1;
+    return a.premium - b.premium;
+  });
+}
+function cheapestBindable(rows) {
+  return rows.find((r) => r.bindable && r.premium !== null) ?? null;
+}
+function summarizeStatus(s) {
+  const quoted = s.carrierQuotes.filter((q) => q.premium !== null).length;
+  const parts = [`${quoted} of ${s.carrierQuotes.length} carriers priced`];
+  if (s.awaitingBrokerReviewCount > 0) parts.push(`${s.awaitingBrokerReviewCount} with a broker for review`);
+  if (!s.allCarriersResolved) parts.push("still waiting on the rest");
+  return parts.join(", ");
+}
+var SUGGESTION_SOURCES = {
+  acord_suggest: "suggested from your business profile"
+};
+function knownValue(q) {
+  if (q.prefill !== void 0 && q.prefill !== null && q.prefill !== "") {
+    return { value: q.prefill, kind: "prefill", source: q.prefillSource === "prior_application" ? "your last application" : "your account" };
+  }
+  const s = q.suggested;
+  if (s && s.value !== void 0 && s.value !== null && s.value !== "") {
+    const route = s.route ? String(s.route) : "";
+    return { value: s.value, kind: "suggested", source: SUGGESTION_SOURCES[route] ?? "suggested, please check" };
+  }
+  return null;
+}
+function planQuestionRound(questions, answers, handled) {
+  const round = { confirm: [], checklist: [], ask: [] };
+  for (const q of questions) {
+    if (handled.has(q.id) || !isVisible(q, answers)) continue;
+    if (knownValue(q)) round.confirm.push(q);
+    else if (!isRequired(q, answers)) handled.add(q.id);
+    else if (q.type === "yes_no") round.checklist.push(q);
+    else round.ask.push(q);
+  }
+  return round;
+}
+function checklistAnswers(items, checkedIds) {
+  const checked = new Set(checkedIds);
+  const out = {};
+  for (const q of items) out[q.id] = checked.has(q.id) ? "yes" : "no";
+  return out;
+}
+function formatKnown(q, value) {
+  if (q.type === "yes_no") return String(value).toLowerCase() === "yes" || value === true ? "Yes" : "No";
+  if (q.type === "select") {
+    const hit = (q.options ?? []).find((o) => o.value === String(value));
+    if (hit) return hit.label;
+  }
+  return String(value);
+}
+
+// src/commerce/demo.ts
+var DEMO_BUSINESS = "Riverbend Bakery (demo), Austin TX, 6 employees";
+var DEMO_QUESTIONS = [
+  { id: "annual_revenue", label: "Annual revenue (USD)", type: "currency", required: true, prefill: 85e4 },
+  { id: "employees", label: "Full-time employees", type: "number", required: true, prefill: 6 },
+  {
+    id: "delivery",
+    label: "Do you deliver orders to customers?",
+    type: "yes_no",
+    required: true,
+    prefill: "no"
+  },
+  {
+    id: "delivery_vehicles",
+    label: "How many vehicles make deliveries?",
+    type: "number",
+    required: false,
+    requiredIfShown: true,
+    showIf: { questionId: "delivery", equals: ["yes"] }
+  },
+  {
+    id: "claims_5y",
+    label: "Claims in the last 5 years",
+    type: "select",
+    required: true,
+    options: [
+      { value: "0", label: "None" },
+      { value: "1", label: "One" },
+      { value: "2+", label: "Two or more" }
+    ],
+    prefill: "0"
+  }
+];
+var DEMO_STATUS = {
+  submissionId: "demo-submission",
+  coverages: ["general_liability", "workers_comp"],
+  expiresAt: null,
+  submitted: true,
+  submitStatus: "completed",
+  allCarriersResolved: true,
+  awaitingBrokerReviewCount: 0,
+  carrierQuotes: [
+    { opportunityId: "demo-1", carrierId: "COTERIE", carrierName: "Coterie", coverage: "CGL", state: "QUOTED", marketStatus: "quote", premium: 612, quoteNumber: "DEMO-GL-1", bindable: true },
+    { opportunityId: "demo-2", carrierId: "CHUBB", carrierName: "Chubb", coverage: "CGL", state: "QUOTED", marketStatus: "quote", premium: 748, quoteNumber: "DEMO-GL-2", bindable: true },
+    { opportunityId: "demo-3", carrierId: "PIE_INSURANCE", carrierName: "Pie Insurance", coverage: "WC", state: "QUOTED", marketStatus: "quote", premium: 1184, quoteNumber: "DEMO-WC-1", bindable: true },
+    { opportunityId: "demo-4", carrierId: "AMTRUST", carrierName: "AmTrust", coverage: "WC", state: "DECLINED", marketStatus: "declined", premium: null, quoteNumber: null, bindable: false }
+  ]
+};
+
+// src/commands/instant-quote.ts
+function activeRequestLines(err, coverageFlag) {
+  if (!(err instanceof import_sdk4.DeleganceError) || err.statusCode !== 409 || !err.body) return null;
+  const { body } = err;
+  const code = body.message;
+  const requote = `delegance quote start --coverage ${coverageFlag} --replace`;
+  if (code === "active_request_exists") {
+    const active = Array.isArray(body.active) ? body.active : [];
+    const first = active[0];
+    const id = typeof first?.submissionId === "string" ? first.submissionId : null;
+    const carriers = Array.isArray(first?.carriers) ? first.carriers.map((c) => `${c.carrierId}${c.state ? ` (${c.state.toLowerCase()})` : ""}`).join(", ") : "";
+    return [
+      `Already with carriers${id ? `: ${id}` : ""}${carriers ? `, ${carriers}` : ""}.`,
+      `Check it: ${id ? `delegance quote status ${id}` : "delegance quote status <id>"}   Replace it: ${requote}`
+    ];
+  }
+  if (code === "replace_conflict") {
+    const carrier = typeof body.carrier === "string" ? body.carrier : "A carrier";
+    return [
+      `Cannot replace: ${carrier} has a bind in progress or bound on the earlier request.`,
+      "Reply to your quote confirmation email and a broker will sort it out."
+    ];
+  }
+  if (code === "answers_changed_requote_required") {
+    return ["Carriers are quoting your earlier answers.", `Re-quote with the new answers: ${requote}`];
+  }
+  return null;
+}
+function answerMode(o) {
+  if (o.hasAnswersFile) return "file";
+  if (o.demo) return o.json || !o.isTTY ? "suggested" : "prompt";
+  if (o.json) return "print_questions";
+  return o.isTTY ? "prompt" : "needs_answers";
+}
+function suggestedAnswers(questions) {
+  const answers = {};
+  for (const q of questions) {
+    if (!isVisible(q, answers) || q.prefill === void 0 || q.prefill === null) continue;
+    const c = coerceAnswer(q, String(q.prefill));
+    if (c.ok && c.value !== void 0) answers[q.id] = c.value;
+  }
+  return answers;
+}
+var isInteractive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
+async function askOne(q, answers, fallback) {
+  const required = isRequired(q, answers);
+  const label = `${q.label}${required ? "" : import_chalk2.default.dim(" (optional)")}`;
+  let prompt;
+  if (q.type === "yes_no") {
+    prompt = { type: "list", name: "v", message: label, choices: [{ name: "Yes", value: "yes" }, { name: "No", value: "no" }], default: fallback };
+  } else if (q.type === "select" && q.options?.length) {
+    prompt = { type: "list", name: "v", message: label, choices: q.options.map((o) => ({ name: o.label, value: o.value })), default: fallback };
+  } else {
+    prompt = {
+      type: "input",
+      name: "v",
+      message: label,
+      default: fallback === void 0 || fallback === null ? void 0 : String(fallback),
+      validate: (v2) => {
+        if (!v2 && required) return "Required";
+        const c2 = coerceAnswer(q, v2);
+        return c2.ok || c2.message;
+      }
+    };
+  }
+  const { v } = await import_inquirer5.default.prompt([prompt]);
+  const c = coerceAnswer(q, v);
+  if (c.ok && c.value !== void 0) answers[q.id] = c.value;
+}
+async function askQuestions(questions, answers = {}) {
+  const handled = /* @__PURE__ */ new Set();
+  const stats = { asked: 0, checklist: 0, prefilled: 0, suggestedConfirmed: 0, suggestedChanged: 0 };
+  for (; ; ) {
+    const round = planQuestionRound(questions, answers, handled);
+    if (round.confirm.length + round.checklist.length + round.ask.length === 0) break;
+    if (round.confirm.length) {
+      const { keep } = await import_inquirer5.default.prompt([
+        {
+          type: "checkbox",
+          name: "keep",
+          message: "We already have these answers. Uncheck any that are wrong, then press Enter:",
+          pageSize: 20,
+          choices: round.confirm.map((q) => {
+            const k = knownValue(q);
+            return { name: `${q.label}: ${import_chalk2.default.bold(formatKnown(q, k.value))} ${import_chalk2.default.dim(`(${k.source})`)}`, value: q.id, checked: true };
+          })
+        }
+      ]);
+      const kept = new Set(keep);
+      for (const q of round.confirm) {
+        handled.add(q.id);
+        const k = knownValue(q);
+        const kc = kept.has(q.id) ? coerceAnswer(q, k.value) : null;
+        if (kc && kc.ok && kc.value !== void 0) {
+          answers[q.id] = kc.value;
+          if (k.kind === "prefill") stats.prefilled += 1;
+          else stats.suggestedConfirmed += 1;
+        } else {
+          if (k.kind === "suggested") stats.suggestedChanged += 1;
+          stats.asked += 1;
+          await askOne(q, answers);
+        }
+      }
+    }
+    if (round.checklist.length) {
+      const { yes } = await import_inquirer5.default.prompt([
+        {
+          type: "checkbox",
+          name: "yes",
+          message: `Check every statement that is TRUE for your business (${round.checklist.length}). Unchecked means No:`,
+          pageSize: 20,
+          choices: round.checklist.map((q) => ({ name: q.label, value: q.id }))
+        }
+      ]);
+      const yn = checklistAnswers(round.checklist, yes);
+      const yesCount = Object.values(yn).filter((v) => v === "yes").length;
+      const { ok } = await import_inquirer5.default.prompt([
+        { type: "confirm", name: "ok", message: `Yes to ${yesCount}, No to ${round.checklist.length - yesCount}. Correct?`, default: true }
+      ]);
+      if (ok) {
+        Object.assign(answers, yn);
+        round.checklist.forEach((q) => handled.add(q.id));
+        stats.checklist += round.checklist.length;
+      }
+    }
+    for (const q of round.ask) {
+      handled.add(q.id);
+      stats.asked += 1;
+      await askOne(q, answers);
+    }
+  }
+  return { answers, stats };
+}
+function handoffLines(r) {
+  const lines = [
+    r.alreadyHandedOff ? "A Delegance broker already has this request." : "A Delegance broker has this request and will place it with a market that quotes by hand."
+  ];
+  if (!r.alreadyHandedOff && r.unansweredRequired > 0) {
+    lines.push(`The broker will email you for the ${r.unansweredRequired} answer(s) still missing.`);
+  }
+  lines.push(`Check it: delegance quote status ${r.submissionId}`);
+  return lines;
+}
+async function runBrokerHandoff(submissionId, instantAnswers, opts) {
+  const client = getClient();
+  const say = (l) => opts.json ? console.error(l) : info(l);
+  let plan;
+  try {
+    plan = await client.instantQuotes.brokerHandoffQuestions(submissionId, instantAnswers);
+  } catch (err) {
+    if (err instanceof import_sdk4.DeleganceError && err.statusCode === 503) {
+      say("A broker can still market it: reply to the confirmation email, or start in the portal.");
+      return;
+    }
+    failWith("Could not load the broker questions", err);
+  }
+  if (plan.alreadyHandedOff) {
+    const lines = handoffLines({ submissionId, unansweredRequired: 0, alreadyHandedOff: true });
+    if (opts.json) json({ submissionId, status: "broker_review", alreadyHandedOff: true, brokerTaskId: plan.brokerTaskId ?? null });
+    else lines.forEach((l) => info(l));
+    return;
+  }
+  let answers = {};
+  let complete = true;
+  const idempotencyKey = (0, import_crypto2.randomUUID)();
+  let inFlight = null;
+  if (opts.answersFile) {
+    try {
+      const provided = JSON.parse(fs5.readFileSync(opts.answersFile, "utf8"));
+      const checked = validateAnswers(plan.questions, provided);
+      if (checked.problems.length) {
+        error("Some answers need fixing:");
+        checked.problems.forEach((p) => console.log(`  - ${p}`));
+        process.exit(1);
+      }
+      answers = checked.answers;
+    } catch (e) {
+      error(`Could not read ${opts.answersFile}: ${e.message}`);
+      process.exit(1);
+    }
+  } else if (!opts.json && isInteractive() && plan.questions.length > 0) {
+    info(`A broker can place ${plan.coverages.join(", ")} with a market that quotes by hand. ${plan.questions.length} application question(s) left.`);
+    info("Press Ctrl-C to stop at any point; what you have answered goes to the broker.");
+    const onInterrupt = () => {
+      complete = false;
+      void send().then(() => process.exit(0));
+    };
+    process.once("SIGINT", onInterrupt);
+    try {
+      await askQuestions(plan.questions, answers);
+    } catch {
+      complete = false;
+    } finally {
+      process.removeListener("SIGINT", onInterrupt);
+    }
+  } else {
+    complete = plan.questions.length === 0;
+  }
+  await send();
+  function send() {
+    inFlight ?? (inFlight = sendHandoff(submissionId, { answers, instantAnswers, complete }, idempotencyKey, opts.json));
+    return inFlight;
+  }
+}
+async function sendHandoff(submissionId, input, idempotencyKey, asJson) {
+  const spinner = asJson ? null : (0, import_ora6.default)("Sending it to a broker...").start();
+  try {
+    const result = await getClient().instantQuotes.brokerHandoff(submissionId, input, { idempotencyKey });
+    spinner?.succeed("Sent to a broker.");
+    if (asJson) json(result);
+    else handoffLines(result).forEach((l) => info(l));
+  } catch (err) {
+    spinner?.fail("Could not reach a broker");
+    console.error(`Try again: delegance quote handoff ${submissionId}`);
+    failWith("API error", err);
+  }
+}
+function printFloorDrops(failures) {
+  const floors = (failures ?? []).filter((f) => f.reason.startsWith("requirement_floor:") && f.missing);
+  if (floors.length === 0) return;
+  warn("Some carriers were skipped because a required fact is missing:");
+  floors.forEach((f) => console.log(`  - ${f.carrierId}: ${f.missing}`));
+  info("Add it to your business profile in the portal, then run the quote again.");
+}
+function printQuoteTable(status, opts = {}) {
+  const rows = sortQuoteRows(status.carrierQuotes);
+  if (rows.length === 0) {
+    if (status.brokerReview) {
+      info(`A broker has this request (${status.brokerReview.status.replace(/_/g, " ")}). They place it by hand and email you with quotes or questions.`);
+      return;
+    }
+    warn("No carrier offers yet.");
+    if (status.awaitingBrokerReviewCount > 0) info(`${status.awaitingBrokerReviewCount} quote(s) are with a broker for review.`);
+    return;
+  }
+  const best = cheapestBindable(rows);
+  if (best) {
+    console.log(import_chalk2.default.bold(`${opts.demo ? "[DEMO] " : ""}Cheapest bindable: ${best.carrier} ${best.coverage} at ${formatCurrency(best.premium)}/yr`));
+  }
+  table(
+    ["Carrier", "Coverage", "Premium/yr", "Status", "Bindable", "Offer id"],
+    rows.map((r) => {
+      const cells = [r.carrier, r.coverage, r.premium === null ? "-" : formatCurrency(r.premium), r.status, r.bindable ? "yes" : "no", r.opportunityId];
+      return r === best ? cells.map((c) => import_chalk2.default.bold(String(c))) : cells;
+    })
+  );
+  console.log(import_chalk2.default.dim(summarizeStatus(status)));
+  if (best && !opts.demo) {
+    console.log(import_chalk2.default.green(`Bind it: delegance bind ${status.submissionId} ${best.opportunityId}`));
+  }
+  if (opts.demo) console.log(import_chalk2.default.yellow('DEMO: sample premiums, nothing was sent to a carrier. Run "delegance signup" for real quotes.'));
+}
+async function runDemo(asJson, answersFile) {
+  (asJson ? console.error : console.log)(import_chalk2.default.yellow(`DEMO quote for ${DEMO_BUSINESS}. Nothing leaves this machine.`));
+  if (answersFile) {
+    let provided;
+    try {
+      provided = JSON.parse(fs5.readFileSync(answersFile, "utf8"));
+    } catch (e) {
+      error(`Could not read ${answersFile}: ${e.message}`);
+      process.exit(1);
+    }
+    const { problems } = validateAnswers(DEMO_QUESTIONS, provided);
+    if (problems.length) {
+      problems.forEach((p) => error(p));
+      process.exit(1);
+    }
+  } else {
+    const mode = answerMode({ demo: true, hasAnswersFile: false, json: asJson, isTTY: isInteractive() });
+    if (mode === "prompt") await askQuestions(DEMO_QUESTIONS);
+    else {
+      suggestedAnswers(DEMO_QUESTIONS);
+      if (!asJson) info("No terminal to ask in, so the demo uses its suggested answers.");
+    }
+  }
+  const spinner = asJson ? null : (0, import_ora6.default)("Asking carriers (demo)...").start();
+  await new Promise((resolve) => setTimeout(resolve, asJson ? 0 : 1200));
+  spinner?.succeed("4 carriers answered (demo)");
+  if (asJson) json({ demo: true, ...DEMO_STATUS });
+  else printQuoteTable(DEMO_STATUS, { demo: true });
+}
+function addInstantQuoteCommands(quote) {
+  quote.command("start").description("Get instant quotes from real carriers: answers the questions, files them, waits for premiums").option("-c, --coverage <list>", "Coverages, comma-separated: gl, wc, bop, cyber, pl (E&O), auto, property, umbrella", "gl").option("-a, --answers <file>", "JSON file of answers keyed by question id (skips the prompts)").option("--demo", "Walk the flow on sample data; nothing is sent anywhere").option("--no-wait", 'File the quote and exit; check later with "quote status"').option("--timeout <minutes>", "How long to wait for premiums", "10").option("--replace", "Close the request already with carriers for this coverage and re-quote").option("--json", "Output as JSON").action(async (options) => {
+    if (options.demo) {
+      await runDemo(!!options.json, options.answers);
+      return;
+    }
+    const coverages = parseCoverages(String(options.coverage));
+    if (coverages.length === 0) {
+      error("Name at least one coverage with --coverage");
+      process.exit(1);
+    }
+    const client = getClient();
+    const spinner = (0, import_ora6.default)("Checking which carriers can quote...").start();
+    let session;
+    try {
+      session = await client.instantQuotes.start(coverages, options.replace ? { fresh: true } : {});
+      spinner.succeed(
+        `${session.eligibleCarriers.length} carrier(s) can quote: ${session.eligibleCarriers.map((c) => c.name).join(", ") || "broker review only"}`
+      );
+    } catch (err) {
+      spinner.fail("Could not start the quote");
+      failWith("API error", err);
+    }
+    let answers;
+    if (options.answers) {
+      let provided;
+      try {
+        provided = JSON.parse(fs5.readFileSync(options.answers, "utf8"));
+      } catch (e) {
+        error(`Could not read ${options.answers}: ${e.message}`);
+        process.exit(1);
+      }
+      const checked = validateAnswers(session.questions, provided);
+      if (checked.problems.length) {
+        error("Some answers need fixing:");
+        checked.problems.forEach((p) => console.log(`  - ${p}`));
+        info(`Question ids: ${session.questions.map((q) => q.id).join(", ")}`);
+        process.exit(1);
+      }
+      answers = checked.answers;
+    } else if (answerMode({ demo: false, hasAnswersFile: false, json: !!options.json, isTTY: isInteractive() }) === "needs_answers") {
+      error("No terminal to ask the questions in.");
+      info(`Re-run with --answers <file.json>, or with --json to print the questions. Session: ${session.submissionId}`);
+      process.exit(1);
+    } else if (options.json) {
+      json({ submissionId: session.submissionId, sessionVersion: session.sessionVersion, questions: session.questions });
+      return;
+    } else {
+      const asked = await askQuestions(session.questions);
+      answers = asked.answers;
+      const s = asked.stats;
+      info(`${s.prefilled + s.suggestedConfirmed} answer(s) confirmed from what we have, ${s.checklist} on the checklist, ${s.asked} asked.`);
+    }
+    const submitSpinner = (0, import_ora6.default)("Sending your answers to the carriers...").start();
+    let submitted;
+    try {
+      submitted = await client.instantQuotes.submit({
+        submissionId: session.submissionId,
+        sessionVersion: session.sessionVersion,
+        answers,
+        ...options.replace ? { replace: true } : {}
+      });
+    } catch (err) {
+      const guardLines = activeRequestLines(err, String(options.coverage));
+      if (guardLines) {
+        submitSpinner.fail("Nothing was sent.");
+        guardLines.forEach((l) => options.json ? console.error(l) : info(l));
+        process.exit(1);
+      }
+      submitSpinner.fail("Submit failed");
+      console.error(`Before trying again, check whether it went through: delegance quote status ${session.submissionId}`);
+      failWith("API error", err);
+    }
+    if (submitted.status === "no_carriers") {
+      if (options.json) console.error("No carrier could take this one instantly. Sending it to a broker.");
+      else submitSpinner.warn("No carrier could take this one instantly.");
+      if (!options.json) printFloorDrops(submitted.partialFailures);
+      await runBrokerHandoff(session.submissionId, answers, { json: !!options.json });
+      return;
+    }
+    if (options.json && (submitted.status !== "submitted" || options.wait === false)) {
+      json({ submissionId: session.submissionId, ...submitted });
+      return;
+    }
+    if (submitted.status === "acord_pending") {
+      submitSpinner.succeed("Sent to a broker: these coverages need a person, not an instant quote.");
+      info(`Track it with: delegance quote status ${session.submissionId}`);
+      return;
+    }
+    submitSpinner.succeed(`Filed with ${submitted.quotes.filter((q) => q.status === "submitted").length} carrier(s).`);
+    printFloorDrops(submitted.partialFailures);
+    if (submitted.replaceNotice && !options.json) info(submitted.replaceNotice);
+    if (options.wait === false) {
+      info(`Check premiums with: delegance quote status ${session.submissionId} --wait`);
+      return;
+    }
+    await waitAndPrint(session.submissionId, Number(options.timeout) * 6e4 || 6e5, !!options.json);
+  });
+  quote.command("submit <submissionId>").description('File answers for a session started with "quote start --json" (scripted flow)').requiredOption("--session-version <version>", 'sessionVersion from "quote start --json"').requiredOption("-a, --answers <file>", "JSON file of answers keyed by question id").option("--idempotency-key <key>", "Reuse on a retry so the same submission is not filed twice").option("--replace", "Close the request already with carriers for this coverage and re-quote").option("--no-wait", "Exit after filing").option("--timeout <minutes>", "How long to wait for premiums", "10").option("--json", "Output as JSON").action(async (submissionId, options) => {
+    let answers;
+    try {
+      answers = JSON.parse(fs5.readFileSync(options.answers, "utf8"));
+    } catch (e) {
+      error(`Could not read ${options.answers}: ${e.message}`);
+      process.exit(1);
+    }
+    try {
+      const submitted = await getClient().instantQuotes.submit(
+        { submissionId, sessionVersion: options.sessionVersion, answers, ...options.replace ? { replace: true } : {} },
+        options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}
+      );
+      if (submitted.status === "no_carriers") {
+        (options.json ? console.error : info)("No carrier could take this one instantly. Sending it to a broker.");
+        await runBrokerHandoff(submissionId, answers, { json: !!options.json });
+        return;
+      }
+      if (options.json && (submitted.status !== "submitted" || options.wait === false)) {
+        json({ submissionId, ...submitted });
+        return;
+      }
+      if (submitted.status !== "submitted") {
+        info("Sent to a broker for these coverages.");
+        info(`Check it: delegance quote status ${submissionId}`);
+        return;
+      }
+      if (options.wait === false) {
+        info(`Check premiums with: delegance quote status ${submissionId} --wait`);
+        return;
+      }
+      await waitAndPrint(submissionId, Number(options.timeout) * 6e4 || 6e5, !!options.json);
+    } catch (err) {
+      const guardLines = activeRequestLines(err, "<list>");
+      if (guardLines) {
+        error("Nothing was sent.");
+        guardLines.forEach((l) => options.json ? console.error(l) : info(l));
+        process.exit(1);
+      }
+      console.error(`Before trying again, check whether it went through: delegance quote status ${submissionId}`);
+      failWith("Submit failed", err);
+    }
+  });
+  quote.command("handoff <submissionId>").description("Send a quote no carrier could take instantly to a broker, after the application questions they need").option("-a, --answers <file>", "JSON file of answers keyed by question id (skips the prompts)").option("--json", "Output as JSON").action(async (submissionId, options) => {
+    await runBrokerHandoff(submissionId, {}, { json: !!options.json, answersFile: options.answers });
+  });
+  quote.command("status <submissionId>").description("Premiums and bindable offers for an instant quote").option("--wait", "Poll until every carrier answers").option("--timeout <minutes>", "How long to wait", "10").option("--json", "Output as JSON").action(async (submissionId, options) => {
+    if (options.wait) {
+      await waitAndPrint(submissionId, Number(options.timeout) * 6e4 || 6e5, !!options.json);
+      return;
+    }
+    try {
+      const status = await getClient().instantQuotes.status(submissionId);
+      if (options.json) json(status);
+      else printQuoteTable(status);
+    } catch (err) {
+      failWith("API error", err);
+    }
+  });
+}
+async function waitAndPrint(submissionId, timeoutMs, asJson) {
+  const client = getClient();
+  const started = Date.now();
+  const spinner = asJson ? null : (0, import_ora6.default)("Waiting for carriers to price...").start();
+  try {
+    const status = await client.instantQuotes.waitForQuotes(submissionId, {
+      timeoutMs,
+      intervalMs: 1e4,
+      onPoll: (s) => {
+        if (spinner) spinner.text = `Waiting for carriers (${Math.round((Date.now() - started) / 1e3)}s): ${summarizeStatus(s)}`;
+      }
+    });
+    spinner?.stop();
+    if (asJson) json(status);
+    else printQuoteTable(status);
+    if (!status.allCarriersResolved && !asJson) info(`Some carriers are still working. Check again: delegance quote status ${submissionId} --wait`);
+  } catch (err) {
+    spinner?.fail("Could not read the quote");
+    failWith("API error", err);
+  }
+}
+
+// src/commands/quote.ts
+var QUOTE_SUBMISSION_UNAVAILABLE = "Quote submission via API isn't available yet";
+function createQuoteCommand() {
+  const quote = new import_commander6.Command("quote").alias("quotes").description("Request and manage insurance quotes");
+  quote.command("carriers").description("List available carriers for quoting").option("--json", "Output as JSON").action(async (options) => {
+    const client = getClient();
+    const spinner = (0, import_ora7.default)("Fetching carriers...").start();
+    try {
+      const { carriers, count } = await client.quotes.listCarriers();
+      spinner.succeed(`Found ${count} carriers`);
+      if (carriers.length === 0) {
+        info("No carriers available");
+        return;
+      }
+      if (options.json) {
+        json(carriers);
+      } else {
+        console.log();
+        table(
+          ["ID", "Name", "Avg Quote Time", "Queue Depth"],
+          carriers.map((c) => [
+            c.id,
+            c.name,
+            `${Math.round(c.averageQuoteTimeSeconds / 60)} min`,
+            String(c.queueDepth)
+          ])
+        );
+      }
+    } catch (err) {
+      spinner.fail("Failed to fetch carriers");
+      failWith("API error", err);
+    }
+  });
+  quote.command("request").description('Legacy partner queue submission (not live). For an instant quote, use "quote start"').option("-c, --carriers <carriers...>", "Carrier IDs to quote (space-separated)").option("-p, --priority <priority>", "Priority level (low, normal, high)", "normal").option("--all", "Request quotes from all available carriers").option("-i, --interactive", "Interactive carrier selection").option("--json", "Output as JSON").action(async (options) => {
+    const client = getClient();
+    let carrierIds = options.carriers || [];
+    const carriersSpinner = (0, import_ora7.default)("Fetching available carriers...").start();
+    let availableCarriers;
+    try {
+      ({ carriers: availableCarriers } = await client.quotes.listCarriers());
+      carriersSpinner.stop();
+    } catch (err) {
+      carriersSpinner.fail("Failed to fetch carriers");
+      failWith("API error", err);
+    }
+    if (availableCarriers.length === 0) {
+      error("No carriers available for quoting");
+      process.exit(1);
+    }
+    if (options.interactive || carrierIds.length === 0 && !options.all) {
+      const { selectedCarriers } = await import_inquirer6.default.prompt([
+        {
+          type: "checkbox",
+          name: "selectedCarriers",
+          message: "Select carriers to quote:",
+          choices: availableCarriers.map((c) => ({
+            name: `${c.name} (avg ${Math.round(c.averageQuoteTimeSeconds / 60)} min)`,
+            value: c.id,
+            checked: false
+          })),
+          validate: (input) => input.length > 0 || "Select at least one carrier"
+        }
+      ]);
+      carrierIds = selectedCarriers;
+    } else if (options.all) {
+      carrierIds = availableCarriers.map((c) => c.id);
+      info(`Requesting quotes from all ${carrierIds.length} carriers`);
+    }
+    if (carrierIds.length === 0) {
+      error("No carriers specified");
+      info("Use --carriers, --all, or --interactive to select carriers");
+      process.exit(1);
+    }
+    const spinner = (0, import_ora7.default)(`Submitting quote request to ${carrierIds.length} carriers...`).start();
+    try {
+      const result = await client.quotes.submit({
+        carriers: carrierIds,
+        priority: options.priority
+      });
+      if (result.success) {
+        spinner.succeed(result.message);
+      } else {
+        spinner.warn(result.message);
+      }
+      if (options.json) {
+        json(result);
+      } else {
+        console.log();
+        if (result.carriers && result.carriers.length > 0) {
+          info("Queued for:");
+          for (const carrier of result.carriers) {
+            console.log(`  - ${carrier.name}`);
+          }
+        }
+        if (result.invalidCarriers && result.invalidCarriers.length > 0) {
+          console.log();
+          warn(`Invalid carriers: ${result.invalidCarriers.join(", ")}`);
+        }
+        if (result.errors && result.errors.length > 0) {
+          console.log();
+          for (const err of result.errors) {
+            error(err);
+          }
+        }
+        console.log();
+        info(`Queue IDs: ${result.queueIds.join(", ")}`);
+        info('Use "delegance quote list" to check status');
+      }
+    } catch (err) {
+      spinner.fail("Failed to submit quote request");
+      if (err instanceof import_sdk5.NotImplementedError) {
+        error(QUOTE_SUBMISSION_UNAVAILABLE);
+        info("For an instant quote from the terminal: delegance quote start --coverage gl");
+        info(`Or start a quote at ${PORTAL_URL}`);
+        process.exit(1);
+      }
+      failWith("API error", err);
+    }
+  });
+  quote.command("list").alias("ls").description("List quote requests").option("-s, --status <status>", "Filter by status (pending, processing, completed, failed)").option("-l, --limit <n>", "Maximum results", "20").option("--json", "Output as JSON").action(async (options) => {
+    const client = getClient();
+    const spinner = (0, import_ora7.default)("Fetching quotes...").start();
+    try {
+      const { quotes, count } = await client.quotes.list({
+        status: options.status,
+        limit: parseInt(options.limit)
+      });
+      spinner.succeed(`Found ${count} quotes`);
+      if (quotes.length === 0) {
+        info("No quotes found");
+        return;
+      }
+      if (options.json) {
+        json(quotes);
+      } else {
+        console.log();
+        table(
+          ["ID", "Carrier", "Status", "Priority", "Created"],
+          quotes.map((q) => [
+            `${q.id.substring(0, 8)}...`,
+            q.carrierName,
+            formatQuoteStatus(q.status),
+            q.priority,
+            formatDate(q.createdAt)
+          ])
+        );
+      }
+    } catch (err) {
+      spinner.fail("Failed to list quotes");
+      failWith("API error", err);
+    }
+  });
+  quote.command("wait <quoteIds...>").description("Wait for quote(s) to complete").option("--timeout <ms>", "Timeout in milliseconds", "300000").option("--json", "Output as JSON").action(async (quoteIds, options) => {
+    const client = getClient();
+    const timeoutMs = parseInt(options.timeout);
+    info(`Waiting for ${quoteIds.length} quote(s) to complete...`);
+    console.log();
+    const results = [];
+    for (const quoteId of quoteIds) {
+      const spinner = (0, import_ora7.default)(`Waiting for ${quoteId.substring(0, 8)}...`).start();
+      try {
+        const quote2 = await client.quotes.waitForCompletion(quoteId, { timeoutMs });
+        if (quote2.status === "completed") {
+          spinner.succeed(`${quote2.carrierName}: Completed`);
+          if (quote2.result?.premium) {
+            info(`  Premium: $${quote2.result.premium.toLocaleString()}`);
+          }
+        } else if (quote2.status === "failed") {
+          spinner.fail(`${quote2.carrierName}: Failed - ${quote2.error || "Unknown error"}`);
+        } else {
+          spinner.warn(`${quote2.carrierName}: ${quote2.status}`);
+        }
+        results.push({ id: quoteId, status: quote2.status, error: quote2.error });
+      } catch (err) {
+        spinner.fail(`${quoteId.substring(0, 8)}: ${err.message}`);
+        results.push({ id: quoteId, status: "error", error: err.message });
+      }
+    }
+    if (options.json) {
+      json(results);
+    }
+  });
+  quote.command("get <quoteId>").description("Show one quote request").option("--json", "Output as JSON").action(async (quoteId, options) => {
+    const client = getClient();
+    const spinner = (0, import_ora7.default)("Fetching quote...").start();
+    try {
+      const { quote: q, canCancel } = await client.quotes.get(quoteId);
+      spinner.succeed("Quote found");
+      if (options.json) {
+        json({ quote: q, canCancel });
+        return;
+      }
+      console.log();
+      header(`${q.carrierName} quote`);
+      keyValue({
+        "ID": q.id,
+        "Status": formatQuoteStatus(q.status),
+        "Priority": q.priority,
+        "Created": formatDate(q.createdAt),
+        "Completed": q.completedAt ? formatDate(q.completedAt) : null,
+        "Premium": q.result?.premium ?? null,
+        "Bindable": q.result?.bindable ?? null,
+        "Error": q.error ?? null,
+        "Can cancel": canCancel
+      });
+    } catch (err) {
+      spinner.fail("Failed to fetch quote");
+      failWith("API error", err);
+    }
+  });
+  quote.command("cancel <quoteId>").description("Cancel a pending quote request").option("--json", "Output as JSON").action(async (quoteId, options) => {
+    const client = getClient();
+    const spinner = (0, import_ora7.default)("Cancelling quote...").start();
+    try {
+      const result = await client.quotes.cancel(quoteId);
+      spinner.succeed(result.message || "Quote cancelled");
+      if (options.json) json(result);
+    } catch (err) {
+      spinner.fail("Failed to cancel quote");
+      failWith("API error", err);
+    }
+  });
+  addInstantQuoteCommands(quote);
+  return quote;
+}
+function formatQuoteStatus(status) {
+  switch (status) {
+    case "completed":
+      return "\u2713 completed";
+    case "pending":
+      return "\u25CB pending";
+    case "processing":
+      return "\u25D0 processing";
+    case "failed":
+      return "\u2717 failed";
+    case "cancelled":
+      return "\u2298 cancelled";
+    default:
+      return status;
+  }
+}
+
+// src/commands/policy.ts
+var import_commander7 = require("commander");
+var import_inquirer7 = __toESM(require("inquirer"));
+var import_ora8 = __toESM(require("ora"));
+function createPolicyCommand() {
+  const policy = new import_commander7.Command("policy").alias("policies").description("Manage insurance policies");
+  policy.command("list").alias("ls").description("List all policies").option("-s, --status <status>", "Filter by status (active, expired, all)", "active").option("-t, --type <type>", "Filter by policy type").option("-l, --limit <n>", "Maximum results", "50").option("--json", "Output as JSON").action(async (options) => {
+    const client = getClient();
+    const spinner = (0, import_ora8.default)("Fetching policies...").start();
+    try {
+      const { policies, count } = await client.policies.list({
+        status: options.status === "all" ? void 0 : options.status,
+        policyType: options.type,
+        limit: parseInt(options.limit)
+      });
+      spinner.succeed(`Found ${count} policies`);
+      if (policies.length === 0) {
+        info("No policies found");
+        return;
+      }
+      if (options.json) {
+        json(policies);
+      } else {
+        console.log();
+        table(
+          ["Carrier", "Type", "Policy #", "Expiry", "Status", "Premium"],
+          policies.map((p) => [
+            p.carrier || "Unknown",
+            p.policyType || p.name || "-",
+            p.policyNumber || "-",
+            p.expiryDate ? formatDate(p.expiryDate) : "-",
+            formatPolicyStatus(p.isActive, p.daysUntilExpiry),
+            p.premium ? formatCurrency(p.premium) : "-"
+          ])
+        );
+      }
+    } catch (err) {
+      spinner.fail("Failed to fetch policies");
+      failWith("API error", err);
+    }
+  });
+  policy.command("expiring [days]").description("Show policies expiring soon").option("--json", "Output as JSON").action(async (days = "30", options) => {
+    const client = getClient();
+    const daysNum = parseInt(days, 10);
+    const spinner = (0, import_ora8.default)(`Fetching policies expiring in ${daysNum} days...`).start();
+    try {
+      const { policies, count } = await client.policies.getExpiring(daysNum);
+      spinner.succeed(`Found ${count} policies expiring in ${daysNum} days`);
+      if (policies.length === 0) {
+        success("No policies expiring soon!");
+        return;
+      }
+      if (options.json) {
+        json(policies);
+      } else {
+        console.log();
+        const urgent = policies.filter((p) => (p.daysUntilExpiry || 0) <= 7);
+        const soon = policies.filter((p) => (p.daysUntilExpiry || 0) > 7 && (p.daysUntilExpiry || 0) <= 30);
+        const later = policies.filter((p) => (p.daysUntilExpiry || 0) > 30);
+        if (urgent.length > 0) {
+          warn(`\u26A0\uFE0F  Expiring within 7 days (${urgent.length}):`);
+          for (const p of urgent) {
+            console.log(`   - ${p.carrier} ${p.policyType || p.name} - expires ${formatDate(p.expiryDate)}`);
+          }
+          console.log();
+        }
+        if (soon.length > 0) {
+          info(`\u{1F4C5} Expiring within 30 days (${soon.length}):`);
+          for (const p of soon) {
+            console.log(`   - ${p.carrier} ${p.policyType || p.name} - expires ${formatDate(p.expiryDate)}`);
+          }
+          console.log();
+        }
+        if (later.length > 0) {
+          console.log(`\u{1F4C6} Expiring later (${later.length}):`);
+          for (const p of later) {
+            console.log(`   - ${p.carrier} ${p.policyType || p.name} - ${p.daysUntilExpiry} days`);
+          }
+        }
+      }
+    } catch (err) {
+      spinner.fail("Failed to fetch expiring policies");
+      failWith("API error", err);
+    }
+  });
+  policy.command("get <id>").description("Get policy details").option("--json", "Output as JSON").action(async (id, options) => {
+    const client = getClient();
+    const spinner = (0, import_ora8.default)("Fetching policy...").start();
+    try {
+      const found = await client.policies.get(id);
+      if (!found) {
+        spinner.fail("Policy not found");
+        process.exit(1);
+      }
+      spinner.succeed("Policy found");
+      if (options.json) {
+        json(found);
+      } else {
+        const { policy: p, coverages } = found;
+        console.log();
+        header(`${p.carrier} - ${p.policyType || p.name}`);
+        console.log();
+        console.log(`  Policy #:       ${p.policyNumber || "N/A"}`);
+        console.log(`  Carrier:        ${p.carrier}`);
+        console.log(`  Type:           ${p.policyType || "N/A"}`);
+        console.log(`  Effective:      ${p.effectiveDate ? formatDate(p.effectiveDate) : "N/A"}`);
+        console.log(`  Expiry:         ${p.expiryDate ? formatDate(p.expiryDate) : "N/A"}`);
+        console.log(`  Status:         ${formatPolicyStatus(p.isActive, p.daysUntilExpiry)}`);
+        console.log();
+        console.log(`  Premium:        ${p.premium ? formatCurrency(p.premium) : "N/A"}`);
+        console.log(`  Deductible:     ${p.deductible ? formatCurrency(p.deductible) : "N/A"}`);
+        console.log(`  Occurrence:     ${p.occurrenceLimit ? formatCurrency(p.occurrenceLimit) : "N/A"}`);
+        console.log(`  Aggregate:      ${p.aggregateLimit ? formatCurrency(p.aggregateLimit) : "N/A"}`);
+        if (p.naicCode) {
+          console.log(`  NAIC:           ${p.naicCode}`);
+        }
+        if (coverages.length > 0) {
+          console.log();
+          table(
+            ["Coverage", "Limit", "Deductible"],
+            coverages.map((c) => [
+              c.coverageType,
+              c.limit ? formatCurrency(c.limit) : "-",
+              c.deductible ? formatCurrency(c.deductible) : "-"
+            ])
+          );
+        }
+      }
+    } catch (err) {
+      spinner.fail("Failed to fetch policy");
+      failWith("API error", err);
+    }
+  });
+  policy.command("docs <id>").description("The documents a policy was read from: declarations, forms, endorsements").option("--json", "Output as JSON").action(async (id, options) => {
+    const client = getClient();
+    try {
+      const found = await client.policies.get(id);
+      if (!found) {
+        error("Policy not found");
+        process.exit(1);
+      }
+      const ids = (found.policy.sourceDocuments ?? []).slice(0, 20);
+      const docs = await Promise.all(ids.map(async (docId) => {
+        try {
+          const d = await client.documents.get(docId);
+          return { id: d.id, fileName: d.fileName, documentType: d.documentType ?? null, status: d.status, createdAt: d.createdAt };
+        } catch {
+          return { id: docId, fileName: null, documentType: null, status: "unavailable", createdAt: null };
+        }
+      }));
+      if (options.json) {
+        json({ policyId: id, documents: docs });
+        return;
+      }
+      if (docs.length === 0) {
+        info("No source documents are linked to this policy yet. Upload one with: delegance document upload <file>");
+        return;
+      }
+      table(
+        ["Document", "File", "Type", "Status", "Added"],
+        docs.map((d) => [d.id, d.fileName ?? "-", d.documentType ?? "-", d.status, d.createdAt ? formatDate(d.createdAt) : "-"])
+      );
+      info("Download one with: delegance document status <documentId>");
+    } catch (err) {
+      failWith("API error", err);
+    }
+  });
+  policy.command("cancel <policyId>").description("Ask to cancel a policy (owner or admin only); sign now with an emailed code, and your broker checks for a coverage gap first").requiredOption("--effective <date>", "Cancellation date, YYYY-MM-DD (coverage ends at 12:01 AM that day)").requiredOption("--reason <reason>", "replaced | business_closed | sold | not_needed | other").option("--replacement <policyId>", "The policy that replaces this one (required with --reason replaced)").option("--signer-name <name>", "Sign now: your full name").option("--signer-title <title>", "Sign now: your title").option("--attest", "Sign now: you are authorized to bind the named insured").option("--json", "Output as JSON").action(async (policyId, options) => {
+    const sig = signatureFrom(options);
+    if (sig === "partial") {
+      failWith("Missing signer details", new Error("To sign now, pass --signer-name, --signer-title and --attest together."));
+      return;
+    }
+    const client = getClient();
+    const spinner = (0, import_ora8.default)("Requesting cancellation...").start();
+    try {
+      const out = await client.policies.requestCancellation(policyId, {
+        requestedEffectiveDate: options.effective,
+        reason: options.reason,
+        replacementPolicyId: options.replacement
+      });
+      spinner.succeed("Cancellation requested");
+      if (options.json) {
+        json(out);
+        return;
+      }
+      console.log();
+      console.log(`  Request:     ${out.request.id}`);
+      console.log(`  Status:      ${out.request.status.replace(/_/g, " ")}`);
+      console.log(`  Continuity:  ${out.request.continuity.replace(/_/g, " ")}`);
+      console.log();
+      if (sig) {
+        await signWithStepUp(client, out.request.id, sig, void 0, void 0);
+      } else {
+        info(`Sign here: ${out.signatureUrl}`);
+        info(`Or sign from here: delegance policy sign ${out.request.id} --signer-name "..." --signer-title "..." --attest`);
+      }
+      info(`Check progress with "delegance policy cancellation ${out.request.id}"`);
+    } catch (err) {
+      spinner.fail("Could not request the cancellation");
+      failWith("API error", err);
+    }
+  });
+  policy.command("sign <requestId>").description("Sign a cancellation request as an owner or admin; we email you a 6-digit code to confirm").requiredOption("--signer-name <name>", "Your full name").requiredOption("--signer-title <title>", "Your title").requiredOption("--attest", "You are authorized to bind the named insured").option("--step-up <id>", "Finish an earlier attempt: the stepUpId the code email belongs to").option("--code <code>", "The 6-digit code (with --step-up), for scripts").action(async (requestId, options) => {
+    const client = getClient();
+    const sig = signatureFrom(options);
+    if (!sig || sig === "partial") {
+      failWith("Missing signer details", new Error("Pass --signer-name, --signer-title and --attest."));
+      return;
+    }
+    try {
+      await signWithStepUp(client, requestId, sig, options.stepUp, options.code);
+    } catch (err) {
+      failWith("Could not sign", err);
+    }
+  });
+  policy.command("cancellation <requestId>").description("Show a cancellation request's status").option("--json", "Output as JSON").action(async (requestId, options) => {
+    const client = getClient();
+    try {
+      const r = await client.policies.getCancellation(requestId);
+      if (options.json) {
+        json(r);
+        return;
+      }
+      console.log(`  Status:      ${r.status.replace(/_/g, " ")}`);
+      console.log(`  Requested:   ${r.requestedEffectiveDate}`);
+      console.log(`  Continuity:  ${r.continuity.replace(/_/g, " ")}`);
+      if (r.confirmationNumber) console.log(`  Confirmed:   ${r.confirmedEffectiveDate} (confirmation ${r.confirmationNumber})`);
+    } catch (err) {
+      failWith("API error", err);
+    }
+  });
+  return policy;
+}
+function signatureFrom(o) {
+  const given = [o.signerName, o.signerTitle, o.attest].filter((v) => v !== void 0 && v !== false).length;
+  if (given === 0) return null;
+  if (given < 3) return "partial";
+  return { signerName: String(o.signerName), signerTitle: String(o.signerTitle), attestAuthority: true };
+}
+async function signWithStepUp(client, requestId, sig, stepUpId, presetCode) {
+  let id = stepUpId;
+  if (!id || !presetCode) {
+    const first = await client.policies.signCancellation(requestId, sig);
+    if (!("stepUpRequired" in first)) {
+      success("Signed. Your broker checks the request and sends it to the carrier.");
+      return;
+    }
+    id = first.stepUpId;
+    info(`We emailed a 6-digit code to ${first.sentTo}. It expires in 10 minutes.`);
+  }
+  let code = presetCode;
+  if (!code) {
+    if (!process.stdin.isTTY) {
+      warn(`No terminal to type the code in. Finish with: delegance policy sign ${requestId} --signer-name "${sig.signerName}" --signer-title "${sig.signerTitle}" --attest --step-up ${id} --code <code>`);
+      return;
+    }
+    const answer = await import_inquirer7.default.prompt([{
+      type: "input",
+      name: "code",
+      message: "Code from your email:",
+      validate: (v) => /^\d{6}$/.test(v.trim()) || "Enter the 6 digits from the email"
+    }]);
+    code = String(answer.code).trim();
+  }
+  await client.policies.signCancellation(requestId, { ...sig, stepUpId: id, code });
+  success("Signed. Your broker checks the request and sends it to the carrier.");
+}
+function formatPolicyStatus(isActive, daysUntilExpiry) {
+  if (!isActive) {
+    return "\u2717 Expired";
+  }
+  if (daysUntilExpiry !== null && daysUntilExpiry !== void 0) {
+    if (daysUntilExpiry <= 7) {
+      return `\u26A0\uFE0F ${daysUntilExpiry}d`;
+    }
+    if (daysUntilExpiry <= 30) {
+      return `\u{1F4C5} ${daysUntilExpiry}d`;
+    }
+  }
+  return "\u2713 Active";
+}
+
+// src/commands/coi.ts
+var import_commander8 = require("commander");
+var import_ora9 = __toESM(require("ora"));
+var import_inquirer8 = __toESM(require("inquirer"));
+function createCOICommand() {
+  const coi = new import_commander8.Command("coi").description("Generate and manage Certificates of Insurance");
+  coi.command("generate").alias("create").description("Generate a Certificate of Insurance").option("-p, --policies <ids...>", "Policy IDs to include").option("-n, --holder-name <name>", "Certificate holder name").option("-a, --holder-address <address>", "Certificate holder address").option("--city <city>", "Certificate holder city").option("--state <state>", "Certificate holder state (2-letter)").option("--zip <zip>", "Certificate holder ZIP").option("-t, --type <type>", "Certificate type (additional_insured, certificate_holder)", "certificate_holder").option("-i, --interactive", "Interactive mode").option("--json", "Output as JSON").action(async (options) => {
+    const client = getClient();
+    let policyIds = options.policies || [];
+    let { holderName } = options;
+    let { holderAddress } = options;
+    let { city } = options;
+    let { state } = options;
+    let { zip } = options;
+    let certificateType = options.type;
+    if (options.interactive || !holderName || policyIds.length === 0) {
+      const policiesSpinner = (0, import_ora9.default)("Fetching active policies...").start();
+      const { policies } = await client.policies.list({ status: "active" });
+      policiesSpinner.stop();
+      if (policies.length === 0) {
+        error("No active policies found");
+        info('Upload policy documents first with "delegance doc upload"');
+        process.exit(1);
+      }
+      const answers = await import_inquirer8.default.prompt([
+        {
+          type: "checkbox",
+          name: "selectedPolicies",
+          message: "Select policies to include:",
+          choices: policies.map((p) => ({
+            name: `${p.carrier} - ${p.policyType || p.name} (${p.policyNumber || "No #"})`,
+            value: p.id,
+            checked: policyIds.includes(p.id)
+          })),
+          validate: (input) => input.length > 0 || "Select at least one policy"
+        },
+        {
+          type: "input",
+          name: "holderName",
+          message: "Certificate holder name:",
+          default: holderName,
+          validate: (input) => input.length >= 2 || "Name must be at least 2 characters"
+        },
+        {
+          type: "input",
+          name: "holderAddress",
+          message: "Certificate holder address:",
+          default: holderAddress
+        },
+        {
+          type: "input",
+          name: "city",
+          message: "City:",
+          default: city
+        },
+        {
+          type: "input",
+          name: "state",
+          message: "State (2-letter):",
+          default: state,
+          validate: (input) => !input || input.length === 2 || "State must be 2 letters (e.g., CA)"
+        },
+        {
+          type: "input",
+          name: "zip",
+          message: "ZIP code:",
+          default: zip
+        },
+        {
+          type: "list",
+          name: "certificateType",
+          message: "Certificate type:",
+          choices: [
+            { name: "Certificate Holder Only", value: "certificate_holder" },
+            { name: "Additional Insured", value: "additional_insured" }
+          ],
+          default: certificateType
+        }
+      ]);
+      policyIds = answers.selectedPolicies;
+      holderName = answers.holderName;
+      holderAddress = answers.holderAddress;
+      city = answers.city;
+      state = answers.state;
+      zip = answers.zip;
+      certificateType = answers.certificateType;
+    }
+    if (!holderName) {
+      error("Certificate holder name is required");
+      process.exit(1);
+    }
+    const spinner = (0, import_ora9.default)("Generating COI...").start();
+    try {
+      const result = await client.coi.generate({
+        policyIds,
+        certificateHolder: {
+          name: holderName,
+          address: holderAddress,
+          city,
+          state,
+          zip
+        },
+        certificateType
+      });
+      spinner.succeed("COI generated successfully!");
+      if (options.json) {
+        json(result);
+      } else {
+        console.log();
+        success(`Certificate of Insurance created for ${holderName}`);
+        console.log();
+        info(`COI ID: ${result.coiId}`);
+        info(`Download URL: ${result.downloadUrl}`);
+        info(`URL expires: ${formatDate(result.expiresAt)}`);
+        console.log();
+        console.log("Policies included:");
+        for (const p of result.policiesIncluded) {
+          console.log(`  - ${p.carrier} (${p.policyType})`);
+        }
+      }
+    } catch (err) {
+      spinner.fail("Failed to generate COI");
+      failWith("API error", err);
+    }
+  });
+  coi.command("list").alias("ls").description("List generated COIs").option("-l, --limit <n>", "Maximum results", "20").option("--json", "Output as JSON").action(async (options) => {
+    const client = getClient();
+    const spinner = (0, import_ora9.default)("Fetching COIs...").start();
+    try {
+      const { cois, count } = await client.coi.list(parseInt(options.limit));
+      spinner.succeed(`Found ${count} COIs`);
+      if (cois.length === 0) {
+        info("No COIs generated yet");
+        info('Generate one with "delegance coi generate --interactive"');
+        return;
+      }
+      if (options.json) {
+        json(cois);
+      } else {
+        console.log();
+        table(
+          ["ID", "Certificate Holder", "Type", "Policies", "Created"],
+          cois.map((c) => [
+            `${c.id.substring(0, 8)}...`,
+            c.certificateHolder,
+            c.certificateType,
+            String(c.policyIds?.length || 0),
+            formatDate(c.createdAt)
+          ])
+        );
+      }
+    } catch (err) {
+      spinner.fail("Failed to fetch COIs");
+      failWith("API error", err);
+    }
+  });
+  return coi;
+}
+
+// src/commands/sov.ts
+var import_commander9 = require("commander");
+var import_ora10 = __toESM(require("ora"));
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+function createSOVCommand() {
+  const sov = new import_commander9.Command("sov").description("Manage Schedules of Values (property schedules)");
+  sov.command("upload <file>").description("Upload a Schedule of Values file").option("-l, --line <line>", "Line of business (property, inland_marine, etc)", "property").option("--effective <date>", "Effective date (YYYY-MM-DD)").option("--expiration <date>", "Expiration date (YYYY-MM-DD)").option("-w, --wait", "Wait for parsing to complete").option("--json", "Output as JSON").action(async (file, options) => {
+    const client = getClient();
+    const filePath = import_path.default.resolve(file);
+    if (!import_fs.default.existsSync(filePath)) {
+      error(`File not found: ${file}`);
+      process.exit(1);
+    }
+    const fileName = import_path.default.basename(filePath);
+    const ext = import_path.default.extname(fileName).toLowerCase();
+    if (![".xlsx", ".xls", ".csv", ".pdf"].includes(ext)) {
+      error("Unsupported file type. Supported: .xlsx, .xls, .csv, .pdf");
+      process.exit(1);
+    }
+    const spinner = (0, import_ora10.default)(`Uploading ${fileName}...`).start();
+    try {
+      const fileBuffer = import_fs.default.readFileSync(filePath);
+      const result = await client.sov.upload({
+        file: fileBuffer,
+        fileName,
+        lineOfBusiness: options.line,
+        effectiveDate: options.effective,
+        expirationDate: options.expiration
+      });
+      spinner.succeed(`SOV uploaded: ${result.sovId}`);
+      if (options.wait) {
+        const parseSpinner = (0, import_ora10.default)("Waiting for parsing...").start();
+        try {
+          const parsed = await client.sov.waitForParsing(result.sovId);
+          if (parsed.status === "error") {
+            parseSpinner.fail("Parsing failed");
+          } else {
+            parseSpinner.succeed(`Parsing complete - ${parsed.totalLocations || 0} locations, TIV: ${formatCurrency(parsed.totalTIV || 0)}`);
+          }
+        } catch (waitErr) {
+          parseSpinner.fail(waitErr.message);
+        }
+      }
+      if (options.json) {
+        json(result);
+      } else {
+        console.log();
+        info(`SOV ID: ${result.sovId}`);
+        info(`Status: ${result.status}`);
+        if (!options.wait) {
+          info('Use "delegance sov status <id>" to check parsing progress');
+        }
+      }
+    } catch (err) {
+      spinner.fail("Failed to upload SOV");
+      failWith("API error", err);
+    }
+  });
+  sov.command("list").alias("ls").description("List uploaded SOVs").option("-s, --status <status>", "Filter by status").option("-l, --limit <n>", "Maximum results", "20").option("--json", "Output as JSON").action(async (options) => {
+    const client = getClient();
+    const spinner = (0, import_ora10.default)("Fetching SOVs...").start();
+    try {
+      const { sovs, count } = await client.sov.list({
+        status: options.status,
+        limit: parseInt(options.limit)
+      });
+      spinner.succeed(`Found ${count} SOVs`);
+      if (sovs.length === 0) {
+        info("No SOVs found");
+        info('Upload one with "delegance sov upload schedule.xlsx"');
+        return;
+      }
+      if (options.json) {
+        json(sovs);
+      } else {
+        console.log();
+        table(
+          ["ID", "File Name", "Status", "Locations", "Total TIV", "Created"],
+          sovs.map((s) => [
+            `${s.id.substring(0, 8)}...`,
+            s.fileName.substring(0, 25) + (s.fileName.length > 25 ? "..." : ""),
+            formatSOVStatus(s.status),
+            s.totalLocations?.toString() || "-",
+            s.totalTIV ? formatCurrency(s.totalTIV) : "-",
+            formatDate(s.createdAt)
+          ])
+        );
+      }
+    } catch (err) {
+      spinner.fail("Failed to fetch SOVs");
+      failWith("API error", err);
+    }
+  });
+  sov.command("status <id>").description("Check SOV status").option("-w, --wait", "Wait for parsing to complete").option("--json", "Output as JSON").action(async (id, options) => {
+    const client = getClient();
+    if (options.wait) {
+      const spinner = (0, import_ora10.default)("Waiting for SOV processing...").start();
+      try {
+        const s = await client.sov.waitForParsing(id);
+        if (s.status === "error") {
+          spinner.fail("SOV processing failed");
+        } else {
+          spinner.succeed("SOV processing complete");
+        }
+        if (options.json) {
+          json(s);
+        } else {
+          showSOVDetails(s);
+        }
+      } catch (err) {
+        spinner.fail(err.message);
+        process.exit(1);
+      }
+    } else {
+      const spinner = (0, import_ora10.default)("Fetching SOV status...").start();
+      try {
+        const { sovs } = await client.sov.list({ limit: 100 });
+        const s = sovs.find((x) => x.id === id);
+        if (!s) {
+          spinner.fail("SOV not found");
+          process.exit(1);
+        }
+        spinner.succeed(`Status: ${formatSOVStatus(s.status)}`);
+        if (options.json) {
+          json(s);
+        } else {
+          showSOVDetails(s);
+        }
+      } catch (err) {
+        spinner.fail("Failed to fetch SOV");
+        failWith("API error", err);
+      }
+    }
+  });
+  return sov;
+}
+function formatSOVStatus(status) {
+  switch (status) {
+    case "parsed":
+    case "validated":
+      return `\u2713 ${status}`;
+    case "parsing":
+    case "uploaded":
+      return `\u25D0 ${status}`;
+    case "error":
+      return "\u2717 error";
+    default:
+      return status;
+  }
+}
+function showSOVDetails(s) {
+  console.log();
+  console.log(`  File:           ${s.fileName}`);
+  console.log(`  Status:         ${formatSOVStatus(s.status)}`);
+  console.log(`  Line:           ${s.lineOfBusiness || "property"}`);
+  if (s.effectiveDate) console.log(`  Effective:      ${formatDate(s.effectiveDate)}`);
+  if (s.expirationDate) console.log(`  Expiration:     ${formatDate(s.expirationDate)}`);
+  if (s.totalLocations) console.log(`  Locations:      ${s.totalLocations}`);
+  if (s.totalTIV) console.log(`  Total TIV:      ${formatCurrency(s.totalTIV)}`);
+  console.log(`  Created:        ${formatDate(s.createdAt)}`);
+}
+
+// src/commands/appetite.ts
+var import_commander10 = require("commander");
+var import_ora11 = __toESM(require("ora"));
+function num(value) {
+  if (value === void 0) return void 0;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : void 0;
+}
+function buildMatchInput(options) {
+  const list = (v) => {
+    if (v === void 0) return void 0;
+    const parts = (Array.isArray(v) ? v : [v]).flatMap((p) => p.split(",")).map((p) => p.trim()).filter(Boolean);
+    return parts.length ? parts : void 0;
+  };
+  return {
+    state: String(options.state ?? "").toUpperCase(),
+    industry: options.industry,
+    businessDescription: options.description,
+    naicsCode: options.naics,
+    sicCode: options.sic,
+    coverageTypes: list(options.coverage),
+    carriers: list(options.carriers),
+    marketSize: options.marketSize,
+    annualRevenue: num(options.revenue),
+    annualPayroll: num(options.payroll),
+    propertyValue: num(options.propertyValue),
+    minFit: options.minFit,
+    topK: num(options.top)
+  };
+}
+function printResult(result) {
+  if (result.carrierResults.length === 0) {
+    warn("No carrier appetite found for this risk");
+  } else {
+    console.log();
+    table(
+      ["Carrier", "Status", "Confidence", "Best class", "Products"],
+      result.carrierResults.map((c) => [
+        c.carrier,
+        c.overallStatus,
+        `${Math.round(c.confidence * 100)}%`,
+        c.bestMatch?.classDescription ?? "-",
+        c.productsAvailable.join(", ")
+      ])
+    );
+  }
+  for (const w of result.warnings) warn(w);
+}
+function createAppetiteCommand() {
+  const appetite = new import_commander10.Command("appetite").description("Check which carriers will write a risk");
+  appetite.command("match").description("Match a business to carrier appetite").requiredOption("-s, --state <state>", "Two-letter state code").option("-i, --industry <industry>", 'Industry, e.g. "bakery"').option("-d, --description <text>", "What the business does").option("--naics <code>", "NAICS code").option("--sic <code>", "SIC code").option("-c, --coverage <types>", "Comma-separated coverage types, e.g. general_liability,workers_comp").option("--carriers <names>", "Comma-separated carriers to limit the match to").option("--market-size <size>", '"Small Business" or "Middle Market"').option("--revenue <usd>", "Annual revenue").option("--payroll <usd>", "Annual payroll").option("--property-value <usd>", "Total property value").option("--min-fit <fit>", "Raise the quality floor: possible or strong").option("--top <n>", "Maximum matches (1-50)").option("--no-wait", "Return the job id instead of waiting for a cold match").option("--timeout <ms>", "How long to wait for a cold match", "120000").option("--json", "Output as JSON").action(async (options) => {
+    const input = buildMatchInput(options);
+    const timeoutMs = positiveInt(options.timeout, "--timeout");
+    if (!input.industry && !input.businessDescription && !input.naicsCode && !input.sicCode) {
+      error("Describe the business");
+      info("Pass one of --industry, --description, --naics, or --sic");
+      process.exit(1);
+    }
+    const client = getClient();
+    const spinner = (0, import_ora11.default)("Matching appetite...").start();
+    try {
+      const start = await client.appetite.match(input);
+      if (start.status === "succeeded") {
+        spinner.succeed("Match ready (cached)");
+        if (options.json) json(start);
+        else printResult(start);
+        return;
+      }
+      if (!options.wait) {
+        spinner.succeed(`Match queued: ${start.jobId}`);
+        if (options.json) json(start);
+        else info(`Check it with "delegance appetite status ${start.jobId}"`);
+        return;
+      }
+      spinner.text = `Matching appetite (about ${start.estimatedSeconds}s)...`;
+      const done = await client.appetite.waitForMatch(start.jobId, { timeoutMs });
+      spinner.succeed("Match ready");
+      if (options.json) json(done);
+      else printResult(done);
+    } catch (err) {
+      spinner.fail("Appetite match failed");
+      failWith("API error", err);
+    }
+  });
+  appetite.command("status <jobId>").description("Check a queued appetite match").option("--json", "Output as JSON").action(async (jobId, options) => {
+    const client = getClient();
+    const spinner = (0, import_ora11.default)("Fetching match...").start();
+    try {
+      const job = await client.appetite.getMatch(jobId);
+      if (job.status === "succeeded") {
+        spinner.succeed("Match ready");
+        if (options.json) json(job);
+        else printResult(job);
+      } else if (job.status === "failed") {
+        spinner.fail(`Match failed: ${job.errorCode}${job.retryable ? " (retryable)" : ""}`);
+        if (options.json) json(job);
+        process.exit(1);
+      } else {
+        spinner.info(`Match ${job.status}`);
+        if (options.json) json(job);
+      }
+    } catch (err) {
+      spinner.fail("Failed to fetch match");
+      failWith("API error", err);
+    }
+  });
+  return appetite;
+}
+
+// src/commands/lead.ts
+var import_commander11 = require("commander");
+var import_ora12 = __toESM(require("ora"));
+function buildLeadInput(options) {
+  const input = {
+    name: options.name ?? "",
+    contactEmail: options.email ?? "",
+    legalName: options.legalName,
+    industry: options.industry,
+    contactPhone: options.phone,
+    website: options.website,
+    companySize: options.size,
+    description: options.description,
+    naicsCode: options.naics,
+    sicCode: options.sic,
+    state: options.state?.toUpperCase(),
+    externalId: options.externalId,
+    source: options.source,
+    notes: options.notes
+  };
+  if (options.street || options.city || options.zip) {
+    input.address = {
+      street: options.street ?? "",
+      suite: options.suite,
+      city: options.city ?? "",
+      state: (options.addressState ?? options.state ?? "").toUpperCase(),
+      zip: options.zip ?? ""
+    };
+  }
+  return input;
+}
+function createLeadCommand() {
+  const lead = new import_commander11.Command("lead").alias("leads").description("Send prospect businesses to Delegance");
+  lead.command("create").description("Create a lead (idempotent on --external-id and contact email)").requiredOption("-n, --name <name>", "Business name").requiredOption("-e, --email <email>", "Contact email").option("--legal-name <name>", "Legal name, if different").option("-i, --industry <industry>", "Industry").option("-p, --phone <phone>", "Contact phone").option("-w, --website <url>", "Website (full URL)").option("--size <size>", "Company size").option("-d, --description <text>", "What the business does").option("--naics <code>", "NAICS code").option("--sic <code>", "SIC code").option("-s, --state <state>", "Two-letter state code").option("--street <street>", "Street address").option("--suite <suite>", "Suite").option("--city <city>", "City").option("--address-state <state>", "Address state (defaults to --state)").option("--zip <zip>", "ZIP code").option("--external-id <id>", "Your id for this lead").option("--source <source>", "Lead source label").option("--notes <notes>", "Notes for the broker").option("--json", "Output as JSON").action(async (options) => {
+    const input = buildLeadInput(options);
+    if (input.address && (!input.address.street || !input.address.city || !input.address.state || !input.address.zip)) {
+      error("An address needs --street, --city, --zip, and a state");
+      process.exit(1);
+    }
+    const client = getClient();
+    const spinner = (0, import_ora12.default)("Creating lead...").start();
+    try {
+      const result = await client.leads.create(input);
+      spinner.succeed(result.message);
+      if (options.json) json(result);
+      else keyValue({ "Company ID": result.companyId });
+    } catch (err) {
+      spinner.fail("Failed to create lead");
+      failWith("API error", err);
+    }
+  });
+  return lead;
+}
+
+// src/commands/knowledge.ts
+var import_commander12 = require("commander");
+var import_ora13 = __toESM(require("ora"));
+var SEARCH_TYPES = ["notecard", "document_chunk"];
+function createKnowledgeCommand() {
+  const knowledge = new import_commander12.Command("knowledge").alias("kb").description("Search notecards and document facts");
+  knowledge.command("search <query...>").description("Search notecards and document text").option("-t, --type <type>", `Limit to one result type (${SEARCH_TYPES.join(", ")})`).option("-l, --limit <n>", "Maximum results", "10").option("--json", "Output as JSON").action(async (queryParts, options) => {
+    const client = getClient();
+    const query = queryParts.join(" ");
+    const spinner = (0, import_ora13.default)("Searching...").start();
+    try {
+      const { data } = await client.knowledge.search({
+        query,
+        types: options.type ? [options.type] : void 0,
+        limit: parseInt(options.limit)
+      });
+      spinner.succeed(`Found ${data.length} results`);
+      if (options.json) {
+        json(data);
+        return;
+      }
+      for (const r of data) {
+        console.log();
+        console.log(`  ${r.title}  (${r.type}, score ${r.score.toFixed(2)})`);
+        if (r.summary) console.log(`    ${r.summary}`);
+        for (const h of r.highlights.slice(0, 2)) console.log(`    > ${h}`);
+      }
+    } catch (err) {
+      spinner.fail("Search failed");
+      failWith("API error", err);
+    }
+  });
+  knowledge.command("notecards").alias("cards").description("List notecards").option("-t, --type <type>", "Filter by template type").option("-l, --limit <n>", "Maximum results", "25").option("--cursor <cursor>", "Page cursor from a previous list").option("--json", "Output as JSON").action(async (options) => {
+    const client = getClient();
+    const spinner = (0, import_ora13.default)("Fetching notecards...").start();
+    try {
+      const { data, pagination } = await client.knowledge.notecards({
+        type: options.type,
+        limit: parseInt(options.limit),
+        cursor: options.cursor
+      });
+      spinner.succeed(`Found ${data.length} notecards`);
+      if (options.json) {
+        json({ data, pagination });
+        return;
+      }
+      if (data.length > 0) {
+        console.log();
+        table(
+          ["ID", "Type", "Title", "Updated"],
+          data.map((n) => [n.id, n.templateType, n.title, formatDate(n.updatedAt ?? n.createdAt)])
+        );
+      }
+      if (pagination.hasMore && pagination.nextCursor) {
+        info(`More: delegance knowledge notecards --cursor ${pagination.nextCursor}`);
+      }
+    } catch (err) {
+      spinner.fail("Failed to list notecards");
+      failWith("API error", err);
+    }
+  });
+  knowledge.command("facts <documentId>").description("Show the structured facts extracted from a document").option("--json", "Output as JSON").action(async (documentId, options) => {
+    const client = getClient();
+    const spinner = (0, import_ora13.default)("Fetching document facts...").start();
+    try {
+      const facts = await client.knowledge.documentFacts(documentId);
+      spinner.stop();
+      if (options.json) {
+        json(facts);
+        return;
+      }
+      header("Document facts");
+      keyValue({ "Carriers": facts.carriers, ...facts.dates });
+      if (facts.policies.length > 0) {
+        console.log();
+        table(
+          ["Type", "Policy #", "Carrier", "Effective", "Expires", "Premium"],
+          facts.policies.map((p) => [
+            p.policyType,
+            p.policyNumber ?? "-",
+            p.carrierName ?? "-",
+            p.effectiveDate ?? "-",
+            p.expirationDate ?? "-",
+            p.premium ? formatCurrency(p.premium) : "-"
+          ])
+        );
+      }
+      if (facts.coverages.length > 0) {
+        console.log();
+        table(
+          ["Coverage", "Limit", "Deductible"],
+          facts.coverages.map((c) => [
+            c.type,
+            c.limit ? formatCurrency(c.limit) : "-",
+            c.deductible ? formatCurrency(c.deductible) : "-"
+          ])
+        );
+      }
+    } catch (err) {
+      spinner.fail("Failed to fetch document facts");
+      failWith("API error", err);
+    }
+  });
+  return knowledge;
+}
+
+// src/commands/onboarding.ts
+var import_commander13 = require("commander");
+var import_ora14 = __toESM(require("ora"));
+var ONBOARDING_STATES = [
+  "created",
+  "awaiting_verification",
+  "documents_pending",
+  "processing",
+  "ready"
+];
+function createOnboardingCommand() {
+  const onboarding = new import_commander13.Command("onboarding").alias("onboard").description("Check account setup and onboarding state");
+  onboarding.command("status").description("Show the setup checklist and the next step").option("--json", "Output as JSON").action(async (options) => {
+    const client = getClient();
+    const spinner = (0, import_ora14.default)("Fetching onboarding status...").start();
+    try {
+      const status = await client.onboarding.status();
+      spinner.stop();
+      if (options.json) {
+        json(status);
+        return;
+      }
+      header("Onboarding");
+      keyValue({
+        "Account": status.account,
+        "Company profile": status.company,
+        "Full profile": status.companyFull,
+        "Billing": status.billing,
+        "Quote ready": status.quoteReady,
+        "Sandbox": status.sandbox
+      });
+      if (status.nextStep) {
+        console.log();
+        info(`Next step: ${status.nextStep.action}`);
+        if (status.nextStep.fields?.length) info(`Missing: ${status.nextStep.fields.join(", ")}`);
+        if (status.nextStep.url) info(status.nextStep.url);
+      }
+    } catch (err) {
+      spinner.fail("Failed to fetch onboarding status");
+      failWith("API error", err);
+    }
+  });
+  onboarding.command("state").description("Show the onboarding state machine position").option("--json", "Output as JSON").action(async (options) => {
+    const client = getClient();
+    const spinner = (0, import_ora14.default)("Fetching onboarding state...").start();
+    try {
+      const state = await client.onboarding.state();
+      spinner.stop();
+      if (options.json) {
+        json(state);
+        return;
+      }
+      header("Onboarding state");
+      keyValue({
+        "State": state.state,
+        "Verified": state.verified,
+        "Verification sent to": state.verification.sentTo,
+        "Documents": `${state.documents.processed}/${state.documents.total} processed`,
+        "Capabilities": state.capabilities
+      });
+    } catch (err) {
+      spinner.fail("Failed to fetch onboarding state");
+      failWith("API error", err);
+    }
+  });
+  onboarding.command("verify").description("Email the account contact a verification link").option("--json", "Output as JSON").action(async (options) => {
+    const client = getClient();
+    const spinner = (0, import_ora14.default)("Requesting verification...").start();
+    try {
+      const result = await client.onboarding.requestVerification();
+      spinner.succeed(`Verification sent to ${result.sentTo}`);
+      if (options.json) json(result);
+      else info('Open the link in that email, then check progress with "delegance onboarding state"');
+    } catch (err) {
+      spinner.fail("Failed to request verification");
+      failWith("API error", err);
+    }
+  });
+  onboarding.command("wait <state>").description(`Wait until onboarding reaches a state (${ONBOARDING_STATES.join(", ")})`).option("--timeout <ms>", "Timeout in milliseconds", "600000").option("--interval <ms>", "Poll interval in milliseconds", "5000").option("--json", "Output as JSON").action(async (target, options) => {
+    if (!ONBOARDING_STATES.includes(target)) {
+      error(`Unknown state "${target}"`);
+      info(`Use one of: ${ONBOARDING_STATES.join(", ")}`);
+      process.exit(1);
+    }
+    const client = getClient();
+    const spinner = (0, import_ora14.default)(`Waiting for ${target}...`).start();
+    try {
+      const state = await client.onboarding.waitForState(target, {
+        timeoutMs: positiveInt(options.timeout, "--timeout"),
+        intervalMs: positiveInt(options.interval, "--interval")
+      });
+      spinner.succeed(`Onboarding reached ${state.state}`);
+      if (options.json) json(state);
+    } catch (err) {
+      spinner.fail(`Did not reach ${target}`);
+      failWith("Wait failed", err);
+    }
+  });
+  return onboarding;
+}
+
+// src/commands/usage.ts
+var import_commander14 = require("commander");
+var import_ora15 = __toESM(require("ora"));
+function isoDay(daysAgo, now = /* @__PURE__ */ new Date()) {
+  const d = new Date(now.getTime() - daysAgo * 24 * 60 * 60 * 1e3);
+  return d.toISOString().slice(0, 10);
+}
+function cents(n) {
+  return `$${(n / 100).toFixed(2)}`;
+}
+function createUsageCommand() {
+  const usage = new import_commander14.Command("usage").description("Show API usage, billing, and rate limits");
+  usage.command("summary").description("Usage for the current billing period").option("--json", "Output as JSON").action(async (options) => {
+    const client = getClient();
+    const spinner = (0, import_ora15.default)("Fetching usage summary...").start();
+    try {
+      const s = await client.usage.summary();
+      spinner.stop();
+      if (options.json) {
+        json(s);
+        return;
+      }
+      header(`Usage for ${s.period}`);
+      keyValue({
+        "Plan": s.plan,
+        "Status": s.status,
+        "Overage": cents(s.totalOverageCents),
+        "As of": formatDate(s.asOf)
+      });
+      const meters = Object.entries(s.meters);
+      if (meters.length > 0) {
+        console.log();
+        table(
+          ["Meter", "Used", "Included", "Overage", "Overage cost"],
+          meters.map(([name, m]) => [name, m.used, m.included, m.overage, cents(m.overageCostCents)])
+        );
+      }
+    } catch (err) {
+      spinner.fail("Failed to fetch usage summary");
+      failWith("API error", err);
+    }
+  });
+  usage.command("daily").description("Daily metered usage (default: the last 30 days)").option("--from <date>", "Start date, YYYY-MM-DD (inclusive)").option("--to <date>", "End date, YYYY-MM-DD (inclusive)").option("-m, --meter <meter>", "Only this meter").option("-g, --group-by <group>", "Aggregate by day or meter").option("--json", "Output as JSON").action(async (options) => {
+    const client = getClient();
+    const spinner = (0, import_ora15.default)("Fetching daily usage...").start();
+    try {
+      const { data } = await client.usage.daily({
+        from: options.from ?? isoDay(29),
+        to: options.to ?? isoDay(0),
+        meter: options.meter,
+        groupBy: options.groupBy
+      });
+      spinner.succeed(`${data.length} rows`);
+      if (options.json) {
+        json(data);
+        return;
+      }
+      if (data.length > 0) {
+        console.log();
+        table(["Date", "Meter", "Quantity"], data.map((r) => [r.date, r.meter, r.quantity]));
+      }
+    } catch (err) {
+      spinner.fail("Failed to fetch daily usage");
+      failWith("API error", err);
+    }
+  });
+  usage.command("limits").alias("rate-limits").description("Current rate-limit window").option("--json", "Output as JSON").action(async (options) => {
+    const client = getClient();
+    const spinner = (0, import_ora15.default)("Fetching rate limits...").start();
+    try {
+      const r = await client.usage.rateLimits();
+      spinner.stop();
+      if (options.json) {
+        json(r);
+        return;
+      }
+      header("Rate limits");
+      keyValue({
+        "Per minute": r.requestsPerMinute,
+        "Remaining": r.remaining,
+        "Resets at": formatDate(r.resetsAt)
+      });
+    } catch (err) {
+      spinner.fail("Failed to fetch rate limits");
+      failWith("API error", err);
+    }
+  });
+  return usage;
+}
+
+// src/commands/keys.ts
+var import_commander15 = require("commander");
+var import_ora16 = __toESM(require("ora"));
+var import_crypto3 = require("crypto");
+var import_sdk6 = require("@delegance/sdk");
+var KEYS_PORTAL_URL = `${PORTAL_URL}/portal/settings/api-keys`;
+function parseScopes(raw) {
+  const parts = (Array.isArray(raw) ? raw : [raw ?? "read,write"]).flatMap((p) => p.split(/[\s,]+/)).map((p) => p.trim()).filter(Boolean);
+  const unknown = parts.filter((p) => !import_sdk6.API_KEY_SCOPES.includes(p));
+  if (unknown.length > 0) {
+    throw new Error(`Unknown scope(s): ${unknown.join(", ")}. Allowed: ${import_sdk6.API_KEY_SCOPES.join(", ")}`);
+  }
+  return Array.from(new Set(parts));
+}
+function replacementExpiryDays(expiresAt, now = /* @__PURE__ */ new Date()) {
+  if (!expiresAt) return void 0;
+  const ms = new Date(expiresAt).getTime() - now.getTime();
+  if (!Number.isFinite(ms)) throw new Error(`Cannot read the old key's expiry "${expiresAt}"; not rotating`);
+  const days = Math.ceil(ms / (24 * 60 * 60 * 1e3));
+  return Math.min(365, Math.max(1, days));
+}
+function printCreatedKey(created) {
+  success("API key created");
+  console.log();
+  keyValue({
+    "ID": created.id,
+    "Name": created.name,
+    "Scopes": created.scopes,
+    "Expires": created.expiresAt ? formatDate(created.expiresAt) : "never"
+  });
+  console.log();
+  warn("Save this key now. It is shown once and cannot be retrieved again:");
+  console.log(`  ${created.key}`);
+}
+function createKeysCommand() {
+  const keys = new import_commander15.Command("keys").alias("api-keys").description("Manage API keys");
+  keys.command("list").alias("ls").description("List API keys for your company").option("-l, --limit <n>", "Maximum results", "50").option("--cursor <cursor>", "Page cursor from a previous list").option("--json", "Output as JSON").action(async (options) => {
+    const client = getClient();
+    const spinner = (0, import_ora16.default)("Fetching API keys...").start();
+    try {
+      const { data, pagination } = await client.apiKeys.list({
+        limit: parseInt(options.limit),
+        cursor: options.cursor
+      });
+      spinner.succeed(`Found ${data.length} keys`);
+      if (options.json) {
+        json({ data, pagination });
+        return;
+      }
+      if (data.length === 0) return;
+      console.log();
+      table(
+        ["ID", "Name", "Prefix", "Scopes", "Active", "Last used", "Expires"],
+        data.map((k) => [
+          k.id,
+          k.name,
+          k.prefix,
+          k.scopes.join(","),
+          k.isActive ? "yes" : "no",
+          k.lastUsedAt ? formatDate(k.lastUsedAt) : "-",
+          k.expiresAt ? formatDate(k.expiresAt) : "-"
+        ])
+      );
+      if (pagination?.hasMore && pagination.nextCursor) {
+        info(`More keys: delegance keys list --cursor ${pagination.nextCursor}`);
+      }
+    } catch (err) {
+      spinner.fail("Failed to list API keys");
+      failWith("API error", err);
+    }
+  });
+  keys.command("create <name>").description("Create an API key (needs a key with the admin scope)").option("-s, --scopes <scopes>", `Comma-separated scopes (${import_sdk6.API_KEY_SCOPES.join(", ")})`, "read,write").option("-e, --expires-in-days <days>", "Expire the key after N days (1-365)").option("--json", "Output as JSON").action(async (name, options) => {
+    let scopes;
+    try {
+      scopes = parseScopes(options.scopes);
+    } catch (err) {
+      error(err.message);
+      process.exit(1);
+    }
+    const client = getClient();
+    const spinner = (0, import_ora16.default)("Creating API key...").start();
+    try {
+      const created = await client.apiKeys.create(
+        {
+          name,
+          scopes,
+          expiresInDays: options.expiresInDays ? parseInt(options.expiresInDays) : void 0
+        },
+        { idempotencyKey: (0, import_crypto3.randomUUID)() }
+      );
+      spinner.stop();
+      if (options.json) {
+        json(created);
+      } else {
+        printCreatedKey(created);
+      }
+    } catch (err) {
+      spinner.fail("Failed to create API key");
+      failWith("API error", err);
+    }
+  });
+  keys.command("rotate <keyId>").description("Create a replacement key with the same name and scopes").option("--json", "Output as JSON").action(async (keyId, options) => {
+    const client = getClient();
+    const spinner = (0, import_ora16.default)("Looking up key...").start();
+    try {
+      let cursor;
+      let current2;
+      do {
+        const page = await client.apiKeys.list({ limit: 100, cursor });
+        current2 = page.data.find((k) => k.id === keyId);
+        cursor = page.pagination?.hasMore ? page.pagination.nextCursor : void 0;
+      } while (!current2 && cursor);
+      if (!current2) {
+        spinner.fail(`No API key with id ${keyId}`);
+        process.exit(1);
+      }
+      spinner.text = "Creating replacement key...";
+      const created = await client.apiKeys.create(
+        {
+          name: `${current2.name} (rotated)`,
+          scopes: current2.scopes,
+          expiresInDays: replacementExpiryDays(current2.expiresAt)
+        },
+        { idempotencyKey: (0, import_crypto3.randomUUID)() }
+      );
+      spinner.stop();
+      if (options.json) {
+        json({ newKey: created, oldKeyId: keyId, oldKeyStillActive: true });
+        return;
+      }
+      printCreatedKey(created);
+      console.log();
+      warn(`The old key ${current2.prefix} is still active.`);
+      info(`Switch your integrations to the new key, then revoke the old one at ${KEYS_PORTAL_URL}`);
+    } catch (err) {
+      spinner.fail("Failed to rotate API key");
+      failWith("API error", err);
+    }
+  });
+  keys.command("revoke <keyId>").description("Revoke an API key").action(async (keyId) => {
+    const client = getClient();
+    const spinner = (0, import_ora16.default)("Revoking API key...").start();
+    try {
+      await client.apiKeys.revoke(keyId);
+      spinner.succeed("API key revoked");
+    } catch (err) {
+      spinner.fail("Failed to revoke API key");
+      if (err instanceof import_sdk6.AuthenticationError) {
+        error("Revoking a key needs a signed-in portal session today");
+        info(`Revoke it at ${KEYS_PORTAL_URL}`);
+        process.exit(1);
+      }
+      failWith("API error", err);
+    }
+  });
+  return keys;
+}
+
+// src/commands/config.ts
+var import_commander16 = require("commander");
+var import_inquirer9 = __toESM(require("inquirer"));
+function createConfigCommand() {
+  const config2 = new import_commander16.Command("config").description("Manage CLI configuration");
+  config2.command("show").alias("list").description("Show current configuration").option("--json", "Output as JSON").action((options) => {
+    const currentConfig = getConfig();
+    const apiKey = getApiKey();
+    const baseUrl = getBaseUrl();
+    if (options.json) {
+      console.log(JSON.stringify({
+        baseUrl,
+        defaultCompany: currentConfig.get("defaultCompany"),
+        hasApiKey: !!apiKey,
+        apiKeyPrefix: apiKey ? apiKey.substring(0, 12) + "..." : null
+      }, null, 2));
+    } else {
+      header("Current Configuration");
+      console.log();
+      keyValue("Base URL", baseUrl);
+      keyValue("API Key", apiKey ? apiKey.substring(0, 12) + "..." + apiKey.slice(-4) : "Not set");
+      keyValue("Default Company", currentConfig.get("defaultCompany") || "Not set");
+      console.log();
+      info(`Config file: ${currentConfig.path}`);
+    }
+  });
+  config2.command("set <key> <value>").description("Set a configuration value").action((key, value) => {
+    const currentConfig = getConfig();
+    const validKeys = ["baseUrl", "defaultCompany"];
+    if (!validKeys.includes(key)) {
+      error(`Unknown config key: ${key}`);
+      info(`Valid keys: ${validKeys.join(", ")}`);
+      process.exit(1);
+    }
+    currentConfig.set(key, value);
+    success(`Set ${key} = ${value}`);
+  });
+  config2.command("get <key>").description("Get a configuration value").action((key) => {
+    const currentConfig = getConfig();
+    const value = currentConfig.get(key);
+    if (value === void 0) {
+      info(`${key} is not set`);
+    } else {
+      console.log(value);
+    }
+  });
+  config2.command("reset").description("Reset all configuration to defaults").option("-f, --force", "Skip confirmation").action(async (options) => {
+    if (!options.force) {
+      const { confirm } = await import_inquirer9.default.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: "This will reset all configuration. Continue?",
+          default: false
+        }
+      ]);
+      if (!confirm) {
+        info("Cancelled");
+        return;
+      }
+    }
+    const currentConfig = getConfig();
+    currentConfig.clear();
+    clearCredentials();
+    success("Configuration reset to defaults");
+    info('You will need to run "delegance auth login" again');
+  });
+  config2.command("env").description("Show environment information").action(() => {
+    header("Environment");
+    console.log();
+    keyValue("Node.js", process.version);
+    keyValue("Platform", process.platform);
+    keyValue("Arch", process.arch);
+    keyValue("CWD", process.cwd());
+    console.log();
+    header("Environment Variables");
+    console.log();
+    keyValue("DELEGANCE_API_KEY", process.env.DELEGANCE_API_KEY ? "(set)" : "(not set)");
+    keyValue("DELEGANCE_BASE_URL", process.env.DELEGANCE_BASE_URL || "(not set)");
+    keyValue("DEBUG", process.env.DEBUG || "(not set)");
+  });
+  config2.command("profiles").description("List available profiles").action(() => {
+    const currentConfig = getConfig();
+    const profiles = currentConfig.get("profiles") || {};
+    const activeProfile = currentConfig.get("activeProfile") || "default";
+    header("Profiles");
+    console.log();
+    if (Object.keys(profiles).length === 0) {
+      info("No profiles configured");
+      info("Profiles allow you to switch between different accounts/environments");
+      console.log();
+      info("Example: delegance config set-profile production --url https://portal.delegancebrokerage.com");
+    } else {
+      for (const [name, profile] of Object.entries(profiles)) {
+        const isActive = name === activeProfile;
+        console.log(`  ${isActive ? "\u2192 " : "  "}${name}${isActive ? " (active)" : ""}`);
+        if (typeof profile === "object" && profile !== null) {
+          console.log(`      URL: ${profile.baseUrl || "default"}`);
+        }
+      }
+    }
+  });
+  config2.command("use-profile <name>").description("Switch to a profile").action((name) => {
+    const currentConfig = getConfig();
+    const profiles = currentConfig.get("profiles") || {};
+    if (!profiles[name] && name !== "default") {
+      error(`Profile "${name}" not found`);
+      info("Create it with: delegance config set-profile <name> --url <base-url>");
+      process.exit(1);
+    }
+    currentConfig.set("activeProfile", name);
+    success(`Switched to profile: ${name}`);
+    if (name !== "default" && profiles[name]?.baseUrl) {
+      info(`Base URL: ${profiles[name].baseUrl}`);
+    }
+  });
+  config2.command("set-profile <name>").description("Create or update a profile").option("-u, --url <url>", "Base URL for this profile").action((name, options) => {
+    const currentConfig = getConfig();
+    const profiles = currentConfig.get("profiles") || {};
+    profiles[name] = {
+      ...profiles[name],
+      baseUrl: options.url || profiles[name]?.baseUrl
+    };
+    currentConfig.set("profiles", profiles);
+    success(`Profile "${name}" ${profiles[name] ? "updated" : "created"}`);
+    if (options.url) {
+      info(`Base URL: ${options.url}`);
+    }
+  });
+  return config2;
+}
+
+// src/program.ts
+var import_commander19 = require("commander");
+
+// src/commands/feedback.ts
+var import_commander17 = require("commander");
+var import_inquirer10 = __toESM(require("inquirer"));
+var import_sdk7 = require("@delegance/sdk");
+var TYPES = ["bug", "idea", "question"];
+var MESSAGE_MAX = 500;
+var USAGE = 'delegance feedback "what happened" [--type bug|idea|question] [--include-last]';
+function feedbackInputMode(o) {
+  if (o.message && o.message.trim()) return "given";
+  return o.isTTY ? "prompt" : "usage_error";
+}
+function buildFeedbackContext(last) {
+  const ctx = {};
+  if (last) {
+    ctx.command = last.command;
+    ctx.exitCode = last.exitCode;
+    if (last.traceId) ctx.traceId = last.traceId;
+    ctx.at = last.at;
+  }
+  ctx.cliVersion = CLI_VERSION;
+  ctx.sdkVersion = import_sdk7.SDK_VERSION;
+  return ctx;
+}
+function usageError(message) {
+  error(message);
+  info(`Usage: ${USAGE}`);
+  process.exit(2);
+}
+function createFeedbackCommand() {
+  return new import_commander17.Command("feedback").alias("bug").description("Report a bug, an idea, or a question to Delegance").argument("[message...]", "What happened (asked for when left out on a terminal)").option("-t, --type <type>", "bug, idea, or question", "bug").option("--include-last", "Attach the last command name, exit code, trace id, and CLI/SDK versions (never its arguments)").option("--json", "Output as JSON").action(async (words, options) => {
+    const type = String(options.type ?? "bug").toLowerCase();
+    if (!TYPES.includes(type)) usageError(`--type must be bug, idea, or question, got "${options.type}"`);
+    let message = (words ?? []).join(" ").trim();
+    const mode = feedbackInputMode({ message, isTTY: Boolean(process.stdin.isTTY && process.stdout.isTTY) });
+    if (mode === "usage_error") usageError(`Say what happened: ${USAGE}`);
+    if (mode === "prompt") {
+      const answer = await import_inquirer10.default.prompt([
+        { type: "input", name: "message", message: type === "bug" ? "What went wrong?" : "What would you like to tell us?" }
+      ]);
+      message = String(answer.message ?? "").trim();
+      if (!message) usageError("Nothing sent: the message was empty.");
+    }
+    if (message.length > MESSAGE_MAX) usageError(`Keep the message to ${MESSAGE_MAX} characters or fewer (it has ${message.length}).`);
+    const context = options.includeLast ? buildFeedbackContext(readLastCommand()) : void 0;
+    try {
+      const { id } = await getClient().feedback.submit({ type, message, context });
+      if (options.json) {
+        json({ id });
+        return;
+      }
+      success(`Sent. Reference: ${id}`);
+    } catch (err) {
+      failWith("Could not send the report", err);
+    }
+  });
+}
+
+// src/commands/commerce.ts
+var import_commander18 = require("commander");
+var fs7 = __toESM(require("fs"));
+var import_inquirer11 = __toESM(require("inquirer"));
+var import_ora17 = __toESM(require("ora"));
+var import_sdk8 = require("@delegance/sdk");
+function formatCents(cents2, currency = "usd") {
+  return currency.toLowerCase() === "usd" ? formatCurrency(cents2 / 100) : `${(cents2 / 100).toFixed(2)} ${currency.toUpperCase()}`;
+}
+function readJsonFile(file) {
+  try {
+    const parsed = JSON.parse(fs7.readFileSync(file, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("expected a JSON object");
+    return parsed;
+  } catch (e) {
+    error(`Could not read ${file}: ${e.message}`);
+    process.exit(1);
+  }
+}
+function describeBindResult(r) {
+  const lines = [];
+  if (r.tier === "A" && r.checkoutUrl) {
+    lines.push(`Checkout opened with ${r.carrierName}. Pay on their page to bind:`);
+    lines.push(r.checkoutUrl);
+    lines.push("You'll get the policy by email; we attach it to your account automatically. It is not bound until the carrier confirms.");
+    return lines;
+  }
+  if (r.tier === "C" && r.reasons?.length) lines.push(`A broker reviews this one (${r.reasons.map((x) => x.replace(/_/g, " ")).join(", ")}).`);
+  lines.push(r.next);
+  return lines;
+}
+async function askCode() {
+  if (!process.stdin.isTTY) return null;
+  const answer = await import_inquirer11.default.prompt([{
+    type: "input",
+    name: "code",
+    message: "Code from your email:",
+    validate: (v) => /^\d{6}$/.test(v.trim()) || "Enter the 6 digits from the email"
+  }]);
+  return String(answer.code).trim();
+}
+function createBindCommand() {
+  return new import_commander18.Command("bind").description('Bind one offer from "quote status": the carrier checkout when the carrier offers it, otherwise a broker review').argument("<submissionId>", "The quote submission id").argument("<offerId>", "The offer id from the quote table").option("--attest", "Confirm the application answers are accurate (asked interactively when omitted)").option("--step-up <id>", "Finish an earlier attempt: the stepUpId the code email belongs to").option("--code <code>", "The 6-digit code from the email").option("--json", "Output as JSON").action(async (submissionId, offerId, options) => {
+    const client = getClient();
+    let attest = options.attest === true;
+    if (!attest && process.stdin.isTTY && !options.json) {
+      const a = await import_inquirer11.default.prompt([{
+        type: "confirm",
+        name: "ok",
+        message: "Are the answers on this application accurate? Binding relies on them.",
+        default: false
+      }]);
+      attest = a.ok === true;
+      if (!attest) {
+        warn('Not bound. Fix the answers with "delegance quote start", then bind again.');
+        return;
+      }
+    }
+    const spinner = options.json ? null : (0, import_ora17.default)("Requesting the bind...").start();
+    try {
+      let r = await client.instantQuotes.bindWithStepUp(submissionId, offerId, {
+        ...attest ? { attest: true } : {},
+        ...options.stepUp && options.code ? { stepUpId: String(options.stepUp), code: String(options.code) } : {}
+      });
+      spinner?.stop();
+      if ("stepUpRequired" in r) {
+        const stepUpId = r.stepUpId;
+        info(`We emailed a 6-digit code to ${r.sentTo}. It expires in 10 minutes.`);
+        const code = options.code ? String(options.code) : await askCode();
+        if (!code) {
+          warn(`Finish with: delegance bind ${submissionId} ${offerId} --attest --step-up ${stepUpId} --code <code>`);
+          return;
+        }
+        r = await client.instantQuotes.bindWithStepUp(submissionId, offerId, { ...attest ? { attest: true } : {}, stepUpId, code });
+        if ("stepUpRequired" in r) {
+          error("The code was not accepted. Run the command again for a new code.");
+          process.exit(1);
+        }
+      }
+      if (options.json) {
+        json(r);
+        return;
+      }
+      if (r.existing) warn(`A bind for this coverage is already open (${r.carrierName}). Showing it.`);
+      else if (r.tier !== "A") success(`Bind requested: ${r.carrierName} ${r.coverage}${r.premium === null ? "" : ` at ${formatCurrency(r.premium)}/yr`}`);
+      keyValue({ "Bind request": r.bindRequestId, Status: r.status });
+      describeBindResult(r).forEach((l) => info(l));
+    } catch (err) {
+      spinner?.stop();
+      if (err instanceof import_sdk8.DeleganceError && [400, 403, 409].includes(err.statusCode ?? 0)) {
+        error(err.message);
+        process.exit(1);
+      }
+      failWith("Bind failed", err);
+    }
+  });
+}
+function summarizeBilling(payments) {
+  let openCents = 0;
+  let paidCents = 0;
+  let openCount = 0;
+  for (const p of payments) {
+    if (p.payable) {
+      openCents += p.amount;
+      openCount += 1;
+    } else if (["paid", "succeeded", "captured"].includes(p.status)) paidCents += p.amount;
+  }
+  return { openCents, paidCents, openCount };
+}
+function createBillingCommand() {
+  return new import_commander18.Command("billing").description("What you owe and what you paid: every premium payment request on the account").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const payments = await getClient().payments.list();
+      const sum = summarizeBilling(payments);
+      if (options.json) {
+        json({ ...sum, payments });
+        return;
+      }
+      if (payments.length === 0) {
+        info("No payment requests yet. Carrier-billed policies are invoiced by the carrier directly.");
+        return;
+      }
+      table(
+        ["Payment", "Amount", "Status", "Due", "For"],
+        payments.map((p) => [p.id, formatCents(p.amount, p.currency), p.status, p.dueDate ? formatDate(p.dueDate) : "-", p.description ?? "-"])
+      );
+      keyValue({ "Open": `${formatCents(sum.openCents)} (${sum.openCount})`, "Paid": formatCents(sum.paidCents) });
+      if (sum.openCount > 0) info("Pay one with: delegance pay <paymentId>");
+    } catch (err) {
+      failWith("API error", err);
+    }
+  });
+}
+function createPayCommand() {
+  return new import_commander18.Command("pay").description("Pay a premium: list payment requests, or get a checkout link for one").argument("[paymentId]", "Payment request to pay (omit to list them)").option("--json", "Output as JSON").action(async (paymentId, options) => {
+    const client = getClient();
+    try {
+      if (!paymentId) {
+        const payments = await client.payments.list();
+        if (options.json) {
+          json(payments);
+          return;
+        }
+        if (payments.length === 0) {
+          info("No payment requests yet. One appears after a broker reviews your bind.");
+          return;
+        }
+        table(
+          ["Payment id", "Amount", "Description", "Status", "Due"],
+          payments.map((p) => [p.id, formatCents(p.amount, p.currency), p.description ?? "", p.payable ? `${p.status} (payable)` : p.status, p.dueDate ? formatDate(p.dueDate) : "-"])
+        );
+        const next = payments.find((p) => p.payable);
+        if (next) info(`Pay it: delegance pay ${next.id}`);
+        return;
+      }
+      const { checkoutUrl } = await client.payments.checkout(paymentId);
+      if (options.json) json({ checkoutUrl });
+      else {
+        success("Open this link to pay with Stripe:");
+        console.log(checkoutUrl);
+      }
+    } catch (err) {
+      failWith("Payment failed", err);
+    }
+  });
+}
+function shellQuote(v) {
+  return `'${v.replace(/'/g, `'\\''`)}'`;
+}
+function bondStartLines(r, ctx = {}) {
+  const out = [];
+  const str = (v) => v === void 0 || v === null ? "" : String(v);
+  if (r.session_id) {
+    out.push(`Bond quote started: ${str(r.session_id)}${r.bond_name ? ` (${str(r.bond_name)})` : ""}`);
+    const qs = Array.isArray(r.questions) ? r.questions : [];
+    if (qs.length) {
+      out.push("Questions (answer by key in a JSON file):");
+      qs.forEach((q) => {
+        const opts = Array.isArray(q.options) && q.options.length ? ` [${q.options.map(str).join(" | ")}]` : "";
+        out.push(`  ${str(q.key)}: ${str(q.label)}${q.required ? " (required)" : ""}${opts}`);
+      });
+    }
+    out.push(`Answer with: delegance bond answer ${str(r.session_id)} --answers answers.json`);
+    return out;
+  }
+  if (Array.isArray(r.candidates) && r.candidates.length) {
+    out.push("That name fits more than one bond. Rerun with the exact name:");
+    const rawState = (ctx.state ?? "").trim();
+    const state = !rawState ? null : /^[A-Za-z]{2}$/.test(rawState) ? rawState.toUpperCase() : shellQuote(rawState);
+    r.candidates.forEach((name) => out.push(state ? `  delegance bond quote --state ${state} --bond ${shellQuote(str(name))}` : `  --bond ${shellQuote(str(name))}`));
+    return out;
+  }
+  if (r.needsAmount) {
+    out.push("This is a contract bond. Rerun with the bond amount in dollars: --bond-amount <amount>");
+    return out;
+  }
+  if (r.route === "underwriting_submission") {
+    out.push(`At ${str(r.amount)} this is above the online limit of ${str(r.instantIssueLimit)}.`);
+    out.push("A licensed Delegance broker submits it to surety markets. Underwriting will need:");
+    (Array.isArray(r.submissionRequirements) ? r.submissionRequirements : []).forEach((item) => out.push(`  - ${str(item)}`));
+    return out;
+  }
+  if (r.applyUrl) {
+    out.push("This bond is not quoted in the terminal yet. Apply with the surety directly:");
+    out.push(`  ${str(r.applyUrl)}`);
+    return out;
+  }
+  const matches = Array.isArray(r.matches) ? r.matches : [];
+  if (matches.length) {
+    out.push("Bonds that match, with their apply links:");
+    matches.forEach((m) => out.push(`  ${str(m.name)}
+    ${str(m.applyUrl)}`));
+    return out;
+  }
+  out.push("No bond matched that name. Browse every bond by state:");
+  out.push(`  ${str(r.filteredUrl ?? r.stateUrl ?? r.finderUrl)}`);
+  return out;
+}
+function createBondCommand() {
+  const bond = new import_commander18.Command("bond").alias("bonds").description("Surety bond quotes");
+  bond.command("quote").description("Start a bond quote and list its questions").requiredOption("-s, --state <state>", "Two-letter state, e.g. TX").option("-b, --bond <name>", 'Bond name or keyword, e.g. "notary", "contractor license"').option("--entity-id <id>", "Exact bond id, when you have it").option("--contract-amount <amount>", "Contract value, for contract bonds").option("--bond-amount <amount>", "Bond penal sum").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const r = await getClient().bonds.start({
+        state: String(options.state).toUpperCase(),
+        bondName: options.bond,
+        entityId: options.entityId,
+        contractAmount: options.contractAmount,
+        bondAmount: options.bondAmount
+      });
+      if (options.json) {
+        json(r);
+        return;
+      }
+      bondStartLines(r, { state: String(options.state).toUpperCase() }).forEach((line) => console.log(line));
+    } catch (err) {
+      failWith("Bond quote failed", err);
+    }
+  });
+  bond.command("answer <sessionId>").description("Submit answers for a bond quote (starts pricing when complete)").requiredOption("-a, --answers <file>", "JSON file of answers keyed by question id").option("--json", "Output as JSON").action(async (sessionId, options) => {
+    try {
+      const r = await getClient().bonds.answer(sessionId, readJsonFile(options.answers));
+      if (options.json) json(r);
+      else {
+        console.log(JSON.stringify(r, null, 2));
+        info(`Check it: delegance bond status ${sessionId}`);
+      }
+    } catch (err) {
+      failWith("Could not submit the answers", err);
+    }
+  });
+  bond.command("status <sessionId>").description("Bond premium and the surety apply link").option("--json", "Output as JSON").action(async (sessionId, options) => {
+    try {
+      const r = await getClient().bonds.status(sessionId);
+      if (options.json) json(r);
+      else {
+        console.log(JSON.stringify(r, null, 2));
+        if (r.apply_url) info(`Buy it on the surety's page: ${String(r.apply_url)}`);
+      }
+    } catch (err) {
+      failWith("Could not read the bond quote", err);
+    }
+  });
+  return bond;
+}
+function createClaimCommand() {
+  const claim = new import_commander18.Command("claim").alias("claims").description("File and track claims");
+  claim.command("file").description("File a claim. The first time, accept the claims disclaimer in the portal").option("-d, --description <text>", "What happened (visible in shell history; prefer --description-file)").option("--description-file <file>", "Read what happened from a file, or - for stdin").option("--date <yyyy-mm-dd>", "When it happened").option("--policy <id>", "Policy id, if you know it").option("--json", "Output as JSON").action(async (options) => {
+    let description = options.description;
+    if (options.descriptionFile) {
+      try {
+        description = fs7.readFileSync(options.descriptionFile === "-" ? 0 : options.descriptionFile, "utf8").trim();
+      } catch (e) {
+        error(`Could not read ${options.descriptionFile}: ${e.message}`);
+        process.exit(1);
+      }
+    }
+    if (!description) {
+      error("Describe what happened with --description-file <file> (or --description).");
+      process.exit(1);
+    }
+    try {
+      const r = await getClient().claims.file({ description, incidentDate: options.date, policyId: options.policy });
+      if (options.json) {
+        json(r);
+        return;
+      }
+      success(r.message);
+      keyValue({ Claim: r.claimId, Status: r.status, Portal: r.portalUrl });
+    } catch (err) {
+      if (err instanceof import_sdk8.DeleganceError && err.reason === "gate_not_acknowledged") {
+        error("Accept the claims disclaimer once in the portal, then file again. It cannot be accepted for you.");
+        info(String(err.body?.portalUrl ?? ""));
+        process.exit(1);
+      }
+      failWith("Could not file the claim", err);
+    }
+  });
+  claim.command("list").description("List claims").option("-s, --status <status>", "open, in_progress, or resolved").option("-l, --limit <n>", "Maximum results", "20").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const claims = await getClient().claims.list({ status: options.status, limit: Number(options.limit) || 20 });
+      if (options.json) json(claims);
+      else if (claims.length === 0) info("No claims.");
+      else table(["Claim", "Status", "Incident", "Summary", "Last activity"], claims.map((c) => [c.claimId, c.status, c.incidentDate ?? "-", c.summary ?? "", formatDate(c.lastActivityAt)]));
+    } catch (err) {
+      failWith("Could not list claims", err);
+    }
+  });
+  claim.command("status <claimId>").description("One claim").option("--json", "Output as JSON").action(async (claimId, options) => {
+    try {
+      const c = await getClient().claims.get(claimId);
+      if (options.json) json(c);
+      else keyValue({ Claim: c.claimId, Status: c.status, Incident: c.incidentDate ?? "-", Summary: c.summary ?? "", "Last activity": formatDate(c.lastActivityAt) });
+    } catch (err) {
+      failWith("Could not read the claim", err);
+    }
+  });
+  return claim;
+}
+
+// src/program.ts
+function createProgram() {
+  const program = new import_commander19.Command();
+  program.name("delegance").description("CLI for the Delegance Brokerage platform").version(CLI_VERSION).enablePositionalOptions().option("-v, --verbose", "Enable verbose output").option("--json", "Output in JSON format").hook("preAction", () => {
+    migrateLegacyConfigKey();
+  });
+  program.addCommand(createSignupCommand());
+  program.addCommand(createVerifyCommand());
+  program.addCommand(createAuthCommand());
+  program.addCommand(createCompanyCommand());
+  program.addCommand(createDocumentCommand());
+  program.addCommand(createChatCommand());
+  program.addCommand(createQuoteCommand());
+  program.addCommand(createPolicyCommand());
+  program.addCommand(createCOICommand());
+  program.addCommand(createSOVCommand());
+  program.addCommand(createAppetiteCommand());
+  program.addCommand(createLeadCommand());
+  program.addCommand(createKnowledgeCommand());
+  program.addCommand(createOnboardingCommand());
+  program.addCommand(createUsageCommand());
+  program.addCommand(createKeysCommand());
+  program.addCommand(createBindCommand());
+  program.addCommand(createPayCommand());
+  program.addCommand(createBillingCommand());
+  program.addCommand(createBondCommand());
+  program.addCommand(createClaimCommand());
+  program.addCommand(createFeedbackCommand());
+  program.addCommand(createConfigCommand());
+  return program;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLI_VERSION,
+  clearConfig,
+  clearCredentials,
+  createAppetiteCommand,
+  createAuthCommand,
+  createCOICommand,
+  createChatCommand,
+  createCompanyCommand,
+  createConfigCommand,
+  createDocumentCommand,
+  createKeysCommand,
+  createKnowledgeCommand,
+  createLeadCommand,
+  createOnboardingCommand,
+  createPolicyCommand,
+  createProgram,
+  createQuoteCommand,
+  createSOVCommand,
+  createUsageCommand,
+  getAllConfig,
+  getApiKey,
+  getBaseUrl,
+  getConfig,
+  getConfigPath,
+  isAuthenticated,
+  maskApiKey,
+  output,
+  setConfig,
+  storeApiKey
+});