@duvoai/cli 1.24.1 → 1.26.0

package/dist/bin/duvo.js

@@ -92,11 +92,11 @@ import { z as z54 } from "zod";
 import { z as z55 } from "zod";
 import { z as z56 } from "zod";
 import { z as z57 } from "zod";
-import { z as z59 } from "zod";
 import { z as z58 } from "zod";
-import { z as z61 } from "zod";
 import { z as z60 } from "zod";
+import { z as z59 } from "zod";
 import { z as z62 } from "zod";
+import { z as z61 } from "zod";
 import { z as z63 } from "zod";
 import { z as z64 } from "zod";
 import { z as z65 } from "zod";
@@ -108,13 +108,14 @@ import { z as z70 } from "zod";
 import { z as z71 } from "zod";
 import { z as z72 } from "zod";
 import { z as z73 } from "zod";
-import { z as z75 } from "zod";
 import { z as z74 } from "zod";
 import { z as z76 } from "zod";
+import { z as z75 } from "zod";
 import { z as z77 } from "zod";
 import { z as z78 } from "zod";
 import { z as z79 } from "zod";
 import { z as z80 } from "zod";
+import { z as z81 } from "zod";
 
 // ../node_modules/.pnpm/jsonrepair@3.13.2/node_modules/jsonrepair/lib/esm/utils/JSONRepairError.js
 var JSONRepairError = class extends Error {
@@ -2502,7 +2503,7 @@ var canExecuteConcurrentResultSchema = z11.object({
 var BrowsingProviderSchema = z12.enum(["google", "anthropic"]);
 var PLATFORM_DEFAULT_MODELS = {
   agent: {
-    model: "claude-sonnet-4-6[1m]"
+    model: "claude-sonnet-5"
   },
   browsing: {
     provider: "google",
@@ -2510,8 +2511,6 @@ var PLATFORM_DEFAULT_MODELS = {
   }
 };
 var CLAUDE_MODEL_IDS = [
-  "claude-sonnet-4-6",
-  "claude-sonnet-4-6[1m]",
   "claude-sonnet-5",
   "claude-opus-4-8",
   "claude-opus-4-8[1m]"
@@ -2536,6 +2535,8 @@ var LEGACY_MODEL_IDS = [
   "claude-sonnet-4-20250514[1m]",
   "claude-sonnet-4-5-20250929",
   "claude-sonnet-4-5-20250929[1m]",
+  "claude-sonnet-4-6",
+  "claude-sonnet-4-6[1m]",
   "claude-opus-4-1-20250805",
   "claude-opus-4-5-20251101",
   // Retired in favour of Opus 4.8 (migrated via LEGACY_MODEL_REMAP, not the
@@ -2550,13 +2551,6 @@ var ClaudeModelIdSchema = z12.enum([
   ...LEGACY_MODEL_IDS
 ]);
 var AVAILABLE_AGENT_MODELS = {
-  "claude-sonnet-4-6": {
-    displayName: "Claude Sonnet 4.6"
-  },
-  "claude-sonnet-4-6[1m]": {
-    displayName: "Claude Sonnet 4.6",
-    description: "Fast and capable for everyday tasks"
-  },
   "claude-sonnet-5": {
     displayName: "Claude Sonnet 5",
     description: "Fast and capable for everyday tasks"
@@ -2578,8 +2572,10 @@ var BrowsingModelIdSchema = z12.enum([
   "claude-sonnet-4-5",
   "claude-opus-4-1"
 ]);
-var LEGACY_DEFAULT_MODEL = "claude-sonnet-4-6[1m]";
+var LEGACY_DEFAULT_MODEL = "claude-sonnet-5";
 var LEGACY_MODEL_REMAP = {
+  "claude-sonnet-4-6": "claude-sonnet-5",
+  "claude-sonnet-4-6[1m]": "claude-sonnet-5",
   "claude-opus-4-6": "claude-opus-4-8",
   "claude-opus-4-6[1m]": "claude-opus-4-8[1m]",
   "claude-opus-4-7": "claude-opus-4-8",
@@ -3360,9 +3356,9 @@ var clarityProcessLandscapeNodeSchema = z15.object({
   teamId: z15.guid().nullable().optional(),
   teamName: z15.string().nullable().optional(),
   assignedTeam: clarityLandscapeAssignedTeamSchema.nullable().optional(),
-  teamAssignmentSuggestions: z15.array(clarityLandscapeTeamAssignmentSuggestionSchema).optional(),
-  captureSuggestions: z15.array(clarityLandscapeCaptureSuggestionSchema).optional(),
-  captureRequests: z15.array(clarityLandscapeCaptureRequestSchema).optional(),
+  teamAssignmentSuggestions: z15.array(clarityLandscapeTeamAssignmentSuggestionSchema).default([]),
+  captureSuggestions: z15.array(clarityLandscapeCaptureSuggestionSchema).default([]),
+  captureRequests: z15.array(clarityLandscapeCaptureRequestSchema).default([]),
   labels: z15.array(clarityProcessAssignedLabelSchema).default([])
 });
 var clarityProcessLandscapeUnlinkedProcessSchema = clarityProcessLandscapeSummarySchema.extend({
@@ -3561,10 +3557,6 @@ var portfolioIntelligenceStatusSchema = z15.enum(
   PORTFOLIO_INTELLIGENCE_STATUSES
 );
 var EXECUTION_MODES = ["human-led", "hybrid", "agent-led"];
-var operatingModelDesignPrincipleSchema = z15.object({
-  title: z15.string().min(1),
-  description: z15.string().min(1)
-});
 var operatingModelValueStreamSchema = z15.object({
   name: z15.string().min(1),
   description: z15.string().min(1),
@@ -3665,7 +3657,6 @@ var operatingModelObjectionsSchema = z15.object({
 });
 var operatingModelAnalysisSchema = z15.object({
   executiveSummary: z15.string().min(1),
-  designPrinciples: z15.array(operatingModelDesignPrincipleSchema).min(1),
   valueStreams: z15.array(operatingModelValueStreamSchema).min(1),
   organizationAndGovernance: z15.array(operatingModelOrgElementSchema).min(1),
   peopleAndSkills: z15.array(operatingModelPeopleSkillSchema).min(1),
@@ -6224,6 +6215,7 @@ __name(makeSentryReporter, "makeSentryReporter");
 __name2(makeSentryReporter, "makeSentryReporter");
 var MAX_BLOCKED_DOMAINS = 1e3;
 var MAX_GUARDRAILS_TEXT_LENGTH = 2e4;
+var MAX_VPN_BYPASS_DOMAINS = 1e3;
 var DOMAIN_LABEL = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/;
 function stripToHost(value) {
   if (/^[a-z][a-z0-9+.-]*:\/\//.test(value)) {
@@ -6354,6 +6346,22 @@ function blockedDomainAgentErrorMessage(args) {
 }
 __name(blockedDomainAgentErrorMessage, "blockedDomainAgentErrorMessage");
 __name2(blockedDomainAgentErrorMessage, "blockedDomainAgentErrorMessage");
+function domainsToBrowserbaseBypassPattern(domains) {
+  if (domains.length === 0) {
+    return null;
+  }
+  const escaped = domains.map(
+    (domain) => domain.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+  );
+  return `^([a-zA-Z0-9-]+\\.)*(${escaped.join("|")})$`;
+}
+__name(domainsToBrowserbaseBypassPattern, "domainsToBrowserbaseBypassPattern");
+__name2(domainsToBrowserbaseBypassPattern, "domainsToBrowserbaseBypassPattern");
+function normalizeShopDomain(input) {
+  return input.trim().toLowerCase().replace(/^https?:\/\//, "").replace(/\/.*$/, "");
+}
+__name(normalizeShopDomain, "normalizeShopDomain");
+__name2(normalizeShopDomain, "normalizeShopDomain");
 var NOTIFICATION_SEVERITIES = [
   "info",
   "warning",
@@ -7414,6 +7422,38 @@ var deleteArtifactShareResponseSchema = z31.object({
 var deleteArtifactResponseSchema = z31.object({
   success: z31.literal(true)
 });
+var movePulseBodySchema = z31.object({
+  targetTeamId: z31.guid().describe("ID of the destination team the dashboard moves to.")
+}).strict();
+var pulseConnectionDecisionSchema = z31.enum([
+  "reuse",
+  "needs_reconnect",
+  "custom_to_rebuild"
+]);
+var pulseConnectionOutcomeSchema = z31.object({
+  integrationType: z31.string(),
+  integrationName: z31.string(),
+  instanceName: z31.string(),
+  decision: pulseConnectionDecisionSchema
+});
+var movePulsePlanSchema = z31.object({
+  artifactId: z31.guid(),
+  artifactTitle: z31.string().nullable(),
+  sourceTeamId: z31.guid(),
+  targetTeamId: z31.guid(),
+  // True when the dashboard's creator differs from the mover, so ownership
+  // will be (or was) reassigned to the mover on the target team.
+  ownershipReassigned: z31.boolean(),
+  // True when the dashboard was published (visibility != 'private') and will
+  // be (or was) reset to private on the target team.
+  visibilityReset: z31.boolean(),
+  connections: z31.object({
+    reused: z31.array(pulseConnectionOutcomeSchema),
+    disconnected: z31.array(pulseConnectionOutcomeSchema),
+    customToRebuild: z31.array(pulseConnectionOutcomeSchema)
+  }),
+  applied: z31.boolean()
+});
 var uploadArtifactThumbnailBodySchema = z31.object({
   image_base64: z31.string().min(1).max(8e6)
 });
@@ -9063,107 +9103,113 @@ var activateAutomationRevisionResponseApiSchema = z50.object({
   ),
   repinned_case_count: z50.int().describe("Number of pending cases re-pinned onto the activated revision")
 });
-var DataResidencySchema = z51.enum(["us", "eu", "apac"]);
-var DataHandlingSchema = z51.enum(["standard", "zdr"]);
-var browserPageSchema = z52.object({
-  id: z52.string().describe("Page ID"),
-  url: z52.url().describe("Page URL"),
-  faviconUrl: z52.string().describe("Page favicon URL"),
-  title: z52.string().describe("Page title"),
-  debuggerUrl: z52.url().describe("Page-specific debugger URL"),
-  debuggerFullscreenUrl: z52.url().describe("Page-specific full-screen debugger URL")
-});
-var browserSessionInfoSchema = z52.object({
+var BROWSER_EGRESS_MODES = [
+  "provider",
+  "direct",
+  "organization-vpn"
+];
+var browserEgressModeSchema = z51.enum(BROWSER_EGRESS_MODES);
+var DataResidencySchema = z52.enum(["us", "eu", "apac"]);
+var DataHandlingSchema = z52.enum(["standard", "zdr"]);
+var browserPageSchema = z53.object({
+  id: z53.string().describe("Page ID"),
+  url: z53.url().describe("Page URL"),
+  faviconUrl: z53.string().describe("Page favicon URL"),
+  title: z53.string().describe("Page title"),
+  debuggerUrl: z53.url().describe("Page-specific debugger URL"),
+  debuggerFullscreenUrl: z53.url().describe("Page-specific full-screen debugger URL")
+});
+var browserSessionInfoSchema = z53.object({
   // Session-level URLs (Browser Use provides these, Browserbase also has them)
-  wsUrl: z52.url().nullable(),
-  liveUrl: z52.url().nullable(),
+  wsUrl: z53.url().nullable(),
+  liveUrl: z53.url().nullable(),
   // Page-level data (Browserbase provides these, Browser Use returns empty array)
-  pages: z52.array(browserPageSchema)
-});
-var browserbaseDebugResponseSchema = z52.object({
-  debuggerFullscreenUrl: z52.url().describe("Session full-screen debugger URL"),
-  debuggerUrl: z52.url().describe("Session debugger URL"),
-  pages: z52.array(browserPageSchema).describe("List of pages in the session"),
-  wsUrl: z52.url().describe("WebSocket URL for the session")
-});
-var browserbaseSessionCreateResponseSchema = z52.object({
-  id: z52.string().describe("Session ID"),
-  createdAt: z52.iso.datetime().describe("Session creation timestamp"),
-  updatedAt: z52.iso.datetime().describe("Session last update timestamp"),
-  projectId: z52.string().describe("Project ID"),
-  startedAt: z52.iso.datetime().describe("Session start timestamp"),
-  endedAt: z52.iso.datetime().optional().describe("Session end timestamp"),
-  expiresAt: z52.iso.datetime().describe("Session expiration timestamp"),
-  status: z52.string().describe("Session status"),
-  proxyBytes: z52.number().describe("Proxy bytes used"),
-  avgCpuUsage: z52.number().describe("Average CPU usage"),
-  memoryUsage: z52.number().describe("Memory usage"),
-  keepAlive: z52.boolean().describe("Keep alive flag"),
-  contextId: z52.string().describe("Context ID"),
-  region: z52.string().describe("Region"),
-  userMetadata: z52.record(z52.string(), z52.unknown()).describe("User metadata"),
-  connectUrl: z52.string().describe("Connect URL"),
-  seleniumRemoteUrl: z52.string().describe("Selenium remote URL"),
-  signingKey: z52.string().describe("Signing key")
-});
-var getBuildParamsSchema = z53.object({
-  buildId: z53.guid()
-});
-var listBuildsParamsSchema = z53.object({
-  copilotId: z53.guid()
-});
-var updateBuildBodySchema = z53.object({
-  config: z53.record(z53.string(), z53.any()).optional().describe("Build configuration object"),
-  handoverTargetIds: z53.array(z53.guid()).optional().describe("Agent IDs that this agent can hand over work to"),
-  revision_name: z53.string().trim().min(1).max(80).nullable().optional().describe(
+  pages: z53.array(browserPageSchema)
+});
+var browserbaseDebugResponseSchema = z53.object({
+  debuggerFullscreenUrl: z53.url().describe("Session full-screen debugger URL"),
+  debuggerUrl: z53.url().describe("Session debugger URL"),
+  pages: z53.array(browserPageSchema).describe("List of pages in the session"),
+  wsUrl: z53.url().describe("WebSocket URL for the session")
+});
+var browserbaseSessionCreateResponseSchema = z53.object({
+  id: z53.string().describe("Session ID"),
+  createdAt: z53.iso.datetime().describe("Session creation timestamp"),
+  updatedAt: z53.iso.datetime().describe("Session last update timestamp"),
+  projectId: z53.string().describe("Project ID"),
+  startedAt: z53.iso.datetime().describe("Session start timestamp"),
+  endedAt: z53.iso.datetime().optional().describe("Session end timestamp"),
+  expiresAt: z53.iso.datetime().describe("Session expiration timestamp"),
+  status: z53.string().describe("Session status"),
+  proxyBytes: z53.number().describe("Proxy bytes used"),
+  avgCpuUsage: z53.number().describe("Average CPU usage"),
+  memoryUsage: z53.number().describe("Memory usage"),
+  keepAlive: z53.boolean().describe("Keep alive flag"),
+  contextId: z53.string().describe("Context ID"),
+  region: z53.string().describe("Region"),
+  userMetadata: z53.record(z53.string(), z53.unknown()).describe("User metadata"),
+  connectUrl: z53.string().describe("Connect URL"),
+  seleniumRemoteUrl: z53.string().describe("Selenium remote URL"),
+  signingKey: z53.string().describe("Signing key")
+});
+var getBuildParamsSchema = z54.object({
+  buildId: z54.guid()
+});
+var listBuildsParamsSchema = z54.object({
+  copilotId: z54.guid()
+});
+var updateBuildBodySchema = z54.object({
+  config: z54.record(z54.string(), z54.any()).optional().describe("Build configuration object"),
+  handoverTargetIds: z54.array(z54.guid()).optional().describe("Agent IDs that this agent can hand over work to"),
+  revision_name: z54.string().trim().min(1).max(80).nullable().optional().describe(
     "Optional user-defined name for this revision. Pass null to clear."
   ),
-  revision_description: z53.string().trim().max(500).nullable().optional().describe(
+  revision_description: z54.string().trim().max(500).nullable().optional().describe(
     "Optional user-defined description for this revision. Pass null to clear."
   )
 });
-var createBuildBodySchema = z53.object({
-  copilot_id: z53.guid().describe("Agent ID"),
-  name: z53.string().describe("Build name"),
-  config: z53.record(z53.string(), z53.any()).optional().describe("Build configuration object"),
-  handoverTargetIds: z53.array(z53.guid()).optional().describe("Agent IDs that this agent can hand over work to"),
-  source_build_id: z53.guid().optional().describe("Build ID to copy integrations and queue links from")
-});
-var buildResponseSchema = z53.object({
-  build_id: z53.string().describe("Build ID"),
-  name: z53.string().describe("Build name"),
-  config: z53.record(z53.string(), z53.any()).nullable().describe("Build configuration"),
-  copilot_id: z53.string().describe("Associated copilot ID"),
-  status: z53.string().describe("Build status"),
-  created_at: z53.coerce.date().describe("Creation timestamp"),
-  updated_at: z53.coerce.date().nullable().describe("Last update timestamp"),
-  revision_number: z53.number().nullable().describe("Revision number"),
-  revision_name: z53.string().nullable().optional().describe("User-defined name for this revision"),
-  revision_description: z53.string().nullable().optional().describe("User-defined description for this revision"),
-  parent_build_id: z53.string().nullable().describe("Parent build ID"),
-  created_by: z53.string().nullable().describe("User who created this build"),
-  created_by_name: z53.string().nullable().optional().describe("Display name of the user who created this build")
-});
-var listBuildsResponseSchema = z53.array(buildResponseSchema);
-var buildResponseApiSchema = z53.object({
+var createBuildBodySchema = z54.object({
+  copilot_id: z54.guid().describe("Agent ID"),
+  name: z54.string().describe("Build name"),
+  config: z54.record(z54.string(), z54.any()).optional().describe("Build configuration object"),
+  handoverTargetIds: z54.array(z54.guid()).optional().describe("Agent IDs that this agent can hand over work to"),
+  source_build_id: z54.guid().optional().describe("Build ID to copy integrations and queue links from")
+});
+var buildResponseSchema = z54.object({
+  build_id: z54.string().describe("Build ID"),
+  name: z54.string().describe("Build name"),
+  config: z54.record(z54.string(), z54.any()).nullable().describe("Build configuration"),
+  copilot_id: z54.string().describe("Associated copilot ID"),
+  status: z54.string().describe("Build status"),
+  created_at: z54.coerce.date().describe("Creation timestamp"),
+  updated_at: z54.coerce.date().nullable().describe("Last update timestamp"),
+  revision_number: z54.number().nullable().describe("Revision number"),
+  revision_name: z54.string().nullable().optional().describe("User-defined name for this revision"),
+  revision_description: z54.string().nullable().optional().describe("User-defined description for this revision"),
+  parent_build_id: z54.string().nullable().describe("Parent build ID"),
+  created_by: z54.string().nullable().describe("User who created this build"),
+  created_by_name: z54.string().nullable().optional().describe("Display name of the user who created this build")
+});
+var listBuildsResponseSchema = z54.array(buildResponseSchema);
+var buildResponseApiSchema = z54.object({
   build: buildApiSchema
 });
-var buildsListApiSchema = z53.object({
-  builds: z53.array(buildApiSchema),
-  total: z53.int(),
-  limit: z53.int(),
-  offset: z53.int()
+var buildsListApiSchema = z54.object({
+  builds: z54.array(buildApiSchema),
+  total: z54.int(),
+  limit: z54.int(),
+  offset: z54.int()
 });
-var createBuildResponseApiSchema = z53.object({
+var createBuildResponseApiSchema = z54.object({
   build: buildApiSchema,
-  agent: z53.object({
-    id: z53.guid()
+  agent: z54.object({
+    id: z54.guid()
   })
 });
-var builderRunGenerateResponseSchema = z53.object({
-  status: z53.literal("generating"),
-  builderRunId: z53.string(),
-  buildId: z53.string()
+var builderRunGenerateResponseSchema = z54.object({
+  status: z54.literal("generating"),
+  builderRunId: z54.string(),
+  buildId: z54.string()
 });
 var BUILDER_RUN_STATUSES = [
   "not_started",
@@ -9174,252 +9220,252 @@ var BUILDER_RUN_STATUSES = [
   "waiting_for_input",
   "waiting_for_approve"
 ];
-var builderRunStatusSchema = z53.object({
-  id: z53.string(),
-  status: z53.enum(BUILDER_RUN_STATUSES),
-  build_id: z53.string(),
-  started_at: z53.string().nullable(),
-  completed_at: z53.string().nullable(),
+var builderRunStatusSchema = z54.object({
+  id: z54.string(),
+  status: z54.enum(BUILDER_RUN_STATUSES),
+  build_id: z54.string(),
+  started_at: z54.string().nullable(),
+  completed_at: z54.string().nullable(),
   checkpoint_config: StoredAgentConfigSchema.nullable(),
   pending_user_questions: askUserQuestionInputSchema.nullable(),
-  schedule_suggested: z53.boolean().optional()
-});
-var filterValueSchema = z54.object({
-  value: z54.string().min(1),
-  name: z54.string().min(1)
-});
-var filterCategorySchema = z54.object({
-  key: z54.string(),
-  name: z54.string().min(1),
-  selectionMode: z54.enum(["single", "multi"]),
-  values: z54.array(filterValueSchema)
-});
-var caseFiltersResponseSchema = z54.object({
-  filters: z54.array(filterCategorySchema)
-});
-var caseQueueFolderResponseSchema = z55.object({
-  id: z55.string(),
-  name: z55.string(),
-  team_id: z55.string(),
-  parent_folder_id: z55.string().nullable(),
-  created_at: z55.string(),
-  updated_at: z55.string()
-});
-var caseQueueFoldersListResponseSchema = z55.object({
-  folders: z55.array(caseQueueFolderResponseSchema)
-});
-var createCaseQueueFolderRequestSchema = z55.object({
-  name: z55.string().min(1).max(100),
-  parent_folder_id: z55.guid().nullable().optional()
-});
-var updateCaseQueueFolderRequestSchema = z55.object({
-  name: z55.string().min(1).max(100).optional(),
-  parent_folder_id: z55.guid().nullable().optional()
-});
-var moveQueuesToFolderRequestSchema = z55.object({
-  queue_ids: z55.array(z55.guid()).min(1),
-  folder_id: z55.guid().nullable()
-});
-var caseQueueLabelSchema = z56.object({
-  id: z56.guid(),
-  key: z56.string(),
+  schedule_suggested: z54.boolean().optional()
+});
+var filterValueSchema = z55.object({
+  value: z55.string().min(1),
+  name: z55.string().min(1)
+});
+var filterCategorySchema = z55.object({
+  key: z55.string(),
+  name: z55.string().min(1),
+  selectionMode: z55.enum(["single", "multi"]),
+  values: z55.array(filterValueSchema)
+});
+var caseFiltersResponseSchema = z55.object({
+  filters: z55.array(filterCategorySchema)
+});
+var caseQueueFolderResponseSchema = z56.object({
+  id: z56.string(),
+  name: z56.string(),
+  team_id: z56.string(),
+  parent_folder_id: z56.string().nullable(),
+  created_at: z56.string(),
+  updated_at: z56.string()
+});
+var caseQueueFoldersListResponseSchema = z56.object({
+  folders: z56.array(caseQueueFolderResponseSchema)
+});
+var createCaseQueueFolderRequestSchema = z56.object({
+  name: z56.string().min(1).max(100),
+  parent_folder_id: z56.guid().nullable().optional()
+});
+var updateCaseQueueFolderRequestSchema = z56.object({
+  name: z56.string().min(1).max(100).optional(),
+  parent_folder_id: z56.guid().nullable().optional()
+});
+var moveQueuesToFolderRequestSchema = z56.object({
+  queue_ids: z56.array(z56.guid()).min(1),
+  folder_id: z56.guid().nullable()
+});
+var caseQueueLabelSchema = z57.object({
+  id: z57.guid(),
+  key: z57.string(),
   // Empty string key means a simple tag (value-only); non-empty key creates a key-value categorization
-  value: z56.string().min(1),
-  color_hue: z56.int().min(0).max(360)
+  value: z57.string().min(1),
+  color_hue: z57.int().min(0).max(360)
 });
-var caseLabelsListResponseSchema = z56.object({
-  labels: z56.array(caseQueueLabelSchema)
+var caseLabelsListResponseSchema = z57.object({
+  labels: z57.array(caseQueueLabelSchema)
 });
-var caseLabelAssignInputSchema = z56.object({
-  labels: z56.array(
-    z56.object({
-      key: z56.string().optional().default(""),
-      value: z56.string().min(1)
+var caseLabelAssignInputSchema = z57.object({
+  labels: z57.array(
+    z57.object({
+      key: z57.string().optional().default(""),
+      value: z57.string().min(1)
     })
   ).min(1).max(50)
 });
-var caseLabelAssignResponseSchema = z56.object({
-  labels: z56.array(caseQueueLabelSchema)
+var caseLabelAssignResponseSchema = z57.object({
+  labels: z57.array(caseQueueLabelSchema)
 });
-var caseLabelUpdateInputSchema = z56.object({
+var caseLabelUpdateInputSchema = z57.object({
   // key is a partial-update field: omit to leave the existing key unchanged.
   // Do NOT add `.default("")` — a missing key must not silently relocate the
   // label into the empty-key ("Labels") bucket when the caller only wants to
   // change color or value.
-  key: z56.string().optional(),
-  value: z56.string().min(1),
-  color_hue: z56.int().min(0).max(360).optional()
+  key: z57.string().optional(),
+  value: z57.string().min(1),
+  color_hue: z57.int().min(0).max(360).optional()
 });
-var caseLabelUpdateResponseSchema = z56.object({
+var caseLabelUpdateResponseSchema = z57.object({
   label: caseQueueLabelSchema
 });
-var caseLabelUnlinkInputSchema = z56.object({
-  label_ids: z56.array(z56.guid()).min(1)
+var caseLabelUnlinkInputSchema = z57.object({
+  label_ids: z57.array(z57.guid()).min(1)
 });
-var caseLabelUnlinkResponseSchema = z56.object({
-  success: z56.boolean()
+var caseLabelUnlinkResponseSchema = z57.object({
+  success: z57.boolean()
 });
-var caseLabelCreateInputSchema = z56.object({
-  key: z56.string().optional().default(""),
-  value: z56.string().min(1),
-  color_hue: z56.int().min(0).max(360).optional()
+var caseLabelCreateInputSchema = z57.object({
+  key: z57.string().optional().default(""),
+  value: z57.string().min(1),
+  color_hue: z57.int().min(0).max(360).optional()
 });
-var caseLabelCreateResponseSchema = z56.object({
+var caseLabelCreateResponseSchema = z57.object({
   label: caseQueueLabelSchema.extend({
-    case_count: z56.int().min(0)
+    case_count: z57.int().min(0)
   })
 });
 var caseQueueLabelWithCountSchema = caseQueueLabelSchema.extend({
-  case_count: z56.int().min(0)
+  case_count: z57.int().min(0)
 });
-var caseLabelsWithCountsListResponseSchema = z56.object({
-  labels: z56.array(caseQueueLabelWithCountSchema)
+var caseLabelsWithCountsListResponseSchema = z57.object({
+  labels: z57.array(caseQueueLabelWithCountSchema)
 });
 var SEQUENTIAL_TRIGGER_CONCURRENCY = 1;
-var settableTriggerConcurrencySchema = z57.literal(SEQUENTIAL_TRIGGER_CONCURRENCY).nullable();
-var caseTriggerApiSchema = z57.object({
-  id: z57.string(),
-  agent_id: z57.string(),
-  case_queue_id: z57.string(),
-  case_queue_name: z57.string(),
-  user_id: z57.string(),
-  enabled: z57.boolean(),
-  concurrency: z57.int().positive().nullable(),
-  created_at: z57.string(),
-  updated_at: z57.string(),
-  creator_display_name: z57.string().nullable(),
-  can_disable: z57.boolean(),
-  has_conflict: z57.boolean(),
-  conflicting_agents: z57.array(conflictingAgentSchema)
-});
-var caseTriggerResponseSchema = z57.object({
+var settableTriggerConcurrencySchema = z58.literal(SEQUENTIAL_TRIGGER_CONCURRENCY).nullable();
+var caseTriggerApiSchema = z58.object({
+  id: z58.string(),
+  agent_id: z58.string(),
+  case_queue_id: z58.string(),
+  case_queue_name: z58.string(),
+  user_id: z58.string(),
+  enabled: z58.boolean(),
+  concurrency: z58.int().positive().nullable(),
+  created_at: z58.string(),
+  updated_at: z58.string(),
+  creator_display_name: z58.string().nullable(),
+  can_disable: z58.boolean(),
+  has_conflict: z58.boolean(),
+  conflicting_agents: z58.array(conflictingAgentSchema)
+});
+var caseTriggerResponseSchema = z58.object({
   case_trigger: caseTriggerApiSchema
 });
-var caseTriggersListResponseSchema = z57.object({
-  case_triggers: z57.array(caseTriggerApiSchema)
+var caseTriggersListResponseSchema = z58.object({
+  case_triggers: z58.array(caseTriggerApiSchema)
 });
-var deleteCaseTriggerResponseSchema = z57.object({
-  success: z57.literal(true)
+var deleteCaseTriggerResponseSchema = z58.object({
+  success: z58.literal(true)
 });
-var caseTriggerConflictPreviewResponseSchema = z57.object({
-  has_conflict: z57.boolean(),
-  conflicting_agents: z57.array(conflictingAgentSchema)
+var caseTriggerConflictPreviewResponseSchema = z58.object({
+  has_conflict: z58.boolean(),
+  conflicting_agents: z58.array(conflictingAgentSchema)
 });
-var integrationConfigMinSchema = z57.object({
-  id: z57.string(),
-  integration_id: z57.guid().nullable(),
-  integration_type: z57.string()
+var integrationConfigMinSchema = z58.object({
+  id: z58.string(),
+  integration_id: z58.guid().nullable(),
+  integration_type: z58.string()
 });
-var integrationConfigsResponseSchema = z57.object({
-  integrations: z57.array(integrationConfigMinSchema)
+var integrationConfigsResponseSchema = z58.object({
+  integrations: z58.array(integrationConfigMinSchema)
 });
-var caseQueueMinSchema = z57.object({
-  id: z57.string(),
-  name: z57.string()
+var caseQueueMinSchema = z58.object({
+  id: z58.string(),
+  name: z58.string()
 });
-var caseQueuesForSlotResponseSchema = z57.object({
-  queues: z57.array(caseQueueMinSchema)
+var caseQueuesForSlotResponseSchema = z58.object({
+  queues: z58.array(caseQueueMinSchema)
 });
 var APPROVAL_DECISION = {
   APPROVED: "approved",
   REJECTED: "rejected"
 };
-var approvalDecisionSchema = z58.enum([
+var approvalDecisionSchema = z59.enum([
   APPROVAL_DECISION.APPROVED,
   APPROVAL_DECISION.REJECTED
 ]);
 var HUMAN_REQUEST_TITLE_MAX = 200;
 var HUMAN_REQUEST_PROMPT_MAX = 2e3;
 var MAX_APPROVERS_PER_BATCH = 20;
-var humanRequestBatchRowSchema = z58.object({
-  id: z58.string().uuid(),
-  assignee_user_id: z58.string().uuid(),
-  assignee_name: z58.string().nullable(),
-  assignee_email: z58.string().nullable(),
+var humanRequestBatchRowSchema = z59.object({
+  id: z59.string().uuid(),
+  assignee_user_id: z59.string().uuid(),
+  assignee_name: z59.string().nullable(),
+  assignee_email: z59.string().nullable(),
   /**
    * The free-text ask the agent posed to THIS specific approver. Each row
    * carries its own prompt — the multi-approver flow does not assume a
    * single shared question across approvers.
    */
-  prompt: z58.string(),
+  prompt: z59.string(),
   decision: approvalDecisionSchema.nullable(),
-  responded_at: z58.string().nullable(),
-  responded_by_user_id: z58.string().uuid().nullable(),
-  responded_by_name: z58.string().nullable(),
-  responded_by_email: z58.string().nullable(),
-  cancelled_at: z58.string().nullable(),
-  cancellation_reason: z58.string().nullable()
-});
-var approvalBatchSchema = z58.object({
-  id: z58.string().uuid(),
-  case_queue_item_id: z58.string().uuid(),
-  agent_run_id: z58.string().uuid(),
-  title: z58.string(),
-  created_at: z58.string(),
-  resolved_at: z58.string().nullable(),
-  cancelled_at: z58.string().nullable(),
-  cancellation_reason: z58.string().nullable(),
-  rows: z58.array(humanRequestBatchRowSchema)
-});
-var approvalRequestInputSchema = z58.object({
-  approverUserId: z58.string().uuid(),
-  prompt: z58.string().trim().min(1).max(HUMAN_REQUEST_PROMPT_MAX)
-});
-var createHumanRequestBatchBodySchema = z58.object({
-  agentRunId: z58.string().uuid(),
-  title: z58.string().trim().min(1).max(HUMAN_REQUEST_TITLE_MAX),
-  requests: z58.array(approvalRequestInputSchema).min(1).max(MAX_APPROVERS_PER_BATCH)
-});
-var createHumanRequestBatchResponseSchema = z58.object({
-  batchId: z58.string().uuid(),
-  createdAt: z58.string(),
-  humanRequestIds: z58.array(z58.string().uuid())
-});
-var requestCaseApprovalsToolInputSchema = z58.object({
-  title: z58.string().trim().min(1).max(HUMAN_REQUEST_TITLE_MAX),
-  requests: z58.array(approvalRequestInputSchema).min(1).max(MAX_APPROVERS_PER_BATCH)
-});
-var requestCaseApprovalsBatchStatusSchema = z58.enum([
+  responded_at: z59.string().nullable(),
+  responded_by_user_id: z59.string().uuid().nullable(),
+  responded_by_name: z59.string().nullable(),
+  responded_by_email: z59.string().nullable(),
+  cancelled_at: z59.string().nullable(),
+  cancellation_reason: z59.string().nullable()
+});
+var approvalBatchSchema = z59.object({
+  id: z59.string().uuid(),
+  case_queue_item_id: z59.string().uuid(),
+  agent_run_id: z59.string().uuid(),
+  title: z59.string(),
+  created_at: z59.string(),
+  resolved_at: z59.string().nullable(),
+  cancelled_at: z59.string().nullable(),
+  cancellation_reason: z59.string().nullable(),
+  rows: z59.array(humanRequestBatchRowSchema)
+});
+var approvalRequestInputSchema = z59.object({
+  approverUserId: z59.string().uuid(),
+  prompt: z59.string().trim().min(1).max(HUMAN_REQUEST_PROMPT_MAX)
+});
+var createHumanRequestBatchBodySchema = z59.object({
+  agentRunId: z59.string().uuid(),
+  title: z59.string().trim().min(1).max(HUMAN_REQUEST_TITLE_MAX),
+  requests: z59.array(approvalRequestInputSchema).min(1).max(MAX_APPROVERS_PER_BATCH)
+});
+var createHumanRequestBatchResponseSchema = z59.object({
+  batchId: z59.string().uuid(),
+  createdAt: z59.string(),
+  humanRequestIds: z59.array(z59.string().uuid())
+});
+var requestCaseApprovalsToolInputSchema = z59.object({
+  title: z59.string().trim().min(1).max(HUMAN_REQUEST_TITLE_MAX),
+  requests: z59.array(approvalRequestInputSchema).min(1).max(MAX_APPROVERS_PER_BATCH)
+});
+var requestCaseApprovalsBatchStatusSchema = z59.enum([
   "resolved",
   "cancelled"
 ]);
-var requestCaseApprovalsDecisionEntrySchema = z58.object({
-  assigneeUserId: z58.string().uuid(),
+var requestCaseApprovalsDecisionEntrySchema = z59.object({
+  assigneeUserId: z59.string().uuid(),
   decision: approvalDecisionSchema,
-  respondedAt: z58.string(),
-  respondedByUserId: z58.string().uuid()
+  respondedAt: z59.string(),
+  respondedByUserId: z59.string().uuid()
 });
-var requestCaseApprovalsToolOutputSchema = z58.object({
+var requestCaseApprovalsToolOutputSchema = z59.object({
   status: requestCaseApprovalsBatchStatusSchema,
-  decisions: z58.array(requestCaseApprovalsDecisionEntrySchema)
-});
-var humanRequestContextSchema = z58.discriminatedUnion("kind", [
-  z58.object({
-    kind: z58.literal("run"),
-    runId: z58.string().uuid(),
-    buildId: z58.string().uuid(),
-    agentId: z58.string().uuid(),
-    agentName: z58.string().nullable()
+  decisions: z59.array(requestCaseApprovalsDecisionEntrySchema)
+});
+var humanRequestContextSchema = z59.discriminatedUnion("kind", [
+  z59.object({
+    kind: z59.literal("run"),
+    runId: z59.string().uuid(),
+    buildId: z59.string().uuid(),
+    agentId: z59.string().uuid(),
+    agentName: z59.string().nullable()
   }),
-  z58.object({
-    kind: z58.literal("case"),
-    queueId: z58.string().uuid(),
-    caseId: z58.string().uuid(),
-    caseTitle: z58.string()
+  z59.object({
+    kind: z59.literal("case"),
+    queueId: z59.string().uuid(),
+    caseId: z59.string().uuid(),
+    caseTitle: z59.string()
   })
 ]);
-var caseQueueItemSchema = z59.object({
-  id: z59.guid(),
-  queue_id: z59.guid(),
-  title: z59.string(),
-  data: z59.string(),
-  status: z59.enum(["pending", "completed", "failed"]),
+var caseQueueItemSchema = z60.object({
+  id: z60.guid(),
+  queue_id: z60.guid(),
+  title: z60.string(),
+  data: z60.string(),
+  status: z60.enum(["pending", "completed", "failed"]),
   /**
    * Derived display bucket combining the settlement status with ownership,
    * open HITL tokens, and scheduling. See CASE_DISPLAY_STATUS in
    * `constants/case-queue.ts` for the derivation rules.
    */
-  display_status: z59.enum([
+  display_status: z60.enum([
     "pending",
     "in_progress",
     "needs_input",
@@ -9427,30 +9473,30 @@ var caseQueueItemSchema = z59.object({
     "completed",
     "failed"
   ]),
-  claimed_at: z59.string().nullable(),
-  claimed_by_run_id: z59.string().nullable(),
-  completed_at: z59.string().nullable(),
+  claimed_at: z60.string().nullable(),
+  claimed_by_run_id: z60.string().nullable(),
+  completed_at: z60.string().nullable(),
   /** When the case is scheduled to be re-handled (null if not postponed) */
-  postponed_to: z59.string().nullable(),
-  created_at: z59.string(),
-  updated_at: z59.string(),
-  created_by_user_id: z59.guid().nullable(),
-  created_by_user_name: z59.string().nullable(),
-  created_by_user_email: z59.string().nullable(),
+  postponed_to: z60.string().nullable(),
+  created_at: z60.string(),
+  updated_at: z60.string(),
+  created_by_user_id: z60.guid().nullable(),
+  created_by_user_name: z60.string().nullable(),
+  created_by_user_email: z60.string().nullable(),
   /** Status of the associated agent run (running, waiting, etc.) - null if no active run */
-  agent_run_status: z59.string().nullable(),
+  agent_run_status: z60.string().nullable(),
   /** User ID of the owner of the active agent run - null if no active run */
-  agent_run_user_id: z59.guid().nullable(),
+  agent_run_user_id: z60.guid().nullable(),
   /** ID of the pending human request for cases waiting for input */
-  pending_human_request_id: z59.guid().nullable(),
+  pending_human_request_id: z60.guid().nullable(),
   /** ID of the open `human_request_batch` bound to this case, if any. Used to derive the `awaiting_approval` UI state. */
-  pending_approval_batch_id: z59.guid().nullable(),
+  pending_approval_batch_id: z60.guid().nullable(),
   /** User IDs of approvers named on the open batch's unresolved rows. Used to switch the badge to "Awaiting your approval" when the viewer is one of them. */
-  pending_approval_assignee_user_ids: z59.array(z59.guid()),
+  pending_approval_assignee_user_ids: z60.array(z60.guid()),
   /** Count of resolved `human_request` approval rows on this case with `decision = 'approved'`. */
-  approval_approved_count: z59.int().nonnegative(),
+  approval_approved_count: z60.int().nonnegative(),
   /** Count of resolved `human_request` approval rows on this case with `decision = 'rejected'`. */
-  approval_rejected_count: z59.int().nonnegative(),
+  approval_rejected_count: z60.int().nonnegative(),
   /**
    * Whole-case evaluation summary for the "Found issues" column, mirroring a
    * Run's `eval_summaries`. Derived from the latest `case_evaluation` output:
@@ -9460,59 +9506,59 @@ var caseQueueItemSchema = z59.object({
    */
   eval_summary: evalSummarySchema.nullable().optional(),
   /** Snippet from the data field showing search match context. Only present when search matches data. */
-  search_match_data_snippet: z59.object({
-    before: z59.string(),
-    match: z59.string(),
-    after: z59.string()
+  search_match_data_snippet: z60.object({
+    before: z60.string(),
+    match: z60.string(),
+    after: z60.string()
   }).optional(),
-  labels: z59.array(caseQueueLabelSchema)
-});
-var caseQueueItemEventSchema = z59.object({
-  id: z59.guid(),
-  case_queue_item_id: z59.guid(),
-  agent_run_id: z59.guid().nullable(),
-  human_request_id: z59.guid().nullable(),
-  type: z59.string(),
-  reason: z59.string().nullable(),
-  created_at: z59.string(),
-  agent_id: z59.guid().nullable(),
-  agent_name: z59.string().nullable(),
+  labels: z60.array(caseQueueLabelSchema)
+});
+var caseQueueItemEventSchema = z60.object({
+  id: z60.guid(),
+  case_queue_item_id: z60.guid(),
+  agent_run_id: z60.guid().nullable(),
+  human_request_id: z60.guid().nullable(),
+  type: z60.string(),
+  reason: z60.string().nullable(),
+  created_at: z60.string(),
+  agent_id: z60.guid().nullable(),
+  agent_name: z60.string().nullable(),
   /**
    * Owner of the agent run referenced by this event (joined from
    * `agent_run.user_id`). The frontend mirrors the backend
    * `assertCanAccessRun` gate against this id + the viewer's team role to
    * decide whether the row should expose a click affordance.
    */
-  user_id: z59.guid().nullable(),
-  user_name: z59.string().nullable(),
-  user_email: z59.string().nullable(),
-  human_request_title: z59.string().nullable()
-});
-var casesListResponseSchema = z59.object({
-  cases: z59.array(caseQueueItemSchema),
-  total: z59.number(),
-  limit: z59.int(),
-  offset: z59.int()
-});
-var caseCreateInputSchema = z59.object({
-  title: z59.string().min(1).max(500).describe(
+  user_id: z60.guid().nullable(),
+  user_name: z60.string().nullable(),
+  user_email: z60.string().nullable(),
+  human_request_title: z60.string().nullable()
+});
+var casesListResponseSchema = z60.object({
+  cases: z60.array(caseQueueItemSchema),
+  total: z60.number(),
+  limit: z60.int(),
+  offset: z60.int()
+});
+var caseCreateInputSchema = z60.object({
+  title: z60.string().min(1).max(500).describe(
     "Short title for the case (max 500 characters). Put long context in `data`."
   ),
-  data: z59.string().optional().describe(
+  data: z60.string().optional().describe(
     "Additional data for the case. Free-form text or JSON; Agents receive this on claim."
   ),
-  labels: z59.array(
-    z59.object({
-      key: z59.string().optional().default("").describe("Label key (omit for a simple tag)."),
-      value: z59.string().min(1).describe("Label value (required).")
+  labels: z60.array(
+    z60.object({
+      key: z60.string().optional().default("").describe("Label key (omit for a simple tag)."),
+      value: z60.string().min(1).describe("Label value (required).")
     })
   ).max(50).optional().describe(
     "Optional labels to assign to the case at creation. Labels are created on the queue if they don't already exist."
   )
 });
-var caseCreateRequestSchema = z59.object({
+var caseCreateRequestSchema = z60.object({
   case: caseCreateInputSchema.optional(),
-  cases: z59.array(caseCreateInputSchema).min(1).max(100).optional()
+  cases: z60.array(caseCreateInputSchema).min(1).max(100).optional()
 }).superRefine((val, ctx) => {
   const hasCase = val.case !== void 0;
   const hasCases = val.cases !== void 0;
@@ -9530,28 +9576,28 @@ var caseCreateRequestSchema = z59.object({
     });
   }
 });
-var caseCreateResponseSchema = z59.object({
-  added_cases: z59.array(caseQueueItemSchema)
+var caseCreateResponseSchema = z60.object({
+  added_cases: z60.array(caseQueueItemSchema)
 });
-var casesStatsSchema = z59.object({
-  total: z59.number(),
+var casesStatsSchema = z60.object({
+  total: z60.number(),
   /** Pending, unowned, not postponed — idle and claimable */
-  pending: z59.number(),
+  pending: z60.number(),
   /** "In Progress": pending cases owned by a run with no open HITL token */
-  claimed: z59.number(),
+  claimed: z60.number(),
   /** "Needs Input": pending cases whose owning run has an open HITL token */
-  waiting: z59.number(),
+  waiting: z60.number(),
   /** Pending, unowned cases postponed for later */
-  postponed: z59.number(),
-  completed: z59.number(),
-  failed: z59.number()
+  postponed: z60.number(),
+  completed: z60.number(),
+  failed: z60.number()
 });
-var casesStatsResponseSchema = z59.object({
+var casesStatsResponseSchema = z60.object({
   stats: casesStatsSchema
 });
-var caseDetailResponseSchema = z59.object({
+var caseDetailResponseSchema = z60.object({
   case: caseQueueItemSchema,
-  events: z59.array(caseQueueItemEventSchema),
+  events: z60.array(caseQueueItemEventSchema),
   /**
    * Every approval batch ever created on this case, newest first. Each
    * batch carries one child row per named approver (with their decision
@@ -9559,21 +9605,21 @@ var caseDetailResponseSchema = z59.object({
    * grouped per batch so the case-level approval history reads inline.
    * Empty array when no batch has ever been created on the case.
    */
-  approvalBatches: z59.array(approvalBatchSchema)
+  approvalBatches: z60.array(approvalBatchSchema)
 });
-var caseJobSummarySchema = z59.object({
-  id: z59.string().uuid(),
-  case_queue_item_id: z59.string().uuid(),
-  agent_id: z59.string().uuid(),
-  agent_name: z59.string(),
+var caseJobSummarySchema = z60.object({
+  id: z60.string().uuid(),
+  case_queue_item_id: z60.string().uuid(),
+  agent_id: z60.string().uuid(),
+  agent_name: z60.string(),
   status: agentRunStatusSchema,
-  source: z59.string().nullable(),
-  created_at: z59.string(),
-  started_at: z59.string().nullable(),
-  completed_at: z59.string().nullable(),
-  claimed_at: z59.string(),
-  has_pending_human_request: z59.boolean(),
-  pending_human_request_title: z59.string().nullable(),
+  source: z60.string().nullable(),
+  created_at: z60.string(),
+  started_at: z60.string().nullable(),
+  completed_at: z60.string().nullable(),
+  claimed_at: z60.string(),
+  has_pending_human_request: z60.boolean(),
+  pending_human_request_title: z60.string().nullable(),
   evaluation: evalSummarySchema,
   /**
    * Owner of the agent run (from `agent_run.user_id`). The frontend mirrors
@@ -9581,228 +9627,228 @@ var caseJobSummarySchema = z59.object({
    * team role to decide whether the card is interactive (live messages,
    * HITL affordances, drawer link).
    */
-  user_id: z59.guid().nullable(),
+  user_id: z60.guid().nullable(),
   /**
    * Display name of the user who triggered the run, joined from `profiles`.
    * Falls back to `user_email` for the in-card user pill when null.
    */
-  user_name: z59.string().nullable(),
-  user_email: z59.string().nullable()
+  user_name: z60.string().nullable(),
+  user_email: z60.string().nullable()
 });
-var caseJobsResponseSchema = z59.object({
-  runs: z59.array(caseJobSummarySchema)
+var caseJobsResponseSchema = z60.object({
+  runs: z60.array(caseJobSummarySchema)
 });
-var caseJobRecentMessagesResponseSchema = z59.object({
-  messages: z59.array(agentMessageWithCreatedAtSchema)
+var caseJobRecentMessagesResponseSchema = z60.object({
+  messages: z60.array(agentMessageWithCreatedAtSchema)
 });
-var adjacentCasesResponseSchema = z59.object({
-  previousId: z59.guid().nullable(),
-  nextId: z59.guid().nullable(),
-  position: z59.number(),
-  total: z59.number()
+var adjacentCasesResponseSchema = z60.object({
+  previousId: z60.guid().nullable(),
+  nextId: z60.guid().nullable(),
+  position: z60.number(),
+  total: z60.number()
 });
-var caseDeleteResponseSchema = z59.object({
-  success: z59.boolean(),
-  interruptedRunIds: z59.array(z59.guid())
+var caseDeleteResponseSchema = z60.object({
+  success: z60.boolean(),
+  interruptedRunIds: z60.array(z60.guid())
 });
-var caseBulkDeleteResponseSchema = z59.object({
-  deletedCount: z59.number(),
-  interruptedRunIds: z59.array(z59.guid())
+var caseBulkDeleteResponseSchema = z60.object({
+  deletedCount: z60.number(),
+  interruptedRunIds: z60.array(z60.guid())
 });
-var caseBulkReprocessResponseSchema = z59.object({
-  reprocessedCount: z59.number(),
-  skippedCount: z59.number(),
+var caseBulkReprocessResponseSchema = z60.object({
+  reprocessedCount: z60.number(),
+  skippedCount: z60.number(),
   // Deprecated aliases of `reprocessedCount`, both equal to it. Returned so
   // clients 308-redirected here from the deprecated `bulk-delegate` /
   // `bulk-retry` endpoints still find their original field. Optional +
   // `deprecated` so consumers don't couple to them; removed with those aliases
   // at the 2026-06-10 sunset.
-  delegatedCount: z59.number().meta({
+  delegatedCount: z60.number().meta({
     deprecated: true,
     description: "Deprecated alias of reprocessedCount, kept for clients redirected from bulk-delegate. Removed on 2026-06-10."
   }).optional(),
-  retriedCount: z59.number().meta({
+  retriedCount: z60.number().meta({
     deprecated: true,
     description: "Deprecated alias of reprocessedCount, kept for clients redirected from bulk-retry. Removed on 2026-06-10."
   }).optional()
 });
-var caseBulkStatusUpdateResponseSchema = z59.object({
-  updatedCount: z59.number(),
-  skippedCount: z59.number(),
-  interruptedRunIds: z59.array(z59.guid())
-});
-var deleteQueueResponseSchema = z59.object({
-  success: z59.boolean(),
-  deleted_case_count: z59.number(),
-  interrupted_run_ids: z59.array(z59.guid())
-});
-var caseClearQueueResponseSchema = z59.object({
-  success: z59.boolean(),
-  deletedCount: z59.number(),
-  interruptedRunIds: z59.array(z59.guid())
-});
-var caseQueueSchema = z59.object({
-  id: z59.guid(),
-  name: z59.string(),
-  description: z59.string().nullable(),
-  folder_id: z59.guid().nullable(),
+var caseBulkStatusUpdateResponseSchema = z60.object({
+  updatedCount: z60.number(),
+  skippedCount: z60.number(),
+  interruptedRunIds: z60.array(z60.guid())
+});
+var deleteQueueResponseSchema = z60.object({
+  success: z60.boolean(),
+  deleted_case_count: z60.number(),
+  interrupted_run_ids: z60.array(z60.guid())
+});
+var caseClearQueueResponseSchema = z60.object({
+  success: z60.boolean(),
+  deletedCount: z60.number(),
+  interruptedRunIds: z60.array(z60.guid())
+});
+var caseQueueSchema = z60.object({
+  id: z60.guid(),
+  name: z60.string(),
+  description: z60.string().nullable(),
+  folder_id: z60.guid().nullable(),
   // Optional (additive) so existing CaseQueue consumers and fixtures across the
   // FE/CLI don't break; the backend always populates it on real responses.
-  automation_id: z59.guid().nullable().optional(),
-  created_at: z59.string(),
+  automation_id: z60.guid().nullable().optional(),
+  created_at: z60.string(),
   /**
    * True when at least one case in this queue has ever had an approval
    * batch (open, resolved, or cancelled). The frontend uses this to relabel
    * the "Needs input" filter to "Needs input/approval" and to show the
    * per-case approvals column.
    */
-  has_approvals: z59.boolean()
+  has_approvals: z60.boolean()
 });
-var caseQueuesResponseSchema = z59.object({
-  queues: z59.array(caseQueueSchema),
-  total: z59.number(),
-  limit: z59.number(),
-  offset: z59.number()
+var caseQueuesResponseSchema = z60.object({
+  queues: z60.array(caseQueueSchema),
+  total: z60.number(),
+  limit: z60.number(),
+  offset: z60.number()
 });
-var caseGetQueueResponseSchema = z59.object({
+var caseGetQueueResponseSchema = z60.object({
   queue: caseQueueSchema
 });
-var caseCreateQueueResponseSchema = z59.object({
+var caseCreateQueueResponseSchema = z60.object({
   queue: caseQueueSchema
 });
-var caseUpdateQueueResponseSchema = z59.object({
+var caseUpdateQueueResponseSchema = z60.object({
   queue: caseQueueSchema
 });
-var caseQueueAgentProblemSchema = z59.enum([
+var caseQueueAgentProblemSchema = z60.enum([
   "multiple_triggers",
   "producer_consumer_mix"
 ]);
-var queueAgentProducerSchema = z59.object({
-  agent_id: z59.guid(),
-  agent_name: z59.string(),
-  case_trigger_enabled: z59.boolean(),
-  case_trigger_queue_name: z59.string().nullable(),
-  problems: z59.array(caseQueueAgentProblemSchema)
-});
-var queueAgentConsumerSchema = z59.object({
-  agent_id: z59.guid(),
-  agent_name: z59.string(),
-  case_trigger_enabled: z59.boolean(),
-  is_handover_target: z59.boolean(),
-  problems: z59.array(caseQueueAgentProblemSchema),
+var queueAgentProducerSchema = z60.object({
+  agent_id: z60.guid(),
+  agent_name: z60.string(),
+  case_trigger_enabled: z60.boolean(),
+  case_trigger_queue_name: z60.string().nullable(),
+  problems: z60.array(caseQueueAgentProblemSchema)
+});
+var queueAgentConsumerSchema = z60.object({
+  agent_id: z60.guid(),
+  agent_name: z60.string(),
+  case_trigger_enabled: z60.boolean(),
+  is_handover_target: z60.boolean(),
+  problems: z60.array(caseQueueAgentProblemSchema),
   /**
    * Max concurrent Jobs this consumer's enabled trigger allows, after the
    * platform cap is applied. Populated only by the single-queue agents
    * endpoint; omitted when the consumer has no enabled trigger.
    */
-  concurrency_limit: z59.int().nonnegative().optional(),
+  concurrency_limit: z60.int().nonnegative().optional(),
   /**
    * True when this consumer's active Jobs have reached `concurrency_limit`, so
    * the dispatcher pauses and new cases stay pending until a Job finishes.
    * Populated only by the single-queue agents endpoint.
    */
-  at_concurrency_limit: z59.boolean().optional()
-});
-var queueAgentsResponseSchema = z59.object({
-  queue_name: z59.string(),
-  producers: z59.array(queueAgentProducerSchema),
-  consumers: z59.array(queueAgentConsumerSchema)
-});
-var exportCasesResponseSchema = z59.object({
-  version: z59.number(),
-  queue_name: z59.string(),
-  exported_at: z59.string(),
-  cases: z59.array(
-    z59.object({
-      title: z59.string(),
-      data: z59.string().optional()
+  at_concurrency_limit: z60.boolean().optional()
+});
+var queueAgentsResponseSchema = z60.object({
+  queue_name: z60.string(),
+  producers: z60.array(queueAgentProducerSchema),
+  consumers: z60.array(queueAgentConsumerSchema)
+});
+var exportCasesResponseSchema = z60.object({
+  version: z60.number(),
+  queue_name: z60.string(),
+  exported_at: z60.string(),
+  cases: z60.array(
+    z60.object({
+      title: z60.string(),
+      data: z60.string().optional()
     })
   )
 });
-var importCasesResponseSchema = z59.object({
-  imported_count: z59.number()
+var importCasesResponseSchema = z60.object({
+  imported_count: z60.number()
 });
-var batchQueueStatsResponseSchema = z59.object({
-  stats: z59.record(z59.guid(), casesStatsSchema)
+var batchQueueStatsResponseSchema = z60.object({
+  stats: z60.record(z60.guid(), casesStatsSchema)
 });
-var batchQueueAgentsResponseSchema = z59.object({
-  agents: z59.record(
-    z59.guid(),
-    z59.object({
-      producers: z59.array(queueAgentProducerSchema),
-      consumers: z59.array(queueAgentConsumerSchema)
+var batchQueueAgentsResponseSchema = z60.object({
+  agents: z60.record(
+    z60.guid(),
+    z60.object({
+      producers: z60.array(queueAgentProducerSchema),
+      consumers: z60.array(queueAgentConsumerSchema)
     })
   )
 });
-var createTeamInviteLinkRequestSchema = z60.object({
-  frontendUrl: z60.url()
+var createTeamInviteLinkRequestSchema = z61.object({
+  frontendUrl: z61.url()
 });
-var getTeamInviteLinkQuerySchema = z60.object({
-  frontendUrl: z60.url()
+var getTeamInviteLinkQuerySchema = z61.object({
+  frontendUrl: z61.url()
 });
-var teamInviteLinkCreatorSchema = z60.object({
-  id: z60.guid(),
-  name: z60.string().nullable(),
-  email: z60.email()
+var teamInviteLinkCreatorSchema = z61.object({
+  id: z61.guid(),
+  name: z61.string().nullable(),
+  email: z61.email()
 });
-var teamInviteLinkSchema = z60.object({
-  id: z60.guid(),
-  url: z60.url().optional(),
-  createdAt: z60.string(),
+var teamInviteLinkSchema = z61.object({
+  id: z61.guid(),
+  url: z61.url().optional(),
+  createdAt: z61.string(),
   createdBy: teamInviteLinkCreatorSchema
 });
-var getTeamInviteLinkResponseSchema = z60.object({
-  hasLink: z60.boolean(),
+var getTeamInviteLinkResponseSchema = z61.object({
+  hasLink: z61.boolean(),
   link: teamInviteLinkSchema.optional()
 });
-var joinLinkInfoResponseSchema = z60.object({
-  valid: z60.boolean(),
-  teamName: z60.string().optional(),
-  teamId: z60.guid().optional(),
-  reason: z60.enum(["invalid", "expired"]).optional()
+var joinLinkInfoResponseSchema = z61.object({
+  valid: z61.boolean(),
+  teamName: z61.string().optional(),
+  teamId: z61.guid().optional(),
+  reason: z61.enum(["invalid", "expired"]).optional()
 });
-var acceptJoinLinkResponseSchema = z60.object({
-  success: z60.boolean(),
-  teamId: z60.guid()
+var acceptJoinLinkResponseSchema = z61.object({
+  success: z61.boolean(),
+  teamId: z61.guid()
 });
-var createClarityProcessInviteLinkRequestSchema = z61.object({
-  frontendUrl: z61.url()
+var createClarityProcessInviteLinkRequestSchema = z62.object({
+  frontendUrl: z62.url()
 });
 var clarityProcessInviteLinkSchema = teamInviteLinkSchema;
-var getClarityProcessInviteLinkResponseSchema = z61.object({
-  hasLink: z61.boolean(),
+var getClarityProcessInviteLinkResponseSchema = z62.object({
+  hasLink: z62.boolean(),
   link: clarityProcessInviteLinkSchema.optional()
 });
-var clarityJoinLinkInfoResponseSchema = z61.object({
-  valid: z61.boolean(),
-  processName: z61.string().optional(),
-  processId: z61.guid().optional(),
-  teamId: z61.guid().optional(),
-  reason: z61.enum(["invalid", "expired"]).optional()
-});
-var acceptClarityJoinLinkResponseSchema = z61.object({
-  success: z61.boolean(),
-  processId: z61.guid()
-});
-var credentialPreviewSchema = z62.object({
-  id: z62.guid().describe("Credential ID"),
-  domain: z62.string().describe("Domain for the credential"),
-  username: z62.string().nullable().describe("Username (if any)"),
-  hasEnabledTOTP: z62.boolean().describe("Whether TOTP is enabled"),
-  hasPassword: z62.boolean().describe("Whether a password is stored"),
-  user_id: z62.string().nullable().describe("Owner user id; null when shared with the team")
-});
-var otpResponseSchema = z62.object({
-  code: z62.string().describe("The TOTP code"),
-  expiresAt: z62.number().describe("Expiration timestamp in milliseconds")
-});
-var encryptedDataSchema = z62.object({
-  encrypted_data: z62.string().describe("Base64-encoded encrypted data"),
-  key_version: z62.string().describe("KMS key version or 'base64' for dev")
-});
-var credentialDetailSchema = z62.object({
-  domain: z62.string().describe("Domain for the credential"),
-  username: z62.string().nullable().describe("Username (if any)"),
+var clarityJoinLinkInfoResponseSchema = z62.object({
+  valid: z62.boolean(),
+  processName: z62.string().optional(),
+  processId: z62.guid().optional(),
+  teamId: z62.guid().optional(),
+  reason: z62.enum(["invalid", "expired"]).optional()
+});
+var acceptClarityJoinLinkResponseSchema = z62.object({
+  success: z62.boolean(),
+  processId: z62.guid()
+});
+var credentialPreviewSchema = z63.object({
+  id: z63.guid().describe("Credential ID"),
+  domain: z63.string().describe("Domain for the credential"),
+  username: z63.string().nullable().describe("Username (if any)"),
+  hasEnabledTOTP: z63.boolean().describe("Whether TOTP is enabled"),
+  hasPassword: z63.boolean().describe("Whether a password is stored"),
+  user_id: z63.string().nullable().describe("Owner user id; null when shared with the team")
+});
+var otpResponseSchema = z63.object({
+  code: z63.string().describe("The TOTP code"),
+  expiresAt: z63.number().describe("Expiration timestamp in milliseconds")
+});
+var encryptedDataSchema = z63.object({
+  encrypted_data: z63.string().describe("Base64-encoded encrypted data"),
+  key_version: z63.string().describe("KMS key version or 'base64' for dev")
+});
+var credentialDetailSchema = z63.object({
+  domain: z63.string().describe("Domain for the credential"),
+  username: z63.string().nullable().describe("Username (if any)"),
   password: encryptedDataSchema.nullable().describe("Encrypted password data")
 });
 var FEATURE_FLAG_CATALOGUE = {
@@ -9961,6 +10007,11 @@ var FEATURE_FLAG_CATALOGUE = {
     defaultValue: false,
     description: "Enables the Move Agent to another team flow. Default-off while we monitor multi-table move semantics in prod; flip on for individual teams to grant access."
   },
+  CROSS_TEAM_PULSE_MOVE: {
+    key: "cross_team_pulse_move",
+    defaultValue: false,
+    description: "Enables the Move Pulse dashboard to another team flow. Moving a dashboard reassigns its ownership to the mover, resets it to private, and reconnects or drops its attached Connections against the target team. Default-off while we monitor move semantics in prod; flip on for individual teams to grant access."
+  },
   TEAM_ONTOLOGY: {
     key: "team_ontology",
     defaultValue: false,
@@ -9986,11 +10037,6 @@ var FEATURE_FLAG_CATALOGUE = {
     defaultValue: false,
     description: "Enables minute-level granularity for scheduling agents, allowing sub-hour scheduling intervals for queue postponement."
   },
-  NEW_ORG_ONBOARDING: {
-    key: "new_org_onboarding",
-    defaultValue: false,
-    description: "Gates the entire organizations feature. When disabled, org UI is hidden and org API routes return 404 so the feature appears not to exist. When enabled, users can create organizations, invite members, manage teams under orgs, and go through the org-based onboarding flow."
-  },
   NOTIFICATION_CENTER: {
     key: "notification_center",
     defaultValue: false,
@@ -10044,160 +10090,160 @@ function coerceFlagValue(value) {
 }
 __name(coerceFlagValue, "coerceFlagValue");
 __name2(coerceFlagValue, "coerceFlagValue");
-var teamFileItemSchema = z63.object({
-  id: z63.string(),
-  name: z63.string(),
-  path: z63.string(),
-  created_at: z63.string().optional(),
-  updated_at: z63.string().optional(),
-  metadata: z63.object({
-    mimetype: z63.string().optional(),
-    size: z63.number().optional()
+var teamFileItemSchema = z64.object({
+  id: z64.string(),
+  name: z64.string(),
+  path: z64.string(),
+  created_at: z64.string().optional(),
+  updated_at: z64.string().optional(),
+  metadata: z64.object({
+    mimetype: z64.string().optional(),
+    size: z64.number().optional()
   }).nullable().optional()
 });
-var listTeamFilesResponseSchema = z63.object({
-  files: z63.array(teamFileItemSchema)
-});
-var createTeamFileUploadUrlBodySchema = z63.object({
-  fileName: z63.string().min(1),
-  contentType: z63.string().min(1)
-});
-var createTeamFileUploadUrlResponseSchema = z63.object({
-  signedUrl: z63.url(),
-  expiresAt: z63.iso.datetime(),
-  filePath: z63.string()
-});
-var renameTeamFileBodySchema = z63.object({
-  relativePath: z63.string().min(1),
-  newFilenameOnly: z63.string().min(1)
-});
-var teamFileSuccessResponseSchema = z63.object({
-  success: z63.boolean()
-});
-var teamFileDownloadUrlResponseSchema = z63.object({
-  url: z63.url(),
-  expiresAt: z63.iso.datetime()
-});
-var teamFileContentResponseSchema = z63.object({
-  content: z63.string(),
-  path: z63.string(),
-  contentType: z63.string().optional()
-});
-var updateTeamFileContentBodySchema = z63.object({
-  content: z63.string()
-});
-var globalAdminApiSchema = z64.object({
-  id: z64.guid(),
-  email: z64.string(),
-  userId: z64.guid(),
-  userName: z64.string().nullable(),
-  addedByUserId: z64.guid().nullable(),
-  createdAt: z64.string()
-});
-var globalAdminListResponseSchema = z64.object({
-  admins: z64.array(globalAdminApiSchema)
-});
-var globalAdminSearchResponseSchema = z64.object({
-  users: z64.array(
-    z64.object({
-      id: z64.guid(),
-      name: z64.string().nullable(),
-      email: z64.string(),
-      createdAt: z64.string().nullable()
+var listTeamFilesResponseSchema = z64.object({
+  files: z64.array(teamFileItemSchema)
+});
+var createTeamFileUploadUrlBodySchema = z64.object({
+  fileName: z64.string().min(1),
+  contentType: z64.string().min(1)
+});
+var createTeamFileUploadUrlResponseSchema = z64.object({
+  signedUrl: z64.url(),
+  expiresAt: z64.iso.datetime(),
+  filePath: z64.string()
+});
+var renameTeamFileBodySchema = z64.object({
+  relativePath: z64.string().min(1),
+  newFilenameOnly: z64.string().min(1)
+});
+var teamFileSuccessResponseSchema = z64.object({
+  success: z64.boolean()
+});
+var teamFileDownloadUrlResponseSchema = z64.object({
+  url: z64.url(),
+  expiresAt: z64.iso.datetime()
+});
+var teamFileContentResponseSchema = z64.object({
+  content: z64.string(),
+  path: z64.string(),
+  contentType: z64.string().optional()
+});
+var updateTeamFileContentBodySchema = z64.object({
+  content: z64.string()
+});
+var globalAdminApiSchema = z65.object({
+  id: z65.guid(),
+  email: z65.string(),
+  userId: z65.guid(),
+  userName: z65.string().nullable(),
+  addedByUserId: z65.guid().nullable(),
+  createdAt: z65.string()
+});
+var globalAdminListResponseSchema = z65.object({
+  admins: z65.array(globalAdminApiSchema)
+});
+var globalAdminSearchResponseSchema = z65.object({
+  users: z65.array(
+    z65.object({
+      id: z65.guid(),
+      name: z65.string().nullable(),
+      email: z65.string(),
+      createdAt: z65.string().nullable()
     })
   )
 });
-var globalAdminCreateRequestSchema = z64.object({
-  userId: z64.guid()
+var globalAdminCreateRequestSchema = z65.object({
+  userId: z65.guid()
 });
-var globalAdminCreateResponseSchema = z64.object({
+var globalAdminCreateResponseSchema = z65.object({
   admin: globalAdminApiSchema
 });
-var globalAdminDeleteResponseSchema = z64.object({
-  success: z64.literal(true)
+var globalAdminDeleteResponseSchema = z65.object({
+  success: z65.literal(true)
 });
-var adminAccessCheckResponseSchema = z64.object({
-  isGlobalAdmin: z64.boolean()
+var adminAccessCheckResponseSchema = z65.object({
+  isGlobalAdmin: z65.boolean()
 });
 var JOB_LIST_SORT_COLUMNS = ["created_at"];
-var jobListSortColumnSchema = z65.enum(JOB_LIST_SORT_COLUMNS);
-var jobListIssueSeveritySchema = z65.enum(
+var jobListSortColumnSchema = z66.enum(JOB_LIST_SORT_COLUMNS);
+var jobListIssueSeveritySchema = z66.enum(
   ALL_EVALUATION_RUBRIC_SEVERITIES
 );
-var jobListItemSchema = z65.object({
-  id: z65.guid(),
-  created_at: z65.coerce.date(),
-  updated_at: z65.coerce.date(),
-  started_at: z65.coerce.date().nullable(),
-  completed_at: z65.coerce.date().nullable(),
+var jobListItemSchema = z66.object({
+  id: z66.guid(),
+  created_at: z66.coerce.date(),
+  updated_at: z66.coerce.date(),
+  started_at: z66.coerce.date().nullable(),
+  completed_at: z66.coerce.date().nullable(),
   status: agentRunStatusSchema,
-  source: z65.string().nullable(),
-  title: z65.string(),
-  run_number: z65.number(),
+  source: z66.string().nullable(),
+  title: z66.string(),
+  run_number: z66.number(),
   // Agent info
-  agent_id: z65.guid(),
-  agent_name: z65.string(),
-  build_id: z65.guid(),
+  agent_id: z66.guid(),
+  agent_name: z66.string(),
+  build_id: z66.guid(),
   // User info
-  user_id: z65.guid().nullable(),
+  user_id: z66.guid().nullable(),
   // Case info
-  case_queue_item_id: z65.guid().nullable(),
-  case_queue_id: z65.guid().nullable(),
-  case_queue_name: z65.string().nullable(),
-  case_title: z65.string().nullable(),
-  postponed_to: z65.coerce.date().nullable(),
-  submitted_prompt_count: z65.number().int().min(0),
+  case_queue_item_id: z66.guid().nullable(),
+  case_queue_id: z66.guid().nullable(),
+  case_queue_name: z66.string().nullable(),
+  case_title: z66.string().nullable(),
+  postponed_to: z66.coerce.date().nullable(),
+  submitted_prompt_count: z66.number().int().min(0),
   eval_summaries: evalSummarySchema.nullable().optional()
 });
-var jobListResponseSchema = z65.object({
-  data: z65.array(jobListItemSchema),
-  total: z65.number()
+var jobListResponseSchema = z66.object({
+  data: z66.array(jobListItemSchema),
+  total: z66.number()
 });
-var jobFilterOptionsSchema = z65.object({
-  agents: z65.array(
-    z65.object({
-      id: z65.string(),
-      name: z65.string(),
-      folder_id: z65.string().nullable()
+var jobFilterOptionsSchema = z66.object({
+  agents: z66.array(
+    z66.object({
+      id: z66.string(),
+      name: z66.string(),
+      folder_id: z66.string().nullable()
     })
   ),
-  folders: z65.array(
-    z65.object({
-      id: z65.string(),
-      name: z65.string(),
-      parent_folder_id: z65.string().nullable()
+  folders: z66.array(
+    z66.object({
+      id: z66.string(),
+      name: z66.string(),
+      parent_folder_id: z66.string().nullable()
     })
   ),
-  users: z65.array(
-    z65.object({
-      id: z65.string(),
-      name: z65.string().nullable(),
-      email: z65.string()
+  users: z66.array(
+    z66.object({
+      id: z66.string(),
+      name: z66.string().nullable(),
+      email: z66.string()
     })
   ),
-  caseQueues: z65.array(z65.object({ id: z65.string(), name: z65.string() }))
-});
-var mcpStepSchema = z66.object({
-  tool: z66.string().describe("MCP tool name (e.g., click, fill, navigate_page)"),
-  params: z66.record(z66.string(), z66.unknown()).describe("Tool-specific parameters"),
-  fallbackSelectors: z66.array(z66.string()).optional().describe("Alternative CSS selectors if primary fails"),
-  description: z66.string().optional().describe("Human-readable step description"),
-  screenshot: z66.string().optional().describe("Base64 screenshot at this step for visual context"),
-  snapshot: z66.string().optional().describe("DOM snapshot in accessibility tree format at this step"),
-  framePath: z66.array(z66.number()).optional().describe(
+  caseQueues: z66.array(z66.object({ id: z66.string(), name: z66.string() }))
+});
+var mcpStepSchema = z67.object({
+  tool: z67.string().describe("MCP tool name (e.g., click, fill, navigate_page)"),
+  params: z67.record(z67.string(), z67.unknown()).describe("Tool-specific parameters"),
+  fallbackSelectors: z67.array(z67.string()).optional().describe("Alternative CSS selectors if primary fails"),
+  description: z67.string().optional().describe("Human-readable step description"),
+  screenshot: z67.string().optional().describe("Base64 screenshot at this step for visual context"),
+  snapshot: z67.string().optional().describe("DOM snapshot in accessibility tree format at this step"),
+  framePath: z67.array(z67.number()).optional().describe(
     "Index-based path to the target iframe (e.g., [0] for first child iframe, [1, 0] for nested)"
   )
 });
-var mcpWorkflowSchema = z66.object({
-  name: z66.string(),
-  startUrl: z66.string(),
-  viewport: z66.object({
-    width: z66.number(),
-    height: z66.number()
+var mcpWorkflowSchema = z67.object({
+  name: z67.string(),
+  startUrl: z67.string(),
+  viewport: z67.object({
+    width: z67.number(),
+    height: z67.number()
   }),
-  steps: z66.array(mcpStepSchema)
+  steps: z67.array(mcpStepSchema)
 });
-var MCP_WORKFLOW_JSON_SCHEMA = z66.toJSONSchema(mcpWorkflowSchema, {
+var MCP_WORKFLOW_JSON_SCHEMA = z67.toJSONSchema(mcpWorkflowSchema, {
   reused: "inline"
 });
 var MCP_WORKFLOW_SCHEMA_DOCS = JSON.stringify(
@@ -10206,52 +10252,55 @@ var MCP_WORKFLOW_SCHEMA_DOCS = JSON.stringify(
   2
 );
 var ORG_BROWSER_CONFIG_VERSION = 1;
-var organizationBrowserConfigDataSchema = z67.object({
+var organizationBrowserConfigDataSchema = z68.object({
   browserProvider: BrowserProviderTypeSchema.nullable(),
   dataResidency: DataResidencySchema.nullable(),
   dataHandling: DataHandlingSchema.nullable(),
-  enforced: z67.boolean()
+  enforced: z68.boolean(),
+  egressMode: browserEgressModeSchema.nullable().optional()
 });
-var organizationBrowserConfigSchema = z67.object({
-  version: z67.literal(ORG_BROWSER_CONFIG_VERSION),
+var organizationBrowserConfigSchema = z68.object({
+  version: z68.literal(ORG_BROWSER_CONFIG_VERSION),
   data: organizationBrowserConfigDataSchema
 });
-var organizationBrowserSettingsSchema = z67.object({
-  organizationId: z67.guid(),
+var organizationBrowserSettingsSchema = z68.object({
+  organizationId: z68.guid(),
   browserProvider: BrowserProviderTypeSchema.nullable(),
   dataResidency: DataResidencySchema.nullable(),
   dataHandling: DataHandlingSchema.nullable(),
-  enforced: z67.boolean(),
-  createdAt: z67.string(),
-  updatedAt: z67.string()
+  enforced: z68.boolean(),
+  egressMode: browserEgressModeSchema.nullable().optional(),
+  createdAt: z68.string(),
+  updatedAt: z68.string()
 });
-var getOrganizationBrowserSettingsResponseSchema = z67.object({
+var getOrganizationBrowserSettingsResponseSchema = z68.object({
   settings: organizationBrowserSettingsSchema.nullable()
 });
-var updateOrganizationBrowserSettingsRequestSchema = z67.object({
+var updateOrganizationBrowserSettingsRequestSchema = z68.object({
   browserProvider: BrowserProviderTypeSchema.nullable().optional(),
   dataResidency: DataResidencySchema.nullable().optional(),
   dataHandling: DataHandlingSchema.nullable().optional(),
-  enforced: z67.boolean().optional()
+  enforced: z68.boolean().optional(),
+  egressMode: browserEgressModeSchema.nullable().optional()
 });
-var updateOrganizationBrowserSettingsResponseSchema = z67.object({
+var updateOrganizationBrowserSettingsResponseSchema = z68.object({
   settings: organizationBrowserSettingsSchema
 });
-var catalogPluginSchema = z68.object({
-  name: z68.string().describe("Identifier to pass in the build's plugins array."),
+var catalogPluginSchema = z69.object({
+  name: z69.string().describe("Identifier to pass in the build's plugins array."),
   type: extensibleEnum(["duvo-platform", "knowledge-work", "github"], {
     description: "Plugin source. 'duvo-platform' plugins are pre-baked into the Duvo runtime; 'knowledge-work' plugins are role-oriented bundles (engineering, sales, legal, \u2026) also baked into the runtime; 'github' plugins are downloaded from a user-supplied repository URL at run time."
   }),
-  description: z68.string()
+  description: z69.string()
 });
-var pluginCatalogResponseSchema = z68.object({
-  plugins: z68.array(catalogPluginSchema)
+var pluginCatalogResponseSchema = z69.object({
+  plugins: z69.array(catalogPluginSchema)
 });
-var limitValueSchema = z69.union([
-  z69.number().int().nonnegative(),
-  z69.literal("unlimited")
+var limitValueSchema = z70.union([
+  z70.number().int().nonnegative(),
+  z70.literal("unlimited")
 ]);
-var runCountingModeSchema = z69.enum(["monthly", "lifetime"]);
+var runCountingModeSchema = z70.enum(["monthly", "lifetime"]);
 function addDuplicateKeyIssues({
   ctx,
   items,
@@ -10263,7 +10312,7 @@ function addDuplicateKeyIssues({
     const key = keyFor(item);
     if (seen.has(key)) {
       ctx.addIssue({
-        code: z69.ZodIssueCode.custom,
+        code: z70.ZodIssueCode.custom,
         message: `Duplicate Product Access grant key: ${key}`,
         path: [...path, index]
       });
@@ -10274,34 +10323,34 @@ function addDuplicateKeyIssues({
 }
 __name(addDuplicateKeyIssues, "addDuplicateKeyIssues");
 __name2(addDuplicateKeyIssues, "addDuplicateKeyIssues");
-var productAccessOwnerSchema = z69.discriminatedUnion("type", [
-  z69.object({
-    type: z69.literal("organization"),
-    organizationId: z69.guid()
+var productAccessOwnerSchema = z70.discriminatedUnion("type", [
+  z70.object({
+    type: z70.literal("organization"),
+    organizationId: z70.guid()
   }),
-  z69.object({
-    type: z69.literal("team"),
-    teamId: z69.guid(),
-    organizationId: z69.guid().nullable()
+  z70.object({
+    type: z70.literal("team"),
+    teamId: z70.guid(),
+    organizationId: z70.guid().nullable()
   })
 ]);
-var productAccessGrantSetSchema = z69.object({
-  products: z69.array(
-    z69.object({
-      productKey: z69.enum(PRODUCT_KEYS),
-      enabled: z69.boolean()
+var productAccessGrantSetSchema = z70.object({
+  products: z70.array(
+    z70.object({
+      productKey: z70.enum(PRODUCT_KEYS),
+      enabled: z70.boolean()
     })
   ),
-  capabilities: z69.array(
-    z69.object({
-      capabilityKey: z69.enum(PRODUCT_ACCESS_CAPABILITY_KEYS),
-      enabled: z69.boolean()
+  capabilities: z70.array(
+    z70.object({
+      capabilityKey: z70.enum(PRODUCT_ACCESS_CAPABILITY_KEYS),
+      enabled: z70.boolean()
     })
   ),
-  limits: z69.array(
-    z69.object({
-      productKey: z69.enum(PRODUCT_KEYS),
-      limitKey: z69.enum(ENTITLEMENT_LIMIT_KEYS),
+  limits: z70.array(
+    z70.object({
+      productKey: z70.enum(PRODUCT_KEYS),
+      limitKey: z70.enum(ENTITLEMENT_LIMIT_KEYS),
       limitValue: limitValueSchema,
       countingMode: runCountingModeSchema.nullable()
     })
@@ -10326,51 +10375,51 @@ var productAccessGrantSetSchema = z69.object({
     path: ["limits"]
   });
 });
-var productAccessSnapshotSchema = z69.object({
-  products: z69.array(
-    z69.object({
-      productKey: z69.enum(PRODUCT_KEYS),
-      enabled: z69.boolean()
+var productAccessSnapshotSchema = z70.object({
+  products: z70.array(
+    z70.object({
+      productKey: z70.enum(PRODUCT_KEYS),
+      enabled: z70.boolean()
     })
   ),
-  capabilities: z69.array(
-    z69.object({
+  capabilities: z70.array(
+    z70.object({
       capabilityKey: extensibleEnum(PRODUCT_ACCESS_CAPABILITY_KEYS),
-      productKey: z69.enum(PRODUCT_KEYS),
-      enabled: z69.boolean()
+      productKey: z70.enum(PRODUCT_KEYS),
+      enabled: z70.boolean()
     })
   ),
-  limits: z69.array(
-    z69.object({
-      limitKey: z69.enum(ENTITLEMENT_LIMIT_KEYS),
-      productKey: z69.enum(PRODUCT_KEYS),
+  limits: z70.array(
+    z70.object({
+      limitKey: z70.enum(ENTITLEMENT_LIMIT_KEYS),
+      productKey: z70.enum(PRODUCT_KEYS),
       limitValue: limitValueSchema,
       countingMode: runCountingModeSchema.nullable(),
-      label: z69.literal("per_team")
+      label: z70.literal("per_team")
     })
   )
 });
-var billingPlanSchema = z69.object({
-  planVersionId: z69.string(),
-  planName: z69.string(),
-  basePlan: z69.enum(["free", "pro", "enterprise"])
+var billingPlanSchema = z70.object({
+  planVersionId: z70.string(),
+  planName: z70.string(),
+  basePlan: z70.enum(["free", "pro", "enterprise"])
 });
-var inheritedFromSchema = z69.discriminatedUnion("type", [
-  z69.object({
-    type: z69.literal("organization"),
-    organizationId: z69.guid()
+var inheritedFromSchema = z70.discriminatedUnion("type", [
+  z70.object({
+    type: z70.literal("organization"),
+    organizationId: z70.guid()
   }),
-  z69.object({
-    type: z69.literal("team_subscription"),
-    planVersionId: z69.string()
+  z70.object({
+    type: z70.literal("team_subscription"),
+    planVersionId: z70.string()
   })
 ]);
-var productAccessReadResponseSchema = z69.object({
+var productAccessReadResponseSchema = z70.object({
   owner: productAccessOwnerSchema,
-  source: z69.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
-  accessRevision: z69.string().min(1),
+  source: z70.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
+  accessRevision: z70.string().min(1),
   displayPreset: displayPresetSchema,
-  hasExplicitTeamAccess: z69.boolean(),
+  hasExplicitTeamAccess: z70.boolean(),
   inheritedFrom: inheritedFromSchema.nullable(),
   billingPlan: billingPlanSchema.nullable(),
   grants: productAccessSnapshotSchema,
@@ -10378,67 +10427,67 @@ var productAccessReadResponseSchema = z69.object({
 }).superRefine((value, ctx) => {
   if (value.owner.type === "team" && value.source === "organization" && value.inheritedFrom?.type !== "organization") {
     ctx.addIssue({
-      code: z69.ZodIssueCode.custom,
+      code: z70.ZodIssueCode.custom,
       message: "inheritedFrom organization context is required when team source is organization",
       path: ["inheritedFrom"]
     });
   }
   if (value.owner.type === "team" && value.source === "team_subscription" && value.inheritedFrom?.type !== "team_subscription") {
     ctx.addIssue({
-      code: z69.ZodIssueCode.custom,
+      code: z70.ZodIssueCode.custom,
       message: "inheritedFrom subscription context is required when team source is team_subscription",
       path: ["inheritedFrom"]
     });
   }
   if (value.owner.type === "team" && value.source === "team" && value.inheritedFrom !== null) {
     ctx.addIssue({
-      code: z69.ZodIssueCode.custom,
+      code: z70.ZodIssueCode.custom,
       message: "inheritedFrom must be null for direct team Product Access",
       path: ["inheritedFrom"]
     });
   }
   if (value.owner.type === "organization" && value.billingPlan !== null) {
     ctx.addIssue({
-      code: z69.ZodIssueCode.custom,
+      code: z70.ZodIssueCode.custom,
       message: "billingPlan must be null for organization Product Access",
       path: ["billingPlan"]
     });
   }
   if (value.owner.type === "organization" && value.source !== "organization") {
     ctx.addIssue({
-      code: z69.ZodIssueCode.custom,
+      code: z70.ZodIssueCode.custom,
       message: "organization Product Access source must be organization",
       path: ["source"]
     });
   }
   if (value.owner.type === "organization" && value.inheritedFrom !== null) {
     ctx.addIssue({
-      code: z69.ZodIssueCode.custom,
+      code: z70.ZodIssueCode.custom,
       message: "inheritedFrom must be null for organization Product Access",
       path: ["inheritedFrom"]
     });
   }
 });
-var productAccessImpactRequestSchema = z69.object({
+var productAccessImpactRequestSchema = z70.object({
   proposedGrants: productAccessGrantSetSchema
 });
-var productAccessWriteRequestSchema = z69.object({
+var productAccessWriteRequestSchema = z70.object({
   proposedGrants: productAccessGrantSetSchema,
-  accessRevision: z69.string().min(1),
-  impactFingerprint: z69.string().min(1).optional()
-});
-var productAccessTeamResetRequestSchema = z69.object({
-  accessRevision: z69.string().min(1),
-  impactFingerprint: z69.string().min(1).optional()
-});
-var productAccessChangeSummarySchema = z69.object({
-  addedProducts: z69.array(z69.enum(PRODUCT_KEYS)),
-  removedProducts: z69.array(z69.enum(PRODUCT_KEYS)),
-  addedCapabilities: z69.array(extensibleEnum(PRODUCT_ACCESS_CAPABILITY_KEYS)),
-  removedCapabilities: z69.array(extensibleEnum(PRODUCT_ACCESS_CAPABILITY_KEYS)),
-  limitChanges: z69.array(
-    z69.object({
-      limitKey: z69.enum(ENTITLEMENT_LIMIT_KEYS),
+  accessRevision: z70.string().min(1),
+  impactFingerprint: z70.string().min(1).optional()
+});
+var productAccessTeamResetRequestSchema = z70.object({
+  accessRevision: z70.string().min(1),
+  impactFingerprint: z70.string().min(1).optional()
+});
+var productAccessChangeSummarySchema = z70.object({
+  addedProducts: z70.array(z70.enum(PRODUCT_KEYS)),
+  removedProducts: z70.array(z70.enum(PRODUCT_KEYS)),
+  addedCapabilities: z70.array(extensibleEnum(PRODUCT_ACCESS_CAPABILITY_KEYS)),
+  removedCapabilities: z70.array(extensibleEnum(PRODUCT_ACCESS_CAPABILITY_KEYS)),
+  limitChanges: z70.array(
+    z70.object({
+      limitKey: z70.enum(ENTITLEMENT_LIMIT_KEYS),
       currentValue: limitValueSchema,
       currentCountingMode: runCountingModeSchema.nullable(),
       proposedValue: limitValueSchema,
@@ -10446,61 +10495,61 @@ var productAccessChangeSummarySchema = z69.object({
     })
   )
 });
-var productAccessImpactResponseSchema = z69.object({
+var productAccessImpactResponseSchema = z70.object({
   owner: productAccessOwnerSchema,
-  impactFingerprint: z69.string().min(1),
-  affectedTeamCount: z69.number().int().nonnegative(),
-  affectedTeamsTruncated: z69.boolean(),
+  impactFingerprint: z70.string().min(1),
+  affectedTeamCount: z70.number().int().nonnegative(),
+  affectedTeamsTruncated: z70.boolean(),
   changes: productAccessChangeSummarySchema,
-  sideEffects: z69.object({
-    automationWillPause: z69.boolean(),
-    clarityWillHide: z69.boolean()
+  sideEffects: z70.object({
+    automationWillPause: z70.boolean(),
+    clarityWillHide: z70.boolean()
   }),
-  affectedTeamsPreview: z69.array(
-    z69.object({
-      teamId: z69.guid(),
-      teamName: z69.string(),
-      source: z69.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
+  affectedTeamsPreview: z70.array(
+    z70.object({
+      teamId: z70.guid(),
+      teamName: z70.string(),
+      source: z70.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
       changes: productAccessChangeSummarySchema
     })
   )
 });
-var publicProfileSchema = z70.object({
-  id: z70.guid(),
-  name: z70.string().nullable(),
-  email: z70.email(),
-  teamId: z70.guid().nullable()
+var publicProfileSchema = z71.object({
+  id: z71.guid(),
+  name: z71.string().nullable(),
+  email: z71.email(),
+  teamId: z71.guid().nullable()
 });
-var publicProfileResponseSchema = z70.object({
+var publicProfileResponseSchema = z71.object({
   profile: publicProfileSchema
 });
-var elementSelectorsSchema = z71.object({
-  css: z71.string().optional(),
-  cssPath: z71.string().optional(),
-  xpath: z71.string().optional(),
-  testId: z71.string().optional(),
-  ariaSelector: z71.string().optional(),
-  text: z71.string().optional()
+var elementSelectorsSchema = z72.object({
+  css: z72.string().optional(),
+  cssPath: z72.string().optional(),
+  xpath: z72.string().optional(),
+  testId: z72.string().optional(),
+  ariaSelector: z72.string().optional(),
+  text: z72.string().optional()
 });
-var elementInfoSchema = z71.object({
-  uid: z71.string().optional(),
+var elementInfoSchema = z72.object({
+  uid: z72.string().optional(),
   selectors: elementSelectorsSchema,
-  tagName: z71.string(),
-  textContent: z71.string().optional(),
-  ariaLabel: z71.string().optional(),
-  computedRole: z71.string().optional(),
-  attributes: z71.record(z71.string(), z71.string()).optional(),
-  framePath: z71.array(z71.number()).optional(),
-  frameUrl: z71.string().optional()
-});
-var recordedEventSchema = z71.looseObject({
-  id: z71.string(),
-  type: z71.string(),
-  timestamp: z71.number(),
-  url: z71.string(),
-  tabId: z71.number().optional(),
-  frameId: z71.number().optional(),
-  framePath: z71.array(z71.number()).optional(),
+  tagName: z72.string(),
+  textContent: z72.string().optional(),
+  ariaLabel: z72.string().optional(),
+  computedRole: z72.string().optional(),
+  attributes: z72.record(z72.string(), z72.string()).optional(),
+  framePath: z72.array(z72.number()).optional(),
+  frameUrl: z72.string().optional()
+});
+var recordedEventSchema = z72.looseObject({
+  id: z72.string(),
+  type: z72.string(),
+  timestamp: z72.number(),
+  url: z72.string(),
+  tabId: z72.number().optional(),
+  frameId: z72.number().optional(),
+  framePath: z72.array(z72.number()).optional(),
   element: elementInfoSchema.optional()
 });
 var COMPUTER_USE_TARGET_SOURCES = [
@@ -10513,72 +10562,72 @@ var COMPUTER_USE_TARGET_CONFIDENCES = [
   "medium",
   "low"
 ];
-var computerUseElementIdentitySchema = z71.object({
-  role: z71.string().optional(),
-  name: z71.string().optional(),
-  automationId: z71.string().optional(),
-  className: z71.string().optional(),
-  bounds: z71.object({
-    x: z71.number(),
-    y: z71.number(),
-    width: z71.number(),
-    height: z71.number()
+var computerUseElementIdentitySchema = z72.object({
+  role: z72.string().optional(),
+  name: z72.string().optional(),
+  automationId: z72.string().optional(),
+  className: z72.string().optional(),
+  bounds: z72.object({
+    x: z72.number(),
+    y: z72.number(),
+    width: z72.number(),
+    height: z72.number()
   }).optional()
 });
-var computerUseElementTargetSchema = z71.object({
-  selector: z71.string().optional(),
-  confidence: z71.enum(COMPUTER_USE_TARGET_CONFIDENCES),
-  source: z71.enum(COMPUTER_USE_TARGET_SOURCES),
+var computerUseElementTargetSchema = z72.object({
+  selector: z72.string().optional(),
+  confidence: z72.enum(COMPUTER_USE_TARGET_CONFIDENCES),
+  source: z72.enum(COMPUTER_USE_TARGET_SOURCES),
   element: computerUseElementIdentitySchema.optional()
 });
-var computerUseEventBaseSchema = z71.object({
+var computerUseEventBaseSchema = z72.object({
   /** Client-generated id; correlates an async element resolution back. */
-  id: z71.string().optional(),
-  timestamp: z71.number(),
+  id: z72.string().optional(),
+  timestamp: z72.number(),
   /** Links this event to a screenshot uploaded in the same/earlier batch. */
-  screenshotSeq: z71.number().int().nonnegative().optional(),
+  screenshotSeq: z72.number().int().nonnegative().optional(),
   /** Resolved UIA element target (primary replay anchor). */
   target: computerUseElementTargetSchema.optional()
 });
 var computerUseClickEventSchema = computerUseEventBaseSchema.extend({
-  type: z71.literal("click"),
+  type: z72.literal("click"),
   /** Cursor position in native desktop pixels. */
-  x: z71.number(),
-  y: z71.number(),
-  button: z71.enum(["left", "right", "middle"]).optional(),
-  double: z71.boolean().optional()
+  x: z72.number(),
+  y: z72.number(),
+  button: z72.enum(["left", "right", "middle"]).optional(),
+  double: z72.boolean().optional()
 });
 var computerUseScrollEventSchema = computerUseEventBaseSchema.extend({
-  type: z71.literal("scroll"),
-  x: z71.number(),
-  y: z71.number(),
-  deltaX: z71.number(),
-  deltaY: z71.number()
+  type: z72.literal("scroll"),
+  x: z72.number(),
+  y: z72.number(),
+  deltaX: z72.number(),
+  deltaY: z72.number()
 });
 var computerUseTypeEventSchema = computerUseEventBaseSchema.extend({
-  type: z71.literal("type"),
+  type: z72.literal("type"),
   /** Number of characters typed (redacted; no literal text). */
-  textLength: z71.number().int().nonnegative(),
+  textLength: z72.number().int().nonnegative(),
   /**
    * @deprecated Never persisted. Literal typed text can contain secrets; the
    * recorder sends `textLength` instead and the backend strips any `text`.
    */
-  text: z71.string().optional()
+  text: z72.string().optional()
 });
 var computerUseKeyEventSchema = computerUseEventBaseSchema.extend({
-  type: z71.literal("key"),
-  key: z71.string()
+  type: z72.literal("key"),
+  key: z72.string()
 });
-var computerUseRecordedEventSchema = z71.discriminatedUnion("type", [
+var computerUseRecordedEventSchema = z72.discriminatedUnion("type", [
   computerUseClickEventSchema,
   computerUseScrollEventSchema,
   computerUseTypeEventSchema,
   computerUseKeyEventSchema
 ]);
-var computerUseScreenshotSchema = z71.object({
-  seq: z71.number().int().nonnegative(),
+var computerUseScreenshotSchema = z72.object({
+  seq: z72.number().int().nonnegative(),
   /** Base64-encoded JPEG (no data: URL prefix). */
-  base64: z71.string()
+  base64: z72.string()
 });
 var DUVO_CLIENT_HEADER = "x-duvo-client";
 var DUVO_CLIENTS = {
@@ -10597,54 +10646,54 @@ function resolveRequestSourceFromClientHeader(header) {
 }
 __name(resolveRequestSourceFromClientHeader, "resolveRequestSourceFromClientHeader");
 __name2(resolveRequestSourceFromClientHeader, "resolveRequestSourceFromClientHeader");
-var RedactedMcpServerConfigSchema = z72.object({
+var RedactedMcpServerConfigSchema = z73.object({
   type: TransportTypeSchema,
   integrationSlug: IntegrationSlugSchema,
-  instanceId: z72.string().nullable()
+  instanceId: z73.string().nullable()
 });
-var ThreadContextMessageSchema = z72.object({
-  role: z72.enum(["user", "assistant"]),
-  content: z72.string()
+var ThreadContextMessageSchema = z73.object({
+  role: z73.enum(["user", "assistant"]),
+  content: z73.string()
 });
-var ChatFileReferenceSchema = z72.object({
-  id: z72.string(),
-  name: z72.string(),
-  mimetype: z72.string(),
-  size: z72.number(),
-  platform: z72.enum(["slack", "teams"]),
-  workspaceId: z72.string(),
-  channelId: z72.string()
-});
-var ResolvedSubAgentSchema = z72.object({
-  agentId: z72.string().uuid(),
-  buildId: z72.string().uuid(),
-  name: z72.string().min(1).max(64).regex(/^[a-z0-9-]+$/).describe(
+var ChatFileReferenceSchema = z73.object({
+  id: z73.string(),
+  name: z73.string(),
+  mimetype: z73.string(),
+  size: z73.number(),
+  platform: z73.enum(["slack", "teams"]),
+  workspaceId: z73.string(),
+  channelId: z73.string()
+});
+var ResolvedSubAgentSchema = z73.object({
+  agentId: z73.string().uuid(),
+  buildId: z73.string().uuid(),
+  name: z73.string().min(1).max(64).regex(/^[a-z0-9-]+$/).describe(
     "Stable slug used as the Claude Code subagent name (kebab-case, \u226464 chars)"
   ),
-  description: z72.string().describe(
+  description: z73.string().describe(
     "Routing description Claude uses to decide when to delegate to this subagent"
   ),
-  prompt: z72.string().describe("System prompt (AOP) for this subagent"),
-  model: z72.string().optional().describe("Optional Claude model identifier override for this subagent"),
-  mcpServers: z72.record(z72.string(), RedactedMcpServerConfigSchema).default({}).describe(
+  prompt: z73.string().describe("System prompt (AOP) for this subagent"),
+  model: z73.string().optional().describe("Optional Claude model identifier override for this subagent"),
+  mcpServers: z73.record(z73.string(), RedactedMcpServerConfigSchema).default({}).describe(
     "Redacted MCP server configs scoped to this subagent. Secrets resolved at execution time."
   )
 });
 var RunConfigSchema = AgentConfigSchema.extend({
-  task: z72.string(),
-  mcpServers: z72.record(z72.string(), RedactedMcpServerConfigSchema),
-  subAgents: z72.array(ResolvedSubAgentSchema).optional().default([]),
-  conversationHistory: z72.array(ThreadContextMessageSchema).optional(),
-  chatFiles: z72.array(ChatFileReferenceSchema).optional(),
+  task: z73.string(),
+  mcpServers: z73.record(z73.string(), RedactedMcpServerConfigSchema),
+  subAgents: z73.array(ResolvedSubAgentSchema).optional().default([]),
+  conversationHistory: z73.array(ThreadContextMessageSchema).optional(),
+  chatFiles: z73.array(ChatFileReferenceSchema).optional(),
   /** IANA timezone (e.g. `"Europe/Prague"`). Consumers should fall back to UTC when absent. */
-  timezone: z72.string().optional(),
+  timezone: z73.string().optional(),
   /**
    * ISO 8601 timestamp captured when the run was created. Frozen at
    * run-creation time and never recomputed, so resumes reuse the same value —
    * the runtime injects it into the cached system prompt and a changing value
    * would bust the prompt cache.
    */
-  sessionStartedAt: z72.string().optional(),
+  sessionStartedAt: z73.string().optional(),
   /**
    * True when this dispatch resumes a run the user stopped. Derived on each
    * continue from the durable `agent_run.stopped_by_user` column (set only by a
@@ -10653,16 +10702,16 @@ var RunConfigSchema = AgentConfigSchema.extend({
    * first resumed turn. Lives here — not in cc-server memory — so it survives a
    * sandbox suspend/resume.
    */
-  resumedAfterStop: z72.boolean().optional()
+  resumedAfterStop: z73.boolean().optional()
 });
-var StoredRunConfigV0Schema = z72.object({
-  version: z72.literal("v0")
+var StoredRunConfigV0Schema = z73.object({
+  version: z73.literal("v0")
 });
-var StoredRunConfigV1Schema = z72.object({
-  version: z72.literal("v1"),
+var StoredRunConfigV1Schema = z73.object({
+  version: z73.literal("v1"),
   data: RunConfigSchema
 });
-var StoredRunConfigSchema = z72.union([
+var StoredRunConfigSchema = z73.union([
   StoredRunConfigV0Schema,
   StoredRunConfigV1Schema
 ]);
@@ -10681,178 +10730,178 @@ function isRunConfig(config) {
 }
 __name(isRunConfig, "isRunConfig");
 __name2(isRunConfig, "isRunConfig");
-var skillApiSchema = z73.object({
-  id: z73.string(),
-  name: z73.string(),
-  description: z73.string(),
+var skillApiSchema = z74.object({
+  id: z74.string(),
+  name: z74.string(),
+  description: z74.string(),
   // System skills have null team_id.
-  team_id: z73.string().nullable()
+  team_id: z74.string().nullable()
 });
-var listSkillsResponseSchema = z73.object({
-  skills: z73.array(skillApiSchema)
-});
-var systemSkillSchema = z73.object({
-  id: z73.string(),
-  name: z73.string(),
-  description: z73.string()
+var listSkillsResponseSchema = z74.object({
+  skills: z74.array(skillApiSchema)
 });
-var listSystemSkillsResponseSchema = z73.object({
-  skills: z73.array(systemSkillSchema)
-});
-var skillFileItemSchema = z73.object({
-  name: z73.string(),
-  path: z73.string(),
-  size: z73.number().optional(),
-  contentType: z73.string().optional(),
-  updatedAt: z73.string().optional()
-});
-var listSkillFilesResponseSchema = z73.object({
-  files: z73.array(skillFileItemSchema)
-});
-var getSkillFileContentResponseSchema = z73.object({
-  content: z73.string(),
-  path: z73.string(),
-  contentType: z73.string().optional()
-});
-var updateSkillFileBodySchema = z73.object({
-  content: z73.string()
-});
-var updateSkillFileResponseSchema = z73.object({
-  success: z73.boolean(),
-  message: z73.string(),
-  skill: z73.object({
-    id: z73.string(),
-    name: z73.string(),
-    description: z73.string()
+var systemSkillSchema = z74.object({
+  id: z74.string(),
+  name: z74.string(),
+  description: z74.string()
+});
+var listSystemSkillsResponseSchema = z74.object({
+  skills: z74.array(systemSkillSchema)
+});
+var skillFileItemSchema = z74.object({
+  name: z74.string(),
+  path: z74.string(),
+  size: z74.number().optional(),
+  contentType: z74.string().optional(),
+  updatedAt: z74.string().optional()
+});
+var listSkillFilesResponseSchema = z74.object({
+  files: z74.array(skillFileItemSchema)
+});
+var getSkillFileContentResponseSchema = z74.object({
+  content: z74.string(),
+  path: z74.string(),
+  contentType: z74.string().optional()
+});
+var updateSkillFileBodySchema = z74.object({
+  content: z74.string()
+});
+var updateSkillFileResponseSchema = z74.object({
+  success: z74.boolean(),
+  message: z74.string(),
+  skill: z74.object({
+    id: z74.string(),
+    name: z74.string(),
+    description: z74.string()
   }).optional()
 });
-var deleteSkillResponseSchema = z73.object({
-  success: z73.boolean(),
-  message: z73.string()
+var deleteSkillResponseSchema = z74.object({
+  success: z74.boolean(),
+  message: z74.string()
 });
-var generateSkillBodySchema = z73.object({
-  prompt: z73.string().min(1).max(2e3),
-  existingContent: z73.string().max(2e4).optional()
+var generateSkillBodySchema = z74.object({
+  prompt: z74.string().min(1).max(2e3),
+  existingContent: z74.string().max(2e4).optional()
 });
-var generateSkillResponseSchema = z73.object({
-  content: z73.string()
+var generateSkillResponseSchema = z74.object({
+  content: z74.string()
 });
-var skillAssignmentSchema = z73.object({
-  id: z73.string(),
-  name: z73.string()
+var skillAssignmentSchema = z74.object({
+  id: z74.string(),
+  name: z74.string()
 });
-var listSkillAssignmentsResponseSchema = z73.object({
-  assignments: z73.array(skillAssignmentSchema),
-  total: z73.number()
+var listSkillAssignmentsResponseSchema = z74.object({
+  assignments: z74.array(skillAssignmentSchema),
+  total: z74.number()
 });
-var teamInvitationApiSchema = z74.object({
-  id: z74.string(),
-  team_id: z74.string(),
-  email: z74.email(),
-  invited_by: z74.string(),
-  role: z74.string(),
-  status: z74.string(),
-  name: z74.string().nullable(),
-  created_at: z74.string(),
-  process_id: z74.guid().nullable().optional()
-});
-var teamInvitationDetailApiSchema = z74.object({
-  id: z74.string(),
-  team_id: z74.string(),
-  email: z74.email(),
-  invited_by: z74.string(),
-  role: z74.string(),
-  status: z74.string(),
-  name: z74.string().nullable(),
-  created_at: z74.string(),
-  process_id: z74.guid().nullable().optional(),
-  team: z74.object({
-    id: z74.string(),
-    name: z74.string()
+var teamInvitationApiSchema = z75.object({
+  id: z75.string(),
+  team_id: z75.string(),
+  email: z75.email(),
+  invited_by: z75.string(),
+  role: z75.string(),
+  status: z75.string(),
+  name: z75.string().nullable(),
+  created_at: z75.string(),
+  process_id: z75.guid().nullable().optional()
+});
+var teamInvitationDetailApiSchema = z75.object({
+  id: z75.string(),
+  team_id: z75.string(),
+  email: z75.email(),
+  invited_by: z75.string(),
+  role: z75.string(),
+  status: z75.string(),
+  name: z75.string().nullable(),
+  created_at: z75.string(),
+  process_id: z75.guid().nullable().optional(),
+  team: z75.object({
+    id: z75.string(),
+    name: z75.string()
   }),
-  invitedBy: z74.object({
-    id: z74.string(),
-    name: z74.string().nullable(),
-    email: z74.email()
+  invitedBy: z75.object({
+    id: z75.string(),
+    name: z75.string().nullable(),
+    email: z75.email()
   }),
-  process: z74.object({
-    id: z74.string(),
-    name: z74.string()
+  process: z75.object({
+    id: z75.string(),
+    name: z75.string()
   }).optional()
 });
-var createTeamInvitationRequestSchema = z74.object({
-  email: z74.email(),
-  role: z74.string(),
-  processId: z74.guid().optional()
+var createTeamInvitationRequestSchema = z75.object({
+  email: z75.email(),
+  role: z75.string(),
+  processId: z75.guid().optional()
 });
-var acceptTeamInvitationRequestSchema = z74.object({
-  name: z74.string().optional()
+var acceptTeamInvitationRequestSchema = z75.object({
+  name: z75.string().optional()
 });
-var bulkInviteResponseSchema = z74.object({
-  succeeded: z74.number(),
-  skipped: z74.number(),
-  failed: z74.number()
+var bulkInviteResponseSchema = z75.object({
+  succeeded: z75.number(),
+  skipped: z75.number(),
+  failed: z75.number()
 });
 var TEAM_DISCOVERY_MODES = ["request", "auto"];
-var teamDiscoveryModeSchema = z75.enum(TEAM_DISCOVERY_MODES);
-var BrowserRegionSchema = z75.enum([
+var teamDiscoveryModeSchema = z76.enum(TEAM_DISCOVERY_MODES);
+var BrowserRegionSchema = z76.enum([
   "us-west-2",
   "us-east-1",
   "eu-central-1",
   "ap-southeast-1"
 ]);
-var BrowserLocationSchema = z75.union([
-  z75.literal("cz"),
-  z75.literal("de"),
-  z75.literal("fr"),
-  z75.literal("gb"),
-  z75.literal("it"),
-  z75.literal("pl"),
-  z75.literal("sk")
+var BrowserLocationSchema = z76.union([
+  z76.literal("cz"),
+  z76.literal("de"),
+  z76.literal("fr"),
+  z76.literal("gb"),
+  z76.literal("it"),
+  z76.literal("pl"),
+  z76.literal("sk")
 ]);
-var teamMemberApiSchema = z75.object({
-  id: z75.guid(),
-  name: z75.string().nullable(),
-  email: z75.email(),
-  role: z75.string(),
-  inheritedFromOrg: z75.boolean().default(false)
-});
-var listTeamMembersResponseSchema = z75.object({
-  members: z75.array(teamMemberApiSchema),
-  total: z75.number().int().nonnegative(),
-  limit: z75.number().int().positive(),
-  offset: z75.number().int().nonnegative()
-});
-var updateMemberRoleRequestSchema = z75.object({
-  role: z75.string()
-});
-var removeMemberResponseSchema = z75.object({
-  success: z75.literal(true),
-  nextTeamId: z75.guid().nullable(),
-  planType: z75.enum(["pro", "enterprise"]).nullable()
-});
-var getMemberMeResponseSchema = z75.object({
-  role: z75.string().nullable(),
+var teamMemberApiSchema = z76.object({
+  id: z76.guid(),
+  name: z76.string().nullable(),
+  email: z76.email(),
+  role: z76.string(),
+  inheritedFromOrg: z76.boolean().default(false)
+});
+var listTeamMembersResponseSchema = z76.object({
+  members: z76.array(teamMemberApiSchema),
+  total: z76.number().int().nonnegative(),
+  limit: z76.number().int().positive(),
+  offset: z76.number().int().nonnegative()
+});
+var updateMemberRoleRequestSchema = z76.object({
+  role: z76.string()
+});
+var removeMemberResponseSchema = z76.object({
+  success: z76.literal(true),
+  nextTeamId: z76.guid().nullable(),
+  planType: z76.enum(["pro", "enterprise"]).nullable()
+});
+var getMemberMeResponseSchema = z76.object({
+  role: z76.string().nullable(),
   // True only when a real `user_team_memberships` row exists. `role` can be a
   // read-only *virtual* role for org leaders who haven't joined, so it is not a
   // membership signal on its own — use this flag to tell a real member apart.
-  isMember: z75.boolean()
+  isMember: z76.boolean()
 });
-var addTeamMemberRequestSchema = z75.object({
-  userId: z75.guid(),
-  role: z75.string()
+var addTeamMemberRequestSchema = z76.object({
+  userId: z76.guid(),
+  role: z76.string()
 });
-var updateTeamRequestSchema = z75.object({
-  name: z75.string().min(1).optional(),
-  slack_team_id: z75.string().optional(),
+var updateTeamRequestSchema = z76.object({
+  name: z76.string().min(1).optional(),
+  slack_team_id: z76.string().optional(),
   discovery_mode: teamDiscoveryModeSchema.optional()
 });
-var teamApiSchema = z75.object({
-  id: z75.guid().describe("Unique team identifier"),
-  name: z75.string().describe("Human-readable team name"),
-  created_at: z75.string().describe("ISO 8601 creation timestamp"),
-  organization_id: z75.guid().nullable().describe("Parent organization ID, or null if the team is standalone"),
-  slack_team_id: z75.string().nullable().describe("Linked Slack workspace ID, or null if Slack is not connected"),
+var teamApiSchema = z76.object({
+  id: z76.guid().describe("Unique team identifier"),
+  name: z76.string().describe("Human-readable team name"),
+  created_at: z76.string().describe("ISO 8601 creation timestamp"),
+  organization_id: z76.guid().nullable().describe("Parent organization ID, or null if the team is standalone"),
+  slack_team_id: z76.string().nullable().describe("Linked Slack workspace ID, or null if Slack is not connected"),
   // Responses use x-extensible-enum: adding a discovery mode to a strict
   // response enum is breaking in oasdiff, while an added x-extensible-enum
   // value is not. The strict request enum (updateTeamRequestSchema) still
@@ -10861,198 +10910,220 @@ var teamApiSchema = z75.object({
     description: "How the team handles agent discovery"
   })
 });
-var teamResponseApiSchema = z75.object({
+var teamResponseApiSchema = z76.object({
   team: teamApiSchema
 });
 var TEAM_CONFIG_VERSION = 1;
-var teamConfigDataSchema = z75.object({
+var teamConfigDataSchema = z76.object({
   browserProviderOverride: BrowserProviderTypeSchema.nullable().optional(),
   // Egress identity (proxy country) — what the target site sees.
   browserLocationOverride: BrowserLocationSchema.nullable().optional(),
+  // Egress mode override (provider / direct / organization-vpn). Location stays
+  // on browserLocationOverride; this is the orthogonal mode axis.
+  browserEgressModeOverride: browserEgressModeSchema.nullable().optional(),
   // Coarse residency + data-handling overrides (the current model).
   dataResidencyOverride: DataResidencySchema.nullable().optional(),
   dataHandlingOverride: DataHandlingSchema.nullable().optional(),
+  // Domains that bypass the org VPN and connect directly (split tunnel).
+  // Union'd at runtime with the org-default list on vpn_proxy_config.
+  vpnBypassDomains: z76.array(z76.string()).max(MAX_VPN_BYPASS_DOMAINS).nullable().optional(),
   // Deprecated: superseded by dataResidencyOverride / dataHandlingOverride.
   // Kept optional so existing v1 rows still parse; the resolver reads the new
   // fields first and falls back to these. Do not surface in the UI.
   browserRegionOverride: BrowserRegionSchema.nullable().optional(),
-  sessionRecordingOverride: z75.boolean().nullable().optional()
+  sessionRecordingOverride: z76.boolean().nullable().optional()
 });
-var teamConfigSchema = z75.object({
-  version: z75.literal(TEAM_CONFIG_VERSION),
+var teamConfigSchema = z76.object({
+  version: z76.literal(TEAM_CONFIG_VERSION),
   data: teamConfigDataSchema
 });
-var listTeamInvitesResponseSchema = z75.object({
-  invitations: z75.array(teamInvitationApiSchema)
+var listTeamInvitesResponseSchema = z76.object({
+  invitations: z76.array(teamInvitationApiSchema)
 });
-var teamInsightsCopilotSchema = z76.object({
-  id: z76.guid(),
-  name: z76.string(),
-  teamName: z76.string().nullable().optional(),
-  created_at: z76.string().nullable(),
-  updated_at: z76.string().nullable(),
-  team_id: z76.string().nullable(),
-  thread_id: z76.string().nullable(),
-  slack_enabled: z76.boolean().nullable()
-});
-var teamInsightsUserProfileSchema = z76.object({
-  id: z76.guid(),
-  name: z76.string().nullable(),
-  email: z76.string()
+var teamInsightsCopilotSchema = z77.object({
+  id: z77.guid(),
+  name: z77.string(),
+  teamName: z77.string().nullable().optional(),
+  created_at: z77.string().nullable(),
+  updated_at: z77.string().nullable(),
+  team_id: z77.string().nullable(),
+  thread_id: z77.string().nullable(),
+  slack_enabled: z77.boolean().nullable()
+});
+var teamInsightsUserProfileSchema = z77.object({
+  id: z77.guid(),
+  name: z77.string().nullable(),
+  email: z77.string()
 });
 var teamInsightsUserUsageSchema = teamInsightsUserProfileSchema.extend(
   {
-    runCount: z76.number(),
-    lastRun: z76.string().nullable()
+    runCount: z77.number(),
+    lastRun: z77.string().nullable()
   }
 );
-var teamInsightsMetricSourceSchema = z76.object({
+var teamInsightsMetricSourceSchema = z77.object({
   source: agentRunSourceSchema,
-  runsTotal: z76.number(),
-  completedRuns: z76.number()
+  runsTotal: z77.number(),
+  completedRuns: z77.number()
 });
 var teamInsightsCopilotWithRunsSchema = teamInsightsCopilotSchema.extend({
-  integrations: z76.array(z76.string()),
-  uniqueUsersCount: z76.number(),
-  users: z76.array(teamInsightsUserUsageSchema),
-  totalRuns: z76.number(),
-  completedRuns: z76.number(),
-  totalTimeSpentMs: z76.number(),
-  averageTimeSpentMs: z76.number(),
-  completedRunsWithTiming: z76.number(),
-  sources: z76.array(teamInsightsMetricSourceSchema)
-});
-var teamInsightsAgentsRunResponseSchema = z76.object({
-  data: z76.array(teamInsightsCopilotWithRunsSchema),
-  total: z76.number()
-});
-var teamInsightsMetricsResponseSchema = z76.object({
-  runsTotal: z76.number(),
-  completedRuns: z76.number(),
-  sources: z76.array(teamInsightsMetricSourceSchema)
-});
-var teamInsightsUserAgentRunSchema = z76.object({
-  id: z76.guid(),
-  created_at: z76.string(),
-  updated_at: z76.string(),
-  agent_id: z76.guid(),
-  agent_name: z76.string(),
-  build_id: z76.guid(),
-  source: z76.string().nullable(),
-  started_at: z76.string().nullable(),
-  completed_at: z76.string().nullable()
-});
-var teamInsightsAgentSchema = z76.object({
-  id: z76.guid(),
-  name: z76.string(),
-  teamName: z76.string().nullable().optional(),
-  runs: z76.array(teamInsightsUserAgentRunSchema)
-});
-var teamInsightsUserWithAgentsAndRunsSchema = teamInsightsUserProfileSchema.extend({
-  agents: z76.array(teamInsightsAgentSchema),
-  runs: z76.array(teamInsightsUserAgentRunSchema),
-  totalRuns: z76.number()
-});
-var teamInsightsUsersResponseSchema = z76.object({
-  data: z76.array(teamInsightsUserWithAgentsAndRunsSchema),
-  total: z76.number()
-});
-var guardrailsAuthorSchema = z77.object({
+  integrations: z77.array(z77.string()),
+  uniqueUsersCount: z77.number(),
+  users: z77.array(teamInsightsUserUsageSchema),
+  totalRuns: z77.number(),
+  completedRuns: z77.number(),
+  totalTimeSpentMs: z77.number(),
+  averageTimeSpentMs: z77.number(),
+  completedRunsWithTiming: z77.number(),
+  sources: z77.array(teamInsightsMetricSourceSchema)
+});
+var teamInsightsAgentsRunResponseSchema = z77.object({
+  data: z77.array(teamInsightsCopilotWithRunsSchema),
+  total: z77.number()
+});
+var teamInsightsMetricsResponseSchema = z77.object({
+  runsTotal: z77.number(),
+  completedRuns: z77.number(),
+  sources: z77.array(teamInsightsMetricSourceSchema)
+});
+var teamInsightsUserAgentRunSchema = z77.object({
   id: z77.guid(),
-  name: z77.string().nullable(),
-  email: z77.email()
-});
-var guardrailsRevisionSchema = z77.object({
+  created_at: z77.string(),
+  updated_at: z77.string(),
+  agent_id: z77.guid(),
+  agent_name: z77.string(),
+  build_id: z77.guid(),
+  source: z77.string().nullable(),
+  started_at: z77.string().nullable(),
+  completed_at: z77.string().nullable()
+});
+var teamInsightsAgentSchema = z77.object({
   id: z77.guid(),
-  teamId: z77.guid(),
-  guardrailsText: z77.string().nullable(),
-  blockedDomains: z77.array(z77.string()),
-  createdAt: z77.string(),
+  name: z77.string(),
+  teamName: z77.string().nullable().optional(),
+  runs: z77.array(teamInsightsUserAgentRunSchema)
+});
+var teamInsightsUserWithAgentsAndRunsSchema = teamInsightsUserProfileSchema.extend({
+  agents: z77.array(teamInsightsAgentSchema),
+  runs: z77.array(teamInsightsUserAgentRunSchema),
+  totalRuns: z77.number()
+});
+var teamInsightsUsersResponseSchema = z77.object({
+  data: z77.array(teamInsightsUserWithAgentsAndRunsSchema),
+  total: z77.number()
+});
+var guardrailsAuthorSchema = z78.object({
+  id: z78.guid(),
+  name: z78.string().nullable(),
+  email: z78.email()
+});
+var guardrailsRevisionSchema = z78.object({
+  id: z78.guid(),
+  teamId: z78.guid(),
+  guardrailsText: z78.string().nullable(),
+  blockedDomains: z78.array(z78.string()),
+  createdAt: z78.string(),
   createdBy: guardrailsAuthorSchema
 });
-var getTeamGuardrailsResponseSchema = z77.object({
+var getTeamGuardrailsResponseSchema = z78.object({
   current: guardrailsRevisionSchema.nullable()
 });
-var listTeamGuardrailsRevisionsQuerySchema = z77.object({
-  limit: z77.coerce.number().int().min(1).max(100).default(20),
-  offset: z77.coerce.number().int().min(0).default(0)
+var listTeamGuardrailsRevisionsQuerySchema = z78.object({
+  limit: z78.coerce.number().int().min(1).max(100).default(20),
+  offset: z78.coerce.number().int().min(0).default(0)
 });
-var listTeamGuardrailsRevisionsResponseSchema = z77.object({
-  revisions: z77.array(guardrailsRevisionSchema),
-  total: z77.number().int().nonnegative()
+var listTeamGuardrailsRevisionsResponseSchema = z78.object({
+  revisions: z78.array(guardrailsRevisionSchema),
+  total: z78.number().int().nonnegative()
 });
-var createTeamGuardrailsRevisionRequestSchema = z77.object({
-  guardrailsText: z77.string().max(MAX_GUARDRAILS_TEXT_LENGTH).nullable().transform((value) => value && value.trim().length > 0 ? value : null),
-  blockedDomains: z77.array(z77.string()).max(MAX_BLOCKED_DOMAINS)
+var createTeamGuardrailsRevisionRequestSchema = z78.object({
+  guardrailsText: z78.string().max(MAX_GUARDRAILS_TEXT_LENGTH).nullable().transform((value) => value && value.trim().length > 0 ? value : null),
+  blockedDomains: z78.array(z78.string()).max(MAX_BLOCKED_DOMAINS)
 });
-var userDismissalListResponseSchema = z78.object({
-  data: z78.array(z78.string())
+var userDismissalListResponseSchema = z79.object({
+  data: z79.array(z79.string())
 });
-var userDismissalMutationSchema = z78.object({
-  elementKey: z78.string()
+var userDismissalMutationSchema = z79.object({
+  elementKey: z79.string()
 });
 var PASSWORD_MIN = 1;
 var PASSWORD_MAX = 1024;
 var NAME_MAX = 200;
 var URL_MAX = 500;
 var USERNAME_MAX = 200;
-var vpnProxyConfigSummarySchema = z79.object({
-  id: z79.guid(),
-  name: z79.string(),
-  server: z79.string(),
-  username: z79.string(),
-  enabled: z79.boolean(),
-  passwordSet: z79.boolean(),
-  organizationCount: z79.number().int().nonnegative(),
-  createdAt: z79.string(),
-  updatedAt: z79.string()
-});
-var vpnProxyConfigListResponseSchema = z79.object({
-  configs: z79.array(vpnProxyConfigSummarySchema)
-});
-var vpnProxyConfigCreateRequestSchema = z79.object({
-  name: z79.string().trim().min(1).max(NAME_MAX),
-  server: z79.string().trim().min(1).max(URL_MAX).url(),
-  username: z79.string().trim().min(1).max(USERNAME_MAX),
-  password: z79.string().min(PASSWORD_MIN).max(PASSWORD_MAX),
-  enabled: z79.boolean().prefault(true)
-});
-var vpnProxyConfigCreateResponseSchema = z79.object({
+var vpnProxyConfigSummarySchema = z80.object({
+  id: z80.guid(),
+  name: z80.string(),
+  server: z80.string(),
+  username: z80.string(),
+  enabled: z80.boolean(),
+  passwordSet: z80.boolean(),
+  organizationCount: z80.number().int().nonnegative(),
+  createdAt: z80.string(),
+  updatedAt: z80.string()
+});
+var vpnProxyConfigListResponseSchema = z80.object({
+  configs: z80.array(vpnProxyConfigSummarySchema)
+});
+var vpnProxyConfigCreateRequestSchema = z80.object({
+  name: z80.string().trim().min(1).max(NAME_MAX),
+  server: z80.string().trim().min(1).max(URL_MAX).url(),
+  username: z80.string().trim().min(1).max(USERNAME_MAX),
+  password: z80.string().min(PASSWORD_MIN).max(PASSWORD_MAX),
+  enabled: z80.boolean().prefault(true)
+});
+var vpnProxyConfigCreateResponseSchema = z80.object({
   config: vpnProxyConfigSummarySchema
 });
-var vpnProxyConfigUpdateRequestSchema = z79.object({
-  name: z79.string().trim().min(1).max(NAME_MAX).optional(),
-  server: z79.string().trim().min(1).max(URL_MAX).url().optional(),
-  username: z79.string().trim().min(1).max(USERNAME_MAX).optional(),
-  password: z79.string().min(PASSWORD_MIN).max(PASSWORD_MAX).optional(),
-  enabled: z79.boolean().optional()
+var vpnProxyConfigUpdateRequestSchema = z80.object({
+  name: z80.string().trim().min(1).max(NAME_MAX).optional(),
+  server: z80.string().trim().min(1).max(URL_MAX).url().optional(),
+  username: z80.string().trim().min(1).max(USERNAME_MAX).optional(),
+  password: z80.string().min(PASSWORD_MIN).max(PASSWORD_MAX).optional(),
+  enabled: z80.boolean().optional()
 });
-var vpnProxyConfigUpdateResponseSchema = z79.object({
+var vpnProxyConfigUpdateResponseSchema = z80.object({
   config: vpnProxyConfigSummarySchema
 });
-var vpnProxyConfigDeleteResponseSchema = z79.object({
-  success: z79.literal(true)
+var vpnProxyConfigDeleteResponseSchema = z80.object({
+  success: z80.literal(true)
 });
-var vpnProxyConfigOrganizationSchema = z79.object({
-  id: z79.guid(),
-  organizationId: z79.guid(),
-  organizationName: z79.string(),
-  attachedAt: z79.string()
+var vpnProxyConfigOrganizationSchema = z80.object({
+  id: z80.guid(),
+  organizationId: z80.guid(),
+  organizationName: z80.string(),
+  bypassDomains: z80.array(z80.string()),
+  vpnEnforced: z80.boolean(),
+  attachedAt: z80.string()
 });
-var vpnProxyConfigOrganizationListResponseSchema = z79.object({
-  organizations: z79.array(vpnProxyConfigOrganizationSchema)
+var vpnProxyConfigOrganizationListResponseSchema = z80.object({
+  organizations: z80.array(vpnProxyConfigOrganizationSchema)
 });
-var vpnProxyConfigAttachOrganizationRequestSchema = z79.object({
-  organizationId: z79.guid()
+var vpnProxyConfigAttachOrganizationRequestSchema = z80.object({
+  organizationId: z80.guid(),
+  bypassDomains: z80.array(z80.string()).max(MAX_VPN_BYPASS_DOMAINS).prefault([]),
+  vpnEnforced: z80.boolean().prefault(false)
 });
-var vpnProxyConfigAttachOrganizationResponseSchema = z79.object({
+var vpnProxyConfigAttachOrganizationResponseSchema = z80.object({
   attachment: vpnProxyConfigOrganizationSchema
 });
-var vpnProxyConfigDetachOrganizationResponseSchema = z79.object({
-  success: z79.literal(true)
+var vpnProxyConfigDetachOrganizationResponseSchema = z80.object({
+  success: z80.literal(true)
+});
+var vpnProxyConfigForOrganizationAttachmentSchema = z80.object({
+  bypassDomains: z80.array(z80.string()),
+  vpnEnforced: z80.boolean()
 });
-var vpnProxyConfigForOrganizationResponseSchema = z79.object({
-  config: vpnProxyConfigSummarySchema.nullable()
+var vpnProxyConfigForOrganizationResponseSchema = z80.object({
+  config: vpnProxyConfigSummarySchema.nullable(),
+  attachment: vpnProxyConfigForOrganizationAttachmentSchema.nullable()
+});
+var vpnProxyConfigUpdateOrganizationPolicyRequestSchema = z80.object({
+  bypassDomains: z80.array(z80.string()).max(MAX_VPN_BYPASS_DOMAINS).optional(),
+  vpnEnforced: z80.boolean().optional()
+});
+var vpnProxyConfigUpdateOrganizationPolicyResponseSchema = z80.object({
+  attachment: vpnProxyConfigOrganizationSchema
 });
 function canonicalizeSopInput(config) {
   const { input } = config.data;
@@ -11072,7 +11143,7 @@ function canonicalizeSopInput(config) {
 }
 __name(canonicalizeSopInput, "canonicalizeSopInput");
 __name2(canonicalizeSopInput, "canonicalizeSopInput");
-var caseFilterStatusSchema = z80.enum([
+var caseFilterStatusSchema = z81.enum([
   "pending",
   "claimed",
   "completed",
@@ -11080,19 +11151,19 @@ var caseFilterStatusSchema = z80.enum([
   "needs_input",
   "postponed"
 ]);
-var casesFiltersSchema = z80.object({
-  status: z80.array(caseFilterStatusSchema).optional(),
-  created_at_from: z80.string().optional(),
-  updated_at_from: z80.string().optional(),
-  labels: z80.record(z80.string(), z80.array(z80.string())).optional()
+var casesFiltersSchema = z81.object({
+  status: z81.array(caseFilterStatusSchema).optional(),
+  created_at_from: z81.string().optional(),
+  updated_at_from: z81.string().optional(),
+  labels: z81.record(z81.string(), z81.array(z81.string())).optional()
 });
-var casesListRequestBodySchema = z80.object({
+var casesListRequestBodySchema = z81.object({
   filters: casesFiltersSchema.default({}),
-  limit: z80.int().min(1).max(100).default(25),
-  offset: z80.int().min(0).default(0),
-  sort_by: z80.enum(["created_at", "updated_at", "postponed_to"]).default("created_at"),
-  sort_order: z80.enum(["asc", "desc"]).default("desc"),
-  search: z80.string().optional()
+  limit: z81.int().min(1).max(100).default(25),
+  offset: z81.int().min(0).default(0),
+  sort_by: z81.enum(["created_at", "updated_at", "postponed_to"]).default("created_at"),
+  sort_order: z81.enum(["asc", "desc"]).default("desc"),
+  search: z81.string().optional()
 });
 function toBase64(input) {
   if (typeof btoa === "function") {
@@ -11187,7 +11258,7 @@ function setFilterValuesByCategoryKey(filters, categoryKey, values) {
       const { status: _, ...rest } = filters;
       return rest;
     }
-    const parsed = z80.array(caseFilterStatusSchema).safeParse(values);
+    const parsed = z81.array(caseFilterStatusSchema).safeParse(values);
     if (!parsed.success) {
       return filters;
     }
@@ -12450,11 +12521,11 @@ function emptyConfig() {
 __name(emptyConfig, "emptyConfig");
 
 // src/config/env.ts
-import { z as z81 } from "zod";
-var optionalEnvString = z81.string().optional().transform(
+import { z as z82 } from "zod";
+var optionalEnvString = z82.string().optional().transform(
   (value) => value === void 0 || value === "" ? void 0 : value
 );
-var CliEnvSchema = z81.object({
+var CliEnvSchema = z82.object({
   DUVO_PROFILE: optionalEnvString,
   DUVO_API_KEY: optionalEnvString,
   DUVO_API_BASE_URL: optionalEnvString,
@@ -12956,9 +13027,9 @@ async function requireAuthenticatedConfig(command) {
 __name(requireAuthenticatedConfig, "requireAuthenticatedConfig");
 
 // src/commands/shared/team-context.ts
-import { z as z82 } from "zod";
-var teamSchema = z82.object({ id: z82.string() });
-var listMyTeamsResponseSchema = z82.object({ teams: z82.array(teamSchema) });
+import { z as z83 } from "zod";
+var teamSchema = z83.object({ id: z83.string() });
+var listMyTeamsResponseSchema = z83.object({ teams: z83.array(teamSchema) });
 async function resolveRequiredTeamId(config, options = {}) {
   if (options.override) {
     return options.override;
@@ -13741,109 +13812,109 @@ 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 z84 } from "zod";
+import { z as z85 } from "zod";
 
 // src/api/json-value.ts
-import { z as z83 } from "zod";
-var jsonValueSchema = z83.lazy(
-  () => z83.union([
-    z83.string(),
-    z83.number(),
-    z83.boolean(),
-    z83.null(),
-    z83.array(jsonValueSchema),
-    z83.record(z83.string(), jsonValueSchema)
+import { z as z84 } from "zod";
+var jsonValueSchema = z84.lazy(
+  () => z84.union([
+    z84.string(),
+    z84.number(),
+    z84.boolean(),
+    z84.null(),
+    z84.array(jsonValueSchema),
+    z84.record(z84.string(), jsonValueSchema)
   ])
 );
 
 // src/api/agent-schemas.ts
-var publicAgentSchema = z84.object({
-  id: z84.string(),
-  name: z84.string(),
-  slack_enabled: z84.boolean().nullish(),
-  microsoft_teams_enabled: z84.boolean().nullish(),
-  agentic_memory_enabled: z84.boolean().nullish(),
-  thread_id: z84.string().nullish(),
-  created_at: z84.string().nullish(),
-  updated_at: z84.string().nullish(),
-  latest_build: z84.object({ config: jsonValueSchema.nullish() }).nullish()
-});
-var publicBuildSchema = z84.object({
-  id: z84.string(),
-  agent_id: z84.string(),
-  name: z84.string(),
-  revision_number: z84.number().nullish(),
-  created_at: z84.string().nullish(),
-  updated_at: z84.string().nullish()
-});
-var listAgentsResponseSchema = z84.object({
-  agents: z84.array(publicAgentSchema),
-  total: z84.number().nullish(),
-  limit: z84.number().nullish(),
-  offset: z84.number().nullish()
-});
-var agentUserContextSchema = z84.object({
-  pinned_at: z84.string().nullable()
-});
-var getAgentResponseSchema = z84.object({
+var publicAgentSchema = z85.object({
+  id: z85.string(),
+  name: z85.string(),
+  slack_enabled: z85.boolean().nullish(),
+  microsoft_teams_enabled: z85.boolean().nullish(),
+  agentic_memory_enabled: z85.boolean().nullish(),
+  thread_id: z85.string().nullish(),
+  created_at: z85.string().nullish(),
+  updated_at: z85.string().nullish(),
+  latest_build: z85.object({ config: jsonValueSchema.nullish() }).nullish()
+});
+var publicBuildSchema = z85.object({
+  id: z85.string(),
+  agent_id: z85.string(),
+  name: z85.string(),
+  revision_number: z85.number().nullish(),
+  created_at: z85.string().nullish(),
+  updated_at: z85.string().nullish()
+});
+var listAgentsResponseSchema = z85.object({
+  agents: z85.array(publicAgentSchema),
+  total: z85.number().nullish(),
+  limit: z85.number().nullish(),
+  offset: z85.number().nullish()
+});
+var agentUserContextSchema = z85.object({
+  pinned_at: z85.string().nullable()
+});
+var getAgentResponseSchema = z85.object({
   agent: publicAgentSchema,
   user_context: agentUserContextSchema.optional()
 });
-var createAgentResponseSchema = z84.object({
+var createAgentResponseSchema = z85.object({
   agent: publicAgentSchema,
   build: publicBuildSchema.optional()
 });
-var deleteAgentResponseSchema = z84.object({
-  success: z84.literal(true)
-});
-var namedRefSchema = z84.object({
-  id: z84.string(),
-  name: z84.string()
-});
-var moveQueueRefSchema = z84.object({
-  id: z84.string(),
-  name: z84.string(),
-  item_count: z84.number()
-});
-var connectionDecisionSchema = z84.object({
-  agent_id: z84.string(),
-  agent_name: z84.string(),
-  integration_type: z84.string(),
-  integration_name: z84.string(),
-  instance_name: z84.string(),
-  decision: z84.string()
-});
-var customRebuildSchema = z84.object({
-  agent_id: z84.string(),
-  agent_name: z84.string(),
-  custom_integration_name: z84.string()
-});
-var moveAgentResponseSchema = z84.object({
-  source_team_id: z84.string(),
-  target_team_id: z84.string(),
-  root_agent_id: z84.string(),
-  agents: z84.array(namedRefSchema),
-  queues: z84.array(moveQueueRefSchema),
-  total_case_items: z84.number(),
-  total_runs: z84.number(),
-  skills_to_clone: z84.array(namedRefSchema),
-  files_to_copy: z84.array(z84.object({ path: z84.string() })),
-  warnings: z84.object({
-    outcome: z84.object({
-      instances_reconnected: z84.array(connectionDecisionSchema),
-      instances_disconnected: z84.array(connectionDecisionSchema),
-      custom_integrations_to_rebuild: z84.array(customRebuildSchema),
-      catalog_rows_created_on_target: z84.number()
+var deleteAgentResponseSchema = z85.object({
+  success: z85.literal(true)
+});
+var namedRefSchema = z85.object({
+  id: z85.string(),
+  name: z85.string()
+});
+var moveQueueRefSchema = z85.object({
+  id: z85.string(),
+  name: z85.string(),
+  item_count: z85.number()
+});
+var connectionDecisionSchema = z85.object({
+  agent_id: z85.string(),
+  agent_name: z85.string(),
+  integration_type: z85.string(),
+  integration_name: z85.string(),
+  instance_name: z85.string(),
+  decision: z85.string()
+});
+var customRebuildSchema = z85.object({
+  agent_id: z85.string(),
+  agent_name: z85.string(),
+  custom_integration_name: z85.string()
+});
+var moveAgentResponseSchema = z85.object({
+  source_team_id: z85.string(),
+  target_team_id: z85.string(),
+  root_agent_id: z85.string(),
+  agents: z85.array(namedRefSchema),
+  queues: z85.array(moveQueueRefSchema),
+  total_case_items: z85.number(),
+  total_runs: z85.number(),
+  skills_to_clone: z85.array(namedRefSchema),
+  files_to_copy: z85.array(z85.object({ path: z85.string() })),
+  warnings: z85.object({
+    outcome: z85.object({
+      instances_reconnected: z85.array(connectionDecisionSchema),
+      instances_disconnected: z85.array(connectionDecisionSchema),
+      custom_integrations_to_rebuild: z85.array(customRebuildSchema),
+      catalog_rows_created_on_target: z85.number()
     }),
-    dropped_folders: z84.array(namedRefSchema),
-    dropped_memory_count: z84.number(),
-    files_copied_count: z84.number(),
-    files_skipped_conflict: z84.array(z84.string())
+    dropped_folders: z85.array(namedRefSchema),
+    dropped_memory_count: z85.number(),
+    files_copied_count: z85.number(),
+    files_skipped_conflict: z85.array(z85.string())
   }),
-  options: z84.object({
-    move_learnings: z84.boolean()
+  options: z85.object({
+    move_learnings: z85.boolean()
   }),
-  applied: z84.boolean()
+  applied: z85.boolean()
 });
 var buildConfigSchema = StoredAgentConfigSchemaV2;
 var DEFAULT_NEW_AGENT_NAME = DEFAULT_AGENT_NAME;
@@ -14560,29 +14631,29 @@ function registerAgentsEvalScores(agents) {
 __name(registerAgentsEvalScores, "registerAgentsEvalScores");
 
 // src/api/build-schemas.ts
-import { z as z85 } from "zod";
-var publicBuildSchema2 = z85.object({
-  id: z85.string(),
-  agent_id: z85.string(),
-  name: z85.string(),
-  status: z85.string().nullish(),
+import { z as z86 } from "zod";
+var publicBuildSchema2 = z86.object({
+  id: z86.string(),
+  agent_id: z86.string(),
+  name: z86.string(),
+  status: z86.string().nullish(),
   config: jsonValueSchema.nullish(),
-  revision_number: z85.number().nullish(),
-  created_at: z85.string().nullish(),
-  updated_at: z85.string().nullish()
+  revision_number: z86.number().nullish(),
+  created_at: z86.string().nullish(),
+  updated_at: z86.string().nullish()
 });
-var listBuildsResponseSchema2 = z85.object({
-  builds: z85.array(publicBuildSchema2),
-  total: z85.number().nullish(),
-  limit: z85.number().nullish(),
-  offset: z85.number().nullish()
+var listBuildsResponseSchema2 = z86.object({
+  builds: z86.array(publicBuildSchema2),
+  total: z86.number().nullish(),
+  limit: z86.number().nullish(),
+  offset: z86.number().nullish()
 });
-var getBuildResponseSchema = z85.object({
+var getBuildResponseSchema = z86.object({
   build: publicBuildSchema2
 });
-var createBuildResponseSchema = z85.object({
+var createBuildResponseSchema = z86.object({
   build: publicBuildSchema2,
-  agent: z85.object({ id: z85.string() })
+  agent: z86.object({ id: z86.string() })
 });
 
 // src/commands/agents/get.ts
@@ -14978,30 +15049,30 @@ ${plan.warnings.dropped_memory_count} AOP exception(s) will be cleared for users
 __name(renderPlan, "renderPlan");
 
 // src/api/schedule-schemas.ts
-import { z as z86 } from "zod";
-var publicScheduleSchema = z86.object({
-  id: z86.string(),
-  build_id: z86.string(),
-  agent_id: z86.string(),
-  user_id: z86.string(),
-  enabled: z86.boolean(),
-  frequency: z86.string(),
-  time: z86.string().nullish(),
-  timezone: z86.string(),
-  day: z86.string().nullish(),
-  day_of_month: z86.number().nullish(),
-  cron: z86.string().nullish(),
-  source: z86.string().nullish(),
-  task: z86.string().nullish(),
-  recurring: z86.boolean().nullish(),
-  created_at: z86.string(),
-  updated_at: z86.string()
-});
-var listSchedulesResponseSchema = z86.object({
-  schedules: z86.array(publicScheduleSchema)
-});
-var deleteScheduleResponseSchema = z86.object({
-  success: z86.literal(true)
+import { z as z87 } from "zod";
+var publicScheduleSchema = z87.object({
+  id: z87.string(),
+  build_id: z87.string(),
+  agent_id: z87.string(),
+  user_id: z87.string(),
+  enabled: z87.boolean(),
+  frequency: z87.string(),
+  time: z87.string().nullish(),
+  timezone: z87.string(),
+  day: z87.string().nullish(),
+  day_of_month: z87.number().nullish(),
+  cron: z87.string().nullish(),
+  source: z87.string().nullish(),
+  task: z87.string().nullish(),
+  recurring: z87.boolean().nullish(),
+  created_at: z87.string(),
+  updated_at: z87.string()
+});
+var listSchedulesResponseSchema = z87.object({
+  schedules: z87.array(publicScheduleSchema)
+});
+var deleteScheduleResponseSchema = z87.object({
+  success: z87.literal(true)
 });
 
 // src/commands/agents/schedules/render-schedule.ts
@@ -15449,33 +15520,33 @@ function registerAgentsSetModel(agents) {
 __name(registerAgentsSetModel, "registerAgentsSetModel");
 
 // src/api/trigger-schemas.ts
-import { z as z87 } from "zod";
-var triggerSchema = z87.object({
-  id: z87.string(),
-  agent_id: z87.string(),
-  user_id: z87.string(),
-  integration_slug: z87.string(),
-  trigger_type: z87.string(),
-  filter_config: z87.record(z87.string(), z87.unknown()),
-  integration_instance_id: z87.string(),
-  enabled: z87.boolean(),
-  created_at: z87.string(),
-  updated_at: z87.string()
+import { z as z88 } from "zod";
+var triggerSchema = z88.object({
+  id: z88.string(),
+  agent_id: z88.string(),
+  user_id: z88.string(),
+  integration_slug: z88.string(),
+  trigger_type: z88.string(),
+  filter_config: z88.record(z88.string(), z88.unknown()),
+  integration_instance_id: z88.string(),
+  enabled: z88.boolean(),
+  created_at: z88.string(),
+  updated_at: z88.string()
 });
-var listTriggersResponseSchema = z87.object({
-  triggers: z87.array(triggerSchema)
+var listTriggersResponseSchema = z88.object({
+  triggers: z88.array(triggerSchema)
 });
-var triggerTypeSchema = z87.object({
-  integration_slug: z87.string(),
-  integration_name: z87.string(),
-  icon_url: z87.string(),
-  trigger_type: z87.string(),
-  label: z87.string(),
-  description: z87.string(),
-  filter_schema: z87.record(z87.string(), z87.unknown())
+var triggerTypeSchema = z88.object({
+  integration_slug: z88.string(),
+  integration_name: z88.string(),
+  icon_url: z88.string(),
+  trigger_type: z88.string(),
+  label: z88.string(),
+  description: z88.string(),
+  filter_schema: z88.record(z88.string(), z88.unknown())
 });
-var listTriggerTypesResponseSchema = z87.object({
-  trigger_types: z87.array(triggerTypeSchema)
+var listTriggerTypesResponseSchema = z88.object({
+  trigger_types: z88.array(triggerTypeSchema)
 });
 
 // src/commands/agents/triggers/list.ts
@@ -16105,55 +16176,55 @@ function fieldsToSearchParams(fields) {
 __name(fieldsToSearchParams, "fieldsToSearchParams");
 
 // src/api/integration-schemas.ts
-import { z as z88 } from "zod";
-var integrationSchema = z88.object({
-  id: z88.string(),
-  name: z88.string(),
-  type: z88.string(),
-  provider: z88.string(),
-  user_id: z88.string().nullable(),
-  team_id: z88.string(),
-  server_url: z88.string().optional(),
-  transport_type: z88.string().optional(),
-  auth_method: z88.string().nullish(),
-  composio_mcp_id: z88.string().nullish(),
-  custom_integration_id: z88.string().nullish(),
-  icon_url: z88.string().nullish(),
-  oauth_provider: z88.string().nullish(),
-  oauth_provider_key: z88.string().nullish(),
-  oauth_scopes: z88.array(z88.string()).nullish(),
-  integration_id: z88.string().nullish(),
-  created_at: z88.string(),
-  updated_at: z88.string()
-});
-var integrationsListResponseSchema2 = z88.object({
-  integrations: z88.array(integrationSchema)
+import { z as z89 } from "zod";
+var integrationSchema = z89.object({
+  id: z89.string(),
+  name: z89.string(),
+  type: z89.string(),
+  provider: z89.string(),
+  user_id: z89.string().nullable(),
+  team_id: z89.string(),
+  server_url: z89.string().optional(),
+  transport_type: z89.string().optional(),
+  auth_method: z89.string().nullish(),
+  composio_mcp_id: z89.string().nullish(),
+  custom_integration_id: z89.string().nullish(),
+  icon_url: z89.string().nullish(),
+  oauth_provider: z89.string().nullish(),
+  oauth_provider_key: z89.string().nullish(),
+  oauth_scopes: z89.array(z89.string()).nullish(),
+  integration_id: z89.string().nullish(),
+  created_at: z89.string(),
+  updated_at: z89.string()
+});
+var integrationsListResponseSchema2 = z89.object({
+  integrations: z89.array(integrationSchema)
 });
 var connectionResponseSchema = integrationSchema;
-var buildIntegrationConfigSchema2 = z88.object({
-  id: z88.string(),
-  integration_id: z88.string().nullable(),
-  custom_integration_id: z88.string().nullable(),
-  integration_type: z88.string(),
-  integration_name: z88.string(),
-  created_at: z88.string()
+var buildIntegrationConfigSchema2 = z89.object({
+  id: z89.string(),
+  integration_id: z89.string().nullable(),
+  custom_integration_id: z89.string().nullable(),
+  integration_type: z89.string(),
+  integration_name: z89.string(),
+  created_at: z89.string()
 });
-var listBuildIntegrationsResponseSchema2 = z88.object({
-  integrations: z88.array(buildIntegrationConfigSchema2)
+var listBuildIntegrationsResponseSchema2 = z89.object({
+  integrations: z89.array(buildIntegrationConfigSchema2)
 });
-var attachBuildIntegrationsResponseSchema = z88.object({
-  success: z88.boolean(),
-  count: z88.number()
+var attachBuildIntegrationsResponseSchema = z89.object({
+  success: z89.boolean(),
+  count: z89.number()
 });
-var buildIntegrationConnectionSchema = z88.object({
-  connection_id: z88.string(),
-  created_at: z88.string()
+var buildIntegrationConnectionSchema = z89.object({
+  connection_id: z89.string(),
+  created_at: z89.string()
 });
-var listBuildIntegrationConnectionsResponseSchema = z88.object({
-  connections: z88.array(buildIntegrationConnectionSchema)
+var listBuildIntegrationConnectionsResponseSchema = z89.object({
+  connections: z89.array(buildIntegrationConnectionSchema)
 });
-var successResponseSchema = z88.object({
-  success: z88.boolean()
+var successResponseSchema = z89.object({
+  success: z89.boolean()
 });
 
 // src/commands/build-integrations/attach.ts
@@ -16196,15 +16267,15 @@ function registerBuildIntegrationsAttach(buildIntegrations) {
 __name(registerBuildIntegrationsAttach, "registerBuildIntegrationsAttach");
 
 // src/commands/build-integrations/case-queue-setup.ts
-import { z as z89 } from "zod";
-var slotSchema = z89.object({
-  config_id: z89.string(),
-  integration_type: z89.string(),
-  linked_queue_count: z89.number()
+import { z as z90 } from "zod";
+var slotSchema = z90.object({
+  config_id: z90.string(),
+  integration_type: z90.string(),
+  linked_queue_count: z90.number()
 });
-var responseSchema2 = z89.object({
-  configs: z89.array(slotSchema),
-  has_available_queues: z89.boolean()
+var responseSchema2 = z90.object({
+  configs: z90.array(slotSchema),
+  has_available_queues: z90.boolean()
 });
 var TABLE_COLUMNS10 = [
   { header: "SLOT ID", cell: /* @__PURE__ */ __name((row) => row.config_id, "cell") },
@@ -16699,9 +16770,9 @@ function registerBuildsList(builds) {
 __name(registerBuildsList, "registerBuildsList");
 
 // src/commands/builds/promote.ts
-import { z as z90 } from "zod";
-var promoteResponseSchema = z90.object({
-  success: z90.boolean()
+import { z as z91 } from "zod";
+var promoteResponseSchema = z91.object({
+  success: z91.boolean()
 });
 function registerBuildsPromote(builds) {
   builds.command("promote <id>").description(
@@ -17712,7 +17783,7 @@ function parseSortOrder(raw) {
 __name(parseSortOrder, "parseSortOrder");
 
 // src/commands/cases/runs.ts
-import { z as z91 } from "zod";
+import { z as z92 } from "zod";
 var MIN_LIMIT4 = 1;
 var MAX_LIMIT4 = 10;
 var DEFAULT_LIMIT4 = 3;
@@ -17730,17 +17801,17 @@ var RUNS_TABLE_COLUMNS = [
     cell: /* @__PURE__ */ __name((row) => row.has_pending_human_request ? row.pending_human_request_title ?? "(unknown)" : "", "cell")
   }
 ];
-var recentMessageSchema = z91.object({
-  id: z91.string(),
-  type: z91.string(),
-  role: z91.string(),
-  timestamp: z91.string(),
-  text_content: z91.string().nullish(),
-  tool_call: z91.object({ id: z91.string(), name: z91.string() }).passthrough().nullish(),
-  tool_result: z91.object({ tool_call_id: z91.string() }).passthrough().nullish()
-});
-var recentMessagesResponseSchema = z91.object({
-  messages: z91.array(recentMessageSchema)
+var recentMessageSchema = z92.object({
+  id: z92.string(),
+  type: z92.string(),
+  role: z92.string(),
+  timestamp: z92.string(),
+  text_content: z92.string().nullish(),
+  tool_call: z92.object({ id: z92.string(), name: z92.string() }).passthrough().nullish(),
+  tool_result: z92.object({ tool_call_id: z92.string() }).passthrough().nullish()
+});
+var recentMessagesResponseSchema = z92.object({
+  messages: z92.array(recentMessageSchema)
 });
 var TEXT_PREVIEW_WIDTH = 60;
 var MESSAGES_TABLE_COLUMNS = [
@@ -17869,55 +17940,55 @@ function registerCases(program) {
 __name(registerCases, "registerCases");
 
 // src/api/clarity-schemas.ts
-import { z as z92 } from "zod";
-var clarityListProcessSchema = z92.object({
-  id: z92.guid(),
-  name: z92.string(),
+import { z as z93 } from "zod";
+var clarityListProcessSchema = z93.object({
+  id: z93.guid(),
+  name: z93.string(),
   status: clarityProcessStatusSchema,
   visibility: clarityProcessVisibilitySchema,
-  version: z92.number().int(),
-  capture_count: z92.number().int(),
-  capture_counts: z92.object({
-    video: z92.number().int(),
-    interview: z92.number().int(),
-    document: z92.number().int()
+  version: z93.number().int(),
+  capture_count: z93.number().int(),
+  capture_counts: z93.object({
+    video: z93.number().int(),
+    interview: z93.number().int(),
+    document: z93.number().int()
   }).optional(),
-  pending_invitation_count: z92.number().int(),
-  contributors: z92.array(
-    z92.object({
-      user_id: z92.string(),
-      user_name: z92.string()
+  pending_invitation_count: z93.number().int(),
+  contributors: z93.array(
+    z93.object({
+      user_id: z93.string(),
+      user_name: z93.string()
     })
   ),
-  created_at: z92.string(),
-  created_by_name: z92.string().nullable()
-});
-var listClarityProcessesResponseSchema = z92.object({
-  processes: z92.array(clarityListProcessSchema),
-  total: z92.number().int(),
-  limit: z92.number().int(),
-  offset: z92.number().int()
-});
-var createClarityInviteLinkResponseSchema = z92.object({
-  invite_link: z92.object({
-    id: z92.guid(),
-    url: z92.url(),
-    created_at: z92.string(),
-    created_by: z92.object({
-      id: z92.guid(),
-      email: z92.email().nullable()
+  created_at: z93.string(),
+  created_by_name: z93.string().nullable()
+});
+var listClarityProcessesResponseSchema = z93.object({
+  processes: z93.array(clarityListProcessSchema),
+  total: z93.number().int(),
+  limit: z93.number().int(),
+  offset: z93.number().int()
+});
+var createClarityInviteLinkResponseSchema = z93.object({
+  invite_link: z93.object({
+    id: z93.guid(),
+    url: z93.url(),
+    created_at: z93.string(),
+    created_by: z93.object({
+      id: z93.guid(),
+      email: z93.email().nullable()
     })
   })
 });
-var createArtifactImportUploadUrlResponseSchema = z92.object({
-  signed_url: z92.url(),
-  capture_id: z92.guid(),
-  expires_at: z92.iso.datetime()
+var createArtifactImportUploadUrlResponseSchema = z93.object({
+  signed_url: z93.url(),
+  capture_id: z93.guid(),
+  expires_at: z93.iso.datetime()
 });
-var completeArtifactImportResponseSchema = z92.object({
+var completeArtifactImportResponseSchema = z93.object({
   capture: clarityCaptureSchema.extend({
-    createdAt: z92.iso.datetime(),
-    updatedAt: z92.iso.datetime()
+    createdAt: z93.iso.datetime(),
+    updatedAt: z93.iso.datetime()
   })
 });
 var legacyClarityProcessResponseSchema = legacyClarityProcessDetailSchema;
@@ -18356,8 +18427,8 @@ function renderCompletedImport(response) {
 __name(renderCompletedImport, "renderCompletedImport");
 
 // src/commands/clarity/assign-extra-capture-request.ts
-import { z as z93 } from "zod";
-var responseSchema3 = z93.object({
+import { z as z94 } from "zod";
+var responseSchema3 = z94.object({
   request: clarityProposalExtraCaptureRequestSchema
 });
 function renderRequest(request) {
@@ -18404,11 +18475,11 @@ function registerClarityAssignExtraCaptureRequest(clarity) {
 __name(registerClarityAssignExtraCaptureRequest, "registerClarityAssignExtraCaptureRequest");
 
 // src/commands/clarity/build-automation.ts
-import { z as z94 } from "zod";
-var responseSchema4 = z94.object({
-  automation_run: z94.object({
-    id: z94.string(),
-    status: z94.string()
+import { z as z95 } from "zod";
+var responseSchema4 = z95.object({
+  automation_run: z95.object({
+    id: z95.string(),
+    status: z95.string()
   })
 });
 function registerClarityBuildAutomation(clarity) {
@@ -18479,7 +18550,7 @@ function registerClarityCreateInviteLink(clarity) {
 __name(registerClarityCreateInviteLink, "registerClarityCreateInviteLink");
 
 // src/commands/clarity/doctor.ts
-import { z as z95 } from "zod";
+import { z as z96 } from "zod";
 
 // src/commands/clarity/render.ts
 var DEFAULT_HUMAN_SUMMARY_LIMIT = 1200;
@@ -20143,19 +20214,6 @@ var CLARITY_WRITE_TOOLS = [
     ],
     description: "Move a landscape node under a new parent or to the root."
   },
-  {
-    name: "confirmClarityLandscapeNode",
-    scope: "v1+v2",
-    read_only: false,
-    commands: ["duvo clarity landscape confirm-node"],
-    endpoints: [
-      {
-        method: "POST",
-        path: "/v2/organizations/:orgId/clarity/hierarchy/nodes/:nodeId/confirm"
-      }
-    ],
-    description: "Confirm a landscape node placement, content, or existence axis."
-  },
   {
     name: "generateClarityProcessLandscape",
     scope: "v1+v2",
@@ -20418,8 +20476,8 @@ async function buildTeamContextCheck(config) {
   }
 }
 __name(buildTeamContextCheck, "buildTeamContextCheck");
-var listMyTeamsResponseSchema2 = z95.object({
-  teams: z95.array(z95.object({ id: z95.string() }))
+var listMyTeamsResponseSchema2 = z96.object({
+  teams: z96.array(z96.object({ id: z96.string() }))
 });
 async function buildClarityApiReachableCheck(command, config) {
   let teamId;
@@ -21037,19 +21095,19 @@ function buildGenerateTransformationProposalBody(options) {
 __name(buildGenerateTransformationProposalBody, "buildGenerateTransformationProposalBody");
 
 // src/commands/clarity/get-current-process.ts
-import { z as z96 } from "zod";
-var snapshotSchema = z96.object({
-  snapshot: z96.object({
-    id: z96.string(),
-    kind: z96.string(),
-    source_snapshot_id: z96.string().nullable(),
-    parent_id: z96.string().nullable(),
-    status: z96.string(),
-    creator_type: z96.string(),
-    user_id: z96.string().nullable(),
-    sandbox_id: z96.string().nullable(),
-    created_at: z96.string(),
-    updated_at: z96.string()
+import { z as z97 } from "zod";
+var snapshotSchema = z97.object({
+  snapshot: z97.object({
+    id: z97.string(),
+    kind: z97.string(),
+    source_snapshot_id: z97.string().nullable(),
+    parent_id: z97.string().nullable(),
+    status: z97.string(),
+    creator_type: z97.string(),
+    user_id: z97.string().nullable(),
+    sandbox_id: z97.string().nullable(),
+    created_at: z97.string(),
+    updated_at: z97.string()
   })
 });
 function registerClarityGetCurrentProcess(clarity) {
@@ -21093,19 +21151,19 @@ function registerClarityGetCurrentProcess(clarity) {
 __name(registerClarityGetCurrentProcess, "registerClarityGetCurrentProcess");
 
 // src/commands/clarity/get-transformation-proposal.ts
-import { z as z97 } from "zod";
-var snapshotSchema2 = z97.object({
-  snapshot: z97.object({
-    id: z97.string(),
-    kind: z97.string(),
-    source_snapshot_id: z97.string().nullable(),
-    parent_id: z97.string().nullable(),
-    status: z97.string(),
-    creator_type: z97.string(),
-    user_id: z97.string().nullable(),
-    sandbox_id: z97.string().nullable(),
-    created_at: z97.string(),
-    updated_at: z97.string()
+import { z as z98 } from "zod";
+var snapshotSchema2 = z98.object({
+  snapshot: z98.object({
+    id: z98.string(),
+    kind: z98.string(),
+    source_snapshot_id: z98.string().nullable(),
+    parent_id: z98.string().nullable(),
+    status: z98.string(),
+    creator_type: z98.string(),
+    user_id: z98.string().nullable(),
+    sandbox_id: z98.string().nullable(),
+    created_at: z98.string(),
+    updated_at: z98.string()
   })
 });
 function registerClarityGetTransformationProposal(clarity) {
@@ -21201,7 +21259,7 @@ Transformation proposal versions (${tpVersions.length}):`
 __name(registerClarityGet, "registerClarityGet");
 
 // src/commands/clarity/landscape.ts
-import { z as z98 } from "zod";
+import { z as z99 } from "zod";
 
 // src/commands/clarity/org-scope.ts
 function getOrgFlag(command) {
@@ -21246,90 +21304,89 @@ var CAPTURES_RESOURCE_PATH = "/clarity/hierarchy/captures";
 var PROPOSED_PROCESSES_RESOURCE_PATH = "/clarity/hierarchy/proposed-processes";
 var PROCESS_NODE_TYPE = "process";
 var AREA_NODE_TYPE = "area";
-var axisSchema = z98.enum(["content", "existence"]);
-var processSummarySchema = z98.object({
-  id: z98.string(),
-  name: z98.string()
+var processSummarySchema = z99.object({
+  id: z99.string(),
+  name: z99.string()
 }).passthrough();
-var landscapeNodeSchema = z98.object({
-  id: z98.string(),
-  parentId: z98.string().nullable(),
-  processId: z98.string().nullable(),
-  name: z98.string(),
-  ownerLabel: z98.string().nullable(),
+var landscapeNodeSchema = z99.object({
+  id: z99.string(),
+  parentId: z99.string().nullable(),
+  processId: z99.string().nullable(),
+  name: z99.string(),
+  ownerLabel: z99.string().nullable(),
   process: processSummarySchema.nullable()
 }).passthrough();
 var unlinkedProcessSchema = processSummarySchema.extend({
-  teamId: z98.string(),
-  teamName: z98.string().nullable()
+  teamId: z99.string(),
+  teamName: z99.string().nullable()
 }).passthrough();
-var treeNodeSchema = z98.object({
-  id: z98.string(),
-  parentId: z98.string().nullable(),
-  processId: z98.string().nullable(),
-  name: z98.string(),
-  ownerLabel: z98.string().nullable(),
-  depth: z98.number()
+var treeNodeSchema = z99.object({
+  id: z99.string(),
+  parentId: z99.string().nullable(),
+  processId: z99.string().nullable(),
+  name: z99.string(),
+  ownerLabel: z99.string().nullable(),
+  depth: z99.number()
 }).passthrough();
-var landscapeResponseSchema = z98.object({
-  nodes: z98.array(landscapeNodeSchema),
-  links: z98.array(
-    z98.object({
-      id: z98.string(),
-      sourceNodeId: z98.string(),
-      targetNodeId: z98.string(),
-      type: z98.string(),
-      state: z98.string(),
-      confidence: z98.number().nullable()
+var landscapeResponseSchema = z99.object({
+  nodes: z99.array(landscapeNodeSchema),
+  links: z99.array(
+    z99.object({
+      id: z99.string(),
+      sourceNodeId: z99.string(),
+      targetNodeId: z99.string(),
+      type: z99.string(),
+      state: z99.string(),
+      confidence: z99.number().nullable()
     }).passthrough()
   ),
-  unlinkedProcesses: z98.array(unlinkedProcessSchema),
-  stats: z98.object({
-    totalNodes: z98.number(),
-    processNodes: z98.number(),
-    proposedNodes: z98.number(),
-    unsortedProcesses: z98.number(),
-    latestUpdatedAt: z98.string().nullable()
+  unlinkedProcesses: z99.array(unlinkedProcessSchema),
+  stats: z99.object({
+    totalNodes: z99.number(),
+    processNodes: z99.number(),
+    proposedNodes: z99.number(),
+    unsortedProcesses: z99.number(),
+    latestUpdatedAt: z99.string().nullable()
   }).passthrough(),
-  truncated: z98.boolean()
+  truncated: z99.boolean()
 }).passthrough();
-var treeResponseSchema = z98.object({
-  nodes: z98.array(treeNodeSchema),
-  truncated: z98.boolean()
+var treeResponseSchema = z99.object({
+  nodes: z99.array(treeNodeSchema),
+  truncated: z99.boolean()
 }).passthrough();
-var nodeResponseSchema = z98.object({
-  id: z98.string(),
-  parentId: z98.string().nullable(),
-  processId: z98.string().nullable(),
-  name: z98.string(),
-  ownerLabel: z98.string().nullable()
+var nodeResponseSchema = z99.object({
+  id: z99.string(),
+  parentId: z99.string().nullable(),
+  processId: z99.string().nullable(),
+  name: z99.string(),
+  ownerLabel: z99.string().nullable()
 }).passthrough();
-var deleteNodeResponseSchema = z98.object({
-  deletedCount: z98.number(),
-  detachedCount: z98.number()
-});
-var generateLandscapeResponseSchema = z98.object({
-  started: z98.literal(true),
-  generationId: z98.string(),
-  eligibleCaptureCount: z98.number()
+var deleteNodeResponseSchema = z99.object({
+  deletedCount: z99.number(),
+  detachedCount: z99.number()
+});
+var generateLandscapeResponseSchema = z99.object({
+  started: z99.literal(true),
+  generationId: z99.string(),
+  eligibleCaptureCount: z99.number()
 }).passthrough();
-var captureSchema = z98.object({
-  id: z98.string(),
-  scope: z98.string(),
-  type: z98.string(),
-  title: z98.string(),
-  organizationId: z98.string().nullable(),
-  organizationName: z98.string().nullable(),
-  teamId: z98.string().nullable(),
-  teamName: z98.string().nullable(),
-  processNodeId: z98.string().nullable(),
-  createdAt: z98.string(),
-  transcriptMessageCount: z98.number()
+var captureSchema = z99.object({
+  id: z99.string(),
+  scope: z99.string(),
+  type: z99.string(),
+  title: z99.string(),
+  organizationId: z99.string().nullable(),
+  organizationName: z99.string().nullable(),
+  teamId: z99.string().nullable(),
+  teamName: z99.string().nullable(),
+  processNodeId: z99.string().nullable(),
+  createdAt: z99.string(),
+  transcriptMessageCount: z99.number()
 }).passthrough();
-var captureListResponseSchema = z98.object({
-  captures: z98.array(captureSchema),
-  total: z98.number(),
-  truncated: z98.boolean()
+var captureListResponseSchema = z99.object({
+  captures: z99.array(captureSchema),
+  total: z99.number(),
+  truncated: z99.boolean()
 }).passthrough();
 var LANDSCAPE_COLUMNS = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell"), maxWidth: 36 },
@@ -21451,18 +21508,6 @@ function registerClarityLandscape(clarity) {
     const node = nodeResponseSchema.parse(raw);
     renderNodeMutationResult("Moved node", node, options);
   }, "moveNodeAction"));
-  landscape.command("confirm-node <node-id>").description("Confirm a landscape node axis").requiredOption("--axis <axis>", "content or existence").option("--org <org-id>", ORG_FLAG_DESCRIPTION).option("--json", "output JSON").action(/* @__PURE__ */ __name(async function confirmNodeAction(nodeId, options) {
-    const config = await requireAuthenticatedConfig(this);
-    const raw = await httpRequest({
-      method: "POST",
-      path: nodeConfirmPath(resolveOrgId(this), nodeId),
-      apiKey: config.apiKey,
-      apiBaseUrl: config.apiBaseUrl,
-      body: { axis: parseAxis(options.axis) }
-    });
-    const node = nodeResponseSchema.parse(raw);
-    renderNodeMutationResult("Confirmed node", node, options);
-  }, "confirmNodeAction"));
   landscape.command("delete-node <node-id>").description(
     "Delete a landscape node and its subtree. The node's linked process and captures are deleted; nested processes move to Unsorted"
   ).option("--org <org-id>", ORG_FLAG_DESCRIPTION).option("--json", "output JSON").action(/* @__PURE__ */ __name(async function deleteNodeAction(nodeId, options) {
@@ -21541,10 +21586,6 @@ function nodePlacementPath(orgId, nodeId) {
   return `${nodePath(orgId, nodeId)}/placement`;
 }
 __name(nodePlacementPath, "nodePlacementPath");
-function nodeConfirmPath(orgId, nodeId) {
-  return `${nodePath(orgId, nodeId)}/confirm`;
-}
-__name(nodeConfirmPath, "nodeConfirmPath");
 function buildRenameNodeBody(options) {
   if (options.ownerLabel !== void 0 && options.clearOwnerLabel) {
     throw new CliError(
@@ -21663,14 +21704,6 @@ function buildRootSearchParams(rootId) {
   return searchParams;
 }
 __name(buildRootSearchParams, "buildRootSearchParams");
-function parseAxis(value) {
-  const parsed = axisSchema.safeParse(value);
-  if (!parsed.success) {
-    throw new CliError("Axis must be content or existence.");
-  }
-  return parsed.data;
-}
-__name(parseAxis, "parseAxis");
 function renderLandscapeNodes(nodes, emptyMessage) {
   if (nodes.length === 0) {
     console.log(emptyMessage);
@@ -21899,22 +21932,22 @@ function registerClarityProcessSummaries(clarity) {
 __name(registerClarityProcessSummaries, "registerClarityProcessSummaries");
 
 // src/commands/clarity/list-snapshots.ts
-import { z as z99 } from "zod";
+import { z as z100 } from "zod";
 var SNAPSHOT_KINDS = ["current_process", "transformation_proposal"];
 var DEFAULT_LIMIT7 = 50;
 var MIN_LIMIT7 = 1;
 var MAX_LIMIT7 = 100;
-var snapshotListItemSchema = z99.looseObject({
-  id: z99.string(),
-  status: z99.string(),
-  creator_type: z99.string(),
-  created_at: z99.string(),
-  parent_id: z99.string().nullable().optional(),
-  source_snapshot_id: z99.string().nullable().optional()
+var snapshotListItemSchema = z100.looseObject({
+  id: z100.string(),
+  status: z100.string(),
+  creator_type: z100.string(),
+  created_at: z100.string(),
+  parent_id: z100.string().nullable().optional(),
+  source_snapshot_id: z100.string().nullable().optional()
 });
-var listSnapshotsResponseSchema = z99.looseObject({
-  snapshots: z99.array(snapshotListItemSchema),
-  total: z99.number().int().optional()
+var listSnapshotsResponseSchema = z100.looseObject({
+  snapshots: z100.array(snapshotListItemSchema),
+  total: z100.number().int().optional()
 });
 var TABLE_COLUMNS21 = [
   {
@@ -22331,40 +22364,40 @@ function renderLabelSummary(label) {
 __name(renderLabelSummary, "renderLabelSummary");
 
 // src/commands/clarity/process-links.ts
-import { z as z100 } from "zod";
+import { z as z101 } from "zod";
 var MIN_LIMIT9 = 1;
 var MAX_LIMIT9 = 500;
 var DEFAULT_LIMIT9 = 100;
 var ORG_FLAG_DESCRIPTION3 = "organization id for the org-scoped process landscape (overrides DUVO_ORG_ID)";
 var PROCESS_LINKS_RESOURCE_PATH = "/clarity/hierarchy/process-links";
-var processLinkTypeSchema = z100.enum([
+var processLinkTypeSchema = z101.enum([
   "hands_off_to",
   "shares_step_with",
   "variant_of"
 ]);
-var processLinkStateSchema = z100.enum(["suggested", "confirmed"]);
-var processLinkSchema = z100.object({
-  id: z100.string(),
-  source_node_id: z100.string(),
-  target_node_id: z100.string(),
+var processLinkStateSchema = z101.enum(["suggested", "confirmed"]);
+var processLinkSchema = z101.object({
+  id: z101.string(),
+  source_node_id: z101.string(),
+  target_node_id: z101.string(),
   type: processLinkTypeSchema,
   state: processLinkStateSchema,
-  confidence: z100.number().nullable(),
-  created_at: z100.string(),
-  updated_at: z100.string()
+  confidence: z101.number().nullable(),
+  created_at: z101.string(),
+  updated_at: z101.string()
 });
-var listProcessLinksResponseSchema = z100.object({
-  process_links: z100.array(processLinkSchema),
-  total: z100.number(),
-  limit: z100.number(),
-  offset: z100.number()
+var listProcessLinksResponseSchema = z101.object({
+  process_links: z101.array(processLinkSchema),
+  total: z101.number(),
+  limit: z101.number(),
+  offset: z101.number()
 });
-var processLinkMutationResponseSchema = z100.object({
+var processLinkMutationResponseSchema = z101.object({
   process_link: processLinkSchema,
-  created: z100.boolean().optional()
+  created: z101.boolean().optional()
 });
-var deleteProcessLinkResponseSchema = z100.object({
-  deleted: z100.boolean()
+var deleteProcessLinkResponseSchema = z101.object({
+  deleted: z101.boolean()
 });
 var PROCESS_LINK_COLUMNS = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell"), maxWidth: 36 },
@@ -22557,14 +22590,14 @@ function renderProcessLinks(response) {
 __name(renderProcessLinks, "renderProcessLinks");
 
 // src/commands/clarity/promote-current-process.ts
-import { z as z101 } from "zod";
-var snapshotSchema3 = z101.object({
-  snapshot: z101.object({
-    id: z101.string(),
-    status: z101.string(),
-    creator_type: z101.string(),
-    created_at: z101.string(),
-    updated_at: z101.string()
+import { z as z102 } from "zod";
+var snapshotSchema3 = z102.object({
+  snapshot: z102.object({
+    id: z102.string(),
+    status: z102.string(),
+    creator_type: z102.string(),
+    created_at: z102.string(),
+    updated_at: z102.string()
   })
 });
 function registerClarityPromoteCurrentProcess(clarity) {
@@ -22601,14 +22634,14 @@ function registerClarityPromoteCurrentProcess(clarity) {
 __name(registerClarityPromoteCurrentProcess, "registerClarityPromoteCurrentProcess");
 
 // src/commands/clarity/promote-transformation-proposal.ts
-import { z as z102 } from "zod";
-var snapshotSchema4 = z102.object({
-  snapshot: z102.object({
-    id: z102.string(),
-    status: z102.string(),
-    creator_type: z102.string(),
-    created_at: z102.string(),
-    updated_at: z102.string()
+import { z as z103 } from "zod";
+var snapshotSchema4 = z103.object({
+  snapshot: z103.object({
+    id: z103.string(),
+    status: z103.string(),
+    creator_type: z103.string(),
+    created_at: z103.string(),
+    updated_at: z103.string()
   })
 });
 function registerClarityPromoteTransformationProposal(clarity) {
@@ -22684,8 +22717,8 @@ __name(registerClarityRevertTransformationProposal, "registerClarityRevertTransf
 
 // src/commands/clarity/save-snapshot.ts
 import { readFile as readFile7 } from "node:fs/promises";
-import { z as z103 } from "zod";
-var snapshotFileSchema = z103.union([
+import { z as z104 } from "zod";
+var snapshotFileSchema = z104.union([
   saveClarityProcessSnapshotBodySchema.shape.steps,
   saveClarityProcessSnapshotBodySchema.pick({
     steps: true,
@@ -23686,16 +23719,16 @@ function registerConnectionsList(connections) {
 __name(registerConnectionsList, "registerConnectionsList");
 
 // src/commands/connections/probe.ts
-import { z as z104 } from "zod";
-var toolSchema = z104.object({
-  name: z104.string(),
-  description: z104.string().optional(),
-  input_schema: z104.record(z104.string(), z104.unknown()).optional()
+import { z as z105 } from "zod";
+var toolSchema = z105.object({
+  name: z105.string(),
+  description: z105.string().optional(),
+  input_schema: z105.record(z105.string(), z105.unknown()).optional()
 });
-var probeResponseSchema = z104.object({
-  success: z104.boolean(),
-  tools: z104.array(toolSchema).optional(),
-  error: z104.string().optional()
+var probeResponseSchema = z105.object({
+  success: z105.boolean(),
+  tools: z105.array(toolSchema).optional(),
+  error: z105.string().optional()
 });
 var DESCRIPTION_MAX_WIDTH = 80;
 var TABLE_COLUMNS23 = [
@@ -23918,48 +23951,48 @@ function registerConnections(program) {
 __name(registerConnections, "registerConnections");
 
 // src/api/credential-schemas.ts
-import { z as z105 } from "zod";
-var dateLike = z105.string();
-var secretSchema = z105.object({
-  id: z105.string(),
-  team_id: z105.string(),
-  user_id: z105.string().nullable(),
-  name: z105.string(),
-  service_slug: z105.string().nullable(),
-  env_var_keys: z105.array(z105.string()),
-  created_by: z105.string(),
+import { z as z106 } from "zod";
+var dateLike = z106.string();
+var secretSchema = z106.object({
+  id: z106.string(),
+  team_id: z106.string(),
+  user_id: z106.string().nullable(),
+  name: z106.string(),
+  service_slug: z106.string().nullable(),
+  env_var_keys: z106.array(z106.string()),
+  created_by: z106.string(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var secretsListResponseSchema = z105.array(secretSchema);
+var secretsListResponseSchema = z106.array(secretSchema);
 var secretResponseSchema = secretSchema;
-var browserLoginSchema = z105.object({
-  id: z105.string(),
-  user_id: z105.string().nullable(),
-  team_id: z105.string(),
-  domain: z105.string(),
-  username: z105.string().nullable(),
+var browserLoginSchema = z106.object({
+  id: z106.string(),
+  user_id: z106.string().nullable(),
+  team_id: z106.string(),
+  domain: z106.string(),
+  username: z106.string().nullable(),
   password: encryptedDataSchema.nullable(),
   otp_secret: encryptedDataSchema.nullable(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var browserLoginsListResponseSchema = z105.array(credentialPreviewSchema);
-var revisionLoginSummarySchema = z105.object({
-  id: z105.string(),
-  user_id: z105.string().nullable(),
-  team_id: z105.string().nullable(),
-  domain: z105.string(),
-  username: z105.string().nullable(),
+var browserLoginsListResponseSchema = z106.array(credentialPreviewSchema);
+var revisionLoginSummarySchema = z106.object({
+  id: z106.string(),
+  user_id: z106.string().nullable(),
+  team_id: z106.string().nullable(),
+  domain: z106.string(),
+  username: z106.string().nullable(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var revisionLoginsListResponseSchema = z105.array(
+var revisionLoginsListResponseSchema = z106.array(
   revisionLoginSummarySchema
 );
-var revisionSecretsListResponseSchema = z105.array(secretSchema);
-var successResponseSchema2 = z105.object({
-  success: z105.boolean()
+var revisionSecretsListResponseSchema = z106.array(secretSchema);
+var successResponseSchema2 = z106.object({
+  success: z106.boolean()
 });
 var attachSuccessResponseSchema = successResponseSchema2;
 var deleteSecretResponseSchema = successResponseSchema2;
@@ -26723,6 +26756,80 @@ function registerPulseMessages(pulse) {
 }
 __name(registerPulseMessages, "registerPulseMessages");
 
+// src/commands/pulse/move.ts
+function registerPulseMove(pulse) {
+  pulse.command("move <id>").description(
+    "Move a Pulse dashboard to another team. Only the latest version moves \u2014 chat, raw events, older versions, and member shares are deleted; you become the owner, visibility resets to private, and the dashboard's API key is rotated. Requires Manager or above on both teams."
+  ).requiredOption("--to <team-id>", "destination team ID").option(
+    "--team <id>",
+    "source team ID (defaults to the team scoped to your credentials)"
+  ).option(
+    "--dry-run",
+    "preview which connections reconnect vs drop without moving anything"
+  ).option("-y, --yes", "skip the confirmation prompt").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function moveAction(id, options) {
+    const pulseId = trimRequired(id, "<id>");
+    const targetTeamId = trimRequired(options.to, "--to");
+    const config = await requireAuthenticatedConfig(this);
+    const { apiKey, apiBaseUrl } = config;
+    const sourceTeamId = await resolveRequiredTeamId(config, {
+      override: options.team ?? getTeamFlag(this)
+    });
+    if (!options.dryRun) {
+      await confirmDestructive({
+        message: `Move Pulse dashboard "${pulseId}" to team ${targetTeamId}? Chat, raw events, older versions, and member shares are deleted, visibility resets to private, and the dashboard's API key is rotated \u2014 only the latest version moves.`,
+        skip: options.yes ?? false
+      });
+    }
+    const searchParams = new URLSearchParams();
+    if (options.dryRun) {
+      searchParams.append("dryRun", "true");
+    }
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/teams/${encodeURIComponent(sourceTeamId)}/artifacts/${encodeURIComponent(pulseId)}/move`,
+      apiKey,
+      apiBaseUrl,
+      searchParams,
+      body: { targetTeamId }
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = movePulsePlanSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const plan = parsed.data;
+    const reused = plan.connections.reused.length;
+    const dropped = plan.connections.disconnected.length;
+    const toRebuild = plan.connections.customToRebuild.length;
+    console.log(
+      plan.applied ? green("Pulse dashboard moved.") : yellow("Preview only \u2014 nothing was moved.")
+    );
+    console.log();
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: plan.artifactId },
+        { label: "Title", value: plan.artifactTitle ?? "" },
+        { label: "From team", value: plan.sourceTeamId },
+        { label: "To team", value: plan.targetTeamId },
+        {
+          label: "Connections",
+          value: `${reused} reconnect, ${dropped} dropped, ${toRebuild} need rebuild`
+        }
+      ])
+    );
+    console.log();
+    console.log(
+      plan.applied ? "The chat and older versions were deleted \u2014 only the latest version moved." : `Apply it with: duvo pulse move ${plan.artifactId} --to ${plan.targetTeamId}`
+    );
+  }, "moveAction"));
+}
+__name(registerPulseMove, "registerPulseMove");
+
 // src/commands/pulse/pdf.ts
 import { writeFile as writeFile2 } from "node:fs/promises";
 
@@ -26768,6 +26875,45 @@ function registerPulsePdf(pulse) {
 }
 __name(registerPulsePdf, "registerPulsePdf");
 
+// src/commands/pulse/refresh.ts
+function registerPulseRefresh(pulse) {
+  pulse.command("refresh <id>").description(
+    "Refresh a Pulse dashboard's data in place. The refresh runs in the background \u2014 poll `duvo pulse get` for status."
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function refreshAction(id, options) {
+    const pulseId = trimRequired(id, "<id>");
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/artifacts/${encodeURIComponent(pulseId)}/refresh`,
+      apiKey,
+      apiBaseUrl,
+      body: {}
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = artifactSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    console.log(green("Pulse refresh started."));
+    console.log();
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: parsed.data.id },
+        { label: "Title", value: parsed.data.title ?? "" },
+        { label: "Status", value: parsed.data.status }
+      ])
+    );
+    console.log();
+    console.log(`Check progress with: duvo pulse get ${parsed.data.id}`);
+  }, "refreshAction"));
+}
+__name(registerPulseRefresh, "registerPulseRefresh");
+
 // src/commands/pulse/rename.ts
 var MAX_TITLE_LENGTH = 120;
 function registerPulseRename(pulse) {
@@ -27094,9 +27240,11 @@ function registerPulse(program) {
   registerPulseSnapshot(pulse);
   registerPulseSendMessage(pulse);
   registerPulseStop(pulse);
+  registerPulseRefresh(pulse);
   registerPulseRename(pulse);
   registerPulseShare(pulse);
   registerPulseDuplicate(pulse);
+  registerPulseMove(pulse);
   registerPulseDelete(pulse);
   registerPulseVersions(pulse);
   registerPulseRestore(pulse);
@@ -28384,91 +28532,91 @@ function registerRevisionSecrets(program) {
 __name(registerRevisionSecrets, "registerRevisionSecrets");
 
 // src/api/run-schemas.ts
-import { z as z106 } from "zod";
-var publicRunSchema = z106.object({
-  id: z106.string(),
-  agent_id: z106.string(),
-  build_id: z106.string(),
-  status: z106.string(),
-  source: z106.string().nullish(),
-  sandbox_id: z106.string().nullish(),
-  started_at: z106.string().nullish(),
-  completed_at: z106.string().nullish(),
-  created_at: z106.string(),
-  updated_at: z106.string().nullish(),
-  human_in_the_loop_enabled: z106.boolean().nullish()
-});
-var startRunResponseSchema = z106.object({
+import { z as z107 } from "zod";
+var publicRunSchema = z107.object({
+  id: z107.string(),
+  agent_id: z107.string(),
+  build_id: z107.string(),
+  status: z107.string(),
+  source: z107.string().nullish(),
+  sandbox_id: z107.string().nullish(),
+  started_at: z107.string().nullish(),
+  completed_at: z107.string().nullish(),
+  created_at: z107.string(),
+  updated_at: z107.string().nullish(),
+  human_in_the_loop_enabled: z107.boolean().nullish()
+});
+var startRunResponseSchema = z107.object({
   run: publicRunSchema
 });
-var questionOptionSchema = z106.object({
-  label: z106.string(),
-  description: z106.string().nullish()
-});
-var questionSchema = z106.object({
-  question: z106.string(),
-  header: z106.string().nullish(),
-  options: z106.array(questionOptionSchema).nullish(),
-  multi_select: z106.boolean().nullish()
-});
-var pendingHumanRequestSchema = z106.object({
-  id: z106.string(),
-  title: z106.string(),
-  description: z106.string().nullish(),
-  created_at: z106.string(),
-  type: z106.string(),
-  questions: z106.array(questionSchema).nullish()
-});
-var getRunResponseSchema = z106.object({
+var questionOptionSchema = z107.object({
+  label: z107.string(),
+  description: z107.string().nullish()
+});
+var questionSchema = z107.object({
+  question: z107.string(),
+  header: z107.string().nullish(),
+  options: z107.array(questionOptionSchema).nullish(),
+  multi_select: z107.boolean().nullish()
+});
+var pendingHumanRequestSchema = z107.object({
+  id: z107.string(),
+  title: z107.string(),
+  description: z107.string().nullish(),
+  created_at: z107.string(),
+  type: z107.string(),
+  questions: z107.array(questionSchema).nullish()
+});
+var getRunResponseSchema = z107.object({
   run: publicRunSchema.nullable(),
   pending_human_request: pendingHumanRequestSchema.nullish()
 });
-var stopRunResponseSchema = z106.object({
-  success: z106.boolean(),
-  message: z106.string().nullish()
-});
-var runMessageSchema = z106.object({
-  id: z106.string(),
-  type: z106.string(),
-  role: z106.string(),
-  timestamp: z106.string(),
-  text_content: z106.string().nullish(),
-  tool_call: z106.object({
-    id: z106.string(),
-    name: z106.string(),
-    arguments: z106.record(z106.string(), z106.unknown()).nullish()
+var stopRunResponseSchema = z107.object({
+  success: z107.boolean(),
+  message: z107.string().nullish()
+});
+var runMessageSchema = z107.object({
+  id: z107.string(),
+  type: z107.string(),
+  role: z107.string(),
+  timestamp: z107.string(),
+  text_content: z107.string().nullish(),
+  tool_call: z107.object({
+    id: z107.string(),
+    name: z107.string(),
+    arguments: z107.record(z107.string(), z107.unknown()).nullish()
   }).nullish(),
-  tool_result: z106.object({
-    tool_call_id: z106.string(),
-    result: z106.unknown().nullish(),
-    error: z106.string().nullish()
+  tool_result: z107.object({
+    tool_call_id: z107.string(),
+    result: z107.unknown().nullish(),
+    error: z107.string().nullish()
   }).nullish()
 });
-var listRunMessagesResponseSchema = z106.object({
-  messages: z106.array(runMessageSchema),
-  total: z106.number().nullish(),
-  limit: z106.number().nullish(),
-  offset: z106.number().nullish()
+var listRunMessagesResponseSchema = z107.object({
+  messages: z107.array(runMessageSchema),
+  total: z107.number().nullish(),
+  limit: z107.number().nullish(),
+  offset: z107.number().nullish()
 });
-var postedMessageSchema = z106.object({
-  id: z106.string(),
-  type: z106.string(),
-  role: z106.string(),
-  timestamp: z106.string(),
-  text_content: z106.string()
+var postedMessageSchema = z107.object({
+  id: z107.string(),
+  type: z107.string(),
+  role: z107.string(),
+  timestamp: z107.string(),
+  text_content: z107.string()
 });
-var postRunMessageResponseSchema = z106.object({
+var postRunMessageResponseSchema = z107.object({
   message: postedMessageSchema
 });
-var respondHumanRequestResponseSchema = z106.object({
-  human_request: z106.object({
-    id: z106.string(),
-    run_id: z106.string(),
-    title: z106.string(),
-    description: z106.string().nullish(),
-    response: z106.string().nullish(),
-    responded_at: z106.string().nullish(),
-    created_at: z106.string()
+var respondHumanRequestResponseSchema = z107.object({
+  human_request: z107.object({
+    id: z107.string(),
+    run_id: z107.string(),
+    title: z107.string(),
+    description: z107.string().nullish(),
+    response: z107.string().nullish(),
+    responded_at: z107.string().nullish(),
+    created_at: z107.string()
   })
 });
 
@@ -29163,28 +29311,28 @@ function registerRuns(program) {
 __name(registerRuns, "registerRuns");
 
 // src/api/sandbox-schemas.ts
-import { z as z107 } from "zod";
-var createSandboxResponseSchema = z107.object({
-  sandbox_id: z107.string(),
-  expires_at: z107.string()
+import { z as z108 } from "zod";
+var createSandboxResponseSchema = z108.object({
+  sandbox_id: z108.string(),
+  expires_at: z108.string()
 });
-var createSandboxUploadUrlResponseSchema = z107.object({
-  upload_url: z107.string(),
-  path: z107.string(),
-  expires_in_seconds: z107.number()
+var createSandboxUploadUrlResponseSchema = z108.object({
+  upload_url: z108.string(),
+  path: z108.string(),
+  expires_in_seconds: z108.number()
 });
-var sandboxFileSchema = z107.object({
-  name: z107.string(),
-  path: z107.string(),
-  type: z107.enum(["file", "dir"]),
-  size_bytes: z107.number()
+var sandboxFileSchema = z108.object({
+  name: z108.string(),
+  path: z108.string(),
+  type: z108.enum(["file", "dir"]),
+  size_bytes: z108.number()
 });
-var listSandboxFilesResponseSchema = z107.object({
-  files: z107.array(sandboxFileSchema)
+var listSandboxFilesResponseSchema = z108.object({
+  files: z108.array(sandboxFileSchema)
 });
-var uploadSandboxFileResponseSchema = z107.object({
-  path: z107.string(),
-  size_bytes: z107.number()
+var uploadSandboxFileResponseSchema = z108.object({
+  path: z108.string(),
+  size_bytes: z108.number()
 });
 var DEFAULT_SANDBOX_FILES_PATH = "/workspace";
 
@@ -29795,13 +29943,13 @@ __name(registerSkillsAssignments, "registerSkillsAssignments");
 
 // src/commands/skills/create.ts
 import { readFileSync as readFileSync5 } from "node:fs";
-import { z as z108 } from "zod";
-var createSkillResponseSchema = z108.object({
-  skill: z108.object({
-    id: z108.string(),
-    name: z108.string(),
-    description: z108.string(),
-    team_id: z108.string()
+import { z as z109 } from "zod";
+var createSkillResponseSchema = z109.object({
+  skill: z109.object({
+    id: z109.string(),
+    name: z109.string(),
+    description: z109.string(),
+    team_id: z109.string()
   })
 });
 function registerSkillsCreate(skills) {
@@ -30165,13 +30313,13 @@ function readExistingContent(source) {
 __name(readExistingContent, "readExistingContent");
 
 // src/commands/skills/install.ts
-import { z as z109 } from "zod";
-var installSkillResponseSchema = z109.object({
-  skill: z109.object({
-    id: z109.string(),
-    name: z109.string(),
-    description: z109.string(),
-    team_id: z109.string()
+import { z as z110 } from "zod";
+var installSkillResponseSchema = z110.object({
+  skill: z110.object({
+    id: z110.string(),
+    name: z110.string(),
+    description: z110.string(),
+    team_id: z110.string()
   })
 });
 function registerSkillsInstall(skills) {
@@ -30361,13 +30509,13 @@ __name(registerSkillsSystem, "registerSkillsSystem");
 // src/commands/skills/upload.ts
 import { readFile as readFile9, stat as stat2 } from "node:fs/promises";
 import { basename as basename3 } from "node:path";
-import { z as z110 } from "zod";
-var uploadSkillResponseSchema = z110.object({
-  skill: z110.object({
-    id: z110.string(),
-    name: z110.string(),
-    description: z110.string(),
-    team_id: z110.string()
+import { z as z111 } from "zod";
+var uploadSkillResponseSchema = z111.object({
+  skill: z111.object({
+    id: z111.string(),
+    name: z111.string(),
+    description: z111.string(),
+    team_id: z111.string()
   })
 });
 function registerSkillsUpload(skills) {
@@ -30740,9 +30888,9 @@ function registerTeamMembers(team) {
 __name(registerTeamMembers, "registerTeamMembers");
 
 // src/commands/team/use.ts
-import { z as z111 } from "zod";
+import { z as z112 } from "zod";
 var TEAM_ID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var teamIdSchema = z111.string().regex(TEAM_ID_SHAPE);
+var teamIdSchema = z112.string().regex(TEAM_ID_SHAPE);
 function registerTeamUse(team) {
   team.command("use <team-id>").description(
     "Set the default team for the active OAuth profile (overridable per-command via --team or DUVO_TEAM_ID)"
@@ -30828,14 +30976,14 @@ function registerTeam(program) {
 __name(registerTeam, "registerTeam");
 
 // src/commands/teams/list.ts
-import { z as z112 } from "zod";
-var teamApiSchema2 = z112.object({
-  id: z112.string(),
-  name: z112.string(),
-  organization_id: z112.string().nullable()
+import { z as z113 } from "zod";
+var teamApiSchema2 = z113.object({
+  id: z113.string(),
+  name: z113.string(),
+  organization_id: z113.string().nullable()
 });
-var listMyTeamsResponseSchema3 = z112.object({
-  teams: z112.array(teamApiSchema2)
+var listMyTeamsResponseSchema3 = z113.object({
+  teams: z113.array(teamApiSchema2)
 });
 function registerTeamsList(teams) {
   teams.command("list", { isDefault: true }).description("List every team you can act on").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
@@ -30878,21 +31026,21 @@ function registerTeamsList(teams) {
 __name(registerTeamsList, "registerTeamsList");
 
 // src/commands/teams/org-insights.ts
-import { z as z113 } from "zod";
-var headlineSchema = z113.object({
-  total_runs: z113.number(),
-  completed_runs: z113.number(),
-  failed_runs: z113.number(),
-  success_rate: z113.number().nullable(),
-  active_agents: z113.number(),
-  active_users: z113.number(),
-  start_date: z113.string(),
-  end_date: z113.string(),
-  truncated: z113.boolean(),
-  aggregated_teams: z113.number(),
-  total_teams: z113.number()
-});
-var orgInsightsHeadlineResponseSchema = z113.object({
+import { z as z114 } from "zod";
+var headlineSchema = z114.object({
+  total_runs: z114.number(),
+  completed_runs: z114.number(),
+  failed_runs: z114.number(),
+  success_rate: z114.number().nullable(),
+  active_agents: z114.number(),
+  active_users: z114.number(),
+  start_date: z114.string(),
+  end_date: z114.string(),
+  truncated: z114.boolean(),
+  aggregated_teams: z114.number(),
+  total_teams: z114.number()
+});
+var orgInsightsHeadlineResponseSchema = z114.object({
   headline: headlineSchema
 });
 function formatRate(rate) {
@@ -30960,26 +31108,26 @@ function registerTeamsOrgInsights(teams) {
 __name(registerTeamsOrgInsights, "registerTeamsOrgInsights");
 
 // src/commands/teams/org-metrics.ts
-import { z as z114 } from "zod";
-var teamMetricSchema = z114.object({
-  team_id: z114.string(),
-  team_name: z114.string(),
-  is_deleted: z114.boolean(),
-  member_count: z114.number(),
-  assignment_count: z114.number(),
-  scheduled_job_count: z114.number(),
-  total_jobs: z114.number(),
-  completed_jobs: z114.number(),
-  failed_jobs: z114.number(),
-  total_runs: z114.number()
-});
-var orgInsightsMetricsResponseSchema = z114.object({
-  teams: z114.array(teamMetricSchema),
-  start_date: z114.string(),
-  end_date: z114.string(),
-  truncated: z114.boolean(),
-  total_teams: z114.number(),
-  org_member_count: z114.number()
+import { z as z115 } from "zod";
+var teamMetricSchema = z115.object({
+  team_id: z115.string(),
+  team_name: z115.string(),
+  is_deleted: z115.boolean(),
+  member_count: z115.number(),
+  assignment_count: z115.number(),
+  scheduled_job_count: z115.number(),
+  total_jobs: z115.number(),
+  completed_jobs: z115.number(),
+  failed_jobs: z115.number(),
+  total_runs: z115.number()
+});
+var orgInsightsMetricsResponseSchema = z115.object({
+  teams: z115.array(teamMetricSchema),
+  start_date: z115.string(),
+  end_date: z115.string(),
+  truncated: z115.boolean(),
+  total_teams: z115.number(),
+  org_member_count: z115.number()
 });
 function registerTeamsOrgMetrics(teams) {
   teams.command("org-metrics <org-id>").description("Show per-team run metrics across an organization").option("--start-date <date>", "window start (ISO 8601, default 7d ago)").option("--end-date <date>", "window end (ISO 8601, default now)").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function orgMetricsAction(orgId, options) {
@@ -31042,20 +31190,20 @@ ${total_teams} teams${suffix} \xB7 ${org_member_count} org members`
 __name(registerTeamsOrgMetrics, "registerTeamsOrgMetrics");
 
 // src/commands/teams/org-usage.ts
-import { z as z115 } from "zod";
+import { z as z116 } from "zod";
 var GRANULARITIES = ["day", "week", "month"];
 var DEFAULT_LOOKBACK_MS = 30 * 24 * 60 * 60 * 1e3;
-var bucketSchema = z115.object({
-  period: z115.string(),
-  total_runs: z115.number(),
-  scheduled_runs: z115.number(),
-  on_demand_runs: z115.number()
-});
-var usageChartResponseSchema = z115.object({
-  buckets: z115.array(bucketSchema),
-  granularity: z115.enum(GRANULARITIES),
-  truncated: z115.boolean(),
-  total_teams: z115.number()
+var bucketSchema = z116.object({
+  period: z116.string(),
+  total_runs: z116.number(),
+  scheduled_runs: z116.number(),
+  on_demand_runs: z116.number()
+});
+var usageChartResponseSchema = z116.object({
+  buckets: z116.array(bucketSchema),
+  granularity: z116.enum(GRANULARITIES),
+  truncated: z116.boolean(),
+  total_teams: z116.number()
 });
 function registerTeamsOrgUsage(teams) {
   teams.command("org-usage <org-id>").description("Show org-wide run volume over time (scheduled vs on-demand)").option("--start-date <date>", "window start (ISO 8601, default 30d ago)").option("--end-date <date>", "window end (ISO 8601, default now)").option(
@@ -31114,17 +31262,17 @@ function registerTeamsOrgUsage(teams) {
 __name(registerTeamsOrgUsage, "registerTeamsOrgUsage");
 
 // src/commands/teams/org.ts
-import { z as z116 } from "zod";
-var orgTeamSchema = z116.object({
-  id: z116.string(),
-  name: z116.string(),
-  userIsMember: z116.boolean(),
-  userRole: z116.string().nullable(),
-  memberCount: z116.number()
-});
-var listOrgTeamsResponseSchema = z116.object({
-  teams: z116.array(orgTeamSchema),
-  total: z116.number()
+import { z as z117 } from "zod";
+var orgTeamSchema = z117.object({
+  id: z117.string(),
+  name: z117.string(),
+  userIsMember: z117.boolean(),
+  userRole: z117.string().nullable(),
+  memberCount: z117.number()
+});
+var listOrgTeamsResponseSchema = z117.object({
+  teams: z117.array(orgTeamSchema),
+  total: z117.number()
 });
 function registerTeamsOrg(teams) {
   teams.command("org <org-id>").description("List all teams in an organization you belong to").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function orgAction(orgId, options) {
@@ -31229,7 +31377,7 @@ __name(resolveActiveTeamId, "resolveActiveTeamId");
 var version = resolveVersion();
 function resolveVersion() {
   if (true) {
-    return "1.24.1";
+    return "1.26.0";
   }
   const packageJsonPath = join3(
     dirname3(fileURLToPath2(import.meta.url)),
@@ -31423,7 +31571,7 @@ function isNewerVersion(candidate, current) {
 __name(isNewerVersion, "isNewerVersion");
 function loadPackageMeta() {
   if (true) {
-    return { name: "@duvoai/cli", version: "1.24.1" };
+    return { name: "@duvoai/cli", version: "1.26.0" };
   }
   const require2 = createRequire(import.meta.url);
   const raw = require2("../package.json");