@duvoai/cli 1.10.1 → 1.11.0

package/dist/bin/duvo.js

@@ -84,11 +84,11 @@ import { z as z46 } from "zod";
 import { z as z47 } from "zod";
 import { z as z48 } from "zod";
 import { z as z49 } from "zod";
-import { z as z51 } from "zod";
 import { z as z50 } from "zod";
-import { z as z53 } from "zod";
 import { z as z52 } from "zod";
+import { z as z51 } from "zod";
 import { z as z54 } from "zod";
+import { z as z53 } from "zod";
 import { z as z55 } from "zod";
 import { z as z56 } from "zod";
 import { z as z57 } from "zod";
@@ -100,13 +100,14 @@ import { z as z62 } from "zod";
 import { z as z63 } from "zod";
 import { z as z64 } from "zod";
 import { z as z65 } from "zod";
-import { z as z67 } from "zod";
 import { z as z66 } from "zod";
 import { z as z68 } from "zod";
+import { z as z67 } from "zod";
 import { z as z69 } from "zod";
 import { z as z70 } from "zod";
 import { z as z71 } from "zod";
 import { z as z72 } from "zod";
+import { z as z73 } from "zod";
 
 // ../node_modules/.pnpm/jsonrepair@3.13.2/node_modules/jsonrepair/lib/esm/utils/JSONRepairError.js
 var JSONRepairError = class extends Error {
@@ -3064,8 +3065,6 @@ var clarityProcessLandscapeNodeSchema = z14.object({
   sortOrder: z14.number(),
   depth: z14.number(),
   existence: z14.enum(["proposed", "active"]),
-  placementState: z14.enum(["unfiled", "suggested", "confirmed"]),
-  placementConfidence: z14.number().nullable(),
   contentConfirmedAt: z14.string().nullable(),
   existenceConfirmedAt: z14.string().nullable(),
   source: z14.enum(["ai", "human"]),
@@ -3079,6 +3078,10 @@ var clarityProcessLandscapeNodeSchema = z14.object({
   captureSuggestions: z14.array(clarityLandscapeCaptureSuggestionSchema).optional(),
   captureRequests: z14.array(clarityLandscapeCaptureRequestSchema).optional()
 });
+var clarityProcessLandscapeUnlinkedProcessSchema = clarityProcessLandscapeSummarySchema.extend({
+  teamId: z14.guid(),
+  teamName: z14.string().nullable()
+});
 var clarityProcessLandscapeLinkSchema = z14.object({
   id: z14.guid(),
   sourceNodeId: z14.guid(),
@@ -3090,15 +3093,25 @@ var clarityProcessLandscapeLinkSchema = z14.object({
 var clarityProcessLandscapeStatsSchema = z14.object({
   totalNodes: z14.number(),
   processNodes: z14.number(),
-  suggestedPlacements: z14.number(),
-  confirmedPlacements: z14.number(),
-  unfiledNodes: z14.number(),
+  proposedNodes: z14.number(),
+  unsortedProcesses: z14.number(),
   latestUpdatedAt: z14.string().nullable()
 });
+var clarityProcessLandscapeGenerationSchema = z14.object({
+  eligibleCaptureCount: z14.number(),
+  status: z14.enum(["idle", "starting", "running", "completed", "failed"])
+});
+var generateClarityProcessLandscapeResponseSchema = z14.object({
+  started: z14.literal(true),
+  generationId: z14.guid(),
+  eligibleCaptureCount: z14.number()
+});
 var clarityProcessLandscapeResponseSchema = z14.object({
   nodes: z14.array(clarityProcessLandscapeNodeSchema),
   links: z14.array(clarityProcessLandscapeLinkSchema),
+  unlinkedProcesses: z14.array(clarityProcessLandscapeUnlinkedProcessSchema),
   stats: clarityProcessLandscapeStatsSchema,
+  generation: clarityProcessLandscapeGenerationSchema,
   truncated: z14.boolean()
 });
 var GENERATION_STEP_STATUSES = [
@@ -4059,7 +4072,8 @@ var organizationInterviewSummarySchema = teamInterviewSummarySchema.extend({
   scope: clarityInterviewScopeSchema,
   teamId: z18.guid().nullable(),
   teamName: z18.string().nullable(),
-  organizationId: z18.guid()
+  organizationId: z18.guid(),
+  hasTranscript: z18.boolean()
 });
 var clarityInterviewSchema = z18.object({
   id: z18.guid(),
@@ -4195,6 +4209,22 @@ var clarityInterviewStatusChangedEventDataSchema = z19.object({
   interviewId: z19.guid(),
   status: clarityInterviewStatusSchema
 });
+var clarityProcessLandscapeGenerationStatusChangedEventDataSchema = z19.object({
+  organizationId: z19.guid(),
+  generationId: z19.guid(),
+  status: clarityProcessLandscapeGenerationSchema.shape.status.exclude([
+    "idle"
+  ]),
+  error: z19.string().optional()
+});
+var clarityProcessLandscapeRoomPayloadSchema = z19.object({
+  organizationId: z19.guid()
+});
+function getClarityProcessLandscapeRoomName(organizationId) {
+  return `clarity-process-landscape:${organizationId}`;
+}
+__name(getClarityProcessLandscapeRoomName, "getClarityProcessLandscapeRoomName");
+__name2(getClarityProcessLandscapeRoomName, "getClarityProcessLandscapeRoomName");
 var clarityProcessRoomPayloadSchema = z19.object({
   processId: z19.guid()
 });
@@ -5713,6 +5743,11 @@ var artifactSchema = z26.object({
   title: z26.string().nullable(),
   html_code_present: z26.boolean(),
   status: artifactStatusSchema,
+  // Time-limited signed URL of the dashboard thumbnail, or null when no
+  // thumbnail has been captured yet. The list view renders it as a preview
+  // image. Optional so older/other clients (and fixtures) tolerate its absence;
+  // the backend always includes it (string or null).
+  thumbnail_url: z26.string().nullable().optional(),
   created_at: z26.string(),
   updated_at: z26.string()
 });
@@ -5820,6 +5855,12 @@ var updateArtifactBodySchema = z26.object({
 var deleteArtifactResponseSchema = z26.object({
   success: z26.literal(true)
 });
+var uploadArtifactThumbnailBodySchema = z26.object({
+  image_base64: z26.string().min(1).max(8e6)
+});
+var uploadArtifactThumbnailResponseSchema = z26.object({
+  ok: z26.literal(true)
+});
 var browserReplayScreenshotSchema = z27.object({
   id: z27.guid(),
   agent_run_id: z27.guid(),
@@ -7116,179 +7157,192 @@ var ensureChatSandboxResponseSchema = z38.object({
 var attachmentSendItemSchema = z38.object({
   attachment_id: z38.uuid()
 });
-var feedbackSentimentSchema = z39.enum(["positive", "negative"]);
+var chatConnectionSchema = z39.object({
+  connection_id: z39.guid(),
+  integration_id: z39.guid().nullable(),
+  custom_integration_id: z39.guid().nullable(),
+  type: z39.string(),
+  created_at: z39.iso.datetime()
+});
+var listChatConnectionsResponseSchema = z39.object({
+  connections: z39.array(chatConnectionSchema)
+});
+var attachChatConnectionBodySchema = z39.object({
+  connection_id: z39.guid()
+});
+var feedbackSentimentSchema = z40.enum(["positive", "negative"]);
 var MAX_FEEDBACK_COMMENT_LENGTH = 2e3;
-var feedbackDataSchema = z39.object({
-  id: z39.guid(),
-  agent_id: z39.guid(),
-  build_id: z39.guid(),
-  run_id: z39.guid(),
-  user_id: z39.guid(),
+var feedbackDataSchema = z40.object({
+  id: z40.guid(),
+  agent_id: z40.guid(),
+  build_id: z40.guid(),
+  run_id: z40.guid(),
+  user_id: z40.guid(),
   sentiment: feedbackSentimentSchema,
-  comment: z39.string().max(MAX_FEEDBACK_COMMENT_LENGTH).nullable(),
-  session_id: z39.string().nullable(),
-  created_at: z39.string(),
-  updated_at: z39.string()
-});
-var agentFolderResponseSchema = z40.object({
-  id: z40.string(),
-  name: z40.string(),
-  team_id: z40.string(),
-  parent_folder_id: z40.string().nullable(),
+  comment: z40.string().max(MAX_FEEDBACK_COMMENT_LENGTH).nullable(),
+  session_id: z40.string().nullable(),
   created_at: z40.string(),
-  updated_at: z40.string(),
-  agent_count: z40.number(),
-  subfolder_count: z40.number()
+  updated_at: z40.string()
 });
-var agentFoldersListResponseSchema = z40.array(
+var agentFolderResponseSchema = z41.object({
+  id: z41.string(),
+  name: z41.string(),
+  team_id: z41.string(),
+  parent_folder_id: z41.string().nullable(),
+  created_at: z41.string(),
+  updated_at: z41.string(),
+  agent_count: z41.number(),
+  subfolder_count: z41.number()
+});
+var agentFoldersListResponseSchema = z41.array(
   agentFolderResponseSchema
 );
-var createAgentFolderRequestSchema = z40.object({
-  name: z40.string().min(1).max(100),
-  parent_folder_id: z40.guid().nullable().optional()
+var createAgentFolderRequestSchema = z41.object({
+  name: z41.string().min(1).max(100),
+  parent_folder_id: z41.guid().nullable().optional()
 });
-var updateAgentFolderRequestSchema = z40.object({
-  name: z40.string().min(1).max(100).optional(),
-  parent_folder_id: z40.guid().nullable().optional()
+var updateAgentFolderRequestSchema = z41.object({
+  name: z41.string().min(1).max(100).optional(),
+  parent_folder_id: z41.guid().nullable().optional()
 });
-var moveAgentsRequestSchema = z40.object({
-  agent_ids: z40.array(z40.guid()).min(1),
-  folder_id: z40.guid().nullable()
+var moveAgentsRequestSchema = z41.object({
+  agent_ids: z41.array(z41.guid()).min(1),
+  folder_id: z41.guid().nullable()
 });
-var learningSchema = z41.object({
-  id: z41.string(),
-  content: z41.string(),
-  sourceRunId: z41.string().nullable(),
-  createdAt: z41.string(),
-  updatedAt: z41.string()
+var learningSchema = z42.object({
+  id: z42.string(),
+  content: z42.string(),
+  sourceRunId: z42.string().nullable(),
+  createdAt: z42.string(),
+  updatedAt: z42.string()
 });
-var getLearningsResponseSchema = z41.object({
+var getLearningsResponseSchema = z42.object({
   learning: learningSchema.nullable()
 });
-var memorySourceTypeSchema = z42.enum(["job", "user"]);
+var memorySourceTypeSchema = z43.enum(["job", "user"]);
 var memorySourceFieldsSchema = {
   source_type: memorySourceTypeSchema.optional(),
-  source_agent_run_id: z42.string().optional(),
-  source_user_id: z42.string().optional(),
-  source_updated_at: z42.string().optional()
+  source_agent_run_id: z43.string().optional(),
+  source_user_id: z43.string().optional(),
+  source_updated_at: z43.string().optional()
 };
-var agentMemoryFileSchema = z42.object({
-  name: z42.string(),
-  path: z42.string(),
-  updated_at: z42.string().optional(),
-  generation: z42.string().optional(),
+var agentMemoryFileSchema = z43.object({
+  name: z43.string(),
+  path: z43.string(),
+  updated_at: z43.string().optional(),
+  generation: z43.string().optional(),
   ...memorySourceFieldsSchema
 });
-var listAgentMemoryFilesResponseSchema = z42.object({
-  files: z42.array(agentMemoryFileSchema)
+var listAgentMemoryFilesResponseSchema = z43.object({
+  files: z43.array(agentMemoryFileSchema)
 });
-var getAgentMemoryFileResponseSchema = z42.object({
-  path: z42.string(),
-  content: z42.string(),
-  generation: z42.string().optional(),
+var getAgentMemoryFileResponseSchema = z43.object({
+  path: z43.string(),
+  content: z43.string(),
+  generation: z43.string().optional(),
   ...memorySourceFieldsSchema
 });
-var DataResidencySchema = z43.enum(["us", "eu", "apac"]);
-var DataHandlingSchema = z43.enum(["standard", "zdr"]);
-var browserPageSchema = z44.object({
-  id: z44.string().describe("Page ID"),
-  url: z44.url().describe("Page URL"),
-  faviconUrl: z44.string().describe("Page favicon URL"),
-  title: z44.string().describe("Page title"),
-  debuggerUrl: z44.url().describe("Page-specific debugger URL"),
-  debuggerFullscreenUrl: z44.url().describe("Page-specific full-screen debugger URL")
-});
-var browserSessionInfoSchema = z44.object({
+var DataResidencySchema = z44.enum(["us", "eu", "apac"]);
+var DataHandlingSchema = z44.enum(["standard", "zdr"]);
+var browserPageSchema = z45.object({
+  id: z45.string().describe("Page ID"),
+  url: z45.url().describe("Page URL"),
+  faviconUrl: z45.string().describe("Page favicon URL"),
+  title: z45.string().describe("Page title"),
+  debuggerUrl: z45.url().describe("Page-specific debugger URL"),
+  debuggerFullscreenUrl: z45.url().describe("Page-specific full-screen debugger URL")
+});
+var browserSessionInfoSchema = z45.object({
   // Session-level URLs (Browser Use provides these, Browserbase also has them)
-  wsUrl: z44.url().nullable(),
-  liveUrl: z44.url().nullable(),
+  wsUrl: z45.url().nullable(),
+  liveUrl: z45.url().nullable(),
   // Page-level data (Browserbase provides these, Browser Use returns empty array)
-  pages: z44.array(browserPageSchema)
-});
-var browserbaseDebugResponseSchema = z44.object({
-  debuggerFullscreenUrl: z44.url().describe("Session full-screen debugger URL"),
-  debuggerUrl: z44.url().describe("Session debugger URL"),
-  pages: z44.array(browserPageSchema).describe("List of pages in the session"),
-  wsUrl: z44.url().describe("WebSocket URL for the session")
-});
-var browserbaseSessionCreateResponseSchema = z44.object({
-  id: z44.string().describe("Session ID"),
-  createdAt: z44.iso.datetime().describe("Session creation timestamp"),
-  updatedAt: z44.iso.datetime().describe("Session last update timestamp"),
-  projectId: z44.string().describe("Project ID"),
-  startedAt: z44.iso.datetime().describe("Session start timestamp"),
-  endedAt: z44.iso.datetime().optional().describe("Session end timestamp"),
-  expiresAt: z44.iso.datetime().describe("Session expiration timestamp"),
-  status: z44.string().describe("Session status"),
-  proxyBytes: z44.number().describe("Proxy bytes used"),
-  avgCpuUsage: z44.number().describe("Average CPU usage"),
-  memoryUsage: z44.number().describe("Memory usage"),
-  keepAlive: z44.boolean().describe("Keep alive flag"),
-  contextId: z44.string().describe("Context ID"),
-  region: z44.string().describe("Region"),
-  userMetadata: z44.record(z44.string(), z44.unknown()).describe("User metadata"),
-  connectUrl: z44.string().describe("Connect URL"),
-  seleniumRemoteUrl: z44.string().describe("Selenium remote URL"),
-  signingKey: z44.string().describe("Signing key")
-});
-var getBuildParamsSchema = z45.object({
-  buildId: z45.guid()
-});
-var listBuildsParamsSchema = z45.object({
-  copilotId: z45.guid()
-});
-var updateBuildBodySchema = z45.object({
-  config: z45.record(z45.string(), z45.any()).optional().describe("Build configuration object"),
-  handoverTargetIds: z45.array(z45.guid()).optional().describe("Agent IDs that this agent can hand over work to"),
-  revision_name: z45.string().trim().min(1).max(80).nullable().optional().describe(
+  pages: z45.array(browserPageSchema)
+});
+var browserbaseDebugResponseSchema = z45.object({
+  debuggerFullscreenUrl: z45.url().describe("Session full-screen debugger URL"),
+  debuggerUrl: z45.url().describe("Session debugger URL"),
+  pages: z45.array(browserPageSchema).describe("List of pages in the session"),
+  wsUrl: z45.url().describe("WebSocket URL for the session")
+});
+var browserbaseSessionCreateResponseSchema = z45.object({
+  id: z45.string().describe("Session ID"),
+  createdAt: z45.iso.datetime().describe("Session creation timestamp"),
+  updatedAt: z45.iso.datetime().describe("Session last update timestamp"),
+  projectId: z45.string().describe("Project ID"),
+  startedAt: z45.iso.datetime().describe("Session start timestamp"),
+  endedAt: z45.iso.datetime().optional().describe("Session end timestamp"),
+  expiresAt: z45.iso.datetime().describe("Session expiration timestamp"),
+  status: z45.string().describe("Session status"),
+  proxyBytes: z45.number().describe("Proxy bytes used"),
+  avgCpuUsage: z45.number().describe("Average CPU usage"),
+  memoryUsage: z45.number().describe("Memory usage"),
+  keepAlive: z45.boolean().describe("Keep alive flag"),
+  contextId: z45.string().describe("Context ID"),
+  region: z45.string().describe("Region"),
+  userMetadata: z45.record(z45.string(), z45.unknown()).describe("User metadata"),
+  connectUrl: z45.string().describe("Connect URL"),
+  seleniumRemoteUrl: z45.string().describe("Selenium remote URL"),
+  signingKey: z45.string().describe("Signing key")
+});
+var getBuildParamsSchema = z46.object({
+  buildId: z46.guid()
+});
+var listBuildsParamsSchema = z46.object({
+  copilotId: z46.guid()
+});
+var updateBuildBodySchema = z46.object({
+  config: z46.record(z46.string(), z46.any()).optional().describe("Build configuration object"),
+  handoverTargetIds: z46.array(z46.guid()).optional().describe("Agent IDs that this agent can hand over work to"),
+  revision_name: z46.string().trim().min(1).max(80).nullable().optional().describe(
     "Optional user-defined name for this revision. Pass null to clear."
   ),
-  revision_description: z45.string().trim().max(500).nullable().optional().describe(
+  revision_description: z46.string().trim().max(500).nullable().optional().describe(
     "Optional user-defined description for this revision. Pass null to clear."
   )
 });
-var createBuildBodySchema = z45.object({
-  copilot_id: z45.guid().describe("Agent ID"),
-  name: z45.string().describe("Build name"),
-  config: z45.record(z45.string(), z45.any()).optional().describe("Build configuration object"),
-  handoverTargetIds: z45.array(z45.guid()).optional().describe("Agent IDs that this agent can hand over work to"),
-  source_build_id: z45.guid().optional().describe("Build ID to copy integrations and queue links from")
-});
-var buildResponseSchema = z45.object({
-  build_id: z45.string().describe("Build ID"),
-  name: z45.string().describe("Build name"),
-  config: z45.record(z45.string(), z45.any()).nullable().describe("Build configuration"),
-  copilot_id: z45.string().describe("Associated copilot ID"),
-  status: z45.string().describe("Build status"),
-  created_at: z45.coerce.date().describe("Creation timestamp"),
-  updated_at: z45.coerce.date().nullable().describe("Last update timestamp"),
-  revision_number: z45.number().nullable().describe("Revision number"),
-  revision_name: z45.string().nullable().optional().describe("User-defined name for this revision"),
-  revision_description: z45.string().nullable().optional().describe("User-defined description for this revision"),
-  parent_build_id: z45.string().nullable().describe("Parent build ID"),
-  created_by: z45.string().nullable().describe("User who created this build"),
-  created_by_name: z45.string().nullable().optional().describe("Display name of the user who created this build")
-});
-var listBuildsResponseSchema = z45.array(buildResponseSchema);
-var buildResponseApiSchema = z45.object({
+var createBuildBodySchema = z46.object({
+  copilot_id: z46.guid().describe("Agent ID"),
+  name: z46.string().describe("Build name"),
+  config: z46.record(z46.string(), z46.any()).optional().describe("Build configuration object"),
+  handoverTargetIds: z46.array(z46.guid()).optional().describe("Agent IDs that this agent can hand over work to"),
+  source_build_id: z46.guid().optional().describe("Build ID to copy integrations and queue links from")
+});
+var buildResponseSchema = z46.object({
+  build_id: z46.string().describe("Build ID"),
+  name: z46.string().describe("Build name"),
+  config: z46.record(z46.string(), z46.any()).nullable().describe("Build configuration"),
+  copilot_id: z46.string().describe("Associated copilot ID"),
+  status: z46.string().describe("Build status"),
+  created_at: z46.coerce.date().describe("Creation timestamp"),
+  updated_at: z46.coerce.date().nullable().describe("Last update timestamp"),
+  revision_number: z46.number().nullable().describe("Revision number"),
+  revision_name: z46.string().nullable().optional().describe("User-defined name for this revision"),
+  revision_description: z46.string().nullable().optional().describe("User-defined description for this revision"),
+  parent_build_id: z46.string().nullable().describe("Parent build ID"),
+  created_by: z46.string().nullable().describe("User who created this build"),
+  created_by_name: z46.string().nullable().optional().describe("Display name of the user who created this build")
+});
+var listBuildsResponseSchema = z46.array(buildResponseSchema);
+var buildResponseApiSchema = z46.object({
   build: buildApiSchema
 });
-var buildsListApiSchema = z45.object({
-  builds: z45.array(buildApiSchema),
-  total: z45.int(),
-  limit: z45.int(),
-  offset: z45.int()
+var buildsListApiSchema = z46.object({
+  builds: z46.array(buildApiSchema),
+  total: z46.int(),
+  limit: z46.int(),
+  offset: z46.int()
 });
-var createBuildResponseApiSchema = z45.object({
+var createBuildResponseApiSchema = z46.object({
   build: buildApiSchema,
-  agent: z45.object({
-    id: z45.guid()
+  agent: z46.object({
+    id: z46.guid()
   })
 });
-var builderRunGenerateResponseSchema = z45.object({
-  status: z45.literal("generating"),
-  builderRunId: z45.string(),
-  buildId: z45.string()
+var builderRunGenerateResponseSchema = z46.object({
+  status: z46.literal("generating"),
+  builderRunId: z46.string(),
+  buildId: z46.string()
 });
 var BUILDER_RUN_STATUSES = [
   "not_started",
@@ -7299,324 +7353,324 @@ var BUILDER_RUN_STATUSES = [
   "waiting_for_input",
   "waiting_for_approve"
 ];
-var builderRunStatusSchema = z45.object({
-  id: z45.string(),
-  status: z45.enum(BUILDER_RUN_STATUSES),
-  build_id: z45.string(),
-  started_at: z45.string().nullable(),
-  completed_at: z45.string().nullable(),
+var builderRunStatusSchema = z46.object({
+  id: z46.string(),
+  status: z46.enum(BUILDER_RUN_STATUSES),
+  build_id: z46.string(),
+  started_at: z46.string().nullable(),
+  completed_at: z46.string().nullable(),
   checkpoint_config: StoredAgentConfigSchema.nullable(),
   pending_user_questions: askUserQuestionInputSchema.nullable(),
-  schedule_suggested: z45.boolean().optional()
-});
-var filterValueSchema = z46.object({
-  value: z46.string().min(1),
-  name: z46.string().min(1)
-});
-var filterCategorySchema = z46.object({
-  key: z46.string(),
-  name: z46.string().min(1),
-  selectionMode: z46.enum(["single", "multi"]),
-  values: z46.array(filterValueSchema)
-});
-var caseFiltersResponseSchema = z46.object({
-  filters: z46.array(filterCategorySchema)
-});
-var caseQueueFolderResponseSchema = z47.object({
-  id: z47.string(),
-  name: z47.string(),
-  team_id: z47.string(),
-  parent_folder_id: z47.string().nullable(),
-  created_at: z47.string(),
-  updated_at: z47.string()
-});
-var caseQueueFoldersListResponseSchema = z47.object({
-  folders: z47.array(caseQueueFolderResponseSchema)
-});
-var createCaseQueueFolderRequestSchema = z47.object({
-  name: z47.string().min(1).max(100),
-  parent_folder_id: z47.guid().nullable().optional()
-});
-var updateCaseQueueFolderRequestSchema = z47.object({
-  name: z47.string().min(1).max(100).optional(),
-  parent_folder_id: z47.guid().nullable().optional()
-});
-var moveQueuesToFolderRequestSchema = z47.object({
-  queue_ids: z47.array(z47.guid()).min(1),
-  folder_id: z47.guid().nullable()
-});
-var caseQueueLabelSchema = z48.object({
-  id: z48.guid(),
-  key: z48.string(),
+  schedule_suggested: z46.boolean().optional()
+});
+var filterValueSchema = z47.object({
+  value: z47.string().min(1),
+  name: z47.string().min(1)
+});
+var filterCategorySchema = z47.object({
+  key: z47.string(),
+  name: z47.string().min(1),
+  selectionMode: z47.enum(["single", "multi"]),
+  values: z47.array(filterValueSchema)
+});
+var caseFiltersResponseSchema = z47.object({
+  filters: z47.array(filterCategorySchema)
+});
+var caseQueueFolderResponseSchema = z48.object({
+  id: z48.string(),
+  name: z48.string(),
+  team_id: z48.string(),
+  parent_folder_id: z48.string().nullable(),
+  created_at: z48.string(),
+  updated_at: z48.string()
+});
+var caseQueueFoldersListResponseSchema = z48.object({
+  folders: z48.array(caseQueueFolderResponseSchema)
+});
+var createCaseQueueFolderRequestSchema = z48.object({
+  name: z48.string().min(1).max(100),
+  parent_folder_id: z48.guid().nullable().optional()
+});
+var updateCaseQueueFolderRequestSchema = z48.object({
+  name: z48.string().min(1).max(100).optional(),
+  parent_folder_id: z48.guid().nullable().optional()
+});
+var moveQueuesToFolderRequestSchema = z48.object({
+  queue_ids: z48.array(z48.guid()).min(1),
+  folder_id: z48.guid().nullable()
+});
+var caseQueueLabelSchema = z49.object({
+  id: z49.guid(),
+  key: z49.string(),
   // Empty string key means a simple tag (value-only); non-empty key creates a key-value categorization
-  value: z48.string().min(1),
-  color_hue: z48.int().min(0).max(360)
+  value: z49.string().min(1),
+  color_hue: z49.int().min(0).max(360)
 });
-var caseLabelsListResponseSchema = z48.object({
-  labels: z48.array(caseQueueLabelSchema)
+var caseLabelsListResponseSchema = z49.object({
+  labels: z49.array(caseQueueLabelSchema)
 });
-var caseLabelAssignInputSchema = z48.object({
-  labels: z48.array(
-    z48.object({
-      key: z48.string().optional().default(""),
-      value: z48.string().min(1)
+var caseLabelAssignInputSchema = z49.object({
+  labels: z49.array(
+    z49.object({
+      key: z49.string().optional().default(""),
+      value: z49.string().min(1)
     })
   ).min(1).max(50)
 });
-var caseLabelAssignResponseSchema = z48.object({
-  labels: z48.array(caseQueueLabelSchema)
+var caseLabelAssignResponseSchema = z49.object({
+  labels: z49.array(caseQueueLabelSchema)
 });
-var caseLabelUpdateInputSchema = z48.object({
+var caseLabelUpdateInputSchema = z49.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: z48.string().optional(),
-  value: z48.string().min(1),
-  color_hue: z48.int().min(0).max(360).optional()
+  key: z49.string().optional(),
+  value: z49.string().min(1),
+  color_hue: z49.int().min(0).max(360).optional()
 });
-var caseLabelUpdateResponseSchema = z48.object({
+var caseLabelUpdateResponseSchema = z49.object({
   label: caseQueueLabelSchema
 });
-var caseLabelUnlinkInputSchema = z48.object({
-  label_ids: z48.array(z48.guid()).min(1)
+var caseLabelUnlinkInputSchema = z49.object({
+  label_ids: z49.array(z49.guid()).min(1)
 });
-var caseLabelUnlinkResponseSchema = z48.object({
-  success: z48.boolean()
+var caseLabelUnlinkResponseSchema = z49.object({
+  success: z49.boolean()
 });
-var caseLabelCreateInputSchema = z48.object({
-  key: z48.string().optional().default(""),
-  value: z48.string().min(1),
-  color_hue: z48.int().min(0).max(360).optional()
+var caseLabelCreateInputSchema = z49.object({
+  key: z49.string().optional().default(""),
+  value: z49.string().min(1),
+  color_hue: z49.int().min(0).max(360).optional()
 });
-var caseLabelCreateResponseSchema = z48.object({
+var caseLabelCreateResponseSchema = z49.object({
   label: caseQueueLabelSchema.extend({
-    case_count: z48.int().min(0)
+    case_count: z49.int().min(0)
   })
 });
 var caseQueueLabelWithCountSchema = caseQueueLabelSchema.extend({
-  case_count: z48.int().min(0)
+  case_count: z49.int().min(0)
 });
-var caseLabelsWithCountsListResponseSchema = z48.object({
-  labels: z48.array(caseQueueLabelWithCountSchema)
+var caseLabelsWithCountsListResponseSchema = z49.object({
+  labels: z49.array(caseQueueLabelWithCountSchema)
 });
 var SEQUENTIAL_TRIGGER_CONCURRENCY = 1;
-var settableTriggerConcurrencySchema = z49.literal(SEQUENTIAL_TRIGGER_CONCURRENCY).nullable();
-var caseTriggerApiSchema = z49.object({
-  id: z49.string(),
-  agent_id: z49.string(),
-  case_queue_id: z49.string(),
-  case_queue_name: z49.string(),
-  user_id: z49.string(),
-  enabled: z49.boolean(),
-  concurrency: z49.int().positive().nullable(),
-  created_at: z49.string(),
-  updated_at: z49.string(),
-  creator_display_name: z49.string().nullable(),
-  can_disable: z49.boolean(),
-  has_conflict: z49.boolean(),
-  conflicting_agents: z49.array(conflictingAgentSchema)
-});
-var caseTriggerResponseSchema = z49.object({
+var settableTriggerConcurrencySchema = z50.literal(SEQUENTIAL_TRIGGER_CONCURRENCY).nullable();
+var caseTriggerApiSchema = z50.object({
+  id: z50.string(),
+  agent_id: z50.string(),
+  case_queue_id: z50.string(),
+  case_queue_name: z50.string(),
+  user_id: z50.string(),
+  enabled: z50.boolean(),
+  concurrency: z50.int().positive().nullable(),
+  created_at: z50.string(),
+  updated_at: z50.string(),
+  creator_display_name: z50.string().nullable(),
+  can_disable: z50.boolean(),
+  has_conflict: z50.boolean(),
+  conflicting_agents: z50.array(conflictingAgentSchema)
+});
+var caseTriggerResponseSchema = z50.object({
   case_trigger: caseTriggerApiSchema
 });
-var caseTriggersListResponseSchema = z49.object({
-  case_triggers: z49.array(caseTriggerApiSchema)
+var caseTriggersListResponseSchema = z50.object({
+  case_triggers: z50.array(caseTriggerApiSchema)
 });
-var deleteCaseTriggerResponseSchema = z49.object({
-  success: z49.literal(true)
+var deleteCaseTriggerResponseSchema = z50.object({
+  success: z50.literal(true)
 });
-var caseTriggerConflictPreviewResponseSchema = z49.object({
-  has_conflict: z49.boolean(),
-  conflicting_agents: z49.array(conflictingAgentSchema)
+var caseTriggerConflictPreviewResponseSchema = z50.object({
+  has_conflict: z50.boolean(),
+  conflicting_agents: z50.array(conflictingAgentSchema)
 });
-var integrationConfigMinSchema = z49.object({
-  id: z49.string(),
-  integration_id: z49.guid().nullable(),
-  integration_type: z49.string()
+var integrationConfigMinSchema = z50.object({
+  id: z50.string(),
+  integration_id: z50.guid().nullable(),
+  integration_type: z50.string()
 });
-var integrationConfigsResponseSchema = z49.object({
-  integrations: z49.array(integrationConfigMinSchema)
+var integrationConfigsResponseSchema = z50.object({
+  integrations: z50.array(integrationConfigMinSchema)
 });
-var caseQueueMinSchema = z49.object({
-  id: z49.string(),
-  name: z49.string()
+var caseQueueMinSchema = z50.object({
+  id: z50.string(),
+  name: z50.string()
 });
-var caseQueuesForSlotResponseSchema = z49.object({
-  queues: z49.array(caseQueueMinSchema)
+var caseQueuesForSlotResponseSchema = z50.object({
+  queues: z50.array(caseQueueMinSchema)
 });
 var APPROVAL_DECISION = {
   APPROVED: "approved",
   REJECTED: "rejected"
 };
-var approvalDecisionSchema = z50.enum([
+var approvalDecisionSchema = z51.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 = z50.object({
-  id: z50.string().uuid(),
-  assignee_user_id: z50.string().uuid(),
-  assignee_name: z50.string().nullable(),
-  assignee_email: z50.string().nullable(),
+var humanRequestBatchRowSchema = z51.object({
+  id: z51.string().uuid(),
+  assignee_user_id: z51.string().uuid(),
+  assignee_name: z51.string().nullable(),
+  assignee_email: z51.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: z50.string(),
+  prompt: z51.string(),
   decision: approvalDecisionSchema.nullable(),
-  responded_at: z50.string().nullable(),
-  responded_by_user_id: z50.string().uuid().nullable(),
-  responded_by_name: z50.string().nullable(),
-  responded_by_email: z50.string().nullable(),
-  cancelled_at: z50.string().nullable(),
-  cancellation_reason: z50.string().nullable()
-});
-var approvalBatchSchema = z50.object({
-  id: z50.string().uuid(),
-  case_queue_item_id: z50.string().uuid(),
-  agent_run_id: z50.string().uuid(),
-  title: z50.string(),
-  created_at: z50.string(),
-  resolved_at: z50.string().nullable(),
-  cancelled_at: z50.string().nullable(),
-  cancellation_reason: z50.string().nullable(),
-  rows: z50.array(humanRequestBatchRowSchema)
-});
-var approvalRequestInputSchema = z50.object({
-  approverUserId: z50.string().uuid(),
-  prompt: z50.string().trim().min(1).max(HUMAN_REQUEST_PROMPT_MAX)
-});
-var createHumanRequestBatchBodySchema = z50.object({
-  agentRunId: z50.string().uuid(),
-  title: z50.string().trim().min(1).max(HUMAN_REQUEST_TITLE_MAX),
-  requests: z50.array(approvalRequestInputSchema).min(1).max(MAX_APPROVERS_PER_BATCH)
-});
-var createHumanRequestBatchResponseSchema = z50.object({
-  batchId: z50.string().uuid(),
-  createdAt: z50.string(),
-  humanRequestIds: z50.array(z50.string().uuid())
-});
-var requestCaseApprovalsToolInputSchema = z50.object({
-  title: z50.string().trim().min(1).max(HUMAN_REQUEST_TITLE_MAX),
-  requests: z50.array(approvalRequestInputSchema).min(1).max(MAX_APPROVERS_PER_BATCH)
-});
-var requestCaseApprovalsBatchStatusSchema = z50.enum([
+  responded_at: z51.string().nullable(),
+  responded_by_user_id: z51.string().uuid().nullable(),
+  responded_by_name: z51.string().nullable(),
+  responded_by_email: z51.string().nullable(),
+  cancelled_at: z51.string().nullable(),
+  cancellation_reason: z51.string().nullable()
+});
+var approvalBatchSchema = z51.object({
+  id: z51.string().uuid(),
+  case_queue_item_id: z51.string().uuid(),
+  agent_run_id: z51.string().uuid(),
+  title: z51.string(),
+  created_at: z51.string(),
+  resolved_at: z51.string().nullable(),
+  cancelled_at: z51.string().nullable(),
+  cancellation_reason: z51.string().nullable(),
+  rows: z51.array(humanRequestBatchRowSchema)
+});
+var approvalRequestInputSchema = z51.object({
+  approverUserId: z51.string().uuid(),
+  prompt: z51.string().trim().min(1).max(HUMAN_REQUEST_PROMPT_MAX)
+});
+var createHumanRequestBatchBodySchema = z51.object({
+  agentRunId: z51.string().uuid(),
+  title: z51.string().trim().min(1).max(HUMAN_REQUEST_TITLE_MAX),
+  requests: z51.array(approvalRequestInputSchema).min(1).max(MAX_APPROVERS_PER_BATCH)
+});
+var createHumanRequestBatchResponseSchema = z51.object({
+  batchId: z51.string().uuid(),
+  createdAt: z51.string(),
+  humanRequestIds: z51.array(z51.string().uuid())
+});
+var requestCaseApprovalsToolInputSchema = z51.object({
+  title: z51.string().trim().min(1).max(HUMAN_REQUEST_TITLE_MAX),
+  requests: z51.array(approvalRequestInputSchema).min(1).max(MAX_APPROVERS_PER_BATCH)
+});
+var requestCaseApprovalsBatchStatusSchema = z51.enum([
   "resolved",
   "cancelled"
 ]);
-var requestCaseApprovalsDecisionEntrySchema = z50.object({
-  assigneeUserId: z50.string().uuid(),
+var requestCaseApprovalsDecisionEntrySchema = z51.object({
+  assigneeUserId: z51.string().uuid(),
   decision: approvalDecisionSchema,
-  respondedAt: z50.string(),
-  respondedByUserId: z50.string().uuid()
+  respondedAt: z51.string(),
+  respondedByUserId: z51.string().uuid()
 });
-var requestCaseApprovalsToolOutputSchema = z50.object({
+var requestCaseApprovalsToolOutputSchema = z51.object({
   status: requestCaseApprovalsBatchStatusSchema,
-  decisions: z50.array(requestCaseApprovalsDecisionEntrySchema)
-});
-var humanRequestContextSchema = z50.discriminatedUnion("kind", [
-  z50.object({
-    kind: z50.literal("run"),
-    runId: z50.string().uuid(),
-    buildId: z50.string().uuid(),
-    agentId: z50.string().uuid(),
-    agentName: z50.string().nullable()
+  decisions: z51.array(requestCaseApprovalsDecisionEntrySchema)
+});
+var humanRequestContextSchema = z51.discriminatedUnion("kind", [
+  z51.object({
+    kind: z51.literal("run"),
+    runId: z51.string().uuid(),
+    buildId: z51.string().uuid(),
+    agentId: z51.string().uuid(),
+    agentName: z51.string().nullable()
   }),
-  z50.object({
-    kind: z50.literal("case"),
-    queueId: z50.string().uuid(),
-    caseId: z50.string().uuid(),
-    caseTitle: z50.string()
+  z51.object({
+    kind: z51.literal("case"),
+    queueId: z51.string().uuid(),
+    caseId: z51.string().uuid(),
+    caseTitle: z51.string()
   })
 ]);
-var caseQueueItemSchema = z51.object({
-  id: z51.guid(),
-  queue_id: z51.guid(),
-  title: z51.string(),
-  data: z51.string(),
-  status: z51.enum(["pending", "claimed", "completed", "failed"]),
-  claimed_at: z51.string().nullable(),
-  claimed_by_run_id: z51.string().nullable(),
-  completed_at: z51.string().nullable(),
+var caseQueueItemSchema = z52.object({
+  id: z52.guid(),
+  queue_id: z52.guid(),
+  title: z52.string(),
+  data: z52.string(),
+  status: z52.enum(["pending", "claimed", "completed", "failed"]),
+  claimed_at: z52.string().nullable(),
+  claimed_by_run_id: z52.string().nullable(),
+  completed_at: z52.string().nullable(),
   /** When the case is scheduled to be re-handled (null if not postponed) */
-  postponed_to: z51.string().nullable(),
-  created_at: z51.string(),
-  updated_at: z51.string(),
-  created_by_user_id: z51.guid().nullable(),
-  created_by_user_name: z51.string().nullable(),
-  created_by_user_email: z51.string().nullable(),
+  postponed_to: z52.string().nullable(),
+  created_at: z52.string(),
+  updated_at: z52.string(),
+  created_by_user_id: z52.guid().nullable(),
+  created_by_user_name: z52.string().nullable(),
+  created_by_user_email: z52.string().nullable(),
   /** Status of the associated agent run (running, waiting, etc.) - null if no active run */
-  agent_run_status: z51.string().nullable(),
+  agent_run_status: z52.string().nullable(),
   /** User ID of the owner of the active agent run - null if no active run */
-  agent_run_user_id: z51.guid().nullable(),
+  agent_run_user_id: z52.guid().nullable(),
   /** ID of the pending human request for cases waiting for input */
-  pending_human_request_id: z51.guid().nullable(),
+  pending_human_request_id: z52.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: z51.guid().nullable(),
+  pending_approval_batch_id: z52.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: z51.array(z51.guid()),
+  pending_approval_assignee_user_ids: z52.array(z52.guid()),
   /** Count of resolved `human_request` approval rows on this case with `decision = 'approved'`. */
-  approval_approved_count: z51.int().nonnegative(),
+  approval_approved_count: z52.int().nonnegative(),
   /** Count of resolved `human_request` approval rows on this case with `decision = 'rejected'`. */
-  approval_rejected_count: z51.int().nonnegative(),
+  approval_rejected_count: z52.int().nonnegative(),
   /** Snippet from the data field showing search match context. Only present when search matches data. */
-  search_match_data_snippet: z51.object({
-    before: z51.string(),
-    match: z51.string(),
-    after: z51.string()
+  search_match_data_snippet: z52.object({
+    before: z52.string(),
+    match: z52.string(),
+    after: z52.string()
   }).optional(),
-  labels: z51.array(caseQueueLabelSchema)
-});
-var caseQueueItemEventSchema = z51.object({
-  id: z51.guid(),
-  case_queue_item_id: z51.guid(),
-  agent_run_id: z51.guid().nullable(),
-  human_request_id: z51.guid().nullable(),
-  type: z51.string(),
-  reason: z51.string().nullable(),
-  created_at: z51.string(),
-  agent_id: z51.guid().nullable(),
-  agent_name: z51.string().nullable(),
+  labels: z52.array(caseQueueLabelSchema)
+});
+var caseQueueItemEventSchema = z52.object({
+  id: z52.guid(),
+  case_queue_item_id: z52.guid(),
+  agent_run_id: z52.guid().nullable(),
+  human_request_id: z52.guid().nullable(),
+  type: z52.string(),
+  reason: z52.string().nullable(),
+  created_at: z52.string(),
+  agent_id: z52.guid().nullable(),
+  agent_name: z52.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: z51.guid().nullable(),
-  user_name: z51.string().nullable(),
-  user_email: z51.string().nullable(),
-  human_request_title: z51.string().nullable()
-});
-var casesListResponseSchema = z51.object({
-  cases: z51.array(caseQueueItemSchema),
-  total: z51.number(),
-  limit: z51.int(),
-  offset: z51.int()
-});
-var caseCreateInputSchema = z51.object({
-  title: z51.string().min(1).max(500).describe(
+  user_id: z52.guid().nullable(),
+  user_name: z52.string().nullable(),
+  user_email: z52.string().nullable(),
+  human_request_title: z52.string().nullable()
+});
+var casesListResponseSchema = z52.object({
+  cases: z52.array(caseQueueItemSchema),
+  total: z52.number(),
+  limit: z52.int(),
+  offset: z52.int()
+});
+var caseCreateInputSchema = z52.object({
+  title: z52.string().min(1).max(500).describe(
     "Short title for the case (max 500 characters). Put long context in `data`."
   ),
-  data: z51.string().optional().describe(
+  data: z52.string().optional().describe(
     "Additional data for the case. Free-form text or JSON; Agents receive this on claim."
   ),
-  labels: z51.array(
-    z51.object({
-      key: z51.string().optional().default("").describe("Label key (omit for a simple tag)."),
-      value: z51.string().min(1).describe("Label value (required).")
+  labels: z52.array(
+    z52.object({
+      key: z52.string().optional().default("").describe("Label key (omit for a simple tag)."),
+      value: z52.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 = z51.object({
+var caseCreateRequestSchema = z52.object({
   case: caseCreateInputSchema.optional(),
-  cases: z51.array(caseCreateInputSchema).min(1).max(100).optional()
+  cases: z52.array(caseCreateInputSchema).min(1).max(100).optional()
 }).superRefine((val, ctx) => {
   const hasCase = val.case !== void 0;
   const hasCases = val.cases !== void 0;
@@ -7634,26 +7688,26 @@ var caseCreateRequestSchema = z51.object({
     });
   }
 });
-var caseCreateResponseSchema = z51.object({
-  added_cases: z51.array(caseQueueItemSchema)
+var caseCreateResponseSchema = z52.object({
+  added_cases: z52.array(caseQueueItemSchema)
 });
-var casesStatsSchema = z51.object({
-  total: z51.number(),
-  pending: z51.number(),
-  claimed: z51.number(),
+var casesStatsSchema = z52.object({
+  total: z52.number(),
+  pending: z52.number(),
+  claimed: z52.number(),
   /** Count of claimed cases waiting for human input (run status = waiting) */
-  waiting: z51.number(),
+  waiting: z52.number(),
   /** Count of pending cases that are postponed for later */
-  postponed: z51.number(),
-  completed: z51.number(),
-  failed: z51.number()
+  postponed: z52.number(),
+  completed: z52.number(),
+  failed: z52.number()
 });
-var casesStatsResponseSchema = z51.object({
+var casesStatsResponseSchema = z52.object({
   stats: casesStatsSchema
 });
-var caseDetailResponseSchema = z51.object({
+var caseDetailResponseSchema = z52.object({
   case: caseQueueItemSchema,
-  events: z51.array(caseQueueItemEventSchema),
+  events: z52.array(caseQueueItemEventSchema),
   /**
    * Every approval batch ever created on this case, newest first. Each
    * batch carries one child row per named approver (with their decision
@@ -7661,21 +7715,21 @@ var caseDetailResponseSchema = z51.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: z51.array(approvalBatchSchema)
+  approvalBatches: z52.array(approvalBatchSchema)
 });
-var caseJobSummarySchema = z51.object({
-  id: z51.string().uuid(),
-  case_queue_item_id: z51.string().uuid(),
-  agent_id: z51.string().uuid(),
-  agent_name: z51.string(),
+var caseJobSummarySchema = z52.object({
+  id: z52.string().uuid(),
+  case_queue_item_id: z52.string().uuid(),
+  agent_id: z52.string().uuid(),
+  agent_name: z52.string(),
   status: agentRunStatusSchema,
-  source: z51.string().nullable(),
-  created_at: z51.string(),
-  started_at: z51.string().nullable(),
-  completed_at: z51.string().nullable(),
-  claimed_at: z51.string(),
-  has_pending_human_request: z51.boolean(),
-  pending_human_request_title: z51.string().nullable(),
+  source: z52.string().nullable(),
+  created_at: z52.string(),
+  started_at: z52.string().nullable(),
+  completed_at: z52.string().nullable(),
+  claimed_at: z52.string(),
+  has_pending_human_request: z52.boolean(),
+  pending_human_request_title: z52.string().nullable(),
   evaluation: evalSummarySchema,
   /**
    * Owner of the agent run (from `agent_run.user_id`). The frontend mirrors
@@ -7683,225 +7737,225 @@ var caseJobSummarySchema = z51.object({
    * team role to decide whether the card is interactive (live messages,
    * HITL affordances, drawer link).
    */
-  user_id: z51.guid().nullable(),
+  user_id: z52.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: z51.string().nullable(),
-  user_email: z51.string().nullable()
+  user_name: z52.string().nullable(),
+  user_email: z52.string().nullable()
 });
-var caseJobsResponseSchema = z51.object({
-  runs: z51.array(caseJobSummarySchema)
+var caseJobsResponseSchema = z52.object({
+  runs: z52.array(caseJobSummarySchema)
 });
-var caseJobRecentMessagesResponseSchema = z51.object({
-  messages: z51.array(agentMessageWithCreatedAtSchema)
+var caseJobRecentMessagesResponseSchema = z52.object({
+  messages: z52.array(agentMessageWithCreatedAtSchema)
 });
-var adjacentCasesResponseSchema = z51.object({
-  previousId: z51.guid().nullable(),
-  nextId: z51.guid().nullable(),
-  position: z51.number(),
-  total: z51.number()
+var adjacentCasesResponseSchema = z52.object({
+  previousId: z52.guid().nullable(),
+  nextId: z52.guid().nullable(),
+  position: z52.number(),
+  total: z52.number()
 });
-var caseDeleteResponseSchema = z51.object({
-  success: z51.boolean(),
-  interruptedRunIds: z51.array(z51.guid())
+var caseDeleteResponseSchema = z52.object({
+  success: z52.boolean(),
+  interruptedRunIds: z52.array(z52.guid())
 });
-var caseBulkDeleteResponseSchema = z51.object({
-  deletedCount: z51.number(),
-  interruptedRunIds: z51.array(z51.guid())
+var caseBulkDeleteResponseSchema = z52.object({
+  deletedCount: z52.number(),
+  interruptedRunIds: z52.array(z52.guid())
 });
-var caseBulkReprocessResponseSchema = z51.object({
-  reprocessedCount: z51.number(),
-  skippedCount: z51.number(),
+var caseBulkReprocessResponseSchema = z52.object({
+  reprocessedCount: z52.number(),
+  skippedCount: z52.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: z51.number().meta({
+  delegatedCount: z52.number().meta({
     deprecated: true,
     description: "Deprecated alias of reprocessedCount, kept for clients redirected from bulk-delegate. Removed on 2026-06-10."
   }).optional(),
-  retriedCount: z51.number().meta({
+  retriedCount: z52.number().meta({
     deprecated: true,
     description: "Deprecated alias of reprocessedCount, kept for clients redirected from bulk-retry. Removed on 2026-06-10."
   }).optional()
 });
-var caseBulkStatusUpdateResponseSchema = z51.object({
-  updatedCount: z51.number(),
-  skippedCount: z51.number(),
-  interruptedRunIds: z51.array(z51.guid())
-});
-var deleteQueueResponseSchema = z51.object({
-  success: z51.boolean(),
-  deleted_case_count: z51.number(),
-  interrupted_run_ids: z51.array(z51.guid())
-});
-var caseClearQueueResponseSchema = z51.object({
-  success: z51.boolean(),
-  deletedCount: z51.number(),
-  interruptedRunIds: z51.array(z51.guid())
-});
-var caseQueueSchema = z51.object({
-  id: z51.guid(),
-  name: z51.string(),
-  description: z51.string().nullable(),
-  folder_id: z51.guid().nullable(),
-  created_at: z51.string(),
+var caseBulkStatusUpdateResponseSchema = z52.object({
+  updatedCount: z52.number(),
+  skippedCount: z52.number(),
+  interruptedRunIds: z52.array(z52.guid())
+});
+var deleteQueueResponseSchema = z52.object({
+  success: z52.boolean(),
+  deleted_case_count: z52.number(),
+  interrupted_run_ids: z52.array(z52.guid())
+});
+var caseClearQueueResponseSchema = z52.object({
+  success: z52.boolean(),
+  deletedCount: z52.number(),
+  interruptedRunIds: z52.array(z52.guid())
+});
+var caseQueueSchema = z52.object({
+  id: z52.guid(),
+  name: z52.string(),
+  description: z52.string().nullable(),
+  folder_id: z52.guid().nullable(),
+  created_at: z52.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: z51.boolean()
+  has_approvals: z52.boolean()
 });
-var caseQueuesResponseSchema = z51.object({
-  queues: z51.array(caseQueueSchema),
-  total: z51.number(),
-  limit: z51.number(),
-  offset: z51.number()
+var caseQueuesResponseSchema = z52.object({
+  queues: z52.array(caseQueueSchema),
+  total: z52.number(),
+  limit: z52.number(),
+  offset: z52.number()
 });
-var caseGetQueueResponseSchema = z51.object({
+var caseGetQueueResponseSchema = z52.object({
   queue: caseQueueSchema
 });
-var caseCreateQueueResponseSchema = z51.object({
+var caseCreateQueueResponseSchema = z52.object({
   queue: caseQueueSchema
 });
-var caseUpdateQueueResponseSchema = z51.object({
+var caseUpdateQueueResponseSchema = z52.object({
   queue: caseQueueSchema
 });
-var caseQueueAgentProblemSchema = z51.enum([
+var caseQueueAgentProblemSchema = z52.enum([
   "multiple_triggers",
   "producer_consumer_mix"
 ]);
-var queueAgentProducerSchema = z51.object({
-  agent_id: z51.guid(),
-  agent_name: z51.string(),
-  case_trigger_enabled: z51.boolean(),
-  case_trigger_queue_name: z51.string().nullable(),
-  problems: z51.array(caseQueueAgentProblemSchema)
-});
-var queueAgentConsumerSchema = z51.object({
-  agent_id: z51.guid(),
-  agent_name: z51.string(),
-  case_trigger_enabled: z51.boolean(),
-  is_handover_target: z51.boolean(),
-  problems: z51.array(caseQueueAgentProblemSchema),
+var queueAgentProducerSchema = z52.object({
+  agent_id: z52.guid(),
+  agent_name: z52.string(),
+  case_trigger_enabled: z52.boolean(),
+  case_trigger_queue_name: z52.string().nullable(),
+  problems: z52.array(caseQueueAgentProblemSchema)
+});
+var queueAgentConsumerSchema = z52.object({
+  agent_id: z52.guid(),
+  agent_name: z52.string(),
+  case_trigger_enabled: z52.boolean(),
+  is_handover_target: z52.boolean(),
+  problems: z52.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: z51.int().nonnegative().optional(),
+  concurrency_limit: z52.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: z51.boolean().optional()
-});
-var queueAgentsResponseSchema = z51.object({
-  queue_name: z51.string(),
-  producers: z51.array(queueAgentProducerSchema),
-  consumers: z51.array(queueAgentConsumerSchema)
-});
-var exportCasesResponseSchema = z51.object({
-  version: z51.number(),
-  queue_name: z51.string(),
-  exported_at: z51.string(),
-  cases: z51.array(
-    z51.object({
-      title: z51.string(),
-      data: z51.string().optional()
+  at_concurrency_limit: z52.boolean().optional()
+});
+var queueAgentsResponseSchema = z52.object({
+  queue_name: z52.string(),
+  producers: z52.array(queueAgentProducerSchema),
+  consumers: z52.array(queueAgentConsumerSchema)
+});
+var exportCasesResponseSchema = z52.object({
+  version: z52.number(),
+  queue_name: z52.string(),
+  exported_at: z52.string(),
+  cases: z52.array(
+    z52.object({
+      title: z52.string(),
+      data: z52.string().optional()
     })
   )
 });
-var importCasesResponseSchema = z51.object({
-  imported_count: z51.number()
+var importCasesResponseSchema = z52.object({
+  imported_count: z52.number()
 });
-var batchQueueStatsResponseSchema = z51.object({
-  stats: z51.record(z51.guid(), casesStatsSchema)
+var batchQueueStatsResponseSchema = z52.object({
+  stats: z52.record(z52.guid(), casesStatsSchema)
 });
-var batchQueueAgentsResponseSchema = z51.object({
-  agents: z51.record(
-    z51.guid(),
-    z51.object({
-      producers: z51.array(queueAgentProducerSchema),
-      consumers: z51.array(queueAgentConsumerSchema)
+var batchQueueAgentsResponseSchema = z52.object({
+  agents: z52.record(
+    z52.guid(),
+    z52.object({
+      producers: z52.array(queueAgentProducerSchema),
+      consumers: z52.array(queueAgentConsumerSchema)
     })
   )
 });
-var createTeamInviteLinkRequestSchema = z52.object({
-  frontendUrl: z52.url()
+var createTeamInviteLinkRequestSchema = z53.object({
+  frontendUrl: z53.url()
 });
-var getTeamInviteLinkQuerySchema = z52.object({
-  frontendUrl: z52.url()
+var getTeamInviteLinkQuerySchema = z53.object({
+  frontendUrl: z53.url()
 });
-var teamInviteLinkCreatorSchema = z52.object({
-  id: z52.guid(),
-  name: z52.string().nullable(),
-  email: z52.email()
+var teamInviteLinkCreatorSchema = z53.object({
+  id: z53.guid(),
+  name: z53.string().nullable(),
+  email: z53.email()
 });
-var teamInviteLinkSchema = z52.object({
-  id: z52.guid(),
-  url: z52.url().optional(),
-  createdAt: z52.string(),
+var teamInviteLinkSchema = z53.object({
+  id: z53.guid(),
+  url: z53.url().optional(),
+  createdAt: z53.string(),
   createdBy: teamInviteLinkCreatorSchema
 });
-var getTeamInviteLinkResponseSchema = z52.object({
-  hasLink: z52.boolean(),
+var getTeamInviteLinkResponseSchema = z53.object({
+  hasLink: z53.boolean(),
   link: teamInviteLinkSchema.optional()
 });
-var joinLinkInfoResponseSchema = z52.object({
-  valid: z52.boolean(),
-  teamName: z52.string().optional(),
-  teamId: z52.guid().optional(),
-  reason: z52.enum(["invalid", "expired"]).optional()
+var joinLinkInfoResponseSchema = z53.object({
+  valid: z53.boolean(),
+  teamName: z53.string().optional(),
+  teamId: z53.guid().optional(),
+  reason: z53.enum(["invalid", "expired"]).optional()
 });
-var acceptJoinLinkResponseSchema = z52.object({
-  success: z52.boolean(),
-  teamId: z52.guid()
+var acceptJoinLinkResponseSchema = z53.object({
+  success: z53.boolean(),
+  teamId: z53.guid()
 });
-var createClarityProcessInviteLinkRequestSchema = z53.object({
-  frontendUrl: z53.url()
+var createClarityProcessInviteLinkRequestSchema = z54.object({
+  frontendUrl: z54.url()
 });
 var clarityProcessInviteLinkSchema = teamInviteLinkSchema;
-var getClarityProcessInviteLinkResponseSchema = z53.object({
-  hasLink: z53.boolean(),
+var getClarityProcessInviteLinkResponseSchema = z54.object({
+  hasLink: z54.boolean(),
   link: clarityProcessInviteLinkSchema.optional()
 });
-var clarityJoinLinkInfoResponseSchema = z53.object({
-  valid: z53.boolean(),
-  processName: z53.string().optional(),
-  processId: z53.guid().optional(),
-  teamId: z53.guid().optional(),
-  reason: z53.enum(["invalid", "expired"]).optional()
-});
-var acceptClarityJoinLinkResponseSchema = z53.object({
-  success: z53.boolean(),
-  processId: z53.guid()
-});
-var credentialPreviewSchema = z54.object({
-  id: z54.guid().describe("Credential ID"),
-  domain: z54.string().describe("Domain for the credential"),
-  username: z54.string().nullable().describe("Username (if any)"),
-  hasEnabledTOTP: z54.boolean().describe("Whether TOTP is enabled"),
-  hasPassword: z54.boolean().describe("Whether a password is stored"),
-  user_id: z54.string().nullable().describe("Owner user id; null when shared with the team")
-});
-var otpResponseSchema = z54.object({
-  code: z54.string().describe("The TOTP code"),
-  expiresAt: z54.number().describe("Expiration timestamp in milliseconds")
-});
-var encryptedDataSchema = z54.object({
-  encrypted_data: z54.string().describe("Base64-encoded encrypted data"),
-  key_version: z54.string().describe("KMS key version or 'base64' for dev")
-});
-var credentialDetailSchema = z54.object({
-  domain: z54.string().describe("Domain for the credential"),
-  username: z54.string().nullable().describe("Username (if any)"),
+var clarityJoinLinkInfoResponseSchema = z54.object({
+  valid: z54.boolean(),
+  processName: z54.string().optional(),
+  processId: z54.guid().optional(),
+  teamId: z54.guid().optional(),
+  reason: z54.enum(["invalid", "expired"]).optional()
+});
+var acceptClarityJoinLinkResponseSchema = z54.object({
+  success: z54.boolean(),
+  processId: z54.guid()
+});
+var credentialPreviewSchema = z55.object({
+  id: z55.guid().describe("Credential ID"),
+  domain: z55.string().describe("Domain for the credential"),
+  username: z55.string().nullable().describe("Username (if any)"),
+  hasEnabledTOTP: z55.boolean().describe("Whether TOTP is enabled"),
+  hasPassword: z55.boolean().describe("Whether a password is stored"),
+  user_id: z55.string().nullable().describe("Owner user id; null when shared with the team")
+});
+var otpResponseSchema = z55.object({
+  code: z55.string().describe("The TOTP code"),
+  expiresAt: z55.number().describe("Expiration timestamp in milliseconds")
+});
+var encryptedDataSchema = z55.object({
+  encrypted_data: z55.string().describe("Base64-encoded encrypted data"),
+  key_version: z55.string().describe("KMS key version or 'base64' for dev")
+});
+var credentialDetailSchema = z55.object({
+  domain: z55.string().describe("Domain for the credential"),
+  username: z55.string().nullable().describe("Username (if any)"),
   password: encryptedDataSchema.nullable().describe("Encrypted password data")
 });
 var FEATURE_FLAG_CATALOGUE = {
@@ -7915,6 +7969,16 @@ var FEATURE_FLAG_CATALOGUE = {
     defaultValue: false,
     description: "Enables the Duvo help chat dock (bottom-right floating composer + history popover) and its backend routes. When disabled, the dock is hidden and /v1/agent-chats endpoints return 404; cc-server ingestion callback is unaffected."
   },
+  AGENT_CHAT_SKIP_MCP_PREFLIGHT: {
+    key: "agent_chat_skip_mcp_preflight",
+    defaultValue: false,
+    description: "Ask Duvo max-speed tier. When on, resumed chat turns skip the MCP preflight reachability check (the eager startup() warmup is already skipped on resumed turns). Lowest first-token latency, but a dead/unreachable connection is no longer caught up front \u2014 it surfaces later during tool use instead of the clean 'Couldn't connect to \u2026' error. Per-team opt-in; off by default."
+  },
+  AGENT_CHAT_VERBOSE: {
+    key: "agent_chat_verbose",
+    defaultValue: false,
+    description: "Frontend-only. When on, the Ask Duvo chat transcript shows completed and failed tool calls as inline cards (mirroring Pulse) instead of only the generic Working\u2026/Reading\u2026 activity line. The running tool still surfaces as the activity-line verb. No backend behavior changes."
+  },
   ASSIGNMENT_EVALS: {
     key: "assignment_evals",
     defaultValue: false,
@@ -8010,6 +8074,11 @@ var FEATURE_FLAG_CATALOGUE = {
     defaultValue: false,
     description: "Enables dynamic island-style UI in the agent builder for contextual actions and status."
   },
+  ERP_DIAGNOSIS: {
+    key: "erp_diagnosis",
+    defaultValue: false,
+    description: "Enables the ERP Diagnosis surface for SAP readiness diagnosis, including SAP connection cards and downloadable diagnosis reports. Off-by-default for staged rollout."
+  },
   COMPUTER_USE: {
     key: "computer_use",
     defaultValue: false,
@@ -8103,160 +8172,160 @@ function coerceFlagValue(value) {
 }
 __name(coerceFlagValue, "coerceFlagValue");
 __name2(coerceFlagValue, "coerceFlagValue");
-var teamFileItemSchema = z55.object({
-  id: z55.string(),
-  name: z55.string(),
-  path: z55.string(),
-  created_at: z55.string().optional(),
-  updated_at: z55.string().optional(),
-  metadata: z55.object({
-    mimetype: z55.string().optional(),
-    size: z55.number().optional()
+var teamFileItemSchema = z56.object({
+  id: z56.string(),
+  name: z56.string(),
+  path: z56.string(),
+  created_at: z56.string().optional(),
+  updated_at: z56.string().optional(),
+  metadata: z56.object({
+    mimetype: z56.string().optional(),
+    size: z56.number().optional()
   }).nullable().optional()
 });
-var listTeamFilesResponseSchema = z55.object({
-  files: z55.array(teamFileItemSchema)
-});
-var createTeamFileUploadUrlBodySchema = z55.object({
-  fileName: z55.string().min(1),
-  contentType: z55.string().min(1)
-});
-var createTeamFileUploadUrlResponseSchema = z55.object({
-  signedUrl: z55.url(),
-  expiresAt: z55.iso.datetime(),
-  filePath: z55.string()
-});
-var renameTeamFileBodySchema = z55.object({
-  relativePath: z55.string().min(1),
-  newFilenameOnly: z55.string().min(1)
-});
-var teamFileSuccessResponseSchema = z55.object({
-  success: z55.boolean()
-});
-var teamFileDownloadUrlResponseSchema = z55.object({
-  url: z55.url(),
-  expiresAt: z55.iso.datetime()
-});
-var teamFileContentResponseSchema = z55.object({
-  content: z55.string(),
-  path: z55.string(),
-  contentType: z55.string().optional()
-});
-var updateTeamFileContentBodySchema = z55.object({
-  content: z55.string()
-});
-var globalAdminApiSchema = z56.object({
-  id: z56.guid(),
-  email: z56.string(),
-  userId: z56.guid(),
-  userName: z56.string().nullable(),
-  addedByUserId: z56.guid().nullable(),
-  createdAt: z56.string()
-});
-var globalAdminListResponseSchema = z56.object({
-  admins: z56.array(globalAdminApiSchema)
-});
-var globalAdminSearchResponseSchema = z56.object({
-  users: z56.array(
-    z56.object({
-      id: z56.guid(),
-      name: z56.string().nullable(),
-      email: z56.string(),
-      createdAt: z56.string().nullable()
+var listTeamFilesResponseSchema = z56.object({
+  files: z56.array(teamFileItemSchema)
+});
+var createTeamFileUploadUrlBodySchema = z56.object({
+  fileName: z56.string().min(1),
+  contentType: z56.string().min(1)
+});
+var createTeamFileUploadUrlResponseSchema = z56.object({
+  signedUrl: z56.url(),
+  expiresAt: z56.iso.datetime(),
+  filePath: z56.string()
+});
+var renameTeamFileBodySchema = z56.object({
+  relativePath: z56.string().min(1),
+  newFilenameOnly: z56.string().min(1)
+});
+var teamFileSuccessResponseSchema = z56.object({
+  success: z56.boolean()
+});
+var teamFileDownloadUrlResponseSchema = z56.object({
+  url: z56.url(),
+  expiresAt: z56.iso.datetime()
+});
+var teamFileContentResponseSchema = z56.object({
+  content: z56.string(),
+  path: z56.string(),
+  contentType: z56.string().optional()
+});
+var updateTeamFileContentBodySchema = z56.object({
+  content: z56.string()
+});
+var globalAdminApiSchema = z57.object({
+  id: z57.guid(),
+  email: z57.string(),
+  userId: z57.guid(),
+  userName: z57.string().nullable(),
+  addedByUserId: z57.guid().nullable(),
+  createdAt: z57.string()
+});
+var globalAdminListResponseSchema = z57.object({
+  admins: z57.array(globalAdminApiSchema)
+});
+var globalAdminSearchResponseSchema = z57.object({
+  users: z57.array(
+    z57.object({
+      id: z57.guid(),
+      name: z57.string().nullable(),
+      email: z57.string(),
+      createdAt: z57.string().nullable()
     })
   )
 });
-var globalAdminCreateRequestSchema = z56.object({
-  userId: z56.guid()
+var globalAdminCreateRequestSchema = z57.object({
+  userId: z57.guid()
 });
-var globalAdminCreateResponseSchema = z56.object({
+var globalAdminCreateResponseSchema = z57.object({
   admin: globalAdminApiSchema
 });
-var globalAdminDeleteResponseSchema = z56.object({
-  success: z56.literal(true)
+var globalAdminDeleteResponseSchema = z57.object({
+  success: z57.literal(true)
 });
-var adminAccessCheckResponseSchema = z56.object({
-  isGlobalAdmin: z56.boolean()
+var adminAccessCheckResponseSchema = z57.object({
+  isGlobalAdmin: z57.boolean()
 });
 var JOB_LIST_SORT_COLUMNS = ["created_at"];
-var jobListSortColumnSchema = z57.enum(JOB_LIST_SORT_COLUMNS);
-var jobListIssueSeveritySchema = z57.enum(
+var jobListSortColumnSchema = z58.enum(JOB_LIST_SORT_COLUMNS);
+var jobListIssueSeveritySchema = z58.enum(
   ALL_EVALUATION_RUBRIC_SEVERITIES
 );
-var jobListItemSchema = z57.object({
-  id: z57.guid(),
-  created_at: z57.coerce.date(),
-  updated_at: z57.coerce.date(),
-  started_at: z57.coerce.date().nullable(),
-  completed_at: z57.coerce.date().nullable(),
+var jobListItemSchema = z58.object({
+  id: z58.guid(),
+  created_at: z58.coerce.date(),
+  updated_at: z58.coerce.date(),
+  started_at: z58.coerce.date().nullable(),
+  completed_at: z58.coerce.date().nullable(),
   status: agentRunStatusSchema,
-  source: z57.string().nullable(),
-  title: z57.string(),
-  run_number: z57.number(),
+  source: z58.string().nullable(),
+  title: z58.string(),
+  run_number: z58.number(),
   // Agent info
-  agent_id: z57.guid(),
-  agent_name: z57.string(),
-  build_id: z57.guid(),
+  agent_id: z58.guid(),
+  agent_name: z58.string(),
+  build_id: z58.guid(),
   // User info
-  user_id: z57.guid().nullable(),
+  user_id: z58.guid().nullable(),
   // Case info
-  case_queue_item_id: z57.guid().nullable(),
-  case_queue_id: z57.guid().nullable(),
-  case_queue_name: z57.string().nullable(),
-  case_title: z57.string().nullable(),
-  postponed_to: z57.coerce.date().nullable(),
-  submitted_prompt_count: z57.number().int().min(0),
+  case_queue_item_id: z58.guid().nullable(),
+  case_queue_id: z58.guid().nullable(),
+  case_queue_name: z58.string().nullable(),
+  case_title: z58.string().nullable(),
+  postponed_to: z58.coerce.date().nullable(),
+  submitted_prompt_count: z58.number().int().min(0),
   eval_summaries: evalSummarySchema.nullable().optional()
 });
-var jobListResponseSchema = z57.object({
-  data: z57.array(jobListItemSchema),
-  total: z57.number()
+var jobListResponseSchema = z58.object({
+  data: z58.array(jobListItemSchema),
+  total: z58.number()
 });
-var jobFilterOptionsSchema = z57.object({
-  agents: z57.array(
-    z57.object({
-      id: z57.string(),
-      name: z57.string(),
-      folder_id: z57.string().nullable()
+var jobFilterOptionsSchema = z58.object({
+  agents: z58.array(
+    z58.object({
+      id: z58.string(),
+      name: z58.string(),
+      folder_id: z58.string().nullable()
     })
   ),
-  folders: z57.array(
-    z57.object({
-      id: z57.string(),
-      name: z57.string(),
-      parent_folder_id: z57.string().nullable()
+  folders: z58.array(
+    z58.object({
+      id: z58.string(),
+      name: z58.string(),
+      parent_folder_id: z58.string().nullable()
     })
   ),
-  users: z57.array(
-    z57.object({
-      id: z57.string(),
-      name: z57.string().nullable(),
-      email: z57.string()
+  users: z58.array(
+    z58.object({
+      id: z58.string(),
+      name: z58.string().nullable(),
+      email: z58.string()
     })
   ),
-  caseQueues: z57.array(z57.object({ id: z57.string(), name: z57.string() }))
-});
-var mcpStepSchema = z58.object({
-  tool: z58.string().describe("MCP tool name (e.g., click, fill, navigate_page)"),
-  params: z58.record(z58.string(), z58.unknown()).describe("Tool-specific parameters"),
-  fallbackSelectors: z58.array(z58.string()).optional().describe("Alternative CSS selectors if primary fails"),
-  description: z58.string().optional().describe("Human-readable step description"),
-  screenshot: z58.string().optional().describe("Base64 screenshot at this step for visual context"),
-  snapshot: z58.string().optional().describe("DOM snapshot in accessibility tree format at this step"),
-  framePath: z58.array(z58.number()).optional().describe(
+  caseQueues: z58.array(z58.object({ id: z58.string(), name: z58.string() }))
+});
+var mcpStepSchema = z59.object({
+  tool: z59.string().describe("MCP tool name (e.g., click, fill, navigate_page)"),
+  params: z59.record(z59.string(), z59.unknown()).describe("Tool-specific parameters"),
+  fallbackSelectors: z59.array(z59.string()).optional().describe("Alternative CSS selectors if primary fails"),
+  description: z59.string().optional().describe("Human-readable step description"),
+  screenshot: z59.string().optional().describe("Base64 screenshot at this step for visual context"),
+  snapshot: z59.string().optional().describe("DOM snapshot in accessibility tree format at this step"),
+  framePath: z59.array(z59.number()).optional().describe(
     "Index-based path to the target iframe (e.g., [0] for first child iframe, [1, 0] for nested)"
   )
 });
-var mcpWorkflowSchema = z58.object({
-  name: z58.string(),
-  startUrl: z58.string(),
-  viewport: z58.object({
-    width: z58.number(),
-    height: z58.number()
+var mcpWorkflowSchema = z59.object({
+  name: z59.string(),
+  startUrl: z59.string(),
+  viewport: z59.object({
+    width: z59.number(),
+    height: z59.number()
   }),
-  steps: z58.array(mcpStepSchema)
+  steps: z59.array(mcpStepSchema)
 });
-var MCP_WORKFLOW_JSON_SCHEMA = z58.toJSONSchema(mcpWorkflowSchema, {
+var MCP_WORKFLOW_JSON_SCHEMA = z59.toJSONSchema(mcpWorkflowSchema, {
   reused: "inline"
 });
 var MCP_WORKFLOW_SCHEMA_DOCS = JSON.stringify(
@@ -8265,52 +8334,52 @@ var MCP_WORKFLOW_SCHEMA_DOCS = JSON.stringify(
   2
 );
 var ORG_BROWSER_CONFIG_VERSION = 1;
-var organizationBrowserConfigDataSchema = z59.object({
+var organizationBrowserConfigDataSchema = z60.object({
   browserProvider: BrowserProviderTypeSchema.nullable(),
   dataResidency: DataResidencySchema.nullable(),
   dataHandling: DataHandlingSchema.nullable(),
-  enforced: z59.boolean()
+  enforced: z60.boolean()
 });
-var organizationBrowserConfigSchema = z59.object({
-  version: z59.literal(ORG_BROWSER_CONFIG_VERSION),
+var organizationBrowserConfigSchema = z60.object({
+  version: z60.literal(ORG_BROWSER_CONFIG_VERSION),
   data: organizationBrowserConfigDataSchema
 });
-var organizationBrowserSettingsSchema = z59.object({
-  organizationId: z59.guid(),
+var organizationBrowserSettingsSchema = z60.object({
+  organizationId: z60.guid(),
   browserProvider: BrowserProviderTypeSchema.nullable(),
   dataResidency: DataResidencySchema.nullable(),
   dataHandling: DataHandlingSchema.nullable(),
-  enforced: z59.boolean(),
-  createdAt: z59.string(),
-  updatedAt: z59.string()
+  enforced: z60.boolean(),
+  createdAt: z60.string(),
+  updatedAt: z60.string()
 });
-var getOrganizationBrowserSettingsResponseSchema = z59.object({
+var getOrganizationBrowserSettingsResponseSchema = z60.object({
   settings: organizationBrowserSettingsSchema.nullable()
 });
-var updateOrganizationBrowserSettingsRequestSchema = z59.object({
+var updateOrganizationBrowserSettingsRequestSchema = z60.object({
   browserProvider: BrowserProviderTypeSchema.nullable().optional(),
   dataResidency: DataResidencySchema.nullable().optional(),
   dataHandling: DataHandlingSchema.nullable().optional(),
-  enforced: z59.boolean().optional()
+  enforced: z60.boolean().optional()
 });
-var updateOrganizationBrowserSettingsResponseSchema = z59.object({
+var updateOrganizationBrowserSettingsResponseSchema = z60.object({
   settings: organizationBrowserSettingsSchema
 });
-var catalogPluginSchema = z60.object({
-  name: z60.string().describe("Identifier to pass in the build's plugins array."),
+var catalogPluginSchema = z61.object({
+  name: z61.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: z60.string()
+  description: z61.string()
 });
-var pluginCatalogResponseSchema = z60.object({
-  plugins: z60.array(catalogPluginSchema)
+var pluginCatalogResponseSchema = z61.object({
+  plugins: z61.array(catalogPluginSchema)
 });
-var limitValueSchema = z61.union([
-  z61.number().int().nonnegative(),
-  z61.literal("unlimited")
+var limitValueSchema = z62.union([
+  z62.number().int().nonnegative(),
+  z62.literal("unlimited")
 ]);
-var runCountingModeSchema = z61.enum(["monthly", "lifetime"]);
+var runCountingModeSchema = z62.enum(["monthly", "lifetime"]);
 function addDuplicateKeyIssues({
   ctx,
   items,
@@ -8322,7 +8391,7 @@ function addDuplicateKeyIssues({
     const key = keyFor(item);
     if (seen.has(key)) {
       ctx.addIssue({
-        code: z61.ZodIssueCode.custom,
+        code: z62.ZodIssueCode.custom,
         message: `Duplicate Product Access grant key: ${key}`,
         path: [...path, index]
       });
@@ -8333,34 +8402,34 @@ function addDuplicateKeyIssues({
 }
 __name(addDuplicateKeyIssues, "addDuplicateKeyIssues");
 __name2(addDuplicateKeyIssues, "addDuplicateKeyIssues");
-var productAccessOwnerSchema = z61.discriminatedUnion("type", [
-  z61.object({
-    type: z61.literal("organization"),
-    organizationId: z61.guid()
+var productAccessOwnerSchema = z62.discriminatedUnion("type", [
+  z62.object({
+    type: z62.literal("organization"),
+    organizationId: z62.guid()
   }),
-  z61.object({
-    type: z61.literal("team"),
-    teamId: z61.guid(),
-    organizationId: z61.guid().nullable()
+  z62.object({
+    type: z62.literal("team"),
+    teamId: z62.guid(),
+    organizationId: z62.guid().nullable()
   })
 ]);
-var productAccessGrantSetSchema = z61.object({
-  products: z61.array(
-    z61.object({
-      productKey: z61.enum(PRODUCT_KEYS),
-      enabled: z61.boolean()
+var productAccessGrantSetSchema = z62.object({
+  products: z62.array(
+    z62.object({
+      productKey: z62.enum(PRODUCT_KEYS),
+      enabled: z62.boolean()
     })
   ),
-  capabilities: z61.array(
-    z61.object({
-      capabilityKey: z61.enum(PRODUCT_ACCESS_CAPABILITY_KEYS),
-      enabled: z61.boolean()
+  capabilities: z62.array(
+    z62.object({
+      capabilityKey: z62.enum(PRODUCT_ACCESS_CAPABILITY_KEYS),
+      enabled: z62.boolean()
     })
   ),
-  limits: z61.array(
-    z61.object({
-      productKey: z61.enum(PRODUCT_KEYS),
-      limitKey: z61.enum(ENTITLEMENT_LIMIT_KEYS),
+  limits: z62.array(
+    z62.object({
+      productKey: z62.enum(PRODUCT_KEYS),
+      limitKey: z62.enum(ENTITLEMENT_LIMIT_KEYS),
       limitValue: limitValueSchema,
       countingMode: runCountingModeSchema.nullable()
     })
@@ -8385,51 +8454,51 @@ var productAccessGrantSetSchema = z61.object({
     path: ["limits"]
   });
 });
-var productAccessSnapshotSchema = z61.object({
-  products: z61.array(
-    z61.object({
-      productKey: z61.enum(PRODUCT_KEYS),
-      enabled: z61.boolean()
+var productAccessSnapshotSchema = z62.object({
+  products: z62.array(
+    z62.object({
+      productKey: z62.enum(PRODUCT_KEYS),
+      enabled: z62.boolean()
     })
   ),
-  capabilities: z61.array(
-    z61.object({
-      capabilityKey: z61.enum(PRODUCT_ACCESS_CAPABILITY_KEYS),
-      productKey: z61.enum(PRODUCT_KEYS),
-      enabled: z61.boolean()
+  capabilities: z62.array(
+    z62.object({
+      capabilityKey: z62.enum(PRODUCT_ACCESS_CAPABILITY_KEYS),
+      productKey: z62.enum(PRODUCT_KEYS),
+      enabled: z62.boolean()
     })
   ),
-  limits: z61.array(
-    z61.object({
-      limitKey: z61.enum(ENTITLEMENT_LIMIT_KEYS),
-      productKey: z61.enum(PRODUCT_KEYS),
+  limits: z62.array(
+    z62.object({
+      limitKey: z62.enum(ENTITLEMENT_LIMIT_KEYS),
+      productKey: z62.enum(PRODUCT_KEYS),
       limitValue: limitValueSchema,
       countingMode: runCountingModeSchema.nullable(),
-      label: z61.literal("per_team")
+      label: z62.literal("per_team")
     })
   )
 });
-var billingPlanSchema = z61.object({
-  planVersionId: z61.string(),
-  planName: z61.string(),
-  basePlan: z61.enum(["free", "pro", "enterprise"])
+var billingPlanSchema = z62.object({
+  planVersionId: z62.string(),
+  planName: z62.string(),
+  basePlan: z62.enum(["free", "pro", "enterprise"])
 });
-var inheritedFromSchema = z61.discriminatedUnion("type", [
-  z61.object({
-    type: z61.literal("organization"),
-    organizationId: z61.guid()
+var inheritedFromSchema = z62.discriminatedUnion("type", [
+  z62.object({
+    type: z62.literal("organization"),
+    organizationId: z62.guid()
   }),
-  z61.object({
-    type: z61.literal("team_subscription"),
-    planVersionId: z61.string()
+  z62.object({
+    type: z62.literal("team_subscription"),
+    planVersionId: z62.string()
   })
 ]);
-var productAccessReadResponseSchema = z61.object({
+var productAccessReadResponseSchema = z62.object({
   owner: productAccessOwnerSchema,
-  source: z61.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
-  accessRevision: z61.string().min(1),
+  source: z62.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
+  accessRevision: z62.string().min(1),
   displayPreset: displayPresetSchema,
-  hasExplicitTeamAccess: z61.boolean(),
+  hasExplicitTeamAccess: z62.boolean(),
   inheritedFrom: inheritedFromSchema.nullable(),
   billingPlan: billingPlanSchema.nullable(),
   grants: productAccessSnapshotSchema,
@@ -8437,67 +8506,67 @@ var productAccessReadResponseSchema = z61.object({
 }).superRefine((value, ctx) => {
   if (value.owner.type === "team" && value.source === "organization" && value.inheritedFrom?.type !== "organization") {
     ctx.addIssue({
-      code: z61.ZodIssueCode.custom,
+      code: z62.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: z61.ZodIssueCode.custom,
+      code: z62.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: z61.ZodIssueCode.custom,
+      code: z62.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: z61.ZodIssueCode.custom,
+      code: z62.ZodIssueCode.custom,
       message: "billingPlan must be null for organization Product Access",
       path: ["billingPlan"]
     });
   }
   if (value.owner.type === "organization" && value.source !== "organization") {
     ctx.addIssue({
-      code: z61.ZodIssueCode.custom,
+      code: z62.ZodIssueCode.custom,
       message: "organization Product Access source must be organization",
       path: ["source"]
     });
   }
   if (value.owner.type === "organization" && value.inheritedFrom !== null) {
     ctx.addIssue({
-      code: z61.ZodIssueCode.custom,
+      code: z62.ZodIssueCode.custom,
       message: "inheritedFrom must be null for organization Product Access",
       path: ["inheritedFrom"]
     });
   }
 });
-var productAccessImpactRequestSchema = z61.object({
+var productAccessImpactRequestSchema = z62.object({
   proposedGrants: productAccessGrantSetSchema
 });
-var productAccessWriteRequestSchema = z61.object({
+var productAccessWriteRequestSchema = z62.object({
   proposedGrants: productAccessGrantSetSchema,
-  accessRevision: z61.string().min(1),
-  impactFingerprint: z61.string().min(1).optional()
-});
-var productAccessTeamResetRequestSchema = z61.object({
-  accessRevision: z61.string().min(1),
-  impactFingerprint: z61.string().min(1).optional()
-});
-var productAccessChangeSummarySchema = z61.object({
-  addedProducts: z61.array(z61.enum(PRODUCT_KEYS)),
-  removedProducts: z61.array(z61.enum(PRODUCT_KEYS)),
-  addedCapabilities: z61.array(z61.enum(PRODUCT_ACCESS_CAPABILITY_KEYS)),
-  removedCapabilities: z61.array(z61.enum(PRODUCT_ACCESS_CAPABILITY_KEYS)),
-  limitChanges: z61.array(
-    z61.object({
-      limitKey: z61.enum(ENTITLEMENT_LIMIT_KEYS),
+  accessRevision: z62.string().min(1),
+  impactFingerprint: z62.string().min(1).optional()
+});
+var productAccessTeamResetRequestSchema = z62.object({
+  accessRevision: z62.string().min(1),
+  impactFingerprint: z62.string().min(1).optional()
+});
+var productAccessChangeSummarySchema = z62.object({
+  addedProducts: z62.array(z62.enum(PRODUCT_KEYS)),
+  removedProducts: z62.array(z62.enum(PRODUCT_KEYS)),
+  addedCapabilities: z62.array(z62.enum(PRODUCT_ACCESS_CAPABILITY_KEYS)),
+  removedCapabilities: z62.array(z62.enum(PRODUCT_ACCESS_CAPABILITY_KEYS)),
+  limitChanges: z62.array(
+    z62.object({
+      limitKey: z62.enum(ENTITLEMENT_LIMIT_KEYS),
       currentValue: limitValueSchema,
       currentCountingMode: runCountingModeSchema.nullable(),
       proposedValue: limitValueSchema,
@@ -8505,61 +8574,61 @@ var productAccessChangeSummarySchema = z61.object({
     })
   )
 });
-var productAccessImpactResponseSchema = z61.object({
+var productAccessImpactResponseSchema = z62.object({
   owner: productAccessOwnerSchema,
-  impactFingerprint: z61.string().min(1),
-  affectedTeamCount: z61.number().int().nonnegative(),
-  affectedTeamsTruncated: z61.boolean(),
+  impactFingerprint: z62.string().min(1),
+  affectedTeamCount: z62.number().int().nonnegative(),
+  affectedTeamsTruncated: z62.boolean(),
   changes: productAccessChangeSummarySchema,
-  sideEffects: z61.object({
-    automationWillPause: z61.boolean(),
-    clarityWillHide: z61.boolean()
+  sideEffects: z62.object({
+    automationWillPause: z62.boolean(),
+    clarityWillHide: z62.boolean()
   }),
-  affectedTeamsPreview: z61.array(
-    z61.object({
-      teamId: z61.guid(),
-      teamName: z61.string(),
-      source: z61.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
+  affectedTeamsPreview: z62.array(
+    z62.object({
+      teamId: z62.guid(),
+      teamName: z62.string(),
+      source: z62.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
       changes: productAccessChangeSummarySchema
     })
   )
 });
-var publicProfileSchema = z62.object({
-  id: z62.guid(),
-  name: z62.string().nullable(),
-  email: z62.email(),
-  teamId: z62.guid().nullable()
+var publicProfileSchema = z63.object({
+  id: z63.guid(),
+  name: z63.string().nullable(),
+  email: z63.email(),
+  teamId: z63.guid().nullable()
 });
-var publicProfileResponseSchema = z62.object({
+var publicProfileResponseSchema = z63.object({
   profile: publicProfileSchema
 });
-var elementSelectorsSchema = z63.object({
-  css: z63.string().optional(),
-  cssPath: z63.string().optional(),
-  xpath: z63.string().optional(),
-  testId: z63.string().optional(),
-  ariaSelector: z63.string().optional(),
-  text: z63.string().optional()
+var elementSelectorsSchema = z64.object({
+  css: z64.string().optional(),
+  cssPath: z64.string().optional(),
+  xpath: z64.string().optional(),
+  testId: z64.string().optional(),
+  ariaSelector: z64.string().optional(),
+  text: z64.string().optional()
 });
-var elementInfoSchema = z63.object({
-  uid: z63.string().optional(),
+var elementInfoSchema = z64.object({
+  uid: z64.string().optional(),
   selectors: elementSelectorsSchema,
-  tagName: z63.string(),
-  textContent: z63.string().optional(),
-  ariaLabel: z63.string().optional(),
-  computedRole: z63.string().optional(),
-  attributes: z63.record(z63.string(), z63.string()).optional(),
-  framePath: z63.array(z63.number()).optional(),
-  frameUrl: z63.string().optional()
-});
-var recordedEventSchema = z63.looseObject({
-  id: z63.string(),
-  type: z63.string(),
-  timestamp: z63.number(),
-  url: z63.string(),
-  tabId: z63.number().optional(),
-  frameId: z63.number().optional(),
-  framePath: z63.array(z63.number()).optional(),
+  tagName: z64.string(),
+  textContent: z64.string().optional(),
+  ariaLabel: z64.string().optional(),
+  computedRole: z64.string().optional(),
+  attributes: z64.record(z64.string(), z64.string()).optional(),
+  framePath: z64.array(z64.number()).optional(),
+  frameUrl: z64.string().optional()
+});
+var recordedEventSchema = z64.looseObject({
+  id: z64.string(),
+  type: z64.string(),
+  timestamp: z64.number(),
+  url: z64.string(),
+  tabId: z64.number().optional(),
+  frameId: z64.number().optional(),
+  framePath: z64.array(z64.number()).optional(),
   element: elementInfoSchema.optional()
 });
 var DUVO_CLIENT_HEADER = "x-duvo-client";
@@ -8579,63 +8648,63 @@ function resolveRequestSourceFromClientHeader(header) {
 }
 __name(resolveRequestSourceFromClientHeader, "resolveRequestSourceFromClientHeader");
 __name2(resolveRequestSourceFromClientHeader, "resolveRequestSourceFromClientHeader");
-var RedactedMcpServerConfigSchema = z64.object({
+var RedactedMcpServerConfigSchema = z65.object({
   type: TransportTypeSchema,
   integrationSlug: IntegrationSlugSchema,
-  instanceId: z64.string().nullable()
+  instanceId: z65.string().nullable()
 });
-var ThreadContextMessageSchema = z64.object({
-  role: z64.enum(["user", "assistant"]),
-  content: z64.string()
+var ThreadContextMessageSchema = z65.object({
+  role: z65.enum(["user", "assistant"]),
+  content: z65.string()
 });
-var ChatFileReferenceSchema = z64.object({
-  id: z64.string(),
-  name: z64.string(),
-  mimetype: z64.string(),
-  size: z64.number(),
-  platform: z64.enum(["slack", "teams"]),
-  workspaceId: z64.string(),
-  channelId: z64.string()
-});
-var ResolvedSubAgentSchema = z64.object({
-  agentId: z64.string().uuid(),
-  buildId: z64.string().uuid(),
-  name: z64.string().min(1).max(64).regex(/^[a-z0-9-]+$/).describe(
+var ChatFileReferenceSchema = z65.object({
+  id: z65.string(),
+  name: z65.string(),
+  mimetype: z65.string(),
+  size: z65.number(),
+  platform: z65.enum(["slack", "teams"]),
+  workspaceId: z65.string(),
+  channelId: z65.string()
+});
+var ResolvedSubAgentSchema = z65.object({
+  agentId: z65.string().uuid(),
+  buildId: z65.string().uuid(),
+  name: z65.string().min(1).max(64).regex(/^[a-z0-9-]+$/).describe(
     "Stable slug used as the Claude Code subagent name (kebab-case, \u226464 chars)"
   ),
-  description: z64.string().describe(
+  description: z65.string().describe(
     "Routing description Claude uses to decide when to delegate to this subagent"
   ),
-  prompt: z64.string().describe("System prompt (AOP) for this subagent"),
-  model: z64.string().optional().describe("Optional Claude model identifier override for this subagent"),
-  mcpServers: z64.record(z64.string(), RedactedMcpServerConfigSchema).default({}).describe(
+  prompt: z65.string().describe("System prompt (AOP) for this subagent"),
+  model: z65.string().optional().describe("Optional Claude model identifier override for this subagent"),
+  mcpServers: z65.record(z65.string(), RedactedMcpServerConfigSchema).default({}).describe(
     "Redacted MCP server configs scoped to this subagent. Secrets resolved at execution time."
   )
 });
 var RunConfigSchema = AgentConfigSchema.extend({
-  task: z64.string(),
-  mcpServers: z64.record(z64.string(), RedactedMcpServerConfigSchema),
-  subAgents: z64.array(ResolvedSubAgentSchema).optional().default([]),
-  conversationHistory: z64.array(ThreadContextMessageSchema).optional(),
-  chatFiles: z64.array(ChatFileReferenceSchema).optional(),
+  task: z65.string(),
+  mcpServers: z65.record(z65.string(), RedactedMcpServerConfigSchema),
+  subAgents: z65.array(ResolvedSubAgentSchema).optional().default([]),
+  conversationHistory: z65.array(ThreadContextMessageSchema).optional(),
+  chatFiles: z65.array(ChatFileReferenceSchema).optional(),
   /** IANA timezone (e.g. `"Europe/Prague"`). Consumers should fall back to UTC when absent. */
-  timezone: z64.string().optional(),
+  timezone: z65.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: z64.string().optional()
+  sessionStartedAt: z65.string().optional()
 });
-var StoredRunConfigV0Schema = z64.object({
-  version: z64.literal("v0")
+var StoredRunConfigV0Schema = z65.object({
+  version: z65.literal("v0")
 });
-var StoredRunConfigV1Schema = z64.object({
-  version: z64.literal("v1"),
+var StoredRunConfigV1Schema = z65.object({
+  version: z65.literal("v1"),
   data: RunConfigSchema
 });
-var StoredRunConfigSchema = z64.union([
+var StoredRunConfigSchema = z65.union([
   StoredRunConfigV0Schema,
   StoredRunConfigV1Schema
 ]);
@@ -8654,177 +8723,177 @@ function isRunConfig(config) {
 }
 __name(isRunConfig, "isRunConfig");
 __name2(isRunConfig, "isRunConfig");
-var skillApiSchema = z65.object({
-  id: z65.string(),
-  name: z65.string(),
-  description: z65.string(),
+var skillApiSchema = z66.object({
+  id: z66.string(),
+  name: z66.string(),
+  description: z66.string(),
   // System skills have null team_id.
-  team_id: z65.string().nullable()
-});
-var listSkillsResponseSchema = z65.object({
-  skills: z65.array(skillApiSchema)
-});
-var systemSkillSchema = z65.object({
-  id: z65.string(),
-  name: z65.string(),
-  description: z65.string()
+  team_id: z66.string().nullable()
 });
-var listSystemSkillsResponseSchema = z65.object({
-  skills: z65.array(systemSkillSchema)
+var listSkillsResponseSchema = z66.object({
+  skills: z66.array(skillApiSchema)
 });
-var skillFileItemSchema = z65.object({
-  name: z65.string(),
-  path: z65.string(),
-  size: z65.number().optional(),
-  contentType: z65.string().optional(),
-  updatedAt: z65.string().optional()
-});
-var listSkillFilesResponseSchema = z65.object({
-  files: z65.array(skillFileItemSchema)
-});
-var getSkillFileContentResponseSchema = z65.object({
-  content: z65.string(),
-  path: z65.string(),
-  contentType: z65.string().optional()
-});
-var updateSkillFileBodySchema = z65.object({
-  content: z65.string()
-});
-var updateSkillFileResponseSchema = z65.object({
-  success: z65.boolean(),
-  message: z65.string(),
-  skill: z65.object({
-    id: z65.string(),
-    name: z65.string(),
-    description: z65.string()
+var systemSkillSchema = z66.object({
+  id: z66.string(),
+  name: z66.string(),
+  description: z66.string()
+});
+var listSystemSkillsResponseSchema = z66.object({
+  skills: z66.array(systemSkillSchema)
+});
+var skillFileItemSchema = z66.object({
+  name: z66.string(),
+  path: z66.string(),
+  size: z66.number().optional(),
+  contentType: z66.string().optional(),
+  updatedAt: z66.string().optional()
+});
+var listSkillFilesResponseSchema = z66.object({
+  files: z66.array(skillFileItemSchema)
+});
+var getSkillFileContentResponseSchema = z66.object({
+  content: z66.string(),
+  path: z66.string(),
+  contentType: z66.string().optional()
+});
+var updateSkillFileBodySchema = z66.object({
+  content: z66.string()
+});
+var updateSkillFileResponseSchema = z66.object({
+  success: z66.boolean(),
+  message: z66.string(),
+  skill: z66.object({
+    id: z66.string(),
+    name: z66.string(),
+    description: z66.string()
   }).optional()
 });
-var deleteSkillResponseSchema = z65.object({
-  success: z65.boolean(),
-  message: z65.string()
+var deleteSkillResponseSchema = z66.object({
+  success: z66.boolean(),
+  message: z66.string()
 });
-var generateSkillBodySchema = z65.object({
-  prompt: z65.string().min(1).max(2e3),
-  existingContent: z65.string().max(2e4).optional()
+var generateSkillBodySchema = z66.object({
+  prompt: z66.string().min(1).max(2e3),
+  existingContent: z66.string().max(2e4).optional()
 });
-var generateSkillResponseSchema = z65.object({
-  content: z65.string()
+var generateSkillResponseSchema = z66.object({
+  content: z66.string()
 });
-var skillAssignmentSchema = z65.object({
-  id: z65.string(),
-  name: z65.string()
+var skillAssignmentSchema = z66.object({
+  id: z66.string(),
+  name: z66.string()
 });
-var listSkillAssignmentsResponseSchema = z65.object({
-  assignments: z65.array(skillAssignmentSchema),
-  total: z65.number()
+var listSkillAssignmentsResponseSchema = z66.object({
+  assignments: z66.array(skillAssignmentSchema),
+  total: z66.number()
 });
-var teamInvitationApiSchema = z66.object({
-  id: z66.string(),
-  team_id: z66.string(),
-  email: z66.email(),
-  invited_by: z66.string(),
-  role: z66.string(),
-  status: z66.string(),
-  name: z66.string().nullable(),
-  created_at: z66.string(),
-  process_id: z66.guid().nullable().optional()
-});
-var teamInvitationDetailApiSchema = z66.object({
-  id: z66.string(),
-  team_id: z66.string(),
-  email: z66.email(),
-  invited_by: z66.string(),
-  role: z66.string(),
-  status: z66.string(),
-  name: z66.string().nullable(),
-  created_at: z66.string(),
-  process_id: z66.guid().nullable().optional(),
-  team: z66.object({
-    id: z66.string(),
-    name: z66.string()
+var teamInvitationApiSchema = z67.object({
+  id: z67.string(),
+  team_id: z67.string(),
+  email: z67.email(),
+  invited_by: z67.string(),
+  role: z67.string(),
+  status: z67.string(),
+  name: z67.string().nullable(),
+  created_at: z67.string(),
+  process_id: z67.guid().nullable().optional()
+});
+var teamInvitationDetailApiSchema = z67.object({
+  id: z67.string(),
+  team_id: z67.string(),
+  email: z67.email(),
+  invited_by: z67.string(),
+  role: z67.string(),
+  status: z67.string(),
+  name: z67.string().nullable(),
+  created_at: z67.string(),
+  process_id: z67.guid().nullable().optional(),
+  team: z67.object({
+    id: z67.string(),
+    name: z67.string()
   }),
-  invitedBy: z66.object({
-    id: z66.string(),
-    name: z66.string().nullable(),
-    email: z66.email()
+  invitedBy: z67.object({
+    id: z67.string(),
+    name: z67.string().nullable(),
+    email: z67.email()
   }),
-  process: z66.object({
-    id: z66.string(),
-    name: z66.string()
+  process: z67.object({
+    id: z67.string(),
+    name: z67.string()
   }).optional()
 });
-var createTeamInvitationRequestSchema = z66.object({
-  email: z66.email(),
-  role: z66.string(),
-  processId: z66.guid().optional()
+var createTeamInvitationRequestSchema = z67.object({
+  email: z67.email(),
+  role: z67.string(),
+  processId: z67.guid().optional()
 });
-var acceptTeamInvitationRequestSchema = z66.object({
-  name: z66.string().optional()
+var acceptTeamInvitationRequestSchema = z67.object({
+  name: z67.string().optional()
 });
-var bulkInviteResponseSchema = z66.object({
-  succeeded: z66.number(),
-  skipped: z66.number(),
-  failed: z66.number()
+var bulkInviteResponseSchema = z67.object({
+  succeeded: z67.number(),
+  skipped: z67.number(),
+  failed: z67.number()
 });
-var teamDiscoveryModeSchema = z67.enum(["request", "auto"]);
-var BrowserRegionSchema = z67.enum([
+var teamDiscoveryModeSchema = z68.enum(["request", "auto"]);
+var BrowserRegionSchema = z68.enum([
   "us-west-2",
   "us-east-1",
   "eu-central-1",
   "ap-southeast-1"
 ]);
-var BrowserLocationSchema = z67.union([
-  z67.literal("cz"),
-  z67.literal("de"),
-  z67.literal("fr"),
-  z67.literal("gb"),
-  z67.literal("it"),
-  z67.literal("pl"),
-  z67.literal("sk")
+var BrowserLocationSchema = z68.union([
+  z68.literal("cz"),
+  z68.literal("de"),
+  z68.literal("fr"),
+  z68.literal("gb"),
+  z68.literal("it"),
+  z68.literal("pl"),
+  z68.literal("sk")
 ]);
-var teamMemberApiSchema = z67.object({
-  id: z67.guid(),
-  name: z67.string().nullable(),
-  email: z67.email(),
-  role: z67.string(),
-  inheritedFromOrg: z67.boolean().default(false)
-});
-var listTeamMembersResponseSchema = z67.object({
-  members: z67.array(teamMemberApiSchema),
-  total: z67.number().int().nonnegative(),
-  limit: z67.number().int().positive(),
-  offset: z67.number().int().nonnegative()
-});
-var updateMemberRoleRequestSchema = z67.object({
-  role: z67.string()
-});
-var removeMemberResponseSchema = z67.object({
-  success: z67.literal(true),
-  nextTeamId: z67.guid().nullable(),
-  planType: z67.enum(["pro", "enterprise"]).nullable()
-});
-var getMemberMeResponseSchema = z67.object({
-  role: z67.string().nullable()
-});
-var addTeamMemberRequestSchema = z67.object({
-  userId: z67.guid(),
-  role: z67.string()
-});
-var updateTeamRequestSchema = z67.object({
-  name: z67.string().min(1).optional(),
-  slack_team_id: z67.string().optional(),
+var teamMemberApiSchema = z68.object({
+  id: z68.guid(),
+  name: z68.string().nullable(),
+  email: z68.email(),
+  role: z68.string(),
+  inheritedFromOrg: z68.boolean().default(false)
+});
+var listTeamMembersResponseSchema = z68.object({
+  members: z68.array(teamMemberApiSchema),
+  total: z68.number().int().nonnegative(),
+  limit: z68.number().int().positive(),
+  offset: z68.number().int().nonnegative()
+});
+var updateMemberRoleRequestSchema = z68.object({
+  role: z68.string()
+});
+var removeMemberResponseSchema = z68.object({
+  success: z68.literal(true),
+  nextTeamId: z68.guid().nullable(),
+  planType: z68.enum(["pro", "enterprise"]).nullable()
+});
+var getMemberMeResponseSchema = z68.object({
+  role: z68.string().nullable()
+});
+var addTeamMemberRequestSchema = z68.object({
+  userId: z68.guid(),
+  role: z68.string()
+});
+var updateTeamRequestSchema = z68.object({
+  name: z68.string().min(1).optional(),
+  slack_team_id: z68.string().optional(),
   discovery_mode: teamDiscoveryModeSchema.optional()
 });
-var teamApiSchema = z67.object({
-  id: z67.guid(),
-  name: z67.string(),
-  created_at: z67.string(),
-  organization_id: z67.guid().nullable(),
-  slack_team_id: z67.string().nullable(),
+var teamApiSchema = z68.object({
+  id: z68.guid(),
+  name: z68.string(),
+  created_at: z68.string(),
+  organization_id: z68.guid().nullable(),
+  slack_team_id: z68.string().nullable(),
   discovery_mode: teamDiscoveryModeSchema
 });
 var TEAM_CONFIG_VERSION = 1;
-var teamConfigDataSchema = z67.object({
+var teamConfigDataSchema = z68.object({
   browserProviderOverride: BrowserProviderTypeSchema.nullable().optional(),
   // Egress identity (proxy country) — what the target site sees.
   browserLocationOverride: BrowserLocationSchema.nullable().optional(),
@@ -8835,182 +8904,182 @@ var teamConfigDataSchema = z67.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: z67.boolean().nullable().optional()
+  sessionRecordingOverride: z68.boolean().nullable().optional()
 });
-var teamConfigSchema = z67.object({
-  version: z67.literal(TEAM_CONFIG_VERSION),
+var teamConfigSchema = z68.object({
+  version: z68.literal(TEAM_CONFIG_VERSION),
   data: teamConfigDataSchema
 });
-var listTeamInvitesResponseSchema = z67.object({
-  invitations: z67.array(teamInvitationApiSchema)
+var listTeamInvitesResponseSchema = z68.object({
+  invitations: z68.array(teamInvitationApiSchema)
 });
-var teamInsightsCopilotSchema = z68.object({
-  id: z68.guid(),
-  name: z68.string(),
-  teamName: z68.string().nullable().optional(),
-  created_at: z68.string().nullable(),
-  updated_at: z68.string().nullable(),
-  team_id: z68.string().nullable(),
-  thread_id: z68.string().nullable(),
-  slack_enabled: z68.boolean().nullable()
-});
-var teamInsightsUserProfileSchema = z68.object({
-  id: z68.guid(),
-  name: z68.string().nullable(),
-  email: z68.string()
+var teamInsightsCopilotSchema = z69.object({
+  id: z69.guid(),
+  name: z69.string(),
+  teamName: z69.string().nullable().optional(),
+  created_at: z69.string().nullable(),
+  updated_at: z69.string().nullable(),
+  team_id: z69.string().nullable(),
+  thread_id: z69.string().nullable(),
+  slack_enabled: z69.boolean().nullable()
+});
+var teamInsightsUserProfileSchema = z69.object({
+  id: z69.guid(),
+  name: z69.string().nullable(),
+  email: z69.string()
 });
 var teamInsightsUserUsageSchema = teamInsightsUserProfileSchema.extend(
   {
-    runCount: z68.number(),
-    lastRun: z68.string().nullable()
+    runCount: z69.number(),
+    lastRun: z69.string().nullable()
   }
 );
-var teamInsightsMetricSourceSchema = z68.object({
+var teamInsightsMetricSourceSchema = z69.object({
   source: agentRunSourceSchema,
-  runsTotal: z68.number(),
-  completedRuns: z68.number()
+  runsTotal: z69.number(),
+  completedRuns: z69.number()
 });
 var teamInsightsCopilotWithRunsSchema = teamInsightsCopilotSchema.extend({
-  integrations: z68.array(z68.string()),
-  uniqueUsersCount: z68.number(),
-  users: z68.array(teamInsightsUserUsageSchema),
-  totalRuns: z68.number(),
-  completedRuns: z68.number(),
-  totalTimeSpentMs: z68.number(),
-  averageTimeSpentMs: z68.number(),
-  completedRunsWithTiming: z68.number(),
-  sources: z68.array(teamInsightsMetricSourceSchema)
-});
-var teamInsightsAgentsRunResponseSchema = z68.object({
-  data: z68.array(teamInsightsCopilotWithRunsSchema),
-  total: z68.number()
-});
-var teamInsightsMetricsResponseSchema = z68.object({
-  runsTotal: z68.number(),
-  completedRuns: z68.number(),
-  sources: z68.array(teamInsightsMetricSourceSchema)
-});
-var teamInsightsUserAgentRunSchema = z68.object({
-  id: z68.guid(),
-  created_at: z68.string(),
-  updated_at: z68.string(),
-  agent_id: z68.guid(),
-  agent_name: z68.string(),
-  build_id: z68.guid(),
-  source: z68.string().nullable(),
-  started_at: z68.string().nullable(),
-  completed_at: z68.string().nullable()
-});
-var teamInsightsAgentSchema = z68.object({
-  id: z68.guid(),
-  name: z68.string(),
-  teamName: z68.string().nullable().optional(),
-  runs: z68.array(teamInsightsUserAgentRunSchema)
-});
-var teamInsightsUserWithAgentsAndRunsSchema = teamInsightsUserProfileSchema.extend({
-  agents: z68.array(teamInsightsAgentSchema),
-  runs: z68.array(teamInsightsUserAgentRunSchema),
-  totalRuns: z68.number()
-});
-var teamInsightsUsersResponseSchema = z68.object({
-  data: z68.array(teamInsightsUserWithAgentsAndRunsSchema),
-  total: z68.number()
-});
-var guardrailsAuthorSchema = z69.object({
+  integrations: z69.array(z69.string()),
+  uniqueUsersCount: z69.number(),
+  users: z69.array(teamInsightsUserUsageSchema),
+  totalRuns: z69.number(),
+  completedRuns: z69.number(),
+  totalTimeSpentMs: z69.number(),
+  averageTimeSpentMs: z69.number(),
+  completedRunsWithTiming: z69.number(),
+  sources: z69.array(teamInsightsMetricSourceSchema)
+});
+var teamInsightsAgentsRunResponseSchema = z69.object({
+  data: z69.array(teamInsightsCopilotWithRunsSchema),
+  total: z69.number()
+});
+var teamInsightsMetricsResponseSchema = z69.object({
+  runsTotal: z69.number(),
+  completedRuns: z69.number(),
+  sources: z69.array(teamInsightsMetricSourceSchema)
+});
+var teamInsightsUserAgentRunSchema = z69.object({
   id: z69.guid(),
-  name: z69.string().nullable(),
-  email: z69.email()
-});
-var guardrailsRevisionSchema = z69.object({
+  created_at: z69.string(),
+  updated_at: z69.string(),
+  agent_id: z69.guid(),
+  agent_name: z69.string(),
+  build_id: z69.guid(),
+  source: z69.string().nullable(),
+  started_at: z69.string().nullable(),
+  completed_at: z69.string().nullable()
+});
+var teamInsightsAgentSchema = z69.object({
   id: z69.guid(),
-  teamId: z69.guid(),
-  guardrailsText: z69.string().nullable(),
-  blockedDomains: z69.array(z69.string()),
-  createdAt: z69.string(),
+  name: z69.string(),
+  teamName: z69.string().nullable().optional(),
+  runs: z69.array(teamInsightsUserAgentRunSchema)
+});
+var teamInsightsUserWithAgentsAndRunsSchema = teamInsightsUserProfileSchema.extend({
+  agents: z69.array(teamInsightsAgentSchema),
+  runs: z69.array(teamInsightsUserAgentRunSchema),
+  totalRuns: z69.number()
+});
+var teamInsightsUsersResponseSchema = z69.object({
+  data: z69.array(teamInsightsUserWithAgentsAndRunsSchema),
+  total: z69.number()
+});
+var guardrailsAuthorSchema = z70.object({
+  id: z70.guid(),
+  name: z70.string().nullable(),
+  email: z70.email()
+});
+var guardrailsRevisionSchema = z70.object({
+  id: z70.guid(),
+  teamId: z70.guid(),
+  guardrailsText: z70.string().nullable(),
+  blockedDomains: z70.array(z70.string()),
+  createdAt: z70.string(),
   createdBy: guardrailsAuthorSchema
 });
-var getTeamGuardrailsResponseSchema = z69.object({
+var getTeamGuardrailsResponseSchema = z70.object({
   current: guardrailsRevisionSchema.nullable()
 });
-var listTeamGuardrailsRevisionsQuerySchema = z69.object({
-  limit: z69.coerce.number().int().min(1).max(100).default(20),
-  offset: z69.coerce.number().int().min(0).default(0)
+var listTeamGuardrailsRevisionsQuerySchema = z70.object({
+  limit: z70.coerce.number().int().min(1).max(100).default(20),
+  offset: z70.coerce.number().int().min(0).default(0)
 });
-var listTeamGuardrailsRevisionsResponseSchema = z69.object({
-  revisions: z69.array(guardrailsRevisionSchema),
-  total: z69.number().int().nonnegative()
+var listTeamGuardrailsRevisionsResponseSchema = z70.object({
+  revisions: z70.array(guardrailsRevisionSchema),
+  total: z70.number().int().nonnegative()
 });
-var createTeamGuardrailsRevisionRequestSchema = z69.object({
-  guardrailsText: z69.string().max(MAX_GUARDRAILS_TEXT_LENGTH).nullable().transform((value) => value && value.trim().length > 0 ? value : null),
-  blockedDomains: z69.array(z69.string()).max(MAX_BLOCKED_DOMAINS)
+var createTeamGuardrailsRevisionRequestSchema = z70.object({
+  guardrailsText: z70.string().max(MAX_GUARDRAILS_TEXT_LENGTH).nullable().transform((value) => value && value.trim().length > 0 ? value : null),
+  blockedDomains: z70.array(z70.string()).max(MAX_BLOCKED_DOMAINS)
 });
-var userDismissalListResponseSchema = z70.object({
-  data: z70.array(z70.string())
+var userDismissalListResponseSchema = z71.object({
+  data: z71.array(z71.string())
 });
-var userDismissalMutationSchema = z70.object({
-  elementKey: z70.string()
+var userDismissalMutationSchema = z71.object({
+  elementKey: z71.string()
 });
 var PASSWORD_MIN = 1;
 var PASSWORD_MAX = 1024;
 var NAME_MAX = 200;
 var URL_MAX = 500;
 var USERNAME_MAX = 200;
-var vpnProxyConfigSummarySchema = z71.object({
-  id: z71.guid(),
-  name: z71.string(),
-  server: z71.string(),
-  username: z71.string(),
-  enabled: z71.boolean(),
-  passwordSet: z71.boolean(),
-  organizationCount: z71.number().int().nonnegative(),
-  createdAt: z71.string(),
-  updatedAt: z71.string()
-});
-var vpnProxyConfigListResponseSchema = z71.object({
-  configs: z71.array(vpnProxyConfigSummarySchema)
-});
-var vpnProxyConfigCreateRequestSchema = z71.object({
-  name: z71.string().trim().min(1).max(NAME_MAX),
-  server: z71.string().trim().min(1).max(URL_MAX).url(),
-  username: z71.string().trim().min(1).max(USERNAME_MAX),
-  password: z71.string().min(PASSWORD_MIN).max(PASSWORD_MAX),
-  enabled: z71.boolean().prefault(true)
-});
-var vpnProxyConfigCreateResponseSchema = z71.object({
+var vpnProxyConfigSummarySchema = z72.object({
+  id: z72.guid(),
+  name: z72.string(),
+  server: z72.string(),
+  username: z72.string(),
+  enabled: z72.boolean(),
+  passwordSet: z72.boolean(),
+  organizationCount: z72.number().int().nonnegative(),
+  createdAt: z72.string(),
+  updatedAt: z72.string()
+});
+var vpnProxyConfigListResponseSchema = z72.object({
+  configs: z72.array(vpnProxyConfigSummarySchema)
+});
+var vpnProxyConfigCreateRequestSchema = z72.object({
+  name: z72.string().trim().min(1).max(NAME_MAX),
+  server: z72.string().trim().min(1).max(URL_MAX).url(),
+  username: z72.string().trim().min(1).max(USERNAME_MAX),
+  password: z72.string().min(PASSWORD_MIN).max(PASSWORD_MAX),
+  enabled: z72.boolean().prefault(true)
+});
+var vpnProxyConfigCreateResponseSchema = z72.object({
   config: vpnProxyConfigSummarySchema
 });
-var vpnProxyConfigUpdateRequestSchema = z71.object({
-  name: z71.string().trim().min(1).max(NAME_MAX).optional(),
-  server: z71.string().trim().min(1).max(URL_MAX).url().optional(),
-  username: z71.string().trim().min(1).max(USERNAME_MAX).optional(),
-  password: z71.string().min(PASSWORD_MIN).max(PASSWORD_MAX).optional(),
-  enabled: z71.boolean().optional()
+var vpnProxyConfigUpdateRequestSchema = z72.object({
+  name: z72.string().trim().min(1).max(NAME_MAX).optional(),
+  server: z72.string().trim().min(1).max(URL_MAX).url().optional(),
+  username: z72.string().trim().min(1).max(USERNAME_MAX).optional(),
+  password: z72.string().min(PASSWORD_MIN).max(PASSWORD_MAX).optional(),
+  enabled: z72.boolean().optional()
 });
-var vpnProxyConfigUpdateResponseSchema = z71.object({
+var vpnProxyConfigUpdateResponseSchema = z72.object({
   config: vpnProxyConfigSummarySchema
 });
-var vpnProxyConfigDeleteResponseSchema = z71.object({
-  success: z71.literal(true)
+var vpnProxyConfigDeleteResponseSchema = z72.object({
+  success: z72.literal(true)
 });
-var vpnProxyConfigOrganizationSchema = z71.object({
-  id: z71.guid(),
-  organizationId: z71.guid(),
-  organizationName: z71.string(),
-  attachedAt: z71.string()
+var vpnProxyConfigOrganizationSchema = z72.object({
+  id: z72.guid(),
+  organizationId: z72.guid(),
+  organizationName: z72.string(),
+  attachedAt: z72.string()
 });
-var vpnProxyConfigOrganizationListResponseSchema = z71.object({
-  organizations: z71.array(vpnProxyConfigOrganizationSchema)
+var vpnProxyConfigOrganizationListResponseSchema = z72.object({
+  organizations: z72.array(vpnProxyConfigOrganizationSchema)
 });
-var vpnProxyConfigAttachOrganizationRequestSchema = z71.object({
-  organizationId: z71.guid()
+var vpnProxyConfigAttachOrganizationRequestSchema = z72.object({
+  organizationId: z72.guid()
 });
-var vpnProxyConfigAttachOrganizationResponseSchema = z71.object({
+var vpnProxyConfigAttachOrganizationResponseSchema = z72.object({
   attachment: vpnProxyConfigOrganizationSchema
 });
-var vpnProxyConfigDetachOrganizationResponseSchema = z71.object({
-  success: z71.literal(true)
+var vpnProxyConfigDetachOrganizationResponseSchema = z72.object({
+  success: z72.literal(true)
 });
-var vpnProxyConfigForOrganizationResponseSchema = z71.object({
+var vpnProxyConfigForOrganizationResponseSchema = z72.object({
   config: vpnProxyConfigSummarySchema.nullable()
 });
 function canonicalizeSopInput(config) {
@@ -9031,7 +9100,7 @@ function canonicalizeSopInput(config) {
 }
 __name(canonicalizeSopInput, "canonicalizeSopInput");
 __name2(canonicalizeSopInput, "canonicalizeSopInput");
-var caseFilterStatusSchema = z72.enum([
+var caseFilterStatusSchema = z73.enum([
   "pending",
   "claimed",
   "completed",
@@ -9039,19 +9108,19 @@ var caseFilterStatusSchema = z72.enum([
   "needs_input",
   "postponed"
 ]);
-var casesFiltersSchema = z72.object({
-  status: z72.array(caseFilterStatusSchema).optional(),
-  created_at_from: z72.string().optional(),
-  updated_at_from: z72.string().optional(),
-  labels: z72.record(z72.string(), z72.array(z72.string())).optional()
+var casesFiltersSchema = z73.object({
+  status: z73.array(caseFilterStatusSchema).optional(),
+  created_at_from: z73.string().optional(),
+  updated_at_from: z73.string().optional(),
+  labels: z73.record(z73.string(), z73.array(z73.string())).optional()
 });
-var casesListRequestBodySchema = z72.object({
+var casesListRequestBodySchema = z73.object({
   filters: casesFiltersSchema.default({}),
-  limit: z72.int().min(1).max(100).default(25),
-  offset: z72.int().min(0).default(0),
-  sort_by: z72.enum(["created_at", "updated_at", "postponed_to"]).default("created_at"),
-  sort_order: z72.enum(["asc", "desc"]).default("desc"),
-  search: z72.string().optional()
+  limit: z73.int().min(1).max(100).default(25),
+  offset: z73.int().min(0).default(0),
+  sort_by: z73.enum(["created_at", "updated_at", "postponed_to"]).default("created_at"),
+  sort_order: z73.enum(["asc", "desc"]).default("desc"),
+  search: z73.string().optional()
 });
 function toBase64(input) {
   if (typeof btoa === "function") {
@@ -9146,7 +9215,7 @@ function setFilterValuesByCategoryKey(filters, categoryKey, values) {
       const { status: _, ...rest } = filters;
       return rest;
     }
-    const parsed = z72.array(caseFilterStatusSchema).safeParse(values);
+    const parsed = z73.array(caseFilterStatusSchema).safeParse(values);
     if (!parsed.success) {
       return filters;
     }
@@ -10369,11 +10438,11 @@ function emptyConfig() {
 __name(emptyConfig, "emptyConfig");
 
 // src/config/env.ts
-import { z as z73 } from "zod";
-var optionalEnvString = z73.string().optional().transform(
+import { z as z74 } from "zod";
+var optionalEnvString = z74.string().optional().transform(
   (value) => value === void 0 || value === "" ? void 0 : value
 );
-var CliEnvSchema = z73.object({
+var CliEnvSchema = z74.object({
   DUVO_PROFILE: optionalEnvString,
   DUVO_API_KEY: optionalEnvString,
   DUVO_API_BASE_URL: optionalEnvString,
@@ -10870,9 +10939,9 @@ async function requireAuthenticatedConfig(command) {
 __name(requireAuthenticatedConfig, "requireAuthenticatedConfig");
 
 // src/commands/shared/team-context.ts
-import { z as z74 } from "zod";
-var teamSchema = z74.object({ id: z74.string() });
-var listMyTeamsResponseSchema = z74.object({ teams: z74.array(teamSchema) });
+import { z as z75 } from "zod";
+var teamSchema = z75.object({ id: z75.string() });
+var listMyTeamsResponseSchema = z75.object({ teams: z75.array(teamSchema) });
 async function resolveRequiredTeamId(config, options = {}) {
   if (options.override) {
     return options.override;
@@ -11655,56 +11724,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 z76 } from "zod";
+import { z as z77 } from "zod";
 
 // src/api/json-value.ts
-import { z as z75 } from "zod";
-var jsonValueSchema = z75.lazy(
-  () => z75.union([
-    z75.string(),
-    z75.number(),
-    z75.boolean(),
-    z75.null(),
-    z75.array(jsonValueSchema),
-    z75.record(z75.string(), jsonValueSchema)
+import { z as z76 } from "zod";
+var jsonValueSchema = z76.lazy(
+  () => z76.union([
+    z76.string(),
+    z76.number(),
+    z76.boolean(),
+    z76.null(),
+    z76.array(jsonValueSchema),
+    z76.record(z76.string(), jsonValueSchema)
   ])
 );
 
 // src/api/agent-schemas.ts
-var publicAgentSchema = z76.object({
-  id: z76.string(),
-  name: z76.string(),
-  slack_enabled: z76.boolean().nullish(),
-  microsoft_teams_enabled: z76.boolean().nullish(),
-  agentic_memory_enabled: z76.boolean().nullish(),
-  thread_id: z76.string().nullish(),
-  created_at: z76.string().nullish(),
-  updated_at: z76.string().nullish(),
-  latest_build: z76.object({ config: jsonValueSchema.nullish() }).nullish()
-});
-var publicBuildSchema = z76.object({
-  id: z76.string(),
-  agent_id: z76.string(),
-  name: z76.string(),
-  revision_number: z76.number().nullish(),
-  created_at: z76.string().nullish(),
-  updated_at: z76.string().nullish()
-});
-var listAgentsResponseSchema = z76.object({
-  agents: z76.array(publicAgentSchema),
-  total: z76.number().nullish(),
-  limit: z76.number().nullish(),
-  offset: z76.number().nullish()
-});
-var getAgentResponseSchema = z76.object({
+var publicAgentSchema = z77.object({
+  id: z77.string(),
+  name: z77.string(),
+  slack_enabled: z77.boolean().nullish(),
+  microsoft_teams_enabled: z77.boolean().nullish(),
+  agentic_memory_enabled: z77.boolean().nullish(),
+  thread_id: z77.string().nullish(),
+  created_at: z77.string().nullish(),
+  updated_at: z77.string().nullish(),
+  latest_build: z77.object({ config: jsonValueSchema.nullish() }).nullish()
+});
+var publicBuildSchema = z77.object({
+  id: z77.string(),
+  agent_id: z77.string(),
+  name: z77.string(),
+  revision_number: z77.number().nullish(),
+  created_at: z77.string().nullish(),
+  updated_at: z77.string().nullish()
+});
+var listAgentsResponseSchema = z77.object({
+  agents: z77.array(publicAgentSchema),
+  total: z77.number().nullish(),
+  limit: z77.number().nullish(),
+  offset: z77.number().nullish()
+});
+var getAgentResponseSchema = z77.object({
   agent: publicAgentSchema
 });
-var createAgentResponseSchema = z76.object({
+var createAgentResponseSchema = z77.object({
   agent: publicAgentSchema,
   build: publicBuildSchema.optional()
 });
-var deleteAgentResponseSchema = z76.object({
-  success: z76.literal(true)
+var deleteAgentResponseSchema = z77.object({
+  success: z77.literal(true)
 });
 var buildConfigSchema = StoredAgentConfigSchemaV2;
 var DEFAULT_NEW_AGENT_NAME = DEFAULT_AGENT_NAME;
@@ -12154,29 +12223,29 @@ function registerAgentsEvalScores(agents) {
 __name(registerAgentsEvalScores, "registerAgentsEvalScores");
 
 // src/api/build-schemas.ts
-import { z as z77 } from "zod";
-var publicBuildSchema2 = z77.object({
-  id: z77.string(),
-  agent_id: z77.string(),
-  name: z77.string(),
-  status: z77.string().nullish(),
+import { z as z78 } from "zod";
+var publicBuildSchema2 = z78.object({
+  id: z78.string(),
+  agent_id: z78.string(),
+  name: z78.string(),
+  status: z78.string().nullish(),
   config: jsonValueSchema.nullish(),
-  revision_number: z77.number().nullish(),
-  created_at: z77.string().nullish(),
-  updated_at: z77.string().nullish()
+  revision_number: z78.number().nullish(),
+  created_at: z78.string().nullish(),
+  updated_at: z78.string().nullish()
 });
-var listBuildsResponseSchema2 = z77.object({
-  builds: z77.array(publicBuildSchema2),
-  total: z77.number().nullish(),
-  limit: z77.number().nullish(),
-  offset: z77.number().nullish()
+var listBuildsResponseSchema2 = z78.object({
+  builds: z78.array(publicBuildSchema2),
+  total: z78.number().nullish(),
+  limit: z78.number().nullish(),
+  offset: z78.number().nullish()
 });
-var getBuildResponseSchema = z77.object({
+var getBuildResponseSchema = z78.object({
   build: publicBuildSchema2
 });
-var createBuildResponseSchema = z77.object({
+var createBuildResponseSchema = z78.object({
   build: publicBuildSchema2,
-  agent: z77.object({ id: z77.string() })
+  agent: z78.object({ id: z78.string() })
 });
 
 // src/commands/agents/get.ts
@@ -12426,30 +12495,30 @@ function registerAgentsModels(agents) {
 __name(registerAgentsModels, "registerAgentsModels");
 
 // src/api/schedule-schemas.ts
-import { z as z78 } from "zod";
-var publicScheduleSchema = z78.object({
-  id: z78.string(),
-  build_id: z78.string(),
-  agent_id: z78.string(),
-  user_id: z78.string(),
-  enabled: z78.boolean(),
-  frequency: z78.string(),
-  time: z78.string().nullish(),
-  timezone: z78.string(),
-  day: z78.string().nullish(),
-  day_of_month: z78.number().nullish(),
-  cron: z78.string().nullish(),
-  source: z78.string().nullish(),
-  task: z78.string().nullish(),
-  recurring: z78.boolean().nullish(),
-  created_at: z78.string(),
-  updated_at: z78.string()
-});
-var listSchedulesResponseSchema = z78.object({
-  schedules: z78.array(publicScheduleSchema)
-});
-var deleteScheduleResponseSchema = z78.object({
-  success: z78.literal(true)
+import { z as z79 } from "zod";
+var publicScheduleSchema = z79.object({
+  id: z79.string(),
+  build_id: z79.string(),
+  agent_id: z79.string(),
+  user_id: z79.string(),
+  enabled: z79.boolean(),
+  frequency: z79.string(),
+  time: z79.string().nullish(),
+  timezone: z79.string(),
+  day: z79.string().nullish(),
+  day_of_month: z79.number().nullish(),
+  cron: z79.string().nullish(),
+  source: z79.string().nullish(),
+  task: z79.string().nullish(),
+  recurring: z79.boolean().nullish(),
+  created_at: z79.string(),
+  updated_at: z79.string()
+});
+var listSchedulesResponseSchema = z79.object({
+  schedules: z79.array(publicScheduleSchema)
+});
+var deleteScheduleResponseSchema = z79.object({
+  success: z79.literal(true)
 });
 
 // src/commands/agents/schedules/render-schedule.ts
@@ -12897,33 +12966,33 @@ function registerAgentsSetModel(agents) {
 __name(registerAgentsSetModel, "registerAgentsSetModel");
 
 // src/api/trigger-schemas.ts
-import { z as z79 } from "zod";
-var triggerSchema = z79.object({
-  id: z79.string(),
-  agent_id: z79.string(),
-  user_id: z79.string(),
-  integration_slug: z79.string(),
-  trigger_type: z79.string(),
-  filter_config: z79.record(z79.string(), z79.unknown()),
-  integration_instance_id: z79.string(),
-  enabled: z79.boolean(),
-  created_at: z79.string(),
-  updated_at: z79.string()
+import { z as z80 } from "zod";
+var triggerSchema = z80.object({
+  id: z80.string(),
+  agent_id: z80.string(),
+  user_id: z80.string(),
+  integration_slug: z80.string(),
+  trigger_type: z80.string(),
+  filter_config: z80.record(z80.string(), z80.unknown()),
+  integration_instance_id: z80.string(),
+  enabled: z80.boolean(),
+  created_at: z80.string(),
+  updated_at: z80.string()
 });
-var listTriggersResponseSchema = z79.object({
-  triggers: z79.array(triggerSchema)
+var listTriggersResponseSchema = z80.object({
+  triggers: z80.array(triggerSchema)
 });
-var triggerTypeSchema = z79.object({
-  integration_slug: z79.string(),
-  integration_name: z79.string(),
-  icon_url: z79.string(),
-  trigger_type: z79.string(),
-  label: z79.string(),
-  description: z79.string(),
-  filter_schema: z79.record(z79.string(), z79.unknown())
+var triggerTypeSchema = z80.object({
+  integration_slug: z80.string(),
+  integration_name: z80.string(),
+  icon_url: z80.string(),
+  trigger_type: z80.string(),
+  label: z80.string(),
+  description: z80.string(),
+  filter_schema: z80.record(z80.string(), z80.unknown())
 });
-var listTriggerTypesResponseSchema = z79.object({
-  trigger_types: z79.array(triggerTypeSchema)
+var listTriggerTypesResponseSchema = z80.object({
+  trigger_types: z80.array(triggerTypeSchema)
 });
 
 // src/commands/agents/triggers/list.ts
@@ -13547,55 +13616,55 @@ function fieldsToSearchParams(fields) {
 __name(fieldsToSearchParams, "fieldsToSearchParams");
 
 // src/api/integration-schemas.ts
-import { z as z80 } from "zod";
-var integrationSchema = z80.object({
-  id: z80.string(),
-  name: z80.string(),
-  type: z80.string(),
-  provider: z80.string(),
-  user_id: z80.string().nullable(),
-  team_id: z80.string(),
-  server_url: z80.string().optional(),
-  transport_type: z80.string().optional(),
-  auth_method: z80.string().nullish(),
-  composio_mcp_id: z80.string().nullish(),
-  custom_integration_id: z80.string().nullish(),
-  icon_url: z80.string().nullish(),
-  oauth_provider: z80.string().nullish(),
-  oauth_provider_key: z80.string().nullish(),
-  oauth_scopes: z80.array(z80.string()).nullish(),
-  integration_id: z80.string().nullish(),
-  created_at: z80.string(),
-  updated_at: z80.string()
-});
-var integrationsListResponseSchema2 = z80.object({
-  integrations: z80.array(integrationSchema)
+import { z as z81 } from "zod";
+var integrationSchema = z81.object({
+  id: z81.string(),
+  name: z81.string(),
+  type: z81.string(),
+  provider: z81.string(),
+  user_id: z81.string().nullable(),
+  team_id: z81.string(),
+  server_url: z81.string().optional(),
+  transport_type: z81.string().optional(),
+  auth_method: z81.string().nullish(),
+  composio_mcp_id: z81.string().nullish(),
+  custom_integration_id: z81.string().nullish(),
+  icon_url: z81.string().nullish(),
+  oauth_provider: z81.string().nullish(),
+  oauth_provider_key: z81.string().nullish(),
+  oauth_scopes: z81.array(z81.string()).nullish(),
+  integration_id: z81.string().nullish(),
+  created_at: z81.string(),
+  updated_at: z81.string()
+});
+var integrationsListResponseSchema2 = z81.object({
+  integrations: z81.array(integrationSchema)
 });
 var connectionResponseSchema = integrationSchema;
-var buildIntegrationConfigSchema2 = z80.object({
-  id: z80.string(),
-  integration_id: z80.string().nullable(),
-  custom_integration_id: z80.string().nullable(),
-  integration_type: z80.string(),
-  integration_name: z80.string(),
-  created_at: z80.string()
+var buildIntegrationConfigSchema2 = z81.object({
+  id: z81.string(),
+  integration_id: z81.string().nullable(),
+  custom_integration_id: z81.string().nullable(),
+  integration_type: z81.string(),
+  integration_name: z81.string(),
+  created_at: z81.string()
 });
-var listBuildIntegrationsResponseSchema2 = z80.object({
-  integrations: z80.array(buildIntegrationConfigSchema2)
+var listBuildIntegrationsResponseSchema2 = z81.object({
+  integrations: z81.array(buildIntegrationConfigSchema2)
 });
-var attachBuildIntegrationsResponseSchema = z80.object({
-  success: z80.boolean(),
-  count: z80.number()
+var attachBuildIntegrationsResponseSchema = z81.object({
+  success: z81.boolean(),
+  count: z81.number()
 });
-var buildIntegrationConnectionSchema = z80.object({
-  connection_id: z80.string(),
-  created_at: z80.string()
+var buildIntegrationConnectionSchema = z81.object({
+  connection_id: z81.string(),
+  created_at: z81.string()
 });
-var listBuildIntegrationConnectionsResponseSchema = z80.object({
-  connections: z80.array(buildIntegrationConnectionSchema)
+var listBuildIntegrationConnectionsResponseSchema = z81.object({
+  connections: z81.array(buildIntegrationConnectionSchema)
 });
-var successResponseSchema = z80.object({
-  success: z80.boolean()
+var successResponseSchema = z81.object({
+  success: z81.boolean()
 });
 
 // src/commands/build-integrations/attach.ts
@@ -13638,15 +13707,15 @@ function registerBuildIntegrationsAttach(buildIntegrations) {
 __name(registerBuildIntegrationsAttach, "registerBuildIntegrationsAttach");
 
 // src/commands/build-integrations/case-queue-setup.ts
-import { z as z81 } from "zod";
-var slotSchema = z81.object({
-  config_id: z81.string(),
-  integration_type: z81.string(),
-  linked_queue_count: z81.number()
+import { z as z82 } from "zod";
+var slotSchema = z82.object({
+  config_id: z82.string(),
+  integration_type: z82.string(),
+  linked_queue_count: z82.number()
 });
-var responseSchema2 = z81.object({
-  configs: z81.array(slotSchema),
-  has_available_queues: z81.boolean()
+var responseSchema2 = z82.object({
+  configs: z82.array(slotSchema),
+  has_available_queues: z82.boolean()
 });
 var TABLE_COLUMNS10 = [
   { header: "SLOT ID", cell: /* @__PURE__ */ __name((row) => row.config_id, "cell") },
@@ -14141,9 +14210,9 @@ function registerBuildsList(builds) {
 __name(registerBuildsList, "registerBuildsList");
 
 // src/commands/builds/promote.ts
-import { z as z82 } from "zod";
-var promoteResponseSchema = z82.object({
-  success: z82.boolean()
+import { z as z83 } from "zod";
+var promoteResponseSchema = z83.object({
+  success: z83.boolean()
 });
 function registerBuildsPromote(builds) {
   builds.command("promote <id>").description(
@@ -15154,7 +15223,7 @@ function parseSortOrder(raw) {
 __name(parseSortOrder, "parseSortOrder");
 
 // src/commands/cases/runs.ts
-import { z as z83 } from "zod";
+import { z as z84 } from "zod";
 var MIN_LIMIT4 = 1;
 var MAX_LIMIT4 = 10;
 var DEFAULT_LIMIT4 = 3;
@@ -15172,17 +15241,17 @@ var RUNS_TABLE_COLUMNS = [
     cell: /* @__PURE__ */ __name((row) => row.has_pending_human_request ? row.pending_human_request_title ?? "(unknown)" : "", "cell")
   }
 ];
-var recentMessageSchema = z83.object({
-  id: z83.string(),
-  type: z83.string(),
-  role: z83.string(),
-  timestamp: z83.string(),
-  text_content: z83.string().nullish(),
-  tool_call: z83.object({ id: z83.string(), name: z83.string() }).passthrough().nullish(),
-  tool_result: z83.object({ tool_call_id: z83.string() }).passthrough().nullish()
-});
-var recentMessagesResponseSchema = z83.object({
-  messages: z83.array(recentMessageSchema)
+var recentMessageSchema = z84.object({
+  id: z84.string(),
+  type: z84.string(),
+  role: z84.string(),
+  timestamp: z84.string(),
+  text_content: z84.string().nullish(),
+  tool_call: z84.object({ id: z84.string(), name: z84.string() }).passthrough().nullish(),
+  tool_result: z84.object({ tool_call_id: z84.string() }).passthrough().nullish()
+});
+var recentMessagesResponseSchema = z84.object({
+  messages: z84.array(recentMessageSchema)
 });
 var TEXT_PREVIEW_WIDTH = 60;
 var MESSAGES_TABLE_COLUMNS = [
@@ -15311,55 +15380,55 @@ function registerCases(program) {
 __name(registerCases, "registerCases");
 
 // src/api/clarity-schemas.ts
-import { z as z84 } from "zod";
-var clarityListProcessSchema = z84.object({
-  id: z84.guid(),
-  name: z84.string(),
+import { z as z85 } from "zod";
+var clarityListProcessSchema = z85.object({
+  id: z85.guid(),
+  name: z85.string(),
   status: clarityProcessStatusSchema,
   visibility: clarityProcessVisibilitySchema,
-  version: z84.number().int(),
-  capture_count: z84.number().int(),
-  capture_counts: z84.object({
-    video: z84.number().int(),
-    interview: z84.number().int(),
-    document: z84.number().int()
+  version: z85.number().int(),
+  capture_count: z85.number().int(),
+  capture_counts: z85.object({
+    video: z85.number().int(),
+    interview: z85.number().int(),
+    document: z85.number().int()
   }).optional(),
-  pending_invitation_count: z84.number().int(),
-  contributors: z84.array(
-    z84.object({
-      user_id: z84.string(),
-      user_name: z84.string()
+  pending_invitation_count: z85.number().int(),
+  contributors: z85.array(
+    z85.object({
+      user_id: z85.string(),
+      user_name: z85.string()
     })
   ),
-  created_at: z84.string(),
-  created_by_name: z84.string().nullable()
-});
-var listClarityProcessesResponseSchema = z84.object({
-  processes: z84.array(clarityListProcessSchema),
-  total: z84.number().int(),
-  limit: z84.number().int(),
-  offset: z84.number().int()
-});
-var createClarityInviteLinkResponseSchema = z84.object({
-  invite_link: z84.object({
-    id: z84.guid(),
-    url: z84.url(),
-    created_at: z84.string(),
-    created_by: z84.object({
-      id: z84.guid(),
-      email: z84.email().nullable()
+  created_at: z85.string(),
+  created_by_name: z85.string().nullable()
+});
+var listClarityProcessesResponseSchema = z85.object({
+  processes: z85.array(clarityListProcessSchema),
+  total: z85.number().int(),
+  limit: z85.number().int(),
+  offset: z85.number().int()
+});
+var createClarityInviteLinkResponseSchema = z85.object({
+  invite_link: z85.object({
+    id: z85.guid(),
+    url: z85.url(),
+    created_at: z85.string(),
+    created_by: z85.object({
+      id: z85.guid(),
+      email: z85.email().nullable()
     })
   })
 });
-var createArtifactImportUploadUrlResponseSchema = z84.object({
-  signed_url: z84.url(),
-  capture_id: z84.guid(),
-  expires_at: z84.iso.datetime()
+var createArtifactImportUploadUrlResponseSchema = z85.object({
+  signed_url: z85.url(),
+  capture_id: z85.guid(),
+  expires_at: z85.iso.datetime()
 });
-var completeArtifactImportResponseSchema = z84.object({
+var completeArtifactImportResponseSchema = z85.object({
   capture: clarityCaptureSchema.extend({
-    createdAt: z84.iso.datetime(),
-    updatedAt: z84.iso.datetime()
+    createdAt: z85.iso.datetime(),
+    updatedAt: z85.iso.datetime()
   })
 });
 var legacyClarityProcessResponseSchema = legacyClarityProcessDetailSchema;
@@ -15798,8 +15867,8 @@ function renderCompletedImport(response) {
 __name(renderCompletedImport, "renderCompletedImport");
 
 // src/commands/clarity/assign-extra-capture-request.ts
-import { z as z85 } from "zod";
-var responseSchema3 = z85.object({
+import { z as z86 } from "zod";
+var responseSchema3 = z86.object({
   request: clarityProposalExtraCaptureRequestSchema
 });
 function renderRequest(request) {
@@ -15846,11 +15915,11 @@ function registerClarityAssignExtraCaptureRequest(clarity) {
 __name(registerClarityAssignExtraCaptureRequest, "registerClarityAssignExtraCaptureRequest");
 
 // src/commands/clarity/build-automation.ts
-import { z as z86 } from "zod";
-var responseSchema4 = z86.object({
-  automation_run: z86.object({
-    id: z86.string(),
-    status: z86.string()
+import { z as z87 } from "zod";
+var responseSchema4 = z87.object({
+  automation_run: z87.object({
+    id: z87.string(),
+    status: z87.string()
   })
 });
 function registerClarityBuildAutomation(clarity) {
@@ -15921,7 +15990,7 @@ function registerClarityCreateInviteLink(clarity) {
 __name(registerClarityCreateInviteLink, "registerClarityCreateInviteLink");
 
 // src/commands/clarity/doctor.ts
-import { z as z87 } from "zod";
+import { z as z88 } from "zod";
 
 // src/commands/clarity/render.ts
 var DEFAULT_HUMAN_SUMMARY_LIMIT = 1200;
@@ -17519,6 +17588,19 @@ var CLARITY_WRITE_TOOLS = [
       }
     ],
     description: "Confirm a landscape node placement, content, or existence axis."
+  },
+  {
+    name: "generateClarityProcessLandscape",
+    scope: "v1+v2",
+    read_only: false,
+    commands: ["duvo clarity landscape generate"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/organizations/:orgId/clarity/hierarchy/landscape/generate"
+      }
+    ],
+    description: "Start a process-landscape generation run from the organization's eligible Clarity captures."
   }
 ];
 var CLARITY_TOOLS = [
@@ -17691,8 +17773,8 @@ async function buildTeamContextCheck(config) {
   }
 }
 __name(buildTeamContextCheck, "buildTeamContextCheck");
-var listMyTeamsResponseSchema2 = z87.object({
-  teams: z87.array(z87.object({ id: z87.string() }))
+var listMyTeamsResponseSchema2 = z88.object({
+  teams: z88.array(z88.object({ id: z88.string() }))
 });
 async function buildClarityApiReachableCheck(command, config) {
   let teamId;
@@ -18310,19 +18392,19 @@ function buildGenerateTransformationProposalBody(options) {
 __name(buildGenerateTransformationProposalBody, "buildGenerateTransformationProposalBody");
 
 // src/commands/clarity/get-current-process.ts
-import { z as z88 } from "zod";
-var snapshotSchema = z88.object({
-  snapshot: z88.object({
-    id: z88.string(),
-    kind: z88.string(),
-    source_snapshot_id: z88.string().nullable(),
-    parent_id: z88.string().nullable(),
-    status: z88.string(),
-    creator_type: z88.string(),
-    user_id: z88.string().nullable(),
-    sandbox_id: z88.string().nullable(),
-    created_at: z88.string(),
-    updated_at: z88.string()
+import { z as z89 } from "zod";
+var snapshotSchema = z89.object({
+  snapshot: z89.object({
+    id: z89.string(),
+    kind: z89.string(),
+    source_snapshot_id: z89.string().nullable(),
+    parent_id: z89.string().nullable(),
+    status: z89.string(),
+    creator_type: z89.string(),
+    user_id: z89.string().nullable(),
+    sandbox_id: z89.string().nullable(),
+    created_at: z89.string(),
+    updated_at: z89.string()
   })
 });
 function registerClarityGetCurrentProcess(clarity) {
@@ -18366,19 +18448,19 @@ function registerClarityGetCurrentProcess(clarity) {
 __name(registerClarityGetCurrentProcess, "registerClarityGetCurrentProcess");
 
 // src/commands/clarity/get-transformation-proposal.ts
-import { z as z89 } from "zod";
-var snapshotSchema2 = z89.object({
-  snapshot: z89.object({
-    id: z89.string(),
-    kind: z89.string(),
-    source_snapshot_id: z89.string().nullable(),
-    parent_id: z89.string().nullable(),
-    status: z89.string(),
-    creator_type: z89.string(),
-    user_id: z89.string().nullable(),
-    sandbox_id: z89.string().nullable(),
-    created_at: z89.string(),
-    updated_at: z89.string()
+import { z as z90 } from "zod";
+var snapshotSchema2 = z90.object({
+  snapshot: z90.object({
+    id: z90.string(),
+    kind: z90.string(),
+    source_snapshot_id: z90.string().nullable(),
+    parent_id: z90.string().nullable(),
+    status: z90.string(),
+    creator_type: z90.string(),
+    user_id: z90.string().nullable(),
+    sandbox_id: z90.string().nullable(),
+    created_at: z90.string(),
+    updated_at: z90.string()
   })
 });
 function registerClarityGetTransformationProposal(clarity) {
@@ -18474,74 +18556,79 @@ Transformation proposal versions (${tpVersions.length}):`
 __name(registerClarityGet, "registerClarityGet");
 
 // src/commands/clarity/landscape.ts
-import { z as z90 } from "zod";
+import { z as z91 } 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";
 var NODES_RESOURCE_PATH = "/clarity/hierarchy/nodes";
 var PROCESS_NODE_TYPE = "process";
 var AREA_NODE_TYPE = "area";
-var placementStateSchema = z90.enum(["unfiled", "suggested", "confirmed"]);
-var axisSchema = z90.enum(["placement", "content", "existence"]);
-var processSummarySchema = z90.object({
-  id: z90.string(),
-  name: z90.string()
+var axisSchema = z91.enum(["content", "existence"]);
+var processSummarySchema = z91.object({
+  id: z91.string(),
+  name: z91.string()
 }).passthrough();
-var landscapeNodeSchema = z90.object({
-  id: z90.string(),
-  parentId: z90.string().nullable(),
-  processId: z90.string().nullable(),
-  name: z90.string(),
-  ownerLabel: z90.string().nullable(),
-  placementState: placementStateSchema,
+var landscapeNodeSchema = z91.object({
+  id: z91.string(),
+  parentId: z91.string().nullable(),
+  processId: z91.string().nullable(),
+  name: z91.string(),
+  ownerLabel: z91.string().nullable(),
   process: processSummarySchema.nullable()
 }).passthrough();
-var treeNodeSchema = z90.object({
-  id: z90.string(),
-  parentId: z90.string().nullable(),
-  processId: z90.string().nullable(),
-  name: z90.string(),
-  ownerLabel: z90.string().nullable(),
-  placementState: placementStateSchema,
-  depth: z90.number()
+var unlinkedProcessSchema = processSummarySchema.extend({
+  teamId: z91.string(),
+  teamName: z91.string().nullable()
+}).passthrough();
+var treeNodeSchema = z91.object({
+  id: z91.string(),
+  parentId: z91.string().nullable(),
+  processId: z91.string().nullable(),
+  name: z91.string(),
+  ownerLabel: z91.string().nullable(),
+  depth: z91.number()
 }).passthrough();
-var landscapeResponseSchema = z90.object({
-  nodes: z90.array(landscapeNodeSchema),
-  links: z90.array(
-    z90.object({
-      id: z90.string(),
-      sourceNodeId: z90.string(),
-      targetNodeId: z90.string(),
-      type: z90.string(),
-      state: z90.string(),
-      confidence: z90.number().nullable()
+var landscapeResponseSchema = z91.object({
+  nodes: z91.array(landscapeNodeSchema),
+  links: z91.array(
+    z91.object({
+      id: z91.string(),
+      sourceNodeId: z91.string(),
+      targetNodeId: z91.string(),
+      type: z91.string(),
+      state: z91.string(),
+      confidence: z91.number().nullable()
     }).passthrough()
   ),
-  stats: z90.object({
-    totalNodes: z90.number(),
-    processNodes: z90.number(),
-    suggestedPlacements: z90.number(),
-    confirmedPlacements: z90.number(),
-    unfiledNodes: z90.number(),
-    latestUpdatedAt: z90.string().nullable()
+  unlinkedProcesses: z91.array(unlinkedProcessSchema),
+  stats: z91.object({
+    totalNodes: z91.number(),
+    processNodes: z91.number(),
+    proposedNodes: z91.number(),
+    unsortedProcesses: z91.number(),
+    latestUpdatedAt: z91.string().nullable()
   }).passthrough(),
-  truncated: z90.boolean()
+  truncated: z91.boolean()
 }).passthrough();
-var treeResponseSchema = z90.object({
-  nodes: z90.array(treeNodeSchema),
-  truncated: z90.boolean()
+var treeResponseSchema = z91.object({
+  nodes: z91.array(treeNodeSchema),
+  truncated: z91.boolean()
 }).passthrough();
-var nodeResponseSchema = z90.object({
-  id: z90.string(),
-  parentId: z90.string().nullable(),
-  processId: z90.string().nullable(),
-  name: z90.string(),
-  ownerLabel: z90.string().nullable(),
-  placementState: placementStateSchema
+var nodeResponseSchema = z91.object({
+  id: z91.string(),
+  parentId: z91.string().nullable(),
+  processId: z91.string().nullable(),
+  name: z91.string(),
+  ownerLabel: z91.string().nullable()
 }).passthrough();
-var deleteNodeResponseSchema = z90.object({
-  deletedCount: z90.number()
+var deleteNodeResponseSchema = z91.object({
+  deletedCount: z91.number()
 });
+var generateLandscapeResponseSchema = z91.object({
+  started: z91.literal(true),
+  generationId: z91.string(),
+  eligibleCaptureCount: z91.number()
+}).passthrough();
 var LANDSCAPE_COLUMNS = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell"), maxWidth: 36 },
   {
@@ -18555,10 +18642,6 @@ var LANDSCAPE_COLUMNS = [
     header: "PROCESS",
     cell: /* @__PURE__ */ __name((row) => row.process?.name ?? "-", "cell"),
     maxWidth: 28
-  },
-  {
-    header: "PLACEMENT",
-    cell: /* @__PURE__ */ __name((row) => row.placementState, "cell")
   }
 ];
 var TREE_COLUMNS = [
@@ -18570,11 +18653,7 @@ var TREE_COLUMNS = [
   },
   { header: "DEPTH", cell: /* @__PURE__ */ __name((row) => String(row.depth), "cell") },
   { header: "TYPE", cell: getTreeNodeType },
-  { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell"), maxWidth: 36 },
-  {
-    header: "PLACEMENT",
-    cell: /* @__PURE__ */ __name((row) => row.placementState, "cell")
-  }
+  { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell"), maxWidth: 36 }
 ];
 function registerClarityLandscape(clarity) {
   const landscape = clarity.command("landscape").description("Inspect and curate the Clarity process landscape").option("--org <org-id>", ORG_FLAG_DESCRIPTION);
@@ -18660,7 +18739,7 @@ function registerClarityLandscape(clarity) {
     const node = nodeResponseSchema.parse(raw);
     renderNodeMutationResult("Moved node", node, options);
   }, "moveNodeAction"));
-  landscape.command("confirm-node <node-id>").description("Confirm a landscape node axis").requiredOption("--axis <axis>", "placement, content, or existence").option("--org <org-id>", ORG_FLAG_DESCRIPTION).option("--json", "output JSON").action(/* @__PURE__ */ __name(async function confirmNodeAction(nodeId, options) {
+  landscape.command("confirm-node <node-id>").description("Confirm a landscape node axis").requiredOption("--axis <axis>", "content or existence").option("--org <org-id>", ORG_FLAG_DESCRIPTION).option("--json", "output JSON").action(/* @__PURE__ */ __name(async function confirmNodeAction(nodeId, options) {
     const config = await requireAuthenticatedConfig(this);
     const raw = await httpRequest({
       method: "POST",
@@ -18687,6 +18766,25 @@ function registerClarityLandscape(clarity) {
     }
     console.log(`Deleted node: ${nodeId} (${response.deletedCount} nodes)`);
   }, "deleteNodeAction"));
+  landscape.command("generate").description(
+    "Generate the Clarity process landscape from eligible captures"
+  ).option("--org <org-id>", ORG_FLAG_DESCRIPTION).option("--json", "output JSON").action(/* @__PURE__ */ __name(async function generateAction(options) {
+    const config = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: resolveOrgPath(this, `${LANDSCAPE_RESOURCE_PATH}/generate`),
+      apiKey: config.apiKey,
+      apiBaseUrl: config.apiBaseUrl
+    });
+    const response = generateLandscapeResponseSchema.parse(raw);
+    if (options.json) {
+      printJson(response);
+      return;
+    }
+    console.log(
+      `Started process landscape generation: ${response.generationId} (${response.eligibleCaptureCount} captures)`
+    );
+  }, "generateAction"));
 }
 __name(registerClarityLandscape, "registerClarityLandscape");
 function nodePath(orgId, nodeId) {
@@ -18835,7 +18933,7 @@ __name(buildRootSearchParams, "buildRootSearchParams");
 function parseAxis(value) {
   const parsed = axisSchema.safeParse(value);
   if (!parsed.success) {
-    throw new CliError("Axis must be placement, content, or existence.");
+    throw new CliError("Axis must be content or existence.");
   }
   return parsed.data;
 }
@@ -18992,40 +19090,40 @@ function registerClarityPostprocess(clarity) {
 __name(registerClarityPostprocess, "registerClarityPostprocess");
 
 // src/commands/clarity/process-links.ts
-import { z as z91 } from "zod";
+import { z as z92 } from "zod";
 var MIN_LIMIT6 = 1;
 var MAX_LIMIT6 = 500;
 var DEFAULT_LIMIT6 = 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 = z91.enum([
+var processLinkTypeSchema = z92.enum([
   "hands_off_to",
   "shares_step_with",
   "variant_of"
 ]);
-var processLinkStateSchema = z91.enum(["suggested", "confirmed"]);
-var processLinkSchema = z91.object({
-  id: z91.string(),
-  source_node_id: z91.string(),
-  target_node_id: z91.string(),
+var processLinkStateSchema = z92.enum(["suggested", "confirmed"]);
+var processLinkSchema = z92.object({
+  id: z92.string(),
+  source_node_id: z92.string(),
+  target_node_id: z92.string(),
   type: processLinkTypeSchema,
   state: processLinkStateSchema,
-  confidence: z91.number().nullable(),
-  created_at: z91.string(),
-  updated_at: z91.string()
+  confidence: z92.number().nullable(),
+  created_at: z92.string(),
+  updated_at: z92.string()
 });
-var listProcessLinksResponseSchema = z91.object({
-  process_links: z91.array(processLinkSchema),
-  total: z91.number(),
-  limit: z91.number(),
-  offset: z91.number()
+var listProcessLinksResponseSchema = z92.object({
+  process_links: z92.array(processLinkSchema),
+  total: z92.number(),
+  limit: z92.number(),
+  offset: z92.number()
 });
-var processLinkMutationResponseSchema = z91.object({
+var processLinkMutationResponseSchema = z92.object({
   process_link: processLinkSchema,
-  created: z91.boolean().optional()
+  created: z92.boolean().optional()
 });
-var deleteProcessLinkResponseSchema = z91.object({
-  deleted: z91.boolean()
+var deleteProcessLinkResponseSchema = z92.object({
+  deleted: z92.boolean()
 });
 var PROCESS_LINK_COLUMNS = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell"), maxWidth: 36 },
@@ -19237,14 +19335,14 @@ function renderProcessLinks(response) {
 __name(renderProcessLinks, "renderProcessLinks");
 
 // src/commands/clarity/promote-current-process.ts
-import { z as z92 } from "zod";
-var snapshotSchema3 = z92.object({
-  snapshot: z92.object({
-    id: z92.string(),
-    status: z92.string(),
-    creator_type: z92.string(),
-    created_at: z92.string(),
-    updated_at: z92.string()
+import { z as z93 } from "zod";
+var snapshotSchema3 = z93.object({
+  snapshot: z93.object({
+    id: z93.string(),
+    status: z93.string(),
+    creator_type: z93.string(),
+    created_at: z93.string(),
+    updated_at: z93.string()
   })
 });
 function registerClarityPromoteCurrentProcess(clarity) {
@@ -19281,14 +19379,14 @@ function registerClarityPromoteCurrentProcess(clarity) {
 __name(registerClarityPromoteCurrentProcess, "registerClarityPromoteCurrentProcess");
 
 // src/commands/clarity/promote-transformation-proposal.ts
-import { z as z93 } from "zod";
-var snapshotSchema4 = z93.object({
-  snapshot: z93.object({
-    id: z93.string(),
-    status: z93.string(),
-    creator_type: z93.string(),
-    created_at: z93.string(),
-    updated_at: z93.string()
+import { z as z94 } from "zod";
+var snapshotSchema4 = z94.object({
+  snapshot: z94.object({
+    id: z94.string(),
+    status: z94.string(),
+    creator_type: z94.string(),
+    created_at: z94.string(),
+    updated_at: z94.string()
   })
 });
 function registerClarityPromoteTransformationProposal(clarity) {
@@ -19364,8 +19462,8 @@ __name(registerClarityRevertTransformationProposal, "registerClarityRevertTransf
 
 // src/commands/clarity/save-snapshot.ts
 import { readFile as readFile6 } from "node:fs/promises";
-import { z as z94 } from "zod";
-var snapshotFileSchema = z94.union([
+import { z as z95 } from "zod";
+var snapshotFileSchema = z95.union([
   saveClarityProcessSnapshotBodySchema.shape.steps,
   saveClarityProcessSnapshotBodySchema.pick({
     steps: true,
@@ -20363,16 +20461,16 @@ function registerConnectionsList(connections) {
 __name(registerConnectionsList, "registerConnectionsList");
 
 // src/commands/connections/probe.ts
-import { z as z95 } from "zod";
-var toolSchema = z95.object({
-  name: z95.string(),
-  description: z95.string().optional(),
-  input_schema: z95.record(z95.string(), z95.unknown()).optional()
+import { z as z96 } from "zod";
+var toolSchema = z96.object({
+  name: z96.string(),
+  description: z96.string().optional(),
+  input_schema: z96.record(z96.string(), z96.unknown()).optional()
 });
-var probeResponseSchema = z95.object({
-  success: z95.boolean(),
-  tools: z95.array(toolSchema).optional(),
-  error: z95.string().optional()
+var probeResponseSchema = z96.object({
+  success: z96.boolean(),
+  tools: z96.array(toolSchema).optional(),
+  error: z96.string().optional()
 });
 var DESCRIPTION_MAX_WIDTH = 80;
 var TABLE_COLUMNS21 = [
@@ -20591,48 +20689,48 @@ function registerConnections(program) {
 __name(registerConnections, "registerConnections");
 
 // src/api/credential-schemas.ts
-import { z as z96 } from "zod";
-var dateLike = z96.string();
-var secretSchema = z96.object({
-  id: z96.string(),
-  team_id: z96.string(),
-  user_id: z96.string().nullable(),
-  name: z96.string(),
-  service_slug: z96.string().nullable(),
-  env_var_keys: z96.array(z96.string()),
-  created_by: z96.string(),
+import { z as z97 } from "zod";
+var dateLike = z97.string();
+var secretSchema = z97.object({
+  id: z97.string(),
+  team_id: z97.string(),
+  user_id: z97.string().nullable(),
+  name: z97.string(),
+  service_slug: z97.string().nullable(),
+  env_var_keys: z97.array(z97.string()),
+  created_by: z97.string(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var secretsListResponseSchema = z96.array(secretSchema);
+var secretsListResponseSchema = z97.array(secretSchema);
 var secretResponseSchema = secretSchema;
-var browserLoginSchema = z96.object({
-  id: z96.string(),
-  user_id: z96.string().nullable(),
-  team_id: z96.string(),
-  domain: z96.string(),
-  username: z96.string().nullable(),
+var browserLoginSchema = z97.object({
+  id: z97.string(),
+  user_id: z97.string().nullable(),
+  team_id: z97.string(),
+  domain: z97.string(),
+  username: z97.string().nullable(),
   password: encryptedDataSchema.nullable(),
   otp_secret: encryptedDataSchema.nullable(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var browserLoginsListResponseSchema = z96.array(credentialPreviewSchema);
-var revisionLoginSummarySchema = z96.object({
-  id: z96.string(),
-  user_id: z96.string().nullable(),
-  team_id: z96.string().nullable(),
-  domain: z96.string(),
-  username: z96.string().nullable(),
+var browserLoginsListResponseSchema = z97.array(credentialPreviewSchema);
+var revisionLoginSummarySchema = z97.object({
+  id: z97.string(),
+  user_id: z97.string().nullable(),
+  team_id: z97.string().nullable(),
+  domain: z97.string(),
+  username: z97.string().nullable(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var revisionLoginsListResponseSchema = z96.array(
+var revisionLoginsListResponseSchema = z97.array(
   revisionLoginSummarySchema
 );
-var revisionSecretsListResponseSchema = z96.array(secretSchema);
-var successResponseSchema2 = z96.object({
-  success: z96.boolean()
+var revisionSecretsListResponseSchema = z97.array(secretSchema);
+var successResponseSchema2 = z97.object({
+  success: z97.boolean()
 });
 var attachSuccessResponseSchema = successResponseSchema2;
 var deleteSecretResponseSchema = successResponseSchema2;
@@ -24502,91 +24600,91 @@ function registerRevisionSecrets(program) {
 __name(registerRevisionSecrets, "registerRevisionSecrets");
 
 // src/api/run-schemas.ts
-import { z as z97 } from "zod";
-var publicRunSchema = z97.object({
-  id: z97.string(),
-  agent_id: z97.string(),
-  build_id: z97.string(),
-  status: z97.string(),
-  source: z97.string().nullish(),
-  sandbox_id: z97.string().nullish(),
-  started_at: z97.string().nullish(),
-  completed_at: z97.string().nullish(),
-  created_at: z97.string(),
-  updated_at: z97.string().nullish(),
-  human_in_the_loop_enabled: z97.boolean().nullish()
-});
-var startRunResponseSchema = z97.object({
+import { z as z98 } from "zod";
+var publicRunSchema = z98.object({
+  id: z98.string(),
+  agent_id: z98.string(),
+  build_id: z98.string(),
+  status: z98.string(),
+  source: z98.string().nullish(),
+  sandbox_id: z98.string().nullish(),
+  started_at: z98.string().nullish(),
+  completed_at: z98.string().nullish(),
+  created_at: z98.string(),
+  updated_at: z98.string().nullish(),
+  human_in_the_loop_enabled: z98.boolean().nullish()
+});
+var startRunResponseSchema = z98.object({
   run: publicRunSchema
 });
-var questionOptionSchema = z97.object({
-  label: z97.string(),
-  description: z97.string().nullish()
-});
-var questionSchema = z97.object({
-  question: z97.string(),
-  header: z97.string().nullish(),
-  options: z97.array(questionOptionSchema).nullish(),
-  multi_select: z97.boolean().nullish()
-});
-var pendingHumanRequestSchema = z97.object({
-  id: z97.string(),
-  title: z97.string(),
-  description: z97.string().nullish(),
-  created_at: z97.string(),
-  type: z97.string(),
-  questions: z97.array(questionSchema).nullish()
-});
-var getRunResponseSchema = z97.object({
+var questionOptionSchema = z98.object({
+  label: z98.string(),
+  description: z98.string().nullish()
+});
+var questionSchema = z98.object({
+  question: z98.string(),
+  header: z98.string().nullish(),
+  options: z98.array(questionOptionSchema).nullish(),
+  multi_select: z98.boolean().nullish()
+});
+var pendingHumanRequestSchema = z98.object({
+  id: z98.string(),
+  title: z98.string(),
+  description: z98.string().nullish(),
+  created_at: z98.string(),
+  type: z98.string(),
+  questions: z98.array(questionSchema).nullish()
+});
+var getRunResponseSchema = z98.object({
   run: publicRunSchema.nullable(),
   pending_human_request: pendingHumanRequestSchema.nullish()
 });
-var stopRunResponseSchema = z97.object({
-  success: z97.boolean(),
-  message: z97.string().nullish()
-});
-var runMessageSchema = z97.object({
-  id: z97.string(),
-  type: z97.string(),
-  role: z97.string(),
-  timestamp: z97.string(),
-  text_content: z97.string().nullish(),
-  tool_call: z97.object({
-    id: z97.string(),
-    name: z97.string(),
-    arguments: z97.record(z97.string(), z97.unknown()).nullish()
+var stopRunResponseSchema = z98.object({
+  success: z98.boolean(),
+  message: z98.string().nullish()
+});
+var runMessageSchema = z98.object({
+  id: z98.string(),
+  type: z98.string(),
+  role: z98.string(),
+  timestamp: z98.string(),
+  text_content: z98.string().nullish(),
+  tool_call: z98.object({
+    id: z98.string(),
+    name: z98.string(),
+    arguments: z98.record(z98.string(), z98.unknown()).nullish()
   }).nullish(),
-  tool_result: z97.object({
-    tool_call_id: z97.string(),
-    result: z97.unknown().nullish(),
-    error: z97.string().nullish()
+  tool_result: z98.object({
+    tool_call_id: z98.string(),
+    result: z98.unknown().nullish(),
+    error: z98.string().nullish()
   }).nullish()
 });
-var listRunMessagesResponseSchema = z97.object({
-  messages: z97.array(runMessageSchema),
-  total: z97.number().nullish(),
-  limit: z97.number().nullish(),
-  offset: z97.number().nullish()
+var listRunMessagesResponseSchema = z98.object({
+  messages: z98.array(runMessageSchema),
+  total: z98.number().nullish(),
+  limit: z98.number().nullish(),
+  offset: z98.number().nullish()
 });
-var postedMessageSchema = z97.object({
-  id: z97.string(),
-  type: z97.string(),
-  role: z97.string(),
-  timestamp: z97.string(),
-  text_content: z97.string()
+var postedMessageSchema = z98.object({
+  id: z98.string(),
+  type: z98.string(),
+  role: z98.string(),
+  timestamp: z98.string(),
+  text_content: z98.string()
 });
-var postRunMessageResponseSchema = z97.object({
+var postRunMessageResponseSchema = z98.object({
   message: postedMessageSchema
 });
-var respondHumanRequestResponseSchema = z97.object({
-  human_request: z97.object({
-    id: z97.string(),
-    run_id: z97.string(),
-    title: z97.string(),
-    description: z97.string().nullish(),
-    response: z97.string().nullish(),
-    responded_at: z97.string().nullish(),
-    created_at: z97.string()
+var respondHumanRequestResponseSchema = z98.object({
+  human_request: z98.object({
+    id: z98.string(),
+    run_id: z98.string(),
+    title: z98.string(),
+    description: z98.string().nullish(),
+    response: z98.string().nullish(),
+    responded_at: z98.string().nullish(),
+    created_at: z98.string()
   })
 });
 
@@ -25281,28 +25379,28 @@ function registerRuns(program) {
 __name(registerRuns, "registerRuns");
 
 // src/api/sandbox-schemas.ts
-import { z as z98 } from "zod";
-var createSandboxResponseSchema = z98.object({
-  sandbox_id: z98.string(),
-  expires_at: z98.string()
+import { z as z99 } from "zod";
+var createSandboxResponseSchema = z99.object({
+  sandbox_id: z99.string(),
+  expires_at: z99.string()
 });
-var createSandboxUploadUrlResponseSchema = z98.object({
-  upload_url: z98.string(),
-  path: z98.string(),
-  expires_in_seconds: z98.number()
+var createSandboxUploadUrlResponseSchema = z99.object({
+  upload_url: z99.string(),
+  path: z99.string(),
+  expires_in_seconds: z99.number()
 });
-var sandboxFileSchema = z98.object({
-  name: z98.string(),
-  path: z98.string(),
-  type: z98.enum(["file", "dir"]),
-  size_bytes: z98.number()
+var sandboxFileSchema = z99.object({
+  name: z99.string(),
+  path: z99.string(),
+  type: z99.enum(["file", "dir"]),
+  size_bytes: z99.number()
 });
-var listSandboxFilesResponseSchema = z98.object({
-  files: z98.array(sandboxFileSchema)
+var listSandboxFilesResponseSchema = z99.object({
+  files: z99.array(sandboxFileSchema)
 });
-var uploadSandboxFileResponseSchema = z98.object({
-  path: z98.string(),
-  size_bytes: z98.number()
+var uploadSandboxFileResponseSchema = z99.object({
+  path: z99.string(),
+  size_bytes: z99.number()
 });
 var DEFAULT_SANDBOX_FILES_PATH = "/workspace";
 
@@ -25913,13 +26011,13 @@ __name(registerSkillsAssignments, "registerSkillsAssignments");
 
 // src/commands/skills/create.ts
 import { readFileSync as readFileSync5 } from "node:fs";
-import { z as z99 } from "zod";
-var createSkillResponseSchema = z99.object({
-  skill: z99.object({
-    id: z99.string(),
-    name: z99.string(),
-    description: z99.string(),
-    team_id: z99.string()
+import { z as z100 } from "zod";
+var createSkillResponseSchema = z100.object({
+  skill: z100.object({
+    id: z100.string(),
+    name: z100.string(),
+    description: z100.string(),
+    team_id: z100.string()
   })
 });
 function registerSkillsCreate(skills) {
@@ -26283,13 +26381,13 @@ function readExistingContent(source) {
 __name(readExistingContent, "readExistingContent");
 
 // src/commands/skills/install.ts
-import { z as z100 } from "zod";
-var installSkillResponseSchema = z100.object({
-  skill: z100.object({
-    id: z100.string(),
-    name: z100.string(),
-    description: z100.string(),
-    team_id: z100.string()
+import { z as z101 } from "zod";
+var installSkillResponseSchema = z101.object({
+  skill: z101.object({
+    id: z101.string(),
+    name: z101.string(),
+    description: z101.string(),
+    team_id: z101.string()
   })
 });
 function registerSkillsInstall(skills) {
@@ -26479,13 +26577,13 @@ __name(registerSkillsSystem, "registerSkillsSystem");
 // src/commands/skills/upload.ts
 import { readFile as readFile8, stat as stat2 } from "node:fs/promises";
 import { basename as basename3 } from "node:path";
-import { z as z101 } from "zod";
-var uploadSkillResponseSchema = z101.object({
-  skill: z101.object({
-    id: z101.string(),
-    name: z101.string(),
-    description: z101.string(),
-    team_id: z101.string()
+import { z as z102 } from "zod";
+var uploadSkillResponseSchema = z102.object({
+  skill: z102.object({
+    id: z102.string(),
+    name: z102.string(),
+    description: z102.string(),
+    team_id: z102.string()
   })
 });
 function registerSkillsUpload(skills) {
@@ -26859,11 +26957,11 @@ function registerTeamMembers(team) {
 __name(registerTeamMembers, "registerTeamMembers");
 
 // src/commands/team/use.ts
-import { z as z102 } from "zod";
+import { z as z103 } 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 = z102.string().regex(TEAM_ID_SHAPE);
-var listMyTeamsResponseSchema3 = z102.object({
-  teams: z102.array(z102.object({ id: z102.string() }))
+var teamIdSchema = z103.string().regex(TEAM_ID_SHAPE);
+var listMyTeamsResponseSchema3 = z103.object({
+  teams: z103.array(z103.object({ id: z103.string() }))
 });
 function registerTeamUse(team) {
   team.command("use <team-id>").description(
@@ -26945,14 +27043,14 @@ function registerTeam(program) {
 __name(registerTeam, "registerTeam");
 
 // src/commands/teams/list.ts
-import { z as z103 } from "zod";
-var teamApiSchema2 = z103.object({
-  id: z103.string(),
-  name: z103.string(),
-  organization_id: z103.string().nullable()
+import { z as z104 } from "zod";
+var teamApiSchema2 = z104.object({
+  id: z104.string(),
+  name: z104.string(),
+  organization_id: z104.string().nullable()
 });
-var listMyTeamsResponseSchema4 = z103.object({
-  teams: z103.array(teamApiSchema2)
+var listMyTeamsResponseSchema4 = z104.object({
+  teams: z104.array(teamApiSchema2)
 });
 function registerTeamsList(program) {
   const teams = program.command("teams").description("Inspect the teams your credentials can act on");
@@ -27048,7 +27146,7 @@ __name(resolveActiveTeamId, "resolveActiveTeamId");
 var version = resolveVersion();
 function resolveVersion() {
   if (true) {
-    return "1.10.1";
+    return "1.11.0";
   }
   const packageJsonPath = join3(
     dirname3(fileURLToPath2(import.meta.url)),
@@ -27132,7 +27230,7 @@ function checkForUpdate() {
 __name(checkForUpdate, "checkForUpdate");
 function loadPackageMeta() {
   if (true) {
-    return { name: "@duvoai/cli", version: "1.10.1" };
+    return { name: "@duvoai/cli", version: "1.11.0" };
   }
   const require2 = createRequire(import.meta.url);
   const raw = require2("../package.json");