@duvoai/cli 1.18.1 → 1.19.0

package/dist/bin/duvo.js

@@ -89,11 +89,11 @@ import { z as z51 } from "zod";
 import { z as z52 } from "zod";
 import { z as z53 } from "zod";
 import { z as z54 } from "zod";
-import { z as z56 } from "zod";
 import { z as z55 } from "zod";
-import { z as z58 } from "zod";
 import { z as z57 } from "zod";
+import { z as z56 } from "zod";
 import { z as z59 } from "zod";
+import { z as z58 } from "zod";
 import { z as z60 } from "zod";
 import { z as z61 } from "zod";
 import { z as z62 } from "zod";
@@ -105,13 +105,14 @@ import { z as z67 } from "zod";
 import { z as z68 } from "zod";
 import { z as z69 } from "zod";
 import { z as z70 } from "zod";
-import { z as z72 } from "zod";
 import { z as z71 } from "zod";
 import { z as z73 } from "zod";
+import { z as z72 } from "zod";
 import { z as z74 } from "zod";
 import { z as z75 } from "zod";
 import { z as z76 } from "zod";
 import { z as z77 } from "zod";
+import { z as z78 } from "zod";
 
 // ../node_modules/.pnpm/jsonrepair@3.13.2/node_modules/jsonrepair/lib/esm/utils/JSONRepairError.js
 var JSONRepairError = class extends Error {
@@ -2469,6 +2470,7 @@ 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]"
 ];
@@ -2513,6 +2515,10 @@ var AVAILABLE_AGENT_MODELS = {
     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"
+  },
   "claude-opus-4-8": {
     displayName: "Claude Opus 4.8",
     description: "Our most capable model \u2014 best for complex work"
@@ -3008,6 +3014,12 @@ var clarityProcessContributorSchema = z14.object({
   userId: z14.string(),
   userName: z14.string()
 });
+var clarityProcessLandscapeMemberSchema = z14.object({
+  id: z14.string(),
+  userId: z14.string().nullable(),
+  email: z14.string().nullable(),
+  name: z14.string()
+});
 var clarityProcessLandscapeSummarySchema = z14.object({
   id: z14.guid(),
   name: z14.string(),
@@ -3021,6 +3033,7 @@ var clarityProcessLandscapeSummarySchema = z14.object({
     document: z14.number()
   }),
   contributors: z14.array(clarityProcessContributorSchema),
+  people: z14.array(clarityProcessLandscapeMemberSchema).default([]),
   updatedAt: z14.coerce.date()
 });
 var clarityLandscapeAssignedTeamSchema = z14.object({
@@ -6509,6 +6522,10 @@ var apiKeySchema = z27.object({
   user_id: z27.guid(),
   user_name: z27.string().nullable(),
   user_email: z27.string().nullable(),
+  /** Team this key is scoped to. `null` means the key is user-scoped. */
+  team_id: z27.guid().nullable(),
+  team_name: z27.string().nullable(),
+  organization_name: z27.string().nullable(),
   last_used_at: z27.string().nullable(),
   expires_at: z27.string().nullable(),
   revoked_at: z27.string().nullable(),
@@ -6519,13 +6536,19 @@ var apiKeyListResponseSchema = z27.object({
 });
 var createApiKeyBodySchema = z27.object({
   name: z27.string().trim().min(1).max(100),
-  expires_in_days: z27.int().min(1).max(365).optional()
+  expires_in_days: z27.int().min(1).max(365).optional(),
+  /**
+   * Team to scope the key to. Omit or pass `null` to create a user-scoped key
+   * that grants access to every team the owning user can reach.
+   */
+  team_id: z27.guid().nullable().optional()
 });
 var createApiKeyResponseSchema = z27.object({
   id: z27.guid(),
   name: z27.string(),
   key: z27.string(),
   key_prefix: z27.string(),
+  team_id: z27.guid().nullable(),
   expires_at: z27.string().nullable(),
   created_at: z27.string()
 });
@@ -6638,7 +6661,7 @@ var artifactDetailResponseSchema = z29.object({
 });
 var artifactMessageListResponseSchema = z29.object({
   data: z29.array(artifactMessageSchema),
-  total: z29.number()
+  total: z29.number().int().nonnegative()
 });
 var artifactRevisionSchema = z29.object({
   id: z29.guid(),
@@ -6675,6 +6698,7 @@ var createArtifactResponseSchema = z29.object({
   artifact_id: z29.guid(),
   user_message: artifactMessageSchema
 });
+var duplicateArtifactResponseSchema = artifactSchema;
 var sendArtifactMessageBodySchema = z29.object({
   message: z29.string().min(1).max(1e4),
   // Continue from a specific version (branch). Omitted = continue from the
@@ -8108,107 +8132,131 @@ var getAgentMemoryFileResponseSchema = z47.object({
   generation: z47.string().optional(),
   ...memorySourceFieldsSchema
 });
-var DataResidencySchema = z48.enum(["us", "eu", "apac"]);
-var DataHandlingSchema = z48.enum(["standard", "zdr"]);
-var browserPageSchema = z49.object({
-  id: z49.string().describe("Page ID"),
-  url: z49.url().describe("Page URL"),
-  faviconUrl: z49.string().describe("Page favicon URL"),
-  title: z49.string().describe("Page title"),
-  debuggerUrl: z49.url().describe("Page-specific debugger URL"),
-  debuggerFullscreenUrl: z49.url().describe("Page-specific full-screen debugger URL")
-});
-var browserSessionInfoSchema = z49.object({
+var automationSummaryApiSchema = z48.object({
+  id: z48.guid(),
+  name: z48.string(),
+  agent_count: z48.int(),
+  queue_count: z48.int(),
+  created_at: z48.string(),
+  updated_at: z48.string()
+});
+var automationsListApiSchema = z48.object({
+  automations: z48.array(automationSummaryApiSchema),
+  total: z48.int(),
+  limit: z48.int(),
+  offset: z48.int()
+});
+var automationDetailApiSchema = automationSummaryApiSchema.extend({
+  live_revision_number: z48.int().nullable(),
+  has_draft: z48.boolean()
+});
+var automationDetailResponseApiSchema = z48.object({
+  automation: automationDetailApiSchema
+});
+var createAutomationResponseApiSchema = z48.object({
+  automation: automationSummaryApiSchema
+});
+var DataResidencySchema = z49.enum(["us", "eu", "apac"]);
+var DataHandlingSchema = z49.enum(["standard", "zdr"]);
+var browserPageSchema = z50.object({
+  id: z50.string().describe("Page ID"),
+  url: z50.url().describe("Page URL"),
+  faviconUrl: z50.string().describe("Page favicon URL"),
+  title: z50.string().describe("Page title"),
+  debuggerUrl: z50.url().describe("Page-specific debugger URL"),
+  debuggerFullscreenUrl: z50.url().describe("Page-specific full-screen debugger URL")
+});
+var browserSessionInfoSchema = z50.object({
   // Session-level URLs (Browser Use provides these, Browserbase also has them)
-  wsUrl: z49.url().nullable(),
-  liveUrl: z49.url().nullable(),
+  wsUrl: z50.url().nullable(),
+  liveUrl: z50.url().nullable(),
   // Page-level data (Browserbase provides these, Browser Use returns empty array)
-  pages: z49.array(browserPageSchema)
-});
-var browserbaseDebugResponseSchema = z49.object({
-  debuggerFullscreenUrl: z49.url().describe("Session full-screen debugger URL"),
-  debuggerUrl: z49.url().describe("Session debugger URL"),
-  pages: z49.array(browserPageSchema).describe("List of pages in the session"),
-  wsUrl: z49.url().describe("WebSocket URL for the session")
-});
-var browserbaseSessionCreateResponseSchema = z49.object({
-  id: z49.string().describe("Session ID"),
-  createdAt: z49.iso.datetime().describe("Session creation timestamp"),
-  updatedAt: z49.iso.datetime().describe("Session last update timestamp"),
-  projectId: z49.string().describe("Project ID"),
-  startedAt: z49.iso.datetime().describe("Session start timestamp"),
-  endedAt: z49.iso.datetime().optional().describe("Session end timestamp"),
-  expiresAt: z49.iso.datetime().describe("Session expiration timestamp"),
-  status: z49.string().describe("Session status"),
-  proxyBytes: z49.number().describe("Proxy bytes used"),
-  avgCpuUsage: z49.number().describe("Average CPU usage"),
-  memoryUsage: z49.number().describe("Memory usage"),
-  keepAlive: z49.boolean().describe("Keep alive flag"),
-  contextId: z49.string().describe("Context ID"),
-  region: z49.string().describe("Region"),
-  userMetadata: z49.record(z49.string(), z49.unknown()).describe("User metadata"),
-  connectUrl: z49.string().describe("Connect URL"),
-  seleniumRemoteUrl: z49.string().describe("Selenium remote URL"),
-  signingKey: z49.string().describe("Signing key")
-});
-var getBuildParamsSchema = z50.object({
-  buildId: z50.guid()
-});
-var listBuildsParamsSchema = z50.object({
-  copilotId: z50.guid()
-});
-var updateBuildBodySchema = z50.object({
-  config: z50.record(z50.string(), z50.any()).optional().describe("Build configuration object"),
-  handoverTargetIds: z50.array(z50.guid()).optional().describe("Agent IDs that this agent can hand over work to"),
-  revision_name: z50.string().trim().min(1).max(80).nullable().optional().describe(
+  pages: z50.array(browserPageSchema)
+});
+var browserbaseDebugResponseSchema = z50.object({
+  debuggerFullscreenUrl: z50.url().describe("Session full-screen debugger URL"),
+  debuggerUrl: z50.url().describe("Session debugger URL"),
+  pages: z50.array(browserPageSchema).describe("List of pages in the session"),
+  wsUrl: z50.url().describe("WebSocket URL for the session")
+});
+var browserbaseSessionCreateResponseSchema = z50.object({
+  id: z50.string().describe("Session ID"),
+  createdAt: z50.iso.datetime().describe("Session creation timestamp"),
+  updatedAt: z50.iso.datetime().describe("Session last update timestamp"),
+  projectId: z50.string().describe("Project ID"),
+  startedAt: z50.iso.datetime().describe("Session start timestamp"),
+  endedAt: z50.iso.datetime().optional().describe("Session end timestamp"),
+  expiresAt: z50.iso.datetime().describe("Session expiration timestamp"),
+  status: z50.string().describe("Session status"),
+  proxyBytes: z50.number().describe("Proxy bytes used"),
+  avgCpuUsage: z50.number().describe("Average CPU usage"),
+  memoryUsage: z50.number().describe("Memory usage"),
+  keepAlive: z50.boolean().describe("Keep alive flag"),
+  contextId: z50.string().describe("Context ID"),
+  region: z50.string().describe("Region"),
+  userMetadata: z50.record(z50.string(), z50.unknown()).describe("User metadata"),
+  connectUrl: z50.string().describe("Connect URL"),
+  seleniumRemoteUrl: z50.string().describe("Selenium remote URL"),
+  signingKey: z50.string().describe("Signing key")
+});
+var getBuildParamsSchema = z51.object({
+  buildId: z51.guid()
+});
+var listBuildsParamsSchema = z51.object({
+  copilotId: z51.guid()
+});
+var updateBuildBodySchema = z51.object({
+  config: z51.record(z51.string(), z51.any()).optional().describe("Build configuration object"),
+  handoverTargetIds: z51.array(z51.guid()).optional().describe("Agent IDs that this agent can hand over work to"),
+  revision_name: z51.string().trim().min(1).max(80).nullable().optional().describe(
     "Optional user-defined name for this revision. Pass null to clear."
   ),
-  revision_description: z50.string().trim().max(500).nullable().optional().describe(
+  revision_description: z51.string().trim().max(500).nullable().optional().describe(
     "Optional user-defined description for this revision. Pass null to clear."
   )
 });
-var createBuildBodySchema = z50.object({
-  copilot_id: z50.guid().describe("Agent ID"),
-  name: z50.string().describe("Build name"),
-  config: z50.record(z50.string(), z50.any()).optional().describe("Build configuration object"),
-  handoverTargetIds: z50.array(z50.guid()).optional().describe("Agent IDs that this agent can hand over work to"),
-  source_build_id: z50.guid().optional().describe("Build ID to copy integrations and queue links from")
-});
-var buildResponseSchema = z50.object({
-  build_id: z50.string().describe("Build ID"),
-  name: z50.string().describe("Build name"),
-  config: z50.record(z50.string(), z50.any()).nullable().describe("Build configuration"),
-  copilot_id: z50.string().describe("Associated copilot ID"),
-  status: z50.string().describe("Build status"),
-  created_at: z50.coerce.date().describe("Creation timestamp"),
-  updated_at: z50.coerce.date().nullable().describe("Last update timestamp"),
-  revision_number: z50.number().nullable().describe("Revision number"),
-  revision_name: z50.string().nullable().optional().describe("User-defined name for this revision"),
-  revision_description: z50.string().nullable().optional().describe("User-defined description for this revision"),
-  parent_build_id: z50.string().nullable().describe("Parent build ID"),
-  created_by: z50.string().nullable().describe("User who created this build"),
-  created_by_name: z50.string().nullable().optional().describe("Display name of the user who created this build")
-});
-var listBuildsResponseSchema = z50.array(buildResponseSchema);
-var buildResponseApiSchema = z50.object({
+var createBuildBodySchema = z51.object({
+  copilot_id: z51.guid().describe("Agent ID"),
+  name: z51.string().describe("Build name"),
+  config: z51.record(z51.string(), z51.any()).optional().describe("Build configuration object"),
+  handoverTargetIds: z51.array(z51.guid()).optional().describe("Agent IDs that this agent can hand over work to"),
+  source_build_id: z51.guid().optional().describe("Build ID to copy integrations and queue links from")
+});
+var buildResponseSchema = z51.object({
+  build_id: z51.string().describe("Build ID"),
+  name: z51.string().describe("Build name"),
+  config: z51.record(z51.string(), z51.any()).nullable().describe("Build configuration"),
+  copilot_id: z51.string().describe("Associated copilot ID"),
+  status: z51.string().describe("Build status"),
+  created_at: z51.coerce.date().describe("Creation timestamp"),
+  updated_at: z51.coerce.date().nullable().describe("Last update timestamp"),
+  revision_number: z51.number().nullable().describe("Revision number"),
+  revision_name: z51.string().nullable().optional().describe("User-defined name for this revision"),
+  revision_description: z51.string().nullable().optional().describe("User-defined description for this revision"),
+  parent_build_id: z51.string().nullable().describe("Parent build ID"),
+  created_by: z51.string().nullable().describe("User who created this build"),
+  created_by_name: z51.string().nullable().optional().describe("Display name of the user who created this build")
+});
+var listBuildsResponseSchema = z51.array(buildResponseSchema);
+var buildResponseApiSchema = z51.object({
   build: buildApiSchema
 });
-var buildsListApiSchema = z50.object({
-  builds: z50.array(buildApiSchema),
-  total: z50.int(),
-  limit: z50.int(),
-  offset: z50.int()
+var buildsListApiSchema = z51.object({
+  builds: z51.array(buildApiSchema),
+  total: z51.int(),
+  limit: z51.int(),
+  offset: z51.int()
 });
-var createBuildResponseApiSchema = z50.object({
+var createBuildResponseApiSchema = z51.object({
   build: buildApiSchema,
-  agent: z50.object({
-    id: z50.guid()
+  agent: z51.object({
+    id: z51.guid()
   })
 });
-var builderRunGenerateResponseSchema = z50.object({
-  status: z50.literal("generating"),
-  builderRunId: z50.string(),
-  buildId: z50.string()
+var builderRunGenerateResponseSchema = z51.object({
+  status: z51.literal("generating"),
+  builderRunId: z51.string(),
+  buildId: z51.string()
 });
 var BUILDER_RUN_STATUSES = [
   "not_started",
@@ -8219,252 +8267,252 @@ var BUILDER_RUN_STATUSES = [
   "waiting_for_input",
   "waiting_for_approve"
 ];
-var builderRunStatusSchema = z50.object({
-  id: z50.string(),
-  status: z50.enum(BUILDER_RUN_STATUSES),
-  build_id: z50.string(),
-  started_at: z50.string().nullable(),
-  completed_at: z50.string().nullable(),
+var builderRunStatusSchema = z51.object({
+  id: z51.string(),
+  status: z51.enum(BUILDER_RUN_STATUSES),
+  build_id: z51.string(),
+  started_at: z51.string().nullable(),
+  completed_at: z51.string().nullable(),
   checkpoint_config: StoredAgentConfigSchema.nullable(),
   pending_user_questions: askUserQuestionInputSchema.nullable(),
-  schedule_suggested: z50.boolean().optional()
-});
-var filterValueSchema = z51.object({
-  value: z51.string().min(1),
-  name: z51.string().min(1)
-});
-var filterCategorySchema = z51.object({
-  key: z51.string(),
-  name: z51.string().min(1),
-  selectionMode: z51.enum(["single", "multi"]),
-  values: z51.array(filterValueSchema)
-});
-var caseFiltersResponseSchema = z51.object({
-  filters: z51.array(filterCategorySchema)
-});
-var caseQueueFolderResponseSchema = z52.object({
-  id: z52.string(),
-  name: z52.string(),
-  team_id: z52.string(),
-  parent_folder_id: z52.string().nullable(),
-  created_at: z52.string(),
-  updated_at: z52.string()
-});
-var caseQueueFoldersListResponseSchema = z52.object({
-  folders: z52.array(caseQueueFolderResponseSchema)
-});
-var createCaseQueueFolderRequestSchema = z52.object({
-  name: z52.string().min(1).max(100),
-  parent_folder_id: z52.guid().nullable().optional()
-});
-var updateCaseQueueFolderRequestSchema = z52.object({
-  name: z52.string().min(1).max(100).optional(),
-  parent_folder_id: z52.guid().nullable().optional()
-});
-var moveQueuesToFolderRequestSchema = z52.object({
-  queue_ids: z52.array(z52.guid()).min(1),
-  folder_id: z52.guid().nullable()
-});
-var caseQueueLabelSchema = z53.object({
-  id: z53.guid(),
-  key: z53.string(),
+  schedule_suggested: z51.boolean().optional()
+});
+var filterValueSchema = z52.object({
+  value: z52.string().min(1),
+  name: z52.string().min(1)
+});
+var filterCategorySchema = z52.object({
+  key: z52.string(),
+  name: z52.string().min(1),
+  selectionMode: z52.enum(["single", "multi"]),
+  values: z52.array(filterValueSchema)
+});
+var caseFiltersResponseSchema = z52.object({
+  filters: z52.array(filterCategorySchema)
+});
+var caseQueueFolderResponseSchema = z53.object({
+  id: z53.string(),
+  name: z53.string(),
+  team_id: z53.string(),
+  parent_folder_id: z53.string().nullable(),
+  created_at: z53.string(),
+  updated_at: z53.string()
+});
+var caseQueueFoldersListResponseSchema = z53.object({
+  folders: z53.array(caseQueueFolderResponseSchema)
+});
+var createCaseQueueFolderRequestSchema = z53.object({
+  name: z53.string().min(1).max(100),
+  parent_folder_id: z53.guid().nullable().optional()
+});
+var updateCaseQueueFolderRequestSchema = z53.object({
+  name: z53.string().min(1).max(100).optional(),
+  parent_folder_id: z53.guid().nullable().optional()
+});
+var moveQueuesToFolderRequestSchema = z53.object({
+  queue_ids: z53.array(z53.guid()).min(1),
+  folder_id: z53.guid().nullable()
+});
+var caseQueueLabelSchema = z54.object({
+  id: z54.guid(),
+  key: z54.string(),
   // Empty string key means a simple tag (value-only); non-empty key creates a key-value categorization
-  value: z53.string().min(1),
-  color_hue: z53.int().min(0).max(360)
+  value: z54.string().min(1),
+  color_hue: z54.int().min(0).max(360)
 });
-var caseLabelsListResponseSchema = z53.object({
-  labels: z53.array(caseQueueLabelSchema)
+var caseLabelsListResponseSchema = z54.object({
+  labels: z54.array(caseQueueLabelSchema)
 });
-var caseLabelAssignInputSchema = z53.object({
-  labels: z53.array(
-    z53.object({
-      key: z53.string().optional().default(""),
-      value: z53.string().min(1)
+var caseLabelAssignInputSchema = z54.object({
+  labels: z54.array(
+    z54.object({
+      key: z54.string().optional().default(""),
+      value: z54.string().min(1)
     })
   ).min(1).max(50)
 });
-var caseLabelAssignResponseSchema = z53.object({
-  labels: z53.array(caseQueueLabelSchema)
+var caseLabelAssignResponseSchema = z54.object({
+  labels: z54.array(caseQueueLabelSchema)
 });
-var caseLabelUpdateInputSchema = z53.object({
+var caseLabelUpdateInputSchema = z54.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: z53.string().optional(),
-  value: z53.string().min(1),
-  color_hue: z53.int().min(0).max(360).optional()
+  key: z54.string().optional(),
+  value: z54.string().min(1),
+  color_hue: z54.int().min(0).max(360).optional()
 });
-var caseLabelUpdateResponseSchema = z53.object({
+var caseLabelUpdateResponseSchema = z54.object({
   label: caseQueueLabelSchema
 });
-var caseLabelUnlinkInputSchema = z53.object({
-  label_ids: z53.array(z53.guid()).min(1)
+var caseLabelUnlinkInputSchema = z54.object({
+  label_ids: z54.array(z54.guid()).min(1)
 });
-var caseLabelUnlinkResponseSchema = z53.object({
-  success: z53.boolean()
+var caseLabelUnlinkResponseSchema = z54.object({
+  success: z54.boolean()
 });
-var caseLabelCreateInputSchema = z53.object({
-  key: z53.string().optional().default(""),
-  value: z53.string().min(1),
-  color_hue: z53.int().min(0).max(360).optional()
+var caseLabelCreateInputSchema = z54.object({
+  key: z54.string().optional().default(""),
+  value: z54.string().min(1),
+  color_hue: z54.int().min(0).max(360).optional()
 });
-var caseLabelCreateResponseSchema = z53.object({
+var caseLabelCreateResponseSchema = z54.object({
   label: caseQueueLabelSchema.extend({
-    case_count: z53.int().min(0)
+    case_count: z54.int().min(0)
   })
 });
 var caseQueueLabelWithCountSchema = caseQueueLabelSchema.extend({
-  case_count: z53.int().min(0)
+  case_count: z54.int().min(0)
 });
-var caseLabelsWithCountsListResponseSchema = z53.object({
-  labels: z53.array(caseQueueLabelWithCountSchema)
+var caseLabelsWithCountsListResponseSchema = z54.object({
+  labels: z54.array(caseQueueLabelWithCountSchema)
 });
 var SEQUENTIAL_TRIGGER_CONCURRENCY = 1;
-var settableTriggerConcurrencySchema = z54.literal(SEQUENTIAL_TRIGGER_CONCURRENCY).nullable();
-var caseTriggerApiSchema = z54.object({
-  id: z54.string(),
-  agent_id: z54.string(),
-  case_queue_id: z54.string(),
-  case_queue_name: z54.string(),
-  user_id: z54.string(),
-  enabled: z54.boolean(),
-  concurrency: z54.int().positive().nullable(),
-  created_at: z54.string(),
-  updated_at: z54.string(),
-  creator_display_name: z54.string().nullable(),
-  can_disable: z54.boolean(),
-  has_conflict: z54.boolean(),
-  conflicting_agents: z54.array(conflictingAgentSchema)
-});
-var caseTriggerResponseSchema = z54.object({
+var settableTriggerConcurrencySchema = z55.literal(SEQUENTIAL_TRIGGER_CONCURRENCY).nullable();
+var caseTriggerApiSchema = z55.object({
+  id: z55.string(),
+  agent_id: z55.string(),
+  case_queue_id: z55.string(),
+  case_queue_name: z55.string(),
+  user_id: z55.string(),
+  enabled: z55.boolean(),
+  concurrency: z55.int().positive().nullable(),
+  created_at: z55.string(),
+  updated_at: z55.string(),
+  creator_display_name: z55.string().nullable(),
+  can_disable: z55.boolean(),
+  has_conflict: z55.boolean(),
+  conflicting_agents: z55.array(conflictingAgentSchema)
+});
+var caseTriggerResponseSchema = z55.object({
   case_trigger: caseTriggerApiSchema
 });
-var caseTriggersListResponseSchema = z54.object({
-  case_triggers: z54.array(caseTriggerApiSchema)
+var caseTriggersListResponseSchema = z55.object({
+  case_triggers: z55.array(caseTriggerApiSchema)
 });
-var deleteCaseTriggerResponseSchema = z54.object({
-  success: z54.literal(true)
+var deleteCaseTriggerResponseSchema = z55.object({
+  success: z55.literal(true)
 });
-var caseTriggerConflictPreviewResponseSchema = z54.object({
-  has_conflict: z54.boolean(),
-  conflicting_agents: z54.array(conflictingAgentSchema)
+var caseTriggerConflictPreviewResponseSchema = z55.object({
+  has_conflict: z55.boolean(),
+  conflicting_agents: z55.array(conflictingAgentSchema)
 });
-var integrationConfigMinSchema = z54.object({
-  id: z54.string(),
-  integration_id: z54.guid().nullable(),
-  integration_type: z54.string()
+var integrationConfigMinSchema = z55.object({
+  id: z55.string(),
+  integration_id: z55.guid().nullable(),
+  integration_type: z55.string()
 });
-var integrationConfigsResponseSchema = z54.object({
-  integrations: z54.array(integrationConfigMinSchema)
+var integrationConfigsResponseSchema = z55.object({
+  integrations: z55.array(integrationConfigMinSchema)
 });
-var caseQueueMinSchema = z54.object({
-  id: z54.string(),
-  name: z54.string()
+var caseQueueMinSchema = z55.object({
+  id: z55.string(),
+  name: z55.string()
 });
-var caseQueuesForSlotResponseSchema = z54.object({
-  queues: z54.array(caseQueueMinSchema)
+var caseQueuesForSlotResponseSchema = z55.object({
+  queues: z55.array(caseQueueMinSchema)
 });
 var APPROVAL_DECISION = {
   APPROVED: "approved",
   REJECTED: "rejected"
 };
-var approvalDecisionSchema = z55.enum([
+var approvalDecisionSchema = z56.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 = z55.object({
-  id: z55.string().uuid(),
-  assignee_user_id: z55.string().uuid(),
-  assignee_name: z55.string().nullable(),
-  assignee_email: z55.string().nullable(),
+var humanRequestBatchRowSchema = z56.object({
+  id: z56.string().uuid(),
+  assignee_user_id: z56.string().uuid(),
+  assignee_name: z56.string().nullable(),
+  assignee_email: z56.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: z55.string(),
+  prompt: z56.string(),
   decision: approvalDecisionSchema.nullable(),
-  responded_at: z55.string().nullable(),
-  responded_by_user_id: z55.string().uuid().nullable(),
-  responded_by_name: z55.string().nullable(),
-  responded_by_email: z55.string().nullable(),
-  cancelled_at: z55.string().nullable(),
-  cancellation_reason: z55.string().nullable()
-});
-var approvalBatchSchema = z55.object({
-  id: z55.string().uuid(),
-  case_queue_item_id: z55.string().uuid(),
-  agent_run_id: z55.string().uuid(),
-  title: z55.string(),
-  created_at: z55.string(),
-  resolved_at: z55.string().nullable(),
-  cancelled_at: z55.string().nullable(),
-  cancellation_reason: z55.string().nullable(),
-  rows: z55.array(humanRequestBatchRowSchema)
-});
-var approvalRequestInputSchema = z55.object({
-  approverUserId: z55.string().uuid(),
-  prompt: z55.string().trim().min(1).max(HUMAN_REQUEST_PROMPT_MAX)
-});
-var createHumanRequestBatchBodySchema = z55.object({
-  agentRunId: z55.string().uuid(),
-  title: z55.string().trim().min(1).max(HUMAN_REQUEST_TITLE_MAX),
-  requests: z55.array(approvalRequestInputSchema).min(1).max(MAX_APPROVERS_PER_BATCH)
-});
-var createHumanRequestBatchResponseSchema = z55.object({
-  batchId: z55.string().uuid(),
-  createdAt: z55.string(),
-  humanRequestIds: z55.array(z55.string().uuid())
-});
-var requestCaseApprovalsToolInputSchema = z55.object({
-  title: z55.string().trim().min(1).max(HUMAN_REQUEST_TITLE_MAX),
-  requests: z55.array(approvalRequestInputSchema).min(1).max(MAX_APPROVERS_PER_BATCH)
-});
-var requestCaseApprovalsBatchStatusSchema = z55.enum([
+  responded_at: z56.string().nullable(),
+  responded_by_user_id: z56.string().uuid().nullable(),
+  responded_by_name: z56.string().nullable(),
+  responded_by_email: z56.string().nullable(),
+  cancelled_at: z56.string().nullable(),
+  cancellation_reason: z56.string().nullable()
+});
+var approvalBatchSchema = z56.object({
+  id: z56.string().uuid(),
+  case_queue_item_id: z56.string().uuid(),
+  agent_run_id: z56.string().uuid(),
+  title: z56.string(),
+  created_at: z56.string(),
+  resolved_at: z56.string().nullable(),
+  cancelled_at: z56.string().nullable(),
+  cancellation_reason: z56.string().nullable(),
+  rows: z56.array(humanRequestBatchRowSchema)
+});
+var approvalRequestInputSchema = z56.object({
+  approverUserId: z56.string().uuid(),
+  prompt: z56.string().trim().min(1).max(HUMAN_REQUEST_PROMPT_MAX)
+});
+var createHumanRequestBatchBodySchema = z56.object({
+  agentRunId: z56.string().uuid(),
+  title: z56.string().trim().min(1).max(HUMAN_REQUEST_TITLE_MAX),
+  requests: z56.array(approvalRequestInputSchema).min(1).max(MAX_APPROVERS_PER_BATCH)
+});
+var createHumanRequestBatchResponseSchema = z56.object({
+  batchId: z56.string().uuid(),
+  createdAt: z56.string(),
+  humanRequestIds: z56.array(z56.string().uuid())
+});
+var requestCaseApprovalsToolInputSchema = z56.object({
+  title: z56.string().trim().min(1).max(HUMAN_REQUEST_TITLE_MAX),
+  requests: z56.array(approvalRequestInputSchema).min(1).max(MAX_APPROVERS_PER_BATCH)
+});
+var requestCaseApprovalsBatchStatusSchema = z56.enum([
   "resolved",
   "cancelled"
 ]);
-var requestCaseApprovalsDecisionEntrySchema = z55.object({
-  assigneeUserId: z55.string().uuid(),
+var requestCaseApprovalsDecisionEntrySchema = z56.object({
+  assigneeUserId: z56.string().uuid(),
   decision: approvalDecisionSchema,
-  respondedAt: z55.string(),
-  respondedByUserId: z55.string().uuid()
+  respondedAt: z56.string(),
+  respondedByUserId: z56.string().uuid()
 });
-var requestCaseApprovalsToolOutputSchema = z55.object({
+var requestCaseApprovalsToolOutputSchema = z56.object({
   status: requestCaseApprovalsBatchStatusSchema,
-  decisions: z55.array(requestCaseApprovalsDecisionEntrySchema)
-});
-var humanRequestContextSchema = z55.discriminatedUnion("kind", [
-  z55.object({
-    kind: z55.literal("run"),
-    runId: z55.string().uuid(),
-    buildId: z55.string().uuid(),
-    agentId: z55.string().uuid(),
-    agentName: z55.string().nullable()
+  decisions: z56.array(requestCaseApprovalsDecisionEntrySchema)
+});
+var humanRequestContextSchema = z56.discriminatedUnion("kind", [
+  z56.object({
+    kind: z56.literal("run"),
+    runId: z56.string().uuid(),
+    buildId: z56.string().uuid(),
+    agentId: z56.string().uuid(),
+    agentName: z56.string().nullable()
   }),
-  z55.object({
-    kind: z55.literal("case"),
-    queueId: z55.string().uuid(),
-    caseId: z55.string().uuid(),
-    caseTitle: z55.string()
+  z56.object({
+    kind: z56.literal("case"),
+    queueId: z56.string().uuid(),
+    caseId: z56.string().uuid(),
+    caseTitle: z56.string()
   })
 ]);
-var caseQueueItemSchema = z56.object({
-  id: z56.guid(),
-  queue_id: z56.guid(),
-  title: z56.string(),
-  data: z56.string(),
-  status: z56.enum(["pending", "completed", "failed"]),
+var caseQueueItemSchema = z57.object({
+  id: z57.guid(),
+  queue_id: z57.guid(),
+  title: z57.string(),
+  data: z57.string(),
+  status: z57.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: z56.enum([
+  display_status: z57.enum([
     "pending",
     "in_progress",
     "needs_input",
@@ -8472,84 +8520,84 @@ var caseQueueItemSchema = z56.object({
     "completed",
     "failed"
   ]),
-  claimed_at: z56.string().nullable(),
-  claimed_by_run_id: z56.string().nullable(),
-  completed_at: z56.string().nullable(),
+  claimed_at: z57.string().nullable(),
+  claimed_by_run_id: z57.string().nullable(),
+  completed_at: z57.string().nullable(),
   /** When the case is scheduled to be re-handled (null if not postponed) */
-  postponed_to: z56.string().nullable(),
-  created_at: z56.string(),
-  updated_at: z56.string(),
-  created_by_user_id: z56.guid().nullable(),
-  created_by_user_name: z56.string().nullable(),
-  created_by_user_email: z56.string().nullable(),
+  postponed_to: z57.string().nullable(),
+  created_at: z57.string(),
+  updated_at: z57.string(),
+  created_by_user_id: z57.guid().nullable(),
+  created_by_user_name: z57.string().nullable(),
+  created_by_user_email: z57.string().nullable(),
   /** Status of the associated agent run (running, waiting, etc.) - null if no active run */
-  agent_run_status: z56.string().nullable(),
+  agent_run_status: z57.string().nullable(),
   /** User ID of the owner of the active agent run - null if no active run */
-  agent_run_user_id: z56.guid().nullable(),
+  agent_run_user_id: z57.guid().nullable(),
   /** ID of the pending human request for cases waiting for input */
-  pending_human_request_id: z56.guid().nullable(),
+  pending_human_request_id: z57.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: z56.guid().nullable(),
+  pending_approval_batch_id: z57.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: z56.array(z56.guid()),
+  pending_approval_assignee_user_ids: z57.array(z57.guid()),
   /** Count of resolved `human_request` approval rows on this case with `decision = 'approved'`. */
-  approval_approved_count: z56.int().nonnegative(),
+  approval_approved_count: z57.int().nonnegative(),
   /** Count of resolved `human_request` approval rows on this case with `decision = 'rejected'`. */
-  approval_rejected_count: z56.int().nonnegative(),
+  approval_rejected_count: z57.int().nonnegative(),
   /** Snippet from the data field showing search match context. Only present when search matches data. */
-  search_match_data_snippet: z56.object({
-    before: z56.string(),
-    match: z56.string(),
-    after: z56.string()
+  search_match_data_snippet: z57.object({
+    before: z57.string(),
+    match: z57.string(),
+    after: z57.string()
   }).optional(),
-  labels: z56.array(caseQueueLabelSchema)
-});
-var caseQueueItemEventSchema = z56.object({
-  id: z56.guid(),
-  case_queue_item_id: z56.guid(),
-  agent_run_id: z56.guid().nullable(),
-  human_request_id: z56.guid().nullable(),
-  type: z56.string(),
-  reason: z56.string().nullable(),
-  created_at: z56.string(),
-  agent_id: z56.guid().nullable(),
-  agent_name: z56.string().nullable(),
+  labels: z57.array(caseQueueLabelSchema)
+});
+var caseQueueItemEventSchema = z57.object({
+  id: z57.guid(),
+  case_queue_item_id: z57.guid(),
+  agent_run_id: z57.guid().nullable(),
+  human_request_id: z57.guid().nullable(),
+  type: z57.string(),
+  reason: z57.string().nullable(),
+  created_at: z57.string(),
+  agent_id: z57.guid().nullable(),
+  agent_name: z57.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: z56.guid().nullable(),
-  user_name: z56.string().nullable(),
-  user_email: z56.string().nullable(),
-  human_request_title: z56.string().nullable()
-});
-var casesListResponseSchema = z56.object({
-  cases: z56.array(caseQueueItemSchema),
-  total: z56.number(),
-  limit: z56.int(),
-  offset: z56.int()
-});
-var caseCreateInputSchema = z56.object({
-  title: z56.string().min(1).max(500).describe(
+  user_id: z57.guid().nullable(),
+  user_name: z57.string().nullable(),
+  user_email: z57.string().nullable(),
+  human_request_title: z57.string().nullable()
+});
+var casesListResponseSchema = z57.object({
+  cases: z57.array(caseQueueItemSchema),
+  total: z57.number(),
+  limit: z57.int(),
+  offset: z57.int()
+});
+var caseCreateInputSchema = z57.object({
+  title: z57.string().min(1).max(500).describe(
     "Short title for the case (max 500 characters). Put long context in `data`."
   ),
-  data: z56.string().optional().describe(
+  data: z57.string().optional().describe(
     "Additional data for the case. Free-form text or JSON; Agents receive this on claim."
   ),
-  labels: z56.array(
-    z56.object({
-      key: z56.string().optional().default("").describe("Label key (omit for a simple tag)."),
-      value: z56.string().min(1).describe("Label value (required).")
+  labels: z57.array(
+    z57.object({
+      key: z57.string().optional().default("").describe("Label key (omit for a simple tag)."),
+      value: z57.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 = z56.object({
+var caseCreateRequestSchema = z57.object({
   case: caseCreateInputSchema.optional(),
-  cases: z56.array(caseCreateInputSchema).min(1).max(100).optional()
+  cases: z57.array(caseCreateInputSchema).min(1).max(100).optional()
 }).superRefine((val, ctx) => {
   const hasCase = val.case !== void 0;
   const hasCases = val.cases !== void 0;
@@ -8567,28 +8615,28 @@ var caseCreateRequestSchema = z56.object({
     });
   }
 });
-var caseCreateResponseSchema = z56.object({
-  added_cases: z56.array(caseQueueItemSchema)
+var caseCreateResponseSchema = z57.object({
+  added_cases: z57.array(caseQueueItemSchema)
 });
-var casesStatsSchema = z56.object({
-  total: z56.number(),
+var casesStatsSchema = z57.object({
+  total: z57.number(),
   /** Pending, unowned, not postponed — idle and claimable */
-  pending: z56.number(),
+  pending: z57.number(),
   /** "In Progress": pending cases owned by a run with no open HITL token */
-  claimed: z56.number(),
+  claimed: z57.number(),
   /** "Needs Input": pending cases whose owning run has an open HITL token */
-  waiting: z56.number(),
+  waiting: z57.number(),
   /** Pending, unowned cases postponed for later */
-  postponed: z56.number(),
-  completed: z56.number(),
-  failed: z56.number()
+  postponed: z57.number(),
+  completed: z57.number(),
+  failed: z57.number()
 });
-var casesStatsResponseSchema = z56.object({
+var casesStatsResponseSchema = z57.object({
   stats: casesStatsSchema
 });
-var caseDetailResponseSchema = z56.object({
+var caseDetailResponseSchema = z57.object({
   case: caseQueueItemSchema,
-  events: z56.array(caseQueueItemEventSchema),
+  events: z57.array(caseQueueItemEventSchema),
   /**
    * Every approval batch ever created on this case, newest first. Each
    * batch carries one child row per named approver (with their decision
@@ -8596,21 +8644,21 @@ var caseDetailResponseSchema = z56.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: z56.array(approvalBatchSchema)
+  approvalBatches: z57.array(approvalBatchSchema)
 });
-var caseJobSummarySchema = z56.object({
-  id: z56.string().uuid(),
-  case_queue_item_id: z56.string().uuid(),
-  agent_id: z56.string().uuid(),
-  agent_name: z56.string(),
+var caseJobSummarySchema = z57.object({
+  id: z57.string().uuid(),
+  case_queue_item_id: z57.string().uuid(),
+  agent_id: z57.string().uuid(),
+  agent_name: z57.string(),
   status: agentRunStatusSchema,
-  source: z56.string().nullable(),
-  created_at: z56.string(),
-  started_at: z56.string().nullable(),
-  completed_at: z56.string().nullable(),
-  claimed_at: z56.string(),
-  has_pending_human_request: z56.boolean(),
-  pending_human_request_title: z56.string().nullable(),
+  source: z57.string().nullable(),
+  created_at: z57.string(),
+  started_at: z57.string().nullable(),
+  completed_at: z57.string().nullable(),
+  claimed_at: z57.string(),
+  has_pending_human_request: z57.boolean(),
+  pending_human_request_title: z57.string().nullable(),
   evaluation: evalSummarySchema,
   /**
    * Owner of the agent run (from `agent_run.user_id`). The frontend mirrors
@@ -8618,225 +8666,228 @@ var caseJobSummarySchema = z56.object({
    * team role to decide whether the card is interactive (live messages,
    * HITL affordances, drawer link).
    */
-  user_id: z56.guid().nullable(),
+  user_id: z57.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: z56.string().nullable(),
-  user_email: z56.string().nullable()
+  user_name: z57.string().nullable(),
+  user_email: z57.string().nullable()
 });
-var caseJobsResponseSchema = z56.object({
-  runs: z56.array(caseJobSummarySchema)
+var caseJobsResponseSchema = z57.object({
+  runs: z57.array(caseJobSummarySchema)
 });
-var caseJobRecentMessagesResponseSchema = z56.object({
-  messages: z56.array(agentMessageWithCreatedAtSchema)
+var caseJobRecentMessagesResponseSchema = z57.object({
+  messages: z57.array(agentMessageWithCreatedAtSchema)
 });
-var adjacentCasesResponseSchema = z56.object({
-  previousId: z56.guid().nullable(),
-  nextId: z56.guid().nullable(),
-  position: z56.number(),
-  total: z56.number()
+var adjacentCasesResponseSchema = z57.object({
+  previousId: z57.guid().nullable(),
+  nextId: z57.guid().nullable(),
+  position: z57.number(),
+  total: z57.number()
 });
-var caseDeleteResponseSchema = z56.object({
-  success: z56.boolean(),
-  interruptedRunIds: z56.array(z56.guid())
+var caseDeleteResponseSchema = z57.object({
+  success: z57.boolean(),
+  interruptedRunIds: z57.array(z57.guid())
 });
-var caseBulkDeleteResponseSchema = z56.object({
-  deletedCount: z56.number(),
-  interruptedRunIds: z56.array(z56.guid())
+var caseBulkDeleteResponseSchema = z57.object({
+  deletedCount: z57.number(),
+  interruptedRunIds: z57.array(z57.guid())
 });
-var caseBulkReprocessResponseSchema = z56.object({
-  reprocessedCount: z56.number(),
-  skippedCount: z56.number(),
+var caseBulkReprocessResponseSchema = z57.object({
+  reprocessedCount: z57.number(),
+  skippedCount: z57.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: z56.number().meta({
+  delegatedCount: z57.number().meta({
     deprecated: true,
     description: "Deprecated alias of reprocessedCount, kept for clients redirected from bulk-delegate. Removed on 2026-06-10."
   }).optional(),
-  retriedCount: z56.number().meta({
+  retriedCount: z57.number().meta({
     deprecated: true,
     description: "Deprecated alias of reprocessedCount, kept for clients redirected from bulk-retry. Removed on 2026-06-10."
   }).optional()
 });
-var caseBulkStatusUpdateResponseSchema = z56.object({
-  updatedCount: z56.number(),
-  skippedCount: z56.number(),
-  interruptedRunIds: z56.array(z56.guid())
-});
-var deleteQueueResponseSchema = z56.object({
-  success: z56.boolean(),
-  deleted_case_count: z56.number(),
-  interrupted_run_ids: z56.array(z56.guid())
-});
-var caseClearQueueResponseSchema = z56.object({
-  success: z56.boolean(),
-  deletedCount: z56.number(),
-  interruptedRunIds: z56.array(z56.guid())
-});
-var caseQueueSchema = z56.object({
-  id: z56.guid(),
-  name: z56.string(),
-  description: z56.string().nullable(),
-  folder_id: z56.guid().nullable(),
-  created_at: z56.string(),
+var caseBulkStatusUpdateResponseSchema = z57.object({
+  updatedCount: z57.number(),
+  skippedCount: z57.number(),
+  interruptedRunIds: z57.array(z57.guid())
+});
+var deleteQueueResponseSchema = z57.object({
+  success: z57.boolean(),
+  deleted_case_count: z57.number(),
+  interrupted_run_ids: z57.array(z57.guid())
+});
+var caseClearQueueResponseSchema = z57.object({
+  success: z57.boolean(),
+  deletedCount: z57.number(),
+  interruptedRunIds: z57.array(z57.guid())
+});
+var caseQueueSchema = z57.object({
+  id: z57.guid(),
+  name: z57.string(),
+  description: z57.string().nullable(),
+  folder_id: z57.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: z57.guid().nullable().optional(),
+  created_at: z57.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: z56.boolean()
+  has_approvals: z57.boolean()
 });
-var caseQueuesResponseSchema = z56.object({
-  queues: z56.array(caseQueueSchema),
-  total: z56.number(),
-  limit: z56.number(),
-  offset: z56.number()
+var caseQueuesResponseSchema = z57.object({
+  queues: z57.array(caseQueueSchema),
+  total: z57.number(),
+  limit: z57.number(),
+  offset: z57.number()
 });
-var caseGetQueueResponseSchema = z56.object({
+var caseGetQueueResponseSchema = z57.object({
   queue: caseQueueSchema
 });
-var caseCreateQueueResponseSchema = z56.object({
+var caseCreateQueueResponseSchema = z57.object({
   queue: caseQueueSchema
 });
-var caseUpdateQueueResponseSchema = z56.object({
+var caseUpdateQueueResponseSchema = z57.object({
   queue: caseQueueSchema
 });
-var caseQueueAgentProblemSchema = z56.enum([
+var caseQueueAgentProblemSchema = z57.enum([
   "multiple_triggers",
   "producer_consumer_mix"
 ]);
-var queueAgentProducerSchema = z56.object({
-  agent_id: z56.guid(),
-  agent_name: z56.string(),
-  case_trigger_enabled: z56.boolean(),
-  case_trigger_queue_name: z56.string().nullable(),
-  problems: z56.array(caseQueueAgentProblemSchema)
-});
-var queueAgentConsumerSchema = z56.object({
-  agent_id: z56.guid(),
-  agent_name: z56.string(),
-  case_trigger_enabled: z56.boolean(),
-  is_handover_target: z56.boolean(),
-  problems: z56.array(caseQueueAgentProblemSchema),
+var queueAgentProducerSchema = z57.object({
+  agent_id: z57.guid(),
+  agent_name: z57.string(),
+  case_trigger_enabled: z57.boolean(),
+  case_trigger_queue_name: z57.string().nullable(),
+  problems: z57.array(caseQueueAgentProblemSchema)
+});
+var queueAgentConsumerSchema = z57.object({
+  agent_id: z57.guid(),
+  agent_name: z57.string(),
+  case_trigger_enabled: z57.boolean(),
+  is_handover_target: z57.boolean(),
+  problems: z57.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: z56.int().nonnegative().optional(),
+  concurrency_limit: z57.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: z56.boolean().optional()
-});
-var queueAgentsResponseSchema = z56.object({
-  queue_name: z56.string(),
-  producers: z56.array(queueAgentProducerSchema),
-  consumers: z56.array(queueAgentConsumerSchema)
-});
-var exportCasesResponseSchema = z56.object({
-  version: z56.number(),
-  queue_name: z56.string(),
-  exported_at: z56.string(),
-  cases: z56.array(
-    z56.object({
-      title: z56.string(),
-      data: z56.string().optional()
+  at_concurrency_limit: z57.boolean().optional()
+});
+var queueAgentsResponseSchema = z57.object({
+  queue_name: z57.string(),
+  producers: z57.array(queueAgentProducerSchema),
+  consumers: z57.array(queueAgentConsumerSchema)
+});
+var exportCasesResponseSchema = z57.object({
+  version: z57.number(),
+  queue_name: z57.string(),
+  exported_at: z57.string(),
+  cases: z57.array(
+    z57.object({
+      title: z57.string(),
+      data: z57.string().optional()
     })
   )
 });
-var importCasesResponseSchema = z56.object({
-  imported_count: z56.number()
+var importCasesResponseSchema = z57.object({
+  imported_count: z57.number()
 });
-var batchQueueStatsResponseSchema = z56.object({
-  stats: z56.record(z56.guid(), casesStatsSchema)
+var batchQueueStatsResponseSchema = z57.object({
+  stats: z57.record(z57.guid(), casesStatsSchema)
 });
-var batchQueueAgentsResponseSchema = z56.object({
-  agents: z56.record(
-    z56.guid(),
-    z56.object({
-      producers: z56.array(queueAgentProducerSchema),
-      consumers: z56.array(queueAgentConsumerSchema)
+var batchQueueAgentsResponseSchema = z57.object({
+  agents: z57.record(
+    z57.guid(),
+    z57.object({
+      producers: z57.array(queueAgentProducerSchema),
+      consumers: z57.array(queueAgentConsumerSchema)
     })
   )
 });
-var createTeamInviteLinkRequestSchema = z57.object({
-  frontendUrl: z57.url()
+var createTeamInviteLinkRequestSchema = z58.object({
+  frontendUrl: z58.url()
 });
-var getTeamInviteLinkQuerySchema = z57.object({
-  frontendUrl: z57.url()
+var getTeamInviteLinkQuerySchema = z58.object({
+  frontendUrl: z58.url()
 });
-var teamInviteLinkCreatorSchema = z57.object({
-  id: z57.guid(),
-  name: z57.string().nullable(),
-  email: z57.email()
+var teamInviteLinkCreatorSchema = z58.object({
+  id: z58.guid(),
+  name: z58.string().nullable(),
+  email: z58.email()
 });
-var teamInviteLinkSchema = z57.object({
-  id: z57.guid(),
-  url: z57.url().optional(),
-  createdAt: z57.string(),
+var teamInviteLinkSchema = z58.object({
+  id: z58.guid(),
+  url: z58.url().optional(),
+  createdAt: z58.string(),
   createdBy: teamInviteLinkCreatorSchema
 });
-var getTeamInviteLinkResponseSchema = z57.object({
-  hasLink: z57.boolean(),
+var getTeamInviteLinkResponseSchema = z58.object({
+  hasLink: z58.boolean(),
   link: teamInviteLinkSchema.optional()
 });
-var joinLinkInfoResponseSchema = z57.object({
-  valid: z57.boolean(),
-  teamName: z57.string().optional(),
-  teamId: z57.guid().optional(),
-  reason: z57.enum(["invalid", "expired"]).optional()
+var joinLinkInfoResponseSchema = z58.object({
+  valid: z58.boolean(),
+  teamName: z58.string().optional(),
+  teamId: z58.guid().optional(),
+  reason: z58.enum(["invalid", "expired"]).optional()
 });
-var acceptJoinLinkResponseSchema = z57.object({
-  success: z57.boolean(),
-  teamId: z57.guid()
+var acceptJoinLinkResponseSchema = z58.object({
+  success: z58.boolean(),
+  teamId: z58.guid()
 });
-var createClarityProcessInviteLinkRequestSchema = z58.object({
-  frontendUrl: z58.url()
+var createClarityProcessInviteLinkRequestSchema = z59.object({
+  frontendUrl: z59.url()
 });
 var clarityProcessInviteLinkSchema = teamInviteLinkSchema;
-var getClarityProcessInviteLinkResponseSchema = z58.object({
-  hasLink: z58.boolean(),
+var getClarityProcessInviteLinkResponseSchema = z59.object({
+  hasLink: z59.boolean(),
   link: clarityProcessInviteLinkSchema.optional()
 });
-var clarityJoinLinkInfoResponseSchema = z58.object({
-  valid: z58.boolean(),
-  processName: z58.string().optional(),
-  processId: z58.guid().optional(),
-  teamId: z58.guid().optional(),
-  reason: z58.enum(["invalid", "expired"]).optional()
-});
-var acceptClarityJoinLinkResponseSchema = z58.object({
-  success: z58.boolean(),
-  processId: z58.guid()
-});
-var credentialPreviewSchema = z59.object({
-  id: z59.guid().describe("Credential ID"),
-  domain: z59.string().describe("Domain for the credential"),
-  username: z59.string().nullable().describe("Username (if any)"),
-  hasEnabledTOTP: z59.boolean().describe("Whether TOTP is enabled"),
-  hasPassword: z59.boolean().describe("Whether a password is stored"),
-  user_id: z59.string().nullable().describe("Owner user id; null when shared with the team")
-});
-var otpResponseSchema = z59.object({
-  code: z59.string().describe("The TOTP code"),
-  expiresAt: z59.number().describe("Expiration timestamp in milliseconds")
-});
-var encryptedDataSchema = z59.object({
-  encrypted_data: z59.string().describe("Base64-encoded encrypted data"),
-  key_version: z59.string().describe("KMS key version or 'base64' for dev")
-});
-var credentialDetailSchema = z59.object({
-  domain: z59.string().describe("Domain for the credential"),
-  username: z59.string().nullable().describe("Username (if any)"),
+var clarityJoinLinkInfoResponseSchema = z59.object({
+  valid: z59.boolean(),
+  processName: z59.string().optional(),
+  processId: z59.guid().optional(),
+  teamId: z59.guid().optional(),
+  reason: z59.enum(["invalid", "expired"]).optional()
+});
+var acceptClarityJoinLinkResponseSchema = z59.object({
+  success: z59.boolean(),
+  processId: z59.guid()
+});
+var credentialPreviewSchema = z60.object({
+  id: z60.guid().describe("Credential ID"),
+  domain: z60.string().describe("Domain for the credential"),
+  username: z60.string().nullable().describe("Username (if any)"),
+  hasEnabledTOTP: z60.boolean().describe("Whether TOTP is enabled"),
+  hasPassword: z60.boolean().describe("Whether a password is stored"),
+  user_id: z60.string().nullable().describe("Owner user id; null when shared with the team")
+});
+var otpResponseSchema = z60.object({
+  code: z60.string().describe("The TOTP code"),
+  expiresAt: z60.number().describe("Expiration timestamp in milliseconds")
+});
+var encryptedDataSchema = z60.object({
+  encrypted_data: z60.string().describe("Base64-encoded encrypted data"),
+  key_version: z60.string().describe("KMS key version or 'base64' for dev")
+});
+var credentialDetailSchema = z60.object({
+  domain: z60.string().describe("Domain for the credential"),
+  username: z60.string().nullable().describe("Username (if any)"),
   password: encryptedDataSchema.nullable().describe("Encrypted password data")
 });
 var FEATURE_FLAG_CATALOGUE = {
@@ -8945,6 +8996,11 @@ var FEATURE_FLAG_CATALOGUE = {
     defaultValue: false,
     description: "Enables the Clarity meeting notetaker (Recall.ai bot). When disabled, the 'Meeting Notetaker' option is hidden in the Add Content menu and the POST /clarity/processes/:id/captures/meeting invite route returns 404; the Recall webhook callback is unaffected. Off-by-default for staged rollout."
   },
+  CLARITY_SIGNAVIO_SWIMLANES_EXPORT: {
+    key: "clarity_signavio_swimlanes_export",
+    defaultValue: false,
+    description: "Enables prompt-driven Clarity to SAP Signavio export conventions that convert performer metadata into BPMN swimlanes and lay diagrams out horizontally. Off-by-default for staged validation."
+  },
   CLARITY_SOURCES_UI: {
     key: "clarity_sources_ui",
     defaultValue: false,
@@ -9068,160 +9124,160 @@ function coerceFlagValue(value) {
 }
 __name(coerceFlagValue, "coerceFlagValue");
 __name2(coerceFlagValue, "coerceFlagValue");
-var teamFileItemSchema = z60.object({
-  id: z60.string(),
-  name: z60.string(),
-  path: z60.string(),
-  created_at: z60.string().optional(),
-  updated_at: z60.string().optional(),
-  metadata: z60.object({
-    mimetype: z60.string().optional(),
-    size: z60.number().optional()
+var teamFileItemSchema = z61.object({
+  id: z61.string(),
+  name: z61.string(),
+  path: z61.string(),
+  created_at: z61.string().optional(),
+  updated_at: z61.string().optional(),
+  metadata: z61.object({
+    mimetype: z61.string().optional(),
+    size: z61.number().optional()
   }).nullable().optional()
 });
-var listTeamFilesResponseSchema = z60.object({
-  files: z60.array(teamFileItemSchema)
-});
-var createTeamFileUploadUrlBodySchema = z60.object({
-  fileName: z60.string().min(1),
-  contentType: z60.string().min(1)
-});
-var createTeamFileUploadUrlResponseSchema = z60.object({
-  signedUrl: z60.url(),
-  expiresAt: z60.iso.datetime(),
-  filePath: z60.string()
-});
-var renameTeamFileBodySchema = z60.object({
-  relativePath: z60.string().min(1),
-  newFilenameOnly: z60.string().min(1)
-});
-var teamFileSuccessResponseSchema = z60.object({
-  success: z60.boolean()
-});
-var teamFileDownloadUrlResponseSchema = z60.object({
-  url: z60.url(),
-  expiresAt: z60.iso.datetime()
-});
-var teamFileContentResponseSchema = z60.object({
-  content: z60.string(),
-  path: z60.string(),
-  contentType: z60.string().optional()
-});
-var updateTeamFileContentBodySchema = z60.object({
-  content: z60.string()
-});
-var globalAdminApiSchema = z61.object({
-  id: z61.guid(),
-  email: z61.string(),
-  userId: z61.guid(),
-  userName: z61.string().nullable(),
-  addedByUserId: z61.guid().nullable(),
-  createdAt: z61.string()
-});
-var globalAdminListResponseSchema = z61.object({
-  admins: z61.array(globalAdminApiSchema)
-});
-var globalAdminSearchResponseSchema = z61.object({
-  users: z61.array(
-    z61.object({
-      id: z61.guid(),
-      name: z61.string().nullable(),
-      email: z61.string(),
-      createdAt: z61.string().nullable()
+var listTeamFilesResponseSchema = z61.object({
+  files: z61.array(teamFileItemSchema)
+});
+var createTeamFileUploadUrlBodySchema = z61.object({
+  fileName: z61.string().min(1),
+  contentType: z61.string().min(1)
+});
+var createTeamFileUploadUrlResponseSchema = z61.object({
+  signedUrl: z61.url(),
+  expiresAt: z61.iso.datetime(),
+  filePath: z61.string()
+});
+var renameTeamFileBodySchema = z61.object({
+  relativePath: z61.string().min(1),
+  newFilenameOnly: z61.string().min(1)
+});
+var teamFileSuccessResponseSchema = z61.object({
+  success: z61.boolean()
+});
+var teamFileDownloadUrlResponseSchema = z61.object({
+  url: z61.url(),
+  expiresAt: z61.iso.datetime()
+});
+var teamFileContentResponseSchema = z61.object({
+  content: z61.string(),
+  path: z61.string(),
+  contentType: z61.string().optional()
+});
+var updateTeamFileContentBodySchema = z61.object({
+  content: z61.string()
+});
+var globalAdminApiSchema = z62.object({
+  id: z62.guid(),
+  email: z62.string(),
+  userId: z62.guid(),
+  userName: z62.string().nullable(),
+  addedByUserId: z62.guid().nullable(),
+  createdAt: z62.string()
+});
+var globalAdminListResponseSchema = z62.object({
+  admins: z62.array(globalAdminApiSchema)
+});
+var globalAdminSearchResponseSchema = z62.object({
+  users: z62.array(
+    z62.object({
+      id: z62.guid(),
+      name: z62.string().nullable(),
+      email: z62.string(),
+      createdAt: z62.string().nullable()
     })
   )
 });
-var globalAdminCreateRequestSchema = z61.object({
-  userId: z61.guid()
+var globalAdminCreateRequestSchema = z62.object({
+  userId: z62.guid()
 });
-var globalAdminCreateResponseSchema = z61.object({
+var globalAdminCreateResponseSchema = z62.object({
   admin: globalAdminApiSchema
 });
-var globalAdminDeleteResponseSchema = z61.object({
-  success: z61.literal(true)
+var globalAdminDeleteResponseSchema = z62.object({
+  success: z62.literal(true)
 });
-var adminAccessCheckResponseSchema = z61.object({
-  isGlobalAdmin: z61.boolean()
+var adminAccessCheckResponseSchema = z62.object({
+  isGlobalAdmin: z62.boolean()
 });
 var JOB_LIST_SORT_COLUMNS = ["created_at"];
-var jobListSortColumnSchema = z62.enum(JOB_LIST_SORT_COLUMNS);
-var jobListIssueSeveritySchema = z62.enum(
+var jobListSortColumnSchema = z63.enum(JOB_LIST_SORT_COLUMNS);
+var jobListIssueSeveritySchema = z63.enum(
   ALL_EVALUATION_RUBRIC_SEVERITIES
 );
-var jobListItemSchema = z62.object({
-  id: z62.guid(),
-  created_at: z62.coerce.date(),
-  updated_at: z62.coerce.date(),
-  started_at: z62.coerce.date().nullable(),
-  completed_at: z62.coerce.date().nullable(),
+var jobListItemSchema = z63.object({
+  id: z63.guid(),
+  created_at: z63.coerce.date(),
+  updated_at: z63.coerce.date(),
+  started_at: z63.coerce.date().nullable(),
+  completed_at: z63.coerce.date().nullable(),
   status: agentRunStatusSchema,
-  source: z62.string().nullable(),
-  title: z62.string(),
-  run_number: z62.number(),
+  source: z63.string().nullable(),
+  title: z63.string(),
+  run_number: z63.number(),
   // Agent info
-  agent_id: z62.guid(),
-  agent_name: z62.string(),
-  build_id: z62.guid(),
+  agent_id: z63.guid(),
+  agent_name: z63.string(),
+  build_id: z63.guid(),
   // User info
-  user_id: z62.guid().nullable(),
+  user_id: z63.guid().nullable(),
   // Case info
-  case_queue_item_id: z62.guid().nullable(),
-  case_queue_id: z62.guid().nullable(),
-  case_queue_name: z62.string().nullable(),
-  case_title: z62.string().nullable(),
-  postponed_to: z62.coerce.date().nullable(),
-  submitted_prompt_count: z62.number().int().min(0),
+  case_queue_item_id: z63.guid().nullable(),
+  case_queue_id: z63.guid().nullable(),
+  case_queue_name: z63.string().nullable(),
+  case_title: z63.string().nullable(),
+  postponed_to: z63.coerce.date().nullable(),
+  submitted_prompt_count: z63.number().int().min(0),
   eval_summaries: evalSummarySchema.nullable().optional()
 });
-var jobListResponseSchema = z62.object({
-  data: z62.array(jobListItemSchema),
-  total: z62.number()
+var jobListResponseSchema = z63.object({
+  data: z63.array(jobListItemSchema),
+  total: z63.number()
 });
-var jobFilterOptionsSchema = z62.object({
-  agents: z62.array(
-    z62.object({
-      id: z62.string(),
-      name: z62.string(),
-      folder_id: z62.string().nullable()
+var jobFilterOptionsSchema = z63.object({
+  agents: z63.array(
+    z63.object({
+      id: z63.string(),
+      name: z63.string(),
+      folder_id: z63.string().nullable()
     })
   ),
-  folders: z62.array(
-    z62.object({
-      id: z62.string(),
-      name: z62.string(),
-      parent_folder_id: z62.string().nullable()
+  folders: z63.array(
+    z63.object({
+      id: z63.string(),
+      name: z63.string(),
+      parent_folder_id: z63.string().nullable()
     })
   ),
-  users: z62.array(
-    z62.object({
-      id: z62.string(),
-      name: z62.string().nullable(),
-      email: z62.string()
+  users: z63.array(
+    z63.object({
+      id: z63.string(),
+      name: z63.string().nullable(),
+      email: z63.string()
     })
   ),
-  caseQueues: z62.array(z62.object({ id: z62.string(), name: z62.string() }))
-});
-var mcpStepSchema = z63.object({
-  tool: z63.string().describe("MCP tool name (e.g., click, fill, navigate_page)"),
-  params: z63.record(z63.string(), z63.unknown()).describe("Tool-specific parameters"),
-  fallbackSelectors: z63.array(z63.string()).optional().describe("Alternative CSS selectors if primary fails"),
-  description: z63.string().optional().describe("Human-readable step description"),
-  screenshot: z63.string().optional().describe("Base64 screenshot at this step for visual context"),
-  snapshot: z63.string().optional().describe("DOM snapshot in accessibility tree format at this step"),
-  framePath: z63.array(z63.number()).optional().describe(
+  caseQueues: z63.array(z63.object({ id: z63.string(), name: z63.string() }))
+});
+var mcpStepSchema = z64.object({
+  tool: z64.string().describe("MCP tool name (e.g., click, fill, navigate_page)"),
+  params: z64.record(z64.string(), z64.unknown()).describe("Tool-specific parameters"),
+  fallbackSelectors: z64.array(z64.string()).optional().describe("Alternative CSS selectors if primary fails"),
+  description: z64.string().optional().describe("Human-readable step description"),
+  screenshot: z64.string().optional().describe("Base64 screenshot at this step for visual context"),
+  snapshot: z64.string().optional().describe("DOM snapshot in accessibility tree format at this step"),
+  framePath: z64.array(z64.number()).optional().describe(
     "Index-based path to the target iframe (e.g., [0] for first child iframe, [1, 0] for nested)"
   )
 });
-var mcpWorkflowSchema = z63.object({
-  name: z63.string(),
-  startUrl: z63.string(),
-  viewport: z63.object({
-    width: z63.number(),
-    height: z63.number()
+var mcpWorkflowSchema = z64.object({
+  name: z64.string(),
+  startUrl: z64.string(),
+  viewport: z64.object({
+    width: z64.number(),
+    height: z64.number()
   }),
-  steps: z63.array(mcpStepSchema)
+  steps: z64.array(mcpStepSchema)
 });
-var MCP_WORKFLOW_JSON_SCHEMA = z63.toJSONSchema(mcpWorkflowSchema, {
+var MCP_WORKFLOW_JSON_SCHEMA = z64.toJSONSchema(mcpWorkflowSchema, {
   reused: "inline"
 });
 var MCP_WORKFLOW_SCHEMA_DOCS = JSON.stringify(
@@ -9230,52 +9286,52 @@ var MCP_WORKFLOW_SCHEMA_DOCS = JSON.stringify(
   2
 );
 var ORG_BROWSER_CONFIG_VERSION = 1;
-var organizationBrowserConfigDataSchema = z64.object({
+var organizationBrowserConfigDataSchema = z65.object({
   browserProvider: BrowserProviderTypeSchema.nullable(),
   dataResidency: DataResidencySchema.nullable(),
   dataHandling: DataHandlingSchema.nullable(),
-  enforced: z64.boolean()
+  enforced: z65.boolean()
 });
-var organizationBrowserConfigSchema = z64.object({
-  version: z64.literal(ORG_BROWSER_CONFIG_VERSION),
+var organizationBrowserConfigSchema = z65.object({
+  version: z65.literal(ORG_BROWSER_CONFIG_VERSION),
   data: organizationBrowserConfigDataSchema
 });
-var organizationBrowserSettingsSchema = z64.object({
-  organizationId: z64.guid(),
+var organizationBrowserSettingsSchema = z65.object({
+  organizationId: z65.guid(),
   browserProvider: BrowserProviderTypeSchema.nullable(),
   dataResidency: DataResidencySchema.nullable(),
   dataHandling: DataHandlingSchema.nullable(),
-  enforced: z64.boolean(),
-  createdAt: z64.string(),
-  updatedAt: z64.string()
+  enforced: z65.boolean(),
+  createdAt: z65.string(),
+  updatedAt: z65.string()
 });
-var getOrganizationBrowserSettingsResponseSchema = z64.object({
+var getOrganizationBrowserSettingsResponseSchema = z65.object({
   settings: organizationBrowserSettingsSchema.nullable()
 });
-var updateOrganizationBrowserSettingsRequestSchema = z64.object({
+var updateOrganizationBrowserSettingsRequestSchema = z65.object({
   browserProvider: BrowserProviderTypeSchema.nullable().optional(),
   dataResidency: DataResidencySchema.nullable().optional(),
   dataHandling: DataHandlingSchema.nullable().optional(),
-  enforced: z64.boolean().optional()
+  enforced: z65.boolean().optional()
 });
-var updateOrganizationBrowserSettingsResponseSchema = z64.object({
+var updateOrganizationBrowserSettingsResponseSchema = z65.object({
   settings: organizationBrowserSettingsSchema
 });
-var catalogPluginSchema = z65.object({
-  name: z65.string().describe("Identifier to pass in the build's plugins array."),
+var catalogPluginSchema = z66.object({
+  name: z66.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: z65.string()
+  description: z66.string()
 });
-var pluginCatalogResponseSchema = z65.object({
-  plugins: z65.array(catalogPluginSchema)
+var pluginCatalogResponseSchema = z66.object({
+  plugins: z66.array(catalogPluginSchema)
 });
-var limitValueSchema = z66.union([
-  z66.number().int().nonnegative(),
-  z66.literal("unlimited")
+var limitValueSchema = z67.union([
+  z67.number().int().nonnegative(),
+  z67.literal("unlimited")
 ]);
-var runCountingModeSchema = z66.enum(["monthly", "lifetime"]);
+var runCountingModeSchema = z67.enum(["monthly", "lifetime"]);
 function addDuplicateKeyIssues({
   ctx,
   items,
@@ -9287,7 +9343,7 @@ function addDuplicateKeyIssues({
     const key = keyFor(item);
     if (seen.has(key)) {
       ctx.addIssue({
-        code: z66.ZodIssueCode.custom,
+        code: z67.ZodIssueCode.custom,
         message: `Duplicate Product Access grant key: ${key}`,
         path: [...path, index]
       });
@@ -9298,34 +9354,34 @@ function addDuplicateKeyIssues({
 }
 __name(addDuplicateKeyIssues, "addDuplicateKeyIssues");
 __name2(addDuplicateKeyIssues, "addDuplicateKeyIssues");
-var productAccessOwnerSchema = z66.discriminatedUnion("type", [
-  z66.object({
-    type: z66.literal("organization"),
-    organizationId: z66.guid()
+var productAccessOwnerSchema = z67.discriminatedUnion("type", [
+  z67.object({
+    type: z67.literal("organization"),
+    organizationId: z67.guid()
   }),
-  z66.object({
-    type: z66.literal("team"),
-    teamId: z66.guid(),
-    organizationId: z66.guid().nullable()
+  z67.object({
+    type: z67.literal("team"),
+    teamId: z67.guid(),
+    organizationId: z67.guid().nullable()
   })
 ]);
-var productAccessGrantSetSchema = z66.object({
-  products: z66.array(
-    z66.object({
-      productKey: z66.enum(PRODUCT_KEYS),
-      enabled: z66.boolean()
+var productAccessGrantSetSchema = z67.object({
+  products: z67.array(
+    z67.object({
+      productKey: z67.enum(PRODUCT_KEYS),
+      enabled: z67.boolean()
     })
   ),
-  capabilities: z66.array(
-    z66.object({
-      capabilityKey: z66.enum(PRODUCT_ACCESS_CAPABILITY_KEYS),
-      enabled: z66.boolean()
+  capabilities: z67.array(
+    z67.object({
+      capabilityKey: z67.enum(PRODUCT_ACCESS_CAPABILITY_KEYS),
+      enabled: z67.boolean()
     })
   ),
-  limits: z66.array(
-    z66.object({
-      productKey: z66.enum(PRODUCT_KEYS),
-      limitKey: z66.enum(ENTITLEMENT_LIMIT_KEYS),
+  limits: z67.array(
+    z67.object({
+      productKey: z67.enum(PRODUCT_KEYS),
+      limitKey: z67.enum(ENTITLEMENT_LIMIT_KEYS),
       limitValue: limitValueSchema,
       countingMode: runCountingModeSchema.nullable()
     })
@@ -9350,51 +9406,51 @@ var productAccessGrantSetSchema = z66.object({
     path: ["limits"]
   });
 });
-var productAccessSnapshotSchema = z66.object({
-  products: z66.array(
-    z66.object({
-      productKey: z66.enum(PRODUCT_KEYS),
-      enabled: z66.boolean()
+var productAccessSnapshotSchema = z67.object({
+  products: z67.array(
+    z67.object({
+      productKey: z67.enum(PRODUCT_KEYS),
+      enabled: z67.boolean()
     })
   ),
-  capabilities: z66.array(
-    z66.object({
-      capabilityKey: z66.enum(PRODUCT_ACCESS_CAPABILITY_KEYS),
-      productKey: z66.enum(PRODUCT_KEYS),
-      enabled: z66.boolean()
+  capabilities: z67.array(
+    z67.object({
+      capabilityKey: z67.enum(PRODUCT_ACCESS_CAPABILITY_KEYS),
+      productKey: z67.enum(PRODUCT_KEYS),
+      enabled: z67.boolean()
     })
   ),
-  limits: z66.array(
-    z66.object({
-      limitKey: z66.enum(ENTITLEMENT_LIMIT_KEYS),
-      productKey: z66.enum(PRODUCT_KEYS),
+  limits: z67.array(
+    z67.object({
+      limitKey: z67.enum(ENTITLEMENT_LIMIT_KEYS),
+      productKey: z67.enum(PRODUCT_KEYS),
       limitValue: limitValueSchema,
       countingMode: runCountingModeSchema.nullable(),
-      label: z66.literal("per_team")
+      label: z67.literal("per_team")
     })
   )
 });
-var billingPlanSchema = z66.object({
-  planVersionId: z66.string(),
-  planName: z66.string(),
-  basePlan: z66.enum(["free", "pro", "enterprise"])
+var billingPlanSchema = z67.object({
+  planVersionId: z67.string(),
+  planName: z67.string(),
+  basePlan: z67.enum(["free", "pro", "enterprise"])
 });
-var inheritedFromSchema = z66.discriminatedUnion("type", [
-  z66.object({
-    type: z66.literal("organization"),
-    organizationId: z66.guid()
+var inheritedFromSchema = z67.discriminatedUnion("type", [
+  z67.object({
+    type: z67.literal("organization"),
+    organizationId: z67.guid()
   }),
-  z66.object({
-    type: z66.literal("team_subscription"),
-    planVersionId: z66.string()
+  z67.object({
+    type: z67.literal("team_subscription"),
+    planVersionId: z67.string()
   })
 ]);
-var productAccessReadResponseSchema = z66.object({
+var productAccessReadResponseSchema = z67.object({
   owner: productAccessOwnerSchema,
-  source: z66.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
-  accessRevision: z66.string().min(1),
+  source: z67.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
+  accessRevision: z67.string().min(1),
   displayPreset: displayPresetSchema,
-  hasExplicitTeamAccess: z66.boolean(),
+  hasExplicitTeamAccess: z67.boolean(),
   inheritedFrom: inheritedFromSchema.nullable(),
   billingPlan: billingPlanSchema.nullable(),
   grants: productAccessSnapshotSchema,
@@ -9402,67 +9458,67 @@ var productAccessReadResponseSchema = z66.object({
 }).superRefine((value, ctx) => {
   if (value.owner.type === "team" && value.source === "organization" && value.inheritedFrom?.type !== "organization") {
     ctx.addIssue({
-      code: z66.ZodIssueCode.custom,
+      code: z67.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: z66.ZodIssueCode.custom,
+      code: z67.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: z66.ZodIssueCode.custom,
+      code: z67.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: z66.ZodIssueCode.custom,
+      code: z67.ZodIssueCode.custom,
       message: "billingPlan must be null for organization Product Access",
       path: ["billingPlan"]
     });
   }
   if (value.owner.type === "organization" && value.source !== "organization") {
     ctx.addIssue({
-      code: z66.ZodIssueCode.custom,
+      code: z67.ZodIssueCode.custom,
       message: "organization Product Access source must be organization",
       path: ["source"]
     });
   }
   if (value.owner.type === "organization" && value.inheritedFrom !== null) {
     ctx.addIssue({
-      code: z66.ZodIssueCode.custom,
+      code: z67.ZodIssueCode.custom,
       message: "inheritedFrom must be null for organization Product Access",
       path: ["inheritedFrom"]
     });
   }
 });
-var productAccessImpactRequestSchema = z66.object({
+var productAccessImpactRequestSchema = z67.object({
   proposedGrants: productAccessGrantSetSchema
 });
-var productAccessWriteRequestSchema = z66.object({
+var productAccessWriteRequestSchema = z67.object({
   proposedGrants: productAccessGrantSetSchema,
-  accessRevision: z66.string().min(1),
-  impactFingerprint: z66.string().min(1).optional()
-});
-var productAccessTeamResetRequestSchema = z66.object({
-  accessRevision: z66.string().min(1),
-  impactFingerprint: z66.string().min(1).optional()
-});
-var productAccessChangeSummarySchema = z66.object({
-  addedProducts: z66.array(z66.enum(PRODUCT_KEYS)),
-  removedProducts: z66.array(z66.enum(PRODUCT_KEYS)),
-  addedCapabilities: z66.array(z66.enum(PRODUCT_ACCESS_CAPABILITY_KEYS)),
-  removedCapabilities: z66.array(z66.enum(PRODUCT_ACCESS_CAPABILITY_KEYS)),
-  limitChanges: z66.array(
-    z66.object({
-      limitKey: z66.enum(ENTITLEMENT_LIMIT_KEYS),
+  accessRevision: z67.string().min(1),
+  impactFingerprint: z67.string().min(1).optional()
+});
+var productAccessTeamResetRequestSchema = z67.object({
+  accessRevision: z67.string().min(1),
+  impactFingerprint: z67.string().min(1).optional()
+});
+var productAccessChangeSummarySchema = z67.object({
+  addedProducts: z67.array(z67.enum(PRODUCT_KEYS)),
+  removedProducts: z67.array(z67.enum(PRODUCT_KEYS)),
+  addedCapabilities: z67.array(z67.enum(PRODUCT_ACCESS_CAPABILITY_KEYS)),
+  removedCapabilities: z67.array(z67.enum(PRODUCT_ACCESS_CAPABILITY_KEYS)),
+  limitChanges: z67.array(
+    z67.object({
+      limitKey: z67.enum(ENTITLEMENT_LIMIT_KEYS),
       currentValue: limitValueSchema,
       currentCountingMode: runCountingModeSchema.nullable(),
       proposedValue: limitValueSchema,
@@ -9470,61 +9526,61 @@ var productAccessChangeSummarySchema = z66.object({
     })
   )
 });
-var productAccessImpactResponseSchema = z66.object({
+var productAccessImpactResponseSchema = z67.object({
   owner: productAccessOwnerSchema,
-  impactFingerprint: z66.string().min(1),
-  affectedTeamCount: z66.number().int().nonnegative(),
-  affectedTeamsTruncated: z66.boolean(),
+  impactFingerprint: z67.string().min(1),
+  affectedTeamCount: z67.number().int().nonnegative(),
+  affectedTeamsTruncated: z67.boolean(),
   changes: productAccessChangeSummarySchema,
-  sideEffects: z66.object({
-    automationWillPause: z66.boolean(),
-    clarityWillHide: z66.boolean()
+  sideEffects: z67.object({
+    automationWillPause: z67.boolean(),
+    clarityWillHide: z67.boolean()
   }),
-  affectedTeamsPreview: z66.array(
-    z66.object({
-      teamId: z66.guid(),
-      teamName: z66.string(),
-      source: z66.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
+  affectedTeamsPreview: z67.array(
+    z67.object({
+      teamId: z67.guid(),
+      teamName: z67.string(),
+      source: z67.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
       changes: productAccessChangeSummarySchema
     })
   )
 });
-var publicProfileSchema = z67.object({
-  id: z67.guid(),
-  name: z67.string().nullable(),
-  email: z67.email(),
-  teamId: z67.guid().nullable()
+var publicProfileSchema = z68.object({
+  id: z68.guid(),
+  name: z68.string().nullable(),
+  email: z68.email(),
+  teamId: z68.guid().nullable()
 });
-var publicProfileResponseSchema = z67.object({
+var publicProfileResponseSchema = z68.object({
   profile: publicProfileSchema
 });
-var elementSelectorsSchema = z68.object({
-  css: z68.string().optional(),
-  cssPath: z68.string().optional(),
-  xpath: z68.string().optional(),
-  testId: z68.string().optional(),
-  ariaSelector: z68.string().optional(),
-  text: z68.string().optional()
+var elementSelectorsSchema = z69.object({
+  css: z69.string().optional(),
+  cssPath: z69.string().optional(),
+  xpath: z69.string().optional(),
+  testId: z69.string().optional(),
+  ariaSelector: z69.string().optional(),
+  text: z69.string().optional()
 });
-var elementInfoSchema = z68.object({
-  uid: z68.string().optional(),
+var elementInfoSchema = z69.object({
+  uid: z69.string().optional(),
   selectors: elementSelectorsSchema,
-  tagName: z68.string(),
-  textContent: z68.string().optional(),
-  ariaLabel: z68.string().optional(),
-  computedRole: z68.string().optional(),
-  attributes: z68.record(z68.string(), z68.string()).optional(),
-  framePath: z68.array(z68.number()).optional(),
-  frameUrl: z68.string().optional()
-});
-var recordedEventSchema = z68.looseObject({
-  id: z68.string(),
-  type: z68.string(),
-  timestamp: z68.number(),
-  url: z68.string(),
-  tabId: z68.number().optional(),
-  frameId: z68.number().optional(),
-  framePath: z68.array(z68.number()).optional(),
+  tagName: z69.string(),
+  textContent: z69.string().optional(),
+  ariaLabel: z69.string().optional(),
+  computedRole: z69.string().optional(),
+  attributes: z69.record(z69.string(), z69.string()).optional(),
+  framePath: z69.array(z69.number()).optional(),
+  frameUrl: z69.string().optional()
+});
+var recordedEventSchema = z69.looseObject({
+  id: z69.string(),
+  type: z69.string(),
+  timestamp: z69.number(),
+  url: z69.string(),
+  tabId: z69.number().optional(),
+  frameId: z69.number().optional(),
+  framePath: z69.array(z69.number()).optional(),
   element: elementInfoSchema.optional()
 });
 var DUVO_CLIENT_HEADER = "x-duvo-client";
@@ -9544,63 +9600,63 @@ function resolveRequestSourceFromClientHeader(header) {
 }
 __name(resolveRequestSourceFromClientHeader, "resolveRequestSourceFromClientHeader");
 __name2(resolveRequestSourceFromClientHeader, "resolveRequestSourceFromClientHeader");
-var RedactedMcpServerConfigSchema = z69.object({
+var RedactedMcpServerConfigSchema = z70.object({
   type: TransportTypeSchema,
   integrationSlug: IntegrationSlugSchema,
-  instanceId: z69.string().nullable()
+  instanceId: z70.string().nullable()
 });
-var ThreadContextMessageSchema = z69.object({
-  role: z69.enum(["user", "assistant"]),
-  content: z69.string()
+var ThreadContextMessageSchema = z70.object({
+  role: z70.enum(["user", "assistant"]),
+  content: z70.string()
 });
-var ChatFileReferenceSchema = z69.object({
-  id: z69.string(),
-  name: z69.string(),
-  mimetype: z69.string(),
-  size: z69.number(),
-  platform: z69.enum(["slack", "teams"]),
-  workspaceId: z69.string(),
-  channelId: z69.string()
-});
-var ResolvedSubAgentSchema = z69.object({
-  agentId: z69.string().uuid(),
-  buildId: z69.string().uuid(),
-  name: z69.string().min(1).max(64).regex(/^[a-z0-9-]+$/).describe(
+var ChatFileReferenceSchema = z70.object({
+  id: z70.string(),
+  name: z70.string(),
+  mimetype: z70.string(),
+  size: z70.number(),
+  platform: z70.enum(["slack", "teams"]),
+  workspaceId: z70.string(),
+  channelId: z70.string()
+});
+var ResolvedSubAgentSchema = z70.object({
+  agentId: z70.string().uuid(),
+  buildId: z70.string().uuid(),
+  name: z70.string().min(1).max(64).regex(/^[a-z0-9-]+$/).describe(
     "Stable slug used as the Claude Code subagent name (kebab-case, \u226464 chars)"
   ),
-  description: z69.string().describe(
+  description: z70.string().describe(
     "Routing description Claude uses to decide when to delegate to this subagent"
   ),
-  prompt: z69.string().describe("System prompt (AOP) for this subagent"),
-  model: z69.string().optional().describe("Optional Claude model identifier override for this subagent"),
-  mcpServers: z69.record(z69.string(), RedactedMcpServerConfigSchema).default({}).describe(
+  prompt: z70.string().describe("System prompt (AOP) for this subagent"),
+  model: z70.string().optional().describe("Optional Claude model identifier override for this subagent"),
+  mcpServers: z70.record(z70.string(), RedactedMcpServerConfigSchema).default({}).describe(
     "Redacted MCP server configs scoped to this subagent. Secrets resolved at execution time."
   )
 });
 var RunConfigSchema = AgentConfigSchema.extend({
-  task: z69.string(),
-  mcpServers: z69.record(z69.string(), RedactedMcpServerConfigSchema),
-  subAgents: z69.array(ResolvedSubAgentSchema).optional().default([]),
-  conversationHistory: z69.array(ThreadContextMessageSchema).optional(),
-  chatFiles: z69.array(ChatFileReferenceSchema).optional(),
+  task: z70.string(),
+  mcpServers: z70.record(z70.string(), RedactedMcpServerConfigSchema),
+  subAgents: z70.array(ResolvedSubAgentSchema).optional().default([]),
+  conversationHistory: z70.array(ThreadContextMessageSchema).optional(),
+  chatFiles: z70.array(ChatFileReferenceSchema).optional(),
   /** IANA timezone (e.g. `"Europe/Prague"`). Consumers should fall back to UTC when absent. */
-  timezone: z69.string().optional(),
+  timezone: z70.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: z69.string().optional()
+  sessionStartedAt: z70.string().optional()
 });
-var StoredRunConfigV0Schema = z69.object({
-  version: z69.literal("v0")
+var StoredRunConfigV0Schema = z70.object({
+  version: z70.literal("v0")
 });
-var StoredRunConfigV1Schema = z69.object({
-  version: z69.literal("v1"),
+var StoredRunConfigV1Schema = z70.object({
+  version: z70.literal("v1"),
   data: RunConfigSchema
 });
-var StoredRunConfigSchema = z69.union([
+var StoredRunConfigSchema = z70.union([
   StoredRunConfigV0Schema,
   StoredRunConfigV1Schema
 ]);
@@ -9619,181 +9675,181 @@ function isRunConfig(config) {
 }
 __name(isRunConfig, "isRunConfig");
 __name2(isRunConfig, "isRunConfig");
-var skillApiSchema = z70.object({
-  id: z70.string(),
-  name: z70.string(),
-  description: z70.string(),
+var skillApiSchema = z71.object({
+  id: z71.string(),
+  name: z71.string(),
+  description: z71.string(),
   // System skills have null team_id.
-  team_id: z70.string().nullable()
-});
-var listSkillsResponseSchema = z70.object({
-  skills: z70.array(skillApiSchema)
-});
-var systemSkillSchema = z70.object({
-  id: z70.string(),
-  name: z70.string(),
-  description: z70.string()
-});
-var listSystemSkillsResponseSchema = z70.object({
-  skills: z70.array(systemSkillSchema)
-});
-var skillFileItemSchema = z70.object({
-  name: z70.string(),
-  path: z70.string(),
-  size: z70.number().optional(),
-  contentType: z70.string().optional(),
-  updatedAt: z70.string().optional()
-});
-var listSkillFilesResponseSchema = z70.object({
-  files: z70.array(skillFileItemSchema)
+  team_id: z71.string().nullable()
 });
-var getSkillFileContentResponseSchema = z70.object({
-  content: z70.string(),
-  path: z70.string(),
-  contentType: z70.string().optional()
-});
-var updateSkillFileBodySchema = z70.object({
-  content: z70.string()
+var listSkillsResponseSchema = z71.object({
+  skills: z71.array(skillApiSchema)
 });
-var updateSkillFileResponseSchema = z70.object({
-  success: z70.boolean(),
-  message: z70.string(),
-  skill: z70.object({
-    id: z70.string(),
-    name: z70.string(),
-    description: z70.string()
+var systemSkillSchema = z71.object({
+  id: z71.string(),
+  name: z71.string(),
+  description: z71.string()
+});
+var listSystemSkillsResponseSchema = z71.object({
+  skills: z71.array(systemSkillSchema)
+});
+var skillFileItemSchema = z71.object({
+  name: z71.string(),
+  path: z71.string(),
+  size: z71.number().optional(),
+  contentType: z71.string().optional(),
+  updatedAt: z71.string().optional()
+});
+var listSkillFilesResponseSchema = z71.object({
+  files: z71.array(skillFileItemSchema)
+});
+var getSkillFileContentResponseSchema = z71.object({
+  content: z71.string(),
+  path: z71.string(),
+  contentType: z71.string().optional()
+});
+var updateSkillFileBodySchema = z71.object({
+  content: z71.string()
+});
+var updateSkillFileResponseSchema = z71.object({
+  success: z71.boolean(),
+  message: z71.string(),
+  skill: z71.object({
+    id: z71.string(),
+    name: z71.string(),
+    description: z71.string()
   }).optional()
 });
-var deleteSkillResponseSchema = z70.object({
-  success: z70.boolean(),
-  message: z70.string()
+var deleteSkillResponseSchema = z71.object({
+  success: z71.boolean(),
+  message: z71.string()
 });
-var generateSkillBodySchema = z70.object({
-  prompt: z70.string().min(1).max(2e3),
-  existingContent: z70.string().max(2e4).optional()
+var generateSkillBodySchema = z71.object({
+  prompt: z71.string().min(1).max(2e3),
+  existingContent: z71.string().max(2e4).optional()
 });
-var generateSkillResponseSchema = z70.object({
-  content: z70.string()
+var generateSkillResponseSchema = z71.object({
+  content: z71.string()
 });
-var skillAssignmentSchema = z70.object({
-  id: z70.string(),
-  name: z70.string()
+var skillAssignmentSchema = z71.object({
+  id: z71.string(),
+  name: z71.string()
 });
-var listSkillAssignmentsResponseSchema = z70.object({
-  assignments: z70.array(skillAssignmentSchema),
-  total: z70.number()
+var listSkillAssignmentsResponseSchema = z71.object({
+  assignments: z71.array(skillAssignmentSchema),
+  total: z71.number()
 });
-var teamInvitationApiSchema = z71.object({
-  id: z71.string(),
-  team_id: z71.string(),
-  email: z71.email(),
-  invited_by: z71.string(),
-  role: z71.string(),
-  status: z71.string(),
-  name: z71.string().nullable(),
-  created_at: z71.string(),
-  process_id: z71.guid().nullable().optional()
-});
-var teamInvitationDetailApiSchema = z71.object({
-  id: z71.string(),
-  team_id: z71.string(),
-  email: z71.email(),
-  invited_by: z71.string(),
-  role: z71.string(),
-  status: z71.string(),
-  name: z71.string().nullable(),
-  created_at: z71.string(),
-  process_id: z71.guid().nullable().optional(),
-  team: z71.object({
-    id: z71.string(),
-    name: z71.string()
+var teamInvitationApiSchema = z72.object({
+  id: z72.string(),
+  team_id: z72.string(),
+  email: z72.email(),
+  invited_by: z72.string(),
+  role: z72.string(),
+  status: z72.string(),
+  name: z72.string().nullable(),
+  created_at: z72.string(),
+  process_id: z72.guid().nullable().optional()
+});
+var teamInvitationDetailApiSchema = z72.object({
+  id: z72.string(),
+  team_id: z72.string(),
+  email: z72.email(),
+  invited_by: z72.string(),
+  role: z72.string(),
+  status: z72.string(),
+  name: z72.string().nullable(),
+  created_at: z72.string(),
+  process_id: z72.guid().nullable().optional(),
+  team: z72.object({
+    id: z72.string(),
+    name: z72.string()
   }),
-  invitedBy: z71.object({
-    id: z71.string(),
-    name: z71.string().nullable(),
-    email: z71.email()
+  invitedBy: z72.object({
+    id: z72.string(),
+    name: z72.string().nullable(),
+    email: z72.email()
   }),
-  process: z71.object({
-    id: z71.string(),
-    name: z71.string()
+  process: z72.object({
+    id: z72.string(),
+    name: z72.string()
   }).optional()
 });
-var createTeamInvitationRequestSchema = z71.object({
-  email: z71.email(),
-  role: z71.string(),
-  processId: z71.guid().optional()
+var createTeamInvitationRequestSchema = z72.object({
+  email: z72.email(),
+  role: z72.string(),
+  processId: z72.guid().optional()
 });
-var acceptTeamInvitationRequestSchema = z71.object({
-  name: z71.string().optional()
+var acceptTeamInvitationRequestSchema = z72.object({
+  name: z72.string().optional()
 });
-var bulkInviteResponseSchema = z71.object({
-  succeeded: z71.number(),
-  skipped: z71.number(),
-  failed: z71.number()
+var bulkInviteResponseSchema = z72.object({
+  succeeded: z72.number(),
+  skipped: z72.number(),
+  failed: z72.number()
 });
-var teamDiscoveryModeSchema = z72.enum(["request", "auto"]);
-var BrowserRegionSchema = z72.enum([
+var teamDiscoveryModeSchema = z73.enum(["request", "auto"]);
+var BrowserRegionSchema = z73.enum([
   "us-west-2",
   "us-east-1",
   "eu-central-1",
   "ap-southeast-1"
 ]);
-var BrowserLocationSchema = z72.union([
-  z72.literal("cz"),
-  z72.literal("de"),
-  z72.literal("fr"),
-  z72.literal("gb"),
-  z72.literal("it"),
-  z72.literal("pl"),
-  z72.literal("sk")
+var BrowserLocationSchema = z73.union([
+  z73.literal("cz"),
+  z73.literal("de"),
+  z73.literal("fr"),
+  z73.literal("gb"),
+  z73.literal("it"),
+  z73.literal("pl"),
+  z73.literal("sk")
 ]);
-var teamMemberApiSchema = z72.object({
-  id: z72.guid(),
-  name: z72.string().nullable(),
-  email: z72.email(),
-  role: z72.string(),
-  inheritedFromOrg: z72.boolean().default(false)
-});
-var listTeamMembersResponseSchema = z72.object({
-  members: z72.array(teamMemberApiSchema),
-  total: z72.number().int().nonnegative(),
-  limit: z72.number().int().positive(),
-  offset: z72.number().int().nonnegative()
-});
-var updateMemberRoleRequestSchema = z72.object({
-  role: z72.string()
-});
-var removeMemberResponseSchema = z72.object({
-  success: z72.literal(true),
-  nextTeamId: z72.guid().nullable(),
-  planType: z72.enum(["pro", "enterprise"]).nullable()
-});
-var getMemberMeResponseSchema = z72.object({
-  role: z72.string().nullable(),
+var teamMemberApiSchema = z73.object({
+  id: z73.guid(),
+  name: z73.string().nullable(),
+  email: z73.email(),
+  role: z73.string(),
+  inheritedFromOrg: z73.boolean().default(false)
+});
+var listTeamMembersResponseSchema = z73.object({
+  members: z73.array(teamMemberApiSchema),
+  total: z73.number().int().nonnegative(),
+  limit: z73.number().int().positive(),
+  offset: z73.number().int().nonnegative()
+});
+var updateMemberRoleRequestSchema = z73.object({
+  role: z73.string()
+});
+var removeMemberResponseSchema = z73.object({
+  success: z73.literal(true),
+  nextTeamId: z73.guid().nullable(),
+  planType: z73.enum(["pro", "enterprise"]).nullable()
+});
+var getMemberMeResponseSchema = z73.object({
+  role: z73.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: z72.boolean()
+  isMember: z73.boolean()
 });
-var addTeamMemberRequestSchema = z72.object({
-  userId: z72.guid(),
-  role: z72.string()
+var addTeamMemberRequestSchema = z73.object({
+  userId: z73.guid(),
+  role: z73.string()
 });
-var updateTeamRequestSchema = z72.object({
-  name: z72.string().min(1).optional(),
-  slack_team_id: z72.string().optional(),
+var updateTeamRequestSchema = z73.object({
+  name: z73.string().min(1).optional(),
+  slack_team_id: z73.string().optional(),
   discovery_mode: teamDiscoveryModeSchema.optional()
 });
-var teamApiSchema = z72.object({
-  id: z72.guid(),
-  name: z72.string(),
-  created_at: z72.string(),
-  organization_id: z72.guid().nullable(),
-  slack_team_id: z72.string().nullable(),
+var teamApiSchema = z73.object({
+  id: z73.guid(),
+  name: z73.string(),
+  created_at: z73.string(),
+  organization_id: z73.guid().nullable(),
+  slack_team_id: z73.string().nullable(),
   discovery_mode: teamDiscoveryModeSchema
 });
 var TEAM_CONFIG_VERSION = 1;
-var teamConfigDataSchema = z72.object({
+var teamConfigDataSchema = z73.object({
   browserProviderOverride: BrowserProviderTypeSchema.nullable().optional(),
   // Egress identity (proxy country) — what the target site sees.
   browserLocationOverride: BrowserLocationSchema.nullable().optional(),
@@ -9804,182 +9860,182 @@ var teamConfigDataSchema = z72.object({
   // 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: z72.boolean().nullable().optional()
+  sessionRecordingOverride: z73.boolean().nullable().optional()
 });
-var teamConfigSchema = z72.object({
-  version: z72.literal(TEAM_CONFIG_VERSION),
+var teamConfigSchema = z73.object({
+  version: z73.literal(TEAM_CONFIG_VERSION),
   data: teamConfigDataSchema
 });
-var listTeamInvitesResponseSchema = z72.object({
-  invitations: z72.array(teamInvitationApiSchema)
+var listTeamInvitesResponseSchema = z73.object({
+  invitations: z73.array(teamInvitationApiSchema)
 });
-var teamInsightsCopilotSchema = z73.object({
-  id: z73.guid(),
-  name: z73.string(),
-  teamName: z73.string().nullable().optional(),
-  created_at: z73.string().nullable(),
-  updated_at: z73.string().nullable(),
-  team_id: z73.string().nullable(),
-  thread_id: z73.string().nullable(),
-  slack_enabled: z73.boolean().nullable()
-});
-var teamInsightsUserProfileSchema = z73.object({
-  id: z73.guid(),
-  name: z73.string().nullable(),
-  email: z73.string()
+var teamInsightsCopilotSchema = z74.object({
+  id: z74.guid(),
+  name: z74.string(),
+  teamName: z74.string().nullable().optional(),
+  created_at: z74.string().nullable(),
+  updated_at: z74.string().nullable(),
+  team_id: z74.string().nullable(),
+  thread_id: z74.string().nullable(),
+  slack_enabled: z74.boolean().nullable()
+});
+var teamInsightsUserProfileSchema = z74.object({
+  id: z74.guid(),
+  name: z74.string().nullable(),
+  email: z74.string()
 });
 var teamInsightsUserUsageSchema = teamInsightsUserProfileSchema.extend(
   {
-    runCount: z73.number(),
-    lastRun: z73.string().nullable()
+    runCount: z74.number(),
+    lastRun: z74.string().nullable()
   }
 );
-var teamInsightsMetricSourceSchema = z73.object({
+var teamInsightsMetricSourceSchema = z74.object({
   source: agentRunSourceSchema,
-  runsTotal: z73.number(),
-  completedRuns: z73.number()
+  runsTotal: z74.number(),
+  completedRuns: z74.number()
 });
 var teamInsightsCopilotWithRunsSchema = teamInsightsCopilotSchema.extend({
-  integrations: z73.array(z73.string()),
-  uniqueUsersCount: z73.number(),
-  users: z73.array(teamInsightsUserUsageSchema),
-  totalRuns: z73.number(),
-  completedRuns: z73.number(),
-  totalTimeSpentMs: z73.number(),
-  averageTimeSpentMs: z73.number(),
-  completedRunsWithTiming: z73.number(),
-  sources: z73.array(teamInsightsMetricSourceSchema)
-});
-var teamInsightsAgentsRunResponseSchema = z73.object({
-  data: z73.array(teamInsightsCopilotWithRunsSchema),
-  total: z73.number()
-});
-var teamInsightsMetricsResponseSchema = z73.object({
-  runsTotal: z73.number(),
-  completedRuns: z73.number(),
-  sources: z73.array(teamInsightsMetricSourceSchema)
-});
-var teamInsightsUserAgentRunSchema = z73.object({
-  id: z73.guid(),
-  created_at: z73.string(),
-  updated_at: z73.string(),
-  agent_id: z73.guid(),
-  agent_name: z73.string(),
-  build_id: z73.guid(),
-  source: z73.string().nullable(),
-  started_at: z73.string().nullable(),
-  completed_at: z73.string().nullable()
-});
-var teamInsightsAgentSchema = z73.object({
-  id: z73.guid(),
-  name: z73.string(),
-  teamName: z73.string().nullable().optional(),
-  runs: z73.array(teamInsightsUserAgentRunSchema)
-});
-var teamInsightsUserWithAgentsAndRunsSchema = teamInsightsUserProfileSchema.extend({
-  agents: z73.array(teamInsightsAgentSchema),
-  runs: z73.array(teamInsightsUserAgentRunSchema),
-  totalRuns: z73.number()
-});
-var teamInsightsUsersResponseSchema = z73.object({
-  data: z73.array(teamInsightsUserWithAgentsAndRunsSchema),
-  total: z73.number()
-});
-var guardrailsAuthorSchema = z74.object({
+  integrations: z74.array(z74.string()),
+  uniqueUsersCount: z74.number(),
+  users: z74.array(teamInsightsUserUsageSchema),
+  totalRuns: z74.number(),
+  completedRuns: z74.number(),
+  totalTimeSpentMs: z74.number(),
+  averageTimeSpentMs: z74.number(),
+  completedRunsWithTiming: z74.number(),
+  sources: z74.array(teamInsightsMetricSourceSchema)
+});
+var teamInsightsAgentsRunResponseSchema = z74.object({
+  data: z74.array(teamInsightsCopilotWithRunsSchema),
+  total: z74.number()
+});
+var teamInsightsMetricsResponseSchema = z74.object({
+  runsTotal: z74.number(),
+  completedRuns: z74.number(),
+  sources: z74.array(teamInsightsMetricSourceSchema)
+});
+var teamInsightsUserAgentRunSchema = z74.object({
   id: z74.guid(),
-  name: z74.string().nullable(),
-  email: z74.email()
-});
-var guardrailsRevisionSchema = z74.object({
+  created_at: z74.string(),
+  updated_at: z74.string(),
+  agent_id: z74.guid(),
+  agent_name: z74.string(),
+  build_id: z74.guid(),
+  source: z74.string().nullable(),
+  started_at: z74.string().nullable(),
+  completed_at: z74.string().nullable()
+});
+var teamInsightsAgentSchema = z74.object({
   id: z74.guid(),
-  teamId: z74.guid(),
-  guardrailsText: z74.string().nullable(),
-  blockedDomains: z74.array(z74.string()),
-  createdAt: z74.string(),
+  name: z74.string(),
+  teamName: z74.string().nullable().optional(),
+  runs: z74.array(teamInsightsUserAgentRunSchema)
+});
+var teamInsightsUserWithAgentsAndRunsSchema = teamInsightsUserProfileSchema.extend({
+  agents: z74.array(teamInsightsAgentSchema),
+  runs: z74.array(teamInsightsUserAgentRunSchema),
+  totalRuns: z74.number()
+});
+var teamInsightsUsersResponseSchema = z74.object({
+  data: z74.array(teamInsightsUserWithAgentsAndRunsSchema),
+  total: z74.number()
+});
+var guardrailsAuthorSchema = z75.object({
+  id: z75.guid(),
+  name: z75.string().nullable(),
+  email: z75.email()
+});
+var guardrailsRevisionSchema = z75.object({
+  id: z75.guid(),
+  teamId: z75.guid(),
+  guardrailsText: z75.string().nullable(),
+  blockedDomains: z75.array(z75.string()),
+  createdAt: z75.string(),
   createdBy: guardrailsAuthorSchema
 });
-var getTeamGuardrailsResponseSchema = z74.object({
+var getTeamGuardrailsResponseSchema = z75.object({
   current: guardrailsRevisionSchema.nullable()
 });
-var listTeamGuardrailsRevisionsQuerySchema = z74.object({
-  limit: z74.coerce.number().int().min(1).max(100).default(20),
-  offset: z74.coerce.number().int().min(0).default(0)
+var listTeamGuardrailsRevisionsQuerySchema = z75.object({
+  limit: z75.coerce.number().int().min(1).max(100).default(20),
+  offset: z75.coerce.number().int().min(0).default(0)
 });
-var listTeamGuardrailsRevisionsResponseSchema = z74.object({
-  revisions: z74.array(guardrailsRevisionSchema),
-  total: z74.number().int().nonnegative()
+var listTeamGuardrailsRevisionsResponseSchema = z75.object({
+  revisions: z75.array(guardrailsRevisionSchema),
+  total: z75.number().int().nonnegative()
 });
-var createTeamGuardrailsRevisionRequestSchema = z74.object({
-  guardrailsText: z74.string().max(MAX_GUARDRAILS_TEXT_LENGTH).nullable().transform((value) => value && value.trim().length > 0 ? value : null),
-  blockedDomains: z74.array(z74.string()).max(MAX_BLOCKED_DOMAINS)
+var createTeamGuardrailsRevisionRequestSchema = z75.object({
+  guardrailsText: z75.string().max(MAX_GUARDRAILS_TEXT_LENGTH).nullable().transform((value) => value && value.trim().length > 0 ? value : null),
+  blockedDomains: z75.array(z75.string()).max(MAX_BLOCKED_DOMAINS)
 });
-var userDismissalListResponseSchema = z75.object({
-  data: z75.array(z75.string())
+var userDismissalListResponseSchema = z76.object({
+  data: z76.array(z76.string())
 });
-var userDismissalMutationSchema = z75.object({
-  elementKey: z75.string()
+var userDismissalMutationSchema = z76.object({
+  elementKey: z76.string()
 });
 var PASSWORD_MIN = 1;
 var PASSWORD_MAX = 1024;
 var NAME_MAX = 200;
 var URL_MAX = 500;
 var USERNAME_MAX = 200;
-var vpnProxyConfigSummarySchema = z76.object({
-  id: z76.guid(),
-  name: z76.string(),
-  server: z76.string(),
-  username: z76.string(),
-  enabled: z76.boolean(),
-  passwordSet: z76.boolean(),
-  organizationCount: z76.number().int().nonnegative(),
-  createdAt: z76.string(),
-  updatedAt: z76.string()
-});
-var vpnProxyConfigListResponseSchema = z76.object({
-  configs: z76.array(vpnProxyConfigSummarySchema)
-});
-var vpnProxyConfigCreateRequestSchema = z76.object({
-  name: z76.string().trim().min(1).max(NAME_MAX),
-  server: z76.string().trim().min(1).max(URL_MAX).url(),
-  username: z76.string().trim().min(1).max(USERNAME_MAX),
-  password: z76.string().min(PASSWORD_MIN).max(PASSWORD_MAX),
-  enabled: z76.boolean().prefault(true)
-});
-var vpnProxyConfigCreateResponseSchema = z76.object({
+var vpnProxyConfigSummarySchema = z77.object({
+  id: z77.guid(),
+  name: z77.string(),
+  server: z77.string(),
+  username: z77.string(),
+  enabled: z77.boolean(),
+  passwordSet: z77.boolean(),
+  organizationCount: z77.number().int().nonnegative(),
+  createdAt: z77.string(),
+  updatedAt: z77.string()
+});
+var vpnProxyConfigListResponseSchema = z77.object({
+  configs: z77.array(vpnProxyConfigSummarySchema)
+});
+var vpnProxyConfigCreateRequestSchema = z77.object({
+  name: z77.string().trim().min(1).max(NAME_MAX),
+  server: z77.string().trim().min(1).max(URL_MAX).url(),
+  username: z77.string().trim().min(1).max(USERNAME_MAX),
+  password: z77.string().min(PASSWORD_MIN).max(PASSWORD_MAX),
+  enabled: z77.boolean().prefault(true)
+});
+var vpnProxyConfigCreateResponseSchema = z77.object({
   config: vpnProxyConfigSummarySchema
 });
-var vpnProxyConfigUpdateRequestSchema = z76.object({
-  name: z76.string().trim().min(1).max(NAME_MAX).optional(),
-  server: z76.string().trim().min(1).max(URL_MAX).url().optional(),
-  username: z76.string().trim().min(1).max(USERNAME_MAX).optional(),
-  password: z76.string().min(PASSWORD_MIN).max(PASSWORD_MAX).optional(),
-  enabled: z76.boolean().optional()
+var vpnProxyConfigUpdateRequestSchema = z77.object({
+  name: z77.string().trim().min(1).max(NAME_MAX).optional(),
+  server: z77.string().trim().min(1).max(URL_MAX).url().optional(),
+  username: z77.string().trim().min(1).max(USERNAME_MAX).optional(),
+  password: z77.string().min(PASSWORD_MIN).max(PASSWORD_MAX).optional(),
+  enabled: z77.boolean().optional()
 });
-var vpnProxyConfigUpdateResponseSchema = z76.object({
+var vpnProxyConfigUpdateResponseSchema = z77.object({
   config: vpnProxyConfigSummarySchema
 });
-var vpnProxyConfigDeleteResponseSchema = z76.object({
-  success: z76.literal(true)
+var vpnProxyConfigDeleteResponseSchema = z77.object({
+  success: z77.literal(true)
 });
-var vpnProxyConfigOrganizationSchema = z76.object({
-  id: z76.guid(),
-  organizationId: z76.guid(),
-  organizationName: z76.string(),
-  attachedAt: z76.string()
+var vpnProxyConfigOrganizationSchema = z77.object({
+  id: z77.guid(),
+  organizationId: z77.guid(),
+  organizationName: z77.string(),
+  attachedAt: z77.string()
 });
-var vpnProxyConfigOrganizationListResponseSchema = z76.object({
-  organizations: z76.array(vpnProxyConfigOrganizationSchema)
+var vpnProxyConfigOrganizationListResponseSchema = z77.object({
+  organizations: z77.array(vpnProxyConfigOrganizationSchema)
 });
-var vpnProxyConfigAttachOrganizationRequestSchema = z76.object({
-  organizationId: z76.guid()
+var vpnProxyConfigAttachOrganizationRequestSchema = z77.object({
+  organizationId: z77.guid()
 });
-var vpnProxyConfigAttachOrganizationResponseSchema = z76.object({
+var vpnProxyConfigAttachOrganizationResponseSchema = z77.object({
   attachment: vpnProxyConfigOrganizationSchema
 });
-var vpnProxyConfigDetachOrganizationResponseSchema = z76.object({
-  success: z76.literal(true)
+var vpnProxyConfigDetachOrganizationResponseSchema = z77.object({
+  success: z77.literal(true)
 });
-var vpnProxyConfigForOrganizationResponseSchema = z76.object({
+var vpnProxyConfigForOrganizationResponseSchema = z77.object({
   config: vpnProxyConfigSummarySchema.nullable()
 });
 function canonicalizeSopInput(config) {
@@ -10000,7 +10056,7 @@ function canonicalizeSopInput(config) {
 }
 __name(canonicalizeSopInput, "canonicalizeSopInput");
 __name2(canonicalizeSopInput, "canonicalizeSopInput");
-var caseFilterStatusSchema = z77.enum([
+var caseFilterStatusSchema = z78.enum([
   "pending",
   "claimed",
   "completed",
@@ -10008,19 +10064,19 @@ var caseFilterStatusSchema = z77.enum([
   "needs_input",
   "postponed"
 ]);
-var casesFiltersSchema = z77.object({
-  status: z77.array(caseFilterStatusSchema).optional(),
-  created_at_from: z77.string().optional(),
-  updated_at_from: z77.string().optional(),
-  labels: z77.record(z77.string(), z77.array(z77.string())).optional()
+var casesFiltersSchema = z78.object({
+  status: z78.array(caseFilterStatusSchema).optional(),
+  created_at_from: z78.string().optional(),
+  updated_at_from: z78.string().optional(),
+  labels: z78.record(z78.string(), z78.array(z78.string())).optional()
 });
-var casesListRequestBodySchema = z77.object({
+var casesListRequestBodySchema = z78.object({
   filters: casesFiltersSchema.default({}),
-  limit: z77.int().min(1).max(100).default(25),
-  offset: z77.int().min(0).default(0),
-  sort_by: z77.enum(["created_at", "updated_at", "postponed_to"]).default("created_at"),
-  sort_order: z77.enum(["asc", "desc"]).default("desc"),
-  search: z77.string().optional()
+  limit: z78.int().min(1).max(100).default(25),
+  offset: z78.int().min(0).default(0),
+  sort_by: z78.enum(["created_at", "updated_at", "postponed_to"]).default("created_at"),
+  sort_order: z78.enum(["asc", "desc"]).default("desc"),
+  search: z78.string().optional()
 });
 function toBase64(input) {
   if (typeof btoa === "function") {
@@ -10115,7 +10171,7 @@ function setFilterValuesByCategoryKey(filters, categoryKey, values) {
       const { status: _, ...rest } = filters;
       return rest;
     }
-    const parsed = z77.array(caseFilterStatusSchema).safeParse(values);
+    const parsed = z78.array(caseFilterStatusSchema).safeParse(values);
     if (!parsed.success) {
       return filters;
     }
@@ -11378,11 +11434,11 @@ function emptyConfig() {
 __name(emptyConfig, "emptyConfig");
 
 // src/config/env.ts
-import { z as z78 } from "zod";
-var optionalEnvString = z78.string().optional().transform(
+import { z as z79 } from "zod";
+var optionalEnvString = z79.string().optional().transform(
   (value) => value === void 0 || value === "" ? void 0 : value
 );
-var CliEnvSchema = z78.object({
+var CliEnvSchema = z79.object({
   DUVO_PROFILE: optionalEnvString,
   DUVO_API_KEY: optionalEnvString,
   DUVO_API_BASE_URL: optionalEnvString,
@@ -11879,9 +11935,9 @@ async function requireAuthenticatedConfig(command) {
 __name(requireAuthenticatedConfig, "requireAuthenticatedConfig");
 
 // src/commands/shared/team-context.ts
-import { z as z79 } from "zod";
-var teamSchema = z79.object({ id: z79.string() });
-var listMyTeamsResponseSchema = z79.object({ teams: z79.array(teamSchema) });
+import { z as z80 } from "zod";
+var teamSchema = z80.object({ id: z80.string() });
+var listMyTeamsResponseSchema = z80.object({ teams: z80.array(teamSchema) });
 async function resolveRequiredTeamId(config, options = {}) {
   if (options.override) {
     return options.override;
@@ -12664,56 +12720,56 @@ 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 z81 } from "zod";
+import { z as z82 } from "zod";
 
 // src/api/json-value.ts
-import { z as z80 } from "zod";
-var jsonValueSchema = z80.lazy(
-  () => z80.union([
-    z80.string(),
-    z80.number(),
-    z80.boolean(),
-    z80.null(),
-    z80.array(jsonValueSchema),
-    z80.record(z80.string(), jsonValueSchema)
+import { z as z81 } from "zod";
+var jsonValueSchema = z81.lazy(
+  () => z81.union([
+    z81.string(),
+    z81.number(),
+    z81.boolean(),
+    z81.null(),
+    z81.array(jsonValueSchema),
+    z81.record(z81.string(), jsonValueSchema)
   ])
 );
 
 // src/api/agent-schemas.ts
-var publicAgentSchema = z81.object({
-  id: z81.string(),
-  name: z81.string(),
-  slack_enabled: z81.boolean().nullish(),
-  microsoft_teams_enabled: z81.boolean().nullish(),
-  agentic_memory_enabled: z81.boolean().nullish(),
-  thread_id: z81.string().nullish(),
-  created_at: z81.string().nullish(),
-  updated_at: z81.string().nullish(),
-  latest_build: z81.object({ config: jsonValueSchema.nullish() }).nullish()
-});
-var publicBuildSchema = z81.object({
-  id: z81.string(),
-  agent_id: z81.string(),
-  name: z81.string(),
-  revision_number: z81.number().nullish(),
-  created_at: z81.string().nullish(),
-  updated_at: z81.string().nullish()
-});
-var listAgentsResponseSchema = z81.object({
-  agents: z81.array(publicAgentSchema),
-  total: z81.number().nullish(),
-  limit: z81.number().nullish(),
-  offset: z81.number().nullish()
-});
-var getAgentResponseSchema = z81.object({
+var publicAgentSchema = z82.object({
+  id: z82.string(),
+  name: z82.string(),
+  slack_enabled: z82.boolean().nullish(),
+  microsoft_teams_enabled: z82.boolean().nullish(),
+  agentic_memory_enabled: z82.boolean().nullish(),
+  thread_id: z82.string().nullish(),
+  created_at: z82.string().nullish(),
+  updated_at: z82.string().nullish(),
+  latest_build: z82.object({ config: jsonValueSchema.nullish() }).nullish()
+});
+var publicBuildSchema = z82.object({
+  id: z82.string(),
+  agent_id: z82.string(),
+  name: z82.string(),
+  revision_number: z82.number().nullish(),
+  created_at: z82.string().nullish(),
+  updated_at: z82.string().nullish()
+});
+var listAgentsResponseSchema = z82.object({
+  agents: z82.array(publicAgentSchema),
+  total: z82.number().nullish(),
+  limit: z82.number().nullish(),
+  offset: z82.number().nullish()
+});
+var getAgentResponseSchema = z82.object({
   agent: publicAgentSchema
 });
-var createAgentResponseSchema = z81.object({
+var createAgentResponseSchema = z82.object({
   agent: publicAgentSchema,
   build: publicBuildSchema.optional()
 });
-var deleteAgentResponseSchema = z81.object({
-  success: z81.literal(true)
+var deleteAgentResponseSchema = z82.object({
+  success: z82.literal(true)
 });
 var buildConfigSchema = StoredAgentConfigSchemaV2;
 var DEFAULT_NEW_AGENT_NAME = DEFAULT_AGENT_NAME;
@@ -13430,29 +13486,29 @@ function registerAgentsEvalScores(agents) {
 __name(registerAgentsEvalScores, "registerAgentsEvalScores");
 
 // src/api/build-schemas.ts
-import { z as z82 } from "zod";
-var publicBuildSchema2 = z82.object({
-  id: z82.string(),
-  agent_id: z82.string(),
-  name: z82.string(),
-  status: z82.string().nullish(),
+import { z as z83 } from "zod";
+var publicBuildSchema2 = z83.object({
+  id: z83.string(),
+  agent_id: z83.string(),
+  name: z83.string(),
+  status: z83.string().nullish(),
   config: jsonValueSchema.nullish(),
-  revision_number: z82.number().nullish(),
-  created_at: z82.string().nullish(),
-  updated_at: z82.string().nullish()
+  revision_number: z83.number().nullish(),
+  created_at: z83.string().nullish(),
+  updated_at: z83.string().nullish()
 });
-var listBuildsResponseSchema2 = z82.object({
-  builds: z82.array(publicBuildSchema2),
-  total: z82.number().nullish(),
-  limit: z82.number().nullish(),
-  offset: z82.number().nullish()
+var listBuildsResponseSchema2 = z83.object({
+  builds: z83.array(publicBuildSchema2),
+  total: z83.number().nullish(),
+  limit: z83.number().nullish(),
+  offset: z83.number().nullish()
 });
-var getBuildResponseSchema = z82.object({
+var getBuildResponseSchema = z83.object({
   build: publicBuildSchema2
 });
-var createBuildResponseSchema = z82.object({
+var createBuildResponseSchema = z83.object({
   build: publicBuildSchema2,
-  agent: z82.object({ id: z82.string() })
+  agent: z83.object({ id: z83.string() })
 });
 
 // src/commands/agents/get.ts
@@ -13702,30 +13758,30 @@ function registerAgentsModels(agents) {
 __name(registerAgentsModels, "registerAgentsModels");
 
 // src/api/schedule-schemas.ts
-import { z as z83 } from "zod";
-var publicScheduleSchema = z83.object({
-  id: z83.string(),
-  build_id: z83.string(),
-  agent_id: z83.string(),
-  user_id: z83.string(),
-  enabled: z83.boolean(),
-  frequency: z83.string(),
-  time: z83.string().nullish(),
-  timezone: z83.string(),
-  day: z83.string().nullish(),
-  day_of_month: z83.number().nullish(),
-  cron: z83.string().nullish(),
-  source: z83.string().nullish(),
-  task: z83.string().nullish(),
-  recurring: z83.boolean().nullish(),
-  created_at: z83.string(),
-  updated_at: z83.string()
-});
-var listSchedulesResponseSchema = z83.object({
-  schedules: z83.array(publicScheduleSchema)
-});
-var deleteScheduleResponseSchema = z83.object({
-  success: z83.literal(true)
+import { z as z84 } from "zod";
+var publicScheduleSchema = z84.object({
+  id: z84.string(),
+  build_id: z84.string(),
+  agent_id: z84.string(),
+  user_id: z84.string(),
+  enabled: z84.boolean(),
+  frequency: z84.string(),
+  time: z84.string().nullish(),
+  timezone: z84.string(),
+  day: z84.string().nullish(),
+  day_of_month: z84.number().nullish(),
+  cron: z84.string().nullish(),
+  source: z84.string().nullish(),
+  task: z84.string().nullish(),
+  recurring: z84.boolean().nullish(),
+  created_at: z84.string(),
+  updated_at: z84.string()
+});
+var listSchedulesResponseSchema = z84.object({
+  schedules: z84.array(publicScheduleSchema)
+});
+var deleteScheduleResponseSchema = z84.object({
+  success: z84.literal(true)
 });
 
 // src/commands/agents/schedules/render-schedule.ts
@@ -14173,33 +14229,33 @@ function registerAgentsSetModel(agents) {
 __name(registerAgentsSetModel, "registerAgentsSetModel");
 
 // src/api/trigger-schemas.ts
-import { z as z84 } from "zod";
-var triggerSchema = z84.object({
-  id: z84.string(),
-  agent_id: z84.string(),
-  user_id: z84.string(),
-  integration_slug: z84.string(),
-  trigger_type: z84.string(),
-  filter_config: z84.record(z84.string(), z84.unknown()),
-  integration_instance_id: z84.string(),
-  enabled: z84.boolean(),
-  created_at: z84.string(),
-  updated_at: z84.string()
+import { z as z85 } from "zod";
+var triggerSchema = z85.object({
+  id: z85.string(),
+  agent_id: z85.string(),
+  user_id: z85.string(),
+  integration_slug: z85.string(),
+  trigger_type: z85.string(),
+  filter_config: z85.record(z85.string(), z85.unknown()),
+  integration_instance_id: z85.string(),
+  enabled: z85.boolean(),
+  created_at: z85.string(),
+  updated_at: z85.string()
 });
-var listTriggersResponseSchema = z84.object({
-  triggers: z84.array(triggerSchema)
+var listTriggersResponseSchema = z85.object({
+  triggers: z85.array(triggerSchema)
 });
-var triggerTypeSchema = z84.object({
-  integration_slug: z84.string(),
-  integration_name: z84.string(),
-  icon_url: z84.string(),
-  trigger_type: z84.string(),
-  label: z84.string(),
-  description: z84.string(),
-  filter_schema: z84.record(z84.string(), z84.unknown())
+var triggerTypeSchema = z85.object({
+  integration_slug: z85.string(),
+  integration_name: z85.string(),
+  icon_url: z85.string(),
+  trigger_type: z85.string(),
+  label: z85.string(),
+  description: z85.string(),
+  filter_schema: z85.record(z85.string(), z85.unknown())
 });
-var listTriggerTypesResponseSchema = z84.object({
-  trigger_types: z84.array(triggerTypeSchema)
+var listTriggerTypesResponseSchema = z85.object({
+  trigger_types: z85.array(triggerTypeSchema)
 });
 
 // src/commands/agents/triggers/list.ts
@@ -14823,55 +14879,55 @@ function fieldsToSearchParams(fields) {
 __name(fieldsToSearchParams, "fieldsToSearchParams");
 
 // src/api/integration-schemas.ts
-import { z as z85 } from "zod";
-var integrationSchema = z85.object({
-  id: z85.string(),
-  name: z85.string(),
-  type: z85.string(),
-  provider: z85.string(),
-  user_id: z85.string().nullable(),
-  team_id: z85.string(),
-  server_url: z85.string().optional(),
-  transport_type: z85.string().optional(),
-  auth_method: z85.string().nullish(),
-  composio_mcp_id: z85.string().nullish(),
-  custom_integration_id: z85.string().nullish(),
-  icon_url: z85.string().nullish(),
-  oauth_provider: z85.string().nullish(),
-  oauth_provider_key: z85.string().nullish(),
-  oauth_scopes: z85.array(z85.string()).nullish(),
-  integration_id: z85.string().nullish(),
-  created_at: z85.string(),
-  updated_at: z85.string()
-});
-var integrationsListResponseSchema2 = z85.object({
-  integrations: z85.array(integrationSchema)
+import { z as z86 } from "zod";
+var integrationSchema = z86.object({
+  id: z86.string(),
+  name: z86.string(),
+  type: z86.string(),
+  provider: z86.string(),
+  user_id: z86.string().nullable(),
+  team_id: z86.string(),
+  server_url: z86.string().optional(),
+  transport_type: z86.string().optional(),
+  auth_method: z86.string().nullish(),
+  composio_mcp_id: z86.string().nullish(),
+  custom_integration_id: z86.string().nullish(),
+  icon_url: z86.string().nullish(),
+  oauth_provider: z86.string().nullish(),
+  oauth_provider_key: z86.string().nullish(),
+  oauth_scopes: z86.array(z86.string()).nullish(),
+  integration_id: z86.string().nullish(),
+  created_at: z86.string(),
+  updated_at: z86.string()
+});
+var integrationsListResponseSchema2 = z86.object({
+  integrations: z86.array(integrationSchema)
 });
 var connectionResponseSchema = integrationSchema;
-var buildIntegrationConfigSchema2 = z85.object({
-  id: z85.string(),
-  integration_id: z85.string().nullable(),
-  custom_integration_id: z85.string().nullable(),
-  integration_type: z85.string(),
-  integration_name: z85.string(),
-  created_at: z85.string()
+var buildIntegrationConfigSchema2 = z86.object({
+  id: z86.string(),
+  integration_id: z86.string().nullable(),
+  custom_integration_id: z86.string().nullable(),
+  integration_type: z86.string(),
+  integration_name: z86.string(),
+  created_at: z86.string()
 });
-var listBuildIntegrationsResponseSchema2 = z85.object({
-  integrations: z85.array(buildIntegrationConfigSchema2)
+var listBuildIntegrationsResponseSchema2 = z86.object({
+  integrations: z86.array(buildIntegrationConfigSchema2)
 });
-var attachBuildIntegrationsResponseSchema = z85.object({
-  success: z85.boolean(),
-  count: z85.number()
+var attachBuildIntegrationsResponseSchema = z86.object({
+  success: z86.boolean(),
+  count: z86.number()
 });
-var buildIntegrationConnectionSchema = z85.object({
-  connection_id: z85.string(),
-  created_at: z85.string()
+var buildIntegrationConnectionSchema = z86.object({
+  connection_id: z86.string(),
+  created_at: z86.string()
 });
-var listBuildIntegrationConnectionsResponseSchema = z85.object({
-  connections: z85.array(buildIntegrationConnectionSchema)
+var listBuildIntegrationConnectionsResponseSchema = z86.object({
+  connections: z86.array(buildIntegrationConnectionSchema)
 });
-var successResponseSchema = z85.object({
-  success: z85.boolean()
+var successResponseSchema = z86.object({
+  success: z86.boolean()
 });
 
 // src/commands/build-integrations/attach.ts
@@ -14914,15 +14970,15 @@ function registerBuildIntegrationsAttach(buildIntegrations) {
 __name(registerBuildIntegrationsAttach, "registerBuildIntegrationsAttach");
 
 // src/commands/build-integrations/case-queue-setup.ts
-import { z as z86 } from "zod";
-var slotSchema = z86.object({
-  config_id: z86.string(),
-  integration_type: z86.string(),
-  linked_queue_count: z86.number()
+import { z as z87 } from "zod";
+var slotSchema = z87.object({
+  config_id: z87.string(),
+  integration_type: z87.string(),
+  linked_queue_count: z87.number()
 });
-var responseSchema2 = z86.object({
-  configs: z86.array(slotSchema),
-  has_available_queues: z86.boolean()
+var responseSchema2 = z87.object({
+  configs: z87.array(slotSchema),
+  has_available_queues: z87.boolean()
 });
 var TABLE_COLUMNS10 = [
   { header: "SLOT ID", cell: /* @__PURE__ */ __name((row) => row.config_id, "cell") },
@@ -15417,9 +15473,9 @@ function registerBuildsList(builds) {
 __name(registerBuildsList, "registerBuildsList");
 
 // src/commands/builds/promote.ts
-import { z as z87 } from "zod";
-var promoteResponseSchema = z87.object({
-  success: z87.boolean()
+import { z as z88 } from "zod";
+var promoteResponseSchema = z88.object({
+  success: z88.boolean()
 });
 function registerBuildsPromote(builds) {
   builds.command("promote <id>").description(
@@ -16430,7 +16486,7 @@ function parseSortOrder(raw) {
 __name(parseSortOrder, "parseSortOrder");
 
 // src/commands/cases/runs.ts
-import { z as z88 } from "zod";
+import { z as z89 } from "zod";
 var MIN_LIMIT4 = 1;
 var MAX_LIMIT4 = 10;
 var DEFAULT_LIMIT4 = 3;
@@ -16448,17 +16504,17 @@ var RUNS_TABLE_COLUMNS = [
     cell: /* @__PURE__ */ __name((row) => row.has_pending_human_request ? row.pending_human_request_title ?? "(unknown)" : "", "cell")
   }
 ];
-var recentMessageSchema = z88.object({
-  id: z88.string(),
-  type: z88.string(),
-  role: z88.string(),
-  timestamp: z88.string(),
-  text_content: z88.string().nullish(),
-  tool_call: z88.object({ id: z88.string(), name: z88.string() }).passthrough().nullish(),
-  tool_result: z88.object({ tool_call_id: z88.string() }).passthrough().nullish()
-});
-var recentMessagesResponseSchema = z88.object({
-  messages: z88.array(recentMessageSchema)
+var recentMessageSchema = z89.object({
+  id: z89.string(),
+  type: z89.string(),
+  role: z89.string(),
+  timestamp: z89.string(),
+  text_content: z89.string().nullish(),
+  tool_call: z89.object({ id: z89.string(), name: z89.string() }).passthrough().nullish(),
+  tool_result: z89.object({ tool_call_id: z89.string() }).passthrough().nullish()
+});
+var recentMessagesResponseSchema = z89.object({
+  messages: z89.array(recentMessageSchema)
 });
 var TEXT_PREVIEW_WIDTH = 60;
 var MESSAGES_TABLE_COLUMNS = [
@@ -16587,55 +16643,55 @@ function registerCases(program) {
 __name(registerCases, "registerCases");
 
 // src/api/clarity-schemas.ts
-import { z as z89 } from "zod";
-var clarityListProcessSchema = z89.object({
-  id: z89.guid(),
-  name: z89.string(),
+import { z as z90 } from "zod";
+var clarityListProcessSchema = z90.object({
+  id: z90.guid(),
+  name: z90.string(),
   status: clarityProcessStatusSchema,
   visibility: clarityProcessVisibilitySchema,
-  version: z89.number().int(),
-  capture_count: z89.number().int(),
-  capture_counts: z89.object({
-    video: z89.number().int(),
-    interview: z89.number().int(),
-    document: z89.number().int()
+  version: z90.number().int(),
+  capture_count: z90.number().int(),
+  capture_counts: z90.object({
+    video: z90.number().int(),
+    interview: z90.number().int(),
+    document: z90.number().int()
   }).optional(),
-  pending_invitation_count: z89.number().int(),
-  contributors: z89.array(
-    z89.object({
-      user_id: z89.string(),
-      user_name: z89.string()
+  pending_invitation_count: z90.number().int(),
+  contributors: z90.array(
+    z90.object({
+      user_id: z90.string(),
+      user_name: z90.string()
     })
   ),
-  created_at: z89.string(),
-  created_by_name: z89.string().nullable()
-});
-var listClarityProcessesResponseSchema = z89.object({
-  processes: z89.array(clarityListProcessSchema),
-  total: z89.number().int(),
-  limit: z89.number().int(),
-  offset: z89.number().int()
-});
-var createClarityInviteLinkResponseSchema = z89.object({
-  invite_link: z89.object({
-    id: z89.guid(),
-    url: z89.url(),
-    created_at: z89.string(),
-    created_by: z89.object({
-      id: z89.guid(),
-      email: z89.email().nullable()
+  created_at: z90.string(),
+  created_by_name: z90.string().nullable()
+});
+var listClarityProcessesResponseSchema = z90.object({
+  processes: z90.array(clarityListProcessSchema),
+  total: z90.number().int(),
+  limit: z90.number().int(),
+  offset: z90.number().int()
+});
+var createClarityInviteLinkResponseSchema = z90.object({
+  invite_link: z90.object({
+    id: z90.guid(),
+    url: z90.url(),
+    created_at: z90.string(),
+    created_by: z90.object({
+      id: z90.guid(),
+      email: z90.email().nullable()
     })
   })
 });
-var createArtifactImportUploadUrlResponseSchema = z89.object({
-  signed_url: z89.url(),
-  capture_id: z89.guid(),
-  expires_at: z89.iso.datetime()
+var createArtifactImportUploadUrlResponseSchema = z90.object({
+  signed_url: z90.url(),
+  capture_id: z90.guid(),
+  expires_at: z90.iso.datetime()
 });
-var completeArtifactImportResponseSchema = z89.object({
+var completeArtifactImportResponseSchema = z90.object({
   capture: clarityCaptureSchema.extend({
-    createdAt: z89.iso.datetime(),
-    updatedAt: z89.iso.datetime()
+    createdAt: z90.iso.datetime(),
+    updatedAt: z90.iso.datetime()
   })
 });
 var legacyClarityProcessResponseSchema = legacyClarityProcessDetailSchema;
@@ -17074,8 +17130,8 @@ function renderCompletedImport(response) {
 __name(renderCompletedImport, "renderCompletedImport");
 
 // src/commands/clarity/assign-extra-capture-request.ts
-import { z as z90 } from "zod";
-var responseSchema3 = z90.object({
+import { z as z91 } from "zod";
+var responseSchema3 = z91.object({
   request: clarityProposalExtraCaptureRequestSchema
 });
 function renderRequest(request) {
@@ -17122,11 +17178,11 @@ function registerClarityAssignExtraCaptureRequest(clarity) {
 __name(registerClarityAssignExtraCaptureRequest, "registerClarityAssignExtraCaptureRequest");
 
 // src/commands/clarity/build-automation.ts
-import { z as z91 } from "zod";
-var responseSchema4 = z91.object({
-  automation_run: z91.object({
-    id: z91.string(),
-    status: z91.string()
+import { z as z92 } from "zod";
+var responseSchema4 = z92.object({
+  automation_run: z92.object({
+    id: z92.string(),
+    status: z92.string()
   })
 });
 function registerClarityBuildAutomation(clarity) {
@@ -17197,7 +17253,7 @@ function registerClarityCreateInviteLink(clarity) {
 __name(registerClarityCreateInviteLink, "registerClarityCreateInviteLink");
 
 // src/commands/clarity/doctor.ts
-import { z as z92 } from "zod";
+import { z as z93 } from "zod";
 
 // src/commands/clarity/render.ts
 var DEFAULT_HUMAN_SUMMARY_LIMIT = 1200;
@@ -19019,8 +19075,8 @@ async function buildTeamContextCheck(config) {
   }
 }
 __name(buildTeamContextCheck, "buildTeamContextCheck");
-var listMyTeamsResponseSchema2 = z92.object({
-  teams: z92.array(z92.object({ id: z92.string() }))
+var listMyTeamsResponseSchema2 = z93.object({
+  teams: z93.array(z93.object({ id: z93.string() }))
 });
 async function buildClarityApiReachableCheck(command, config) {
   let teamId;
@@ -19638,19 +19694,19 @@ function buildGenerateTransformationProposalBody(options) {
 __name(buildGenerateTransformationProposalBody, "buildGenerateTransformationProposalBody");
 
 // src/commands/clarity/get-current-process.ts
-import { z as z93 } from "zod";
-var snapshotSchema = z93.object({
-  snapshot: z93.object({
-    id: z93.string(),
-    kind: z93.string(),
-    source_snapshot_id: z93.string().nullable(),
-    parent_id: z93.string().nullable(),
-    status: z93.string(),
-    creator_type: z93.string(),
-    user_id: z93.string().nullable(),
-    sandbox_id: z93.string().nullable(),
-    created_at: z93.string(),
-    updated_at: z93.string()
+import { z as z94 } from "zod";
+var snapshotSchema = z94.object({
+  snapshot: z94.object({
+    id: z94.string(),
+    kind: z94.string(),
+    source_snapshot_id: z94.string().nullable(),
+    parent_id: z94.string().nullable(),
+    status: z94.string(),
+    creator_type: z94.string(),
+    user_id: z94.string().nullable(),
+    sandbox_id: z94.string().nullable(),
+    created_at: z94.string(),
+    updated_at: z94.string()
   })
 });
 function registerClarityGetCurrentProcess(clarity) {
@@ -19694,19 +19750,19 @@ function registerClarityGetCurrentProcess(clarity) {
 __name(registerClarityGetCurrentProcess, "registerClarityGetCurrentProcess");
 
 // src/commands/clarity/get-transformation-proposal.ts
-import { z as z94 } from "zod";
-var snapshotSchema2 = z94.object({
-  snapshot: z94.object({
-    id: z94.string(),
-    kind: z94.string(),
-    source_snapshot_id: z94.string().nullable(),
-    parent_id: z94.string().nullable(),
-    status: z94.string(),
-    creator_type: z94.string(),
-    user_id: z94.string().nullable(),
-    sandbox_id: z94.string().nullable(),
-    created_at: z94.string(),
-    updated_at: z94.string()
+import { z as z95 } from "zod";
+var snapshotSchema2 = z95.object({
+  snapshot: z95.object({
+    id: z95.string(),
+    kind: z95.string(),
+    source_snapshot_id: z95.string().nullable(),
+    parent_id: z95.string().nullable(),
+    status: z95.string(),
+    creator_type: z95.string(),
+    user_id: z95.string().nullable(),
+    sandbox_id: z95.string().nullable(),
+    created_at: z95.string(),
+    updated_at: z95.string()
   })
 });
 function registerClarityGetTransformationProposal(clarity) {
@@ -19802,7 +19858,7 @@ Transformation proposal versions (${tpVersions.length}):`
 __name(registerClarityGet, "registerClarityGet");
 
 // src/commands/clarity/landscape.ts
-import { z as z95 } from "zod";
+import { z as z96 } from "zod";
 var ORG_FLAG_DESCRIPTION = "organization id for the org-scoped process landscape (overrides DUVO_ORG_ID)";
 var LANDSCAPE_RESOURCE_PATH = "/clarity/hierarchy/landscape";
 var TREE_RESOURCE_PATH = "/clarity/hierarchy/tree";
@@ -19811,89 +19867,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 = z95.enum(["content", "existence"]);
-var processSummarySchema = z95.object({
-  id: z95.string(),
-  name: z95.string()
+var axisSchema = z96.enum(["content", "existence"]);
+var processSummarySchema = z96.object({
+  id: z96.string(),
+  name: z96.string()
 }).passthrough();
-var landscapeNodeSchema = z95.object({
-  id: z95.string(),
-  parentId: z95.string().nullable(),
-  processId: z95.string().nullable(),
-  name: z95.string(),
-  ownerLabel: z95.string().nullable(),
+var landscapeNodeSchema = z96.object({
+  id: z96.string(),
+  parentId: z96.string().nullable(),
+  processId: z96.string().nullable(),
+  name: z96.string(),
+  ownerLabel: z96.string().nullable(),
   process: processSummarySchema.nullable()
 }).passthrough();
 var unlinkedProcessSchema = processSummarySchema.extend({
-  teamId: z95.string(),
-  teamName: z95.string().nullable()
+  teamId: z96.string(),
+  teamName: z96.string().nullable()
 }).passthrough();
-var treeNodeSchema = z95.object({
-  id: z95.string(),
-  parentId: z95.string().nullable(),
-  processId: z95.string().nullable(),
-  name: z95.string(),
-  ownerLabel: z95.string().nullable(),
-  depth: z95.number()
+var treeNodeSchema = z96.object({
+  id: z96.string(),
+  parentId: z96.string().nullable(),
+  processId: z96.string().nullable(),
+  name: z96.string(),
+  ownerLabel: z96.string().nullable(),
+  depth: z96.number()
 }).passthrough();
-var landscapeResponseSchema = z95.object({
-  nodes: z95.array(landscapeNodeSchema),
-  links: z95.array(
-    z95.object({
-      id: z95.string(),
-      sourceNodeId: z95.string(),
-      targetNodeId: z95.string(),
-      type: z95.string(),
-      state: z95.string(),
-      confidence: z95.number().nullable()
+var landscapeResponseSchema = z96.object({
+  nodes: z96.array(landscapeNodeSchema),
+  links: z96.array(
+    z96.object({
+      id: z96.string(),
+      sourceNodeId: z96.string(),
+      targetNodeId: z96.string(),
+      type: z96.string(),
+      state: z96.string(),
+      confidence: z96.number().nullable()
     }).passthrough()
   ),
-  unlinkedProcesses: z95.array(unlinkedProcessSchema),
-  stats: z95.object({
-    totalNodes: z95.number(),
-    processNodes: z95.number(),
-    proposedNodes: z95.number(),
-    unsortedProcesses: z95.number(),
-    latestUpdatedAt: z95.string().nullable()
+  unlinkedProcesses: z96.array(unlinkedProcessSchema),
+  stats: z96.object({
+    totalNodes: z96.number(),
+    processNodes: z96.number(),
+    proposedNodes: z96.number(),
+    unsortedProcesses: z96.number(),
+    latestUpdatedAt: z96.string().nullable()
   }).passthrough(),
-  truncated: z95.boolean()
+  truncated: z96.boolean()
 }).passthrough();
-var treeResponseSchema = z95.object({
-  nodes: z95.array(treeNodeSchema),
-  truncated: z95.boolean()
+var treeResponseSchema = z96.object({
+  nodes: z96.array(treeNodeSchema),
+  truncated: z96.boolean()
 }).passthrough();
-var nodeResponseSchema = z95.object({
-  id: z95.string(),
-  parentId: z95.string().nullable(),
-  processId: z95.string().nullable(),
-  name: z95.string(),
-  ownerLabel: z95.string().nullable()
+var nodeResponseSchema = z96.object({
+  id: z96.string(),
+  parentId: z96.string().nullable(),
+  processId: z96.string().nullable(),
+  name: z96.string(),
+  ownerLabel: z96.string().nullable()
 }).passthrough();
-var deleteNodeResponseSchema = z95.object({
-  deletedCount: z95.number()
+var deleteNodeResponseSchema = z96.object({
+  deletedCount: z96.number()
 });
-var generateLandscapeResponseSchema = z95.object({
-  started: z95.literal(true),
-  generationId: z95.string(),
-  eligibleCaptureCount: z95.number()
+var generateLandscapeResponseSchema = z96.object({
+  started: z96.literal(true),
+  generationId: z96.string(),
+  eligibleCaptureCount: z96.number()
 }).passthrough();
-var captureSchema = z95.object({
-  id: z95.string(),
-  scope: z95.string(),
-  type: z95.string(),
-  title: z95.string(),
-  organizationId: z95.string().nullable(),
-  organizationName: z95.string().nullable(),
-  teamId: z95.string().nullable(),
-  teamName: z95.string().nullable(),
-  processNodeId: z95.string().nullable(),
-  createdAt: z95.string(),
-  transcriptMessageCount: z95.number()
+var captureSchema = z96.object({
+  id: z96.string(),
+  scope: z96.string(),
+  type: z96.string(),
+  title: z96.string(),
+  organizationId: z96.string().nullable(),
+  organizationName: z96.string().nullable(),
+  teamId: z96.string().nullable(),
+  teamName: z96.string().nullable(),
+  processNodeId: z96.string().nullable(),
+  createdAt: z96.string(),
+  transcriptMessageCount: z96.number()
 }).passthrough();
-var captureListResponseSchema = z95.object({
-  captures: z95.array(captureSchema),
-  total: z95.number(),
-  truncated: z95.boolean()
+var captureListResponseSchema = z96.object({
+  captures: z96.array(captureSchema),
+  total: z96.number(),
+  truncated: z96.boolean()
 }).passthrough();
 var LANDSCAPE_COLUMNS = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell"), maxWidth: 36 },
@@ -20521,40 +20577,40 @@ function registerClarityPostprocess(clarity) {
 __name(registerClarityPostprocess, "registerClarityPostprocess");
 
 // src/commands/clarity/process-links.ts
-import { z as z96 } from "zod";
+import { z as z97 } from "zod";
 var MIN_LIMIT7 = 1;
 var MAX_LIMIT7 = 500;
 var DEFAULT_LIMIT7 = 100;
 var ORG_FLAG_DESCRIPTION2 = "organization id for the org-scoped process landscape (overrides DUVO_ORG_ID)";
 var PROCESS_LINKS_RESOURCE_PATH = "/clarity/hierarchy/process-links";
-var processLinkTypeSchema = z96.enum([
+var processLinkTypeSchema = z97.enum([
   "hands_off_to",
   "shares_step_with",
   "variant_of"
 ]);
-var processLinkStateSchema = z96.enum(["suggested", "confirmed"]);
-var processLinkSchema = z96.object({
-  id: z96.string(),
-  source_node_id: z96.string(),
-  target_node_id: z96.string(),
+var processLinkStateSchema = z97.enum(["suggested", "confirmed"]);
+var processLinkSchema = z97.object({
+  id: z97.string(),
+  source_node_id: z97.string(),
+  target_node_id: z97.string(),
   type: processLinkTypeSchema,
   state: processLinkStateSchema,
-  confidence: z96.number().nullable(),
-  created_at: z96.string(),
-  updated_at: z96.string()
+  confidence: z97.number().nullable(),
+  created_at: z97.string(),
+  updated_at: z97.string()
 });
-var listProcessLinksResponseSchema = z96.object({
-  process_links: z96.array(processLinkSchema),
-  total: z96.number(),
-  limit: z96.number(),
-  offset: z96.number()
+var listProcessLinksResponseSchema = z97.object({
+  process_links: z97.array(processLinkSchema),
+  total: z97.number(),
+  limit: z97.number(),
+  offset: z97.number()
 });
-var processLinkMutationResponseSchema = z96.object({
+var processLinkMutationResponseSchema = z97.object({
   process_link: processLinkSchema,
-  created: z96.boolean().optional()
+  created: z97.boolean().optional()
 });
-var deleteProcessLinkResponseSchema = z96.object({
-  deleted: z96.boolean()
+var deleteProcessLinkResponseSchema = z97.object({
+  deleted: z97.boolean()
 });
 var PROCESS_LINK_COLUMNS = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell"), maxWidth: 36 },
@@ -20766,14 +20822,14 @@ function renderProcessLinks(response) {
 __name(renderProcessLinks, "renderProcessLinks");
 
 // src/commands/clarity/promote-current-process.ts
-import { z as z97 } from "zod";
-var snapshotSchema3 = z97.object({
-  snapshot: z97.object({
-    id: z97.string(),
-    status: z97.string(),
-    creator_type: z97.string(),
-    created_at: z97.string(),
-    updated_at: z97.string()
+import { z as z98 } from "zod";
+var snapshotSchema3 = z98.object({
+  snapshot: z98.object({
+    id: z98.string(),
+    status: z98.string(),
+    creator_type: z98.string(),
+    created_at: z98.string(),
+    updated_at: z98.string()
   })
 });
 function registerClarityPromoteCurrentProcess(clarity) {
@@ -20810,14 +20866,14 @@ function registerClarityPromoteCurrentProcess(clarity) {
 __name(registerClarityPromoteCurrentProcess, "registerClarityPromoteCurrentProcess");
 
 // src/commands/clarity/promote-transformation-proposal.ts
-import { z as z98 } from "zod";
-var snapshotSchema4 = z98.object({
-  snapshot: z98.object({
-    id: z98.string(),
-    status: z98.string(),
-    creator_type: z98.string(),
-    created_at: z98.string(),
-    updated_at: z98.string()
+import { z as z99 } from "zod";
+var snapshotSchema4 = z99.object({
+  snapshot: z99.object({
+    id: z99.string(),
+    status: z99.string(),
+    creator_type: z99.string(),
+    created_at: z99.string(),
+    updated_at: z99.string()
   })
 });
 function registerClarityPromoteTransformationProposal(clarity) {
@@ -20893,8 +20949,8 @@ __name(registerClarityRevertTransformationProposal, "registerClarityRevertTransf
 
 // src/commands/clarity/save-snapshot.ts
 import { readFile as readFile7 } from "node:fs/promises";
-import { z as z99 } from "zod";
-var snapshotFileSchema = z99.union([
+import { z as z100 } from "zod";
+var snapshotFileSchema = z100.union([
   saveClarityProcessSnapshotBodySchema.shape.steps,
   saveClarityProcessSnapshotBodySchema.pick({
     steps: true,
@@ -21893,16 +21949,16 @@ function registerConnectionsList(connections) {
 __name(registerConnectionsList, "registerConnectionsList");
 
 // src/commands/connections/probe.ts
-import { z as z100 } from "zod";
-var toolSchema = z100.object({
-  name: z100.string(),
-  description: z100.string().optional(),
-  input_schema: z100.record(z100.string(), z100.unknown()).optional()
+import { z as z101 } from "zod";
+var toolSchema = z101.object({
+  name: z101.string(),
+  description: z101.string().optional(),
+  input_schema: z101.record(z101.string(), z101.unknown()).optional()
 });
-var probeResponseSchema = z100.object({
-  success: z100.boolean(),
-  tools: z100.array(toolSchema).optional(),
-  error: z100.string().optional()
+var probeResponseSchema = z101.object({
+  success: z101.boolean(),
+  tools: z101.array(toolSchema).optional(),
+  error: z101.string().optional()
 });
 var DESCRIPTION_MAX_WIDTH = 80;
 var TABLE_COLUMNS22 = [
@@ -22121,48 +22177,48 @@ function registerConnections(program) {
 __name(registerConnections, "registerConnections");
 
 // src/api/credential-schemas.ts
-import { z as z101 } from "zod";
-var dateLike = z101.string();
-var secretSchema = z101.object({
-  id: z101.string(),
-  team_id: z101.string(),
-  user_id: z101.string().nullable(),
-  name: z101.string(),
-  service_slug: z101.string().nullable(),
-  env_var_keys: z101.array(z101.string()),
-  created_by: z101.string(),
+import { z as z102 } from "zod";
+var dateLike = z102.string();
+var secretSchema = z102.object({
+  id: z102.string(),
+  team_id: z102.string(),
+  user_id: z102.string().nullable(),
+  name: z102.string(),
+  service_slug: z102.string().nullable(),
+  env_var_keys: z102.array(z102.string()),
+  created_by: z102.string(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var secretsListResponseSchema = z101.array(secretSchema);
+var secretsListResponseSchema = z102.array(secretSchema);
 var secretResponseSchema = secretSchema;
-var browserLoginSchema = z101.object({
-  id: z101.string(),
-  user_id: z101.string().nullable(),
-  team_id: z101.string(),
-  domain: z101.string(),
-  username: z101.string().nullable(),
+var browserLoginSchema = z102.object({
+  id: z102.string(),
+  user_id: z102.string().nullable(),
+  team_id: z102.string(),
+  domain: z102.string(),
+  username: z102.string().nullable(),
   password: encryptedDataSchema.nullable(),
   otp_secret: encryptedDataSchema.nullable(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var browserLoginsListResponseSchema = z101.array(credentialPreviewSchema);
-var revisionLoginSummarySchema = z101.object({
-  id: z101.string(),
-  user_id: z101.string().nullable(),
-  team_id: z101.string().nullable(),
-  domain: z101.string(),
-  username: z101.string().nullable(),
+var browserLoginsListResponseSchema = z102.array(credentialPreviewSchema);
+var revisionLoginSummarySchema = z102.object({
+  id: z102.string(),
+  user_id: z102.string().nullable(),
+  team_id: z102.string().nullable(),
+  domain: z102.string(),
+  username: z102.string().nullable(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var revisionLoginsListResponseSchema = z101.array(
+var revisionLoginsListResponseSchema = z102.array(
   revisionLoginSummarySchema
 );
-var revisionSecretsListResponseSchema = z101.array(secretSchema);
-var successResponseSchema2 = z101.object({
-  success: z101.boolean()
+var revisionSecretsListResponseSchema = z102.array(secretSchema);
+var successResponseSchema2 = z102.object({
+  success: z102.boolean()
 });
 var attachSuccessResponseSchema = successResponseSchema2;
 var deleteSecretResponseSchema = successResponseSchema2;
@@ -24421,6 +24477,171 @@ function registerProfiles(program) {
 }
 __name(registerProfiles, "registerProfiles");
 
+// src/commands/pulse/answer.ts
+function collectAnswer2(value, previous) {
+  return [...previous, value];
+}
+__name(collectAnswer2, "collectAnswer");
+function buildAnswers(raw) {
+  const answers = {};
+  for (const entry of raw) {
+    const separator = entry.indexOf("=");
+    if (separator <= 0) {
+      throw new CliError(
+        `Invalid --answer "${entry}". Use key=value (e.g. --answer timeframe="last 14 days").`
+      );
+    }
+    const key = entry.slice(0, separator).trim();
+    const value = entry.slice(separator + 1);
+    if (key.length === 0) {
+      throw new CliError(
+        `Invalid --answer "${entry}". The key must not be empty.`
+      );
+    }
+    if (key in answers) {
+      throw new CliError(
+        `Duplicate --answer key "${key}". Pass each key once.`
+      );
+    }
+    answers[key] = value;
+  }
+  return answers;
+}
+__name(buildAnswers, "buildAnswers");
+function registerPulseAnswer(pulse) {
+  pulse.command("answer <id>").description(
+    "Answer a pending question from the Pulse agent and resume the run (requires edit access). Find the tool call id and question keys in the pending question's payload via `duvo pulse messages --json`."
+  ).requiredOption(
+    "--tool-call-id <id>",
+    "the tool call id of the pending question"
+  ).option(
+    "--answer <key=value>",
+    "an answer as key=value; repeat for multiple answers",
+    collectAnswer2,
+    []
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function answerAction(id, options) {
+    const pulseId = trimRequired(id, "<id>");
+    const toolCallId = trimRequired(
+      options.toolCallId ?? "",
+      "--tool-call-id"
+    );
+    const answers = buildAnswers(options.answer);
+    if (Object.keys(answers).length === 0) {
+      throw new CliError("At least one --answer key=value is required.");
+    }
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/artifacts/${encodeURIComponent(pulseId)}/answer`,
+      apiKey,
+      apiBaseUrl,
+      body: { toolCallId, answers }
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = answerArtifactQuestionResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    console.log(green("Answer sent. The agent is resuming the dashboard\u2026"));
+    console.log();
+    console.log(`Track progress with: duvo pulse get ${pulseId}`);
+  }, "answerAction"));
+}
+__name(registerPulseAnswer, "registerPulseAnswer");
+
+// src/commands/pulse/connections.ts
+var TABLE_COLUMNS28 = [
+  {
+    header: "CONNECTION ID",
+    cell: /* @__PURE__ */ __name((row) => row.connection_id, "cell")
+  },
+  { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
+  { header: "CREATED", cell: /* @__PURE__ */ __name((row) => row.created_at, "cell") }
+];
+function registerList3(connections) {
+  connections.command("list <id>").description("List the connections attached to a Pulse dashboard").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(id, options) {
+    const pulseId = trimRequired(id, "<id>");
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "GET",
+      path: `/v2/artifacts/${encodeURIComponent(pulseId)}/connections`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = listArtifactConnectionsResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    if (parsed.data.connections.length === 0) {
+      console.log("No connections attached.");
+      return;
+    }
+    console.log(renderTable(TABLE_COLUMNS28, parsed.data.connections));
+  }, "listAction"));
+}
+__name(registerList3, "registerList");
+function registerAttach(connections) {
+  connections.command("attach <id> <connection-id>").description(
+    "Attach one of your connections to a Pulse dashboard so the agent can use its data (creator only)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function attachAction(id, connectionId, options) {
+    const pulseId = trimRequired(id, "<id>");
+    const connection = trimRequired(connectionId, "<connection-id>");
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/artifacts/${encodeURIComponent(pulseId)}/connections`,
+      apiKey,
+      apiBaseUrl,
+      body: { connection_id: connection }
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    console.log(green(`Connection "${connection}" attached.`));
+  }, "attachAction"));
+}
+__name(registerAttach, "registerAttach");
+function registerDetach(connections) {
+  connections.command("detach <id> <connection-id>").description("Detach a connection from a Pulse dashboard (creator only)").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function detachAction(id, connectionId, options) {
+    const pulseId = trimRequired(id, "<id>");
+    const connection = trimRequired(connectionId, "<connection-id>");
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "DELETE",
+      path: `/v2/artifacts/${encodeURIComponent(pulseId)}/connections/${encodeURIComponent(connection)}`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    console.log(green(`Connection "${connection}" detached.`));
+  }, "detachAction"));
+}
+__name(registerDetach, "registerDetach");
+function registerPulseConnections(pulse) {
+  const connections = pulse.command("connections").description(
+    "Manage the connections (data sources) attached to a Pulse dashboard"
+  );
+  registerList3(connections);
+  registerAttach(connections);
+  registerDetach(connections);
+}
+__name(registerPulseConnections, "registerPulseConnections");
+
 // src/commands/pulse/create.ts
 function registerPulseCreate(pulse) {
   pulse.command("create").description(
@@ -24491,6 +24712,44 @@ function registerPulseDelete(pulse) {
 }
 __name(registerPulseDelete, "registerPulseDelete");
 
+// src/commands/pulse/duplicate.ts
+function registerPulseDuplicate(pulse) {
+  pulse.command("duplicate <id>").description(
+    "Duplicate a Pulse dashboard into a new idle clone. The conversation, shares, and connections are not copied."
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function duplicateAction(id, options) {
+    const pulseId = trimRequired(id, "<id>");
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/artifacts/${encodeURIComponent(pulseId)}/duplicate`,
+      apiKey,
+      apiBaseUrl,
+      body: {}
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = duplicateArtifactResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    console.log(green("Pulse dashboard duplicated."));
+    console.log();
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: parsed.data.id },
+        { label: "Title", value: parsed.data.title ?? "" }
+      ])
+    );
+    console.log();
+    console.log(`Open the clone with: duvo pulse get ${parsed.data.id}`);
+  }, "duplicateAction"));
+}
+__name(registerPulseDuplicate, "registerPulseDuplicate");
+
 // src/commands/pulse/get.ts
 function registerPulseGet(pulse) {
   pulse.command("get <id>").description("Get a Pulse dashboard's metadata and generation status").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function getAction(id, options) {
@@ -24567,7 +24826,7 @@ __name(registerPulseHtml, "registerPulseHtml");
 var DEFAULT_LIMIT9 = 20;
 var MIN_LIMIT9 = 1;
 var MAX_LIMIT9 = 100;
-var TABLE_COLUMNS28 = [
+var TABLE_COLUMNS29 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   {
     header: "TITLE",
@@ -24629,7 +24888,7 @@ function registerPulseList(pulse) {
       console.log("No Pulse dashboards found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS28, response.artifacts));
+    console.log(renderTable(TABLE_COLUMNS29, response.artifacts));
     console.log(
       `Showing ${response.artifacts.length} of ${response.total} \xB7 offset ${response.offset}`
     );
@@ -24637,6 +24896,63 @@ function registerPulseList(pulse) {
 }
 __name(registerPulseList, "registerPulseList");
 
+// src/commands/pulse/messages.ts
+var DEFAULT_LIMIT10 = 100;
+var MIN_LIMIT10 = 1;
+var MAX_LIMIT10 = 500;
+var TABLE_COLUMNS30 = [
+  { header: "ROLE", cell: /* @__PURE__ */ __name((row) => row.role, "cell") },
+  {
+    header: "CONTENT",
+    cell: /* @__PURE__ */ __name((row) => row.content.replace(/\s+/g, " "), "cell"),
+    maxWidth: 60
+  },
+  { header: "CREATED", cell: /* @__PURE__ */ __name((row) => row.created_at, "cell") }
+];
+function registerPulseMessages(pulse) {
+  pulse.command("messages <id>").description("List a Pulse dashboard's chat transcript (creator only)").option("--limit <n>", `page size (${MIN_LIMIT10}-${MAX_LIMIT10})`).option("--offset <n>", "number of messages to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function messagesAction(id, options) {
+    const pulseId = trimRequired(id, "<id>");
+    const limit = parseLimit(options.limit, {
+      defaultValue: DEFAULT_LIMIT10,
+      min: MIN_LIMIT10,
+      max: MAX_LIMIT10
+    });
+    const offset = parseOffset(options.offset);
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const searchParams = new URLSearchParams();
+    searchParams.append("limit", String(limit));
+    searchParams.append("offset", String(offset));
+    const raw = await httpRequest({
+      method: "GET",
+      path: `/v2/artifacts/${encodeURIComponent(pulseId)}/messages`,
+      apiKey,
+      apiBaseUrl,
+      searchParams
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = artifactMessageListResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const { data, total } = parsed.data;
+    if (data.length === 0) {
+      console.log("No messages yet.");
+      return;
+    }
+    console.log(renderTable(TABLE_COLUMNS30, data));
+    console.log(`Showing ${data.length} of ${total} \xB7 offset ${offset}`);
+    console.log(
+      "Run with --json to see full message payloads, including the tool call id `duvo pulse answer` needs."
+    );
+  }, "messagesAction"));
+}
+__name(registerPulseMessages, "registerPulseMessages");
+
 // src/commands/pulse/pdf.ts
 import { writeFile as writeFile2 } from "node:fs/promises";
 
@@ -24682,6 +24998,47 @@ function registerPulsePdf(pulse) {
 }
 __name(registerPulsePdf, "registerPulsePdf");
 
+// src/commands/pulse/rename.ts
+var MAX_TITLE_LENGTH = 120;
+function registerPulseRename(pulse) {
+  pulse.command("rename <id>").description("Rename a Pulse dashboard (creator only)").requiredOption("--title <title>", "the new title (1-120 chars)").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function renameAction(id, options) {
+    const pulseId = trimRequired(id, "<id>");
+    const title = trimRequired(options.title ?? "", "--title");
+    if (title.length > MAX_TITLE_LENGTH) {
+      throw new CliError(
+        `--title must be ${MAX_TITLE_LENGTH} characters or fewer.`
+      );
+    }
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "PATCH",
+      path: `/v2/artifacts/${encodeURIComponent(pulseId)}`,
+      apiKey,
+      apiBaseUrl,
+      body: { title }
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = artifactSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    console.log(green("Pulse dashboard renamed."));
+    console.log();
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: parsed.data.id },
+        { label: "Title", value: parsed.data.title ?? "" }
+      ])
+    );
+  }, "renameAction"));
+}
+__name(registerPulseRename, "registerPulseRename");
+
 // src/commands/pulse/restore.ts
 function registerPulseRestore(pulse) {
   pulse.command("restore <id> <version-id>").description(
@@ -24753,6 +25110,80 @@ function registerPulseSendMessage(pulse) {
 }
 __name(registerPulseSendMessage, "registerPulseSendMessage");
 
+// src/commands/pulse/share.ts
+function parseVisibility(value) {
+  if (value === "private" || value === "team") {
+    return value;
+  }
+  throw new CliError("--visibility must be one of: private, team.");
+}
+__name(parseVisibility, "parseVisibility");
+function parsePermission(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === "view" || value === "edit") {
+    return value;
+  }
+  throw new CliError("--permission must be one of: view, edit.");
+}
+__name(parsePermission, "parsePermission");
+function registerPulseShare(pulse) {
+  pulse.command("share <id>").description(
+    "Share a Pulse dashboard with your team, or revert it to private (creator only)."
+  ).requiredOption(
+    "--visibility <visibility>",
+    "private (creator only) or team (visible to your whole team)"
+  ).option(
+    "--permission <permission>",
+    "when sharing to the team: view (rendered dashboard only) or edit (teammates can also iterate). Default view."
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function shareAction(id, options) {
+    const pulseId = trimRequired(id, "<id>");
+    const visibility = parseVisibility(options.visibility);
+    const permission = parsePermission(options.permission);
+    if (visibility === "private" && permission) {
+      throw new CliError(
+        "--permission only applies when sharing to the team (--visibility team)."
+      );
+    }
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const body = {
+      visibility
+    };
+    if (permission) {
+      body.permission = permission;
+    }
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/artifacts/${encodeURIComponent(pulseId)}/publish`,
+      apiKey,
+      apiBaseUrl,
+      body
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = artifactSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const message = parsed.data.visibility === "team" ? `Pulse dashboard shared with your team (${parsed.data.publish_permission} access).` : "Pulse dashboard reverted to private.";
+    console.log(green(message));
+    console.log();
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: parsed.data.id },
+        { label: "Visibility", value: parsed.data.visibility },
+        { label: "Permission", value: parsed.data.publish_permission }
+      ])
+    );
+  }, "shareAction"));
+}
+__name(registerPulseShare, "registerPulseShare");
+
 // src/commands/pulse/snapshot.ts
 import { writeFile as writeFile3 } from "node:fs/promises";
 var SNAPSHOT_REQUEST_TIMEOUT_MS = 9e4;
@@ -24839,14 +25270,20 @@ function registerPulse(program) {
   registerPulsePdf(pulse);
   registerPulseSnapshot(pulse);
   registerPulseSendMessage(pulse);
+  registerPulseRename(pulse);
+  registerPulseShare(pulse);
+  registerPulseDuplicate(pulse);
   registerPulseDelete(pulse);
   registerPulseVersions(pulse);
   registerPulseRestore(pulse);
+  registerPulseMessages(pulse);
+  registerPulseAnswer(pulse);
+  registerPulseConnections(pulse);
 }
 __name(registerPulse, "registerPulse");
 
 // src/commands/queue-labels/index.ts
-var TABLE_COLUMNS29 = [
+var TABLE_COLUMNS31 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "KEY", cell: /* @__PURE__ */ __name((row) => row.key, "cell") },
   { header: "VALUE", cell: /* @__PURE__ */ __name((row) => row.value, "cell") },
@@ -24861,13 +25298,13 @@ var TABLE_COLUMNS29 = [
 ];
 function registerQueueLabels(program) {
   const labels = program.command("queue-labels").description("Manage label vocabularies on a queue");
-  registerList3(labels);
+  registerList4(labels);
   registerCreate(labels);
   registerUpdate(labels);
   registerDelete(labels);
 }
 __name(registerQueueLabels, "registerQueueLabels");
-function registerList3(labels) {
+function registerList4(labels) {
   labels.command("list", { isDefault: true }).description(
     "List labels defined on a queue along with the number of cases each is assigned to"
   ).requiredOption("--queue <id>", "ID of the queue").option("--limit <n>", "page size (1-1000, default 1000)").option("--offset <n>", "number of labels to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
@@ -24900,11 +25337,11 @@ function registerList3(labels) {
       console.log("No labels defined on this queue.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS29, parsed.data.labels));
+    console.log(renderTable(TABLE_COLUMNS31, parsed.data.labels));
     console.log(`Showing ${parsed.data.labels.length}`);
   }, "listAction"));
 }
-__name(registerList3, "registerList");
+__name(registerList4, "registerList");
 function registerCreate(labels) {
   labels.command("create").description("Create a label on a queue without assigning it to a case").requiredOption("--queue <id>", "ID of the queue").option("--key <text>", "label key (omit for tag-only labels)").requiredOption("--value <text>", "label value (required, non-empty)").option("--color-hue <n>", "color hue 0-360 (auto-derived if omitted)").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function createAction(options) {
     if (options.value.trim().length === 0) {
@@ -25651,10 +26088,10 @@ function registerQueuesLinkAgent(queues) {
 __name(registerQueuesLinkAgent, "registerQueuesLinkAgent");
 
 // src/commands/queues/list.ts
-var DEFAULT_LIMIT10 = 20;
-var MIN_LIMIT10 = 1;
-var MAX_LIMIT10 = 100;
-var TABLE_COLUMNS30 = [
+var DEFAULT_LIMIT11 = 20;
+var MIN_LIMIT11 = 1;
+var MAX_LIMIT11 = 100;
+var TABLE_COLUMNS32 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -25665,11 +26102,11 @@ var TABLE_COLUMNS30 = [
   { header: "CREATED", cell: /* @__PURE__ */ __name((row) => row.created_at ?? "", "cell") }
 ];
 function registerQueuesList(queues) {
-  queues.command("list", { isDefault: true }).description("List queues for your team").option("--limit <n>", `page size (${MIN_LIMIT10}-${MAX_LIMIT10})`).option("--offset <n>", "number of queues to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
+  queues.command("list", { isDefault: true }).description("List queues for your team").option("--limit <n>", `page size (${MIN_LIMIT11}-${MAX_LIMIT11})`).option("--offset <n>", "number of queues to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT10,
-      min: MIN_LIMIT10,
-      max: MAX_LIMIT10
+      defaultValue: DEFAULT_LIMIT11,
+      min: MIN_LIMIT11,
+      max: MAX_LIMIT11
     });
     const offset = parseOffset(options.offset);
     const config = await requireAuthenticatedConfig(this);
@@ -25702,7 +26139,7 @@ function registerQueuesList(queues) {
       console.log("No queues found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS30, response.queues));
+    console.log(renderTable(TABLE_COLUMNS32, response.queues));
     const resolvedOffset = response.offset ?? offset;
     const total = response.total ?? null;
     const summary = total === null ? `Showing ${response.queues.length} \xB7 offset ${resolvedOffset}` : `Showing ${response.queues.length} of ${total} \xB7 offset ${resolvedOffset}`;
@@ -25960,7 +26397,7 @@ function registerRevisionLoginsDetach(revisionLogins) {
 __name(registerRevisionLoginsDetach, "registerRevisionLoginsDetach");
 
 // src/commands/revision-logins/list.ts
-var TABLE_COLUMNS31 = [
+var TABLE_COLUMNS33 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "DOMAIN", cell: /* @__PURE__ */ __name((row) => row.domain, "cell") },
   {
@@ -25996,7 +26433,7 @@ function registerRevisionLoginsList(revisionLogins) {
       console.log("No browser logins attached to this revision.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS31, rows));
+    console.log(renderTable(TABLE_COLUMNS33, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -26069,7 +26506,7 @@ function registerRevisionSecretsDetach(revisionSecrets) {
 __name(registerRevisionSecretsDetach, "registerRevisionSecretsDetach");
 
 // src/commands/revision-secrets/list.ts
-var TABLE_COLUMNS32 = [
+var TABLE_COLUMNS34 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -26107,7 +26544,7 @@ function registerRevisionSecretsList(revisionSecrets) {
       console.log("No secrets attached to this revision.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS32, rows));
+    console.log(renderTable(TABLE_COLUMNS34, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -26123,91 +26560,91 @@ function registerRevisionSecrets(program) {
 __name(registerRevisionSecrets, "registerRevisionSecrets");
 
 // src/api/run-schemas.ts
-import { z as z102 } from "zod";
-var publicRunSchema = z102.object({
-  id: z102.string(),
-  agent_id: z102.string(),
-  build_id: z102.string(),
-  status: z102.string(),
-  source: z102.string().nullish(),
-  sandbox_id: z102.string().nullish(),
-  started_at: z102.string().nullish(),
-  completed_at: z102.string().nullish(),
-  created_at: z102.string(),
-  updated_at: z102.string().nullish(),
-  human_in_the_loop_enabled: z102.boolean().nullish()
-});
-var startRunResponseSchema = z102.object({
+import { z as z103 } from "zod";
+var publicRunSchema = z103.object({
+  id: z103.string(),
+  agent_id: z103.string(),
+  build_id: z103.string(),
+  status: z103.string(),
+  source: z103.string().nullish(),
+  sandbox_id: z103.string().nullish(),
+  started_at: z103.string().nullish(),
+  completed_at: z103.string().nullish(),
+  created_at: z103.string(),
+  updated_at: z103.string().nullish(),
+  human_in_the_loop_enabled: z103.boolean().nullish()
+});
+var startRunResponseSchema = z103.object({
   run: publicRunSchema
 });
-var questionOptionSchema = z102.object({
-  label: z102.string(),
-  description: z102.string().nullish()
-});
-var questionSchema = z102.object({
-  question: z102.string(),
-  header: z102.string().nullish(),
-  options: z102.array(questionOptionSchema).nullish(),
-  multi_select: z102.boolean().nullish()
-});
-var pendingHumanRequestSchema = z102.object({
-  id: z102.string(),
-  title: z102.string(),
-  description: z102.string().nullish(),
-  created_at: z102.string(),
-  type: z102.string(),
-  questions: z102.array(questionSchema).nullish()
-});
-var getRunResponseSchema = z102.object({
+var questionOptionSchema = z103.object({
+  label: z103.string(),
+  description: z103.string().nullish()
+});
+var questionSchema = z103.object({
+  question: z103.string(),
+  header: z103.string().nullish(),
+  options: z103.array(questionOptionSchema).nullish(),
+  multi_select: z103.boolean().nullish()
+});
+var pendingHumanRequestSchema = z103.object({
+  id: z103.string(),
+  title: z103.string(),
+  description: z103.string().nullish(),
+  created_at: z103.string(),
+  type: z103.string(),
+  questions: z103.array(questionSchema).nullish()
+});
+var getRunResponseSchema = z103.object({
   run: publicRunSchema.nullable(),
   pending_human_request: pendingHumanRequestSchema.nullish()
 });
-var stopRunResponseSchema = z102.object({
-  success: z102.boolean(),
-  message: z102.string().nullish()
-});
-var runMessageSchema = z102.object({
-  id: z102.string(),
-  type: z102.string(),
-  role: z102.string(),
-  timestamp: z102.string(),
-  text_content: z102.string().nullish(),
-  tool_call: z102.object({
-    id: z102.string(),
-    name: z102.string(),
-    arguments: z102.record(z102.string(), z102.unknown()).nullish()
+var stopRunResponseSchema = z103.object({
+  success: z103.boolean(),
+  message: z103.string().nullish()
+});
+var runMessageSchema = z103.object({
+  id: z103.string(),
+  type: z103.string(),
+  role: z103.string(),
+  timestamp: z103.string(),
+  text_content: z103.string().nullish(),
+  tool_call: z103.object({
+    id: z103.string(),
+    name: z103.string(),
+    arguments: z103.record(z103.string(), z103.unknown()).nullish()
   }).nullish(),
-  tool_result: z102.object({
-    tool_call_id: z102.string(),
-    result: z102.unknown().nullish(),
-    error: z102.string().nullish()
+  tool_result: z103.object({
+    tool_call_id: z103.string(),
+    result: z103.unknown().nullish(),
+    error: z103.string().nullish()
   }).nullish()
 });
-var listRunMessagesResponseSchema = z102.object({
-  messages: z102.array(runMessageSchema),
-  total: z102.number().nullish(),
-  limit: z102.number().nullish(),
-  offset: z102.number().nullish()
+var listRunMessagesResponseSchema = z103.object({
+  messages: z103.array(runMessageSchema),
+  total: z103.number().nullish(),
+  limit: z103.number().nullish(),
+  offset: z103.number().nullish()
 });
-var postedMessageSchema = z102.object({
-  id: z102.string(),
-  type: z102.string(),
-  role: z102.string(),
-  timestamp: z102.string(),
-  text_content: z102.string()
+var postedMessageSchema = z103.object({
+  id: z103.string(),
+  type: z103.string(),
+  role: z103.string(),
+  timestamp: z103.string(),
+  text_content: z103.string()
 });
-var postRunMessageResponseSchema = z102.object({
+var postRunMessageResponseSchema = z103.object({
   message: postedMessageSchema
 });
-var respondHumanRequestResponseSchema = z102.object({
-  human_request: z102.object({
-    id: z102.string(),
-    run_id: z102.string(),
-    title: z102.string(),
-    description: z102.string().nullish(),
-    response: z102.string().nullish(),
-    responded_at: z102.string().nullish(),
-    created_at: z102.string()
+var respondHumanRequestResponseSchema = z103.object({
+  human_request: z103.object({
+    id: z103.string(),
+    run_id: z103.string(),
+    title: z103.string(),
+    description: z103.string().nullish(),
+    response: z103.string().nullish(),
+    responded_at: z103.string().nullish(),
+    created_at: z103.string()
   })
 });
 
@@ -26352,13 +26789,13 @@ function registerRunsGet(runs) {
 __name(registerRunsGet, "registerRunsGet");
 
 // src/commands/runs/list.ts
-var DEFAULT_LIMIT11 = 20;
-var MIN_LIMIT11 = 1;
-var MAX_LIMIT11 = 100;
+var DEFAULT_LIMIT12 = 20;
+var MIN_LIMIT12 = 1;
+var MAX_LIMIT12 = 100;
 var SORT_ORDERS2 = ["asc", "desc"];
 var HAS_ISSUES_VALUES = ["true", "false"];
 var TITLE_PREVIEW_WIDTH = 50;
-var TABLE_COLUMNS33 = [
+var TABLE_COLUMNS35 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "RUN#", cell: /* @__PURE__ */ __name((row) => String(row.run_number), "cell") },
   { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
@@ -26382,7 +26819,7 @@ function isHasIssuesValue(value) {
 }
 __name(isHasIssuesValue, "isHasIssuesValue");
 function registerRunsList(runs) {
-  runs.command("list").description("List agent runs for your team").option("--limit <n>", `page size (${MIN_LIMIT11}-${MAX_LIMIT11})`).option("--offset <n>", "number of runs to skip").option("--sort-order <order>", `sort direction (${SORT_ORDERS2.join("|")})`).option(
+  runs.command("list").description("List agent runs for your team").option("--limit <n>", `page size (${MIN_LIMIT12}-${MAX_LIMIT12})`).option("--offset <n>", "number of runs to skip").option("--sort-order <order>", `sort direction (${SORT_ORDERS2.join("|")})`).option(
     "--status <status>",
     "filter by status (e.g. running, completed, failed, waiting, interrupted, stopped, needs_attention)"
   ).option("--agent <id>", "filter by agent ID").option("--user <id>", "filter by user ID").option("--case-queue <id>", "filter by queue ID").option("--source <source>", "filter by source").option("--search <query>", "free-text search across runs").option(
@@ -26390,9 +26827,9 @@ function registerRunsList(runs) {
     `show only runs with (or without) issues (${HAS_ISSUES_VALUES.join("|")})`
   ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT11,
-      min: MIN_LIMIT11,
-      max: MAX_LIMIT11
+      defaultValue: DEFAULT_LIMIT12,
+      min: MIN_LIMIT12,
+      max: MAX_LIMIT12
     });
     const offset = parseOffset(options.offset);
     if (options.sortOrder !== void 0 && !isSortOrder(options.sortOrder)) {
@@ -26459,7 +26896,7 @@ function registerRunsList(runs) {
       console.log("No runs found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS33, response.data));
+    console.log(renderTable(TABLE_COLUMNS35, response.data));
     console.log(
       `Showing ${response.data.length} of ${response.total} \xB7 offset ${offset}`
     );
@@ -26565,11 +27002,11 @@ function getContent(msg) {
 __name(getContent, "getContent");
 
 // src/commands/runs/messages.ts
-var DEFAULT_LIMIT12 = 20;
-var MIN_LIMIT12 = 1;
-var MAX_LIMIT12 = 50;
+var DEFAULT_LIMIT13 = 20;
+var MIN_LIMIT13 = 1;
+var MAX_LIMIT13 = 50;
 var TEXT_PREVIEW_WIDTH2 = 60;
-var TABLE_COLUMNS34 = [
+var TABLE_COLUMNS36 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "ROLE", cell: /* @__PURE__ */ __name((row) => row.role, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
@@ -26594,7 +27031,7 @@ function previewCell(row) {
 }
 __name(previewCell, "previewCell");
 function registerRunsMessages(runs) {
-  runs.command("messages <id>").description("List messages for an agent run").option("--limit <n>", `page size (${MIN_LIMIT12}-${MAX_LIMIT12})`).option("--offset <n>", "number of messages to skip").option("--follow", "poll for new messages until the job completes").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function messagesAction(id, options) {
+  runs.command("messages <id>").description("List messages for an agent run").option("--limit <n>", `page size (${MIN_LIMIT13}-${MAX_LIMIT13})`).option("--offset <n>", "number of messages to skip").option("--follow", "poll for new messages until the job completes").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function messagesAction(id, options) {
     const offset = parseOffset(options.offset);
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
     if (options.follow) {
@@ -26605,9 +27042,9 @@ function registerRunsMessages(runs) {
       return;
     }
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT12,
-      min: MIN_LIMIT12,
-      max: MAX_LIMIT12
+      defaultValue: DEFAULT_LIMIT13,
+      min: MIN_LIMIT13,
+      max: MAX_LIMIT13
     });
     const searchParams = new URLSearchParams();
     searchParams.append("limit", String(limit));
@@ -26634,7 +27071,7 @@ function registerRunsMessages(runs) {
       console.log("No messages found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS34, response.messages));
+    console.log(renderTable(TABLE_COLUMNS36, response.messages));
     const resolvedOffset = response.offset ?? offset;
     const summary = response.total === null || response.total === void 0 ? `Showing ${response.messages.length} \xB7 offset ${resolvedOffset}` : `Showing ${response.messages.length} of ${response.total} \xB7 offset ${resolvedOffset}`;
     console.log(summary);
@@ -26643,10 +27080,10 @@ function registerRunsMessages(runs) {
 __name(registerRunsMessages, "registerRunsMessages");
 
 // src/commands/runs/respond.ts
-function collectAnswer2(value, previous = []) {
+function collectAnswer3(value, previous = []) {
   return [...previous, value];
 }
-__name(collectAnswer2, "collectAnswer");
+__name(collectAnswer3, "collectAnswer");
 function parseAnswers2(raw) {
   const answers = /* @__PURE__ */ Object.create(null);
   for (const entry of raw) {
@@ -26722,7 +27159,7 @@ function registerRunsRespond(runs) {
   ).option("--approve", "approve an approval-type request").option("--deny", "deny an approval-type request").option(
     "--answer <question=answer>",
     "answer a question-type request (repeatable)",
-    collectAnswer2,
+    collectAnswer3,
     []
   ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function respondAction(runId, requestIdArg, options) {
     const body = buildBody6(options);
@@ -26902,28 +27339,28 @@ function registerRuns(program) {
 __name(registerRuns, "registerRuns");
 
 // src/api/sandbox-schemas.ts
-import { z as z103 } from "zod";
-var createSandboxResponseSchema = z103.object({
-  sandbox_id: z103.string(),
-  expires_at: z103.string()
+import { z as z104 } from "zod";
+var createSandboxResponseSchema = z104.object({
+  sandbox_id: z104.string(),
+  expires_at: z104.string()
 });
-var createSandboxUploadUrlResponseSchema = z103.object({
-  upload_url: z103.string(),
-  path: z103.string(),
-  expires_in_seconds: z103.number()
+var createSandboxUploadUrlResponseSchema = z104.object({
+  upload_url: z104.string(),
+  path: z104.string(),
+  expires_in_seconds: z104.number()
 });
-var sandboxFileSchema = z103.object({
-  name: z103.string(),
-  path: z103.string(),
-  type: z103.enum(["file", "dir"]),
-  size_bytes: z103.number()
+var sandboxFileSchema = z104.object({
+  name: z104.string(),
+  path: z104.string(),
+  type: z104.enum(["file", "dir"]),
+  size_bytes: z104.number()
 });
-var listSandboxFilesResponseSchema = z103.object({
-  files: z103.array(sandboxFileSchema)
+var listSandboxFilesResponseSchema = z104.object({
+  files: z104.array(sandboxFileSchema)
 });
-var uploadSandboxFileResponseSchema = z103.object({
-  path: z103.string(),
-  size_bytes: z103.number()
+var uploadSandboxFileResponseSchema = z104.object({
+  path: z104.string(),
+  size_bytes: z104.number()
 });
 var DEFAULT_SANDBOX_FILES_PATH = "/workspace";
 
@@ -26960,7 +27397,7 @@ function registerSandboxesCreate(sandboxes) {
 __name(registerSandboxesCreate, "registerSandboxesCreate");
 
 // src/commands/sandboxes/files.ts
-var TABLE_COLUMNS35 = [
+var TABLE_COLUMNS37 = [
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "PATH", cell: /* @__PURE__ */ __name((row) => row.path, "cell") },
@@ -26998,7 +27435,7 @@ function registerSandboxesFiles(sandboxes) {
       console.log("No files found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS35, files));
+    console.log(renderTable(TABLE_COLUMNS37, files));
     console.log(`Showing ${files.length}`);
   }, "filesAction"));
 }
@@ -27343,7 +27780,7 @@ function registerSecretsGet(secrets) {
 __name(registerSecretsGet, "registerSecretsGet");
 
 // src/commands/secrets/list.ts
-var TABLE_COLUMNS36 = [
+var TABLE_COLUMNS38 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -27387,7 +27824,7 @@ function registerSecretsList(secrets) {
       console.log("No secrets found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS36, rows));
+    console.log(renderTable(TABLE_COLUMNS38, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -27498,7 +27935,7 @@ function registerSecrets(program) {
 __name(registerSecrets, "registerSecrets");
 
 // src/commands/skills/assignments.ts
-var TABLE_COLUMNS37 = [
+var TABLE_COLUMNS39 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") }
 ];
@@ -27526,7 +27963,7 @@ function registerSkillsAssignments(skills) {
       console.log("No agents use this skill.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS37, assignments));
+    console.log(renderTable(TABLE_COLUMNS39, assignments));
     console.log(`Showing ${assignments.length} of ${total}`);
   }, "assignmentsAction"));
 }
@@ -27534,13 +27971,13 @@ __name(registerSkillsAssignments, "registerSkillsAssignments");
 
 // src/commands/skills/create.ts
 import { readFileSync as readFileSync5 } from "node:fs";
-import { z as z104 } from "zod";
-var createSkillResponseSchema = z104.object({
-  skill: z104.object({
-    id: z104.string(),
-    name: z104.string(),
-    description: z104.string(),
-    team_id: z104.string()
+import { z as z105 } from "zod";
+var createSkillResponseSchema = z105.object({
+  skill: z105.object({
+    id: z105.string(),
+    name: z105.string(),
+    description: z105.string(),
+    team_id: z105.string()
   })
 });
 function registerSkillsCreate(skills) {
@@ -27808,7 +28245,7 @@ function readContent2(options) {
 __name(readContent2, "readContent");
 
 // src/commands/skills/files.ts
-var TABLE_COLUMNS38 = [
+var TABLE_COLUMNS40 = [
   { header: "PATH", cell: /* @__PURE__ */ __name((row) => row.path, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -27847,7 +28284,7 @@ function registerSkillsFiles(skills) {
       console.log("No files found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS38, parsed.data.files));
+    console.log(renderTable(TABLE_COLUMNS40, parsed.data.files));
     console.log(`Showing ${parsed.data.files.length}`);
   }, "filesAction"));
 }
@@ -27904,13 +28341,13 @@ function readExistingContent(source) {
 __name(readExistingContent, "readExistingContent");
 
 // src/commands/skills/install.ts
-import { z as z105 } from "zod";
-var installSkillResponseSchema = z105.object({
-  skill: z105.object({
-    id: z105.string(),
-    name: z105.string(),
-    description: z105.string(),
-    team_id: z105.string()
+import { z as z106 } from "zod";
+var installSkillResponseSchema = z106.object({
+  skill: z106.object({
+    id: z106.string(),
+    name: z106.string(),
+    description: z106.string(),
+    team_id: z106.string()
   })
 });
 function registerSkillsInstall(skills) {
@@ -28100,13 +28537,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 z106 } from "zod";
-var uploadSkillResponseSchema = z106.object({
-  skill: z106.object({
-    id: z106.string(),
-    name: z106.string(),
-    description: z106.string(),
-    team_id: z106.string()
+import { z as z107 } from "zod";
+var uploadSkillResponseSchema = z107.object({
+  skill: z107.object({
+    id: z107.string(),
+    name: z107.string(),
+    description: z107.string(),
+    team_id: z107.string()
   })
 });
 function registerSkillsUpload(skills) {
@@ -28225,12 +28662,12 @@ function registerSuggestionsConsume(suggestions) {
 __name(registerSuggestionsConsume, "registerSuggestionsConsume");
 
 // src/commands/suggestions/list.ts
-var DEFAULT_LIMIT13 = 100;
-var MIN_LIMIT13 = 1;
-var MAX_LIMIT13 = 250;
+var DEFAULT_LIMIT14 = 100;
+var MIN_LIMIT14 = 1;
+var MAX_LIMIT14 = 250;
 var STATUS_FILTERS = ["pending", "history"];
 var TITLE_PREVIEW_WIDTH2 = 50;
-var TABLE_COLUMNS39 = [
+var TABLE_COLUMNS41 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
   { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
@@ -28251,11 +28688,11 @@ function registerSuggestionsList(suggestions) {
   ).option(
     "--status <filter>",
     `which inbox to show (${STATUS_FILTERS.join("|")}, default: pending)`
-  ).option("--limit <n>", `page size (${MIN_LIMIT13}-${MAX_LIMIT13})`).option("--offset <n>", "number of suggestions to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(agentId, options) {
+  ).option("--limit <n>", `page size (${MIN_LIMIT14}-${MAX_LIMIT14})`).option("--offset <n>", "number of suggestions to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(agentId, options) {
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT13,
-      min: MIN_LIMIT13,
-      max: MAX_LIMIT13
+      defaultValue: DEFAULT_LIMIT14,
+      min: MIN_LIMIT14,
+      max: MAX_LIMIT14
     });
     const offset = parseOffset(options.offset);
     if (options.status !== void 0 && !isStatusFilter(options.status)) {
@@ -28293,7 +28730,7 @@ function registerSuggestionsList(suggestions) {
       console.log(`Pending total: ${pendingCount}`);
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS39, data));
+    console.log(renderTable(TABLE_COLUMNS41, data));
     console.log(
       `Showing ${data.length} \xB7 offset ${offset} \xB7 pending total ${pendingCount}`
     );
@@ -28417,10 +28854,10 @@ function registerTeamGet(team) {
 __name(registerTeamGet, "registerTeamGet");
 
 // src/commands/team/members.ts
-var DEFAULT_LIMIT14 = 50;
-var MIN_LIMIT14 = 1;
-var MAX_LIMIT14 = 100;
-var TABLE_COLUMNS40 = [
+var DEFAULT_LIMIT15 = 50;
+var MIN_LIMIT15 = 1;
+var MAX_LIMIT15 = 100;
+var TABLE_COLUMNS42 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name ?? "", "cell") },
   { header: "EMAIL", cell: /* @__PURE__ */ __name((row) => row.email, "cell") },
@@ -28434,11 +28871,11 @@ function registerTeamMembers(team) {
   team.command("members").description("List members of a team").option(
     "--team <id>",
     "team ID (defaults to the team scoped to your credentials)"
-  ).option("--limit <n>", `page size (${MIN_LIMIT14}-${MAX_LIMIT14})`).option("--offset <n>", "number of members to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function membersAction(options) {
+  ).option("--limit <n>", `page size (${MIN_LIMIT15}-${MAX_LIMIT15})`).option("--offset <n>", "number of members to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function membersAction(options) {
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT14,
-      min: MIN_LIMIT14,
-      max: MAX_LIMIT14
+      defaultValue: DEFAULT_LIMIT15,
+      min: MIN_LIMIT15,
+      max: MAX_LIMIT15
     });
     const offset = parseOffset(options.offset);
     const config = await requireAuthenticatedConfig(this);
@@ -28471,7 +28908,7 @@ function registerTeamMembers(team) {
       console.log("No members found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS40, response.members));
+    console.log(renderTable(TABLE_COLUMNS42, response.members));
     console.log(
       `Showing ${response.members.length} of ${response.total} \xB7 offset ${response.offset}`
     );
@@ -28480,9 +28917,9 @@ function registerTeamMembers(team) {
 __name(registerTeamMembers, "registerTeamMembers");
 
 // src/commands/team/use.ts
-import { z as z107 } from "zod";
+import { z as z108 } 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 = z107.string().regex(TEAM_ID_SHAPE);
+var teamIdSchema = z108.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)"
@@ -28568,14 +29005,14 @@ function registerTeam(program) {
 __name(registerTeam, "registerTeam");
 
 // src/commands/teams/list.ts
-import { z as z108 } from "zod";
-var teamApiSchema2 = z108.object({
-  id: z108.string(),
-  name: z108.string(),
-  organization_id: z108.string().nullable()
+import { z as z109 } from "zod";
+var teamApiSchema2 = z109.object({
+  id: z109.string(),
+  name: z109.string(),
+  organization_id: z109.string().nullable()
 });
-var listMyTeamsResponseSchema3 = z108.object({
-  teams: z108.array(teamApiSchema2)
+var listMyTeamsResponseSchema3 = z109.object({
+  teams: z109.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) {
@@ -28618,17 +29055,17 @@ function registerTeamsList(teams) {
 __name(registerTeamsList, "registerTeamsList");
 
 // src/commands/teams/org.ts
-import { z as z109 } from "zod";
-var orgTeamSchema = z109.object({
-  id: z109.string(),
-  name: z109.string(),
-  userIsMember: z109.boolean(),
-  userRole: z109.string().nullable(),
-  memberCount: z109.number()
-});
-var listOrgTeamsResponseSchema = z109.object({
-  teams: z109.array(orgTeamSchema),
-  total: z109.number()
+import { z as z110 } from "zod";
+var orgTeamSchema = z110.object({
+  id: z110.string(),
+  name: z110.string(),
+  userIsMember: z110.boolean(),
+  userRole: z110.string().nullable(),
+  memberCount: z110.number()
+});
+var listOrgTeamsResponseSchema = z110.object({
+  teams: z110.array(orgTeamSchema),
+  total: z110.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) {
@@ -28730,7 +29167,7 @@ __name(resolveActiveTeamId, "resolveActiveTeamId");
 var version = resolveVersion();
 function resolveVersion() {
   if (true) {
-    return "1.18.1";
+    return "1.19.0";
   }
   const packageJsonPath = join3(
     dirname3(fileURLToPath2(import.meta.url)),
@@ -28814,7 +29251,7 @@ function checkForUpdate() {
 __name(checkForUpdate, "checkForUpdate");
 function loadPackageMeta() {
   if (true) {
-    return { name: "@duvoai/cli", version: "1.18.1" };
+    return { name: "@duvoai/cli", version: "1.19.0" };
   }
   const require2 = createRequire(import.meta.url);
   const raw = require2("../package.json");