@rudderhq/cli 0.5.0 → 0.5.1

package/dist/index.js

@@ -17,9 +17,13 @@ var init_browser_shortcuts = __esm({
 });
 
 // ../packages/shared/dist/chat-inline-visuals.js
+var MAX_RUDDER_INLINE_VISUAL_FRAGMENT_BYTES, MAX_RUDDER_INLINE_VISUAL_TOTAL_BYTES, MAX_RUDDER_INLINE_VISUAL_REPLY_BYTES;
 var init_chat_inline_visuals = __esm({
   "../packages/shared/dist/chat-inline-visuals.js"() {
     "use strict";
+    MAX_RUDDER_INLINE_VISUAL_FRAGMENT_BYTES = 64 * 1024;
+    MAX_RUDDER_INLINE_VISUAL_TOTAL_BYTES = 128 * 1024;
+    MAX_RUDDER_INLINE_VISUAL_REPLY_BYTES = 256 * 1024;
   }
 });
 
@@ -39,7 +43,7 @@ var init_chat_work_manifest = __esm({
 });
 
 // ../packages/shared/dist/constants.js
-var ORGANIZATION_STATUSES, ORGANIZATION_INTELLIGENCE_PROFILE_PURPOSES, ORGANIZATION_INTELLIGENCE_PROFILE_STATUSES, DEPLOYMENT_MODES, DEPLOYMENT_EXPOSURES, AUTH_BASE_URL_MODES, AGENT_STATUSES, AGENT_RUNTIME_TYPES, AGENT_ROLES, AGENT_ICON_NAMES, AGENT_DICEBEAR_NOTIONISTS_ICON_PREFIX, AGENT_AVATAR_BACKGROUND_PRESET_IDS, ISSUE_STATUSES, ISSUE_PRIORITIES, AGENT_INTEGRATION_PROVIDERS, AGENT_INTEGRATION_STATUSES, AGENT_INTEGRATION_TRANSPORTS, AGENT_INTEGRATION_PROVIDER_REGIONS, AGENT_INTEGRATION_CHAT_TYPES, AGENT_INTEGRATION_DROP_REASONS, AGENT_INTEGRATION_OUTBOUND_STATUSES, CUSTOM_INTEGRATION_KINDS, CUSTOM_INTEGRATION_SCOPES, CUSTOM_INTEGRATION_STATUSES, CUSTOM_INTEGRATION_TOOL_STATUSES, CUSTOM_INTEGRATION_BINDING_STATUSES, CUSTOM_INTEGRATION_TOOL_CALL_STATUSES, CALENDAR_SOURCE_TYPES, CALENDAR_OWNER_TYPES, CALENDAR_VISIBILITIES, CALENDAR_SOURCE_STATUSES, CALENDAR_EVENT_KINDS, CALENDAR_EVENT_STATUSES, CALENDAR_SOURCE_MODES, CHAT_CONVERSATION_STATUSES, CHAT_ISSUE_CREATION_MODES, CHAT_MESSAGE_ROLES, CHAT_MESSAGE_KINDS, CHAT_MESSAGE_STATUSES, CHAT_CONTEXT_ENTITY_TYPES, GOAL_LEVELS, GOAL_STATUSES, PROJECT_STATUSES, ORGANIZATION_RESOURCE_KINDS, ORGANIZATION_RESOURCE_SOURCE_TYPES, PROJECT_RESOURCE_ATTACHMENT_ROLES, AUTOMATION_STATUSES, AUTOMATION_CONCURRENCY_POLICIES, AUTOMATION_CATCH_UP_POLICIES, AUTOMATION_OUTPUT_MODES, AUTOMATION_TRIGGER_SIGNING_MODES, PROJECT_COLORS, PROJECT_ICONS, APPROVAL_TYPES, SECRET_PROVIDERS, STORAGE_PROVIDERS, BILLING_TYPES, FINANCE_EVENT_KINDS, FINANCE_DIRECTIONS, FINANCE_UNITS, BUDGET_SCOPE_TYPES, BUDGET_METRICS, BUDGET_WINDOW_KINDS, BUDGET_INCIDENT_RESOLUTION_ACTIONS, INVITE_JOIN_TYPES, JOIN_REQUEST_TYPES, JOIN_REQUEST_STATUSES, PERMISSION_KEYS, PLUGIN_STATUSES, PLUGIN_CATEGORIES, PLUGIN_CAPABILITIES, PLUGIN_UI_SLOT_TYPES, PLUGIN_RESERVED_COMPANY_ROUTE_SEGMENTS, PLUGIN_LAUNCHER_PLACEMENT_ZONES, PLUGIN_LAUNCHER_ACTIONS, PLUGIN_LAUNCHER_BOUNDS, PLUGIN_LAUNCHER_RENDER_ENVIRONMENTS, PLUGIN_UI_SLOT_ENTITY_TYPES, PLUGIN_STATE_SCOPE_KINDS;
+var ORGANIZATION_STATUSES, ORGANIZATION_INTELLIGENCE_PROFILE_PURPOSES, ORGANIZATION_INTELLIGENCE_PROFILE_STATUSES, DEPLOYMENT_MODES, DEPLOYMENT_EXPOSURES, AUTH_BASE_URL_MODES, AGENT_STATUSES, AGENT_RUNTIME_TYPES, AGENT_ROLES, AGENT_ICON_NAMES, AGENT_OREO_ICON_PREFIX, AGENT_OREO_SHAPE_IDS, AGENT_OREO_PALETTE_IDS, AGENT_DICEBEAR_NOTIONISTS_ICON_PREFIX, AGENT_AVATAR_BACKGROUND_PRESET_IDS, ISSUE_STATUSES, ISSUE_PRIORITIES, AGENT_INTEGRATION_PROVIDERS, AGENT_INTEGRATION_STATUSES, AGENT_INTEGRATION_TRANSPORTS, AGENT_INTEGRATION_PROVIDER_REGIONS, AGENT_INTEGRATION_CHAT_TYPES, AGENT_INTEGRATION_DROP_REASONS, AGENT_INTEGRATION_OUTBOUND_STATUSES, CUSTOM_INTEGRATION_KINDS, CUSTOM_INTEGRATION_SCOPES, CUSTOM_INTEGRATION_STATUSES, CUSTOM_INTEGRATION_TOOL_STATUSES, CUSTOM_INTEGRATION_BINDING_STATUSES, CUSTOM_INTEGRATION_TOOL_CALL_STATUSES, CALENDAR_SOURCE_TYPES, CALENDAR_OWNER_TYPES, CALENDAR_VISIBILITIES, CALENDAR_SOURCE_STATUSES, CALENDAR_EVENT_KINDS, CALENDAR_EVENT_STATUSES, CALENDAR_SOURCE_MODES, CHAT_CONVERSATION_STATUSES, CHAT_ISSUE_CREATION_MODES, CHAT_MESSAGE_ROLES, CHAT_MESSAGE_KINDS, CHAT_MESSAGE_STATUSES, CHAT_CONTEXT_ENTITY_TYPES, GOAL_LEVELS, GOAL_STATUSES, PROJECT_STATUSES, ORGANIZATION_RESOURCE_KINDS, ORGANIZATION_RESOURCE_SOURCE_TYPES, PROJECT_RESOURCE_ATTACHMENT_ROLES, AUTOMATION_STATUSES, AUTOMATION_CONCURRENCY_POLICIES, AUTOMATION_CATCH_UP_POLICIES, AUTOMATION_OUTPUT_MODES, AUTOMATION_TRIGGER_SIGNING_MODES, PROJECT_COLORS, PROJECT_ICONS, APPROVAL_TYPES, SECRET_PROVIDERS, STORAGE_PROVIDERS, BILLING_TYPES, FINANCE_EVENT_KINDS, FINANCE_DIRECTIONS, FINANCE_UNITS, BUDGET_SCOPE_TYPES, BUDGET_METRICS, BUDGET_WINDOW_KINDS, BUDGET_INCIDENT_RESOLUTION_ACTIONS, INVITE_JOIN_TYPES, JOIN_REQUEST_TYPES, JOIN_REQUEST_STATUSES, PERMISSION_KEYS, PLUGIN_STATUSES, PLUGIN_CATEGORIES, PLUGIN_CAPABILITIES, PLUGIN_UI_SLOT_TYPES, PLUGIN_RESERVED_COMPANY_ROUTE_SEGMENTS, PLUGIN_LAUNCHER_PLACEMENT_ZONES, PLUGIN_LAUNCHER_ACTIONS, PLUGIN_LAUNCHER_BOUNDS, PLUGIN_LAUNCHER_RENDER_ENVIRONMENTS, PLUGIN_UI_SLOT_ENTITY_TYPES, PLUGIN_STATE_SCOPE_KINDS;
 var init_constants = __esm({
   "../packages/shared/dist/constants.js"() {
     "use strict";
@@ -126,6 +130,57 @@ var init_constants = __esm({
       "pentagon",
       "fingerprint"
     ];
+    AGENT_OREO_ICON_PREFIX = "oreo:";
+    AGENT_OREO_SHAPE_IDS = [
+      "bloom",
+      "silk",
+      "flare",
+      "nova",
+      "void",
+      "jade"
+    ];
+    AGENT_OREO_PALETTE_IDS = [
+      "rose-milk",
+      "peach-cream",
+      "mint-milk",
+      "aurora-pink",
+      "lilac-silk",
+      "blue-cream",
+      "jade-cream",
+      "coral-mist",
+      "lemon-mint",
+      "violet-peach",
+      "magenta-void",
+      "teal-void",
+      "amber-dusk",
+      "sky-melon",
+      "grapefruit",
+      "lavender-lime",
+      "aqua-orchid",
+      "honeydew",
+      "plum-gold",
+      "ice-berry",
+      "apricot-mint",
+      "candy-blue",
+      "raspberry-cream",
+      "spring-glow",
+      "sunset-punch",
+      "moon-pearl",
+      "seafoam-rose",
+      "blueberry-milk",
+      "mango-iris",
+      "forest-neon",
+      "cotton-candy",
+      "lime-sorbet",
+      "cherry-cola",
+      "opal-mint",
+      "peach-lilac",
+      "cyan-flame",
+      "orchid-night",
+      "pistachio-blush",
+      "lagoon-gold",
+      "vanilla-sky"
+    ];
     AGENT_DICEBEAR_NOTIONISTS_ICON_PREFIX = "dicebear:notionists:";
     AGENT_AVATAR_BACKGROUND_PRESET_IDS = [
       "mist",
@@ -552,7 +607,7 @@ var init_website_icons = __esm({
     KNOWN_WEBSITE_ICONS = [
       { hostnames: ["x.com", "twitter.com"], includeSubdomains: true, siteName: "X", iconDataUrl: xIcon },
       { hostnames: ["linkedin.com", "www.linkedin.com"], siteName: "LinkedIn", iconDataUrl: linkedinIcon },
-      { hostnames: ["github.com", "www.github.com", "gist.github.com"], siteName: "GitHub", iconDataUrl: githubIcon },
+      { hostnames: ["github.com", "www.github.com", "gist.github.com"], siteName: "GitHub", iconDataUrl: githubIcon, darkMode: "invert" },
       { hostnames: ["youtube.com", "www.youtube.com", "youtu.be"], siteName: "YouTube", iconDataUrl: youtubeIcon },
       { hostnames: ["google.com", "www.google.com"], siteName: "Google", iconDataUrl: googleIcon },
       { hostnames: ["docs.google.com"], siteName: "Google Docs", iconDataUrl: googleDocsIcon },
@@ -630,7 +685,7 @@ var init_custom_integration = __esm({
 
 // ../packages/shared/dist/validators/chat.js
 import { z as z2 } from "zod";
-var chatConversationStatusSchema, chatIssueCreationModeSchema, chatMessageRoleSchema, chatMessageKindSchema, chatMessageStatusSchema, chatContextEntityTypeSchema, chatGenerationStatusSchema, chatGenerationControlStateSchema, chatQueueDeliveryIntentSchema, chatControlDispositionSchema, chatProviderControlDispositionSchema, chatControlActionKindSchema, chatGenerationEventKindSchema, chatTerminalOutboxStatusSchema, chatQueuedMessageStatusSchema, chatControlActionIdSchema, chatBodyHashSchema, createChatContextLinkSchema, createChatConversationSchema, setChatProjectContextSchema, updateChatConversationSchema, forkChatConversationSchema, createSideChatSchema, addChatMessageSchema, chatQueuedMessagePayloadSchema, createChatQueuedMessageSchema, updateChatQueuedMessageSchema, cancelChatQueuedMessageSchema, steerChatQueuedMessageSchema, stopChatGenerationSchema, chatClientCheckpointSchema, appendChatGenerationEventSchema, chatRichReferenceDisplaySchema, chatIssueIdentifierSchema, chatAskUserIdentifierSchema, chatAskUserOptionSchema, chatAskUserQuestionSchema, chatAskUserRequestSchema, chatIssueRichReferenceSchema, chatIssueCommentRichReferenceSchema, chatRichReferenceSchema, chatRichReferencesSchema, chatAutomationCreateSchema, createChatAttachmentMetadataSchema, chatIssueProposalSchema, convertChatToIssueSchema, chatOperationProposalSchema, resolveChatOperationProposalSchema, updateChatConversationUserStateSchema, updateMessengerThreadUserStateSchema, createMessengerCustomGroupSchema, createMessengerCustomGroupWithEntriesSchema, updateMessengerCustomGroupSchema, reorderMessengerCustomGroupsSchema, assignMessengerCustomGroupEntrySchema, reorderMessengerCustomGroupEntriesSchema;
+var chatConversationStatusSchema, chatIssueCreationModeSchema, chatMessageRoleSchema, chatMessageKindSchema, chatMessageStatusSchema, chatContextEntityTypeSchema, chatGenerationStatusSchema, chatGenerationControlStateSchema, chatQueueDeliveryIntentSchema, chatControlDispositionSchema, chatProviderControlDispositionSchema, chatControlActionKindSchema, chatGenerationEventKindSchema, chatTerminalOutboxStatusSchema, chatQueuedMessageStatusSchema, chatControlActionIdSchema, chatBodyHashSchema, createChatContextLinkSchema, chatDraftSchema, createChatConversationSchema, createChatFirstTurnSchema, setChatProjectContextSchema, updateChatConversationSchema, forkChatConversationSchema, createSideChatSchema, addChatMessageSchema, chatQueuedMessagePayloadSchema, createChatQueuedMessageSchema, updateChatQueuedMessageSchema, cancelChatQueuedMessageSchema, steerChatQueuedMessageSchema, stopChatGenerationSchema, chatClientCheckpointSchema, appendChatGenerationEventSchema, chatRichReferenceDisplaySchema, chatIssueIdentifierSchema, chatAskUserIdentifierSchema, chatAskUserOptionSchema, chatAskUserQuestionSchema, chatAskUserRequestSchema, chatIssueRichReferenceSchema, chatIssueCommentRichReferenceSchema, chatRichReferenceSchema, chatRichReferencesSchema, chatAutomationCreateSchema, createChatAttachmentMetadataSchema, chatIssueProposalSchema, convertChatToIssueSchema, chatOperationProposalSchema, resolveChatOperationProposalSchema, updateChatConversationUserStateSchema, updateMessengerThreadUserStateSchema, createMessengerCustomGroupSchema, messengerItemKeySchema, messengerItemKeysSchema, createMessengerCustomGroupWithEntriesSchema, updateMessengerCustomGroupSchema, reorderMessengerCustomGroupsSchema, assignMessengerCustomGroupEntrySchema, reorderMessengerCustomGroupEntriesSchema;
 var init_chat = __esm({
   "../packages/shared/dist/validators/chat.js"() {
     "use strict";
@@ -741,7 +796,7 @@ var init_chat = __esm({
       entityId: z2.string().min(1),
       metadata: z2.record(z2.unknown()).optional().nullable()
     });
-    createChatConversationSchema = z2.object({
+    chatDraftSchema = z2.object({
       title: z2.string().trim().min(1).max(200).optional(),
       summary: z2.string().trim().max(5e3).optional().nullable(),
       preferredAgentId: z2.string().uuid().optional().nullable(),
@@ -749,10 +804,18 @@ var init_chat = __esm({
       planMode: z2.boolean().optional(),
       contextLinks: z2.array(createChatContextLinkSchema).optional().default([])
     });
+    createChatConversationSchema = chatDraftSchema.extend({
+      initialMessage: z2.object({
+        body: z2.string().trim().min(1).max(2e4)
+      })
+    });
+    createChatFirstTurnSchema = chatDraftSchema.extend({
+      body: z2.string().trim().min(1).max(2e4)
+    });
     setChatProjectContextSchema = z2.object({
       projectId: z2.string().uuid().optional().nullable()
     });
-    updateChatConversationSchema = createChatConversationSchema.partial().extend({
+    updateChatConversationSchema = chatDraftSchema.partial().extend({
       status: chatConversationStatusSchema.optional(),
       routedAgentId: z2.string().uuid().optional().nullable(),
       primaryIssueId: z2.string().uuid().optional().nullable(),
@@ -1014,10 +1077,23 @@ var init_chat = __esm({
       name: z2.string().trim().min(1).max(80),
       icon: z2.string().trim().min(1).max(24).optional().nullable()
     });
+    messengerItemKeySchema = z2.string().trim().min(1).max(240).refine((itemKey) => {
+      if (!itemKey.startsWith("saved-view:"))
+        return true;
+      return z2.string().uuid().safeParse(itemKey.slice("saved-view:".length)).success;
+    }, "Saved View item keys must contain a valid UUID");
+    messengerItemKeysSchema = z2.array(messengerItemKeySchema).min(1).max(50);
     createMessengerCustomGroupWithEntriesSchema = createMessengerCustomGroupSchema.extend({
-      threadKeys: z2.array(z2.string().trim().min(1).max(240)).min(1).max(50),
+      itemKeys: messengerItemKeysSchema.optional(),
+      threadKeys: messengerItemKeysSchema.optional(),
       autoGenerateName: z2.boolean().optional()
-    });
+    }).superRefine((value, ctx) => {
+      if (!value.itemKeys && !value.threadKeys) {
+        ctx.addIssue({ code: "custom", message: "itemKeys or threadKeys is required", path: ["itemKeys"] });
+      } else if (value.itemKeys && value.threadKeys && JSON.stringify(value.itemKeys) !== JSON.stringify(value.threadKeys)) {
+        ctx.addIssue({ code: "custom", message: "itemKeys and threadKeys must match", path: ["itemKeys"] });
+      }
+    }).transform((value) => ({ ...value, itemKeys: value.itemKeys ?? value.threadKeys }));
     updateMessengerCustomGroupSchema = z2.object({
       name: z2.string().trim().min(1).max(80).optional(),
       icon: z2.string().trim().min(1).max(24).optional().nullable(),
@@ -1029,16 +1105,112 @@ var init_chat = __esm({
       groupIds: z2.array(z2.string().uuid()).max(200)
     });
     assignMessengerCustomGroupEntrySchema = z2.object({
-      threadKey: z2.string().trim().min(1).max(240)
-    });
+      itemKey: messengerItemKeySchema.optional(),
+      threadKey: messengerItemKeySchema.optional()
+    }).superRefine((value, ctx) => {
+      if (!value.itemKey && !value.threadKey) {
+        ctx.addIssue({ code: "custom", message: "itemKey or threadKey is required", path: ["itemKey"] });
+      } else if (value.itemKey && value.threadKey && value.itemKey !== value.threadKey) {
+        ctx.addIssue({ code: "custom", message: "itemKey and threadKey must match", path: ["itemKey"] });
+      }
+    }).transform((value) => ({ ...value, itemKey: value.itemKey ?? value.threadKey }));
     reorderMessengerCustomGroupEntriesSchema = z2.object({
-      threadKeys: z2.array(z2.string().trim().min(1).max(240)).max(500)
+      itemKeys: z2.array(messengerItemKeySchema).max(500).optional(),
+      threadKeys: z2.array(messengerItemKeySchema).max(500).optional()
+    }).superRefine((value, ctx) => {
+      if (!value.itemKeys && !value.threadKeys) {
+        ctx.addIssue({ code: "custom", message: "itemKeys or threadKeys is required", path: ["itemKeys"] });
+      } else if (value.itemKeys && value.threadKeys && JSON.stringify(value.itemKeys) !== JSON.stringify(value.threadKeys)) {
+        ctx.addIssue({ code: "custom", message: "itemKeys and threadKeys must match", path: ["itemKeys"] });
+      }
+      const resolvedKeys = value.itemKeys ?? value.threadKeys;
+      if (resolvedKeys && new Set(resolvedKeys).size !== resolvedKeys.length) {
+        ctx.addIssue({
+          code: "custom",
+          message: "Messenger custom group reorder keys must be unique",
+          path: [value.itemKeys ? "itemKeys" : "threadKeys"]
+        });
+      }
+    }).transform((value) => ({ ...value, itemKeys: value.itemKeys ?? value.threadKeys }));
+  }
+});
+
+// ../packages/shared/dist/validators/messenger.js
+import { z as z3 } from "zod";
+function isCanonicalPortableLibraryPath(value, allowRoot) {
+  if (allowRoot && value === "")
+    return true;
+  if (!value || value !== value.trim())
+    return false;
+  if (value.startsWith("/") || value.includes("\\"))
+    return false;
+  if (/^[a-z][a-z0-9+.-]*:/i.test(value))
+    return false;
+  const segments = value.split("/");
+  return segments.every((segment) => Boolean(segment) && segment !== "." && segment !== ".." && !segment.startsWith("~"));
+}
+var uuid, nonBlankId, libraryPathSchema, libraryDirectoryPathSchema, browserUrlSchema, messengerSavedViewTargetSchema, savedViewMetadataShape, createMessengerSavedViewSchema, updateMessengerSavedViewSchema, reorderMessengerSavedViewsSchema, listMessengerSavedViewsQuerySchema;
+var init_messenger = __esm({
+  "../packages/shared/dist/validators/messenger.js"() {
+    "use strict";
+    init_chat();
+    uuid = z3.string().uuid();
+    nonBlankId = z3.string().trim().min(1).max(240);
+    libraryPathSchema = z3.string().max(4096).refine((value) => isCanonicalPortableLibraryPath(value, false), "Library path must be canonical and relative");
+    libraryDirectoryPathSchema = z3.string().max(4096).refine((value) => isCanonicalPortableLibraryPath(value, true), "Library directory path must be canonical and relative");
+    browserUrlSchema = z3.string().trim().min(1).max(8192).refine((value) => {
+      try {
+        const url = new URL(value);
+        return (url.protocol === "http:" || url.protocol === "https:") && Boolean(url.hostname);
+      } catch {
+        return false;
+      }
+    }, "Browser URL must be an absolute HTTP(S) URL");
+    messengerSavedViewTargetSchema = z3.discriminatedUnion("kind", [
+      z3.object({ kind: z3.literal("browser"), tabId: nonBlankId, url: browserUrlSchema }).strict(),
+      z3.object({ kind: z3.literal("automation"), automationId: uuid }).strict(),
+      z3.object({ kind: z3.literal("library_document"), documentId: uuid }).strict(),
+      z3.object({ kind: z3.literal("library_entry"), entryId: uuid, path: libraryPathSchema }).strict(),
+      z3.object({ kind: z3.literal("library_file"), filePath: libraryPathSchema }).strict(),
+      z3.object({ kind: z3.literal("library_directory"), directoryPath: libraryDirectoryPathSchema }).strict()
+    ]);
+    savedViewMetadataShape = {
+      title: z3.string().trim().min(1).max(240),
+      subtitle: z3.string().trim().max(1e3).optional().nullable(),
+      favicon: z3.string().trim().max(8192).optional().nullable()
+    };
+    createMessengerSavedViewSchema = z3.object({
+      target: messengerSavedViewTargetSchema,
+      ...savedViewMetadataShape
+    }).strict();
+    updateMessengerSavedViewSchema = z3.object({
+      target: messengerSavedViewTargetSchema.optional(),
+      title: savedViewMetadataShape.title.optional(),
+      subtitle: savedViewMetadataShape.subtitle,
+      favicon: savedViewMetadataShape.favicon,
+      hidden: z3.boolean().optional()
+    }).strict().refine((value) => Object.keys(value).length > 0, "At least one field is required");
+    reorderMessengerSavedViewsSchema = z3.object({
+      ids: z3.array(uuid).max(500)
+    }).strict().superRefine(({ ids }, ctx) => {
+      const seen = /* @__PURE__ */ new Set();
+      for (const [index, id] of ids.entries()) {
+        if (seen.has(id)) {
+          ctx.addIssue({ code: "custom", message: "Saved View ids must be unique", path: ["ids", index] });
+        }
+        seen.add(id);
+      }
     });
+    listMessengerSavedViewsQuerySchema = z3.object({
+      visibility: z3.enum(["visible", "hidden", "all"]).default("visible"),
+      limit: z3.coerce.number().int().min(1).max(100).default(50),
+      offset: z3.coerce.number().int().min(0).default(0)
+    }).strict();
   }
 });
 
 // ../packages/shared/dist/validators/instance.js
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var DEFAULT_INSTANCE_BROWSER_SETTINGS, instanceBrowserSettingsSchema, patchInstanceBrowserSettingsSchema, instanceLocaleSchema, instanceGeneralSettingsSchema, patchInstanceGeneralSettingsSchema, instanceNotificationSettingsSchema, patchInstanceNotificationSettingsSchema, OPERATOR_PROFILE_MORE_ABOUT_YOU_MAX_LENGTH, operatorProfileSettingsSchema, patchOperatorProfileSettingsSchema, KEYBOARD_SHORTCUT_ACTION_IDS, keyboardShortcutActionIdSchema, keyboardShortcutBindingSchema, keyboardShortcutPreferenceSchema, keyboardShortcutSettingsSchema, instancePathPickerSelectionTypeSchema, instancePathPickerRequestSchema, instancePathPickerResultSchema;
 var init_instance = __esm({
   "../packages/shared/dist/validators/instance.js"() {
@@ -1047,32 +1219,32 @@ var init_instance = __esm({
       enabled: true,
       openLinksIn: "built_in"
     };
-    instanceBrowserSettingsSchema = z3.object({
-      enabled: z3.boolean().default(DEFAULT_INSTANCE_BROWSER_SETTINGS.enabled),
-      openLinksIn: z3.enum(["built_in", "default_browser"]).default(DEFAULT_INSTANCE_BROWSER_SETTINGS.openLinksIn)
+    instanceBrowserSettingsSchema = z4.object({
+      enabled: z4.boolean().default(DEFAULT_INSTANCE_BROWSER_SETTINGS.enabled),
+      openLinksIn: z4.enum(["built_in", "default_browser"]).default(DEFAULT_INSTANCE_BROWSER_SETTINGS.openLinksIn)
     }).strict();
-    patchInstanceBrowserSettingsSchema = z3.object({
-      enabled: z3.boolean().optional(),
-      openLinksIn: z3.enum(["built_in", "default_browser"]).optional()
+    patchInstanceBrowserSettingsSchema = z4.object({
+      enabled: z4.boolean().optional(),
+      openLinksIn: z4.enum(["built_in", "default_browser"]).optional()
     }).strict();
-    instanceLocaleSchema = z3.enum(["en", "zh-CN"]);
-    instanceGeneralSettingsSchema = z3.object({
-      censorUsernameInLogs: z3.boolean().default(false),
-      showDeveloperDiagnostics: z3.boolean().default(false),
+    instanceLocaleSchema = z4.enum(["en", "zh-CN"]);
+    instanceGeneralSettingsSchema = z4.object({
+      censorUsernameInLogs: z4.boolean().default(false),
+      showDeveloperDiagnostics: z4.boolean().default(false),
       locale: instanceLocaleSchema.default("en")
     }).strict();
     patchInstanceGeneralSettingsSchema = instanceGeneralSettingsSchema.partial();
-    instanceNotificationSettingsSchema = z3.object({
-      desktopInboxNotifications: z3.boolean().default(true),
-      desktopDockBadge: z3.boolean().default(true),
-      desktopIssueNotifications: z3.boolean().default(true),
-      desktopChatNotifications: z3.boolean().default(true)
+    instanceNotificationSettingsSchema = z4.object({
+      desktopInboxNotifications: z4.boolean().default(true),
+      desktopDockBadge: z4.boolean().default(true),
+      desktopIssueNotifications: z4.boolean().default(true),
+      desktopChatNotifications: z4.boolean().default(true)
     }).strict();
     patchInstanceNotificationSettingsSchema = instanceNotificationSettingsSchema.partial();
     OPERATOR_PROFILE_MORE_ABOUT_YOU_MAX_LENGTH = 8e3;
-    operatorProfileSettingsSchema = z3.object({
-      nickname: z3.string().max(80).default(""),
-      moreAboutYou: z3.string().max(OPERATOR_PROFILE_MORE_ABOUT_YOU_MAX_LENGTH).default("")
+    operatorProfileSettingsSchema = z4.object({
+      nickname: z4.string().max(80).default(""),
+      moreAboutYou: z4.string().max(OPERATOR_PROFILE_MORE_ABOUT_YOU_MAX_LENGTH).default("")
     }).strict();
     patchOperatorProfileSettingsSchema = operatorProfileSettingsSchema.partial();
     KEYBOARD_SHORTCUT_ACTION_IDS = [
@@ -1083,28 +1255,28 @@ var init_instance = __esm({
       "sidebar.toggle",
       "panel.toggle"
     ];
-    keyboardShortcutActionIdSchema = z3.enum(KEYBOARD_SHORTCUT_ACTION_IDS);
-    keyboardShortcutBindingSchema = z3.object({
-      key: z3.string().trim().min(1).max(64),
-      code: z3.string().trim().min(1).max(80).optional(),
-      metaKey: z3.boolean().optional(),
-      ctrlKey: z3.boolean().optional(),
-      altKey: z3.boolean().optional(),
-      shiftKey: z3.boolean().optional()
+    keyboardShortcutActionIdSchema = z4.enum(KEYBOARD_SHORTCUT_ACTION_IDS);
+    keyboardShortcutBindingSchema = z4.object({
+      key: z4.string().trim().min(1).max(64),
+      code: z4.string().trim().min(1).max(80).optional(),
+      metaKey: z4.boolean().optional(),
+      ctrlKey: z4.boolean().optional(),
+      altKey: z4.boolean().optional(),
+      shiftKey: z4.boolean().optional()
     }).strict();
-    keyboardShortcutPreferenceSchema = z3.object({
+    keyboardShortcutPreferenceSchema = z4.object({
       actionId: keyboardShortcutActionIdSchema,
-      bindings: z3.array(keyboardShortcutBindingSchema).max(4).optional(),
-      disabled: z3.boolean().optional()
+      bindings: z4.array(keyboardShortcutBindingSchema).max(4).optional(),
+      disabled: z4.boolean().optional()
     }).strict();
-    keyboardShortcutSettingsSchema = z3.object({
-      shortcuts: z3.array(keyboardShortcutPreferenceSchema).max(KEYBOARD_SHORTCUT_ACTION_IDS.length).default([])
+    keyboardShortcutSettingsSchema = z4.object({
+      shortcuts: z4.array(keyboardShortcutPreferenceSchema).max(KEYBOARD_SHORTCUT_ACTION_IDS.length).default([])
     }).strict().superRefine((value, ctx) => {
       const seen = /* @__PURE__ */ new Set();
       value.shortcuts.forEach((shortcut, index) => {
         if (seen.has(shortcut.actionId)) {
           ctx.addIssue({
-            code: z3.ZodIssueCode.custom,
+            code: z4.ZodIssueCode.custom,
             message: `Duplicate shortcut action id: ${shortcut.actionId}`,
             path: ["shortcuts", index, "actionId"]
           });
@@ -1113,43 +1285,43 @@ var init_instance = __esm({
         seen.add(shortcut.actionId);
       });
     });
-    instancePathPickerSelectionTypeSchema = z3.enum(["file", "directory"]);
-    instancePathPickerRequestSchema = z3.object({
+    instancePathPickerSelectionTypeSchema = z4.enum(["file", "directory"]);
+    instancePathPickerRequestSchema = z4.object({
       selectionType: instancePathPickerSelectionTypeSchema
     }).strict();
-    instancePathPickerResultSchema = z3.object({
-      path: z3.string().nullable(),
-      cancelled: z3.boolean()
+    instancePathPickerResultSchema = z4.object({
+      path: z4.string().nullable(),
+      cancelled: z4.boolean()
     }).strict();
   }
 });
 
 // ../packages/shared/dist/validators/budget.js
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var upsertBudgetPolicySchema, resolveBudgetIncidentSchema;
 var init_budget = __esm({
   "../packages/shared/dist/validators/budget.js"() {
     "use strict";
     init_constants();
-    upsertBudgetPolicySchema = z4.object({
-      scopeType: z4.enum(BUDGET_SCOPE_TYPES),
-      scopeId: z4.string().uuid(),
-      metric: z4.enum(BUDGET_METRICS).optional().default("billed_cents"),
-      windowKind: z4.enum(BUDGET_WINDOW_KINDS).optional().default("calendar_month_utc"),
-      amount: z4.number().int().nonnegative(),
-      warnPercent: z4.number().int().min(1).max(99).optional().default(80),
-      hardStopEnabled: z4.boolean().optional().default(true),
-      notifyEnabled: z4.boolean().optional().default(true),
-      isActive: z4.boolean().optional().default(true)
+    upsertBudgetPolicySchema = z5.object({
+      scopeType: z5.enum(BUDGET_SCOPE_TYPES),
+      scopeId: z5.string().uuid(),
+      metric: z5.enum(BUDGET_METRICS).optional().default("billed_cents"),
+      windowKind: z5.enum(BUDGET_WINDOW_KINDS).optional().default("calendar_month_utc"),
+      amount: z5.number().int().nonnegative(),
+      warnPercent: z5.number().int().min(1).max(99).optional().default(80),
+      hardStopEnabled: z5.boolean().optional().default(true),
+      notifyEnabled: z5.boolean().optional().default(true),
+      isActive: z5.boolean().optional().default(true)
     });
-    resolveBudgetIncidentSchema = z4.object({
-      action: z4.enum(BUDGET_INCIDENT_RESOLUTION_ACTIONS),
-      amount: z4.number().int().nonnegative().optional(),
-      decisionNote: z4.string().optional().nullable()
+    resolveBudgetIncidentSchema = z5.object({
+      action: z5.enum(BUDGET_INCIDENT_RESOLUTION_ACTIONS),
+      amount: z5.number().int().nonnegative().optional(),
+      decisionNote: z5.string().optional().nullable()
     }).superRefine((value, ctx) => {
       if (value.action === "raise_budget_and_resume" && typeof value.amount !== "number") {
         ctx.addIssue({
-          code: z4.ZodIssueCode.custom,
+          code: z5.ZodIssueCode.custom,
           message: "amount is required when raising a budget",
           path: ["amount"]
         });
@@ -1159,12 +1331,12 @@ var init_budget = __esm({
 });
 
 // ../packages/shared/dist/validators/adapter-skills.js
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var agentSkillStateSchema, agentSkillOriginSchema, agentSkillSourceClassSchema, agentSkillSyncModeSchema, agentSkillEntrySchema, agentSkillSnapshotSchema, agentSkillSyncSchema, agentSkillEnableSchema;
 var init_adapter_skills = __esm({
   "../packages/shared/dist/validators/adapter-skills.js"() {
     "use strict";
-    agentSkillStateSchema = z5.enum([
+    agentSkillStateSchema = z6.enum([
       "available",
       "configured",
       "installed",
@@ -1172,107 +1344,107 @@ var init_adapter_skills = __esm({
       "stale",
       "external"
     ]);
-    agentSkillOriginSchema = z5.preprocess((value) => {
+    agentSkillOriginSchema = z6.preprocess((value) => {
       if (value === "company_managed")
         return "organization_managed";
       return value;
-    }, z5.enum([
+    }, z6.enum([
       "organization_managed",
       "user_installed",
       "external_unknown"
     ]));
-    agentSkillSourceClassSchema = z5.enum([
+    agentSkillSourceClassSchema = z6.enum([
       "bundled",
       "organization",
       "agent_home",
       "global",
       "adapter_home"
     ]);
-    agentSkillSyncModeSchema = z5.enum([
+    agentSkillSyncModeSchema = z6.enum([
       "unsupported",
       "persistent",
       "ephemeral"
     ]);
-    agentSkillEntrySchema = z5.object({
-      key: z5.string().min(1),
-      selectionKey: z5.string().min(1),
-      runtimeName: z5.string().min(1).nullable(),
-      description: z5.string().nullable().optional(),
-      desired: z5.boolean(),
-      configurable: z5.boolean(),
-      alwaysEnabled: z5.boolean(),
-      managed: z5.boolean(),
+    agentSkillEntrySchema = z6.object({
+      key: z6.string().min(1),
+      selectionKey: z6.string().min(1),
+      runtimeName: z6.string().min(1).nullable(),
+      description: z6.string().nullable().optional(),
+      desired: z6.boolean(),
+      configurable: z6.boolean(),
+      alwaysEnabled: z6.boolean(),
+      managed: z6.boolean(),
       state: agentSkillStateSchema,
       sourceClass: agentSkillSourceClassSchema,
       origin: agentSkillOriginSchema.optional(),
-      originLabel: z5.string().nullable().optional(),
-      locationLabel: z5.string().nullable().optional(),
-      readOnly: z5.boolean().optional(),
-      sourcePath: z5.string().nullable().optional(),
-      targetPath: z5.string().nullable().optional(),
-      workspaceEditPath: z5.string().nullable().optional(),
-      detail: z5.string().nullable().optional()
+      originLabel: z6.string().nullable().optional(),
+      locationLabel: z6.string().nullable().optional(),
+      readOnly: z6.boolean().optional(),
+      sourcePath: z6.string().nullable().optional(),
+      targetPath: z6.string().nullable().optional(),
+      workspaceEditPath: z6.string().nullable().optional(),
+      detail: z6.string().nullable().optional()
     });
-    agentSkillSnapshotSchema = z5.object({
-      agentRuntimeType: z5.string().min(1),
-      supported: z5.boolean(),
+    agentSkillSnapshotSchema = z6.object({
+      agentRuntimeType: z6.string().min(1),
+      supported: z6.boolean(),
       mode: agentSkillSyncModeSchema,
-      desiredSkills: z5.array(z5.string().min(1)),
-      entries: z5.array(agentSkillEntrySchema),
-      warnings: z5.array(z5.string())
+      desiredSkills: z6.array(z6.string().min(1)),
+      entries: z6.array(agentSkillEntrySchema),
+      warnings: z6.array(z6.string())
     });
-    agentSkillSyncSchema = z5.object({
-      desiredSkills: z5.array(z5.string().min(1))
+    agentSkillSyncSchema = z6.object({
+      desiredSkills: z6.array(z6.string().min(1))
     });
-    agentSkillEnableSchema = z5.object({
-      skills: z5.array(z5.string().min(1)).min(1)
+    agentSkillEnableSchema = z6.object({
+      skills: z6.array(z6.string().min(1)).min(1)
     });
   }
 });
 
 // ../packages/shared/dist/validators/secret.js
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var envBindingPlainSchema, envBindingSecretRefSchema, envBindingSchema, envConfigSchema, createSecretSchema, rotateSecretSchema, updateSecretSchema;
 var init_secret = __esm({
   "../packages/shared/dist/validators/secret.js"() {
     "use strict";
     init_constants();
-    envBindingPlainSchema = z6.object({
-      type: z6.literal("plain"),
-      value: z6.string()
+    envBindingPlainSchema = z7.object({
+      type: z7.literal("plain"),
+      value: z7.string()
     });
-    envBindingSecretRefSchema = z6.object({
-      type: z6.literal("secret_ref"),
-      secretId: z6.string().uuid(),
-      version: z6.union([z6.literal("latest"), z6.number().int().positive()]).optional()
+    envBindingSecretRefSchema = z7.object({
+      type: z7.literal("secret_ref"),
+      secretId: z7.string().uuid(),
+      version: z7.union([z7.literal("latest"), z7.number().int().positive()]).optional()
     });
-    envBindingSchema = z6.union([
-      z6.string(),
+    envBindingSchema = z7.union([
+      z7.string(),
       envBindingPlainSchema,
       envBindingSecretRefSchema
     ]);
-    envConfigSchema = z6.record(envBindingSchema);
-    createSecretSchema = z6.object({
-      name: z6.string().min(1),
-      provider: z6.enum(SECRET_PROVIDERS).optional(),
-      value: z6.string().min(1),
-      description: z6.string().optional().nullable(),
-      externalRef: z6.string().optional().nullable()
+    envConfigSchema = z7.record(envBindingSchema);
+    createSecretSchema = z7.object({
+      name: z7.string().min(1),
+      provider: z7.enum(SECRET_PROVIDERS).optional(),
+      value: z7.string().min(1),
+      description: z7.string().optional().nullable(),
+      externalRef: z7.string().optional().nullable()
     });
-    rotateSecretSchema = z6.object({
-      value: z6.string().min(1),
-      externalRef: z6.string().optional().nullable()
+    rotateSecretSchema = z7.object({
+      value: z7.string().min(1),
+      externalRef: z7.string().optional().nullable()
     });
-    updateSecretSchema = z6.object({
-      name: z6.string().min(1).optional(),
-      description: z6.string().optional().nullable(),
-      externalRef: z6.string().optional().nullable()
+    updateSecretSchema = z7.object({
+      name: z7.string().min(1).optional(),
+      description: z7.string().optional().nullable(),
+      externalRef: z7.string().optional().nullable()
     });
   }
 });
 
 // ../packages/shared/dist/validators/model-fallbacks.js
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1282,7 +1454,7 @@ function validateModelFallbacksConfig(value, ctx, pathPrefix) {
     return;
   if (!Array.isArray(fallbackModels)) {
     ctx.addIssue({
-      code: z7.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       message: "modelFallbacks must be an array",
       path: [...pathPrefix, "modelFallbacks"]
     });
@@ -1292,7 +1464,7 @@ function validateModelFallbacksConfig(value, ctx, pathPrefix) {
     if (typeof fallback === "string") {
       if (fallback.trim().length === 0) {
         ctx.addIssue({
-          code: z7.ZodIssueCode.custom,
+          code: z8.ZodIssueCode.custom,
           message: "modelFallbacks string entries must be non-empty",
           path: [...pathPrefix, "modelFallbacks", index]
         });
@@ -1301,7 +1473,7 @@ function validateModelFallbacksConfig(value, ctx, pathPrefix) {
     }
     if (!isRecord(fallback)) {
       ctx.addIssue({
-        code: z7.ZodIssueCode.custom,
+        code: z8.ZodIssueCode.custom,
         message: "modelFallbacks entries must be strings or runtime/model objects",
         path: [...pathPrefix, "modelFallbacks", index]
       });
@@ -1309,27 +1481,27 @@ function validateModelFallbacksConfig(value, ctx, pathPrefix) {
     }
     if (typeof fallback.agentRuntimeType !== "string" || fallback.agentRuntimeType.trim().length === 0) {
       ctx.addIssue({
-        code: z7.ZodIssueCode.custom,
+        code: z8.ZodIssueCode.custom,
         message: "modelFallbacks entries must include agentRuntimeType",
         path: [...pathPrefix, "modelFallbacks", index, "agentRuntimeType"]
       });
     } else if (!agentRuntimeTypes.has(fallback.agentRuntimeType)) {
       ctx.addIssue({
-        code: z7.ZodIssueCode.custom,
+        code: z8.ZodIssueCode.custom,
         message: "modelFallbacks entries must include a valid agentRuntimeType",
         path: [...pathPrefix, "modelFallbacks", index, "agentRuntimeType"]
       });
     }
     if (typeof fallback.model !== "string" || fallback.model.trim().length === 0) {
       ctx.addIssue({
-        code: z7.ZodIssueCode.custom,
+        code: z8.ZodIssueCode.custom,
         message: "modelFallbacks entries must include model",
         path: [...pathPrefix, "modelFallbacks", index, "model"]
       });
     }
     if (fallback.config !== void 0 && !isRecord(fallback.config)) {
       ctx.addIssue({
-        code: z7.ZodIssueCode.custom,
+        code: z8.ZodIssueCode.custom,
         message: "modelFallbacks entry config must be an object",
         path: [...pathPrefix, "modelFallbacks", index, "config"]
       });
@@ -1337,7 +1509,7 @@ function validateModelFallbacksConfig(value, ctx, pathPrefix) {
       const parsed = envConfigSchema.safeParse(fallback.config.env);
       if (!parsed.success) {
         ctx.addIssue({
-          code: z7.ZodIssueCode.custom,
+          code: z8.ZodIssueCode.custom,
           message: "modelFallbacks entry config.env must be a map of valid env bindings",
           path: [...pathPrefix, "modelFallbacks", index, "config", "env"]
         });
@@ -1356,7 +1528,7 @@ var init_model_fallbacks = __esm({
 });
 
 // ../packages/shared/dist/validators/organization-intelligence-profile.js
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var organizationIntelligenceProfilePurposeSchema, organizationIntelligenceProfileStatusSchema, organizationIntelligenceProfileConfigSchema, upsertOrganizationIntelligenceProfileSchema;
 var init_organization_intelligence_profile = __esm({
   "../packages/shared/dist/validators/organization-intelligence-profile.js"() {
@@ -1364,15 +1536,15 @@ var init_organization_intelligence_profile = __esm({
     init_constants();
     init_model_fallbacks();
     init_secret();
-    organizationIntelligenceProfilePurposeSchema = z8.enum(ORGANIZATION_INTELLIGENCE_PROFILE_PURPOSES);
-    organizationIntelligenceProfileStatusSchema = z8.enum(ORGANIZATION_INTELLIGENCE_PROFILE_STATUSES);
-    organizationIntelligenceProfileConfigSchema = z8.record(z8.unknown()).superRefine((value, ctx) => {
+    organizationIntelligenceProfilePurposeSchema = z9.enum(ORGANIZATION_INTELLIGENCE_PROFILE_PURPOSES);
+    organizationIntelligenceProfileStatusSchema = z9.enum(ORGANIZATION_INTELLIGENCE_PROFILE_STATUSES);
+    organizationIntelligenceProfileConfigSchema = z9.record(z9.unknown()).superRefine((value, ctx) => {
       const envValue = value.env;
       if (envValue !== void 0) {
         const parsed = envConfigSchema.safeParse(envValue);
         if (!parsed.success) {
           ctx.addIssue({
-            code: z8.ZodIssueCode.custom,
+            code: z9.ZodIssueCode.custom,
             message: "agentRuntimeConfig.env must be a map of valid env bindings",
             path: ["env"]
           });
@@ -1380,8 +1552,8 @@ var init_organization_intelligence_profile = __esm({
       }
       validateModelFallbacksConfig(value, ctx, []);
     });
-    upsertOrganizationIntelligenceProfileSchema = z8.object({
-      agentRuntimeType: z8.enum(AGENT_RUNTIME_TYPES),
+    upsertOrganizationIntelligenceProfileSchema = z9.object({
+      agentRuntimeType: z9.enum(AGENT_RUNTIME_TYPES),
       agentRuntimeConfig: organizationIntelligenceProfileConfigSchema.default({}),
       status: organizationIntelligenceProfileStatusSchema.optional().default("disabled")
     });
@@ -1399,296 +1571,296 @@ var init_organization_issue_key = __esm({
 });
 
 // ../packages/shared/dist/validators/organization.js
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var logoAssetIdSchema, brandColorSchema, organizationIssueKeySchema, createOrganizationSchema, updateOrganizationSchema, updateOrganizationBrandingSchema, updateOrganizationWorkspaceFileSchema, workspaceWebPreviewNetworkModeSchema, createOrganizationWorkspaceWebPreviewSessionSchema, createOrganizationWorkspaceFileSchema, createOrganizationWorkspaceDirectorySchema, renameOrganizationWorkspaceEntrySchema, moveOrganizationWorkspaceEntrySchema, copyOrganizationWorkspaceEntrySchema;
 var init_organization = __esm({
   "../packages/shared/dist/validators/organization.js"() {
     "use strict";
     init_constants();
     init_organization_issue_key();
-    logoAssetIdSchema = z9.string().uuid().nullable().optional();
-    brandColorSchema = z9.string().regex(/^#[0-9a-fA-F]{6}$/).nullable().optional();
-    organizationIssueKeySchema = z9.string().trim().min(1).max(ORGANIZATION_ISSUE_KEY_MAX_LENGTH).transform((value) => value.toUpperCase()).refine((value) => ORGANIZATION_ISSUE_KEY_PATTERN.test(value), {
+    logoAssetIdSchema = z10.string().uuid().nullable().optional();
+    brandColorSchema = z10.string().regex(/^#[0-9a-fA-F]{6}$/).nullable().optional();
+    organizationIssueKeySchema = z10.string().trim().min(1).max(ORGANIZATION_ISSUE_KEY_MAX_LENGTH).transform((value) => value.toUpperCase()).refine((value) => ORGANIZATION_ISSUE_KEY_PATTERN.test(value), {
       message: "Issue key must start with a letter and contain only letters and numbers"
     });
-    createOrganizationSchema = z9.object({
-      name: z9.string().min(1),
+    createOrganizationSchema = z10.object({
+      name: z10.string().min(1),
       issuePrefix: organizationIssueKeySchema.optional(),
-      description: z9.string().optional().nullable(),
-      budgetMonthlyCents: z9.number().int().nonnegative().optional().default(0),
-      defaultChatIssueCreationMode: z9.enum(CHAT_ISSUE_CREATION_MODES).optional().default("manual_approval"),
+      description: z10.string().optional().nullable(),
+      budgetMonthlyCents: z10.number().int().nonnegative().optional().default(0),
+      defaultChatIssueCreationMode: z10.enum(CHAT_ISSUE_CREATION_MODES).optional().default("manual_approval"),
       brandColor: brandColorSchema,
-      requireBoardApprovalForNewAgents: z9.boolean().optional()
+      requireBoardApprovalForNewAgents: z10.boolean().optional()
     });
     updateOrganizationSchema = createOrganizationSchema.partial().extend({
-      status: z9.enum(ORGANIZATION_STATUSES).optional(),
-      spentMonthlyCents: z9.number().int().nonnegative().optional(),
-      requireBoardApprovalForNewAgents: z9.boolean().optional(),
-      defaultChatIssueCreationMode: z9.enum(CHAT_ISSUE_CREATION_MODES).optional(),
+      status: z10.enum(ORGANIZATION_STATUSES).optional(),
+      spentMonthlyCents: z10.number().int().nonnegative().optional(),
+      requireBoardApprovalForNewAgents: z10.boolean().optional(),
+      defaultChatIssueCreationMode: z10.enum(CHAT_ISSUE_CREATION_MODES).optional(),
       brandColor: brandColorSchema,
       logoAssetId: logoAssetIdSchema
     });
-    updateOrganizationBrandingSchema = z9.object({
-      name: z9.string().min(1).optional(),
-      description: z9.string().nullable().optional(),
+    updateOrganizationBrandingSchema = z10.object({
+      name: z10.string().min(1).optional(),
+      description: z10.string().nullable().optional(),
       brandColor: brandColorSchema,
       logoAssetId: logoAssetIdSchema
     }).strict().refine((value) => value.name !== void 0 || value.description !== void 0 || value.brandColor !== void 0 || value.logoAssetId !== void 0, "At least one branding field must be provided");
-    updateOrganizationWorkspaceFileSchema = z9.object({
-      content: z9.string(),
-      expectedContent: z9.string().optional()
+    updateOrganizationWorkspaceFileSchema = z10.object({
+      content: z10.string(),
+      expectedContent: z10.string().optional()
     });
-    workspaceWebPreviewNetworkModeSchema = z9.enum(["offline", "connected"]);
-    createOrganizationWorkspaceWebPreviewSessionSchema = z9.object({
-      entryPath: z9.string().trim().min(1).max(1e3),
+    workspaceWebPreviewNetworkModeSchema = z10.enum(["offline", "connected"]);
+    createOrganizationWorkspaceWebPreviewSessionSchema = z10.object({
+      entryPath: z10.string().trim().min(1).max(1e3),
       networkMode: workspaceWebPreviewNetworkModeSchema,
-      htmlContent: z9.string().optional()
+      htmlContent: z10.string().optional()
     });
-    createOrganizationWorkspaceFileSchema = z9.object({
-      filePath: z9.string().trim().min(1).max(1e3),
-      content: z9.string().optional().default("")
+    createOrganizationWorkspaceFileSchema = z10.object({
+      filePath: z10.string().trim().min(1).max(1e3),
+      content: z10.string().optional().default("")
     });
-    createOrganizationWorkspaceDirectorySchema = z9.object({
-      directoryPath: z9.string().trim().min(1).max(1e3)
+    createOrganizationWorkspaceDirectorySchema = z10.object({
+      directoryPath: z10.string().trim().min(1).max(1e3)
     });
-    renameOrganizationWorkspaceEntrySchema = z9.object({
-      name: z9.string().trim().min(1).max(255)
+    renameOrganizationWorkspaceEntrySchema = z10.object({
+      name: z10.string().trim().min(1).max(255)
     });
-    moveOrganizationWorkspaceEntrySchema = z9.object({
-      destinationDirectoryPath: z9.string().trim().max(1e3).default("")
+    moveOrganizationWorkspaceEntrySchema = z10.object({
+      destinationDirectoryPath: z10.string().trim().max(1e3).default("")
     });
-    copyOrganizationWorkspaceEntrySchema = z9.object({
-      destinationDirectoryPath: z9.string().trim().max(1e3).optional()
+    copyOrganizationWorkspaceEntrySchema = z10.object({
+      destinationDirectoryPath: z10.string().trim().max(1e3).optional()
     });
   }
 });
 
 // ../packages/shared/dist/validators/organization-portability.js
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var portabilityIncludeSchema, portabilityEnvInputSchema, portabilityFileEntrySchema, portabilityOrganizationManifestEntrySchema, portabilitySidebarOrderSchema, portabilityAgentManifestEntrySchema, portabilitySkillManifestEntrySchema, portabilityProjectManifestEntrySchema, portabilityIssueAutomationTriggerManifestEntrySchema, portabilityIssueAutomationManifestEntrySchema, portabilityIssueManifestEntrySchema, portabilityManifestSchema, portabilitySourceSchema, portabilityTargetSchema, portabilityAgentSelectionSchema, portabilityCollisionStrategySchema, organizationPortabilityExportSchema, organizationPortabilityPreviewSchema, portabilityAdapterOverrideSchema, organizationPortabilityImportSchema;
 var init_organization_portability = __esm({
   "../packages/shared/dist/validators/organization-portability.js"() {
     "use strict";
     init_organization();
-    portabilityIncludeSchema = z10.object({
-      organization: z10.boolean().optional(),
-      agents: z10.boolean().optional(),
-      projects: z10.boolean().optional(),
-      issues: z10.boolean().optional(),
-      skills: z10.boolean().optional()
+    portabilityIncludeSchema = z11.object({
+      organization: z11.boolean().optional(),
+      agents: z11.boolean().optional(),
+      projects: z11.boolean().optional(),
+      issues: z11.boolean().optional(),
+      skills: z11.boolean().optional()
     }).partial();
-    portabilityEnvInputSchema = z10.object({
-      key: z10.string().min(1),
-      description: z10.string().nullable(),
-      agentSlug: z10.string().min(1).nullable(),
-      kind: z10.enum(["secret", "plain"]),
-      requirement: z10.enum(["required", "optional"]),
-      defaultValue: z10.string().nullable(),
-      portability: z10.enum(["portable", "system_dependent"])
+    portabilityEnvInputSchema = z11.object({
+      key: z11.string().min(1),
+      description: z11.string().nullable(),
+      agentSlug: z11.string().min(1).nullable(),
+      kind: z11.enum(["secret", "plain"]),
+      requirement: z11.enum(["required", "optional"]),
+      defaultValue: z11.string().nullable(),
+      portability: z11.enum(["portable", "system_dependent"])
     });
-    portabilityFileEntrySchema = z10.union([
-      z10.string(),
-      z10.object({
-        encoding: z10.literal("base64"),
-        data: z10.string(),
-        contentType: z10.string().min(1).optional().nullable()
+    portabilityFileEntrySchema = z11.union([
+      z11.string(),
+      z11.object({
+        encoding: z11.literal("base64"),
+        data: z11.string(),
+        contentType: z11.string().min(1).optional().nullable()
       })
     ]);
-    portabilityOrganizationManifestEntrySchema = z10.object({
-      path: z10.string().min(1),
-      name: z10.string().min(1),
-      description: z10.string().nullable(),
-      brandColor: z10.string().nullable(),
-      logoPath: z10.string().nullable(),
-      requireBoardApprovalForNewAgents: z10.boolean()
+    portabilityOrganizationManifestEntrySchema = z11.object({
+      path: z11.string().min(1),
+      name: z11.string().min(1),
+      description: z11.string().nullable(),
+      brandColor: z11.string().nullable(),
+      logoPath: z11.string().nullable(),
+      requireBoardApprovalForNewAgents: z11.boolean()
     });
-    portabilitySidebarOrderSchema = z10.object({
-      agents: z10.array(z10.string().min(1)).default([]),
-      projects: z10.array(z10.string().min(1)).default([])
+    portabilitySidebarOrderSchema = z11.object({
+      agents: z11.array(z11.string().min(1)).default([]),
+      projects: z11.array(z11.string().min(1)).default([])
     });
-    portabilityAgentManifestEntrySchema = z10.object({
-      slug: z10.string().min(1),
-      name: z10.string().min(1),
-      path: z10.string().min(1),
-      skills: z10.array(z10.string().min(1)).default([]),
-      role: z10.string().min(1),
-      title: z10.string().nullable(),
-      icon: z10.string().nullable(),
-      capabilities: z10.string().nullable(),
-      reportsToSlug: z10.string().min(1).nullable(),
-      agentRuntimeType: z10.string().min(1),
-      agentRuntimeConfig: z10.record(z10.unknown()),
-      runtimeConfig: z10.record(z10.unknown()),
-      permissions: z10.record(z10.unknown()),
-      budgetMonthlyCents: z10.number().int().nonnegative(),
-      metadata: z10.record(z10.unknown()).nullable()
+    portabilityAgentManifestEntrySchema = z11.object({
+      slug: z11.string().min(1),
+      name: z11.string().min(1),
+      path: z11.string().min(1),
+      skills: z11.array(z11.string().min(1)).default([]),
+      role: z11.string().min(1),
+      title: z11.string().nullable(),
+      icon: z11.string().nullable(),
+      capabilities: z11.string().nullable(),
+      reportsToSlug: z11.string().min(1).nullable(),
+      agentRuntimeType: z11.string().min(1),
+      agentRuntimeConfig: z11.record(z11.unknown()),
+      runtimeConfig: z11.record(z11.unknown()),
+      permissions: z11.record(z11.unknown()),
+      budgetMonthlyCents: z11.number().int().nonnegative(),
+      metadata: z11.record(z11.unknown()).nullable()
     });
-    portabilitySkillManifestEntrySchema = z10.object({
-      key: z10.string().min(1),
-      slug: z10.string().min(1),
-      name: z10.string().min(1),
-      path: z10.string().min(1),
-      description: z10.string().nullable(),
-      sourceType: z10.string().min(1),
-      sourceLocator: z10.string().nullable(),
-      sourceRef: z10.string().nullable(),
-      trustLevel: z10.string().nullable(),
-      compatibility: z10.string().nullable(),
-      metadata: z10.record(z10.unknown()).nullable(),
-      fileInventory: z10.array(z10.object({
-        path: z10.string().min(1),
-        kind: z10.string().min(1)
+    portabilitySkillManifestEntrySchema = z11.object({
+      key: z11.string().min(1),
+      slug: z11.string().min(1),
+      name: z11.string().min(1),
+      path: z11.string().min(1),
+      description: z11.string().nullable(),
+      sourceType: z11.string().min(1),
+      sourceLocator: z11.string().nullable(),
+      sourceRef: z11.string().nullable(),
+      trustLevel: z11.string().nullable(),
+      compatibility: z11.string().nullable(),
+      metadata: z11.record(z11.unknown()).nullable(),
+      fileInventory: z11.array(z11.object({
+        path: z11.string().min(1),
+        kind: z11.string().min(1)
       })).default([])
     });
-    portabilityProjectManifestEntrySchema = z10.object({
-      slug: z10.string().min(1),
-      name: z10.string().min(1),
-      path: z10.string().min(1),
-      description: z10.string().nullable(),
-      ownerAgentSlug: z10.string().min(1).nullable(),
-      leadAgentSlug: z10.string().min(1).nullable(),
-      targetDate: z10.string().nullable(),
-      color: z10.string().nullable(),
-      status: z10.string().nullable(),
-      executionWorkspacePolicy: z10.record(z10.unknown()).nullable(),
-      workspaces: z10.array(z10.object({
-        key: z10.string().min(1),
-        name: z10.string().min(1),
-        sourceType: z10.string().nullable(),
-        repoUrl: z10.string().nullable(),
-        repoRef: z10.string().nullable(),
-        defaultRef: z10.string().nullable(),
-        visibility: z10.string().nullable(),
-        setupCommand: z10.string().nullable(),
-        cleanupCommand: z10.string().nullable(),
-        metadata: z10.record(z10.unknown()).nullable(),
-        isPrimary: z10.boolean()
+    portabilityProjectManifestEntrySchema = z11.object({
+      slug: z11.string().min(1),
+      name: z11.string().min(1),
+      path: z11.string().min(1),
+      description: z11.string().nullable(),
+      ownerAgentSlug: z11.string().min(1).nullable(),
+      leadAgentSlug: z11.string().min(1).nullable(),
+      targetDate: z11.string().nullable(),
+      color: z11.string().nullable(),
+      status: z11.string().nullable(),
+      executionWorkspacePolicy: z11.record(z11.unknown()).nullable(),
+      workspaces: z11.array(z11.object({
+        key: z11.string().min(1),
+        name: z11.string().min(1),
+        sourceType: z11.string().nullable(),
+        repoUrl: z11.string().nullable(),
+        repoRef: z11.string().nullable(),
+        defaultRef: z11.string().nullable(),
+        visibility: z11.string().nullable(),
+        setupCommand: z11.string().nullable(),
+        cleanupCommand: z11.string().nullable(),
+        metadata: z11.record(z11.unknown()).nullable(),
+        isPrimary: z11.boolean()
       })).default([]),
-      metadata: z10.record(z10.unknown()).nullable()
+      metadata: z11.record(z11.unknown()).nullable()
     });
-    portabilityIssueAutomationTriggerManifestEntrySchema = z10.object({
-      kind: z10.string().min(1),
-      label: z10.string().nullable(),
-      enabled: z10.boolean(),
-      cronExpression: z10.string().nullable(),
-      timezone: z10.string().nullable(),
-      signingMode: z10.string().nullable(),
-      replayWindowSec: z10.number().int().nullable()
+    portabilityIssueAutomationTriggerManifestEntrySchema = z11.object({
+      kind: z11.string().min(1),
+      label: z11.string().nullable(),
+      enabled: z11.boolean(),
+      cronExpression: z11.string().nullable(),
+      timezone: z11.string().nullable(),
+      signingMode: z11.string().nullable(),
+      replayWindowSec: z11.number().int().nullable()
     });
-    portabilityIssueAutomationManifestEntrySchema = z10.object({
-      concurrencyPolicy: z10.string().nullable(),
-      catchUpPolicy: z10.string().nullable(),
-      triggers: z10.array(portabilityIssueAutomationTriggerManifestEntrySchema).default([])
+    portabilityIssueAutomationManifestEntrySchema = z11.object({
+      concurrencyPolicy: z11.string().nullable(),
+      catchUpPolicy: z11.string().nullable(),
+      triggers: z11.array(portabilityIssueAutomationTriggerManifestEntrySchema).default([])
     });
-    portabilityIssueManifestEntrySchema = z10.object({
-      slug: z10.string().min(1),
-      identifier: z10.string().min(1).nullable(),
-      title: z10.string().min(1),
-      path: z10.string().min(1),
-      projectSlug: z10.string().min(1).nullable(),
-      projectWorkspaceKey: z10.string().min(1).nullable(),
-      assigneeAgentSlug: z10.string().min(1).nullable(),
-      description: z10.string().nullable(),
-      recurring: z10.boolean().default(false),
+    portabilityIssueManifestEntrySchema = z11.object({
+      slug: z11.string().min(1),
+      identifier: z11.string().min(1).nullable(),
+      title: z11.string().min(1),
+      path: z11.string().min(1),
+      projectSlug: z11.string().min(1).nullable(),
+      projectWorkspaceKey: z11.string().min(1).nullable(),
+      assigneeAgentSlug: z11.string().min(1).nullable(),
+      description: z11.string().nullable(),
+      recurring: z11.boolean().default(false),
       automation: portabilityIssueAutomationManifestEntrySchema.nullable(),
-      legacyRecurrence: z10.record(z10.unknown()).nullable(),
-      status: z10.string().nullable(),
-      priority: z10.string().nullable(),
-      labelIds: z10.array(z10.string().min(1)).default([]),
-      billingCode: z10.string().nullable(),
-      executionWorkspaceSettings: z10.record(z10.unknown()).nullable(),
-      assigneeAgentRuntimeOverrides: z10.record(z10.unknown()).nullable(),
-      metadata: z10.record(z10.unknown()).nullable()
+      legacyRecurrence: z11.record(z11.unknown()).nullable(),
+      status: z11.string().nullable(),
+      priority: z11.string().nullable(),
+      labelIds: z11.array(z11.string().min(1)).default([]),
+      billingCode: z11.string().nullable(),
+      executionWorkspaceSettings: z11.record(z11.unknown()).nullable(),
+      assigneeAgentRuntimeOverrides: z11.record(z11.unknown()).nullable(),
+      metadata: z11.record(z11.unknown()).nullable()
     });
-    portabilityManifestSchema = z10.object({
-      schemaVersion: z10.number().int().positive(),
-      generatedAt: z10.string().datetime(),
-      source: z10.object({
-        orgId: z10.string().uuid(),
-        organizationName: z10.string().min(1)
+    portabilityManifestSchema = z11.object({
+      schemaVersion: z11.number().int().positive(),
+      generatedAt: z11.string().datetime(),
+      source: z11.object({
+        orgId: z11.string().uuid(),
+        organizationName: z11.string().min(1)
       }).nullable(),
-      includes: z10.object({
-        organization: z10.boolean(),
-        agents: z10.boolean(),
-        projects: z10.boolean(),
-        issues: z10.boolean(),
-        skills: z10.boolean()
+      includes: z11.object({
+        organization: z11.boolean(),
+        agents: z11.boolean(),
+        projects: z11.boolean(),
+        issues: z11.boolean(),
+        skills: z11.boolean()
       }),
       organization: portabilityOrganizationManifestEntrySchema.nullable(),
       sidebar: portabilitySidebarOrderSchema.nullable(),
-      agents: z10.array(portabilityAgentManifestEntrySchema),
-      skills: z10.array(portabilitySkillManifestEntrySchema).default([]),
-      projects: z10.array(portabilityProjectManifestEntrySchema).default([]),
-      issues: z10.array(portabilityIssueManifestEntrySchema).default([]),
-      envInputs: z10.array(portabilityEnvInputSchema).default([])
+      agents: z11.array(portabilityAgentManifestEntrySchema),
+      skills: z11.array(portabilitySkillManifestEntrySchema).default([]),
+      projects: z11.array(portabilityProjectManifestEntrySchema).default([]),
+      issues: z11.array(portabilityIssueManifestEntrySchema).default([]),
+      envInputs: z11.array(portabilityEnvInputSchema).default([])
     });
-    portabilitySourceSchema = z10.discriminatedUnion("type", [
-      z10.object({
-        type: z10.literal("inline"),
-        rootPath: z10.string().min(1).optional().nullable(),
-        files: z10.record(portabilityFileEntrySchema)
+    portabilitySourceSchema = z11.discriminatedUnion("type", [
+      z11.object({
+        type: z11.literal("inline"),
+        rootPath: z11.string().min(1).optional().nullable(),
+        files: z11.record(portabilityFileEntrySchema)
       }),
-      z10.object({
-        type: z10.literal("github"),
-        url: z10.string().url()
+      z11.object({
+        type: z11.literal("github"),
+        url: z11.string().url()
       })
     ]);
-    portabilityTargetSchema = z10.discriminatedUnion("mode", [
-      z10.object({
-        mode: z10.literal("new_organization"),
-        newOrganizationName: z10.string().min(1).optional().nullable(),
+    portabilityTargetSchema = z11.discriminatedUnion("mode", [
+      z11.object({
+        mode: z11.literal("new_organization"),
+        newOrganizationName: z11.string().min(1).optional().nullable(),
         newOrganizationIssueKey: organizationIssueKeySchema.optional().nullable()
       }),
-      z10.object({
-        mode: z10.literal("existing_organization"),
-        orgId: z10.string().uuid()
+      z11.object({
+        mode: z11.literal("existing_organization"),
+        orgId: z11.string().uuid()
       })
     ]);
-    portabilityAgentSelectionSchema = z10.union([
-      z10.literal("all"),
-      z10.array(z10.string().min(1))
+    portabilityAgentSelectionSchema = z11.union([
+      z11.literal("all"),
+      z11.array(z11.string().min(1))
     ]);
-    portabilityCollisionStrategySchema = z10.enum(["rename", "skip", "replace"]);
-    organizationPortabilityExportSchema = z10.object({
+    portabilityCollisionStrategySchema = z11.enum(["rename", "skip", "replace"]);
+    organizationPortabilityExportSchema = z11.object({
       include: portabilityIncludeSchema.optional(),
-      agents: z10.array(z10.string().min(1)).optional(),
-      skills: z10.array(z10.string().min(1)).optional(),
-      projects: z10.array(z10.string().min(1)).optional(),
-      issues: z10.array(z10.string().min(1)).optional(),
-      projectIssues: z10.array(z10.string().min(1)).optional(),
-      selectedFiles: z10.array(z10.string().min(1)).optional(),
-      expandReferencedSkills: z10.boolean().optional(),
+      agents: z11.array(z11.string().min(1)).optional(),
+      skills: z11.array(z11.string().min(1)).optional(),
+      projects: z11.array(z11.string().min(1)).optional(),
+      issues: z11.array(z11.string().min(1)).optional(),
+      projectIssues: z11.array(z11.string().min(1)).optional(),
+      selectedFiles: z11.array(z11.string().min(1)).optional(),
+      expandReferencedSkills: z11.boolean().optional(),
       sidebarOrder: portabilitySidebarOrderSchema.partial().optional()
     });
-    organizationPortabilityPreviewSchema = z10.object({
+    organizationPortabilityPreviewSchema = z11.object({
       source: portabilitySourceSchema,
       include: portabilityIncludeSchema.optional(),
       target: portabilityTargetSchema,
       agents: portabilityAgentSelectionSchema.optional(),
       collisionStrategy: portabilityCollisionStrategySchema.optional(),
-      nameOverrides: z10.record(z10.string().min(1), z10.string().min(1)).optional(),
-      selectedFiles: z10.array(z10.string().min(1)).optional()
+      nameOverrides: z11.record(z11.string().min(1), z11.string().min(1)).optional(),
+      selectedFiles: z11.array(z11.string().min(1)).optional()
     });
-    portabilityAdapterOverrideSchema = z10.object({
-      agentRuntimeType: z10.string().min(1),
-      agentRuntimeConfig: z10.record(z10.unknown()).optional()
+    portabilityAdapterOverrideSchema = z11.object({
+      agentRuntimeType: z11.string().min(1),
+      agentRuntimeConfig: z11.record(z11.unknown()).optional()
     });
     organizationPortabilityImportSchema = organizationPortabilityPreviewSchema.extend({
-      agentRuntimeOverrides: z10.record(z10.string().min(1), portabilityAdapterOverrideSchema).optional()
+      agentRuntimeOverrides: z11.record(z11.string().min(1), portabilityAdapterOverrideSchema).optional()
     });
   }
 });
 
 // ../packages/shared/dist/validators/organization-skill.js
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var organizationSkillSourceTypeSchema, organizationSkillTrustLevelSchema, organizationSkillCompatibilitySchema, organizationSkillSourceBadgeSchema, organizationSkillFileInventoryEntrySchema, organizationSkillSchema, organizationSkillListItemSchema, organizationSkillUsageAgentSchema, organizationSkillDetailSchema, organizationSkillUpdateStatusSchema, organizationSkillImportSchema, organizationSkillProjectScanRequestSchema, organizationSkillProjectScanSkippedSchema, organizationSkillProjectScanConflictSchema, organizationSkillProjectScanResultSchema, organizationSkillLocalScanRequestSchema, organizationSkillLocalScanSkippedSchema, organizationSkillLocalScanConflictSchema, organizationSkillLocalScanResultSchema, organizationSkillCreateSchema, organizationSkillFileDetailSchema, organizationSkillFileUpdateSchema;
 var init_organization_skill = __esm({
   "../packages/shared/dist/validators/organization-skill.js"() {
     "use strict";
-    organizationSkillSourceTypeSchema = z11.enum(["local_path", "github", "url", "catalog", "skills_sh"]);
-    organizationSkillTrustLevelSchema = z11.enum(["markdown_only", "assets", "scripts_executables"]);
-    organizationSkillCompatibilitySchema = z11.enum(["compatible", "unknown", "invalid"]);
-    organizationSkillSourceBadgeSchema = z11.enum([
+    organizationSkillSourceTypeSchema = z12.enum(["local_path", "github", "url", "catalog", "skills_sh"]);
+    organizationSkillTrustLevelSchema = z12.enum(["markdown_only", "assets", "scripts_executables"]);
+    organizationSkillCompatibilitySchema = z12.enum(["compatible", "unknown", "invalid"]);
+    organizationSkillSourceBadgeSchema = z12.enum([
       "rudder",
       "community",
       "github",
@@ -1697,152 +1869,152 @@ var init_organization_skill = __esm({
       "catalog",
       "skills_sh"
     ]);
-    organizationSkillFileInventoryEntrySchema = z11.object({
-      path: z11.string().min(1),
-      kind: z11.enum(["skill", "markdown", "reference", "script", "asset", "other"])
+    organizationSkillFileInventoryEntrySchema = z12.object({
+      path: z12.string().min(1),
+      kind: z12.enum(["skill", "markdown", "reference", "script", "asset", "other"])
     });
-    organizationSkillSchema = z11.object({
-      id: z11.string().uuid(),
-      orgId: z11.string().uuid(),
-      key: z11.string().min(1),
-      slug: z11.string().min(1),
-      name: z11.string().min(1),
-      description: z11.string().nullable(),
-      markdown: z11.string(),
+    organizationSkillSchema = z12.object({
+      id: z12.string().uuid(),
+      orgId: z12.string().uuid(),
+      key: z12.string().min(1),
+      slug: z12.string().min(1),
+      name: z12.string().min(1),
+      description: z12.string().nullable(),
+      markdown: z12.string(),
       sourceType: organizationSkillSourceTypeSchema,
-      sourceLocator: z11.string().nullable(),
-      sourceRef: z11.string().nullable(),
+      sourceLocator: z12.string().nullable(),
+      sourceRef: z12.string().nullable(),
       trustLevel: organizationSkillTrustLevelSchema,
       compatibility: organizationSkillCompatibilitySchema,
-      fileInventory: z11.array(organizationSkillFileInventoryEntrySchema).default([]),
-      metadata: z11.record(z11.unknown()).nullable(),
-      createdAt: z11.coerce.date(),
-      updatedAt: z11.coerce.date()
+      fileInventory: z12.array(organizationSkillFileInventoryEntrySchema).default([]),
+      metadata: z12.record(z12.unknown()).nullable(),
+      createdAt: z12.coerce.date(),
+      updatedAt: z12.coerce.date()
     });
     organizationSkillListItemSchema = organizationSkillSchema.extend({
-      attachedAgentCount: z11.number().int().nonnegative(),
-      editable: z11.boolean(),
-      editableReason: z11.string().nullable(),
-      sourceLabel: z11.string().nullable(),
+      attachedAgentCount: z12.number().int().nonnegative(),
+      editable: z12.boolean(),
+      editableReason: z12.string().nullable(),
+      sourceLabel: z12.string().nullable(),
       sourceBadge: organizationSkillSourceBadgeSchema,
-      sourcePath: z11.string().nullable(),
-      workspaceEditPath: z11.string().nullable()
+      sourcePath: z12.string().nullable(),
+      workspaceEditPath: z12.string().nullable()
     });
-    organizationSkillUsageAgentSchema = z11.object({
-      id: z11.string().uuid(),
-      name: z11.string().min(1),
-      urlKey: z11.string().min(1),
-      agentRuntimeType: z11.string().min(1),
-      desired: z11.boolean(),
-      actualState: z11.string().nullable()
+    organizationSkillUsageAgentSchema = z12.object({
+      id: z12.string().uuid(),
+      name: z12.string().min(1),
+      urlKey: z12.string().min(1),
+      agentRuntimeType: z12.string().min(1),
+      desired: z12.boolean(),
+      actualState: z12.string().nullable()
     });
     organizationSkillDetailSchema = organizationSkillSchema.extend({
-      attachedAgentCount: z11.number().int().nonnegative(),
-      usedByAgents: z11.array(organizationSkillUsageAgentSchema).default([]),
-      editable: z11.boolean(),
-      editableReason: z11.string().nullable(),
-      sourceLabel: z11.string().nullable(),
+      attachedAgentCount: z12.number().int().nonnegative(),
+      usedByAgents: z12.array(organizationSkillUsageAgentSchema).default([]),
+      editable: z12.boolean(),
+      editableReason: z12.string().nullable(),
+      sourceLabel: z12.string().nullable(),
       sourceBadge: organizationSkillSourceBadgeSchema,
-      sourcePath: z11.string().nullable(),
-      workspaceEditPath: z11.string().nullable()
+      sourcePath: z12.string().nullable(),
+      workspaceEditPath: z12.string().nullable()
     });
-    organizationSkillUpdateStatusSchema = z11.object({
-      supported: z11.boolean(),
-      reason: z11.string().nullable(),
-      trackingRef: z11.string().nullable(),
-      currentRef: z11.string().nullable(),
-      latestRef: z11.string().nullable(),
-      hasUpdate: z11.boolean()
+    organizationSkillUpdateStatusSchema = z12.object({
+      supported: z12.boolean(),
+      reason: z12.string().nullable(),
+      trackingRef: z12.string().nullable(),
+      currentRef: z12.string().nullable(),
+      latestRef: z12.string().nullable(),
+      hasUpdate: z12.boolean()
     });
-    organizationSkillImportSchema = z11.object({
-      source: z11.string().min(1)
+    organizationSkillImportSchema = z12.object({
+      source: z12.string().min(1)
     });
-    organizationSkillProjectScanRequestSchema = z11.object({
-      projectIds: z11.array(z11.string().uuid()).optional(),
-      workspaceIds: z11.array(z11.string().uuid()).optional()
+    organizationSkillProjectScanRequestSchema = z12.object({
+      projectIds: z12.array(z12.string().uuid()).optional(),
+      workspaceIds: z12.array(z12.string().uuid()).optional()
     });
-    organizationSkillProjectScanSkippedSchema = z11.object({
-      projectId: z11.string().uuid(),
-      projectName: z11.string().min(1),
-      workspaceId: z11.string().uuid().nullable(),
-      workspaceName: z11.string().nullable(),
-      path: z11.string().nullable(),
-      reason: z11.string().min(1)
+    organizationSkillProjectScanSkippedSchema = z12.object({
+      projectId: z12.string().uuid(),
+      projectName: z12.string().min(1),
+      workspaceId: z12.string().uuid().nullable(),
+      workspaceName: z12.string().nullable(),
+      path: z12.string().nullable(),
+      reason: z12.string().min(1)
     });
-    organizationSkillProjectScanConflictSchema = z11.object({
-      slug: z11.string().min(1),
-      key: z11.string().min(1),
-      projectId: z11.string().uuid(),
-      projectName: z11.string().min(1),
-      workspaceId: z11.string().uuid(),
-      workspaceName: z11.string().min(1),
-      path: z11.string().min(1),
-      existingSkillId: z11.string().uuid(),
-      existingSkillKey: z11.string().min(1),
-      existingSourceLocator: z11.string().nullable(),
-      reason: z11.string().min(1)
+    organizationSkillProjectScanConflictSchema = z12.object({
+      slug: z12.string().min(1),
+      key: z12.string().min(1),
+      projectId: z12.string().uuid(),
+      projectName: z12.string().min(1),
+      workspaceId: z12.string().uuid(),
+      workspaceName: z12.string().min(1),
+      path: z12.string().min(1),
+      existingSkillId: z12.string().uuid(),
+      existingSkillKey: z12.string().min(1),
+      existingSourceLocator: z12.string().nullable(),
+      reason: z12.string().min(1)
     });
-    organizationSkillProjectScanResultSchema = z11.object({
-      scannedProjects: z11.number().int().nonnegative(),
-      scannedWorkspaces: z11.number().int().nonnegative(),
-      discovered: z11.number().int().nonnegative(),
-      imported: z11.array(organizationSkillSchema),
-      updated: z11.array(organizationSkillSchema),
-      skipped: z11.array(organizationSkillProjectScanSkippedSchema),
-      conflicts: z11.array(organizationSkillProjectScanConflictSchema),
-      warnings: z11.array(z11.string())
+    organizationSkillProjectScanResultSchema = z12.object({
+      scannedProjects: z12.number().int().nonnegative(),
+      scannedWorkspaces: z12.number().int().nonnegative(),
+      discovered: z12.number().int().nonnegative(),
+      imported: z12.array(organizationSkillSchema),
+      updated: z12.array(organizationSkillSchema),
+      skipped: z12.array(organizationSkillProjectScanSkippedSchema),
+      conflicts: z12.array(organizationSkillProjectScanConflictSchema),
+      warnings: z12.array(z12.string())
     });
-    organizationSkillLocalScanRequestSchema = z11.object({
-      roots: z11.array(z11.string().min(1)).optional()
+    organizationSkillLocalScanRequestSchema = z12.object({
+      roots: z12.array(z12.string().min(1)).optional()
     });
-    organizationSkillLocalScanSkippedSchema = z11.object({
-      root: z11.string().min(1),
-      path: z11.string().nullable(),
-      reason: z11.string().min(1)
+    organizationSkillLocalScanSkippedSchema = z12.object({
+      root: z12.string().min(1),
+      path: z12.string().nullable(),
+      reason: z12.string().min(1)
     });
-    organizationSkillLocalScanConflictSchema = z11.object({
-      root: z11.string().min(1),
-      path: z11.string().min(1),
-      slug: z11.string().min(1),
-      key: z11.string().min(1),
-      existingSkillId: z11.string().uuid(),
-      existingSkillKey: z11.string().min(1),
-      existingSourceLocator: z11.string().nullable(),
-      reason: z11.string().min(1)
+    organizationSkillLocalScanConflictSchema = z12.object({
+      root: z12.string().min(1),
+      path: z12.string().min(1),
+      slug: z12.string().min(1),
+      key: z12.string().min(1),
+      existingSkillId: z12.string().uuid(),
+      existingSkillKey: z12.string().min(1),
+      existingSourceLocator: z12.string().nullable(),
+      reason: z12.string().min(1)
     });
-    organizationSkillLocalScanResultSchema = z11.object({
-      scannedRoots: z11.number().int().nonnegative(),
-      discovered: z11.number().int().nonnegative(),
-      imported: z11.array(organizationSkillSchema),
-      updated: z11.array(organizationSkillSchema),
-      skipped: z11.array(organizationSkillLocalScanSkippedSchema),
-      conflicts: z11.array(organizationSkillLocalScanConflictSchema),
-      warnings: z11.array(z11.string())
+    organizationSkillLocalScanResultSchema = z12.object({
+      scannedRoots: z12.number().int().nonnegative(),
+      discovered: z12.number().int().nonnegative(),
+      imported: z12.array(organizationSkillSchema),
+      updated: z12.array(organizationSkillSchema),
+      skipped: z12.array(organizationSkillLocalScanSkippedSchema),
+      conflicts: z12.array(organizationSkillLocalScanConflictSchema),
+      warnings: z12.array(z12.string())
     });
-    organizationSkillCreateSchema = z11.object({
-      name: z11.string().min(1),
-      slug: z11.string().min(1).nullable().optional(),
-      description: z11.string().nullable().optional(),
-      markdown: z11.string().nullable().optional()
+    organizationSkillCreateSchema = z12.object({
+      name: z12.string().min(1),
+      slug: z12.string().min(1).nullable().optional(),
+      description: z12.string().nullable().optional(),
+      markdown: z12.string().nullable().optional()
     });
-    organizationSkillFileDetailSchema = z11.object({
-      skillId: z11.string().uuid(),
-      path: z11.string().min(1),
-      kind: z11.enum(["skill", "markdown", "reference", "script", "asset", "other"]),
-      content: z11.string(),
-      language: z11.string().nullable(),
-      markdown: z11.boolean(),
-      editable: z11.boolean()
+    organizationSkillFileDetailSchema = z12.object({
+      skillId: z12.string().uuid(),
+      path: z12.string().min(1),
+      kind: z12.enum(["skill", "markdown", "reference", "script", "asset", "other"]),
+      content: z12.string(),
+      language: z12.string().nullable(),
+      markdown: z12.boolean(),
+      editable: z12.boolean()
     });
-    organizationSkillFileUpdateSchema = z11.object({
-      path: z11.string().min(1),
-      content: z11.string()
+    organizationSkillFileUpdateSchema = z12.object({
+      path: z12.string().min(1),
+      content: z12.string()
     });
   }
 });
 
 // ../packages/shared/dist/validators/resource.js
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 function isValidLibraryProjectPath(locator, kind) {
   const trimmed = locator.trim();
   if (!trimmed)
@@ -1865,14 +2037,14 @@ function validateLibraryResourceContract(value, ctx) {
     return;
   if (value.kind !== void 0 && value.kind !== "file" && value.kind !== "directory") {
     ctx.addIssue({
-      code: z12.ZodIssueCode.custom,
+      code: z13.ZodIssueCode.custom,
       message: "Library resources must be file or directory resources.",
       path: ["kind"]
     });
   }
   if (value.locator !== void 0 && !isValidLibraryProjectPath(value.locator, value.kind)) {
     ctx.addIssue({
-      code: z12.ZodIssueCode.custom,
+      code: z13.ZodIssueCode.custom,
       message: "Library resource locator must be a normalized project Library path.",
       path: ["locator"]
     });
@@ -1883,78 +2055,78 @@ var init_resource = __esm({
   "../packages/shared/dist/validators/resource.js"() {
     "use strict";
     init_constants();
-    organizationResourceKindSchema = z12.enum(ORGANIZATION_RESOURCE_KINDS);
-    organizationResourceSourceTypeSchema = z12.enum(ORGANIZATION_RESOURCE_SOURCE_TYPES);
-    projectResourceAttachmentRoleSchema = z12.enum(PROJECT_RESOURCE_ATTACHMENT_ROLES);
+    organizationResourceKindSchema = z13.enum(ORGANIZATION_RESOURCE_KINDS);
+    organizationResourceSourceTypeSchema = z13.enum(ORGANIZATION_RESOURCE_SOURCE_TYPES);
+    projectResourceAttachmentRoleSchema = z13.enum(PROJECT_RESOURCE_ATTACHMENT_ROLES);
     LIBRARY_PATH_SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
-    createOrganizationResourceBaseSchema = z12.object({
-      name: z12.string().min(1),
+    createOrganizationResourceBaseSchema = z13.object({
+      name: z13.string().min(1),
       kind: organizationResourceKindSchema,
       sourceType: organizationResourceSourceTypeSchema.optional().default("external"),
-      locator: z12.string().min(1),
-      description: z12.string().optional().nullable(),
-      metadata: z12.record(z12.unknown()).optional().nullable()
+      locator: z13.string().min(1),
+      description: z13.string().optional().nullable(),
+      metadata: z13.record(z13.unknown()).optional().nullable()
     });
     createOrganizationResourceSchema = createOrganizationResourceBaseSchema.superRefine(validateLibraryResourceContract);
-    updateOrganizationResourceSchema = z12.object({
-      name: z12.string().min(1).optional(),
+    updateOrganizationResourceSchema = z13.object({
+      name: z13.string().min(1).optional(),
       kind: organizationResourceKindSchema.optional(),
       sourceType: organizationResourceSourceTypeSchema.optional(),
-      locator: z12.string().min(1).optional(),
-      description: z12.string().optional().nullable(),
-      metadata: z12.record(z12.unknown()).optional().nullable()
+      locator: z13.string().min(1).optional(),
+      description: z13.string().optional().nullable(),
+      metadata: z13.record(z13.unknown()).optional().nullable()
     }).strict().superRefine(validateLibraryResourceContract);
-    projectResourceAttachmentInputSchema = z12.object({
-      resourceId: z12.string().uuid(),
+    projectResourceAttachmentInputSchema = z13.object({
+      resourceId: z13.string().uuid(),
       role: projectResourceAttachmentRoleSchema.optional(),
-      note: z12.string().optional().nullable(),
-      sortOrder: z12.number().int().nonnegative().optional()
+      note: z13.string().optional().nullable(),
+      sortOrder: z13.number().int().nonnegative().optional()
     }).strict();
-    updateProjectResourceAttachmentSchema = z12.object({
+    updateProjectResourceAttachmentSchema = z13.object({
       role: projectResourceAttachmentRoleSchema.optional(),
-      note: z12.string().optional().nullable(),
-      sortOrder: z12.number().int().nonnegative().optional()
+      note: z13.string().optional().nullable(),
+      sortOrder: z13.number().int().nonnegative().optional()
     }).strict();
     createProjectInlineResourceSchema = createOrganizationResourceBaseSchema.extend({
       role: projectResourceAttachmentRoleSchema.optional(),
-      note: z12.string().optional().nullable(),
-      sortOrder: z12.number().int().nonnegative().optional()
+      note: z13.string().optional().nullable(),
+      sortOrder: z13.number().int().nonnegative().optional()
     }).strict().superRefine(validateLibraryResourceContract);
   }
 });
 
 // ../packages/shared/dist/validators/agent.js
-import { z as z13 } from "zod";
-var agentPermissionsSchema, agentInstructionsBundleModeSchema, updateAgentInstructionsBundleSchema, upsertAgentInstructionsFileSchema, agentRuntimeConfigSchema, optionalAgentNameSchema, uploadedAgentIconSchema, diceBearNotionistsAgentIconSchema, agentIconSchema, createAgentSchema, createAgentHireSchema, updateAgentSchema, updateAgentInstructionsPathSchema, createAgentKeySchema, wakeAgentSchema, resetAgentSessionSchema, testAgentRuntimeEnvironmentSchema, updateAgentPermissionsSchema;
+import { z as z14 } from "zod";
+var agentPermissionsSchema, agentInstructionsBundleModeSchema, updateAgentInstructionsBundleSchema, upsertAgentInstructionsFileSchema, agentRuntimeConfigSchema, optionalAgentNameSchema, uploadedAgentIconSchema, diceBearNotionistsAgentIconSchema, oreoAgentIconSchema, agentIconSchema, createAgentSchema, createAgentHireSchema, updateAgentSchema, updateAgentInstructionsPathSchema, createAgentKeySchema, wakeAgentSchema, resetAgentSessionSchema, testAgentRuntimeEnvironmentSchema, updateAgentPermissionsSchema;
 var init_agent = __esm({
   "../packages/shared/dist/validators/agent.js"() {
     "use strict";
     init_constants();
     init_model_fallbacks();
     init_secret();
-    agentPermissionsSchema = z13.object({
-      canCreateAgents: z13.boolean().optional().default(true),
-      canManageSkills: z13.boolean().optional().default(true)
+    agentPermissionsSchema = z14.object({
+      canCreateAgents: z14.boolean().optional().default(true),
+      canManageSkills: z14.boolean().optional().default(true)
     });
-    agentInstructionsBundleModeSchema = z13.enum(["managed", "external"]);
-    updateAgentInstructionsBundleSchema = z13.object({
+    agentInstructionsBundleModeSchema = z14.enum(["managed", "external"]);
+    updateAgentInstructionsBundleSchema = z14.object({
       mode: agentInstructionsBundleModeSchema.optional(),
-      rootPath: z13.string().trim().min(1).nullable().optional(),
-      entryFile: z13.string().trim().min(1).optional(),
-      clearLegacyPromptTemplate: z13.boolean().optional().default(false)
+      rootPath: z14.string().trim().min(1).nullable().optional(),
+      entryFile: z14.string().trim().min(1).optional(),
+      clearLegacyPromptTemplate: z14.boolean().optional().default(false)
     });
-    upsertAgentInstructionsFileSchema = z13.object({
-      path: z13.string().trim().min(1),
-      content: z13.string(),
-      clearLegacyPromptTemplate: z13.boolean().optional().default(false)
+    upsertAgentInstructionsFileSchema = z14.object({
+      path: z14.string().trim().min(1),
+      content: z14.string(),
+      clearLegacyPromptTemplate: z14.boolean().optional().default(false)
     });
-    agentRuntimeConfigSchema = z13.record(z13.unknown()).superRefine((value, ctx) => {
+    agentRuntimeConfigSchema = z14.record(z14.unknown()).superRefine((value, ctx) => {
       const envValue = value.env;
       if (envValue !== void 0) {
         const parsed = envConfigSchema.safeParse(envValue);
         if (!parsed.success) {
           ctx.addIssue({
-            code: z13.ZodIssueCode.custom,
+            code: z14.ZodIssueCode.custom,
             message: "agentRuntimeConfig.env must be a map of valid env bindings",
             path: ["env"]
           });
@@ -1962,166 +2134,168 @@ var init_agent = __esm({
       }
       validateModelFallbacksConfig(value, ctx, []);
     });
-    optionalAgentNameSchema = z13.preprocess((value) => {
+    optionalAgentNameSchema = z14.preprocess((value) => {
       if (typeof value !== "string")
         return value;
       const trimmed = value.trim();
       return trimmed.length > 0 ? trimmed : void 0;
-    }, z13.string().trim().min(1).optional());
-    uploadedAgentIconSchema = z13.string().regex(new RegExp(`^asset:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}(?:\\?bg=(?:${AGENT_AVATAR_BACKGROUND_PRESET_IDS.join("|")}))?$`, "i"), "Invalid uploaded avatar reference");
-    diceBearNotionistsAgentIconSchema = z13.string().regex(new RegExp(`^${AGENT_DICEBEAR_NOTIONISTS_ICON_PREFIX}[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}(?:\\?bg=(?:${AGENT_AVATAR_BACKGROUND_PRESET_IDS.join("|")}))?$`, "i"), "Invalid DiceBear avatar reference");
-    agentIconSchema = z13.preprocess((value) => {
+    }, z14.string().trim().min(1).optional());
+    uploadedAgentIconSchema = z14.string().regex(new RegExp(`^asset:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}(?:\\?bg=(?:${AGENT_AVATAR_BACKGROUND_PRESET_IDS.join("|")}))?$`, "i"), "Invalid uploaded avatar reference");
+    diceBearNotionistsAgentIconSchema = z14.string().regex(new RegExp(`^${AGENT_DICEBEAR_NOTIONISTS_ICON_PREFIX}[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}(?:\\?bg=(?:${AGENT_AVATAR_BACKGROUND_PRESET_IDS.join("|")}))?$`, "i"), "Invalid DiceBear avatar reference");
+    oreoAgentIconSchema = z14.string().regex(new RegExp(`^${AGENT_OREO_ICON_PREFIX}(?:${AGENT_OREO_SHAPE_IDS.join("|")}):(?:${AGENT_OREO_PALETTE_IDS.join("|")}):[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$`, "i"), "Invalid Oreo avatar reference");
+    agentIconSchema = z14.preprocess((value) => {
       if (typeof value !== "string")
         return value;
       const trimmed = value.trim();
       return trimmed.length > 0 ? trimmed : null;
-    }, z13.union([
-      z13.enum(AGENT_ICON_NAMES),
+    }, z14.union([
+      z14.enum(AGENT_ICON_NAMES),
+      oreoAgentIconSchema,
       uploadedAgentIconSchema,
       diceBearNotionistsAgentIconSchema
     ]).nullable());
-    createAgentSchema = z13.object({
+    createAgentSchema = z14.object({
       name: optionalAgentNameSchema,
-      role: z13.enum(AGENT_ROLES).optional().default("general"),
-      title: z13.string().optional().nullable(),
+      role: z14.enum(AGENT_ROLES).optional().default("general"),
+      title: z14.string().optional().nullable(),
       icon: agentIconSchema.optional(),
-      reportsTo: z13.string().uuid().optional().nullable(),
-      capabilities: z13.string().optional().nullable(),
-      desiredSkills: z13.array(z13.string().min(1)).optional(),
-      agentRuntimeType: z13.enum(AGENT_RUNTIME_TYPES).optional().default("process"),
+      reportsTo: z14.string().uuid().optional().nullable(),
+      capabilities: z14.string().optional().nullable(),
+      desiredSkills: z14.array(z14.string().min(1)).optional(),
+      agentRuntimeType: z14.enum(AGENT_RUNTIME_TYPES).optional().default("process"),
       agentRuntimeConfig: agentRuntimeConfigSchema.optional().default({}),
-      runtimeConfig: z13.record(z13.unknown()).optional().default({}),
-      budgetMonthlyCents: z13.number().int().nonnegative().optional().default(0),
+      runtimeConfig: z14.record(z14.unknown()).optional().default({}),
+      budgetMonthlyCents: z14.number().int().nonnegative().optional().default(0),
       permissions: agentPermissionsSchema.optional(),
-      metadata: z13.record(z13.unknown()).optional().nullable(),
-      seedOrganizationIntelligenceDefaults: z13.boolean().optional().default(false)
+      metadata: z14.record(z14.unknown()).optional().nullable(),
+      seedOrganizationIntelligenceDefaults: z14.boolean().optional().default(false)
     });
     createAgentHireSchema = createAgentSchema.omit({ seedOrganizationIntelligenceDefaults: true }).extend({
-      sourceIssueId: z13.string().uuid().optional().nullable(),
-      sourceIssueIds: z13.array(z13.string().uuid()).optional()
+      sourceIssueId: z14.string().uuid().optional().nullable(),
+      sourceIssueIds: z14.array(z14.string().uuid()).optional()
     });
     updateAgentSchema = createAgentSchema.omit({ permissions: true, seedOrganizationIntelligenceDefaults: true }).partial().extend({
-      permissions: z13.never().optional(),
-      replaceAgentRuntimeConfig: z13.boolean().optional(),
-      status: z13.enum(AGENT_STATUSES).optional(),
-      spentMonthlyCents: z13.number().int().nonnegative().optional()
+      permissions: z14.never().optional(),
+      replaceAgentRuntimeConfig: z14.boolean().optional(),
+      status: z14.enum(AGENT_STATUSES).optional(),
+      spentMonthlyCents: z14.number().int().nonnegative().optional()
     });
-    updateAgentInstructionsPathSchema = z13.object({
-      path: z13.string().trim().min(1).nullable(),
-      agentRuntimeConfigKey: z13.string().trim().min(1).optional()
+    updateAgentInstructionsPathSchema = z14.object({
+      path: z14.string().trim().min(1).nullable(),
+      agentRuntimeConfigKey: z14.string().trim().min(1).optional()
     });
-    createAgentKeySchema = z13.object({
-      name: z13.string().min(1).default("default")
+    createAgentKeySchema = z14.object({
+      name: z14.string().min(1).default("default")
     });
-    wakeAgentSchema = z13.object({
-      source: z13.enum(["timer", "assignment", "review", "on_demand", "automation"]).optional().default("on_demand"),
-      triggerDetail: z13.enum(["manual", "ping", "callback", "system"]).optional(),
-      reason: z13.string().optional().nullable(),
-      payload: z13.record(z13.unknown()).optional().nullable(),
-      idempotencyKey: z13.string().optional().nullable(),
-      forceFreshSession: z13.preprocess((value) => value === null ? void 0 : value, z13.boolean().optional().default(false))
+    wakeAgentSchema = z14.object({
+      source: z14.enum(["timer", "assignment", "review", "on_demand", "automation"]).optional().default("on_demand"),
+      triggerDetail: z14.enum(["manual", "ping", "callback", "system"]).optional(),
+      reason: z14.string().optional().nullable(),
+      payload: z14.record(z14.unknown()).optional().nullable(),
+      idempotencyKey: z14.string().optional().nullable(),
+      forceFreshSession: z14.preprocess((value) => value === null ? void 0 : value, z14.boolean().optional().default(false))
     });
-    resetAgentSessionSchema = z13.object({
-      taskKey: z13.string().min(1).optional().nullable()
+    resetAgentSessionSchema = z14.object({
+      taskKey: z14.string().min(1).optional().nullable()
     });
-    testAgentRuntimeEnvironmentSchema = z13.object({
+    testAgentRuntimeEnvironmentSchema = z14.object({
       agentRuntimeConfig: agentRuntimeConfigSchema.optional().default({})
     });
-    updateAgentPermissionsSchema = z13.object({
-      canCreateAgents: z13.boolean(),
-      canManageSkills: z13.boolean().optional(),
-      canAssignTasks: z13.boolean()
+    updateAgentPermissionsSchema = z14.object({
+      canCreateAgents: z14.boolean(),
+      canManageSkills: z14.boolean().optional(),
+      canAssignTasks: z14.boolean()
     });
   }
 });
 
 // ../packages/shared/dist/validators/agent-integration.js
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var agentIntegrationProviderSchema, agentIntegrationStatusSchema, agentIntegrationTransportSchema, agentIntegrationProviderRegionSchema, agentIntegrationChatTypeSchema, agentIntegrationDropReasonSchema, agentIntegrationOutboundStatusSchema, createAgentIntegrationSchema, connectAgentIntegrationSchema, feishuIntegrationSettingsSchema, agentIntegrationSettingsSchema, updateAgentIntegrationSettingsSchema, feishuEventHeaderSchema, feishuSenderIdSchema, feishuMessageMentionSchema, feishuMessageSchema, feishuEventSchema, mockFeishuInboundEventSchema;
 var init_agent_integration = __esm({
   "../packages/shared/dist/validators/agent-integration.js"() {
     "use strict";
     init_constants();
-    agentIntegrationProviderSchema = z14.enum(AGENT_INTEGRATION_PROVIDERS);
-    agentIntegrationStatusSchema = z14.enum(AGENT_INTEGRATION_STATUSES);
-    agentIntegrationTransportSchema = z14.enum(AGENT_INTEGRATION_TRANSPORTS);
-    agentIntegrationProviderRegionSchema = z14.enum(AGENT_INTEGRATION_PROVIDER_REGIONS);
-    agentIntegrationChatTypeSchema = z14.enum(AGENT_INTEGRATION_CHAT_TYPES);
-    agentIntegrationDropReasonSchema = z14.enum(AGENT_INTEGRATION_DROP_REASONS);
-    agentIntegrationOutboundStatusSchema = z14.enum(AGENT_INTEGRATION_OUTBOUND_STATUSES);
-    createAgentIntegrationSchema = z14.object({
-      agentId: z14.string().uuid(),
+    agentIntegrationProviderSchema = z15.enum(AGENT_INTEGRATION_PROVIDERS);
+    agentIntegrationStatusSchema = z15.enum(AGENT_INTEGRATION_STATUSES);
+    agentIntegrationTransportSchema = z15.enum(AGENT_INTEGRATION_TRANSPORTS);
+    agentIntegrationProviderRegionSchema = z15.enum(AGENT_INTEGRATION_PROVIDER_REGIONS);
+    agentIntegrationChatTypeSchema = z15.enum(AGENT_INTEGRATION_CHAT_TYPES);
+    agentIntegrationDropReasonSchema = z15.enum(AGENT_INTEGRATION_DROP_REASONS);
+    agentIntegrationOutboundStatusSchema = z15.enum(AGENT_INTEGRATION_OUTBOUND_STATUSES);
+    createAgentIntegrationSchema = z15.object({
+      agentId: z15.string().uuid(),
       provider: agentIntegrationProviderSchema.default("feishu"),
       transport: agentIntegrationTransportSchema.default("long_connection"),
       providerRegion: agentIntegrationProviderRegionSchema.default("feishu_cn"),
-      appCredentialSecretId: z14.string().uuid(),
-      externalAppId: z14.string().min(1),
-      externalBotOpenId: z14.string().min(1).optional().nullable(),
-      externalTenantKey: z14.string().min(1).optional().nullable(),
-      installerUserId: z14.string().min(1).optional().nullable(),
-      manageUrl: z14.string().url().optional().nullable()
+      appCredentialSecretId: z15.string().uuid(),
+      externalAppId: z15.string().min(1),
+      externalBotOpenId: z15.string().min(1).optional().nullable(),
+      externalTenantKey: z15.string().min(1).optional().nullable(),
+      installerUserId: z15.string().min(1).optional().nullable(),
+      manageUrl: z15.string().url().optional().nullable()
     });
     connectAgentIntegrationSchema = createAgentIntegrationSchema.omit({ agentId: true });
-    feishuIntegrationSettingsSchema = z14.object({
-      dailySessionRolloverEnabled: z14.boolean().default(true),
-      dailySessionRolloverHours: z14.number().int().min(1).max(168).default(24),
-      dailySessionRolloverNotifyFeishu: z14.boolean().default(true)
+    feishuIntegrationSettingsSchema = z15.object({
+      dailySessionRolloverEnabled: z15.boolean().default(true),
+      dailySessionRolloverHours: z15.number().int().min(1).max(168).default(24),
+      dailySessionRolloverNotifyFeishu: z15.boolean().default(true)
     });
-    agentIntegrationSettingsSchema = z14.object({
+    agentIntegrationSettingsSchema = z15.object({
       feishu: feishuIntegrationSettingsSchema.optional()
     }).default({});
-    updateAgentIntegrationSettingsSchema = z14.object({
+    updateAgentIntegrationSettingsSchema = z15.object({
       settings: agentIntegrationSettingsSchema
     });
-    feishuEventHeaderSchema = z14.object({
-      event_id: z14.string().min(1).optional(),
-      app_id: z14.string().min(1).optional(),
-      token: z14.string().min(1).optional(),
-      create_time: z14.string().min(1).optional()
+    feishuEventHeaderSchema = z15.object({
+      event_id: z15.string().min(1).optional(),
+      app_id: z15.string().min(1).optional(),
+      token: z15.string().min(1).optional(),
+      create_time: z15.string().min(1).optional()
     }).passthrough();
-    feishuSenderIdSchema = z14.object({
-      open_id: z14.string().min(1).optional(),
-      union_id: z14.string().min(1).optional()
+    feishuSenderIdSchema = z15.object({
+      open_id: z15.string().min(1).optional(),
+      union_id: z15.string().min(1).optional()
     }).passthrough();
-    feishuMessageMentionSchema = z14.object({
-      key: z14.string().optional(),
+    feishuMessageMentionSchema = z15.object({
+      key: z15.string().optional(),
       id: feishuSenderIdSchema.optional()
     }).passthrough();
-    feishuMessageSchema = z14.object({
-      message_id: z14.string().min(1).optional(),
-      chat_id: z14.string().min(1).optional(),
+    feishuMessageSchema = z15.object({
+      message_id: z15.string().min(1).optional(),
+      chat_id: z15.string().min(1).optional(),
       chat_type: agentIntegrationChatTypeSchema.optional(),
-      message_type: z14.string().min(1).optional(),
-      content: z14.string().optional(),
-      mentions: z14.array(feishuMessageMentionSchema).optional(),
-      parent_id: z14.string().min(1).optional().nullable()
+      message_type: z15.string().min(1).optional(),
+      content: z15.string().optional(),
+      mentions: z15.array(feishuMessageMentionSchema).optional(),
+      parent_id: z15.string().min(1).optional().nullable()
     }).passthrough();
-    feishuEventSchema = z14.object({
-      sender: z14.object({
+    feishuEventSchema = z15.object({
+      sender: z15.object({
         sender_id: feishuSenderIdSchema.optional()
       }).passthrough().optional(),
       message: feishuMessageSchema.optional()
     }).passthrough();
-    mockFeishuInboundEventSchema = z14.object({
-      type: z14.string().min(1).optional(),
-      token: z14.string().min(1).optional(),
-      challenge: z14.string().min(1).optional(),
-      mockVerificationToken: z14.string().min(1).optional(),
-      mockEncryptKey: z14.string().min(1).optional(),
-      eventId: z14.string().min(1).optional(),
-      appId: z14.string().min(1).optional(),
-      botOpenId: z14.string().min(1).optional().nullable(),
-      chatId: z14.string().min(1).optional(),
+    mockFeishuInboundEventSchema = z15.object({
+      type: z15.string().min(1).optional(),
+      token: z15.string().min(1).optional(),
+      challenge: z15.string().min(1).optional(),
+      mockVerificationToken: z15.string().min(1).optional(),
+      mockEncryptKey: z15.string().min(1).optional(),
+      eventId: z15.string().min(1).optional(),
+      appId: z15.string().min(1).optional(),
+      botOpenId: z15.string().min(1).optional().nullable(),
+      chatId: z15.string().min(1).optional(),
       chatType: agentIntegrationChatTypeSchema.optional(),
-      messageId: z14.string().min(1).optional(),
-      senderOpenId: z14.string().min(1).optional(),
-      senderUnionId: z14.string().min(1).optional().nullable(),
-      body: z14.string().optional(),
-      commandBody: z14.string().optional(),
-      addressedToBot: z14.boolean().optional(),
-      messageType: z14.string().min(1).optional(),
-      parentMessageId: z14.string().min(1).optional().nullable(),
-      receivedAt: z14.string().datetime().optional(),
+      messageId: z15.string().min(1).optional(),
+      senderOpenId: z15.string().min(1).optional(),
+      senderUnionId: z15.string().min(1).optional().nullable(),
+      body: z15.string().optional(),
+      commandBody: z15.string().optional(),
+      addressedToBot: z15.boolean().optional(),
+      messageType: z15.string().min(1).optional(),
+      parentMessageId: z15.string().min(1).optional().nullable(),
+      receivedAt: z15.string().datetime().optional(),
       header: feishuEventHeaderSchema.optional(),
       event: feishuEventSchema.optional()
     }).passthrough();
@@ -2129,7 +2303,7 @@ var init_agent_integration = __esm({
 });
 
 // ../packages/shared/dist/validators/project.js
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 function validateProjectWorkspace(value, ctx) {
   const sourceType = value.sourceType ?? "local_path";
   const hasCwd = typeof value.cwd === "string" && value.cwd.trim().length > 0;
@@ -2138,7 +2312,7 @@ function validateProjectWorkspace(value, ctx) {
   if (sourceType === "remote_managed") {
     if (!hasRemoteRef && !hasRepo) {
       ctx.addIssue({
-        code: z15.ZodIssueCode.custom,
+        code: z16.ZodIssueCode.custom,
         message: "Remote-managed workspace requires remoteWorkspaceRef or repoUrl.",
         path: ["remoteWorkspaceRef"]
       });
@@ -2147,7 +2321,7 @@ function validateProjectWorkspace(value, ctx) {
   }
   if (!hasCwd && !hasRepo) {
     ctx.addIssue({
-      code: z15.ZodIssueCode.custom,
+      code: z16.ZodIssueCode.custom,
       message: "Workspace requires at least one of cwd or repoUrl.",
       path: ["cwd"]
     });
@@ -2159,120 +2333,120 @@ var init_project = __esm({
     "use strict";
     init_constants();
     init_resource();
-    executionWorkspaceStrategySchema = z15.object({
-      type: z15.enum(["project_primary", "git_worktree", "adapter_managed", "cloud_sandbox"]).optional(),
-      baseRef: z15.string().optional().nullable(),
-      branchTemplate: z15.string().optional().nullable(),
-      worktreeParentDir: z15.string().optional().nullable(),
-      provisionCommand: z15.string().optional().nullable(),
-      teardownCommand: z15.string().optional().nullable()
+    executionWorkspaceStrategySchema = z16.object({
+      type: z16.enum(["project_primary", "git_worktree", "adapter_managed", "cloud_sandbox"]).optional(),
+      baseRef: z16.string().optional().nullable(),
+      branchTemplate: z16.string().optional().nullable(),
+      worktreeParentDir: z16.string().optional().nullable(),
+      provisionCommand: z16.string().optional().nullable(),
+      teardownCommand: z16.string().optional().nullable()
     }).strict();
-    projectExecutionWorkspacePolicySchema = z15.object({
-      enabled: z15.boolean(),
-      defaultMode: z15.enum(["shared_workspace", "isolated_workspace", "operator_branch", "adapter_default"]).optional(),
-      allowIssueOverride: z15.boolean().optional(),
-      defaultProjectWorkspaceId: z15.string().uuid().optional().nullable(),
+    projectExecutionWorkspacePolicySchema = z16.object({
+      enabled: z16.boolean(),
+      defaultMode: z16.enum(["shared_workspace", "isolated_workspace", "operator_branch", "adapter_default"]).optional(),
+      allowIssueOverride: z16.boolean().optional(),
+      defaultProjectWorkspaceId: z16.string().uuid().optional().nullable(),
       workspaceStrategy: executionWorkspaceStrategySchema.optional().nullable(),
-      workspaceRuntime: z15.record(z15.unknown()).optional().nullable(),
-      branchPolicy: z15.record(z15.unknown()).optional().nullable(),
-      pullRequestPolicy: z15.record(z15.unknown()).optional().nullable(),
-      runtimePolicy: z15.record(z15.unknown()).optional().nullable(),
-      cleanupPolicy: z15.record(z15.unknown()).optional().nullable()
+      workspaceRuntime: z16.record(z16.unknown()).optional().nullable(),
+      branchPolicy: z16.record(z16.unknown()).optional().nullable(),
+      pullRequestPolicy: z16.record(z16.unknown()).optional().nullable(),
+      runtimePolicy: z16.record(z16.unknown()).optional().nullable(),
+      cleanupPolicy: z16.record(z16.unknown()).optional().nullable()
     }).strict();
-    projectWorkspaceSourceTypeSchema = z15.enum(["local_path", "git_repo", "remote_managed", "non_git_path"]);
-    projectWorkspaceVisibilitySchema = z15.enum(["default", "advanced"]);
+    projectWorkspaceSourceTypeSchema = z16.enum(["local_path", "git_repo", "remote_managed", "non_git_path"]);
+    projectWorkspaceVisibilitySchema = z16.enum(["default", "advanced"]);
     projectWorkspaceFields = {
-      name: z15.string().min(1).optional(),
+      name: z16.string().min(1).optional(),
       sourceType: projectWorkspaceSourceTypeSchema.optional(),
-      cwd: z15.string().min(1).optional().nullable(),
-      repoUrl: z15.string().url().optional().nullable(),
-      repoRef: z15.string().optional().nullable(),
-      defaultRef: z15.string().optional().nullable(),
+      cwd: z16.string().min(1).optional().nullable(),
+      repoUrl: z16.string().url().optional().nullable(),
+      repoRef: z16.string().optional().nullable(),
+      defaultRef: z16.string().optional().nullable(),
       visibility: projectWorkspaceVisibilitySchema.optional(),
-      setupCommand: z15.string().optional().nullable(),
-      cleanupCommand: z15.string().optional().nullable(),
-      remoteProvider: z15.string().optional().nullable(),
-      remoteWorkspaceRef: z15.string().optional().nullable(),
-      sharedWorkspaceKey: z15.string().optional().nullable(),
-      metadata: z15.record(z15.unknown()).optional().nullable()
+      setupCommand: z16.string().optional().nullable(),
+      cleanupCommand: z16.string().optional().nullable(),
+      remoteProvider: z16.string().optional().nullable(),
+      remoteWorkspaceRef: z16.string().optional().nullable(),
+      sharedWorkspaceKey: z16.string().optional().nullable(),
+      metadata: z16.record(z16.unknown()).optional().nullable()
     };
     projectColorValues = new Set(PROJECT_COLORS);
-    legacyProjectColorSchema = z15.string().regex(/^#[0-9a-fA-F]{6}$/);
-    projectColorSchema = z15.string().refine((value) => legacyProjectColorSchema.safeParse(value).success || projectColorValues.has(value), "Color must be a 6-digit hex value or a supported project gradient");
-    projectIconSchema = z15.enum(PROJECT_ICONS);
-    createProjectWorkspaceSchema = z15.object({
+    legacyProjectColorSchema = z16.string().regex(/^#[0-9a-fA-F]{6}$/);
+    projectColorSchema = z16.string().refine((value) => legacyProjectColorSchema.safeParse(value).success || projectColorValues.has(value), "Color must be a 6-digit hex value or a supported project gradient");
+    projectIconSchema = z16.enum(PROJECT_ICONS);
+    createProjectWorkspaceSchema = z16.object({
       ...projectWorkspaceFields,
-      isPrimary: z15.boolean().optional().default(false)
+      isPrimary: z16.boolean().optional().default(false)
     }).superRefine(validateProjectWorkspace);
-    updateProjectWorkspaceSchema = z15.object({
+    updateProjectWorkspaceSchema = z16.object({
       ...projectWorkspaceFields,
-      isPrimary: z15.boolean().optional()
+      isPrimary: z16.boolean().optional()
     }).partial();
     projectFields = {
       /** @deprecated Use goalIds instead */
-      goalId: z15.string().uuid().optional().nullable(),
-      goalIds: z15.array(z15.string().uuid()).optional(),
-      name: z15.string().min(1),
-      description: z15.string().optional().nullable(),
-      status: z15.enum(PROJECT_STATUSES).optional().default("backlog"),
-      leadAgentId: z15.string().uuid().optional().nullable(),
-      targetDate: z15.string().optional().nullable(),
+      goalId: z16.string().uuid().optional().nullable(),
+      goalIds: z16.array(z16.string().uuid()).optional(),
+      name: z16.string().min(1),
+      description: z16.string().optional().nullable(),
+      status: z16.enum(PROJECT_STATUSES).optional().default("backlog"),
+      leadAgentId: z16.string().uuid().optional().nullable(),
+      targetDate: z16.string().optional().nullable(),
       color: projectColorSchema.optional().nullable(),
       icon: projectIconSchema.optional().nullable(),
       executionWorkspacePolicy: projectExecutionWorkspacePolicySchema.optional().nullable(),
-      resourceAttachments: z15.array(projectResourceAttachmentInputSchema).optional(),
-      newResources: z15.array(createProjectInlineResourceSchema).optional(),
-      archivedAt: z15.string().datetime().optional().nullable()
+      resourceAttachments: z16.array(projectResourceAttachmentInputSchema).optional(),
+      newResources: z16.array(createProjectInlineResourceSchema).optional(),
+      archivedAt: z16.string().datetime().optional().nullable()
     };
-    createProjectSchema = z15.object({
+    createProjectSchema = z16.object({
       ...projectFields
     });
-    updateProjectSchema = z15.object(projectFields).partial();
+    updateProjectSchema = z16.object(projectFields).partial();
   }
 });
 
 // ../packages/shared/dist/validators/issue.js
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var runWorkspaceStrategySchema, issueRunWorkspaceSettingsSchema, issueAssigneeAdapterOverridesSchema, createIssueSchema, createIssueLabelSchema, updateIssueLabelSchema, updateIssueSchema, reorderIssueSchema, checkoutIssueSchema, addIssueCommentSchema, updateIssueCommentSchema, reportIssueCommitSchema, linkIssueApprovalSchema, createIssueAttachmentMetadataSchema, createIssueWorkspaceAttachmentSchema, ISSUE_DOCUMENT_FORMATS, issueDocumentFormatSchema, createLibraryDocumentSchema, updateLibraryDocumentSchema, restoreLibraryDocumentRevisionSchema;
 var init_issue = __esm({
   "../packages/shared/dist/validators/issue.js"() {
     "use strict";
     init_constants();
-    runWorkspaceStrategySchema = z16.object({
-      type: z16.enum(["project_primary", "git_worktree", "adapter_managed", "cloud_sandbox"]).optional(),
-      baseRef: z16.string().optional().nullable(),
-      branchTemplate: z16.string().optional().nullable(),
-      worktreeParentDir: z16.string().optional().nullable(),
-      provisionCommand: z16.string().optional().nullable(),
-      teardownCommand: z16.string().optional().nullable()
+    runWorkspaceStrategySchema = z17.object({
+      type: z17.enum(["project_primary", "git_worktree", "adapter_managed", "cloud_sandbox"]).optional(),
+      baseRef: z17.string().optional().nullable(),
+      branchTemplate: z17.string().optional().nullable(),
+      worktreeParentDir: z17.string().optional().nullable(),
+      provisionCommand: z17.string().optional().nullable(),
+      teardownCommand: z17.string().optional().nullable()
     }).strict();
-    issueRunWorkspaceSettingsSchema = z16.object({
-      mode: z16.enum(["inherit", "shared_workspace", "isolated_workspace", "operator_branch", "reuse_existing", "agent_default"]).optional(),
+    issueRunWorkspaceSettingsSchema = z17.object({
+      mode: z17.enum(["inherit", "shared_workspace", "isolated_workspace", "operator_branch", "reuse_existing", "agent_default"]).optional(),
       workspaceStrategy: runWorkspaceStrategySchema.optional().nullable(),
-      workspaceRuntime: z16.record(z16.unknown()).optional().nullable()
+      workspaceRuntime: z17.record(z17.unknown()).optional().nullable()
     }).strict();
-    issueAssigneeAdapterOverridesSchema = z16.object({
-      agentRuntimeConfig: z16.record(z16.unknown()).optional(),
-      useProjectWorkspace: z16.boolean().optional()
+    issueAssigneeAdapterOverridesSchema = z17.object({
+      agentRuntimeConfig: z17.record(z17.unknown()).optional(),
+      useProjectWorkspace: z17.boolean().optional()
     }).strict();
-    createIssueSchema = z16.object({
-      projectId: z16.string().uuid().optional().nullable(),
-      projectWorkspaceId: z16.string().uuid().optional().nullable(),
-      goalId: z16.string().uuid().optional().nullable(),
-      parentId: z16.string().uuid().optional().nullable(),
-      title: z16.string().min(1),
-      description: z16.string().optional().nullable(),
-      status: z16.enum(ISSUE_STATUSES).optional().default("backlog"),
-      priority: z16.enum(ISSUE_PRIORITIES).optional().default("medium"),
-      assigneeAgentId: z16.string().uuid().optional().nullable(),
-      assigneeUserId: z16.string().optional().nullable(),
-      reviewerAgentId: z16.string().uuid().optional().nullable(),
-      reviewerUserId: z16.string().optional().nullable(),
-      requestDepth: z16.number().int().nonnegative().optional().default(0),
-      billingCode: z16.string().optional().nullable(),
+    createIssueSchema = z17.object({
+      projectId: z17.string().uuid().optional().nullable(),
+      projectWorkspaceId: z17.string().uuid().optional().nullable(),
+      goalId: z17.string().uuid().optional().nullable(),
+      parentId: z17.string().uuid().optional().nullable(),
+      title: z17.string().min(1),
+      description: z17.string().optional().nullable(),
+      status: z17.enum(ISSUE_STATUSES).optional().default("backlog"),
+      priority: z17.enum(ISSUE_PRIORITIES).optional().default("medium"),
+      assigneeAgentId: z17.string().uuid().optional().nullable(),
+      assigneeUserId: z17.string().optional().nullable(),
+      reviewerAgentId: z17.string().uuid().optional().nullable(),
+      reviewerUserId: z17.string().optional().nullable(),
+      requestDepth: z17.number().int().nonnegative().optional().default(0),
+      billingCode: z17.string().optional().nullable(),
       assigneeAgentRuntimeOverrides: issueAssigneeAdapterOverridesSchema.optional().nullable(),
-      runWorkspaceId: z16.string().uuid().optional().nullable(),
-      runWorkspacePreference: z16.enum([
+      runWorkspaceId: z17.string().uuid().optional().nullable(),
+      runWorkspacePreference: z17.enum([
         "inherit",
         "shared_workspace",
         "isolated_workspace",
@@ -2282,9 +2456,9 @@ var init_issue = __esm({
       ]).optional().nullable(),
       runWorkspaceSettings: issueRunWorkspaceSettingsSchema.optional().nullable(),
       /** @deprecated Use runWorkspaceId. */
-      executionWorkspaceId: z16.string().uuid().optional().nullable(),
+      executionWorkspaceId: z17.string().uuid().optional().nullable(),
       /** @deprecated Use runWorkspacePreference. */
-      executionWorkspacePreference: z16.enum([
+      executionWorkspacePreference: z17.enum([
         "inherit",
         "shared_workspace",
         "isolated_workspace",
@@ -2294,88 +2468,88 @@ var init_issue = __esm({
       ]).optional().nullable(),
       /** @deprecated Use runWorkspaceSettings. */
       executionWorkspaceSettings: issueRunWorkspaceSettingsSchema.optional().nullable(),
-      labelIds: z16.array(z16.string().uuid()).optional()
+      labelIds: z17.array(z17.string().uuid()).optional()
     });
-    createIssueLabelSchema = z16.object({
-      name: z16.string().trim().min(1).max(48),
-      color: z16.string().regex(/^#(?:[0-9a-fA-F]{6})$/, "Color must be a 6-digit hex value")
+    createIssueLabelSchema = z17.object({
+      name: z17.string().trim().min(1).max(48),
+      color: z17.string().regex(/^#(?:[0-9a-fA-F]{6})$/, "Color must be a 6-digit hex value")
     });
     updateIssueLabelSchema = createIssueLabelSchema.partial().refine((value) => value.name !== void 0 || value.color !== void 0, {
       message: "At least one label field must be provided"
     });
     updateIssueSchema = createIssueSchema.partial().extend({
-      comment: z16.string().min(1).optional(),
-      reopen: z16.boolean().optional(),
-      hiddenAt: z16.string().datetime().nullable().optional(),
-      reviewDecision: z16.enum(["approve", "request_changes", "needs_followup", "blocked"]).optional()
+      comment: z17.string().min(1).optional(),
+      reopen: z17.boolean().optional(),
+      hiddenAt: z17.string().datetime().nullable().optional(),
+      reviewDecision: z17.enum(["approve", "request_changes", "needs_followup", "blocked"]).optional()
     });
-    reorderIssueSchema = z16.object({
-      issueId: z16.string().uuid(),
-      targetStatus: z16.enum(ISSUE_STATUSES),
-      previousIssueId: z16.string().uuid().optional().nullable(),
-      nextIssueId: z16.string().uuid().optional().nullable(),
-      position: z16.enum(["start", "end"]).optional()
+    reorderIssueSchema = z17.object({
+      issueId: z17.string().uuid(),
+      targetStatus: z17.enum(ISSUE_STATUSES),
+      previousIssueId: z17.string().uuid().optional().nullable(),
+      nextIssueId: z17.string().uuid().optional().nullable(),
+      position: z17.enum(["start", "end"]).optional()
     }).refine((value) => !(value.previousIssueId && value.nextIssueId && value.previousIssueId === value.nextIssueId), {
       message: "previousIssueId and nextIssueId must be different"
     });
-    checkoutIssueSchema = z16.object({
-      agentId: z16.string().uuid(),
-      expectedStatuses: z16.array(z16.enum(ISSUE_STATUSES)).nonempty()
+    checkoutIssueSchema = z17.object({
+      agentId: z17.string().uuid(),
+      expectedStatuses: z17.array(z17.enum(ISSUE_STATUSES)).nonempty()
     });
-    addIssueCommentSchema = z16.object({
-      body: z16.string().min(1),
-      reopen: z16.boolean().optional(),
-      interrupt: z16.boolean().optional()
+    addIssueCommentSchema = z17.object({
+      body: z17.string().min(1),
+      reopen: z17.boolean().optional(),
+      interrupt: z17.boolean().optional()
     });
-    updateIssueCommentSchema = z16.object({
-      body: z16.string().trim().min(1)
+    updateIssueCommentSchema = z17.object({
+      body: z17.string().trim().min(1)
     });
-    reportIssueCommitSchema = z16.object({
-      sha: z16.string().trim().regex(/^[0-9a-f]{7,64}$/i, "Commit SHA must be 7 to 64 hexadecimal characters"),
-      message: z16.string().trim().min(1).max(500),
-      branch: z16.string().trim().min(1).max(255).optional().nullable(),
-      repoPath: z16.string().trim().min(1).max(2048).optional().nullable(),
-      workspacePath: z16.string().trim().min(1).max(2048).optional().nullable(),
-      commitCount: z16.number().int().positive().max(1e3).optional()
+    reportIssueCommitSchema = z17.object({
+      sha: z17.string().trim().regex(/^[0-9a-f]{7,64}$/i, "Commit SHA must be 7 to 64 hexadecimal characters"),
+      message: z17.string().trim().min(1).max(500),
+      branch: z17.string().trim().min(1).max(255).optional().nullable(),
+      repoPath: z17.string().trim().min(1).max(2048).optional().nullable(),
+      workspacePath: z17.string().trim().min(1).max(2048).optional().nullable(),
+      commitCount: z17.number().int().positive().max(1e3).optional()
     });
-    linkIssueApprovalSchema = z16.object({
-      approvalId: z16.string().uuid()
+    linkIssueApprovalSchema = z17.object({
+      approvalId: z17.string().uuid()
     });
-    createIssueAttachmentMetadataSchema = z16.object({
-      issueCommentId: z16.string().uuid().optional().nullable(),
-      usage: z16.enum(["issue", "description_inline", "document_inline", "comment_inline", "comment_attachment"]).optional()
+    createIssueAttachmentMetadataSchema = z17.object({
+      issueCommentId: z17.string().uuid().optional().nullable(),
+      usage: z17.enum(["issue", "description_inline", "document_inline", "comment_inline", "comment_attachment"]).optional()
     });
-    createIssueWorkspaceAttachmentSchema = z16.object({
-      path: z16.string().trim().min(1).max(2048)
+    createIssueWorkspaceAttachmentSchema = z17.object({
+      path: z17.string().trim().min(1).max(2048)
     });
     ISSUE_DOCUMENT_FORMATS = ["markdown"];
-    issueDocumentFormatSchema = z16.enum(ISSUE_DOCUMENT_FORMATS);
-    createLibraryDocumentSchema = z16.object({
-      title: z16.string().trim().max(200).nullable().optional(),
+    issueDocumentFormatSchema = z17.enum(ISSUE_DOCUMENT_FORMATS);
+    createLibraryDocumentSchema = z17.object({
+      title: z17.string().trim().max(200).nullable().optional(),
       format: issueDocumentFormatSchema.optional().default("markdown"),
-      body: z16.string().max(524288).optional().default(""),
-      changeSummary: z16.string().trim().max(500).nullable().optional()
+      body: z17.string().max(524288).optional().default(""),
+      changeSummary: z17.string().trim().max(500).nullable().optional()
     });
-    updateLibraryDocumentSchema = z16.object({
-      title: z16.string().trim().max(200).nullable().optional(),
+    updateLibraryDocumentSchema = z17.object({
+      title: z17.string().trim().max(200).nullable().optional(),
       format: issueDocumentFormatSchema.optional().default("markdown"),
-      body: z16.string().max(524288),
-      changeSummary: z16.string().trim().max(500).nullable().optional(),
-      baseRevisionId: z16.string().uuid().nullable().optional()
+      body: z17.string().max(524288),
+      changeSummary: z17.string().trim().max(500).nullable().optional(),
+      baseRevisionId: z17.string().uuid().nullable().optional()
     });
-    restoreLibraryDocumentRevisionSchema = z16.object({
-      changeSummary: z16.string().trim().max(500).nullable().optional()
+    restoreLibraryDocumentRevisionSchema = z17.object({
+      changeSummary: z17.string().trim().max(500).nullable().optional()
     });
   }
 });
 
 // ../packages/shared/dist/validators/work-product.js
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var issueWorkProductTypeSchema, issueWorkProductStatusSchema, issueWorkProductReviewStateSchema, createIssueWorkProductSchema, updateIssueWorkProductSchema;
 var init_work_product = __esm({
   "../packages/shared/dist/validators/work-product.js"() {
     "use strict";
-    issueWorkProductTypeSchema = z17.enum([
+    issueWorkProductTypeSchema = z18.enum([
       "preview_url",
       "runtime_service",
       "pull_request",
@@ -2384,7 +2558,7 @@ var init_work_product = __esm({
       "artifact",
       "document"
     ]);
-    issueWorkProductStatusSchema = z17.enum([
+    issueWorkProductStatusSchema = z18.enum([
       "active",
       "ready_for_review",
       "approved",
@@ -2395,125 +2569,125 @@ var init_work_product = __esm({
       "archived",
       "draft"
     ]);
-    issueWorkProductReviewStateSchema = z17.enum([
+    issueWorkProductReviewStateSchema = z18.enum([
       "none",
       "needs_board_review",
       "approved",
       "changes_requested"
     ]);
-    createIssueWorkProductSchema = z17.object({
-      projectId: z17.string().uuid().optional().nullable(),
-      runWorkspaceId: z17.string().uuid().optional().nullable(),
+    createIssueWorkProductSchema = z18.object({
+      projectId: z18.string().uuid().optional().nullable(),
+      runWorkspaceId: z18.string().uuid().optional().nullable(),
       /** @deprecated Use runWorkspaceId. */
-      executionWorkspaceId: z17.string().uuid().optional().nullable(),
-      runtimeServiceId: z17.string().uuid().optional().nullable(),
+      executionWorkspaceId: z18.string().uuid().optional().nullable(),
+      runtimeServiceId: z18.string().uuid().optional().nullable(),
       type: issueWorkProductTypeSchema,
-      provider: z17.string().min(1),
-      externalId: z17.string().optional().nullable(),
-      title: z17.string().min(1),
-      url: z17.string().url().optional().nullable(),
+      provider: z18.string().min(1),
+      externalId: z18.string().optional().nullable(),
+      title: z18.string().min(1),
+      url: z18.string().url().optional().nullable(),
       status: issueWorkProductStatusSchema.default("active"),
       reviewState: issueWorkProductReviewStateSchema.optional().default("none"),
-      isPrimary: z17.boolean().optional().default(false),
-      healthStatus: z17.enum(["unknown", "healthy", "unhealthy"]).optional().default("unknown"),
-      summary: z17.string().optional().nullable(),
-      metadata: z17.record(z17.unknown()).optional().nullable(),
-      createdByRunId: z17.string().uuid().optional().nullable()
+      isPrimary: z18.boolean().optional().default(false),
+      healthStatus: z18.enum(["unknown", "healthy", "unhealthy"]).optional().default("unknown"),
+      summary: z18.string().optional().nullable(),
+      metadata: z18.record(z18.unknown()).optional().nullable(),
+      createdByRunId: z18.string().uuid().optional().nullable()
     });
     updateIssueWorkProductSchema = createIssueWorkProductSchema.partial();
   }
 });
 
 // ../packages/shared/dist/validators/execution-workspace.js
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var runWorkspaceStatusSchema, updateRunWorkspaceSchema;
 var init_execution_workspace = __esm({
   "../packages/shared/dist/validators/execution-workspace.js"() {
     "use strict";
-    runWorkspaceStatusSchema = z18.enum([
+    runWorkspaceStatusSchema = z19.enum([
       "active",
       "idle",
       "in_review",
       "archived",
       "cleanup_failed"
     ]);
-    updateRunWorkspaceSchema = z18.object({
+    updateRunWorkspaceSchema = z19.object({
       status: runWorkspaceStatusSchema.optional(),
-      cleanupEligibleAt: z18.string().datetime().optional().nullable(),
-      cleanupReason: z18.string().optional().nullable(),
-      metadata: z18.record(z18.unknown()).optional().nullable()
+      cleanupEligibleAt: z19.string().datetime().optional().nullable(),
+      cleanupReason: z19.string().optional().nullable(),
+      metadata: z19.record(z19.unknown()).optional().nullable()
     }).strict();
   }
 });
 
 // ../packages/shared/dist/validators/workspace-backup.js
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var workspaceBackupTriggerSourceSchema, createWorkspaceBackupSchema, restoreWorkspaceBackupSchema;
 var init_workspace_backup2 = __esm({
   "../packages/shared/dist/validators/workspace-backup.js"() {
     "use strict";
-    workspaceBackupTriggerSourceSchema = z19.enum(["manual", "scheduled", "pre_restore"]);
-    createWorkspaceBackupSchema = z19.object({
+    workspaceBackupTriggerSourceSchema = z20.enum(["manual", "scheduled", "pre_restore"]);
+    createWorkspaceBackupSchema = z20.object({
       triggerSource: workspaceBackupTriggerSourceSchema.optional().default("manual")
     }).strict();
-    restoreWorkspaceBackupSchema = z19.object({
-      confirm: z19.literal(true)
+    restoreWorkspaceBackupSchema = z20.object({
+      confirm: z20.literal(true)
     }).strict();
   }
 });
 
 // ../packages/shared/dist/validators/goal.js
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var createGoalSchema, updateGoalSchema;
 var init_goal = __esm({
   "../packages/shared/dist/validators/goal.js"() {
     "use strict";
     init_constants();
-    createGoalSchema = z20.object({
-      title: z20.string().min(1),
-      description: z20.string().optional().nullable(),
-      level: z20.enum(GOAL_LEVELS).optional().default("task"),
-      status: z20.enum(GOAL_STATUSES).optional().default("planned"),
-      parentId: z20.string().uuid().optional().nullable(),
-      ownerAgentId: z20.string().uuid().optional().nullable()
+    createGoalSchema = z21.object({
+      title: z21.string().min(1),
+      description: z21.string().optional().nullable(),
+      level: z21.enum(GOAL_LEVELS).optional().default("task"),
+      status: z21.enum(GOAL_STATUSES).optional().default("planned"),
+      parentId: z21.string().uuid().optional().nullable(),
+      ownerAgentId: z21.string().uuid().optional().nullable()
     });
     updateGoalSchema = createGoalSchema.partial();
   }
 });
 
 // ../packages/shared/dist/validators/approval.js
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var createApprovalSchema, resolveApprovalSchema, requestApprovalRevisionSchema, resubmitApprovalSchema, addApprovalCommentSchema;
 var init_approval = __esm({
   "../packages/shared/dist/validators/approval.js"() {
     "use strict";
     init_constants();
-    createApprovalSchema = z21.object({
-      type: z21.enum(APPROVAL_TYPES),
-      requestedByAgentId: z21.string().uuid().optional().nullable(),
-      payload: z21.record(z21.unknown()),
-      issueIds: z21.array(z21.string().uuid()).optional()
+    createApprovalSchema = z22.object({
+      type: z22.enum(APPROVAL_TYPES),
+      requestedByAgentId: z22.string().uuid().optional().nullable(),
+      payload: z22.record(z22.unknown()),
+      issueIds: z22.array(z22.string().uuid()).optional()
     });
-    resolveApprovalSchema = z21.object({
-      decisionNote: z21.string().optional().nullable(),
-      decidedByUserId: z21.string().optional().default("board"),
-      payload: z21.record(z21.unknown()).optional()
+    resolveApprovalSchema = z22.object({
+      decisionNote: z22.string().optional().nullable(),
+      decidedByUserId: z22.string().optional().default("board"),
+      payload: z22.record(z22.unknown()).optional()
     });
-    requestApprovalRevisionSchema = z21.object({
-      decisionNote: z21.string().optional().nullable(),
-      decidedByUserId: z21.string().optional().default("board")
+    requestApprovalRevisionSchema = z22.object({
+      decisionNote: z22.string().optional().nullable(),
+      decidedByUserId: z22.string().optional().default("board")
     });
-    resubmitApprovalSchema = z21.object({
-      payload: z21.record(z21.unknown()).optional()
+    resubmitApprovalSchema = z22.object({
+      payload: z22.record(z22.unknown()).optional()
     });
-    addApprovalCommentSchema = z21.object({
-      body: z21.string().min(1)
+    addApprovalCommentSchema = z22.object({
+      body: z22.string().min(1)
     });
   }
 });
 
 // ../packages/shared/dist/validators/automation.js
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 function normalizeAutomationInstructions(value) {
   const { instructions, ...rest } = value;
   return {
@@ -2531,27 +2705,27 @@ var init_automation = __esm({
   "../packages/shared/dist/validators/automation.js"() {
     "use strict";
     init_constants();
-    automationTextFieldSchema = z22.string().optional().nullable();
-    automationBodyFieldsSchema = z22.object({
-      projectId: z22.string().uuid().optional().nullable().default(null),
-      goalId: z22.string().uuid().optional().nullable(),
-      parentIssueId: z22.string().uuid().optional().nullable(),
-      title: z22.string().trim().min(1).max(200),
+    automationTextFieldSchema = z23.string().optional().nullable();
+    automationBodyFieldsSchema = z23.object({
+      projectId: z23.string().uuid().optional().nullable().default(null),
+      goalId: z23.string().uuid().optional().nullable(),
+      parentIssueId: z23.string().uuid().optional().nullable(),
+      title: z23.string().trim().min(1).max(200),
       instructions: automationTextFieldSchema,
       description: automationTextFieldSchema,
-      assigneeAgentId: z22.string().uuid(),
-      priority: z22.enum(ISSUE_PRIORITIES).optional().default("medium"),
-      status: z22.enum(AUTOMATION_STATUSES).optional().default("active"),
-      concurrencyPolicy: z22.enum(AUTOMATION_CONCURRENCY_POLICIES).optional().default("coalesce_if_active"),
-      catchUpPolicy: z22.enum(AUTOMATION_CATCH_UP_POLICIES).optional().default("skip_missed"),
-      outputMode: z22.enum(AUTOMATION_OUTPUT_MODES).optional().default("track_issue"),
-      chatConversationId: z22.string().uuid().optional().nullable().default(null),
-      notifyOnIssueCreated: z22.boolean().optional().default(false)
+      assigneeAgentId: z23.string().uuid(),
+      priority: z23.enum(ISSUE_PRIORITIES).optional().default("medium"),
+      status: z23.enum(AUTOMATION_STATUSES).optional().default("active"),
+      concurrencyPolicy: z23.enum(AUTOMATION_CONCURRENCY_POLICIES).optional().default("coalesce_if_active"),
+      catchUpPolicy: z23.enum(AUTOMATION_CATCH_UP_POLICIES).optional().default("skip_missed"),
+      outputMode: z23.enum(AUTOMATION_OUTPUT_MODES).optional().default("track_issue"),
+      chatConversationId: z23.string().uuid().optional().nullable().default(null),
+      notifyOnIssueCreated: z23.boolean().optional().default(false)
     });
     createAutomationSchema = automationBodyFieldsSchema.superRefine((value, ctx) => {
       if (value.chatConversationId) {
         ctx.addIssue({
-          code: z22.ZodIssueCode.custom,
+          code: z23.ZodIssueCode.custom,
           path: ["chatConversationId"],
           message: "Chat output creates an automation-owned conversation; existing chats cannot be selected"
         });
@@ -2560,185 +2734,185 @@ var init_automation = __esm({
     updateAutomationSchema = automationBodyFieldsSchema.partial().superRefine((value, ctx) => {
       if (value.chatConversationId) {
         ctx.addIssue({
-          code: z22.ZodIssueCode.custom,
+          code: z23.ZodIssueCode.custom,
           path: ["chatConversationId"],
           message: "Chat output creates an automation-owned conversation; existing chats cannot be selected"
         });
       }
     }).transform(normalizeAutomationInstructions).transform(normalizeAutomationNotifications);
-    baseTriggerSchema = z22.object({
-      label: z22.string().trim().max(120).optional().nullable(),
-      enabled: z22.boolean().optional().default(true)
+    baseTriggerSchema = z23.object({
+      label: z23.string().trim().max(120).optional().nullable(),
+      enabled: z23.boolean().optional().default(true)
     });
-    createAutomationTriggerSchema = z22.discriminatedUnion("kind", [
+    createAutomationTriggerSchema = z23.discriminatedUnion("kind", [
       baseTriggerSchema.extend({
-        kind: z22.literal("schedule"),
-        cronExpression: z22.string().trim().min(1),
-        timezone: z22.string().trim().min(1).default("UTC")
+        kind: z23.literal("schedule"),
+        cronExpression: z23.string().trim().min(1),
+        timezone: z23.string().trim().min(1).default("UTC")
       }),
       baseTriggerSchema.extend({
-        kind: z22.literal("webhook"),
-        signingMode: z22.enum(AUTOMATION_TRIGGER_SIGNING_MODES).optional().default("bearer"),
-        replayWindowSec: z22.number().int().min(30).max(86400).optional().default(300)
+        kind: z23.literal("webhook"),
+        signingMode: z23.enum(AUTOMATION_TRIGGER_SIGNING_MODES).optional().default("bearer"),
+        replayWindowSec: z23.number().int().min(30).max(86400).optional().default(300)
       }),
       baseTriggerSchema.extend({
-        kind: z22.literal("api")
+        kind: z23.literal("api")
       })
     ]);
-    updateAutomationTriggerSchema = z22.object({
-      label: z22.string().trim().max(120).optional().nullable(),
-      enabled: z22.boolean().optional(),
-      cronExpression: z22.string().trim().min(1).optional().nullable(),
-      timezone: z22.string().trim().min(1).optional().nullable(),
-      signingMode: z22.enum(AUTOMATION_TRIGGER_SIGNING_MODES).optional().nullable(),
-      replayWindowSec: z22.number().int().min(30).max(86400).optional().nullable()
+    updateAutomationTriggerSchema = z23.object({
+      label: z23.string().trim().max(120).optional().nullable(),
+      enabled: z23.boolean().optional(),
+      cronExpression: z23.string().trim().min(1).optional().nullable(),
+      timezone: z23.string().trim().min(1).optional().nullable(),
+      signingMode: z23.enum(AUTOMATION_TRIGGER_SIGNING_MODES).optional().nullable(),
+      replayWindowSec: z23.number().int().min(30).max(86400).optional().nullable()
     });
-    runAutomationSchema = z22.object({
-      triggerId: z22.string().uuid().optional().nullable(),
-      payload: z22.record(z22.unknown()).optional().nullable(),
-      idempotencyKey: z22.string().trim().max(255).optional().nullable(),
-      source: z22.enum(["manual", "api"]).optional().default("manual")
+    runAutomationSchema = z23.object({
+      triggerId: z23.string().uuid().optional().nullable(),
+      payload: z23.record(z23.unknown()).optional().nullable(),
+      idempotencyKey: z23.string().trim().max(255).optional().nullable(),
+      source: z23.enum(["manual", "api"]).optional().default("manual")
     });
-    rotateAutomationTriggerSecretSchema = z22.object({});
+    rotateAutomationTriggerSecretSchema = z23.object({});
   }
 });
 
 // ../packages/shared/dist/validators/calendar.js
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var nullableUuid, createCalendarSourceSchema, updateCalendarSourceSchema, calendarEventBaseSchema, createCalendarEventSchema, updateCalendarEventSchema, calendarEventListQuerySchema, googleCalendarSyncSchema, updateGoogleCalendarOAuthConfigSchema;
 var init_calendar = __esm({
   "../packages/shared/dist/validators/calendar.js"() {
     "use strict";
     init_constants();
-    nullableUuid = z23.string().uuid().optional().nullable();
-    createCalendarSourceSchema = z23.object({
-      type: z23.enum(CALENDAR_SOURCE_TYPES).optional().default("rudder_local"),
-      name: z23.string().trim().min(1).max(160),
-      ownerType: z23.enum(CALENDAR_OWNER_TYPES).optional().default("user"),
-      ownerUserId: z23.string().trim().min(1).optional().nullable(),
+    nullableUuid = z24.string().uuid().optional().nullable();
+    createCalendarSourceSchema = z24.object({
+      type: z24.enum(CALENDAR_SOURCE_TYPES).optional().default("rudder_local"),
+      name: z24.string().trim().min(1).max(160),
+      ownerType: z24.enum(CALENDAR_OWNER_TYPES).optional().default("user"),
+      ownerUserId: z24.string().trim().min(1).optional().nullable(),
       ownerAgentId: nullableUuid,
-      externalProvider: z23.string().trim().min(1).max(80).optional().nullable(),
-      externalCalendarId: z23.string().trim().min(1).max(512).optional().nullable(),
-      visibilityDefault: z23.enum(CALENDAR_VISIBILITIES).optional().default("full"),
-      status: z23.enum(CALENDAR_SOURCE_STATUSES).optional().default("active"),
-      syncCursorJson: z23.record(z23.unknown()).optional().nullable()
+      externalProvider: z24.string().trim().min(1).max(80).optional().nullable(),
+      externalCalendarId: z24.string().trim().min(1).max(512).optional().nullable(),
+      visibilityDefault: z24.enum(CALENDAR_VISIBILITIES).optional().default("full"),
+      status: z24.enum(CALENDAR_SOURCE_STATUSES).optional().default("active"),
+      syncCursorJson: z24.record(z24.unknown()).optional().nullable()
     });
     updateCalendarSourceSchema = createCalendarSourceSchema.partial().extend({
-      lastSyncedAt: z23.coerce.date().optional().nullable()
+      lastSyncedAt: z24.coerce.date().optional().nullable()
     });
-    calendarEventBaseSchema = z23.object({
+    calendarEventBaseSchema = z24.object({
       sourceId: nullableUuid,
-      eventKind: z23.enum(CALENDAR_EVENT_KINDS),
-      eventStatus: z23.enum(CALENDAR_EVENT_STATUSES).optional().default("planned"),
-      ownerType: z23.enum(CALENDAR_OWNER_TYPES),
-      ownerUserId: z23.string().trim().min(1).optional().nullable(),
+      eventKind: z24.enum(CALENDAR_EVENT_KINDS),
+      eventStatus: z24.enum(CALENDAR_EVENT_STATUSES).optional().default("planned"),
+      ownerType: z24.enum(CALENDAR_OWNER_TYPES),
+      ownerUserId: z24.string().trim().min(1).optional().nullable(),
       ownerAgentId: nullableUuid,
-      title: z23.string().trim().min(1).max(240),
-      description: z23.string().optional().nullable(),
-      startAt: z23.coerce.date(),
-      endAt: z23.coerce.date(),
-      timezone: z23.string().trim().min(1).max(80).optional().default("UTC"),
-      allDay: z23.boolean().optional().default(false),
-      visibility: z23.enum(CALENDAR_VISIBILITIES).optional().default("full"),
+      title: z24.string().trim().min(1).max(240),
+      description: z24.string().optional().nullable(),
+      startAt: z24.coerce.date(),
+      endAt: z24.coerce.date(),
+      timezone: z24.string().trim().min(1).max(80).optional().default("UTC"),
+      allDay: z24.boolean().optional().default(false),
+      visibility: z24.enum(CALENDAR_VISIBILITIES).optional().default("full"),
       issueId: nullableUuid,
       projectId: nullableUuid,
       goalId: nullableUuid,
       approvalId: nullableUuid,
       heartbeatRunId: nullableUuid,
       activityId: nullableUuid,
-      sourceMode: z23.enum(CALENDAR_SOURCE_MODES).optional().default("manual"),
-      externalProvider: z23.string().trim().min(1).max(80).optional().nullable(),
-      externalCalendarId: z23.string().trim().min(1).max(512).optional().nullable(),
-      externalEventId: z23.string().trim().min(1).max(512).optional().nullable(),
-      externalEtag: z23.string().trim().min(1).max(512).optional().nullable(),
-      externalUpdatedAt: z23.coerce.date().optional().nullable()
+      sourceMode: z24.enum(CALENDAR_SOURCE_MODES).optional().default("manual"),
+      externalProvider: z24.string().trim().min(1).max(80).optional().nullable(),
+      externalCalendarId: z24.string().trim().min(1).max(512).optional().nullable(),
+      externalEventId: z24.string().trim().min(1).max(512).optional().nullable(),
+      externalEtag: z24.string().trim().min(1).max(512).optional().nullable(),
+      externalUpdatedAt: z24.coerce.date().optional().nullable()
     });
     createCalendarEventSchema = calendarEventBaseSchema.refine((value) => value.endAt.getTime() > value.startAt.getTime(), { path: ["endAt"], message: "End time must be after start time" });
     updateCalendarEventSchema = calendarEventBaseSchema.partial().refine((value) => value.startAt === void 0 || value.endAt === void 0 || value.endAt.getTime() > value.startAt.getTime(), { path: ["endAt"], message: "End time must be after start time" });
-    calendarEventListQuerySchema = z23.object({
-      start: z23.coerce.date(),
-      end: z23.coerce.date(),
-      agentIds: z23.string().optional(),
-      sourceIds: z23.string().optional(),
-      eventKinds: z23.string().optional(),
-      statuses: z23.string().optional()
+    calendarEventListQuerySchema = z24.object({
+      start: z24.coerce.date(),
+      end: z24.coerce.date(),
+      agentIds: z24.string().optional(),
+      sourceIds: z24.string().optional(),
+      eventKinds: z24.string().optional(),
+      statuses: z24.string().optional()
     }).refine((value) => value.end.getTime() > value.start.getTime(), { path: ["end"], message: "End time must be after start time" });
-    googleCalendarSyncSchema = z23.object({
-      sourceId: z23.string().uuid().optional().nullable()
+    googleCalendarSyncSchema = z24.object({
+      sourceId: z24.string().uuid().optional().nullable()
     });
-    updateGoogleCalendarOAuthConfigSchema = z23.object({
-      clientId: z23.string().trim().min(1).max(512).optional(),
-      clientSecret: z23.string().trim().min(1).max(2048).optional(),
-      clear: z23.boolean().optional().default(false)
+    updateGoogleCalendarOAuthConfigSchema = z24.object({
+      clientId: z24.string().trim().min(1).max(512).optional(),
+      clientSecret: z24.string().trim().min(1).max(2048).optional(),
+      clear: z24.boolean().optional().default(false)
     }).refine((value) => value.clear || value.clientId !== void 0 || value.clientSecret !== void 0, { message: "Provide credentials or clear the stored Google Calendar OAuth configuration" });
   }
 });
 
 // ../packages/shared/dist/validators/cost.js
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var createCostEventSchema, updateBudgetSchema;
 var init_cost = __esm({
   "../packages/shared/dist/validators/cost.js"() {
     "use strict";
     init_constants();
-    createCostEventSchema = z24.object({
-      agentId: z24.string().uuid(),
-      issueId: z24.string().uuid().optional().nullable(),
-      projectId: z24.string().uuid().optional().nullable(),
-      goalId: z24.string().uuid().optional().nullable(),
-      heartbeatRunId: z24.string().uuid().optional().nullable(),
-      billingCode: z24.string().optional().nullable(),
-      provider: z24.string().min(1),
-      biller: z24.string().min(1).optional(),
-      billingType: z24.enum(BILLING_TYPES).optional().default("unknown"),
-      model: z24.string().min(1),
-      inputTokens: z24.number().int().nonnegative().optional().default(0),
-      cachedInputTokens: z24.number().int().nonnegative().optional().default(0),
-      outputTokens: z24.number().int().nonnegative().optional().default(0),
-      costCents: z24.number().int().nonnegative(),
-      occurredAt: z24.string().datetime()
+    createCostEventSchema = z25.object({
+      agentId: z25.string().uuid(),
+      issueId: z25.string().uuid().optional().nullable(),
+      projectId: z25.string().uuid().optional().nullable(),
+      goalId: z25.string().uuid().optional().nullable(),
+      heartbeatRunId: z25.string().uuid().optional().nullable(),
+      billingCode: z25.string().optional().nullable(),
+      provider: z25.string().min(1),
+      biller: z25.string().min(1).optional(),
+      billingType: z25.enum(BILLING_TYPES).optional().default("unknown"),
+      model: z25.string().min(1),
+      inputTokens: z25.number().int().nonnegative().optional().default(0),
+      cachedInputTokens: z25.number().int().nonnegative().optional().default(0),
+      outputTokens: z25.number().int().nonnegative().optional().default(0),
+      costCents: z25.number().int().nonnegative(),
+      occurredAt: z25.string().datetime()
     }).transform((value) => ({
       ...value,
       biller: value.biller ?? value.provider
     }));
-    updateBudgetSchema = z24.object({
-      budgetMonthlyCents: z24.number().int().nonnegative()
+    updateBudgetSchema = z25.object({
+      budgetMonthlyCents: z25.number().int().nonnegative()
     });
   }
 });
 
 // ../packages/shared/dist/validators/finance.js
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var createFinanceEventSchema;
 var init_finance = __esm({
   "../packages/shared/dist/validators/finance.js"() {
     "use strict";
     init_constants();
-    createFinanceEventSchema = z25.object({
-      agentId: z25.string().uuid().optional().nullable(),
-      issueId: z25.string().uuid().optional().nullable(),
-      projectId: z25.string().uuid().optional().nullable(),
-      goalId: z25.string().uuid().optional().nullable(),
-      heartbeatRunId: z25.string().uuid().optional().nullable(),
-      costEventId: z25.string().uuid().optional().nullable(),
-      billingCode: z25.string().optional().nullable(),
-      description: z25.string().max(500).optional().nullable(),
-      eventKind: z25.enum(FINANCE_EVENT_KINDS),
-      direction: z25.enum(FINANCE_DIRECTIONS).optional().default("debit"),
-      biller: z25.string().min(1),
-      provider: z25.string().min(1).optional().nullable(),
-      executionAgentRuntimeType: z25.enum(AGENT_RUNTIME_TYPES).optional().nullable(),
-      pricingTier: z25.string().min(1).optional().nullable(),
-      region: z25.string().min(1).optional().nullable(),
-      model: z25.string().min(1).optional().nullable(),
-      quantity: z25.number().int().nonnegative().optional().nullable(),
-      unit: z25.enum(FINANCE_UNITS).optional().nullable(),
-      amountCents: z25.number().int().nonnegative(),
-      currency: z25.string().length(3).optional().default("USD"),
-      estimated: z25.boolean().optional().default(false),
-      externalInvoiceId: z25.string().optional().nullable(),
-      metadataJson: z25.record(z25.string(), z25.unknown()).optional().nullable(),
-      occurredAt: z25.string().datetime()
+    createFinanceEventSchema = z26.object({
+      agentId: z26.string().uuid().optional().nullable(),
+      issueId: z26.string().uuid().optional().nullable(),
+      projectId: z26.string().uuid().optional().nullable(),
+      goalId: z26.string().uuid().optional().nullable(),
+      heartbeatRunId: z26.string().uuid().optional().nullable(),
+      costEventId: z26.string().uuid().optional().nullable(),
+      billingCode: z26.string().optional().nullable(),
+      description: z26.string().max(500).optional().nullable(),
+      eventKind: z26.enum(FINANCE_EVENT_KINDS),
+      direction: z26.enum(FINANCE_DIRECTIONS).optional().default("debit"),
+      biller: z26.string().min(1),
+      provider: z26.string().min(1).optional().nullable(),
+      executionAgentRuntimeType: z26.enum(AGENT_RUNTIME_TYPES).optional().nullable(),
+      pricingTier: z26.string().min(1).optional().nullable(),
+      region: z26.string().min(1).optional().nullable(),
+      model: z26.string().min(1).optional().nullable(),
+      quantity: z26.number().int().nonnegative().optional().nullable(),
+      unit: z26.enum(FINANCE_UNITS).optional().nullable(),
+      amountCents: z26.number().int().nonnegative(),
+      currency: z26.string().length(3).optional().default("USD"),
+      estimated: z26.boolean().optional().default(false),
+      externalInvoiceId: z26.string().optional().nullable(),
+      metadataJson: z26.record(z26.string(), z26.unknown()).optional().nullable(),
+      occurredAt: z26.string().datetime()
     }).transform((value) => ({
       ...value,
       currency: value.currency.toUpperCase()
@@ -2747,79 +2921,79 @@ var init_finance = __esm({
 });
 
 // ../packages/shared/dist/validators/asset.js
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var createAssetImageMetadataSchema;
 var init_asset = __esm({
   "../packages/shared/dist/validators/asset.js"() {
     "use strict";
-    createAssetImageMetadataSchema = z26.object({
-      namespace: z26.string().trim().min(1).max(120).regex(/^[a-zA-Z0-9/_-]+$/).optional()
+    createAssetImageMetadataSchema = z27.object({
+      namespace: z27.string().trim().min(1).max(120).regex(/^[a-zA-Z0-9/_-]+$/).optional()
     });
   }
 });
 
 // ../packages/shared/dist/validators/access.js
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var createCompanyInviteSchema, createOpenClawInvitePromptSchema, acceptInviteSchema, listJoinRequestsQuerySchema, claimJoinRequestApiKeySchema, boardCliAuthAccessLevelSchema, createCliAuthChallengeSchema, resolveCliAuthChallengeSchema, updateMemberPermissionsSchema, updateUserCompanyAccessSchema;
 var init_access = __esm({
   "../packages/shared/dist/validators/access.js"() {
     "use strict";
     init_constants();
-    createCompanyInviteSchema = z27.object({
-      allowedJoinTypes: z27.enum(INVITE_JOIN_TYPES).default("both"),
-      defaultsPayload: z27.record(z27.string(), z27.unknown()).optional().nullable(),
-      agentMessage: z27.string().max(4e3).optional().nullable()
+    createCompanyInviteSchema = z28.object({
+      allowedJoinTypes: z28.enum(INVITE_JOIN_TYPES).default("both"),
+      defaultsPayload: z28.record(z28.string(), z28.unknown()).optional().nullable(),
+      agentMessage: z28.string().max(4e3).optional().nullable()
     });
-    createOpenClawInvitePromptSchema = z27.object({
-      agentMessage: z27.string().max(4e3).optional().nullable()
+    createOpenClawInvitePromptSchema = z28.object({
+      agentMessage: z28.string().max(4e3).optional().nullable()
     });
-    acceptInviteSchema = z27.object({
-      requestType: z27.enum(JOIN_REQUEST_TYPES),
-      agentName: z27.string().min(1).max(120).optional(),
-      agentRuntimeType: z27.enum(AGENT_RUNTIME_TYPES).optional(),
-      capabilities: z27.string().max(4e3).optional().nullable(),
-      agentDefaultsPayload: z27.record(z27.string(), z27.unknown()).optional().nullable(),
+    acceptInviteSchema = z28.object({
+      requestType: z28.enum(JOIN_REQUEST_TYPES),
+      agentName: z28.string().min(1).max(120).optional(),
+      agentRuntimeType: z28.enum(AGENT_RUNTIME_TYPES).optional(),
+      capabilities: z28.string().max(4e3).optional().nullable(),
+      agentDefaultsPayload: z28.record(z28.string(), z28.unknown()).optional().nullable(),
       // OpenClaw join compatibility fields accepted at top level.
-      responsesWebhookUrl: z27.string().max(4e3).optional().nullable(),
-      responsesWebhookMethod: z27.string().max(32).optional().nullable(),
-      responsesWebhookHeaders: z27.record(z27.string(), z27.unknown()).optional().nullable(),
-      rudderApiUrl: z27.string().max(4e3).optional().nullable(),
-      webhookAuthHeader: z27.string().max(4e3).optional().nullable()
+      responsesWebhookUrl: z28.string().max(4e3).optional().nullable(),
+      responsesWebhookMethod: z28.string().max(32).optional().nullable(),
+      responsesWebhookHeaders: z28.record(z28.string(), z28.unknown()).optional().nullable(),
+      rudderApiUrl: z28.string().max(4e3).optional().nullable(),
+      webhookAuthHeader: z28.string().max(4e3).optional().nullable()
     });
-    listJoinRequestsQuerySchema = z27.object({
-      status: z27.enum(JOIN_REQUEST_STATUSES).optional(),
-      requestType: z27.enum(JOIN_REQUEST_TYPES).optional()
+    listJoinRequestsQuerySchema = z28.object({
+      status: z28.enum(JOIN_REQUEST_STATUSES).optional(),
+      requestType: z28.enum(JOIN_REQUEST_TYPES).optional()
     });
-    claimJoinRequestApiKeySchema = z27.object({
-      claimSecret: z27.string().min(16).max(256)
+    claimJoinRequestApiKeySchema = z28.object({
+      claimSecret: z28.string().min(16).max(256)
     });
-    boardCliAuthAccessLevelSchema = z27.enum([
+    boardCliAuthAccessLevelSchema = z28.enum([
       "board",
       "instance_admin_required"
     ]);
-    createCliAuthChallengeSchema = z27.object({
-      command: z27.string().min(1).max(240),
-      clientName: z27.string().max(120).optional().nullable(),
+    createCliAuthChallengeSchema = z28.object({
+      command: z28.string().min(1).max(240),
+      clientName: z28.string().max(120).optional().nullable(),
       requestedAccess: boardCliAuthAccessLevelSchema.default("board"),
-      requestedCompanyId: z27.string().uuid().optional().nullable()
+      requestedCompanyId: z28.string().uuid().optional().nullable()
     });
-    resolveCliAuthChallengeSchema = z27.object({
-      token: z27.string().min(16).max(256)
+    resolveCliAuthChallengeSchema = z28.object({
+      token: z28.string().min(16).max(256)
     });
-    updateMemberPermissionsSchema = z27.object({
-      grants: z27.array(z27.object({
-        permissionKey: z27.enum(PERMISSION_KEYS),
-        scope: z27.record(z27.string(), z27.unknown()).optional().nullable()
+    updateMemberPermissionsSchema = z28.object({
+      grants: z28.array(z28.object({
+        permissionKey: z28.enum(PERMISSION_KEYS),
+        scope: z28.record(z28.string(), z28.unknown()).optional().nullable()
       }))
     });
-    updateUserCompanyAccessSchema = z27.object({
-      orgIds: z27.array(z27.string().uuid()).default([])
+    updateUserCompanyAccessSchema = z28.object({
+      orgIds: z28.array(z28.string().uuid()).default([])
     });
   }
 });
 
 // ../packages/shared/dist/validators/plugin.js
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 function isValidCronExpression(expression) {
   const trimmed = expression.trim();
   if (!trimmed)
@@ -2834,79 +3008,79 @@ var init_plugin = __esm({
   "../packages/shared/dist/validators/plugin.js"() {
     "use strict";
     init_constants();
-    jsonSchemaSchema = z28.record(z28.unknown()).refine((val) => {
+    jsonSchemaSchema = z29.record(z29.unknown()).refine((val) => {
       if (Object.keys(val).length === 0)
         return true;
       return typeof val.type === "string" || val.$ref !== void 0 || val.oneOf !== void 0 || val.anyOf !== void 0 || val.allOf !== void 0;
     }, { message: "Must be a valid JSON Schema object (requires at least a 'type', '$ref', or composition keyword)" });
     CRON_FIELD_PATTERN = /^(\*(?:\/[0-9]+)?|[0-9]+(?:-[0-9]+)?(?:\/[0-9]+)?)(?:,(\*(?:\/[0-9]+)?|[0-9]+(?:-[0-9]+)?(?:\/[0-9]+)?))*$/;
-    pluginJobDeclarationSchema = z28.object({
-      jobKey: z28.string().min(1),
-      displayName: z28.string().min(1),
-      description: z28.string().optional(),
-      schedule: z28.string().refine((val) => isValidCronExpression(val), { message: "schedule must be a valid 5-field cron expression (e.g. '*/15 * * * *')" }).optional()
+    pluginJobDeclarationSchema = z29.object({
+      jobKey: z29.string().min(1),
+      displayName: z29.string().min(1),
+      description: z29.string().optional(),
+      schedule: z29.string().refine((val) => isValidCronExpression(val), { message: "schedule must be a valid 5-field cron expression (e.g. '*/15 * * * *')" }).optional()
     });
-    pluginWebhookDeclarationSchema = z28.object({
-      endpointKey: z28.string().min(1),
-      displayName: z28.string().min(1),
-      description: z28.string().optional()
+    pluginWebhookDeclarationSchema = z29.object({
+      endpointKey: z29.string().min(1),
+      displayName: z29.string().min(1),
+      description: z29.string().optional()
     });
-    pluginToolDeclarationSchema = z28.object({
-      name: z28.string().min(1),
-      displayName: z28.string().min(1),
-      description: z28.string().min(1),
+    pluginToolDeclarationSchema = z29.object({
+      name: z29.string().min(1),
+      displayName: z29.string().min(1),
+      description: z29.string().min(1),
       parametersSchema: jsonSchemaSchema
     });
-    pluginUiSlotDeclarationSchema = z28.object({
-      type: z28.enum(PLUGIN_UI_SLOT_TYPES),
-      id: z28.string().min(1),
-      displayName: z28.string().min(1),
-      exportName: z28.string().min(1),
-      entityTypes: z28.array(z28.enum(PLUGIN_UI_SLOT_ENTITY_TYPES)).optional(),
-      routePath: z28.string().regex(/^[a-z0-9][a-z0-9-]*$/, {
+    pluginUiSlotDeclarationSchema = z29.object({
+      type: z29.enum(PLUGIN_UI_SLOT_TYPES),
+      id: z29.string().min(1),
+      displayName: z29.string().min(1),
+      exportName: z29.string().min(1),
+      entityTypes: z29.array(z29.enum(PLUGIN_UI_SLOT_ENTITY_TYPES)).optional(),
+      routePath: z29.string().regex(/^[a-z0-9][a-z0-9-]*$/, {
         message: "routePath must be a lowercase single-segment slug (letters, numbers, hyphens)"
       }).optional(),
-      order: z28.number().int().optional()
+      order: z29.number().int().optional()
     }).superRefine((value, ctx) => {
       const entityScopedTypes = ["detailTab", "taskDetailView", "contextMenuItem", "commentAnnotation", "commentContextMenuItem", "projectSidebarItem"];
       if (entityScopedTypes.includes(value.type) && (!value.entityTypes || value.entityTypes.length === 0)) {
         ctx.addIssue({
-          code: z28.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: `${value.type} slots require at least one entityType`,
           path: ["entityTypes"]
         });
       }
       if (value.type === "projectSidebarItem" && value.entityTypes && !value.entityTypes.includes("project")) {
         ctx.addIssue({
-          code: z28.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: 'projectSidebarItem slots require entityTypes to include "project"',
           path: ["entityTypes"]
         });
       }
       if (value.type === "commentAnnotation" && value.entityTypes && !value.entityTypes.includes("comment")) {
         ctx.addIssue({
-          code: z28.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: 'commentAnnotation slots require entityTypes to include "comment"',
           path: ["entityTypes"]
         });
       }
       if (value.type === "commentContextMenuItem" && value.entityTypes && !value.entityTypes.includes("comment")) {
         ctx.addIssue({
-          code: z28.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: 'commentContextMenuItem slots require entityTypes to include "comment"',
           path: ["entityTypes"]
         });
       }
       if (value.routePath && value.type !== "page") {
         ctx.addIssue({
-          code: z28.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: "routePath is only supported for page slots",
           path: ["routePath"]
         });
       }
       if (value.routePath && PLUGIN_RESERVED_COMPANY_ROUTE_SEGMENTS.includes(value.routePath)) {
         ctx.addIssue({
-          code: z28.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: `routePath "${value.routePath}" is reserved by the host`,
           path: ["routePath"]
         });
@@ -2927,29 +3101,29 @@ var init_plugin = __esm({
       external: [],
       iframe: ["compact", "default", "wide", "full"]
     };
-    pluginLauncherActionDeclarationSchema = z28.object({
-      type: z28.enum(PLUGIN_LAUNCHER_ACTIONS),
-      target: z28.string().min(1),
-      params: z28.record(z28.unknown()).optional()
+    pluginLauncherActionDeclarationSchema = z29.object({
+      type: z29.enum(PLUGIN_LAUNCHER_ACTIONS),
+      target: z29.string().min(1),
+      params: z29.record(z29.unknown()).optional()
     }).superRefine((value, ctx) => {
       if (value.type === "performAction" && value.target.includes("/")) {
         ctx.addIssue({
-          code: z28.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: "performAction launchers must target an action key, not a route or URL",
           path: ["target"]
         });
       }
       if (value.type === "navigate" && /^https?:\/\//.test(value.target)) {
         ctx.addIssue({
-          code: z28.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: "navigate launchers must target a host route, not an absolute URL",
           path: ["target"]
         });
       }
     });
-    pluginLauncherRenderDeclarationSchema = z28.object({
-      environment: z28.enum(PLUGIN_LAUNCHER_RENDER_ENVIRONMENTS),
-      bounds: z28.enum(PLUGIN_LAUNCHER_BOUNDS).optional()
+    pluginLauncherRenderDeclarationSchema = z29.object({
+      environment: z29.enum(PLUGIN_LAUNCHER_RENDER_ENVIRONMENTS),
+      bounds: z29.enum(PLUGIN_LAUNCHER_BOUNDS).optional()
     }).superRefine((value, ctx) => {
       if (!value.bounds) {
         return;
@@ -2957,110 +3131,110 @@ var init_plugin = __esm({
       const supportedBounds = launcherBoundsByEnvironment[value.environment];
       if (!supportedBounds.includes(value.bounds)) {
         ctx.addIssue({
-          code: z28.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: `bounds "${value.bounds}" is not supported for render environment "${value.environment}"`,
           path: ["bounds"]
         });
       }
     });
-    pluginLauncherDeclarationSchema = z28.object({
-      id: z28.string().min(1),
-      displayName: z28.string().min(1),
-      description: z28.string().optional(),
-      placementZone: z28.enum(PLUGIN_LAUNCHER_PLACEMENT_ZONES),
-      exportName: z28.string().min(1).optional(),
-      entityTypes: z28.array(z28.enum(PLUGIN_UI_SLOT_ENTITY_TYPES)).optional(),
-      order: z28.number().int().optional(),
+    pluginLauncherDeclarationSchema = z29.object({
+      id: z29.string().min(1),
+      displayName: z29.string().min(1),
+      description: z29.string().optional(),
+      placementZone: z29.enum(PLUGIN_LAUNCHER_PLACEMENT_ZONES),
+      exportName: z29.string().min(1).optional(),
+      entityTypes: z29.array(z29.enum(PLUGIN_UI_SLOT_ENTITY_TYPES)).optional(),
+      order: z29.number().int().optional(),
       action: pluginLauncherActionDeclarationSchema,
       render: pluginLauncherRenderDeclarationSchema.optional()
     }).superRefine((value, ctx) => {
       if (entityScopedLauncherPlacementZones.some((zone) => zone === value.placementZone) && (!value.entityTypes || value.entityTypes.length === 0)) {
         ctx.addIssue({
-          code: z28.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: `${value.placementZone} launchers require at least one entityType`,
           path: ["entityTypes"]
         });
       }
       if (value.placementZone === "projectSidebarItem" && value.entityTypes && !value.entityTypes.includes("project")) {
         ctx.addIssue({
-          code: z28.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: 'projectSidebarItem launchers require entityTypes to include "project"',
           path: ["entityTypes"]
         });
       }
       if (value.action.type === "performAction" && value.render) {
         ctx.addIssue({
-          code: z28.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: "performAction launchers cannot declare render hints",
           path: ["render"]
         });
       }
       if (["openModal", "openDrawer", "openPopover"].includes(value.action.type) && !value.render) {
         ctx.addIssue({
-          code: z28.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: `${value.action.type} launchers require render metadata`,
           path: ["render"]
         });
       }
       if (value.action.type === "openModal" && value.render?.environment === "hostInline") {
         ctx.addIssue({
-          code: z28.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: "openModal launchers cannot use the hostInline render environment",
           path: ["render", "environment"]
         });
       }
       if (value.action.type === "openDrawer" && value.render && !["hostOverlay", "iframe"].includes(value.render.environment)) {
         ctx.addIssue({
-          code: z28.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: "openDrawer launchers must use hostOverlay or iframe render environments",
           path: ["render", "environment"]
         });
       }
       if (value.action.type === "openPopover" && value.render?.environment === "hostRoute") {
         ctx.addIssue({
-          code: z28.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: "openPopover launchers cannot use the hostRoute render environment",
           path: ["render", "environment"]
         });
       }
     });
-    pluginManifestV1Schema = z28.object({
-      id: z28.string().min(1).regex(/^[a-z0-9][a-z0-9._-]*$/, "Plugin id must start with a lowercase alphanumeric and contain only lowercase letters, digits, dots, hyphens, or underscores"),
-      apiVersion: z28.literal(1),
-      version: z28.string().min(1).regex(/^\d+\.\d+\.\d+(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/, "Version must follow semver (e.g. 1.0.0 or 1.0.0-beta.1)"),
-      displayName: z28.string().min(1).max(100),
-      description: z28.string().min(1).max(500),
-      author: z28.string().min(1).max(200),
-      categories: z28.array(z28.enum(PLUGIN_CATEGORIES)).min(1),
-      minimumHostVersion: z28.string().regex(/^\d+\.\d+\.\d+(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/, "minimumHostVersion must follow semver (e.g. 1.0.0)").optional(),
-      minimumPaperclipVersion: z28.string().regex(/^\d+\.\d+\.\d+(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/, "minimumPaperclipVersion must follow semver (e.g. 1.0.0)").optional(),
-      capabilities: z28.array(z28.enum(PLUGIN_CAPABILITIES)).min(1),
-      entrypoints: z28.object({
-        worker: z28.string().min(1),
-        ui: z28.string().min(1).optional()
+    pluginManifestV1Schema = z29.object({
+      id: z29.string().min(1).regex(/^[a-z0-9][a-z0-9._-]*$/, "Plugin id must start with a lowercase alphanumeric and contain only lowercase letters, digits, dots, hyphens, or underscores"),
+      apiVersion: z29.literal(1),
+      version: z29.string().min(1).regex(/^\d+\.\d+\.\d+(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/, "Version must follow semver (e.g. 1.0.0 or 1.0.0-beta.1)"),
+      displayName: z29.string().min(1).max(100),
+      description: z29.string().min(1).max(500),
+      author: z29.string().min(1).max(200),
+      categories: z29.array(z29.enum(PLUGIN_CATEGORIES)).min(1),
+      minimumHostVersion: z29.string().regex(/^\d+\.\d+\.\d+(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/, "minimumHostVersion must follow semver (e.g. 1.0.0)").optional(),
+      minimumPaperclipVersion: z29.string().regex(/^\d+\.\d+\.\d+(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/, "minimumPaperclipVersion must follow semver (e.g. 1.0.0)").optional(),
+      capabilities: z29.array(z29.enum(PLUGIN_CAPABILITIES)).min(1),
+      entrypoints: z29.object({
+        worker: z29.string().min(1),
+        ui: z29.string().min(1).optional()
       }),
       instanceConfigSchema: jsonSchemaSchema.optional(),
-      jobs: z28.array(pluginJobDeclarationSchema).optional(),
-      webhooks: z28.array(pluginWebhookDeclarationSchema).optional(),
-      tools: z28.array(pluginToolDeclarationSchema).optional(),
-      launchers: z28.array(pluginLauncherDeclarationSchema).optional(),
-      ui: z28.object({
-        slots: z28.array(pluginUiSlotDeclarationSchema).min(1).optional(),
-        launchers: z28.array(pluginLauncherDeclarationSchema).optional()
+      jobs: z29.array(pluginJobDeclarationSchema).optional(),
+      webhooks: z29.array(pluginWebhookDeclarationSchema).optional(),
+      tools: z29.array(pluginToolDeclarationSchema).optional(),
+      launchers: z29.array(pluginLauncherDeclarationSchema).optional(),
+      ui: z29.object({
+        slots: z29.array(pluginUiSlotDeclarationSchema).min(1).optional(),
+        launchers: z29.array(pluginLauncherDeclarationSchema).optional()
       }).optional()
     }).superRefine((manifest, ctx) => {
       const hasUiSlots = (manifest.ui?.slots?.length ?? 0) > 0;
       const hasUiLaunchers = (manifest.ui?.launchers?.length ?? 0) > 0;
       if ((hasUiSlots || hasUiLaunchers) && !manifest.entrypoints.ui) {
         ctx.addIssue({
-          code: z28.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: "entrypoints.ui is required when ui.slots or ui.launchers are declared",
           path: ["entrypoints", "ui"]
         });
       }
       if (manifest.minimumHostVersion && manifest.minimumPaperclipVersion && manifest.minimumHostVersion !== manifest.minimumPaperclipVersion) {
         ctx.addIssue({
-          code: z28.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: "minimumHostVersion and minimumPaperclipVersion must match when both are declared",
           path: ["minimumHostVersion"]
         });
@@ -3068,7 +3242,7 @@ var init_plugin = __esm({
       if (manifest.tools && manifest.tools.length > 0) {
         if (!manifest.capabilities.includes("agent.tools.register")) {
           ctx.addIssue({
-            code: z28.ZodIssueCode.custom,
+            code: z29.ZodIssueCode.custom,
             message: "Capability 'agent.tools.register' is required when tools are declared",
             path: ["capabilities"]
           });
@@ -3077,7 +3251,7 @@ var init_plugin = __esm({
       if (manifest.jobs && manifest.jobs.length > 0) {
         if (!manifest.capabilities.includes("jobs.schedule")) {
           ctx.addIssue({
-            code: z28.ZodIssueCode.custom,
+            code: z29.ZodIssueCode.custom,
             message: "Capability 'jobs.schedule' is required when jobs are declared",
             path: ["capabilities"]
           });
@@ -3086,7 +3260,7 @@ var init_plugin = __esm({
       if (manifest.webhooks && manifest.webhooks.length > 0) {
         if (!manifest.capabilities.includes("webhooks.receive")) {
           ctx.addIssue({
-            code: z28.ZodIssueCode.custom,
+            code: z29.ZodIssueCode.custom,
             message: "Capability 'webhooks.receive' is required when webhooks are declared",
             path: ["capabilities"]
           });
@@ -3097,7 +3271,7 @@ var init_plugin = __esm({
         const duplicates = jobKeys.filter((key, i) => jobKeys.indexOf(key) !== i);
         if (duplicates.length > 0) {
           ctx.addIssue({
-            code: z28.ZodIssueCode.custom,
+            code: z29.ZodIssueCode.custom,
             message: `Duplicate job keys: ${[...new Set(duplicates)].join(", ")}`,
             path: ["jobs"]
           });
@@ -3108,7 +3282,7 @@ var init_plugin = __esm({
         const duplicates = endpointKeys.filter((key, i) => endpointKeys.indexOf(key) !== i);
         if (duplicates.length > 0) {
           ctx.addIssue({
-            code: z28.ZodIssueCode.custom,
+            code: z29.ZodIssueCode.custom,
             message: `Duplicate webhook endpoint keys: ${[...new Set(duplicates)].join(", ")}`,
             path: ["webhooks"]
           });
@@ -3119,7 +3293,7 @@ var init_plugin = __esm({
         const duplicates = toolNames.filter((name, i) => toolNames.indexOf(name) !== i);
         if (duplicates.length > 0) {
           ctx.addIssue({
-            code: z28.ZodIssueCode.custom,
+            code: z29.ZodIssueCode.custom,
             message: `Duplicate tool names: ${[...new Set(duplicates)].join(", ")}`,
             path: ["tools"]
           });
@@ -3131,7 +3305,7 @@ var init_plugin = __esm({
           const duplicates = slotIds.filter((id, i) => slotIds.indexOf(id) !== i);
           if (duplicates.length > 0) {
             ctx.addIssue({
-              code: z28.ZodIssueCode.custom,
+              code: z29.ZodIssueCode.custom,
               message: `Duplicate UI slot ids: ${[...new Set(duplicates)].join(", ")}`,
               path: ["ui", "slots"]
             });
@@ -3147,50 +3321,50 @@ var init_plugin = __esm({
         const duplicates = launcherIds.filter((id, i) => launcherIds.indexOf(id) !== i);
         if (duplicates.length > 0) {
           ctx.addIssue({
-            code: z28.ZodIssueCode.custom,
+            code: z29.ZodIssueCode.custom,
             message: `Duplicate launcher ids: ${[...new Set(duplicates)].join(", ")}`,
             path: manifest.ui?.launchers ? ["ui", "launchers"] : ["launchers"]
           });
         }
       }
     });
-    installPluginSchema = z28.object({
-      packageName: z28.string().min(1),
-      version: z28.string().min(1).optional(),
+    installPluginSchema = z29.object({
+      packageName: z29.string().min(1),
+      version: z29.string().min(1).optional(),
       /** Set by loader for local-path installs so the worker can be resolved. */
-      packagePath: z28.string().min(1).optional()
+      packagePath: z29.string().min(1).optional()
     });
-    upsertPluginConfigSchema = z28.object({
-      configJson: z28.record(z28.unknown())
+    upsertPluginConfigSchema = z29.object({
+      configJson: z29.record(z29.unknown())
     });
-    patchPluginConfigSchema = z28.object({
-      configJson: z28.record(z28.unknown())
+    patchPluginConfigSchema = z29.object({
+      configJson: z29.record(z29.unknown())
     });
-    updatePluginStatusSchema = z28.object({
-      status: z28.enum(PLUGIN_STATUSES),
-      lastError: z28.string().nullable().optional()
+    updatePluginStatusSchema = z29.object({
+      status: z29.enum(PLUGIN_STATUSES),
+      lastError: z29.string().nullable().optional()
     });
-    uninstallPluginSchema = z28.object({
-      removeData: z28.boolean().optional().default(false)
+    uninstallPluginSchema = z29.object({
+      removeData: z29.boolean().optional().default(false)
     });
-    pluginStateScopeKeySchema = z28.object({
-      scopeKind: z28.enum(PLUGIN_STATE_SCOPE_KINDS),
-      scopeId: z28.string().min(1).optional(),
-      namespace: z28.string().min(1).optional(),
-      stateKey: z28.string().min(1)
+    pluginStateScopeKeySchema = z29.object({
+      scopeKind: z29.enum(PLUGIN_STATE_SCOPE_KINDS),
+      scopeId: z29.string().min(1).optional(),
+      namespace: z29.string().min(1).optional(),
+      stateKey: z29.string().min(1)
     });
-    setPluginStateSchema = z28.object({
-      scopeKind: z28.enum(PLUGIN_STATE_SCOPE_KINDS),
-      scopeId: z28.string().min(1).optional(),
-      namespace: z28.string().min(1).optional(),
-      stateKey: z28.string().min(1),
+    setPluginStateSchema = z29.object({
+      scopeKind: z29.enum(PLUGIN_STATE_SCOPE_KINDS),
+      scopeId: z29.string().min(1).optional(),
+      namespace: z29.string().min(1).optional(),
+      stateKey: z29.string().min(1),
       /** JSON-serializable value to store. */
-      value: z28.unknown()
+      value: z29.unknown()
     });
-    listPluginStateSchema = z28.object({
-      scopeKind: z28.enum(PLUGIN_STATE_SCOPE_KINDS).optional(),
-      scopeId: z28.string().min(1).optional(),
-      namespace: z28.string().min(1).optional()
+    listPluginStateSchema = z29.object({
+      scopeKind: z29.enum(PLUGIN_STATE_SCOPE_KINDS).optional(),
+      scopeId: z29.string().min(1).optional(),
+      namespace: z29.string().min(1).optional()
     });
   }
 });
@@ -3203,6 +3377,7 @@ var init_validators = __esm({
     init_budget();
     init_adapter_skills();
     init_chat();
+    init_messenger();
     init_organization_intelligence_profile();
     init_organization_portability();
     init_organization_skill();
@@ -3289,7 +3464,7 @@ var init_organization_url_key = __esm({
 });
 
 // ../packages/shared/dist/organization-skill-reference.js
-var RUDDER_BUNDLED_SKILL_SLUGS, RUDDER_BUNDLED_SKILL_KEYS, RUDDER_DOCS_SKILL_SLUG, RUDDER_DOCS_SKILL_KEY, RUDDER_DOCS_SELECTION_KEY;
+var RUDDER_BUNDLED_SKILL_SLUGS, RUDDER_BUNDLED_SKILL_KEYS, RUDDER_DOCS_SKILL_SLUG, RUDDER_DOCS_SKILL_KEY, RUDDER_DOCS_SELECTION_KEY, RETIRED_RUDDER_CREATION_SKILL_SLUGS, RETIRED_RUDDER_CREATION_SKILL_SLUG_SET;
 var init_organization_skill_reference = __esm({
   "../packages/shared/dist/organization-skill-reference.js"() {
     "use strict";
@@ -3298,8 +3473,6 @@ var init_organization_skill_reference = __esm({
     RUDDER_BUNDLED_SKILL_SLUGS = [
       "para-memory-files",
       "rudder-docs",
-      "rudder-create-agent",
-      "rudder-create-plugin",
       "skill-creator",
       "visualize",
       "browser"
@@ -3308,6 +3481,11 @@ var init_organization_skill_reference = __esm({
     RUDDER_DOCS_SKILL_SLUG = "rudder-docs";
     RUDDER_DOCS_SKILL_KEY = `rudder/${RUDDER_DOCS_SKILL_SLUG}`;
     RUDDER_DOCS_SELECTION_KEY = `bundled:${RUDDER_DOCS_SKILL_KEY}`;
+    RETIRED_RUDDER_CREATION_SKILL_SLUGS = [
+      "rudder-create-agent",
+      "rudder-create-plugin"
+    ];
+    RETIRED_RUDDER_CREATION_SKILL_SLUG_SET = new Set(RETIRED_RUDDER_CREATION_SKILL_SLUGS);
   }
 });
 
@@ -3372,34 +3550,34 @@ var init_issue_activity = __esm({
 });
 
 // ../packages/shared/dist/config-schema.js
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var DEFAULT_DATABASE_BACKUP_MAX_ESTIMATED_BYTES, configMetaSchema, llmConfigSchema, databaseBackupConfigSchema, databaseConfigSchema, loggingConfigSchema, serverConfigSchema, authConfigSchema, storageLocalDiskConfigSchema, storageS3ConfigSchema, storageConfigSchema, secretsLocalEncryptedConfigSchema, secretsConfigSchema, rudderConfigSchema;
 var init_config_schema = __esm({
   "../packages/shared/dist/config-schema.js"() {
     "use strict";
     init_constants();
     DEFAULT_DATABASE_BACKUP_MAX_ESTIMATED_BYTES = 256 * 1024 * 1024;
-    configMetaSchema = z29.object({
-      version: z29.literal(1),
-      updatedAt: z29.string(),
-      source: z29.enum(["onboard", "configure", "doctor"])
+    configMetaSchema = z30.object({
+      version: z30.literal(1),
+      updatedAt: z30.string(),
+      source: z30.enum(["onboard", "configure", "doctor"])
     });
-    llmConfigSchema = z29.object({
-      provider: z29.enum(["claude", "openai"]),
-      apiKey: z29.string().optional()
+    llmConfigSchema = z30.object({
+      provider: z30.enum(["claude", "openai"]),
+      apiKey: z30.string().optional()
     });
-    databaseBackupConfigSchema = z29.object({
-      enabled: z29.boolean().default(true),
-      intervalMinutes: z29.number().int().min(1).max(7 * 24 * 60).default(60),
-      retentionDays: z29.number().int().min(1).max(3650).default(30),
-      maxEstimatedBytes: z29.number().int().min(1).default(DEFAULT_DATABASE_BACKUP_MAX_ESTIMATED_BYTES),
-      dir: z29.string().default("~/.rudder/instances/default/data/backups")
+    databaseBackupConfigSchema = z30.object({
+      enabled: z30.boolean().default(true),
+      intervalMinutes: z30.number().int().min(1).max(7 * 24 * 60).default(60),
+      retentionDays: z30.number().int().min(1).max(3650).default(30),
+      maxEstimatedBytes: z30.number().int().min(1).default(DEFAULT_DATABASE_BACKUP_MAX_ESTIMATED_BYTES),
+      dir: z30.string().default("~/.rudder/instances/default/data/backups")
     });
-    databaseConfigSchema = z29.object({
-      mode: z29.enum(["embedded-postgres", "postgres"]).default("embedded-postgres"),
-      connectionString: z29.string().optional(),
-      embeddedPostgresDataDir: z29.string().default("~/.rudder/instances/default/db"),
-      embeddedPostgresPort: z29.number().int().min(1).max(65535).default(54329),
+    databaseConfigSchema = z30.object({
+      mode: z30.enum(["embedded-postgres", "postgres"]).default("embedded-postgres"),
+      connectionString: z30.string().optional(),
+      embeddedPostgresDataDir: z30.string().default("~/.rudder/instances/default/db"),
+      embeddedPostgresPort: z30.number().int().min(1).max(65535).default(54329),
       backup: databaseBackupConfigSchema.default({
         enabled: true,
         intervalMinutes: 60,
@@ -3408,35 +3586,35 @@ var init_config_schema = __esm({
         dir: "~/.rudder/instances/default/data/backups"
       })
     });
-    loggingConfigSchema = z29.object({
-      mode: z29.enum(["file", "cloud"]),
-      logDir: z29.string().default("~/.rudder/instances/default/logs")
+    loggingConfigSchema = z30.object({
+      mode: z30.enum(["file", "cloud"]),
+      logDir: z30.string().default("~/.rudder/instances/default/logs")
     });
-    serverConfigSchema = z29.object({
-      deploymentMode: z29.enum(DEPLOYMENT_MODES).default("local_trusted"),
-      exposure: z29.enum(DEPLOYMENT_EXPOSURES).default("private"),
-      host: z29.string().default("127.0.0.1"),
-      port: z29.number().int().min(1).max(65535).default(3100),
-      allowedHostnames: z29.array(z29.string().min(1)).default([]),
-      serveUi: z29.boolean().default(true)
+    serverConfigSchema = z30.object({
+      deploymentMode: z30.enum(DEPLOYMENT_MODES).default("local_trusted"),
+      exposure: z30.enum(DEPLOYMENT_EXPOSURES).default("private"),
+      host: z30.string().default("127.0.0.1"),
+      port: z30.number().int().min(1).max(65535).default(3100),
+      allowedHostnames: z30.array(z30.string().min(1)).default([]),
+      serveUi: z30.boolean().default(true)
     });
-    authConfigSchema = z29.object({
-      baseUrlMode: z29.enum(AUTH_BASE_URL_MODES).default("auto"),
-      publicBaseUrl: z29.string().url().optional(),
-      disableSignUp: z29.boolean().default(false)
+    authConfigSchema = z30.object({
+      baseUrlMode: z30.enum(AUTH_BASE_URL_MODES).default("auto"),
+      publicBaseUrl: z30.string().url().optional(),
+      disableSignUp: z30.boolean().default(false)
     });
-    storageLocalDiskConfigSchema = z29.object({
-      baseDir: z29.string().default("~/.rudder/instances/default/data/storage")
+    storageLocalDiskConfigSchema = z30.object({
+      baseDir: z30.string().default("~/.rudder/instances/default/data/storage")
     });
-    storageS3ConfigSchema = z29.object({
-      bucket: z29.string().min(1).default("rudder"),
-      region: z29.string().min(1).default("us-east-1"),
-      endpoint: z29.string().optional(),
-      prefix: z29.string().default(""),
-      forcePathStyle: z29.boolean().default(false)
+    storageS3ConfigSchema = z30.object({
+      bucket: z30.string().min(1).default("rudder"),
+      region: z30.string().min(1).default("us-east-1"),
+      endpoint: z30.string().optional(),
+      prefix: z30.string().default(""),
+      forcePathStyle: z30.boolean().default(false)
     });
-    storageConfigSchema = z29.object({
-      provider: z29.enum(STORAGE_PROVIDERS).default("local_disk"),
+    storageConfigSchema = z30.object({
+      provider: z30.enum(STORAGE_PROVIDERS).default("local_disk"),
       localDisk: storageLocalDiskConfigSchema.default({
         baseDir: "~/.rudder/instances/default/data/storage"
       }),
@@ -3447,17 +3625,17 @@ var init_config_schema = __esm({
         forcePathStyle: false
       })
     });
-    secretsLocalEncryptedConfigSchema = z29.object({
-      keyFilePath: z29.string().default("~/.rudder/instances/default/secrets/master.key")
+    secretsLocalEncryptedConfigSchema = z30.object({
+      keyFilePath: z30.string().default("~/.rudder/instances/default/secrets/master.key")
     });
-    secretsConfigSchema = z29.object({
-      provider: z29.enum(SECRET_PROVIDERS).default("local_encrypted"),
-      strictMode: z29.boolean().default(false),
+    secretsConfigSchema = z30.object({
+      provider: z30.enum(SECRET_PROVIDERS).default("local_encrypted"),
+      strictMode: z30.boolean().default(false),
       localEncrypted: secretsLocalEncryptedConfigSchema.default({
         keyFilePath: "~/.rudder/instances/default/secrets/master.key"
       })
     });
-    rudderConfigSchema = z29.object({
+    rudderConfigSchema = z30.object({
       $meta: configMetaSchema,
       llm: llmConfigSchema.optional(),
       database: databaseConfigSchema,
@@ -3490,7 +3668,7 @@ var init_config_schema = __esm({
       if (value.server.deploymentMode === "local_trusted") {
         if (value.server.exposure !== "private") {
           ctx.addIssue({
-            code: z29.ZodIssueCode.custom,
+            code: z30.ZodIssueCode.custom,
             message: "server.exposure must be private when deploymentMode is local_trusted",
             path: ["server", "exposure"]
           });
@@ -3499,21 +3677,21 @@ var init_config_schema = __esm({
       }
       if (value.auth.baseUrlMode === "explicit" && !value.auth.publicBaseUrl) {
         ctx.addIssue({
-          code: z29.ZodIssueCode.custom,
+          code: z30.ZodIssueCode.custom,
           message: "auth.publicBaseUrl is required when auth.baseUrlMode is explicit",
           path: ["auth", "publicBaseUrl"]
         });
       }
       if (value.server.exposure === "public" && value.auth.baseUrlMode !== "explicit") {
         ctx.addIssue({
-          code: z29.ZodIssueCode.custom,
+          code: z30.ZodIssueCode.custom,
           message: "auth.baseUrlMode must be explicit when deploymentMode=authenticated and exposure=public",
           path: ["auth", "baseUrlMode"]
         });
       }
       if (value.server.exposure === "public" && !value.auth.publicBaseUrl) {
         ctx.addIssue({
-          code: z29.ZodIssueCode.custom,
+          code: z30.ZodIssueCode.custom,
           message: "auth.publicBaseUrl is required when deploymentMode=authenticated and exposure=public",
           path: ["auth", "publicBaseUrl"]
         });
@@ -3535,6 +3713,7 @@ var init_dist = __esm({
     init_website_icons();
     init_custom_integration();
     init_chat();
+    init_messenger();
     init_validators();
     init_validators();
     init_agent_url_key();
@@ -5577,10 +5756,10 @@ var init_banner = __esm({
       "\u2588\u2588\u2551  \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551",
       "\u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D"
     ];
-    TAGLINE = "Orchestration and control platform for agent work";
+    TAGLINE = "Assign, run, review, and improve agent work";
     DESCRIPTION = [
-      "Operating layer for agent teams",
-      "Goals, tasks, knowledge, and workflows in an executable structure"
+      "Connect goals, tasks, runs, budgets, feedback, and learning",
+      "Keep agent work visible, reviewable, and tied to real outcomes"
     ];
   }
 });
@@ -7141,7 +7320,7 @@ var RUDDER_MCP_TOOL_DESCRIPTORS = [
   {
     "capabilityId": "agent.update",
     "name": "rudder_agent_update",
-    "description": "Update an agent's control-plane identity fields; defaults to the authenticated agent.",
+    "description": "Update an agent's identity fields; defaults to the authenticated agent.",
     "mutating": true,
     "requiresOrgId": false,
     "requiresAgentId": false,
@@ -7699,7 +7878,7 @@ var RUDDER_MCP_TOOL_DESCRIPTORS = [
   {
     "capabilityId": "chat.create",
     "name": "rudder_chat_create",
-    "description": "Create a chat conversation.",
+    "description": "Create a chat conversation with its first message.",
     "mutating": true,
     "requiresOrgId": true,
     "requiresAgentId": false,
@@ -8039,7 +8218,12 @@ function rudderMcpInputSchemaForCapability(id) {
   for (const key of ["clearTitle", "clearCapabilities", "clearDescription", "clearReportsTo", "enable", "enabled", "disabled", "reopen", "planMode", "includeTranscript", "includeOutput", "includeOutputs", "notifyOnIssueCreated", "errorsOnly", "chronological", "narrative", "submit", "full"]) {
     add(key, mcpBoolean(`Boolean option ${key}.`));
   }
-  return { type: "object", additionalProperties: false, properties };
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties,
+    ...id === "chat.create" ? { required: ["body"] } : {}
+  };
 }
 var RUDDER_MCP_CANONICAL_TOOL_DEFINITIONS = RUDDER_MCP_TOOL_DESCRIPTORS.map((tool) => ({
   ...tool,
@@ -8059,7 +8243,11 @@ var RUDDER_CORE_MCP_TOOL_NAMES = RUDDER_CORE_MCP_TOOL_CONTRACTS.map((tool) => to
 var RUDDER_BROWSER_MCP_TOOL_NAMES = RUDDER_BROWSER_MCP_TOOL_CONTRACTS.map((tool) => tool.name);
 
 // ../packages/agent-runtime-utils/dist/rudder-mcp.js
-var RUDDER_MCP_SERVER_NAME = "rudder-control-plane";
+var RUDDER_MCP_SERVER_NAME = "rudder-tools";
+var RUDDER_MCP_LEGACY_SERVER_NAMES = [
+  ["rudder", "control", "plane"].join("-"),
+  ["rudder", "operating", "layer"].join("-")
+];
 var RUDDER_MCP_TOOL_COUNT = RUDDER_CORE_MCP_TOOL_NAMES.length;
 var RUDDER_BROWSER_MCP_TOOL_COUNT = RUDDER_BROWSER_MCP_TOOL_NAMES.length;
 
@@ -8158,7 +8346,7 @@ var AGENT_CLI_CAPABILITIES = [
     id: "agent.update",
     command: "rudder agent update [agent-id] [--title <title>] [--description <text>]",
     category: "agent",
-    description: "Update an agent's control-plane identity fields; defaults to the authenticated agent.",
+    description: "Update an agent's identity fields; defaults to the authenticated agent.",
     mutating: true,
     contract: "agent-v1",
     requiresOrgId: false,
@@ -9020,9 +9208,9 @@ var AGENT_CLI_CAPABILITIES = [
   },
   {
     id: "chat.create",
-    command: "rudder chat create --org-id <id>",
+    command: "rudder chat create --org-id <id> --body <text>",
     category: "chat",
-    description: "Create a chat conversation.",
+    description: "Create a chat conversation with its first message.",
     mutating: true,
     contract: "agent-v1",
     requiresOrgId: true,
@@ -9211,7 +9399,7 @@ function buildAgentV1McpToolsManifest(contract = "agent-v1", options = {}) {
   return {
     schema: "rudder.agent-mcp-tools/v1",
     contract,
-    serverName: "rudder-control-plane",
+    serverName: "rudder-tools",
     tools: capabilities.map((entry) => {
       const semanticContract = semanticContractByCapability.get(entry.id);
       if (!semanticContract) {
@@ -10163,7 +10351,7 @@ function cliArgsForCapability(capabilityId, input, tempFiles, env) {
       return args;
     }
     case "chat.create": {
-      const args = ["chat", "create"];
+      const args = ["chat", "create", "--body", requiredString(input, "body")];
       pushJson(args, "--payload", input.payload);
       pushOptional(args, "--title", input.title);
       pushOptional(args, "--summary", input.summary);
@@ -10959,7 +11147,7 @@ function shortenCliValueForKey(key, value, parent) {
     return displayIdForCli(key, value, parent);
   }
   if (typeof value === "string" && isCliReferenceStringKey(key)) {
-    return value.replace(UUID_SUBSTRING_RE, (uuid) => shortUuid(uuid));
+    return value.replace(UUID_SUBSTRING_RE, (uuid2) => shortUuid(uuid2));
   }
   if (Array.isArray(value) && isCliIdListKey(key)) {
     return value.map(
@@ -10968,7 +11156,7 @@ function shortenCliValueForKey(key, value, parent) {
   }
   return toCliShortIdOutput(value);
 }
-function displayIdForCli(key, uuid, parent) {
+function displayIdForCli(key, uuid2, parent) {
   if (key === "id") {
     const directShortRef = readString(parent.shortRef);
     if (directShortRef) return directShortRef;
@@ -10976,15 +11164,15 @@ function displayIdForCli(key, uuid, parent) {
     if (issueIdentifier) return issueIdentifier;
   }
   if (isAgentIdKey(key, parent)) {
-    return formatTypedShortRef("agent", uuid);
+    return formatTypedShortRef("agent", uuid2);
   }
   if (isIssueCommentIdKey(key)) {
-    return formatTypedShortRef("issue_comment", uuid);
+    return formatTypedShortRef("issue_comment", uuid2);
   }
   if (key === "entityId" && parent.entityType === "issue") {
-    return readIssueIdentifier(parent) ?? shortUuid(uuid);
+    return readIssueIdentifier(parent) ?? shortUuid(uuid2);
   }
-  return shortUuid(uuid);
+  return shortUuid(uuid2);
 }
 function shouldShowFullIds(explicit) {
   return Boolean((explicit ?? currentCommandFullIds) || process.argv.includes("--full-ids"));
@@ -11009,12 +11197,12 @@ function isAgentIdKey(key, parent) {
 function isIssueCommentIdKey(key) {
   return key.toLowerCase().includes("commentid");
 }
-function formatTypedShortRef(kind, uuid) {
+function formatTypedShortRef(kind, uuid2) {
   const prefix = kind === "agent" ? "agt" : "cmt";
-  return `${prefix}_${shortUuid(uuid)}`;
+  return `${prefix}_${shortUuid(uuid2)}`;
 }
-function shortUuid(uuid) {
-  return uuid.replace(/-/g, "").slice(0, CLI_SHORT_UUID_LENGTH).toLowerCase();
+function shortUuid(uuid2) {
+  return uuid2.replace(/-/g, "").slice(0, CLI_SHORT_UUID_LENGTH).toLowerCase();
 }
 function readIssueIdentifier(parent) {
   const direct = readDirectIssueIdentifier(parent);
@@ -11411,7 +11599,7 @@ var RUDDER_AGENT_HEARTBEAT_INSTRUCTION = [
   "8. Treat passive follow-up as issue follow-up, not a fresh assignment.",
   "9. Treat review close-out follow-up as review follow-up; free-form accept/reject text is not a durable decision.",
   "",
-  "Use the Rudder control-plane interface available in this runtime. When exact Rudder command, Library handoff, organization-skill, or control-plane details are needed, CLI-capable runtimes may consult the bundled `rudder-docs` skill. Do not load it merely because this is a heartbeat. HTTP compatibility runtimes should follow the explicit HTTP workflow in their wake text; that workflow overrides CLI command guidance."
+  "Use the Rudder tools available in this runtime. When exact Rudder command, Library handoff, organization-skill, or operating details are needed, CLI-capable runtimes may consult the bundled `rudder-docs` skill. Do not load it merely because this is a heartbeat. HTTP compatibility runtimes should follow the explicit HTTP workflow in their wake text; that workflow overrides CLI command guidance."
 ].join("\n");
 
 // ../packages/agent-runtime-utils/dist/server-utils.cli.js
@@ -12842,11 +13030,13 @@ function registerChatCommands(program) {
     })
   );
   addCommonClientOptions(
-    chat.command("create").description(getAgentCliCapabilityById("chat.create").description).option("-O, --org-id <id>", "Organization ID").option("--payload <json>", "Raw chat create payload JSON").option("--title <title>", "Chat title").option("--summary <text>", "Chat summary").option("--preferred-agent-id <id>", "Preferred agent ID").option("--issue-creation-mode <mode>", "Issue creation mode").option("--plan-mode", "Create a plan-mode chat").action(async (opts) => {
+    chat.command("create").description(getAgentCliCapabilityById("chat.create").description).option("-O, --org-id <id>", "Organization ID").option("--payload <json>", "Raw chat create payload JSON").option("--body <text>", "First message body (reads stdin when omitted)").option("--title <title>", "Chat title").option("--summary <text>", "Chat summary").option("--preferred-agent-id <id>", "Preferred agent ID").option("--issue-creation-mode <mode>", "Issue creation mode").option("--plan-mode", "Create a plan-mode chat").action(async (opts) => {
       try {
         const ctx = resolveCommandContext(opts, { requireCompany: true });
+        const body = opts.body ?? await readStdin();
         const payload = createChatConversationSchema.parse({
           ...parseJsonObjectOption2(opts.payload, "--payload"),
+          initialMessage: { body },
           ...definedRecord2({
             title: opts.title,
             summary: opts.summary,