@duvoai/cli 1.25.0 → 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,
@@ -10039,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(
@@ -10201,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,
@@ -10258,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]
       });
@@ -10269,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()
     })
@@ -10321,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,
@@ -10373,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,
@@ -10441,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 = [
@@ -10508,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 = {
@@ -10592,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
@@ -10648,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
 ]);
@@ -10676,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()
-});
-var listSkillsResponseSchema = z73.object({
-  skills: z73.array(skillApiSchema)
+  team_id: z74.string().nullable()
 });
-var systemSkillSchema = z73.object({
-  id: z73.string(),
-  name: z73.string(),
-  description: z73.string()
-});
-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 listSkillsResponseSchema = z74.object({
+  skills: z74.array(skillApiSchema)
 });
-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
@@ -10856,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 vpnProxyConfigForOrganizationResponseSchema = z79.object({
-  config: vpnProxyConfigSummarySchema.nullable()
+var vpnProxyConfigForOrganizationAttachmentSchema = z80.object({
+  bypassDomains: z80.array(z80.string()),
+  vpnEnforced: z80.boolean()
+});
+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;
@@ -11067,7 +11143,7 @@ function canonicalizeSopInput(config) {
 }
 __name(canonicalizeSopInput, "canonicalizeSopInput");
 __name2(canonicalizeSopInput, "canonicalizeSopInput");
-var caseFilterStatusSchema = z80.enum([
+var caseFilterStatusSchema = z81.enum([
   "pending",
   "claimed",
   "completed",
@@ -11075,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") {
@@ -11182,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;
     }
@@ -12445,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,
@@ -12951,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;
@@ -13736,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;
@@ -14555,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
@@ -14973,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
@@ -15444,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
@@ -16100,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
@@ -16191,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") },
@@ -16694,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(
@@ -17707,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;
@@ -17725,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 = [
@@ -17864,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;
@@ -18351,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) {
@@ -18399,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) {
@@ -18474,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;
@@ -20138,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",
@@ -20413,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;
@@ -21032,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) {
@@ -21088,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) {
@@ -21196,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) {
@@ -21241,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 },
@@ -21446,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) {
@@ -21536,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(
@@ -21658,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);
@@ -21894,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 = [
   {
@@ -22326,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 },
@@ -22552,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) {
@@ -22596,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) {
@@ -22679,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,
@@ -23681,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 = [
@@ -23913,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;
@@ -26718,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";
 
@@ -27132,6 +27244,7 @@ function registerPulse(program) {
   registerPulseRename(pulse);
   registerPulseShare(pulse);
   registerPulseDuplicate(pulse);
+  registerPulseMove(pulse);
   registerPulseDelete(pulse);
   registerPulseVersions(pulse);
   registerPulseRestore(pulse);
@@ -28419,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()
   })
 });
 
@@ -29198,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";
 
@@ -29830,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) {
@@ -30200,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) {
@@ -30396,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) {
@@ -30775,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)"
@@ -30863,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) {
@@ -30913,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) {
@@ -30995,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) {
@@ -31077,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(
@@ -31149,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) {
@@ -31264,7 +31377,7 @@ __name(resolveActiveTeamId, "resolveActiveTeamId");
 var version = resolveVersion();
 function resolveVersion() {
   if (true) {
-    return "1.25.0";
+    return "1.26.0";
   }
   const packageJsonPath = join3(
     dirname3(fileURLToPath2(import.meta.url)),
@@ -31458,7 +31571,7 @@ function isNewerVersion(candidate, current) {
 __name(isNewerVersion, "isNewerVersion");
 function loadPackageMeta() {
   if (true) {
-    return { name: "@duvoai/cli", version: "1.25.0" };
+    return { name: "@duvoai/cli", version: "1.26.0" };
   }
   const require2 = createRequire(import.meta.url);
   const raw = require2("../package.json");