@duvoai/cli 0.4.2 → 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 {
@@ -3464,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(),
@@ -3510,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",
@@ -3551,6 +3885,13 @@ 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()
@@ -4115,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 = {
@@ -6447,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 = {
@@ -6484,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,
@@ -6539,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,
@@ -6622,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",
@@ -6775,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);
 }
@@ -6786,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;
@@ -6900,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(
@@ -7017,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
 ]);
@@ -7133,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()
-});
-var createTeamInviteLinkRequestSchema = z54.object({
-  frontendUrl: z54.url()
+  agents: z55.array(teamInsightsAgentSchema),
+  runs: z55.array(teamInsightsUserAgentRunSchema),
+  totalRuns: z55.number()
 });
-var getTeamInviteLinkQuerySchema = z54.object({
-  frontendUrl: z54.url()
+var teamInsightsUsersResponseSchema = z55.object({
+  data: z55.array(teamInsightsUserWithAgentsAndRunsSchema),
+  total: z55.number()
 });
-var teamInviteLinkCreatorSchema = z54.object({
-  id: z54.guid(),
-  name: z54.string().nullable(),
-  email: z54.email()
-});
-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 userDismissalListResponseSchema = z56.object({
+  data: z56.array(z56.string())
 });
-var acceptJoinLinkResponseSchema = z54.object({
-  success: z54.boolean(),
-  teamId: z54.guid()
+var userDismissalMutationSchema = z56.object({
+  elementKey: z56.string()
 });
-var caseFilterStatusSchema = z55.enum([
+var caseFilterStatusSchema = z57.enum([
   "pending",
   "claimed",
   "completed",
@@ -7419,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") {
@@ -7526,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;
     }
@@ -8397,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()
 });
@@ -8729,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
@@ -9221,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
@@ -9513,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
@@ -9696,9 +10070,9 @@ function registerBuildsList(builds) {
 __name(registerBuildsList, "registerBuildsList");
 
 // src/commands/builds/promote.ts
-import { z as z61 } from "zod";
-var promoteResponseSchema = z61.object({
-  success: z61.boolean()
+import { z as z63 } from "zod";
+var promoteResponseSchema = z63.object({
+  success: z63.boolean()
 });
 function registerBuildsPromote(builds) {
   builds.command("promote <id>").description(
@@ -10707,7 +11081,7 @@ function parseSortOrder(raw) {
 __name(parseSortOrder, "parseSortOrder");
 
 // src/commands/cases/runs.ts
-import { z as z62 } from "zod";
+import { z as z64 } from "zod";
 var MIN_LIMIT4 = 1;
 var MAX_LIMIT4 = 10;
 var DEFAULT_LIMIT4 = 3;
@@ -10725,17 +11099,17 @@ var RUNS_TABLE_COLUMNS = [
     cell: /* @__PURE__ */ __name((row) => row.has_pending_human_request ? row.pending_human_request_title ?? "(unknown)" : "", "cell")
   }
 ];
-var recentMessageSchema = 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() }).passthrough().nullish(),
-  tool_result: z62.object({ tool_call_id: z62.string() }).passthrough().nullish()
+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 = z62.object({
-  messages: z62.array(recentMessageSchema)
+var recentMessagesResponseSchema = z64.object({
+  messages: z64.array(recentMessageSchema)
 });
 var TEXT_PREVIEW_WIDTH = 60;
 var MESSAGES_TABLE_COLUMNS = [
@@ -11163,16 +11537,16 @@ function registerConnectionsList(connections) {
 __name(registerConnectionsList, "registerConnectionsList");
 
 // src/commands/connections/probe.ts
-import { z as z63 } from "zod";
-var toolSchema = z63.object({
-  name: z63.string(),
-  description: z63.string().optional(),
-  input_schema: z63.record(z63.string(), z63.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 = z63.object({
-  success: z63.boolean(),
-  tools: z63.array(toolSchema).optional(),
-  error: z63.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_COLUMNS13 = [
@@ -11386,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) {
@@ -11474,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) {
@@ -13614,91 +13988,91 @@ function registerQueues(program) {
 __name(registerQueues, "registerQueues");
 
 // src/api/run-schemas.ts
-import { z as z64 } from "zod";
-var publicRunSchema = z64.object({
-  id: z64.string(),
-  agent_id: z64.string(),
-  build_id: z64.string(),
-  status: z64.string(),
-  source: z64.string().nullish(),
-  sandbox_id: z64.string().nullish(),
-  started_at: z64.string().nullish(),
-  completed_at: z64.string().nullish(),
-  created_at: z64.string(),
-  updated_at: z64.string().nullish(),
-  human_in_the_loop_enabled: z64.boolean().nullish()
-});
-var startRunResponseSchema = z64.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 = z64.object({
-  label: z64.string(),
-  description: z64.string().nullish()
-});
-var questionSchema = z64.object({
-  question: z64.string(),
-  header: z64.string().nullish(),
-  options: z64.array(questionOptionSchema).nullish(),
-  multi_select: z64.boolean().nullish()
-});
-var pendingHumanRequestSchema = z64.object({
-  id: z64.string(),
-  title: z64.string(),
-  description: z64.string().nullish(),
-  created_at: z64.string(),
-  type: z64.string(),
-  questions: z64.array(questionSchema).nullish()
-});
-var getRunResponseSchema = z64.object({
+var questionOptionSchema = z66.object({
+  label: z66.string(),
+  description: z66.string().nullish()
+});
+var questionSchema = z66.object({
+  question: z66.string(),
+  header: z66.string().nullish(),
+  options: z66.array(questionOptionSchema).nullish(),
+  multi_select: z66.boolean().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 = z66.object({
   run: publicRunSchema.nullable(),
   pending_human_request: pendingHumanRequestSchema.nullish()
 });
-var stopRunResponseSchema = z64.object({
-  success: z64.boolean(),
-  message: z64.string().nullish()
-});
-var runMessageSchema = 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(),
-    arguments: z64.record(z64.string(), z64.unknown()).nullish()
+var stopRunResponseSchema = z66.object({
+  success: z66.boolean(),
+  message: z66.string().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: z64.object({
-    tool_call_id: z64.string(),
-    result: z64.unknown().nullish(),
-    error: z64.string().nullish()
+  tool_result: z66.object({
+    tool_call_id: z66.string(),
+    result: z66.unknown().nullish(),
+    error: z66.string().nullish()
   }).nullish()
 });
-var listRunMessagesResponseSchema = z64.object({
-  messages: z64.array(runMessageSchema),
-  total: z64.number().nullish(),
-  limit: z64.number().nullish(),
-  offset: z64.number().nullish()
+var listRunMessagesResponseSchema = z66.object({
+  messages: z66.array(runMessageSchema),
+  total: z66.number().nullish(),
+  limit: z66.number().nullish(),
+  offset: z66.number().nullish()
 });
-var postedMessageSchema = z64.object({
-  id: z64.string(),
-  type: z64.string(),
-  role: z64.string(),
-  timestamp: z64.string(),
-  text_content: z64.string()
+var postedMessageSchema = z66.object({
+  id: z66.string(),
+  type: z66.string(),
+  role: z66.string(),
+  timestamp: z66.string(),
+  text_content: z66.string()
 });
-var postRunMessageResponseSchema = z64.object({
+var postRunMessageResponseSchema = z66.object({
   message: postedMessageSchema
 });
-var respondHumanRequestResponseSchema = z64.object({
-  human_request: z64.object({
-    id: z64.string(),
-    run_id: z64.string(),
-    title: z64.string(),
-    description: z64.string().nullish(),
-    response: z64.string().nullish(),
-    responded_at: z64.string().nullish(),
-    created_at: z64.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()
   })
 });
 
@@ -14192,28 +14566,28 @@ function registerRuns(program) {
 __name(registerRuns, "registerRuns");
 
 // src/api/sandbox-schemas.ts
-import { z as z65 } from "zod";
-var createSandboxResponseSchema = z65.object({
-  sandbox_id: z65.string(),
-  expires_at: z65.string()
+import { z as z67 } from "zod";
+var createSandboxResponseSchema = z67.object({
+  sandbox_id: z67.string(),
+  expires_at: z67.string()
 });
-var createSandboxUploadUrlResponseSchema = z65.object({
-  upload_url: z65.string(),
-  path: z65.string(),
-  expires_in_seconds: z65.number()
+var createSandboxUploadUrlResponseSchema = z67.object({
+  upload_url: z67.string(),
+  path: z67.string(),
+  expires_in_seconds: z67.number()
 });
-var sandboxFileSchema = z65.object({
-  name: z65.string(),
-  path: z65.string(),
-  type: z65.enum(["file", "dir"]),
-  size_bytes: z65.number()
+var sandboxFileSchema = z67.object({
+  name: z67.string(),
+  path: z67.string(),
+  type: z67.enum(["file", "dir"]),
+  size_bytes: z67.number()
 });
-var listSandboxFilesResponseSchema = z65.object({
-  files: z65.array(sandboxFileSchema)
+var listSandboxFilesResponseSchema = z67.object({
+  files: z67.array(sandboxFileSchema)
 });
-var uploadSandboxFileResponseSchema = z65.object({
-  path: z65.string(),
-  size_bytes: z65.number()
+var uploadSandboxFileResponseSchema = z67.object({
+  path: z67.string(),
+  size_bytes: z67.number()
 });
 var DEFAULT_SANDBOX_FILES_PATH = "/workspace";
 
@@ -14460,13 +14834,13 @@ __name(registerSkillsAssignments, "registerSkillsAssignments");
 
 // src/commands/skills/create.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-import { z as z66 } from "zod";
-var createSkillResponseSchema = z66.object({
-  skill: z66.object({
-    id: z66.string(),
-    name: z66.string(),
-    description: z66.string(),
-    team_id: z66.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) {
@@ -14935,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 z67 } from "zod";
-var uploadSkillResponseSchema = z67.object({
-  skill: z67.object({
-    id: z67.string(),
-    name: z67.string(),
-    description: z67.string(),
-    team_id: z67.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) {
@@ -15011,7 +15385,7 @@ function registerSkills(program) {
 __name(registerSkills, "registerSkills");
 
 // src/commands/team/get.ts
-import { z as z68 } from "zod";
+import { z as z70 } from "zod";
 
 // src/commands/team/resolve-team-id.ts
 async function resolveTeamIdFromApiKey(options) {
@@ -15038,15 +15412,15 @@ async function resolveTeamIdFromApiKey(options) {
 __name(resolveTeamIdFromApiKey, "resolveTeamIdFromApiKey");
 
 // src/commands/team/get.ts
-var teamApiSchema2 = z68.object({
-  id: z68.string(),
-  name: z68.string(),
-  organization_id: z68.string().nullable(),
-  slack_team_id: z68.string().nullable(),
-  discovery_mode: z68.string(),
-  created_at: z68.string()
-});
-var teamResponseSchema = z68.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) {
@@ -15234,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);
 });