@duvoai/cli 0.4.1 → 0.5.0

package/dist/bin/duvo.js

@@ -83,8 +83,222 @@ function handleCliError(error) {
 }
 __name(handleCliError, "handleCliError");
 
+// src/output/should-color.ts
+function shouldColor() {
+  if (process.env.NO_COLOR !== void 0 && process.env.NO_COLOR !== "") {
+    return false;
+  }
+  return Boolean(process.stdout.isTTY);
+}
+__name(shouldColor, "shouldColor");
+
+// src/output/colors.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m",
+  orange: "\x1B[38;5;208m",
+  yellow: "\x1B[38;5;178m"
+};
+function wrap(code, text3) {
+  if (!shouldColor()) {
+    return text3;
+  }
+  return `${code}${text3}${ANSI.reset}`;
+}
+__name(wrap, "wrap");
+var green = /* @__PURE__ */ __name((text3) => wrap(ANSI.green, text3), "green");
+var red = /* @__PURE__ */ __name((text3) => wrap(ANSI.red, text3), "red");
+var cyan = /* @__PURE__ */ __name((text3) => wrap(ANSI.cyan, text3), "cyan");
+var bold = /* @__PURE__ */ __name((text3) => wrap(ANSI.bold, text3), "bold");
+var yellow = /* @__PURE__ */ __name((text3) => wrap(ANSI.yellow, text3), "yellow");
+
+// src/output/deprecation-notice.ts
+var DEPRECATION_HEADER = "Deprecation";
+var SUNSET_HEADER = "Sunset";
+var LINK_HEADER = "Link";
+var SUCCESSOR_REL = "successor-version";
+var DEPRECATION_REL = "deprecation";
+var printedKeys = /* @__PURE__ */ new Set();
+function parseDeprecationHeaders(headers) {
+  const deprecationRaw = headers.get(DEPRECATION_HEADER);
+  const sunsetRaw = headers.get(SUNSET_HEADER);
+  const linkRaw = headers.get(LINK_HEADER);
+  const links = linkRaw === null ? [] : parseLinkHeader(linkRaw);
+  const successor = links.find((entry) => entry.rel === SUCCESSOR_REL);
+  const deprecationDoc = links.find((entry) => entry.rel === DEPRECATION_REL);
+  if (deprecationRaw === null && sunsetRaw === null && successor === void 0 && deprecationDoc === void 0) {
+    return null;
+  }
+  const info = { deprecated: true };
+  const deprecatedAt = parseHttpDate(deprecationRaw);
+  if (deprecatedAt !== null) {
+    info.deprecatedAt = deprecatedAt;
+  }
+  const sunsetAt = parseHttpDate(sunsetRaw);
+  if (sunsetAt !== null) {
+    info.sunsetAt = sunsetAt;
+  }
+  if (successor !== void 0) {
+    info.successorUri = successor.uri;
+  }
+  if (deprecationDoc !== void 0) {
+    info.deprecationDocUri = deprecationDoc.uri;
+  }
+  return info;
+}
+__name(parseDeprecationHeaders, "parseDeprecationHeaders");
+function formatDeprecationNotice(info, ctx) {
+  const lines = [yellow(`duvo: \u26A0 ${ctx.method} ${ctx.path} is deprecated`)];
+  if (info.sunsetAt !== void 0) {
+    const now = ctx.now ?? /* @__PURE__ */ new Date();
+    const iso = formatIsoDate(info.sunsetAt);
+    const relative = formatRelativeDays(info.sunsetAt, now);
+    lines.push(yellow(`duvo:   sunset: ${iso} (${relative})`));
+  }
+  const docUri = info.deprecationDocUri ?? info.successorUri;
+  if (docUri !== void 0) {
+    lines.push(yellow(`duvo:   see:    ${docUri}`));
+  }
+  return lines.join("\n");
+}
+__name(formatDeprecationNotice, "formatDeprecationNotice");
+function formatIsoDate(date) {
+  const yyyy = date.getUTCFullYear();
+  const mm = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(date.getUTCDate()).padStart(2, "0");
+  return `${yyyy}-${mm}-${dd}`;
+}
+__name(formatIsoDate, "formatIsoDate");
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+function formatRelativeDays(target, now) {
+  const targetDay = Date.UTC(
+    target.getUTCFullYear(),
+    target.getUTCMonth(),
+    target.getUTCDate()
+  );
+  const nowDay = Date.UTC(
+    now.getUTCFullYear(),
+    now.getUTCMonth(),
+    now.getUTCDate()
+  );
+  const diffDays = Math.round((targetDay - nowDay) / MS_PER_DAY);
+  if (diffDays === 0) {
+    return "today";
+  }
+  if (diffDays === 1) {
+    return "tomorrow";
+  }
+  if (diffDays === -1) {
+    return "yesterday";
+  }
+  if (diffDays > 0) {
+    return `in ${diffDays} days`;
+  }
+  return `${Math.abs(diffDays)} days ago`;
+}
+__name(formatRelativeDays, "formatRelativeDays");
+function printDeprecationNotice(info, ctx) {
+  const dedupKey = `${ctx.method} ${ctx.path}`;
+  if (printedKeys.has(dedupKey)) {
+    return;
+  }
+  printedKeys.add(dedupKey);
+  const stderr = ctx.stderr ?? process.stderr;
+  stderr.write(`${formatDeprecationNotice(info, ctx)}
+`);
+}
+__name(printDeprecationNotice, "printDeprecationNotice");
+function parseHttpDate(raw) {
+  if (raw === null) {
+    return null;
+  }
+  const trimmed = raw.trim();
+  if (trimmed === "" || trimmed === "true") {
+    return null;
+  }
+  const parsed = new Date(trimmed);
+  if (Number.isNaN(parsed.getTime())) {
+    return null;
+  }
+  return parsed;
+}
+__name(parseHttpDate, "parseHttpDate");
+function parseLinkHeader(raw) {
+  const entries = [];
+  for (const segment of splitTopLevelCommas(raw)) {
+    const entry = parseLinkEntry(segment);
+    if (entry !== null) {
+      entries.push(entry);
+    }
+  }
+  return entries;
+}
+__name(parseLinkHeader, "parseLinkHeader");
+function parseLinkEntry(segment) {
+  const trimmed = segment.trim();
+  if (!trimmed.startsWith("<")) {
+    return null;
+  }
+  const closeIdx = trimmed.indexOf(">");
+  if (closeIdx < 0) {
+    return null;
+  }
+  const uri = trimmed.slice(1, closeIdx).trim();
+  if (uri === "") {
+    return null;
+  }
+  const rel = extractRelParam(trimmed.slice(closeIdx + 1));
+  if (rel === null) {
+    return null;
+  }
+  return { uri, rel };
+}
+__name(parseLinkEntry, "parseLinkEntry");
+var REL_PARAM = /(?:^|;)\s*rel\s*=\s*(?:"([^"]*)"|([^;,\s]+))/i;
+function extractRelParam(params) {
+  const match = REL_PARAM.exec(params);
+  if (match === null) {
+    return null;
+  }
+  const value = match[1] ?? match[2] ?? "";
+  return value.trim().toLowerCase();
+}
+__name(extractRelParam, "extractRelParam");
+function splitTopLevelCommas(raw) {
+  const out = [];
+  let depth = 0;
+  let inQuotes = false;
+  let start = 0;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+    if (ch === '"' && raw[i - 1] !== "\\") {
+      inQuotes = !inQuotes;
+      continue;
+    }
+    if (inQuotes) {
+      continue;
+    }
+    if (ch === "<") {
+      depth++;
+    } else if (ch === ">") {
+      depth = Math.max(0, depth - 1);
+    } else if (ch === "," && depth === 0) {
+      out.push(raw.slice(start, i));
+      start = i + 1;
+    }
+  }
+  out.push(raw.slice(start));
+  return out;
+}
+__name(splitTopLevelCommas, "splitTopLevelCommas");
+
 // src/client/client.ts
 var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var MAX_REDIRECTS = 5;
 async function httpRequest(options) {
   const url = buildUrl(options.apiBaseUrl, options.path, options.searchParams);
   const headers = {
@@ -102,7 +316,12 @@ async function httpRequest(options) {
     init.body = JSON.stringify(options.body);
   }
   try {
-    const response = await fetch(url, init);
+    const response = await fetchFollowingRedirects(
+      url,
+      init,
+      options.method,
+      options.path
+    );
     return await handleResponse(response, options.method, options.path);
   } catch (error) {
     if (isTimeoutError(error)) {
@@ -128,7 +347,12 @@ async function httpUpload(options) {
     signal: AbortSignal.timeout(timeoutMs)
   };
   try {
-    const response = await fetch(url, init);
+    const response = await fetchFollowingRedirects(
+      url,
+      init,
+      "POST",
+      options.path
+    );
     return await handleResponse(response, "POST", options.path);
   } catch (error) {
     if (isTimeoutError(error)) {
@@ -140,6 +364,131 @@ async function httpUpload(options) {
   }
 }
 __name(httpUpload, "httpUpload");
+async function fetchFollowingRedirects(initialUrl, initialInit, method, path) {
+  let currentUrl = initialUrl;
+  let currentInit = { ...initialInit, redirect: "manual" };
+  for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+    const response = await fetch(currentUrl, currentInit);
+    const deprecation = parseDeprecationHeaders(response.headers);
+    if (deprecation !== null) {
+      printDeprecationNotice(deprecation, { method, path });
+    }
+    if (!isRedirect(response.status)) {
+      return response;
+    }
+    const location = response.headers.get("Location");
+    if (location === null) {
+      return response;
+    }
+    const nextUrl = new URL(location, currentUrl);
+    let nextHeaders = currentInit.headers;
+    let nextMethod = currentInit.method;
+    let nextBody = currentInit.body;
+    const currentMethod = (currentInit.method ?? "GET").toUpperCase();
+    if (shouldDowngradeToGet(response.status, currentMethod)) {
+      nextMethod = "GET";
+      nextBody = void 0;
+      nextHeaders = stripEntityHeaders(nextHeaders);
+    }
+    if (nextUrl.origin !== currentUrl.origin) {
+      nextHeaders = stripAuthorization(nextHeaders);
+    }
+    currentInit = {
+      ...currentInit,
+      method: nextMethod,
+      body: nextBody,
+      headers: nextHeaders
+    };
+    currentUrl = nextUrl;
+  }
+  throw new CliError(
+    `Too many redirects (>${MAX_REDIRECTS}) for ${method} ${path}`
+  );
+}
+__name(fetchFollowingRedirects, "fetchFollowingRedirects");
+function isRedirect(status) {
+  return status >= 300 && status < 400 && status !== 304;
+}
+__name(isRedirect, "isRedirect");
+function shouldDowngradeToGet(status, method) {
+  if ((status === 301 || status === 302) && method === "POST") {
+    return true;
+  }
+  if (status === 303 && method !== "GET" && method !== "HEAD") {
+    return true;
+  }
+  return false;
+}
+__name(shouldDowngradeToGet, "shouldDowngradeToGet");
+var ENTITY_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "content-encoding",
+  "content-language",
+  "content-location",
+  "content-type",
+  "content-length"
+]);
+function stripEntityHeaders(headers) {
+  const out = {};
+  if (headers === void 0) {
+    return out;
+  }
+  if (headers instanceof Headers) {
+    headers.forEach((value, key) => {
+      if (!ENTITY_HEADER_NAMES.has(key.toLowerCase())) {
+        out[key] = value;
+      }
+    });
+    return out;
+  }
+  if (Array.isArray(headers)) {
+    for (const [key, value] of headers) {
+      if (!ENTITY_HEADER_NAMES.has(key.toLowerCase())) {
+        out[key] = value;
+      }
+    }
+    return out;
+  }
+  for (const [key, value] of Object.entries(
+    headers
+  )) {
+    if (!ENTITY_HEADER_NAMES.has(key.toLowerCase())) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+__name(stripEntityHeaders, "stripEntityHeaders");
+function stripAuthorization(headers) {
+  const out = {};
+  if (headers === void 0) {
+    return out;
+  }
+  if (headers instanceof Headers) {
+    headers.forEach((value, key) => {
+      if (key.toLowerCase() !== "authorization") {
+        out[key] = value;
+      }
+    });
+    return out;
+  }
+  if (Array.isArray(headers)) {
+    for (const [key, value] of headers) {
+      if (key.toLowerCase() !== "authorization") {
+        out[key] = value;
+      }
+    }
+    return out;
+  }
+  for (const [key, value] of Object.entries(
+    headers
+  )) {
+    if (key.toLowerCase() !== "authorization") {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+__name(stripAuthorization, "stripAuthorization");
 function isTimeoutError(error) {
   return error instanceof DOMException && (error.name === "TimeoutError" || error.name === "AbortError");
 }
@@ -202,39 +551,6 @@ async function safeReadText(response) {
 }
 __name(safeReadText, "safeReadText");
 
-// src/output/should-color.ts
-function shouldColor() {
-  if (process.env.NO_COLOR !== void 0 && process.env.NO_COLOR !== "") {
-    return false;
-  }
-  return Boolean(process.stdout.isTTY);
-}
-__name(shouldColor, "shouldColor");
-
-// src/output/colors.ts
-var ANSI = {
-  reset: "\x1B[0m",
-  green: "\x1B[32m",
-  red: "\x1B[31m",
-  cyan: "\x1B[36m",
-  dim: "\x1B[2m",
-  bold: "\x1B[1m",
-  orange: "\x1B[38;5;208m",
-  yellow: "\x1B[38;5;178m"
-};
-function wrap(code, text3) {
-  if (!shouldColor()) {
-    return text3;
-  }
-  return `${code}${text3}${ANSI.reset}`;
-}
-__name(wrap, "wrap");
-var green = /* @__PURE__ */ __name((text3) => wrap(ANSI.green, text3), "green");
-var red = /* @__PURE__ */ __name((text3) => wrap(ANSI.red, text3), "red");
-var cyan = /* @__PURE__ */ __name((text3) => wrap(ANSI.cyan, text3), "cyan");
-var bold = /* @__PURE__ */ __name((text3) => wrap(ANSI.bold, text3), "bold");
-var yellow = /* @__PURE__ */ __name((text3) => wrap(ANSI.yellow, text3), "yellow");
-
 // src/output/json.ts
 function printJson(data) {
   console.log(JSON.stringify(data, null, 2));
@@ -1148,8 +1464,8 @@ import { z as z36 } from "zod";
 import { z as z37 } from "zod";
 import { z as z38 } from "zod";
 import { z as z39 } from "zod";
-import { z as z40 } from "zod";
 import { z as z41 } from "zod";
+import { z as z40 } from "zod";
 import { z as z42 } from "zod";
 import { z as z43 } from "zod";
 import { z as z44 } from "zod";
@@ -1159,11 +1475,13 @@ import { z as z47 } from "zod";
 import { z as z48 } from "zod";
 import { z as z49 } from "zod";
 import { z as z50 } from "zod";
-import { z as z52 } from "zod";
 import { z as z51 } from "zod";
-import { z as z53 } from "zod";
+import { z as z52 } from "zod";
 import { z as z54 } from "zod";
+import { z as z53 } from "zod";
 import { z as z55 } from "zod";
+import { z as z56 } from "zod";
+import { z as z57 } from "zod";
 
 // ../node_modules/.pnpm/jsonrepair@3.13.2/node_modules/jsonrepair/lib/esm/utils/JSONRepairError.js
 var JSONRepairError = class extends Error {
@@ -1887,45 +2205,6 @@ var __name2 = /* @__PURE__ */ __name((target, value) => __defProp2(target, "name
 var customerPortalResponseSchema = z3.object({
   url: z3.string()
 });
-var limitSchema = z22.union([z22.number(), z22.literal("unlimited")]);
-var entitlementsResponseSchema = z22.object({
-  planVersionId: z22.string(),
-  planName: z22.string(),
-  basePlan: z22.enum(["free", "pro", "enterprise"]),
-  features: z22.array(z22.string()),
-  limits: z22.object({
-    maxAgents: limitSchema,
-    maxAgentRunsPerMonth: limitSchema,
-    runCountingMode: z22.enum(["monthly", "lifetime"])
-  }),
-  usage: z22.object({
-    currentAssignments: z22.number(),
-    currentMonthAgentRuns: z22.number()
-  }),
-  subscription: z22.object({
-    status: z22.enum(["active", "trialing", "canceled", "past_due"]),
-    trialEndsAt: z22.coerce.date().nullable(),
-    currentPeriodEnd: z22.coerce.date().nullable()
-  }),
-  canCreateTeams: z22.boolean()
-});
-var invoiceSchema = z32.object({
-  id: z32.string(),
-  number: z32.string().nullable(),
-  status: z32.enum(["draft", "open", "paid", "uncollectible", "void"]),
-  amountDue: z32.number(),
-  amountPaid: z32.number(),
-  currency: z32.string(),
-  createdAt: z32.string(),
-  paidAt: z32.string().nullable(),
-  hostedInvoiceUrl: z32.string().nullable(),
-  invoicePdf: z32.string().nullable()
-});
-var invoicesResponseSchema = z32.object({
-  invoices: z32.array(invoiceSchema),
-  hasMore: z32.boolean(),
-  nextCursor: z32.string().nullable()
-});
 var PLAN_FEATURE = {
   API_ACCESS: "api_access",
   BROWSER_AUTOMATION: "browser_automation",
@@ -2033,6 +2312,15 @@ var AGENT_PLAN_FEATURES = [
   PLAN_FEATURE.AGENTIC_MEMORY,
   PLAN_FEATURE.BROWSING_SKILL_RECORDING
 ];
+function isClarityOnlyPlan(plan) {
+  const hasClarity = plan.features.includes(PLAN_FEATURE.CLARITY);
+  const hasAgentFeature = AGENT_PLAN_FEATURES.some(
+    (feature) => plan.features.includes(feature)
+  );
+  return hasClarity && !hasAgentFeature;
+}
+__name(isClarityOnlyPlan, "isClarityOnlyPlan");
+__name2(isClarityOnlyPlan, "isClarityOnlyPlan");
 var STRIPE_PRICE_IDS = {
   development: {
     pro_v1: "price_1SsNA0G2suWmkoit1EDZ1yIp",
@@ -2112,6 +2400,247 @@ function isWithinPlanLimit(planVersionId, limit, currentValue) {
 }
 __name(isWithinPlanLimit, "isWithinPlanLimit");
 __name2(isWithinPlanLimit, "isWithinPlanLimit");
+var PRODUCT = {
+  AUTOMATION: "automation",
+  CLARITY: "clarity",
+  PLATFORM: "platform"
+};
+var PRODUCT_KEYS = [
+  PRODUCT.AUTOMATION,
+  PRODUCT.CLARITY,
+  PRODUCT.PLATFORM
+];
+var CUSTOMER_VISIBLE_PRODUCTS = [
+  PRODUCT.AUTOMATION,
+  PRODUCT.CLARITY
+];
+var PRODUCT_FEATURE_COMPATIBILITY = {
+  [PRODUCT.AUTOMATION]: [],
+  [PRODUCT.CLARITY]: [PLAN_FEATURE.CLARITY],
+  [PRODUCT.PLATFORM]: []
+};
+var CAPABILITY = {
+  API_ACCESS: "api_access",
+  BROWSER_AUTOMATION: "browser_automation",
+  ADVANCED_INTEGRATIONS: "advanced_integrations",
+  CUSTOM_MCP_SERVERS: "custom_mcp_servers",
+  CASE_QUEUE: "case_queue",
+  CLARITY_OVERVIEW: "clarity_overview",
+  PORTFOLIO_INTELLIGENCE: "portfolio_intelligence",
+  SSO: "sso",
+  AUDIT_LOGS: "audit_logs",
+  PRIORITY_SUPPORT: "priority_support",
+  CAN_CREATE_TEAMS: "can_create_teams",
+  LEARNINGS: "learnings",
+  BROWSING_SKILL_RECORDING: "browsing_skill_recording",
+  WORKFLOW_BUILDER: "workflow_builder",
+  AGENTIC_MEMORY: "agentic_memory"
+};
+var CAPABILITY_KEYS = [
+  CAPABILITY.API_ACCESS,
+  CAPABILITY.BROWSER_AUTOMATION,
+  CAPABILITY.ADVANCED_INTEGRATIONS,
+  CAPABILITY.CUSTOM_MCP_SERVERS,
+  CAPABILITY.CASE_QUEUE,
+  CAPABILITY.CLARITY_OVERVIEW,
+  CAPABILITY.PORTFOLIO_INTELLIGENCE,
+  CAPABILITY.SSO,
+  CAPABILITY.AUDIT_LOGS,
+  CAPABILITY.PRIORITY_SUPPORT,
+  CAPABILITY.CAN_CREATE_TEAMS,
+  CAPABILITY.LEARNINGS,
+  CAPABILITY.BROWSING_SKILL_RECORDING,
+  CAPABILITY.WORKFLOW_BUILDER,
+  CAPABILITY.AGENTIC_MEMORY
+];
+var CAPABILITY_PRODUCT = {
+  [CAPABILITY.API_ACCESS]: PRODUCT.AUTOMATION,
+  [CAPABILITY.BROWSER_AUTOMATION]: PRODUCT.AUTOMATION,
+  [CAPABILITY.ADVANCED_INTEGRATIONS]: PRODUCT.AUTOMATION,
+  [CAPABILITY.CUSTOM_MCP_SERVERS]: PRODUCT.AUTOMATION,
+  [CAPABILITY.CASE_QUEUE]: PRODUCT.AUTOMATION,
+  [CAPABILITY.CLARITY_OVERVIEW]: PRODUCT.CLARITY,
+  [CAPABILITY.PORTFOLIO_INTELLIGENCE]: PRODUCT.CLARITY,
+  [CAPABILITY.SSO]: PRODUCT.PLATFORM,
+  [CAPABILITY.AUDIT_LOGS]: PRODUCT.PLATFORM,
+  [CAPABILITY.PRIORITY_SUPPORT]: PRODUCT.PLATFORM,
+  [CAPABILITY.CAN_CREATE_TEAMS]: PRODUCT.PLATFORM,
+  [CAPABILITY.LEARNINGS]: PRODUCT.AUTOMATION,
+  [CAPABILITY.BROWSING_SKILL_RECORDING]: PRODUCT.AUTOMATION,
+  [CAPABILITY.WORKFLOW_BUILDER]: PRODUCT.AUTOMATION,
+  [CAPABILITY.AGENTIC_MEMORY]: PRODUCT.AUTOMATION
+};
+var CAPABILITY_FEATURE_COMPATIBILITY = {
+  [CAPABILITY.API_ACCESS]: PLAN_FEATURE.API_ACCESS,
+  [CAPABILITY.BROWSER_AUTOMATION]: PLAN_FEATURE.BROWSER_AUTOMATION,
+  [CAPABILITY.ADVANCED_INTEGRATIONS]: PLAN_FEATURE.ADVANCED_INTEGRATIONS,
+  [CAPABILITY.CUSTOM_MCP_SERVERS]: PLAN_FEATURE.CUSTOM_MCP_SERVERS,
+  [CAPABILITY.CASE_QUEUE]: PLAN_FEATURE.CASE_QUEUE,
+  [CAPABILITY.CLARITY_OVERVIEW]: PLAN_FEATURE.CLARITY_OVERVIEW,
+  [CAPABILITY.SSO]: PLAN_FEATURE.SSO,
+  [CAPABILITY.AUDIT_LOGS]: PLAN_FEATURE.AUDIT_LOGS,
+  [CAPABILITY.PRIORITY_SUPPORT]: PLAN_FEATURE.PRIORITY_SUPPORT,
+  [CAPABILITY.CAN_CREATE_TEAMS]: PLAN_FEATURE.CAN_CREATE_TEAMS,
+  [CAPABILITY.LEARNINGS]: PLAN_FEATURE.LEARNINGS,
+  [CAPABILITY.BROWSING_SKILL_RECORDING]: PLAN_FEATURE.BROWSING_SKILL_RECORDING,
+  [CAPABILITY.WORKFLOW_BUILDER]: PLAN_FEATURE.WORKFLOW_BUILDER,
+  [CAPABILITY.AGENTIC_MEMORY]: PLAN_FEATURE.AGENTIC_MEMORY
+};
+var ENTITLEMENT_LIMIT = {
+  MAX_AGENTS: "maxAgents",
+  MAX_AGENT_RUNS_PER_MONTH: "maxAgentRunsPerMonth",
+  MAX_CONCURRENT_RUNS: "maxConcurrentRuns"
+};
+var ENTITLEMENT_LIMIT_KEYS = [
+  ENTITLEMENT_LIMIT.MAX_AGENTS,
+  ENTITLEMENT_LIMIT.MAX_AGENT_RUNS_PER_MONTH,
+  ENTITLEMENT_LIMIT.MAX_CONCURRENT_RUNS
+];
+function getLimitsFromPlan(plan) {
+  return {
+    maxAgents: plan.maxAgents,
+    maxAgentRunsPerMonth: plan.maxAgentRunsPerMonth,
+    maxConcurrentRuns: plan.maxConcurrentRuns
+  };
+}
+__name(getLimitsFromPlan, "getLimitsFromPlan");
+__name2(getLimitsFromPlan, "getLimitsFromPlan");
+var PLAN_PRESET_ENTITLEMENTS = {
+  free_v1: {
+    products: [PRODUCT.AUTOMATION],
+    capabilities: [],
+    limits: getLimitsFromPlan(PLAN_VERSIONS.free_v1)
+  },
+  pro_v1: {
+    products: [PRODUCT.AUTOMATION],
+    capabilities: [
+      CAPABILITY.BROWSER_AUTOMATION,
+      CAPABILITY.ADVANCED_INTEGRATIONS,
+      CAPABILITY.CUSTOM_MCP_SERVERS,
+      CAPABILITY.BROWSING_SKILL_RECORDING,
+      CAPABILITY.AGENTIC_MEMORY
+    ],
+    limits: getLimitsFromPlan(PLAN_VERSIONS.pro_v1)
+  },
+  enterprise_v1: {
+    products: [PRODUCT.AUTOMATION, PRODUCT.CLARITY, PRODUCT.PLATFORM],
+    capabilities: [
+      CAPABILITY.API_ACCESS,
+      CAPABILITY.BROWSER_AUTOMATION,
+      CAPABILITY.ADVANCED_INTEGRATIONS,
+      CAPABILITY.CUSTOM_MCP_SERVERS,
+      CAPABILITY.CASE_QUEUE,
+      CAPABILITY.CLARITY_OVERVIEW,
+      CAPABILITY.SSO,
+      CAPABILITY.AUDIT_LOGS,
+      CAPABILITY.PRIORITY_SUPPORT,
+      CAPABILITY.CAN_CREATE_TEAMS,
+      CAPABILITY.LEARNINGS,
+      CAPABILITY.BROWSING_SKILL_RECORDING,
+      CAPABILITY.WORKFLOW_BUILDER,
+      CAPABILITY.AGENTIC_MEMORY
+    ],
+    limits: getLimitsFromPlan(PLAN_VERSIONS.enterprise_v1)
+  },
+  clarity_v1: {
+    products: [PRODUCT.CLARITY],
+    capabilities: [CAPABILITY.CLARITY_OVERVIEW],
+    limits: getLimitsFromPlan(PLAN_VERSIONS.clarity_v1)
+  }
+};
+function getPlanPresetEntitlements(planVersionId) {
+  return PLAN_PRESET_ENTITLEMENTS[planVersionId];
+}
+__name(getPlanPresetEntitlements, "getPlanPresetEntitlements");
+__name2(getPlanPresetEntitlements, "getPlanPresetEntitlements");
+function getPlanProducts(planVersionId) {
+  return getPlanPresetEntitlements(planVersionId).products;
+}
+__name(getPlanProducts, "getPlanProducts");
+__name2(getPlanProducts, "getPlanProducts");
+function getPlanCapabilities(planVersionId) {
+  return getPlanPresetEntitlements(planVersionId).capabilities;
+}
+__name(getPlanCapabilities, "getPlanCapabilities");
+__name2(getPlanCapabilities, "getPlanCapabilities");
+function getPlanPresetLimits(planVersionId) {
+  return getPlanPresetEntitlements(planVersionId).limits;
+}
+__name(getPlanPresetLimits, "getPlanPresetLimits");
+__name2(getPlanPresetLimits, "getPlanPresetLimits");
+function getCompatibilityFeaturesForEntitlements(entitlements) {
+  const features = /* @__PURE__ */ new Set();
+  for (const product of entitlements.products) {
+    for (const feature of PRODUCT_FEATURE_COMPATIBILITY[product]) {
+      features.add(feature);
+    }
+  }
+  for (const capability of entitlements.capabilities) {
+    const feature = CAPABILITY_FEATURE_COMPATIBILITY[capability];
+    if (feature) {
+      features.add(feature);
+    }
+  }
+  return [...features];
+}
+__name(getCompatibilityFeaturesForEntitlements, "getCompatibilityFeaturesForEntitlements");
+__name2(getCompatibilityFeaturesForEntitlements, "getCompatibilityFeaturesForEntitlements");
+function getPlanPresetCompatibilityFeatures(planVersionId) {
+  const features = new Set(
+    getCompatibilityFeaturesForEntitlements(
+      getPlanPresetEntitlements(planVersionId)
+    )
+  );
+  return PLAN_VERSIONS[planVersionId].features.filter(
+    (feature) => features.has(feature)
+  );
+}
+__name(getPlanPresetCompatibilityFeatures, "getPlanPresetCompatibilityFeatures");
+__name2(getPlanPresetCompatibilityFeatures, "getPlanPresetCompatibilityFeatures");
+var limitSchema = z22.union([z22.number(), z22.literal("unlimited")]);
+var entitlementsResponseSchema = z22.object({
+  planVersionId: z22.string(),
+  planName: z22.string(),
+  basePlan: z22.enum(["free", "pro", "enterprise"]),
+  features: z22.array(z22.string()),
+  products: z22.array(z22.string()).default([]),
+  capabilities: z22.array(z22.string()).default([]),
+  source: z22.literal("team_subscription").default("team_subscription"),
+  organizationId: z22.string().nullable().default(null),
+  limits: z22.object({
+    maxAgents: limitSchema,
+    maxAgentRunsPerMonth: limitSchema,
+    maxConcurrentRuns: limitSchema.default(0),
+    runCountingMode: z22.enum(["monthly", "lifetime"])
+  }),
+  usage: z22.object({
+    currentAssignments: z22.number(),
+    currentMonthAgentRuns: z22.number()
+  }),
+  subscription: z22.object({
+    status: z22.enum(["active", "trialing", "canceled", "past_due"]),
+    trialEndsAt: z22.coerce.date().nullable(),
+    currentPeriodEnd: z22.coerce.date().nullable()
+  }),
+  canCreateTeams: z22.boolean()
+});
+var invoiceSchema = z32.object({
+  id: z32.string(),
+  number: z32.string().nullable(),
+  status: z32.enum(["draft", "open", "paid", "uncollectible", "void"]),
+  amountDue: z32.number(),
+  amountPaid: z32.number(),
+  currency: z32.string(),
+  createdAt: z32.string(),
+  paidAt: z32.string().nullable(),
+  hostedInvoiceUrl: z32.string().nullable(),
+  invoicePdf: z32.string().nullable()
+});
+var invoicesResponseSchema = z32.object({
+  invoices: z32.array(invoiceSchema),
+  hasMore: z32.boolean(),
+  nextCursor: z32.string().nullable()
+});
 var PLAN_FEATURE_LABELS = {
   [PLAN_FEATURE.API_ACCESS]: "API Access",
   [PLAN_FEATURE.BROWSER_AUTOMATION]: "Browser Automation",
@@ -3253,6 +3782,16 @@ var teamClaritySettingsSchema = z11.object({
   annualRevenue: z11.number().nullable().optional(),
   isUserConfigured: z11.boolean()
 });
+var updateTeamClaritySettingsSchema = z11.object({
+  teamSize: z11.int().positive().max(1e4).optional(),
+  averageHourlyRate: z11.number().positive().max(1e4).optional(),
+  emailReportsEnabled: z11.boolean().optional(),
+  emailReportIncludeSummary: z11.boolean().optional(),
+  emailReportIncludeCaptures: z11.boolean().optional(),
+  companyName: z11.string().trim().max(255).nullable().optional(),
+  industry: z11.string().trim().max(255).nullable().optional(),
+  annualRevenue: z11.number().nonnegative().nullable().optional()
+});
 var clarityCaptureSchema = z11.object({
   id: z11.guid(),
   processId: z11.guid(),
@@ -3299,13 +3838,19 @@ var clarityProcessListItemSchema = z11.object({
   }).optional(),
   insightsCount: z11.number(),
   hasAnalysis: z11.boolean(),
-  pendingInvitationCount: z11.number().optional(),
+  pendingInvitationCount: z11.number(),
   summary: z11.string().nullable().optional(),
   vulnerabilityCount: z11.number().optional(),
   contributors: z11.array(z11.object({ userId: z11.string(), userName: z11.string() })).optional(),
   createdAt: z11.coerce.date(),
   createdByName: z11.string().optional()
 });
+var clarityProcessListResponseSchema = z11.object({
+  data: z11.array(clarityProcessListItemSchema),
+  total: z11.number(),
+  limit: z11.number(),
+  offset: z11.number()
+});
 var GENERATION_STEP_STATUSES = [
   "pending",
   "in_progress",
@@ -3340,18 +3885,17 @@ var clarityProcessDetailSchema = clarityProcessSchema.extend({
 var createClarityProcessSchema = z11.object({
   name: z11.string().min(1).max(255).optional()
 });
+var createClarityProcessResponseSchema = z11.object({
+  id: z11.guid(),
+  name: z11.string(),
+  status: clarityProcessStatusSchema,
+  version: z11.union([z11.literal(1), z11.literal(2)]),
+  createdAt: z11.string()
+});
 var updateClarityProcessSchema = z11.object({
   name: z11.string().min(1).max(255).optional(),
   customPrompt: z11.string().max(5e3).nullable().optional()
 });
-var saveClarityCaptureInterviewSchema = z11.object({
-  captureId: z11.guid().optional(),
-  extraCaptureRequestId: z11.guid().optional(),
-  transcript: z11.array(conversationMessageSchema).min(1)
-});
-var startClarityCaptureInterviewQuerySchema = z11.object({
-  extraCaptureRequestId: z11.guid().optional()
-});
 var INTERVIEW_LANGUAGES = [
   "en",
   "cs",
@@ -3631,11 +4175,7 @@ function captureSubTypeToColumnValue(subType) {
 __name(captureSubTypeToColumnValue, "captureSubTypeToColumnValue");
 __name2(captureSubTypeToColumnValue, "captureSubTypeToColumnValue");
 var clarityInterviewTurnBodySchema = z12.object({
-  // Optional with a `"screenshare"` default so old clients calling the
-  // deprecated `/v1/clarity/screenshare/*` routes (which don't send `type`)
-  // still parse cleanly. New `/v1/clarity/interview/*` callers always
-  // include it explicitly.
-  type: clarityCaptureSubTypeSchema.default("screenshare"),
+  type: clarityCaptureSubTypeSchema,
   transcript: z12.array(conversationMessageSchema).max(MAX_INTERVIEW_TRANSCRIPT_ENTRIES),
   images: z12.array(clarityInterviewFrameSchema).max(MAX_INTERVIEW_FRAMES_PER_TURN),
   coverage: clarityInterviewCoverageSchema,
@@ -3916,7 +4456,12 @@ var proposalSummaryAgentTransformationProposalSchema = z13.object({
     'One short paragraph (3-5 sentences) describing the proposed transformed process at a glance. Surfaced at the top of the transformation-proposal tab so reviewers can orient themselves before scanning the steps. Example: "Customers self-order on a tablet at the bar; a smart tap auto-pours the chosen beer into a labelled glass, which the customer collects from the pickup counter once payment clears."'
   )
 });
-var postprocessClarityTransformationProposalDataSchema = clarityTransformationProposalDataObjectSchema.extend(proposalSummaryAgentTransformationProposalSchema.shape).extend({});
+var projectedImpactAgentTransformationProposalSchema = z13.object({
+  projectedImpact: z13.string().min(1).nullable().optional().describe(
+    "Answer-first, MECE-structured business case. 4-8 sentences of prose + one markdown assumptions table. Null when team context is insufficient to produce any quantitative or qualitative assessment."
+  )
+});
+var postprocessClarityTransformationProposalDataSchema = clarityTransformationProposalDataObjectSchema.extend(proposalSummaryAgentTransformationProposalSchema.shape).extend(projectedImpactAgentTransformationProposalSchema.shape).extend({});
 var clarityV2SnapshotStatusSchema = z13.enum(["live", "historic"]);
 var clarityV2SnapshotCreatorTypeSchema = z13.enum(["human", "ai"]);
 var versioningApiFields = {
@@ -4510,9 +5055,7 @@ var startInterviewCaptureResponseSchema = clarityCaptureSchema.extend({
 });
 var MAX_INTERVIEW_FRAMES_PER_CAPTURE = 300;
 var interviewUploadUrlsBodySchema = z19.object({
-  // Optional with a `"screenshare"` default for deprecated-route
-  // back-compat — see `clarityInterviewTurnBodySchema`.
-  type: clarityCaptureSubTypeSchema.default("screenshare"),
+  type: clarityCaptureSubTypeSchema,
   screenshareStartTime: z19.int().nonnegative(),
   frameTimestamps: z19.array(z19.int().nonnegative()).max(MAX_INTERVIEW_FRAMES_PER_CAPTURE)
 });
@@ -4535,8 +5078,7 @@ var completeInterviewCaptureResponseSchema = clarityCaptureSchema.extend({
   updatedAt: z19.string()
 });
 var autoSaveInterviewCaptureBodySchema = z19.object({
-  // See `clarityInterviewTurnBodySchema` for why this defaults.
-  type: clarityCaptureSubTypeSchema.default("screenshare"),
+  type: clarityCaptureSubTypeSchema,
   transcript: z19.array(conversationMessageSchema).max(MAX_INTERVIEW_TRANSCRIPT_ENTRIES),
   images: z19.array(clarityInterviewFrameSchema).max(MAX_INTERVIEW_FRAMES_PER_CAPTURE)
 });
@@ -5264,6 +5806,7 @@ var agentApiSchema = z27.object({
   team_id: z27.string().nullable(),
   thread_id: z27.string().nullable(),
   folder_id: z27.string().nullable().optional(),
+  pinned_at: z27.string().nullable().optional(),
   created_at: z27.string().nullable(),
   updated_at: z27.string().nullable(),
   last_run_at: z27.string().nullable(),
@@ -6250,25 +6793,78 @@ var clarityOverviewDetailSchema = z39.object({
   createdAt: z39.coerce.date(),
   updatedAt: z39.coerce.date()
 });
-var credentialPreviewSchema = z40.object({
-  id: z40.guid().describe("Credential ID"),
-  domain: z40.string().describe("Domain for the credential"),
-  username: z40.string().nullable().describe("Username (if any)"),
-  hasEnabledTOTP: z40.boolean().describe("Whether TOTP is enabled"),
-  hasPassword: z40.boolean().describe("Whether a password is stored"),
-  user_id: z40.string().nullable().describe("Owner user id; null when shared with the team")
-});
-var otpResponseSchema = z40.object({
-  code: z40.string().describe("The TOTP code"),
-  expiresAt: z40.number().describe("Expiration timestamp in milliseconds")
-});
-var encryptedDataSchema = z40.object({
-  encrypted_data: z40.string().describe("Base64-encoded encrypted data"),
-  key_version: z40.string().describe("KMS key version or 'base64' for dev")
-});
-var credentialDetailSchema = z40.object({
-  domain: z40.string().describe("Domain for the credential"),
-  username: z40.string().nullable().describe("Username (if any)"),
+var createTeamInviteLinkRequestSchema = z40.object({
+  frontendUrl: z40.url()
+});
+var getTeamInviteLinkQuerySchema = z40.object({
+  frontendUrl: z40.url()
+});
+var teamInviteLinkCreatorSchema = z40.object({
+  id: z40.guid(),
+  name: z40.string().nullable(),
+  email: z40.email()
+});
+var teamInviteLinkSchema = z40.object({
+  id: z40.guid(),
+  url: z40.url().optional(),
+  createdAt: z40.string(),
+  createdBy: teamInviteLinkCreatorSchema
+});
+var getTeamInviteLinkResponseSchema = z40.object({
+  hasLink: z40.boolean(),
+  link: teamInviteLinkSchema.optional()
+});
+var joinLinkInfoResponseSchema = z40.object({
+  valid: z40.boolean(),
+  teamName: z40.string().optional(),
+  teamId: z40.guid().optional(),
+  reason: z40.enum(["invalid", "expired"]).optional()
+});
+var acceptJoinLinkResponseSchema = z40.object({
+  success: z40.boolean(),
+  teamId: z40.guid()
+});
+var createClarityProcessInviteLinkRequestSchema = z41.object({
+  frontendUrl: z41.url()
+});
+var getClarityProcessInviteLinkQuerySchema = z41.object({
+  frontendUrl: z41.url()
+});
+var clarityProcessInviteLinkSchema = teamInviteLinkSchema;
+var getClarityProcessInviteLinkResponseSchema = z41.object({
+  hasLink: z41.boolean(),
+  link: clarityProcessInviteLinkSchema.optional()
+});
+var clarityJoinLinkInfoResponseSchema = z41.object({
+  valid: z41.boolean(),
+  processName: z41.string().optional(),
+  processId: z41.guid().optional(),
+  teamId: z41.guid().optional(),
+  reason: z41.enum(["invalid", "expired"]).optional()
+});
+var acceptClarityJoinLinkResponseSchema = z41.object({
+  success: z41.boolean(),
+  processId: z41.guid()
+});
+var credentialPreviewSchema = z42.object({
+  id: z42.guid().describe("Credential ID"),
+  domain: z42.string().describe("Domain for the credential"),
+  username: z42.string().nullable().describe("Username (if any)"),
+  hasEnabledTOTP: z42.boolean().describe("Whether TOTP is enabled"),
+  hasPassword: z42.boolean().describe("Whether a password is stored"),
+  user_id: z42.string().nullable().describe("Owner user id; null when shared with the team")
+});
+var otpResponseSchema = z42.object({
+  code: z42.string().describe("The TOTP code"),
+  expiresAt: z42.number().describe("Expiration timestamp in milliseconds")
+});
+var encryptedDataSchema = z42.object({
+  encrypted_data: z42.string().describe("Base64-encoded encrypted data"),
+  key_version: z42.string().describe("KMS key version or 'base64' for dev")
+});
+var credentialDetailSchema = z42.object({
+  domain: z42.string().describe("Domain for the credential"),
+  username: z42.string().nullable().describe("Username (if any)"),
   password: encryptedDataSchema.nullable().describe("Encrypted password data")
 });
 var FEATURE_FLAG_CATALOGUE = {
@@ -6287,6 +6883,11 @@ var FEATURE_FLAG_CATALOGUE = {
     defaultValue: false,
     description: "Enables team-wide agentic memory. When active, newly created agents default to persistent memory and existing agents can also be enabled for persistent memory across runs."
   },
+  PULSE: {
+    key: "pulse",
+    defaultValue: false,
+    description: "Enables Duvo Pulse \u2014 the agent-generated visualization Artifacts surface. When disabled, the side-nav entry is hidden and every /v1/artifacts/* endpoint returns 404; the cc-server ingestion callback is unaffected."
+  },
   AGENT_SELF_SCHEDULING: {
     key: "agent_self_scheduling",
     defaultValue: false,
@@ -6342,11 +6943,6 @@ var FEATURE_FLAG_CATALOGUE = {
     defaultValue: false,
     description: "Routes voice-only Clarity interviews to the ElevenLabs conversational provider. When off, voice-only interviews use OpenAI Realtime. Screenshare interviews always use OpenAI Realtime."
   },
-  CLARITY_V2: {
-    key: "clarity_v2",
-    defaultValue: false,
-    description: "Enables the Clarity v2 architecture: typed snapshot tables (clarity_current_process, clarity_transformation_proposal), the P1-P4 pipelines, the v2 read model, and the v2 process page (/clarity/v2/[id]) with end-to-end use of /v1/clarity-v2/* endpoints."
-  },
   DYNAMIC_BUILDER_ISLAND: {
     key: "dynamic_builder_island",
     defaultValue: false,
@@ -6425,82 +7021,82 @@ function coerceFlagValue(value) {
 }
 __name(coerceFlagValue, "coerceFlagValue");
 __name2(coerceFlagValue, "coerceFlagValue");
-var teamFileItemSchema = z41.object({
-  id: z41.string(),
-  name: z41.string(),
-  path: z41.string(),
-  created_at: z41.string().optional(),
-  updated_at: z41.string().optional(),
-  metadata: z41.object({
-    mimetype: z41.string().optional(),
-    size: z41.number().optional()
+var teamFileItemSchema = z43.object({
+  id: z43.string(),
+  name: z43.string(),
+  path: z43.string(),
+  created_at: z43.string().optional(),
+  updated_at: z43.string().optional(),
+  metadata: z43.object({
+    mimetype: z43.string().optional(),
+    size: z43.number().optional()
   }).nullable().optional()
 });
-var listTeamFilesResponseSchema = z41.object({
-  files: z41.array(teamFileItemSchema)
-});
-var createTeamFileUploadUrlBodySchema = z41.object({
-  fileName: z41.string().min(1),
-  contentType: z41.string().min(1)
-});
-var createTeamFileUploadUrlResponseSchema = z41.object({
-  signedUrl: z41.url(),
-  expiresAt: z41.iso.datetime(),
-  filePath: z41.string()
-});
-var renameTeamFileBodySchema = z41.object({
-  relativePath: z41.string().min(1),
-  newFilenameOnly: z41.string().min(1)
-});
-var teamFileSuccessResponseSchema = z41.object({
-  success: z41.boolean()
-});
-var teamFileDownloadUrlResponseSchema = z41.object({
-  url: z41.url(),
-  expiresAt: z41.iso.datetime()
-});
-var teamFileContentResponseSchema = z41.object({
-  content: z41.string(),
-  path: z41.string(),
-  contentType: z41.string().optional()
-});
-var updateTeamFileContentBodySchema = z41.object({
-  content: z41.string()
-});
-var globalAdminApiSchema = z42.object({
-  id: z42.guid(),
-  email: z42.string(),
-  userId: z42.guid(),
-  userName: z42.string().nullable(),
-  addedByUserId: z42.guid().nullable(),
-  createdAt: z42.string()
-});
-var globalAdminListResponseSchema = z42.object({
-  admins: z42.array(globalAdminApiSchema)
-});
-var globalAdminSearchResponseSchema = z42.object({
-  users: z42.array(
-    z42.object({
-      id: z42.guid(),
-      name: z42.string().nullable(),
-      email: z42.string(),
-      createdAt: z42.string().nullable()
+var listTeamFilesResponseSchema = z43.object({
+  files: z43.array(teamFileItemSchema)
+});
+var createTeamFileUploadUrlBodySchema = z43.object({
+  fileName: z43.string().min(1),
+  contentType: z43.string().min(1)
+});
+var createTeamFileUploadUrlResponseSchema = z43.object({
+  signedUrl: z43.url(),
+  expiresAt: z43.iso.datetime(),
+  filePath: z43.string()
+});
+var renameTeamFileBodySchema = z43.object({
+  relativePath: z43.string().min(1),
+  newFilenameOnly: z43.string().min(1)
+});
+var teamFileSuccessResponseSchema = z43.object({
+  success: z43.boolean()
+});
+var teamFileDownloadUrlResponseSchema = z43.object({
+  url: z43.url(),
+  expiresAt: z43.iso.datetime()
+});
+var teamFileContentResponseSchema = z43.object({
+  content: z43.string(),
+  path: z43.string(),
+  contentType: z43.string().optional()
+});
+var updateTeamFileContentBodySchema = z43.object({
+  content: z43.string()
+});
+var globalAdminApiSchema = z44.object({
+  id: z44.guid(),
+  email: z44.string(),
+  userId: z44.guid(),
+  userName: z44.string().nullable(),
+  addedByUserId: z44.guid().nullable(),
+  createdAt: z44.string()
+});
+var globalAdminListResponseSchema = z44.object({
+  admins: z44.array(globalAdminApiSchema)
+});
+var globalAdminSearchResponseSchema = z44.object({
+  users: z44.array(
+    z44.object({
+      id: z44.guid(),
+      name: z44.string().nullable(),
+      email: z44.string(),
+      createdAt: z44.string().nullable()
     })
   )
 });
-var globalAdminCreateRequestSchema = z42.object({
-  userId: z42.guid()
+var globalAdminCreateRequestSchema = z44.object({
+  userId: z44.guid()
 });
-var globalAdminCreateResponseSchema = z42.object({
+var globalAdminCreateResponseSchema = z44.object({
   admin: globalAdminApiSchema
 });
-var globalAdminDeleteResponseSchema = z42.object({
-  success: z42.literal(true)
+var globalAdminDeleteResponseSchema = z44.object({
+  success: z44.literal(true)
 });
-var adminAccessCheckResponseSchema = z42.object({
-  isGlobalAdmin: z42.boolean()
+var adminAccessCheckResponseSchema = z44.object({
+  isGlobalAdmin: z44.boolean()
 });
-var TransportTypeSchema = z43.enum(["stdio", "sse", "http"]);
+var TransportTypeSchema = z45.enum(["stdio", "sse", "http"]);
 var INTEGRATION_SLUGS = [
   "googlecalendar",
   "google-calendar",
@@ -6578,7 +7174,7 @@ var INTEGRATION_SLUGS = [
   "notion-native",
   "granola"
 ];
-var IntegrationSlugSchema = z43.enum(INTEGRATION_SLUGS);
+var IntegrationSlugSchema = z45.enum(INTEGRATION_SLUGS);
 function isIntegrationSlug(value) {
   return INTEGRATION_SLUGS.includes(value);
 }
@@ -6589,110 +7185,110 @@ function isCaseQueueIntegrationType(type) {
 }
 __name(isCaseQueueIntegrationType, "isCaseQueueIntegrationType");
 __name2(isCaseQueueIntegrationType, "isCaseQueueIntegrationType");
-var integrationResponseSchema = z43.object({
-  id: z43.string(),
-  name: z43.string(),
-  type: z43.string(),
-  provider: z43.string(),
-  user_id: z43.string().nullable(),
-  team_id: z43.string(),
-  server_url: z43.string().optional(),
+var integrationResponseSchema = z45.object({
+  id: z45.string(),
+  name: z45.string(),
+  type: z45.string(),
+  provider: z45.string(),
+  user_id: z45.string().nullable(),
+  team_id: z45.string(),
+  server_url: z45.string().optional(),
   transport_type: TransportTypeSchema.optional(),
-  auth_method: z43.string().nullable().optional(),
-  composio_mcp_id: z43.string().nullable().default(null),
-  custom_integration_id: z43.string().nullable().optional(),
-  icon_url: z43.string().nullable().optional(),
-  oauth_provider: z43.string().nullable().optional(),
-  oauth_scopes: z43.array(z43.string()).nullable().optional(),
-  has_headers: z43.boolean().optional(),
-  has_oauth_tokens: z43.boolean().optional(),
+  auth_method: z45.string().nullable().optional(),
+  composio_mcp_id: z45.string().nullable().default(null),
+  custom_integration_id: z45.string().nullable().optional(),
+  icon_url: z45.string().nullable().optional(),
+  oauth_provider: z45.string().nullable().optional(),
+  oauth_scopes: z45.array(z45.string()).nullable().optional(),
+  has_headers: z45.boolean().optional(),
+  has_oauth_tokens: z45.boolean().optional(),
   /**
    * For connection rows (user instances), this is the FK to the team-level
    * integration this connection was created against. Null on catalog rows
    * (where `id` already represents the integration itself) and on
    * custom-integration-backed connections.
    */
-  integration_id: z43.string().nullable().optional(),
+  integration_id: z45.string().nullable().optional(),
   /**
    * Derived from `user_id IS NULL`. True for team-shared connections, false
    * for personal connections. Mirrors the Shared Logins API contract — FE
    * never sees the null sentinel.
    */
-  shared: z43.boolean().optional(),
+  shared: z45.boolean().optional(),
   /**
    * Original creator of the connection. Populated lazily on first share —
    * stays NULL for legacy personal rows that were never shared.
    */
-  created_by: z43.string().nullable().optional(),
-  created_at: z43.iso.datetime(),
-  updated_at: z43.iso.datetime()
-});
-var integrationsListResponseSchema = z43.object({
-  integrations: z43.array(integrationResponseSchema),
-  total: z43.int().min(0),
-  limit: z43.int().min(1),
-  offset: z43.int().min(0)
-});
-var integrationsListRequestQuerySchema = z43.object({
-  type: z43.string().optional(),
+  created_by: z45.string().nullable().optional(),
+  created_at: z45.iso.datetime(),
+  updated_at: z45.iso.datetime()
+});
+var integrationsListResponseSchema = z45.object({
+  integrations: z45.array(integrationResponseSchema),
+  total: z45.int().min(0),
+  limit: z45.int().min(1),
+  offset: z45.int().min(0)
+});
+var integrationsListRequestQuerySchema = z45.object({
+  type: z45.string().optional(),
   // Default high (100) because both the team integration catalog and the
   // user's connections are naturally small per team; existing dashboard
   // callers expect "everything" without explicit pagination.
-  limit: z43.coerce.number().int().min(1).max(100).prefault(100),
-  offset: z43.coerce.number().int().min(0).prefault(0)
-});
-var connectIntegrationResponseSchema = z43.object({
-  integration_id: z43.string(),
-  mcp_url: z43.string()
-});
-var testIntegrationResponseSchema = z43.object({
-  success: z43.boolean(),
-  tools: z43.array(
-    z43.object({
-      name: z43.string(),
-      description: z43.string().optional(),
+  limit: z45.coerce.number().int().min(1).max(100).prefault(100),
+  offset: z45.coerce.number().int().min(0).prefault(0)
+});
+var connectIntegrationResponseSchema = z45.object({
+  integration_id: z45.string(),
+  mcp_url: z45.string()
+});
+var testIntegrationResponseSchema = z45.object({
+  success: z45.boolean(),
+  tools: z45.array(
+    z45.object({
+      name: z45.string(),
+      description: z45.string().optional(),
       // Tool input schemas are JSON-Schema documents whose internal shape
       // varies per MCP server. Modeled as a record of unknowns (matching
       // the upstream MCP SDK's `{ [x: string]: unknown; type: "object" }`
       // typing) so that producers can pass `tool.inputSchema` straight
       // through without an unsafe cast — using `z.json()` here would force
       // every caller to cast since the SDK does not assert JSON-ness.
-      input_schema: z43.record(z43.string(), z43.unknown()).optional()
+      input_schema: z45.record(z45.string(), z45.unknown()).optional()
     })
   ).optional(),
-  error: z43.string().optional()
+  error: z45.string().optional()
 });
-var integrationCredentialsResponseSchema = z43.object({
-  id: z43.guid(),
-  headers: z43.record(z43.string(), z43.string())
+var integrationCredentialsResponseSchema = z45.object({
+  id: z45.guid(),
+  headers: z45.record(z45.string(), z45.string())
 });
-var deleteIntegrationResponseSchema = z43.object({
-  success: z43.boolean(),
-  message: z43.string()
+var deleteIntegrationResponseSchema = z45.object({
+  success: z45.boolean(),
+  message: z45.string()
 });
-var checkDcrSupportResponseSchema = z43.object({
-  supports_dcr: z43.boolean(),
-  authorization_endpoint: z43.string().optional(),
-  scopes: z43.array(z43.string()).optional()
+var checkDcrSupportResponseSchema = z45.object({
+  supports_dcr: z45.boolean(),
+  authorization_endpoint: z45.string().optional(),
+  scopes: z45.array(z45.string()).optional()
 });
-var authorizationUrlResponseSchema = z43.object({
-  authorization_url: z43.string().describe("OAuth provider authorization URL to open in a browser")
+var authorizationUrlResponseSchema = z45.object({
+  authorization_url: z45.string().describe("OAuth provider authorization URL to open in a browser")
 });
-var startComposioConnectionResponseSchema = z43.object({
-  redirect_url: z43.string().nullable().describe(
+var startComposioConnectionResponseSchema = z45.object({
+  redirect_url: z45.string().nullable().describe(
     "Browser URL the user must visit to complete authorization. Null when the connection was completed synchronously (e.g. for API_KEY auth that did not require a browser flow)."
   ),
-  status: z43.string().nullable().describe("Composio connection status, e.g. INITIATED or ACTIVE."),
-  connected_account_id: z43.string().describe(
+  status: z45.string().nullable().describe("Composio connection status, e.g. INITIATED or ACTIVE."),
+  connected_account_id: z45.string().describe(
     "Composio connected-account ID, passed to /v1/connections/composio/finalize to complete the flow."
   )
 });
-var createCustomIntegrationRequestSchema = z43.object({
-  name: z43.string().min(1, "Name is required"),
-  auth_method: z43.enum(["url", "apikey", "headers", "oauth"]),
-  server_url: z43.url("Must be a valid URL"),
-  oauth_client_id: z43.string().min(1).optional(),
-  oauth_client_secret: z43.string().min(1).optional()
+var createCustomIntegrationRequestSchema = z45.object({
+  name: z45.string().min(1, "Name is required"),
+  auth_method: z45.enum(["url", "apikey", "headers", "oauth"]),
+  server_url: z45.url("Must be a valid URL"),
+  oauth_client_id: z45.string().min(1).optional(),
+  oauth_client_secret: z45.string().min(1).optional()
 }).refine(
   (data) => {
     const hasClientId = !!data.oauth_client_id;
@@ -6703,116 +7299,116 @@ var createCustomIntegrationRequestSchema = z43.object({
     error: "Both OAuth Client ID and Client Secret are required, or leave both empty for automatic registration"
   }
 );
-var createIntegrationRequestSchema = z43.object({
-  name: z43.string().min(1, "Name is required"),
-  server_url: z43.url("Must be a valid URL").optional(),
-  type: z43.string().default("custom_mcp"),
-  provider: z43.literal("user"),
-  auth_method: z43.enum(["url", "apikey", "headers", "oauth"]),
-  custom_integration_id: z43.guid().optional(),
-  headers: z43.object({
-    plaintext: z43.record(z43.string(), z43.string()).optional(),
-    secret: z43.record(z43.string(), z43.string()).optional()
+var createIntegrationRequestSchema = z45.object({
+  name: z45.string().min(1, "Name is required"),
+  server_url: z45.url("Must be a valid URL").optional(),
+  type: z45.string().default("custom_mcp"),
+  provider: z45.literal("user"),
+  auth_method: z45.enum(["url", "apikey", "headers", "oauth"]),
+  custom_integration_id: z45.guid().optional(),
+  headers: z45.object({
+    plaintext: z45.record(z45.string(), z45.string()).optional(),
+    secret: z45.record(z45.string(), z45.string()).optional()
   }).optional()
 });
-var updateIntegrationRequestSchema = z43.object({
-  name: z43.string().min(1).optional(),
-  server_url: z43.url().optional(),
-  auth_method: z43.enum(["url", "oauth", "apikey", "headers"]).optional(),
-  headers: z43.object({
-    plaintext: z43.record(z43.string(), z43.string()).optional(),
-    secret: z43.record(z43.string(), z43.string()).optional()
+var updateIntegrationRequestSchema = z45.object({
+  name: z45.string().min(1).optional(),
+  server_url: z45.url().optional(),
+  auth_method: z45.enum(["url", "oauth", "apikey", "headers"]).optional(),
+  headers: z45.object({
+    plaintext: z45.record(z45.string(), z45.string()).optional(),
+    secret: z45.record(z45.string(), z45.string()).optional()
   }).nullable().optional(),
-  composio_mcp_id: z43.string().nullable().optional(),
+  composio_mcp_id: z45.string().nullable().optional(),
   // Toggle team sharing. `true` makes the instance team-shared
   // (`user_id = NULL`); `false` reverts it to personal owned by the caller.
   // Rejected when the org-level "Connections sharing" setting is OFF and
   // `shared === true`. Mirrors the Shared Logins update contract.
-  shared: z43.boolean().optional()
+  shared: z45.boolean().optional()
 });
-var testIntegrationRequestSchema = z43.object({
-  server_url: z43.url().describe("MCP server URL to test"),
-  headers: z43.record(z43.string(), z43.string()).optional().describe("Optional HTTP headers for authentication")
+var testIntegrationRequestSchema = z45.object({
+  server_url: z45.url().describe("MCP server URL to test"),
+  headers: z45.record(z45.string(), z45.string()).optional().describe("Optional HTTP headers for authentication")
 });
 var JOB_LIST_SORT_COLUMNS = ["created_at"];
-var jobListSortColumnSchema = z44.enum(JOB_LIST_SORT_COLUMNS);
-var jobListIssueSeveritySchema = z44.enum(
+var jobListSortColumnSchema = z46.enum(JOB_LIST_SORT_COLUMNS);
+var jobListIssueSeveritySchema = z46.enum(
   ALL_EVALUATION_RUBRIC_SEVERITIES
 );
-var jobListItemSchema = z44.object({
-  id: z44.guid(),
-  created_at: z44.coerce.date(),
-  updated_at: z44.coerce.date(),
-  started_at: z44.coerce.date().nullable(),
-  completed_at: z44.coerce.date().nullable(),
+var jobListItemSchema = z46.object({
+  id: z46.guid(),
+  created_at: z46.coerce.date(),
+  updated_at: z46.coerce.date(),
+  started_at: z46.coerce.date().nullable(),
+  completed_at: z46.coerce.date().nullable(),
   status: agentRunStatusSchema,
-  source: z44.string().nullable(),
-  title: z44.string(),
-  run_number: z44.number(),
+  source: z46.string().nullable(),
+  title: z46.string(),
+  run_number: z46.number(),
   // Assignment info
-  agent_id: z44.guid(),
-  agent_name: z44.string(),
-  build_id: z44.guid(),
+  agent_id: z46.guid(),
+  agent_name: z46.string(),
+  build_id: z46.guid(),
   // User info
-  user_id: z44.guid().nullable(),
+  user_id: z46.guid().nullable(),
   // Case info
-  case_queue_item_id: z44.guid().nullable(),
-  case_queue_id: z44.guid().nullable(),
-  case_queue_name: z44.string().nullable(),
-  case_title: z44.string().nullable(),
-  postponed_to: z44.coerce.date().nullable(),
-  submitted_prompt_count: z44.number().int().min(0),
+  case_queue_item_id: z46.guid().nullable(),
+  case_queue_id: z46.guid().nullable(),
+  case_queue_name: z46.string().nullable(),
+  case_title: z46.string().nullable(),
+  postponed_to: z46.coerce.date().nullable(),
+  submitted_prompt_count: z46.number().int().min(0),
   eval_summaries: evalSummarySchema.nullable().optional()
 });
-var jobListResponseSchema = z44.object({
-  data: z44.array(jobListItemSchema),
-  total: z44.number()
+var jobListResponseSchema = z46.object({
+  data: z46.array(jobListItemSchema),
+  total: z46.number()
 });
-var jobFilterOptionsSchema = z44.object({
-  agents: z44.array(
-    z44.object({
-      id: z44.string(),
-      name: z44.string(),
-      folder_id: z44.string().nullable()
+var jobFilterOptionsSchema = z46.object({
+  agents: z46.array(
+    z46.object({
+      id: z46.string(),
+      name: z46.string(),
+      folder_id: z46.string().nullable()
     })
   ),
-  folders: z44.array(
-    z44.object({
-      id: z44.string(),
-      name: z44.string(),
-      parent_folder_id: z44.string().nullable()
+  folders: z46.array(
+    z46.object({
+      id: z46.string(),
+      name: z46.string(),
+      parent_folder_id: z46.string().nullable()
     })
   ),
-  users: z44.array(
-    z44.object({
-      id: z44.string(),
-      name: z44.string().nullable(),
-      email: z44.string()
+  users: z46.array(
+    z46.object({
+      id: z46.string(),
+      name: z46.string().nullable(),
+      email: z46.string()
     })
   ),
-  caseQueues: z44.array(z44.object({ id: z44.string(), name: z44.string() }))
-});
-var mcpStepSchema = z45.object({
-  tool: z45.string().describe("MCP tool name (e.g., click, fill, navigate_page)"),
-  params: z45.record(z45.string(), z45.unknown()).describe("Tool-specific parameters"),
-  fallbackSelectors: z45.array(z45.string()).optional().describe("Alternative CSS selectors if primary fails"),
-  description: z45.string().optional().describe("Human-readable step description"),
-  screenshot: z45.string().optional().describe("Base64 screenshot at this step for visual context"),
-  snapshot: z45.string().optional().describe("DOM snapshot in accessibility tree format at this step"),
-  framePath: z45.array(z45.number()).optional().describe(
+  caseQueues: z46.array(z46.object({ id: z46.string(), name: z46.string() }))
+});
+var mcpStepSchema = z47.object({
+  tool: z47.string().describe("MCP tool name (e.g., click, fill, navigate_page)"),
+  params: z47.record(z47.string(), z47.unknown()).describe("Tool-specific parameters"),
+  fallbackSelectors: z47.array(z47.string()).optional().describe("Alternative CSS selectors if primary fails"),
+  description: z47.string().optional().describe("Human-readable step description"),
+  screenshot: z47.string().optional().describe("Base64 screenshot at this step for visual context"),
+  snapshot: z47.string().optional().describe("DOM snapshot in accessibility tree format at this step"),
+  framePath: z47.array(z47.number()).optional().describe(
     "Index-based path to the target iframe (e.g., [0] for first child iframe, [1, 0] for nested)"
   )
 });
-var mcpWorkflowSchema = z45.object({
-  name: z45.string(),
-  startUrl: z45.string(),
-  viewport: z45.object({
-    width: z45.number(),
-    height: z45.number()
+var mcpWorkflowSchema = z47.object({
+  name: z47.string(),
+  startUrl: z47.string(),
+  viewport: z47.object({
+    width: z47.number(),
+    height: z47.number()
   }),
-  steps: z45.array(mcpStepSchema)
+  steps: z47.array(mcpStepSchema)
 });
-var MCP_WORKFLOW_JSON_SCHEMA = z45.toJSONSchema(mcpWorkflowSchema, {
+var MCP_WORKFLOW_JSON_SCHEMA = z47.toJSONSchema(mcpWorkflowSchema, {
   reused: "inline"
 });
 var MCP_WORKFLOW_SCHEMA_DOCS = JSON.stringify(
@@ -6820,104 +7416,104 @@ var MCP_WORKFLOW_SCHEMA_DOCS = JSON.stringify(
   null,
   2
 );
-var catalogPluginSchema = z46.object({
-  name: z46.string().describe("Identifier to pass in the build's plugins array."),
-  type: z46.enum(["duvo-platform", "github"]).describe(
+var catalogPluginSchema = z48.object({
+  name: z48.string().describe("Identifier to pass in the build's plugins array."),
+  type: z48.enum(["duvo-platform", "github"]).describe(
     "Plugin source. 'duvo-platform' plugins are pre-baked into the Duvo runtime; 'github' plugins are downloaded from a user-supplied repository URL at run time."
   ),
-  description: z46.string()
+  description: z48.string()
 });
-var pluginCatalogResponseSchema = z46.object({
-  plugins: z46.array(catalogPluginSchema)
+var pluginCatalogResponseSchema = z48.object({
+  plugins: z48.array(catalogPluginSchema)
 });
-var publicProfileSchema = z47.object({
-  id: z47.guid(),
-  name: z47.string().nullable(),
-  email: z47.email(),
-  teamId: z47.guid().nullable()
+var publicProfileSchema = z49.object({
+  id: z49.guid(),
+  name: z49.string().nullable(),
+  email: z49.email(),
+  teamId: z49.guid().nullable()
 });
-var publicProfileResponseSchema = z47.object({
+var publicProfileResponseSchema = z49.object({
   profile: publicProfileSchema
 });
-var elementSelectorsSchema = z48.object({
-  css: z48.string().optional(),
-  cssPath: z48.string().optional(),
-  xpath: z48.string().optional(),
-  testId: z48.string().optional(),
-  ariaSelector: z48.string().optional(),
-  text: z48.string().optional()
+var elementSelectorsSchema = z50.object({
+  css: z50.string().optional(),
+  cssPath: z50.string().optional(),
+  xpath: z50.string().optional(),
+  testId: z50.string().optional(),
+  ariaSelector: z50.string().optional(),
+  text: z50.string().optional()
 });
-var elementInfoSchema = z48.object({
-  uid: z48.string().optional(),
+var elementInfoSchema = z50.object({
+  uid: z50.string().optional(),
   selectors: elementSelectorsSchema,
-  tagName: z48.string(),
-  textContent: z48.string().optional(),
-  ariaLabel: z48.string().optional(),
-  computedRole: z48.string().optional(),
-  attributes: z48.record(z48.string(), z48.string()).optional(),
-  framePath: z48.array(z48.number()).optional(),
-  frameUrl: z48.string().optional()
-});
-var recordedEventSchema = z48.looseObject({
-  id: z48.string(),
-  type: z48.string(),
-  timestamp: z48.number(),
-  url: z48.string(),
-  tabId: z48.number().optional(),
-  frameId: z48.number().optional(),
-  framePath: z48.array(z48.number()).optional(),
+  tagName: z50.string(),
+  textContent: z50.string().optional(),
+  ariaLabel: z50.string().optional(),
+  computedRole: z50.string().optional(),
+  attributes: z50.record(z50.string(), z50.string()).optional(),
+  framePath: z50.array(z50.number()).optional(),
+  frameUrl: z50.string().optional()
+});
+var recordedEventSchema = z50.looseObject({
+  id: z50.string(),
+  type: z50.string(),
+  timestamp: z50.number(),
+  url: z50.string(),
+  tabId: z50.number().optional(),
+  frameId: z50.number().optional(),
+  framePath: z50.array(z50.number()).optional(),
   element: elementInfoSchema.optional()
 });
-var RedactedMcpServerConfigSchema = z49.object({
+var RedactedMcpServerConfigSchema = z51.object({
   type: TransportTypeSchema,
   integrationSlug: IntegrationSlugSchema,
-  instanceId: z49.string().nullable()
-});
-var ThreadContextMessageSchema = z49.object({
-  role: z49.enum(["user", "assistant"]),
-  content: z49.string()
-});
-var ChatFileReferenceSchema = z49.object({
-  id: z49.string(),
-  name: z49.string(),
-  mimetype: z49.string(),
-  size: z49.number(),
-  platform: z49.enum(["slack", "teams"]),
-  workspaceId: z49.string(),
-  channelId: z49.string()
-});
-var ResolvedSubAgentSchema = z49.object({
-  agentId: z49.string().uuid(),
-  buildId: z49.string().uuid(),
-  name: z49.string().min(1).max(64).regex(/^[a-z0-9-]+$/).describe(
+  instanceId: z51.string().nullable()
+});
+var ThreadContextMessageSchema = z51.object({
+  role: z51.enum(["user", "assistant"]),
+  content: z51.string()
+});
+var ChatFileReferenceSchema = z51.object({
+  id: z51.string(),
+  name: z51.string(),
+  mimetype: z51.string(),
+  size: z51.number(),
+  platform: z51.enum(["slack", "teams"]),
+  workspaceId: z51.string(),
+  channelId: z51.string()
+});
+var ResolvedSubAgentSchema = z51.object({
+  agentId: z51.string().uuid(),
+  buildId: z51.string().uuid(),
+  name: z51.string().min(1).max(64).regex(/^[a-z0-9-]+$/).describe(
     "Stable slug used as the Claude Code subagent name (kebab-case, \u226464 chars)"
   ),
-  description: z49.string().describe(
+  description: z51.string().describe(
     "Routing description Claude uses to decide when to delegate to this subagent"
   ),
-  prompt: z49.string().describe("System prompt (SOP) for this subagent"),
-  model: z49.string().optional().describe("Optional Claude model identifier override for this subagent"),
-  mcpServers: z49.record(z49.string(), RedactedMcpServerConfigSchema).default({}).describe(
+  prompt: z51.string().describe("System prompt (SOP) for this subagent"),
+  model: z51.string().optional().describe("Optional Claude model identifier override for this subagent"),
+  mcpServers: z51.record(z51.string(), RedactedMcpServerConfigSchema).default({}).describe(
     "Redacted MCP server configs scoped to this subagent. Secrets resolved at execution time."
   )
 });
 var RunConfigSchema = AgentConfigSchema.extend({
-  task: z49.string(),
-  mcpServers: z49.record(z49.string(), RedactedMcpServerConfigSchema),
-  subAgents: z49.array(ResolvedSubAgentSchema).optional().default([]),
-  conversationHistory: z49.array(ThreadContextMessageSchema).optional(),
-  chatFiles: z49.array(ChatFileReferenceSchema).optional(),
+  task: z51.string(),
+  mcpServers: z51.record(z51.string(), RedactedMcpServerConfigSchema),
+  subAgents: z51.array(ResolvedSubAgentSchema).optional().default([]),
+  conversationHistory: z51.array(ThreadContextMessageSchema).optional(),
+  chatFiles: z51.array(ChatFileReferenceSchema).optional(),
   /** IANA timezone (e.g. `"Europe/Prague"`). Consumers should fall back to UTC when absent. */
-  timezone: z49.string().optional()
+  timezone: z51.string().optional()
 });
-var StoredRunConfigV0Schema = z49.object({
-  version: z49.literal("v0")
+var StoredRunConfigV0Schema = z51.object({
+  version: z51.literal("v0")
 });
-var StoredRunConfigV1Schema = z49.object({
-  version: z49.literal("v1"),
+var StoredRunConfigV1Schema = z51.object({
+  version: z51.literal("v1"),
   data: RunConfigSchema
 });
-var StoredRunConfigSchema = z49.union([
+var StoredRunConfigSchema = z51.union([
   StoredRunConfigV0Schema,
   StoredRunConfigV1Schema
 ]);
@@ -6936,285 +7532,260 @@ function isRunConfig(config) {
 }
 __name(isRunConfig, "isRunConfig");
 __name2(isRunConfig, "isRunConfig");
-var skillApiSchema = z50.object({
-  id: z50.string(),
-  name: z50.string(),
-  description: z50.string(),
+var skillApiSchema = z52.object({
+  id: z52.string(),
+  name: z52.string(),
+  description: z52.string(),
   // System skills have null team_id.
-  team_id: z50.string().nullable()
+  team_id: z52.string().nullable()
 });
-var listSkillsResponseSchema = z50.object({
-  skills: z50.array(skillApiSchema)
+var listSkillsResponseSchema = z52.object({
+  skills: z52.array(skillApiSchema)
 });
-var systemSkillSchema = z50.object({
-  id: z50.string(),
-  name: z50.string(),
-  description: z50.string()
-});
-var listSystemSkillsResponseSchema = z50.object({
-  skills: z50.array(systemSkillSchema)
-});
-var skillFileItemSchema = z50.object({
-  name: z50.string(),
-  path: z50.string(),
-  size: z50.number().optional(),
-  contentType: z50.string().optional(),
-  updatedAt: z50.string().optional()
-});
-var listSkillFilesResponseSchema = z50.object({
-  files: z50.array(skillFileItemSchema)
-});
-var getSkillFileContentResponseSchema = z50.object({
-  content: z50.string(),
-  path: z50.string(),
-  contentType: z50.string().optional()
-});
-var updateSkillFileBodySchema = z50.object({
-  content: z50.string()
-});
-var updateSkillFileResponseSchema = z50.object({
-  success: z50.boolean(),
-  message: z50.string(),
-  skill: z50.object({
-    id: z50.string(),
-    name: z50.string(),
-    description: z50.string()
+var systemSkillSchema = z52.object({
+  id: z52.string(),
+  name: z52.string(),
+  description: z52.string()
+});
+var listSystemSkillsResponseSchema = z52.object({
+  skills: z52.array(systemSkillSchema)
+});
+var skillFileItemSchema = z52.object({
+  name: z52.string(),
+  path: z52.string(),
+  size: z52.number().optional(),
+  contentType: z52.string().optional(),
+  updatedAt: z52.string().optional()
+});
+var listSkillFilesResponseSchema = z52.object({
+  files: z52.array(skillFileItemSchema)
+});
+var getSkillFileContentResponseSchema = z52.object({
+  content: z52.string(),
+  path: z52.string(),
+  contentType: z52.string().optional()
+});
+var updateSkillFileBodySchema = z52.object({
+  content: z52.string()
+});
+var updateSkillFileResponseSchema = z52.object({
+  success: z52.boolean(),
+  message: z52.string(),
+  skill: z52.object({
+    id: z52.string(),
+    name: z52.string(),
+    description: z52.string()
   }).optional()
 });
-var deleteSkillResponseSchema = z50.object({
-  success: z50.boolean(),
-  message: z50.string()
+var deleteSkillResponseSchema = z52.object({
+  success: z52.boolean(),
+  message: z52.string()
 });
-var generateSkillBodySchema = z50.object({
-  prompt: z50.string().min(1).max(2e3),
-  existingContent: z50.string().max(2e4).optional()
+var generateSkillBodySchema = z52.object({
+  prompt: z52.string().min(1).max(2e3),
+  existingContent: z52.string().max(2e4).optional()
 });
-var generateSkillResponseSchema = z50.object({
-  content: z50.string()
+var generateSkillResponseSchema = z52.object({
+  content: z52.string()
 });
-var skillAssignmentSchema = z50.object({
-  id: z50.string(),
-  name: z50.string()
+var skillAssignmentSchema = z52.object({
+  id: z52.string(),
+  name: z52.string()
 });
-var listSkillAssignmentsResponseSchema = z50.object({
-  assignments: z50.array(skillAssignmentSchema),
-  total: z50.number()
+var listSkillAssignmentsResponseSchema = z52.object({
+  assignments: z52.array(skillAssignmentSchema),
+  total: z52.number()
 });
-var teamInvitationApiSchema = z51.object({
-  id: z51.string(),
-  team_id: z51.string(),
-  email: z51.email(),
-  invited_by: z51.string(),
-  role: z51.string(),
-  status: z51.string(),
-  name: z51.string().nullable(),
-  created_at: z51.string(),
-  process_id: z51.guid().nullable().optional()
-});
-var teamInvitationDetailApiSchema = z51.object({
-  id: z51.string(),
-  team_id: z51.string(),
-  email: z51.email(),
-  invited_by: z51.string(),
-  role: z51.string(),
-  status: z51.string(),
-  name: z51.string().nullable(),
-  created_at: z51.string(),
-  process_id: z51.guid().nullable().optional(),
-  team: z51.object({
-    id: z51.string(),
-    name: z51.string()
+var teamInvitationApiSchema = z53.object({
+  id: z53.string(),
+  team_id: z53.string(),
+  email: z53.email(),
+  invited_by: z53.string(),
+  role: z53.string(),
+  status: z53.string(),
+  name: z53.string().nullable(),
+  created_at: z53.string(),
+  process_id: z53.guid().nullable().optional()
+});
+var teamInvitationDetailApiSchema = z53.object({
+  id: z53.string(),
+  team_id: z53.string(),
+  email: z53.email(),
+  invited_by: z53.string(),
+  role: z53.string(),
+  status: z53.string(),
+  name: z53.string().nullable(),
+  created_at: z53.string(),
+  process_id: z53.guid().nullable().optional(),
+  team: z53.object({
+    id: z53.string(),
+    name: z53.string()
   }),
-  invitedBy: z51.object({
-    id: z51.string(),
-    name: z51.string().nullable(),
-    email: z51.email()
+  invitedBy: z53.object({
+    id: z53.string(),
+    name: z53.string().nullable(),
+    email: z53.email()
   }),
-  process: z51.object({
-    id: z51.string(),
-    name: z51.string()
+  process: z53.object({
+    id: z53.string(),
+    name: z53.string()
   }).optional()
 });
-var createTeamInvitationRequestSchema = z51.object({
-  email: z51.email(),
-  role: z51.string(),
-  processId: z51.guid().optional()
-});
-var acceptTeamInvitationRequestSchema = z51.object({
-  name: z51.string().optional()
-});
-var bulkInviteResponseSchema = z51.object({
-  succeeded: z51.number(),
-  skipped: z51.number(),
-  failed: z51.number()
-});
-var teamDiscoveryModeSchema = z52.enum(["request", "auto"]);
-var BrowserLocationSchema = z52.union([
-  z52.literal("cz"),
-  z52.literal("de"),
-  z52.literal("fr"),
-  z52.literal("gb"),
-  z52.literal("it"),
-  z52.literal("pl"),
-  z52.literal("sk")
+var createTeamInvitationRequestSchema = z53.object({
+  email: z53.email(),
+  role: z53.string(),
+  processId: z53.guid().optional()
+});
+var acceptTeamInvitationRequestSchema = z53.object({
+  name: z53.string().optional()
+});
+var bulkInviteResponseSchema = z53.object({
+  succeeded: z53.number(),
+  skipped: z53.number(),
+  failed: z53.number()
+});
+var teamDiscoveryModeSchema = z54.enum(["request", "auto"]);
+var BrowserLocationSchema = z54.union([
+  z54.literal("cz"),
+  z54.literal("de"),
+  z54.literal("fr"),
+  z54.literal("gb"),
+  z54.literal("it"),
+  z54.literal("pl"),
+  z54.literal("sk")
 ]);
-var teamMemberApiSchema = z52.object({
-  id: z52.guid(),
-  name: z52.string().nullable(),
-  email: z52.email(),
-  role: z52.string(),
-  inheritedFromOrg: z52.boolean().default(false)
-});
-var listTeamMembersResponseSchema = z52.object({
-  members: z52.array(teamMemberApiSchema),
-  total: z52.number().int().nonnegative(),
-  limit: z52.number().int().positive(),
-  offset: z52.number().int().nonnegative()
-});
-var updateMemberRoleRequestSchema = z52.object({
-  role: z52.string()
-});
-var removeMemberResponseSchema = z52.object({
-  success: z52.literal(true),
-  nextTeamId: z52.guid().nullable(),
-  planType: z52.enum(["pro", "enterprise"]).nullable()
-});
-var getMemberMeResponseSchema = z52.object({
-  role: z52.string().nullable()
-});
-var addTeamMemberRequestSchema = z52.object({
-  userId: z52.guid(),
-  role: z52.string()
-});
-var updateTeamRequestSchema = z52.object({
-  name: z52.string().min(1).optional(),
-  slack_team_id: z52.string().optional(),
+var teamMemberApiSchema = z54.object({
+  id: z54.guid(),
+  name: z54.string().nullable(),
+  email: z54.email(),
+  role: z54.string(),
+  inheritedFromOrg: z54.boolean().default(false)
+});
+var listTeamMembersResponseSchema = z54.object({
+  members: z54.array(teamMemberApiSchema),
+  total: z54.number().int().nonnegative(),
+  limit: z54.number().int().positive(),
+  offset: z54.number().int().nonnegative()
+});
+var updateMemberRoleRequestSchema = z54.object({
+  role: z54.string()
+});
+var removeMemberResponseSchema = z54.object({
+  success: z54.literal(true),
+  nextTeamId: z54.guid().nullable(),
+  planType: z54.enum(["pro", "enterprise"]).nullable()
+});
+var getMemberMeResponseSchema = z54.object({
+  role: z54.string().nullable()
+});
+var addTeamMemberRequestSchema = z54.object({
+  userId: z54.guid(),
+  role: z54.string()
+});
+var updateTeamRequestSchema = z54.object({
+  name: z54.string().min(1).optional(),
+  slack_team_id: z54.string().optional(),
   discovery_mode: teamDiscoveryModeSchema.optional()
 });
-var teamApiSchema = z52.object({
-  id: z52.guid(),
-  name: z52.string(),
-  created_at: z52.string(),
-  organization_id: z52.guid().nullable(),
-  slack_team_id: z52.string().nullable(),
+var teamApiSchema = z54.object({
+  id: z54.guid(),
+  name: z54.string(),
+  created_at: z54.string(),
+  organization_id: z54.guid().nullable(),
+  slack_team_id: z54.string().nullable(),
   discovery_mode: teamDiscoveryModeSchema
 });
 var TEAM_CONFIG_VERSION = 1;
-var teamConfigDataSchema = z52.object({
+var teamConfigDataSchema = z54.object({
   browserProviderOverride: BrowserProviderTypeSchema.nullable().optional(),
   browserLocationOverride: BrowserLocationSchema.nullable().optional()
 });
-var teamConfigSchema = z52.object({
-  version: z52.literal(TEAM_CONFIG_VERSION),
+var teamConfigSchema = z54.object({
+  version: z54.literal(TEAM_CONFIG_VERSION),
   data: teamConfigDataSchema
 });
-var listTeamInvitesResponseSchema = z52.object({
-  invitations: z52.array(teamInvitationApiSchema)
-});
-var teamInsightsCopilotSchema = z53.object({
-  id: z53.guid(),
-  name: z53.string(),
-  teamName: z53.string().nullable().optional(),
-  created_at: z53.string().nullable(),
-  updated_at: z53.string().nullable(),
-  team_id: z53.string().nullable(),
-  thread_id: z53.string().nullable(),
-  slack_enabled: z53.boolean().nullable()
-});
-var teamInsightsUserProfileSchema = z53.object({
-  id: z53.guid(),
-  name: z53.string().nullable(),
-  email: z53.string()
+var listTeamInvitesResponseSchema = z54.object({
+  invitations: z54.array(teamInvitationApiSchema)
+});
+var teamInsightsCopilotSchema = z55.object({
+  id: z55.guid(),
+  name: z55.string(),
+  teamName: z55.string().nullable().optional(),
+  created_at: z55.string().nullable(),
+  updated_at: z55.string().nullable(),
+  team_id: z55.string().nullable(),
+  thread_id: z55.string().nullable(),
+  slack_enabled: z55.boolean().nullable()
+});
+var teamInsightsUserProfileSchema = z55.object({
+  id: z55.guid(),
+  name: z55.string().nullable(),
+  email: z55.string()
 });
 var teamInsightsUserUsageSchema = teamInsightsUserProfileSchema.extend(
   {
-    runCount: z53.number(),
-    lastRun: z53.string().nullable()
+    runCount: z55.number(),
+    lastRun: z55.string().nullable()
   }
 );
-var teamInsightsMetricSourceSchema = z53.object({
+var teamInsightsMetricSourceSchema = z55.object({
   source: agentRunSourceSchema,
-  runsTotal: z53.number(),
-  completedRuns: z53.number()
+  runsTotal: z55.number(),
+  completedRuns: z55.number()
 });
 var teamInsightsCopilotWithRunsSchema = teamInsightsCopilotSchema.extend({
-  integrations: z53.array(z53.string()),
-  uniqueUsersCount: z53.number(),
-  users: z53.array(teamInsightsUserUsageSchema),
-  totalRuns: z53.number(),
-  completedRuns: z53.number(),
-  totalTimeSpentMs: z53.number(),
-  averageTimeSpentMs: z53.number(),
-  completedRunsWithTiming: z53.number(),
-  sources: z53.array(teamInsightsMetricSourceSchema)
-});
-var teamInsightsAgentsRunResponseSchema = z53.object({
-  data: z53.array(teamInsightsCopilotWithRunsSchema),
-  total: z53.number()
-});
-var teamInsightsMetricsResponseSchema = z53.object({
-  runsTotal: z53.number(),
-  completedRuns: z53.number(),
-  sources: z53.array(teamInsightsMetricSourceSchema)
-});
-var teamInsightsUserAgentRunSchema = z53.object({
-  id: z53.guid(),
-  created_at: z53.string(),
-  updated_at: z53.string(),
-  agent_id: z53.guid(),
-  agent_name: z53.string(),
-  build_id: z53.guid(),
-  source: z53.string().nullable(),
-  started_at: z53.string().nullable(),
-  completed_at: z53.string().nullable()
-});
-var teamInsightsAgentSchema = z53.object({
-  id: z53.guid(),
-  name: z53.string(),
-  teamName: z53.string().nullable().optional(),
-  runs: z53.array(teamInsightsUserAgentRunSchema)
+  integrations: z55.array(z55.string()),
+  uniqueUsersCount: z55.number(),
+  users: z55.array(teamInsightsUserUsageSchema),
+  totalRuns: z55.number(),
+  completedRuns: z55.number(),
+  totalTimeSpentMs: z55.number(),
+  averageTimeSpentMs: z55.number(),
+  completedRunsWithTiming: z55.number(),
+  sources: z55.array(teamInsightsMetricSourceSchema)
+});
+var teamInsightsAgentsRunResponseSchema = z55.object({
+  data: z55.array(teamInsightsCopilotWithRunsSchema),
+  total: z55.number()
+});
+var teamInsightsMetricsResponseSchema = z55.object({
+  runsTotal: z55.number(),
+  completedRuns: z55.number(),
+  sources: z55.array(teamInsightsMetricSourceSchema)
+});
+var teamInsightsUserAgentRunSchema = z55.object({
+  id: z55.guid(),
+  created_at: z55.string(),
+  updated_at: z55.string(),
+  agent_id: z55.guid(),
+  agent_name: z55.string(),
+  build_id: z55.guid(),
+  source: z55.string().nullable(),
+  started_at: z55.string().nullable(),
+  completed_at: z55.string().nullable()
+});
+var teamInsightsAgentSchema = z55.object({
+  id: z55.guid(),
+  name: z55.string(),
+  teamName: z55.string().nullable().optional(),
+  runs: z55.array(teamInsightsUserAgentRunSchema)
 });
 var teamInsightsUserWithAgentsAndRunsSchema = teamInsightsUserProfileSchema.extend({
-  agents: z53.array(teamInsightsAgentSchema),
-  runs: z53.array(teamInsightsUserAgentRunSchema),
-  totalRuns: z53.number()
-});
-var teamInsightsUsersResponseSchema = z53.object({
-  data: z53.array(teamInsightsUserWithAgentsAndRunsSchema),
-  total: z53.number()
+  agents: z55.array(teamInsightsAgentSchema),
+  runs: z55.array(teamInsightsUserAgentRunSchema),
+  totalRuns: z55.number()
 });
-var createTeamInviteLinkRequestSchema = z54.object({
-  frontendUrl: z54.url()
+var teamInsightsUsersResponseSchema = z55.object({
+  data: z55.array(teamInsightsUserWithAgentsAndRunsSchema),
+  total: z55.number()
 });
-var getTeamInviteLinkQuerySchema = z54.object({
-  frontendUrl: z54.url()
+var userDismissalListResponseSchema = z56.object({
+  data: z56.array(z56.string())
 });
-var teamInviteLinkCreatorSchema = z54.object({
-  id: z54.guid(),
-  name: z54.string().nullable(),
-  email: z54.email()
+var userDismissalMutationSchema = z56.object({
+  elementKey: z56.string()
 });
-var teamInviteLinkSchema = z54.object({
-  id: z54.guid(),
-  url: z54.url().optional(),
-  createdAt: z54.string(),
-  createdBy: teamInviteLinkCreatorSchema
-});
-var getTeamInviteLinkResponseSchema = z54.object({
-  hasLink: z54.boolean(),
-  link: teamInviteLinkSchema.optional()
-});
-var joinLinkInfoResponseSchema = z54.object({
-  valid: z54.boolean(),
-  teamName: z54.string().optional(),
-  teamId: z54.guid().optional(),
-  reason: z54.enum(["invalid", "expired"]).optional()
-});
-var acceptJoinLinkResponseSchema = z54.object({
-  success: z54.boolean(),
-  teamId: z54.guid()
-});
-var caseFilterStatusSchema = z55.enum([
+var caseFilterStatusSchema = z57.enum([
   "pending",
   "claimed",
   "completed",
@@ -7222,19 +7793,19 @@ var caseFilterStatusSchema = z55.enum([
   "needs_input",
   "postponed"
 ]);
-var casesFiltersSchema = z55.object({
-  status: z55.array(caseFilterStatusSchema).optional(),
-  created_at_from: z55.string().optional(),
-  updated_at_from: z55.string().optional(),
-  labels: z55.record(z55.string(), z55.array(z55.string())).optional()
+var casesFiltersSchema = z57.object({
+  status: z57.array(caseFilterStatusSchema).optional(),
+  created_at_from: z57.string().optional(),
+  updated_at_from: z57.string().optional(),
+  labels: z57.record(z57.string(), z57.array(z57.string())).optional()
 });
-var casesListRequestBodySchema = z55.object({
+var casesListRequestBodySchema = z57.object({
   filters: casesFiltersSchema.default({}),
-  limit: z55.int().min(1).max(100).default(25),
-  offset: z55.int().min(0).default(0),
-  sort_by: z55.enum(["created_at", "updated_at", "postponed_to"]).default("created_at"),
-  sort_order: z55.enum(["asc", "desc"]).default("desc"),
-  search: z55.string().optional()
+  limit: z57.int().min(1).max(100).default(25),
+  offset: z57.int().min(0).default(0),
+  sort_by: z57.enum(["created_at", "updated_at", "postponed_to"]).default("created_at"),
+  sort_order: z57.enum(["asc", "desc"]).default("desc"),
+  search: z57.string().optional()
 });
 function toBase64(input) {
   if (typeof btoa === "function") {
@@ -7329,7 +7900,7 @@ function setFilterValuesByCategoryKey(filters, categoryKey, values) {
       const { status: _, ...rest } = filters;
       return rest;
     }
-    const parsed = z55.array(caseFilterStatusSchema).safeParse(values);
+    const parsed = z57.array(caseFilterStatusSchema).safeParse(values);
     if (!parsed.success) {
       return filters;
     }
@@ -8010,7 +8581,9 @@ var TABLE_COLUMNS2 = [
   }
 ];
 function registerAgentsCaseTriggersList(caseTriggers) {
-  caseTriggers.command("list <agent-id>", { isDefault: true }).description("List case triggers configured for an agent").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(agentId, options) {
+  caseTriggers.command("list <agent-id>", { isDefault: true }).description(
+    "List case triggers configured for an agent (use to find the trigger ID for get / update / delete)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(agentId, options) {
     const id = trimRequired(agentId, "<agent-id>");
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
     const raw = await httpRequest({
@@ -8149,7 +8722,9 @@ function renderTriggerDetails3(trigger) {
 }
 __name(renderTriggerDetails3, "renderTriggerDetails");
 function registerAgentsCaseTriggersUpdate(caseTriggers) {
-  caseTriggers.command("update <agent-id> <trigger-id>").description("Update a case trigger").option("--queue <id>", "new queue ID").option("--enable", "enable the trigger").option("--disable", "disable the trigger").option("--concurrency <n>", "new max number of concurrent runs").option("--clear-concurrency", "remove the concurrency limit (unlimited)").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function updateAction(agentId, triggerId, options) {
+  caseTriggers.command("update <agent-id> <trigger-id>").description(
+    "Update a case trigger \u2014 enable, disable, change its queue, or set concurrency"
+  ).option("--queue <id>", "new queue ID").option("--enable", "enable the trigger").option("--disable", "disable the trigger").option("--concurrency <n>", "new max number of concurrent runs").option("--clear-concurrency", "remove the concurrency limit (unlimited)").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function updateAction(agentId, triggerId, options) {
     const trimmedAgentId = trimRequired(agentId, "<agent-id>");
     const trimmedTriggerId = trimRequired(triggerId, "<trigger-id>");
     const body = buildBody2(options);
@@ -8196,35 +8771,35 @@ import { readFile as readFile2 } from "node:fs/promises";
 import { confirm as confirm2, isCancel as isCancel2, text } from "@clack/prompts";
 
 // src/api/agent-schemas.ts
-import { z as z56 } from "zod";
-var publicAgentSchema = z56.object({
-  id: z56.string(),
-  name: z56.string(),
-  slack_enabled: z56.boolean().nullish(),
-  microsoft_teams_enabled: z56.boolean().nullish(),
-  agentic_memory_enabled: z56.boolean().nullish(),
-  thread_id: z56.string().nullish(),
-  created_at: z56.string().nullish(),
-  updated_at: z56.string().nullish()
-});
-var publicBuildSchema = z56.object({
-  id: z56.string(),
-  agent_id: z56.string(),
-  name: z56.string(),
-  revision_number: z56.number().nullish(),
-  created_at: z56.string().nullish(),
-  updated_at: z56.string().nullish()
-});
-var listAgentsResponseSchema = z56.object({
-  agents: z56.array(publicAgentSchema),
-  total: z56.number().nullish(),
-  limit: z56.number().nullish(),
-  offset: z56.number().nullish()
-});
-var getAgentResponseSchema = z56.object({
+import { z as z58 } from "zod";
+var publicAgentSchema = z58.object({
+  id: z58.string(),
+  name: z58.string(),
+  slack_enabled: z58.boolean().nullish(),
+  microsoft_teams_enabled: z58.boolean().nullish(),
+  agentic_memory_enabled: z58.boolean().nullish(),
+  thread_id: z58.string().nullish(),
+  created_at: z58.string().nullish(),
+  updated_at: z58.string().nullish()
+});
+var publicBuildSchema = z58.object({
+  id: z58.string(),
+  agent_id: z58.string(),
+  name: z58.string(),
+  revision_number: z58.number().nullish(),
+  created_at: z58.string().nullish(),
+  updated_at: z58.string().nullish()
+});
+var listAgentsResponseSchema = z58.object({
+  agents: z58.array(publicAgentSchema),
+  total: z58.number().nullish(),
+  limit: z58.number().nullish(),
+  offset: z58.number().nullish()
+});
+var getAgentResponseSchema = z58.object({
   agent: publicAgentSchema
 });
-var createAgentResponseSchema = z56.object({
+var createAgentResponseSchema = z58.object({
   agent: publicAgentSchema,
   build: publicBuildSchema.optional()
 });
@@ -8528,27 +9103,27 @@ function registerAgentsList(agents) {
 __name(registerAgentsList, "registerAgentsList");
 
 // src/api/schedule-schemas.ts
-import { z as z57 } from "zod";
-var publicScheduleSchema = z57.object({
-  id: z57.string(),
-  build_id: z57.string(),
-  agent_id: z57.string(),
-  user_id: z57.string(),
-  enabled: z57.boolean(),
-  frequency: z57.string(),
-  time: z57.string().nullish(),
-  timezone: z57.string(),
-  day: z57.string().nullish(),
-  day_of_month: z57.number().nullish(),
-  cron: z57.string().nullish(),
-  source: z57.string().nullish(),
-  task: z57.string().nullish(),
-  recurring: z57.boolean().nullish(),
-  created_at: z57.string(),
-  updated_at: z57.string()
-});
-var listSchedulesResponseSchema = z57.object({
-  schedules: z57.array(publicScheduleSchema)
+import { z as z59 } from "zod";
+var publicScheduleSchema = z59.object({
+  id: z59.string(),
+  build_id: z59.string(),
+  agent_id: z59.string(),
+  user_id: z59.string(),
+  enabled: z59.boolean(),
+  frequency: z59.string(),
+  time: z59.string().nullish(),
+  timezone: z59.string(),
+  day: z59.string().nullish(),
+  day_of_month: z59.number().nullish(),
+  cron: z59.string().nullish(),
+  source: z59.string().nullish(),
+  task: z59.string().nullish(),
+  recurring: z59.boolean().nullish(),
+  created_at: z59.string(),
+  updated_at: z59.string()
+});
+var listSchedulesResponseSchema = z59.object({
+  schedules: z59.array(publicScheduleSchema)
 });
 
 // src/commands/agents/schedules.ts
@@ -9020,54 +9595,54 @@ function fieldsToSearchParams(fields) {
 __name(fieldsToSearchParams, "fieldsToSearchParams");
 
 // src/api/integration-schemas.ts
-import { z as z58 } from "zod";
-var integrationSchema = z58.object({
-  id: z58.string(),
-  name: z58.string(),
-  type: z58.string(),
-  provider: z58.string(),
-  user_id: z58.string().nullable(),
-  team_id: z58.string(),
-  server_url: z58.string().optional(),
-  transport_type: z58.string().optional(),
-  auth_method: z58.string().nullish(),
-  composio_mcp_id: z58.string().nullish(),
-  custom_integration_id: z58.string().nullish(),
-  icon_url: z58.string().nullish(),
-  oauth_provider: z58.string().nullish(),
-  oauth_scopes: z58.array(z58.string()).nullish(),
-  integration_id: z58.string().nullish(),
-  created_at: z58.string(),
-  updated_at: z58.string()
-});
-var integrationsListResponseSchema2 = z58.object({
-  integrations: z58.array(integrationSchema)
+import { z as z60 } from "zod";
+var integrationSchema = z60.object({
+  id: z60.string(),
+  name: z60.string(),
+  type: z60.string(),
+  provider: z60.string(),
+  user_id: z60.string().nullable(),
+  team_id: z60.string(),
+  server_url: z60.string().optional(),
+  transport_type: z60.string().optional(),
+  auth_method: z60.string().nullish(),
+  composio_mcp_id: z60.string().nullish(),
+  custom_integration_id: z60.string().nullish(),
+  icon_url: z60.string().nullish(),
+  oauth_provider: z60.string().nullish(),
+  oauth_scopes: z60.array(z60.string()).nullish(),
+  integration_id: z60.string().nullish(),
+  created_at: z60.string(),
+  updated_at: z60.string()
+});
+var integrationsListResponseSchema2 = z60.object({
+  integrations: z60.array(integrationSchema)
 });
 var connectionResponseSchema = integrationSchema;
-var buildIntegrationConfigSchema2 = z58.object({
-  id: z58.string(),
-  integration_id: z58.string().nullable(),
-  custom_integration_id: z58.string().nullable(),
-  integration_type: z58.string(),
-  integration_name: z58.string(),
-  created_at: z58.string()
+var buildIntegrationConfigSchema2 = z60.object({
+  id: z60.string(),
+  integration_id: z60.string().nullable(),
+  custom_integration_id: z60.string().nullable(),
+  integration_type: z60.string(),
+  integration_name: z60.string(),
+  created_at: z60.string()
 });
-var listBuildIntegrationsResponseSchema2 = z58.object({
-  integrations: z58.array(buildIntegrationConfigSchema2)
+var listBuildIntegrationsResponseSchema2 = z60.object({
+  integrations: z60.array(buildIntegrationConfigSchema2)
 });
-var attachBuildIntegrationsResponseSchema = z58.object({
-  success: z58.boolean(),
-  count: z58.number()
+var attachBuildIntegrationsResponseSchema = z60.object({
+  success: z60.boolean(),
+  count: z60.number()
 });
-var buildIntegrationConnectionSchema = z58.object({
-  connection_id: z58.string(),
-  created_at: z58.string()
+var buildIntegrationConnectionSchema = z60.object({
+  connection_id: z60.string(),
+  created_at: z60.string()
 });
-var listBuildIntegrationConnectionsResponseSchema = z58.object({
-  connections: z58.array(buildIntegrationConnectionSchema)
+var listBuildIntegrationConnectionsResponseSchema = z60.object({
+  connections: z60.array(buildIntegrationConnectionSchema)
 });
-var successResponseSchema = z58.object({
-  success: z58.boolean()
+var successResponseSchema = z60.object({
+  success: z60.boolean()
 });
 
 // src/commands/build-integrations/attach.ts
@@ -9312,43 +9887,43 @@ function registerBuildIntegrations(program) {
 __name(registerBuildIntegrations, "registerBuildIntegrations");
 
 // src/api/build-schemas.ts
-import { z as z60 } from "zod";
+import { z as z62 } from "zod";
 
 // src/api/json-value.ts
-import { z as z59 } from "zod";
-var jsonValueSchema = z59.lazy(
-  () => z59.union([
-    z59.string(),
-    z59.number(),
-    z59.boolean(),
-    z59.null(),
-    z59.array(jsonValueSchema),
-    z59.record(z59.string(), jsonValueSchema)
+import { z as z61 } from "zod";
+var jsonValueSchema = z61.lazy(
+  () => z61.union([
+    z61.string(),
+    z61.number(),
+    z61.boolean(),
+    z61.null(),
+    z61.array(jsonValueSchema),
+    z61.record(z61.string(), jsonValueSchema)
   ])
 );
 
 // src/api/build-schemas.ts
-var publicBuildSchema2 = z60.object({
-  id: z60.string(),
-  agent_id: z60.string(),
-  name: z60.string(),
+var publicBuildSchema2 = z62.object({
+  id: z62.string(),
+  agent_id: z62.string(),
+  name: z62.string(),
   config: jsonValueSchema.nullish(),
-  revision_number: z60.number().nullish(),
-  created_at: z60.string().nullish(),
-  updated_at: z60.string().nullish()
+  revision_number: z62.number().nullish(),
+  created_at: z62.string().nullish(),
+  updated_at: z62.string().nullish()
 });
-var listBuildsResponseSchema2 = z60.object({
-  builds: z60.array(publicBuildSchema2),
-  total: z60.number().nullish(),
-  limit: z60.number().nullish(),
-  offset: z60.number().nullish()
+var listBuildsResponseSchema2 = z62.object({
+  builds: z62.array(publicBuildSchema2),
+  total: z62.number().nullish(),
+  limit: z62.number().nullish(),
+  offset: z62.number().nullish()
 });
-var getBuildResponseSchema = z60.object({
+var getBuildResponseSchema = z62.object({
   build: publicBuildSchema2
 });
-var createBuildResponseSchema = z60.object({
+var createBuildResponseSchema = z62.object({
   build: publicBuildSchema2,
-  agent: z60.object({ id: z60.string() })
+  agent: z62.object({ id: z62.string() })
 });
 
 // src/commands/builds/create.ts
@@ -9494,6 +10069,51 @@ function registerBuildsList(builds) {
 }
 __name(registerBuildsList, "registerBuildsList");
 
+// src/commands/builds/promote.ts
+import { z as z63 } from "zod";
+var promoteResponseSchema = z63.object({
+  success: z63.boolean()
+});
+function registerBuildsPromote(builds) {
+  builds.command("promote <id>").description(
+    "Promote a draft or historic revision to live. The live revision is used by triggers and new runs."
+  ).option(
+    "--name <text>",
+    "display name to set on the promoted revision (1-80 chars)"
+  ).option("--description <text>", "description for the promoted revision").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function promoteAction(id, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const body = {};
+    if (options.name !== void 0) {
+      body.revision_name = options.name;
+    }
+    if (options.description !== void 0) {
+      body.revision_description = options.description;
+    }
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v1/revisions/${encodeURIComponent(id)}/promote`,
+      apiKey,
+      apiBaseUrl,
+      body
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = promoteResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    if (!parsed.data.success) {
+      throw new CliError("Promotion failed.");
+    }
+    console.log(green(`Revision "${id}" promoted to live!`));
+  }, "promoteAction"));
+}
+__name(registerBuildsPromote, "registerBuildsPromote");
+
 // src/commands/builds/update.ts
 function registerBuildsUpdate(builds) {
   builds.command("update <revision-id>").description(
@@ -9561,6 +10181,7 @@ function registerBuilds(program) {
   registerBuildsGet(builds);
   registerBuildsCreate(builds);
   registerBuildsUpdate(builds);
+  registerBuildsPromote(builds);
 }
 __name(registerBuilds, "registerBuilds");
 
@@ -9925,7 +10546,7 @@ function registerCasesCreate(cases) {
     []
   ).option(
     "--from-file <path>",
-    'JSON file with a single case object or an array of cases (max 100). "-" reads from stdin.'
+    'JSON file with a single case object or an array of cases (max 100). Each case: {"title":"\u2026","data":"\u2026","labels":[{"key":"\u2026","value":"\u2026"}]}. "-" reads from stdin.'
   ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function createAction(options) {
     const body = await buildRequestBody(options);
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
@@ -10460,7 +11081,11 @@ function parseSortOrder(raw) {
 __name(parseSortOrder, "parseSortOrder");
 
 // src/commands/cases/runs.ts
-var TABLE_COLUMNS12 = [
+import { z as z64 } from "zod";
+var MIN_LIMIT4 = 1;
+var MAX_LIMIT4 = 10;
+var DEFAULT_LIMIT4 = 3;
+var RUNS_TABLE_COLUMNS = [
   { header: "RUN ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "AGENT", cell: /* @__PURE__ */ __name((row) => row.agent_name, "cell") },
   { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
@@ -10474,8 +11099,46 @@ var TABLE_COLUMNS12 = [
     cell: /* @__PURE__ */ __name((row) => row.has_pending_human_request ? row.pending_human_request_title ?? "(unknown)" : "", "cell")
   }
 ];
+var recentMessageSchema = z64.object({
+  id: z64.string(),
+  type: z64.string(),
+  role: z64.string(),
+  timestamp: z64.string(),
+  text_content: z64.string().nullish(),
+  tool_call: z64.object({ id: z64.string(), name: z64.string() }).passthrough().nullish(),
+  tool_result: z64.object({ tool_call_id: z64.string() }).passthrough().nullish()
+});
+var recentMessagesResponseSchema = z64.object({
+  messages: z64.array(recentMessageSchema)
+});
+var TEXT_PREVIEW_WIDTH = 60;
+var MESSAGES_TABLE_COLUMNS = [
+  { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
+  { header: "ROLE", cell: /* @__PURE__ */ __name((row) => row.role, "cell") },
+  { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
+  { header: "TIMESTAMP", cell: /* @__PURE__ */ __name((row) => row.timestamp, "cell") },
+  {
+    header: "PREVIEW",
+    cell: previewMessageCell,
+    maxWidth: TEXT_PREVIEW_WIDTH
+  }
+];
+function previewMessageCell(row) {
+  if (row.text_content) {
+    return row.text_content.replace(/\s+/g, " ").trim();
+  }
+  if (row.tool_call) {
+    return `tool_call ${row.tool_call.name}`;
+  }
+  if (row.tool_result) {
+    return `tool_result ${row.tool_result.tool_call_id}`;
+  }
+  return "";
+}
+__name(previewMessageCell, "previewMessageCell");
 function registerCasesRuns(cases) {
-  cases.command("runs <case-id>").description("List jobs (agent runs) that have worked on a case").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function runsAction(caseId, options) {
+  const runs = cases.command("runs").description("Manage jobs (agent runs) for a case");
+  runs.command("list <case-id>", { isDefault: true }).description("List jobs (agent runs) that have worked on a case").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(caseId, options) {
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
     const raw = await httpRequest({
       method: "GET",
@@ -10497,11 +11160,66 @@ function registerCasesRuns(cases) {
       console.log("No runs found for this case.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS12, parsed.data.runs));
+    console.log(renderTable(RUNS_TABLE_COLUMNS, parsed.data.runs));
     console.log(`Showing ${parsed.data.runs.length}`);
-  }, "runsAction"));
+  }, "listAction"));
+  runs.command("recent-messages <case-id> <run-id>").description(
+    "Show the latest messages from a Job on a case (assistant text and tool calls)"
+  ).option(
+    "--limit <n>",
+    `number of messages to return (${MIN_LIMIT4}-${MAX_LIMIT4}, default ${DEFAULT_LIMIT4})`
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function recentMessagesAction(caseId, runId, options) {
+    const limit = parseRecentMessageLimit(options.limit);
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const searchParams = new URLSearchParams();
+    if (limit !== DEFAULT_LIMIT4) {
+      searchParams.append("limit", String(limit));
+    }
+    const raw = await httpRequest({
+      method: "GET",
+      path: `/v1/cases/${encodeURIComponent(caseId)}/runs/${encodeURIComponent(runId)}/recent-messages`,
+      apiKey,
+      apiBaseUrl,
+      searchParams: searchParams.size > 0 ? searchParams : void 0
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = recentMessagesResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    if (parsed.data.messages.length === 0) {
+      console.log("No recent messages found.");
+      return;
+    }
+    console.log(renderTable(MESSAGES_TABLE_COLUMNS, parsed.data.messages));
+    console.log(
+      renderKeyValue([
+        { label: "Case", value: caseId },
+        { label: "Run", value: runId },
+        { label: "Messages", value: String(parsed.data.messages.length) }
+      ])
+    );
+  }, "recentMessagesAction"));
 }
 __name(registerCasesRuns, "registerCasesRuns");
+function parseRecentMessageLimit(raw) {
+  if (raw === void 0) {
+    return DEFAULT_LIMIT4;
+  }
+  const value = Number.parseInt(raw, 10);
+  if (Number.isNaN(value) || value < MIN_LIMIT4 || value > MAX_LIMIT4) {
+    throw new CliError(
+      `--limit must be an integer between ${MIN_LIMIT4} and ${MAX_LIMIT4}`
+    );
+  }
+  return value;
+}
+__name(parseRecentMessageLimit, "parseRecentMessageLimit");
 
 // src/commands/cases/index.ts
 function registerCases(program) {
@@ -10776,7 +11494,7 @@ function registerConnectionsGet(connections) {
 __name(registerConnectionsGet, "registerConnectionsGet");
 
 // src/commands/connections/list.ts
-var TABLE_COLUMNS13 = [
+var TABLE_COLUMNS12 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
@@ -10812,26 +11530,26 @@ function registerConnectionsList(connections) {
       console.log("No connections found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS13, rows));
+    console.log(renderTable(TABLE_COLUMNS12, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
 __name(registerConnectionsList, "registerConnectionsList");
 
 // src/commands/connections/probe.ts
-import { z as z61 } from "zod";
-var toolSchema = z61.object({
-  name: z61.string(),
-  description: z61.string().optional(),
-  input_schema: z61.record(z61.string(), z61.unknown()).optional()
+import { z as z65 } from "zod";
+var toolSchema = z65.object({
+  name: z65.string(),
+  description: z65.string().optional(),
+  input_schema: z65.record(z65.string(), z65.unknown()).optional()
 });
-var probeResponseSchema = z61.object({
-  success: z61.boolean(),
-  tools: z61.array(toolSchema).optional(),
-  error: z61.string().optional()
+var probeResponseSchema = z65.object({
+  success: z65.boolean(),
+  tools: z65.array(toolSchema).optional(),
+  error: z65.string().optional()
 });
 var DESCRIPTION_MAX_WIDTH = 80;
-var TABLE_COLUMNS14 = [
+var TABLE_COLUMNS13 = [
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
     header: "DESCRIPTION",
@@ -10887,7 +11605,7 @@ function registerConnectionsProbe(connections) {
       console.log("No tools found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS14, tools));
+    console.log(renderTable(TABLE_COLUMNS13, tools));
     console.log(
       `Showing ${tools.length} tool${tools.length === 1 ? "" : "s"}`
     );
@@ -11042,32 +11760,6 @@ function registerConnections(program) {
 }
 __name(registerConnections, "registerConnections");
 
-// src/commands/files/content.ts
-function registerFilesContent(files) {
-  files.command("content <path>").description("Get the content of a text file (binary files are rejected)").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function contentAction(filePath, options) {
-    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
-    const encodedPath = filePath.split("/").map((segment) => encodeURIComponent(segment)).join("/");
-    const raw = await httpRequest({
-      method: "GET",
-      path: `/v1/files/content/${encodedPath}`,
-      apiKey,
-      apiBaseUrl
-    });
-    if (options.json) {
-      printJson(raw);
-      return;
-    }
-    const parsed = teamFileContentResponseSchema.safeParse(raw);
-    if (!parsed.success) {
-      throw new CliError(
-        `Unexpected response from the API: ${parsed.error.message}`
-      );
-    }
-    process.stdout.write(parsed.data.content);
-  }, "contentAction"));
-}
-__name(registerFilesContent, "registerFilesContent");
-
 // src/commands/files/content-set.ts
 import { readFileSync as readFileSync3 } from "node:fs";
 function registerFilesContentSet(files) {
@@ -11130,6 +11822,32 @@ function readContent(options) {
 }
 __name(readContent, "readContent");
 
+// src/commands/files/content.ts
+function registerFilesContent(files) {
+  files.command("content <path>").description("Get the content of a text file (binary files are rejected)").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function contentAction(filePath, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const encodedPath = filePath.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+    const raw = await httpRequest({
+      method: "GET",
+      path: `/v1/files/content/${encodedPath}`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = teamFileContentResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    process.stdout.write(parsed.data.content);
+  }, "contentAction"));
+}
+__name(registerFilesContent, "registerFilesContent");
+
 // src/commands/files/delete.ts
 function registerFilesDelete(files) {
   files.command("delete <path>").description("Delete a team file").option("-y, --yes", "skip confirmation prompt").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function deleteAction(filePath, options) {
@@ -11198,7 +11916,7 @@ function registerFilesDownloadUrl(files) {
 __name(registerFilesDownloadUrl, "registerFilesDownloadUrl");
 
 // src/commands/files/list.ts
-var TABLE_COLUMNS15 = [
+var TABLE_COLUMNS14 = [
   { header: "PATH", cell: /* @__PURE__ */ __name((row) => row.path, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -11237,7 +11955,7 @@ function registerFilesList(files) {
       console.log("No files found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS15, parsed.data.files));
+    console.log(renderTable(TABLE_COLUMNS14, parsed.data.files));
     console.log(`Showing ${parsed.data.files.length}`);
   }, "listAction"));
 }
@@ -11487,7 +12205,7 @@ function registerIntegrationsCustom(integrations) {
 __name(registerIntegrationsCustom, "registerIntegrationsCustom");
 
 // src/commands/integrations/list.ts
-var TABLE_COLUMNS16 = [
+var TABLE_COLUMNS15 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
@@ -11521,7 +12239,7 @@ function registerIntegrationsList(integrations) {
       console.log("No integrations found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS16, rows));
+    console.log(renderTable(TABLE_COLUMNS15, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -12348,7 +13066,7 @@ function parseHeaders(raw) {
   return result;
 }
 __name(parseHeaders, "parseHeaders");
-var TABLE_COLUMNS17 = [
+var TABLE_COLUMNS16 = [
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "DESCRIPTION", cell: /* @__PURE__ */ __name((row) => row.description, "cell") }
 ];
@@ -12402,7 +13120,7 @@ function registerOauthMcpProbe(mcp) {
       console.log("No tools advertised by this MCP server.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS17, rows));
+    console.log(renderTable(TABLE_COLUMNS16, rows));
     console.log(`Showing ${rows.length}`);
   }, "probeMcpAction"));
 }
@@ -12477,7 +13195,7 @@ function registerOauth(program) {
 __name(registerOauth, "registerOauth");
 
 // src/commands/plugins/list.ts
-var TABLE_COLUMNS18 = [
+var TABLE_COLUMNS17 = [
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
   {
@@ -12511,7 +13229,7 @@ function registerPluginsList(plugins) {
       console.log("No plugins found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS18, parsed.data.plugins));
+    console.log(renderTable(TABLE_COLUMNS17, parsed.data.plugins));
     console.log(`Showing ${parsed.data.plugins.length}`);
   }, "listAction"));
 }
@@ -12709,7 +13427,7 @@ function registerProfiles(program) {
 __name(registerProfiles, "registerProfiles");
 
 // src/commands/queue-labels/index.ts
-var TABLE_COLUMNS19 = [
+var TABLE_COLUMNS18 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "KEY", cell: /* @__PURE__ */ __name((row) => row.key, "cell") },
   { header: "VALUE", cell: /* @__PURE__ */ __name((row) => row.value, "cell") },
@@ -12763,7 +13481,7 @@ function registerList2(labels) {
       console.log("No labels defined on this queue.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS19, parsed.data.labels));
+    console.log(renderTable(TABLE_COLUMNS18, parsed.data.labels));
     console.log(`Showing ${parsed.data.labels.length}`);
   }, "listAction"));
 }
@@ -13121,10 +13839,10 @@ function registerQueuesGet(queues) {
 __name(registerQueuesGet, "registerQueuesGet");
 
 // src/commands/queues/list.ts
-var DEFAULT_LIMIT4 = 20;
-var MIN_LIMIT4 = 1;
-var MAX_LIMIT4 = 100;
-var TABLE_COLUMNS20 = [
+var DEFAULT_LIMIT5 = 20;
+var MIN_LIMIT5 = 1;
+var MAX_LIMIT5 = 100;
+var TABLE_COLUMNS19 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -13135,11 +13853,11 @@ var TABLE_COLUMNS20 = [
   { header: "CREATED", cell: /* @__PURE__ */ __name((row) => row.created_at ?? "", "cell") }
 ];
 function registerQueuesList(queues) {
-  queues.command("list", { isDefault: true }).description("List case queues for your team").option("--limit <n>", `page size (${MIN_LIMIT4}-${MAX_LIMIT4})`).option("--offset <n>", "number of queues to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
+  queues.command("list", { isDefault: true }).description("List case queues for your team").option("--limit <n>", `page size (${MIN_LIMIT5}-${MAX_LIMIT5})`).option("--offset <n>", "number of queues to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT4,
-      min: MIN_LIMIT4,
-      max: MAX_LIMIT4
+      defaultValue: DEFAULT_LIMIT5,
+      min: MIN_LIMIT5,
+      max: MAX_LIMIT5
     });
     const offset = parseOffset(options.offset);
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
@@ -13168,7 +13886,7 @@ function registerQueuesList(queues) {
       console.log("No queues found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS20, response.queues));
+    console.log(renderTable(TABLE_COLUMNS19, response.queues));
     const resolvedOffset = response.offset ?? offset;
     const total = response.total ?? null;
     const summary = total === null ? `Showing ${response.queues.length} \xB7 offset ${resolvedOffset}` : `Showing ${response.queues.length} of ${total} \xB7 offset ${resolvedOffset}`;
@@ -13270,91 +13988,91 @@ function registerQueues(program) {
 __name(registerQueues, "registerQueues");
 
 // src/api/run-schemas.ts
-import { z as z62 } from "zod";
-var publicRunSchema = z62.object({
-  id: z62.string(),
-  agent_id: z62.string(),
-  build_id: z62.string(),
-  status: z62.string(),
-  source: z62.string().nullish(),
-  sandbox_id: z62.string().nullish(),
-  started_at: z62.string().nullish(),
-  completed_at: z62.string().nullish(),
-  created_at: z62.string(),
-  updated_at: z62.string().nullish(),
-  human_in_the_loop_enabled: z62.boolean().nullish()
-});
-var startRunResponseSchema = z62.object({
+import { z as z66 } from "zod";
+var publicRunSchema = z66.object({
+  id: z66.string(),
+  agent_id: z66.string(),
+  build_id: z66.string(),
+  status: z66.string(),
+  source: z66.string().nullish(),
+  sandbox_id: z66.string().nullish(),
+  started_at: z66.string().nullish(),
+  completed_at: z66.string().nullish(),
+  created_at: z66.string(),
+  updated_at: z66.string().nullish(),
+  human_in_the_loop_enabled: z66.boolean().nullish()
+});
+var startRunResponseSchema = z66.object({
   run: publicRunSchema
 });
-var questionOptionSchema = z62.object({
-  label: z62.string(),
-  description: z62.string().nullish()
+var questionOptionSchema = z66.object({
+  label: z66.string(),
+  description: z66.string().nullish()
 });
-var questionSchema = z62.object({
-  question: z62.string(),
-  header: z62.string().nullish(),
-  options: z62.array(questionOptionSchema).nullish(),
-  multi_select: z62.boolean().nullish()
+var questionSchema = z66.object({
+  question: z66.string(),
+  header: z66.string().nullish(),
+  options: z66.array(questionOptionSchema).nullish(),
+  multi_select: z66.boolean().nullish()
 });
-var pendingHumanRequestSchema = z62.object({
-  id: z62.string(),
-  title: z62.string(),
-  description: z62.string().nullish(),
-  created_at: z62.string(),
-  type: z62.string(),
-  questions: z62.array(questionSchema).nullish()
+var pendingHumanRequestSchema = z66.object({
+  id: z66.string(),
+  title: z66.string(),
+  description: z66.string().nullish(),
+  created_at: z66.string(),
+  type: z66.string(),
+  questions: z66.array(questionSchema).nullish()
 });
-var getRunResponseSchema = z62.object({
+var getRunResponseSchema = z66.object({
   run: publicRunSchema.nullable(),
   pending_human_request: pendingHumanRequestSchema.nullish()
 });
-var stopRunResponseSchema = z62.object({
-  success: z62.boolean(),
-  message: z62.string().nullish()
+var stopRunResponseSchema = z66.object({
+  success: z66.boolean(),
+  message: z66.string().nullish()
 });
-var runMessageSchema = z62.object({
-  id: z62.string(),
-  type: z62.string(),
-  role: z62.string(),
-  timestamp: z62.string(),
-  text_content: z62.string().nullish(),
-  tool_call: z62.object({
-    id: z62.string(),
-    name: z62.string(),
-    arguments: z62.record(z62.string(), z62.unknown()).nullish()
+var runMessageSchema = z66.object({
+  id: z66.string(),
+  type: z66.string(),
+  role: z66.string(),
+  timestamp: z66.string(),
+  text_content: z66.string().nullish(),
+  tool_call: z66.object({
+    id: z66.string(),
+    name: z66.string(),
+    arguments: z66.record(z66.string(), z66.unknown()).nullish()
   }).nullish(),
-  tool_result: z62.object({
-    tool_call_id: z62.string(),
-    result: z62.unknown().nullish(),
-    error: z62.string().nullish()
+  tool_result: z66.object({
+    tool_call_id: z66.string(),
+    result: z66.unknown().nullish(),
+    error: z66.string().nullish()
   }).nullish()
 });
-var listRunMessagesResponseSchema = z62.object({
-  messages: z62.array(runMessageSchema),
-  total: z62.number().nullish(),
-  limit: z62.number().nullish(),
-  offset: z62.number().nullish()
+var listRunMessagesResponseSchema = z66.object({
+  messages: z66.array(runMessageSchema),
+  total: z66.number().nullish(),
+  limit: z66.number().nullish(),
+  offset: z66.number().nullish()
 });
-var postedMessageSchema = z62.object({
-  id: z62.string(),
-  type: z62.string(),
-  role: z62.string(),
-  timestamp: z62.string(),
-  text_content: z62.string()
+var postedMessageSchema = z66.object({
+  id: z66.string(),
+  type: z66.string(),
+  role: z66.string(),
+  timestamp: z66.string(),
+  text_content: z66.string()
 });
-var postRunMessageResponseSchema = z62.object({
+var postRunMessageResponseSchema = z66.object({
   message: postedMessageSchema
 });
-var respondHumanRequestResponseSchema = z62.object({
-  human_request: z62.object({
-    id: z62.string(),
-    run_id: z62.string(),
-    title: z62.string(),
-    description: z62.string().nullish(),
-    response: z62.string().nullish(),
-    responded_at: z62.string().nullish(),
-    created_at: z62.string()
+var respondHumanRequestResponseSchema = z66.object({
+  human_request: z66.object({
+    id: z66.string(),
+    run_id: z66.string(),
+    title: z66.string(),
+    description: z66.string().nullish(),
+    response: z66.string().nullish(),
+    responded_at: z66.string().nullish(),
+    created_at: z66.string()
   })
 });
 
@@ -13417,13 +14135,13 @@ function registerRunsGet(runs) {
 __name(registerRunsGet, "registerRunsGet");
 
 // src/commands/runs/list.ts
-var DEFAULT_LIMIT5 = 20;
-var MIN_LIMIT5 = 1;
-var MAX_LIMIT5 = 100;
+var DEFAULT_LIMIT6 = 20;
+var MIN_LIMIT6 = 1;
+var MAX_LIMIT6 = 100;
 var SORT_ORDERS2 = ["asc", "desc"];
 var HAS_ISSUES_VALUES = ["true", "false"];
 var TITLE_PREVIEW_WIDTH = 50;
-var TABLE_COLUMNS21 = [
+var TABLE_COLUMNS20 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "RUN#", cell: /* @__PURE__ */ __name((row) => String(row.run_number), "cell") },
   { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
@@ -13447,7 +14165,7 @@ function isHasIssuesValue(value) {
 }
 __name(isHasIssuesValue, "isHasIssuesValue");
 function registerRunsList(runs) {
-  runs.command("list").description("List agent runs for your team").option("--limit <n>", `page size (${MIN_LIMIT5}-${MAX_LIMIT5})`).option("--offset <n>", "number of runs to skip").option("--sort-order <order>", `sort direction (${SORT_ORDERS2.join("|")})`).option(
+  runs.command("list").description("List agent runs for your team").option("--limit <n>", `page size (${MIN_LIMIT6}-${MAX_LIMIT6})`).option("--offset <n>", "number of runs to skip").option("--sort-order <order>", `sort direction (${SORT_ORDERS2.join("|")})`).option(
     "--status <status>",
     "filter by status (e.g. running, completed, failed, waiting, interrupted, stopped, needs_attention)"
   ).option("--agent <id>", "filter by agent ID").option("--user <id>", "filter by user ID").option("--case-queue <id>", "filter by case queue ID").option("--source <source>", "filter by source").option("--search <query>", "free-text search across runs").option(
@@ -13455,9 +14173,9 @@ function registerRunsList(runs) {
     `show only runs with (or without) issues (${HAS_ISSUES_VALUES.join("|")})`
   ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT5,
-      min: MIN_LIMIT5,
-      max: MAX_LIMIT5
+      defaultValue: DEFAULT_LIMIT6,
+      min: MIN_LIMIT6,
+      max: MAX_LIMIT6
     });
     const offset = parseOffset(options.offset);
     if (options.sortOrder !== void 0 && !isSortOrder(options.sortOrder)) {
@@ -13520,7 +14238,7 @@ function registerRunsList(runs) {
       console.log("No runs found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS21, response.data));
+    console.log(renderTable(TABLE_COLUMNS20, response.data));
     console.log(
       `Showing ${response.data.length} of ${response.total} \xB7 offset ${offset}`
     );
@@ -13529,11 +14247,11 @@ function registerRunsList(runs) {
 __name(registerRunsList, "registerRunsList");
 
 // src/commands/runs/messages.ts
-var DEFAULT_LIMIT6 = 20;
-var MIN_LIMIT6 = 1;
-var MAX_LIMIT6 = 50;
-var TEXT_PREVIEW_WIDTH = 60;
-var TABLE_COLUMNS22 = [
+var DEFAULT_LIMIT7 = 20;
+var MIN_LIMIT7 = 1;
+var MAX_LIMIT7 = 50;
+var TEXT_PREVIEW_WIDTH2 = 60;
+var TABLE_COLUMNS21 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "ROLE", cell: /* @__PURE__ */ __name((row) => row.role, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
@@ -13541,7 +14259,7 @@ var TABLE_COLUMNS22 = [
   {
     header: "PREVIEW",
     cell: previewCell,
-    maxWidth: TEXT_PREVIEW_WIDTH
+    maxWidth: TEXT_PREVIEW_WIDTH2
   }
 ];
 function previewCell(row) {
@@ -13558,11 +14276,11 @@ function previewCell(row) {
 }
 __name(previewCell, "previewCell");
 function registerRunsMessages(runs) {
-  runs.command("messages <id>").description("List messages for an agent run").option("--limit <n>", `page size (${MIN_LIMIT6}-${MAX_LIMIT6})`).option("--offset <n>", "number of messages to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function messagesAction(id, options) {
+  runs.command("messages <id>").description("List messages for an agent run").option("--limit <n>", `page size (${MIN_LIMIT7}-${MAX_LIMIT7})`).option("--offset <n>", "number of messages to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function messagesAction(id, options) {
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT6,
-      min: MIN_LIMIT6,
-      max: MAX_LIMIT6
+      defaultValue: DEFAULT_LIMIT7,
+      min: MIN_LIMIT7,
+      max: MAX_LIMIT7
     });
     const offset = parseOffset(options.offset);
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
@@ -13591,7 +14309,7 @@ function registerRunsMessages(runs) {
       console.log("No messages found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS22, response.messages));
+    console.log(renderTable(TABLE_COLUMNS21, response.messages));
     const resolvedOffset = response.offset ?? offset;
     const summary = response.total === null || response.total === void 0 ? `Showing ${response.messages.length} \xB7 offset ${resolvedOffset}` : `Showing ${response.messages.length} of ${response.total} \xB7 offset ${resolvedOffset}`;
     console.log(summary);
@@ -13848,28 +14566,28 @@ function registerRuns(program) {
 __name(registerRuns, "registerRuns");
 
 // src/api/sandbox-schemas.ts
-import { z as z63 } from "zod";
-var createSandboxResponseSchema = z63.object({
-  sandbox_id: z63.string(),
-  expires_at: z63.string()
+import { z as z67 } from "zod";
+var createSandboxResponseSchema = z67.object({
+  sandbox_id: z67.string(),
+  expires_at: z67.string()
 });
-var createSandboxUploadUrlResponseSchema = z63.object({
-  upload_url: z63.string(),
-  path: z63.string(),
-  expires_in_seconds: z63.number()
+var createSandboxUploadUrlResponseSchema = z67.object({
+  upload_url: z67.string(),
+  path: z67.string(),
+  expires_in_seconds: z67.number()
 });
-var sandboxFileSchema = z63.object({
-  name: z63.string(),
-  path: z63.string(),
-  type: z63.enum(["file", "dir"]),
-  size_bytes: z63.number()
+var sandboxFileSchema = z67.object({
+  name: z67.string(),
+  path: z67.string(),
+  type: z67.enum(["file", "dir"]),
+  size_bytes: z67.number()
 });
-var listSandboxFilesResponseSchema = z63.object({
-  files: z63.array(sandboxFileSchema)
+var listSandboxFilesResponseSchema = z67.object({
+  files: z67.array(sandboxFileSchema)
 });
-var uploadSandboxFileResponseSchema = z63.object({
-  path: z63.string(),
-  size_bytes: z63.number()
+var uploadSandboxFileResponseSchema = z67.object({
+  path: z67.string(),
+  size_bytes: z67.number()
 });
 var DEFAULT_SANDBOX_FILES_PATH = "/workspace";
 
@@ -13906,7 +14624,7 @@ function registerSandboxesCreate(sandboxes) {
 __name(registerSandboxesCreate, "registerSandboxesCreate");
 
 // src/commands/sandboxes/files.ts
-var TABLE_COLUMNS23 = [
+var TABLE_COLUMNS22 = [
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "PATH", cell: /* @__PURE__ */ __name((row) => row.path, "cell") },
@@ -13944,7 +14662,7 @@ function registerSandboxesFiles(sandboxes) {
       console.log("No files found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS23, files));
+    console.log(renderTable(TABLE_COLUMNS22, files));
     console.log(`Showing ${files.length}`);
   }, "filesAction"));
 }
@@ -14080,7 +14798,7 @@ function registerSandboxes(program) {
 __name(registerSandboxes, "registerSandboxes");
 
 // src/commands/skills/assignments.ts
-var TABLE_COLUMNS24 = [
+var TABLE_COLUMNS23 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") }
 ];
@@ -14108,7 +14826,7 @@ function registerSkillsAssignments(skills) {
       console.log("No assignments use this skill.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS24, assignments));
+    console.log(renderTable(TABLE_COLUMNS23, assignments));
     console.log(`Showing ${assignments.length} of ${total}`);
   }, "assignmentsAction"));
 }
@@ -14116,13 +14834,13 @@ __name(registerSkillsAssignments, "registerSkillsAssignments");
 
 // src/commands/skills/create.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-import { z as z64 } from "zod";
-var createSkillResponseSchema = z64.object({
-  skill: z64.object({
-    id: z64.string(),
-    name: z64.string(),
-    description: z64.string(),
-    team_id: z64.string()
+import { z as z68 } from "zod";
+var createSkillResponseSchema = z68.object({
+  skill: z68.object({
+    id: z68.string(),
+    name: z68.string(),
+    description: z68.string(),
+    team_id: z68.string()
   })
 });
 function registerSkillsCreate(skills) {
@@ -14386,7 +15104,7 @@ function readContent2(options) {
 __name(readContent2, "readContent");
 
 // src/commands/skills/files.ts
-var TABLE_COLUMNS25 = [
+var TABLE_COLUMNS24 = [
   { header: "PATH", cell: /* @__PURE__ */ __name((row) => row.path, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -14425,7 +15143,7 @@ function registerSkillsFiles(skills) {
       console.log("No files found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS25, parsed.data.files));
+    console.log(renderTable(TABLE_COLUMNS24, parsed.data.files));
     console.log(`Showing ${parsed.data.files.length}`);
   }, "filesAction"));
 }
@@ -14591,13 +15309,13 @@ __name(registerSkillsSystem, "registerSkillsSystem");
 // src/commands/skills/upload.ts
 import { readFile as readFile6, stat as stat2 } from "node:fs/promises";
 import { basename as basename2 } from "node:path";
-import { z as z65 } from "zod";
-var uploadSkillResponseSchema = z65.object({
-  skill: z65.object({
-    id: z65.string(),
-    name: z65.string(),
-    description: z65.string(),
-    team_id: z65.string()
+import { z as z69 } from "zod";
+var uploadSkillResponseSchema = z69.object({
+  skill: z69.object({
+    id: z69.string(),
+    name: z69.string(),
+    description: z69.string(),
+    team_id: z69.string()
   })
 });
 function registerSkillsUpload(skills) {
@@ -14667,7 +15385,7 @@ function registerSkills(program) {
 __name(registerSkills, "registerSkills");
 
 // src/commands/team/get.ts
-import { z as z66 } from "zod";
+import { z as z70 } from "zod";
 
 // src/commands/team/resolve-team-id.ts
 async function resolveTeamIdFromApiKey(options) {
@@ -14694,15 +15412,15 @@ async function resolveTeamIdFromApiKey(options) {
 __name(resolveTeamIdFromApiKey, "resolveTeamIdFromApiKey");
 
 // src/commands/team/get.ts
-var teamApiSchema2 = z66.object({
-  id: z66.string(),
-  name: z66.string(),
-  organization_id: z66.string().nullable(),
-  slack_team_id: z66.string().nullable(),
-  discovery_mode: z66.string(),
-  created_at: z66.string()
-});
-var teamResponseSchema = z66.object({
+var teamApiSchema2 = z70.object({
+  id: z70.string(),
+  name: z70.string(),
+  organization_id: z70.string().nullable(),
+  slack_team_id: z70.string().nullable(),
+  discovery_mode: z70.string(),
+  created_at: z70.string()
+});
+var teamResponseSchema = z70.object({
   team: teamApiSchema2
 });
 function registerTeamGet(team) {
@@ -14746,10 +15464,10 @@ function registerTeamGet(team) {
 __name(registerTeamGet, "registerTeamGet");
 
 // src/commands/team/members.ts
-var DEFAULT_LIMIT7 = 50;
-var MIN_LIMIT7 = 1;
-var MAX_LIMIT7 = 100;
-var TABLE_COLUMNS26 = [
+var DEFAULT_LIMIT8 = 50;
+var MIN_LIMIT8 = 1;
+var MAX_LIMIT8 = 100;
+var TABLE_COLUMNS25 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name ?? "", "cell") },
   { header: "EMAIL", cell: /* @__PURE__ */ __name((row) => row.email, "cell") },
@@ -14763,11 +15481,11 @@ function registerTeamMembers(team) {
   team.command("members").description("List members of a team").option(
     "--team <id>",
     "team ID (defaults to the team scoped to your API key)"
-  ).option("--limit <n>", `page size (${MIN_LIMIT7}-${MAX_LIMIT7})`).option("--offset <n>", "number of members to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function membersAction(options) {
+  ).option("--limit <n>", `page size (${MIN_LIMIT8}-${MAX_LIMIT8})`).option("--offset <n>", "number of members to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function membersAction(options) {
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT7,
-      min: MIN_LIMIT7,
-      max: MAX_LIMIT7
+      defaultValue: DEFAULT_LIMIT8,
+      min: MIN_LIMIT8,
+      max: MAX_LIMIT8
     });
     const offset = parseOffset(options.offset);
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
@@ -14797,7 +15515,7 @@ function registerTeamMembers(team) {
       console.log("No members found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS26, response.members));
+    console.log(renderTable(TABLE_COLUMNS25, response.members));
     console.log(
       `Showing ${response.members.length} of ${response.total} \xB7 offset ${response.offset}`
     );
@@ -14890,7 +15608,39 @@ function createProgram() {
 }
 __name(createProgram, "createProgram");
 
+// src/update-check.ts
+import { createRequire } from "node:module";
+import updateNotifier from "update-notifier";
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+function checkForUpdate() {
+  try {
+    const pkg = loadPackageMeta();
+    const notifier = updateNotifier({
+      pkg,
+      updateCheckInterval: ONE_DAY_MS,
+      shouldNotifyInNpmScript: false
+    });
+    notifier.notify({ defer: false, isGlobal: true });
+  } catch {
+  }
+}
+__name(checkForUpdate, "checkForUpdate");
+function loadPackageMeta() {
+  if (true) {
+    return { name: "@duvoai/cli", version: "0.5.0" };
+  }
+  const require2 = createRequire(import.meta.url);
+  const raw = require2("../package.json");
+  if (typeof raw !== "object" || raw === null || !("name" in raw) || !("version" in raw) || typeof raw.name !== "string" || typeof raw.version !== "string") {
+    throw new Error("package.json is missing name or version");
+  }
+  const typed = raw;
+  return { name: typed.name, version: typed.version };
+}
+__name(loadPackageMeta, "loadPackageMeta");
+
 // src/bin/duvo.ts
+checkForUpdate();
 createProgram().parseAsync(process.argv).catch((error) => {
   handleCliError(error);
 });