@rudderhq/cli 0.1.0-canary.2 → 0.1.0-canary.21

package/dist/index.js

@@ -10,7 +10,7 @@ var __export = (target, all) => {
 };
 
 // ../packages/shared/src/constants.ts
-var ORGANIZATION_STATUSES, DEPLOYMENT_MODES, DEPLOYMENT_EXPOSURES, AUTH_BASE_URL_MODES, AGENT_STATUSES, AGENT_RUNTIME_TYPES, AGENT_ROLES, AGENT_ICON_NAMES, ISSUE_STATUSES, ISSUE_PRIORITIES, 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, PROJECT_RESOURCE_ATTACHMENT_ROLES, AUTOMATION_STATUSES, AUTOMATION_CONCURRENCY_POLICIES, AUTOMATION_CATCH_UP_POLICIES, AUTOMATION_TRIGGER_SIGNING_MODES, 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, DEPLOYMENT_MODES, DEPLOYMENT_EXPOSURES, AUTH_BASE_URL_MODES, AGENT_STATUSES, AGENT_RUNTIME_TYPES, AGENT_ROLES, AGENT_ICON_NAMES, ISSUE_STATUSES, ISSUE_PRIORITIES, 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, PROJECT_RESOURCE_ATTACHMENT_ROLES, AUTOMATION_STATUSES, AUTOMATION_CONCURRENCY_POLICIES, AUTOMATION_CATCH_UP_POLICIES, AUTOMATION_TRIGGER_SIGNING_MODES, PROJECT_COLORS, 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/src/constants.ts"() {
     "use strict";
@@ -113,6 +113,7 @@ var init_constants = __esm({
       "issue_proposal",
       "operation_proposal",
       "routing_suggestion",
+      "user_input_request",
       "system_event"
     ];
     CHAT_MESSAGE_STATUSES = ["completed", "stopped", "failed"];
@@ -143,6 +144,26 @@ var init_constants = __esm({
     AUTOMATION_CONCURRENCY_POLICIES = ["coalesce_if_active", "always_enqueue", "skip_if_active"];
     AUTOMATION_CATCH_UP_POLICIES = ["skip_missed", "enqueue_missed_with_cap"];
     AUTOMATION_TRIGGER_SIGNING_MODES = ["bearer", "hmac_sha256"];
+    PROJECT_COLORS = [
+      "linear-gradient(135deg, #6366f1 0%, #8b5cf6 100%)",
+      "linear-gradient(135deg, #7c3aed 0%, #d946ef 100%)",
+      "linear-gradient(135deg, #db2777 0%, #f97316 100%)",
+      "linear-gradient(135deg, #ef4444 0%, #f59e0b 100%)",
+      "linear-gradient(135deg, #f97316 0%, #facc15 100%)",
+      "linear-gradient(135deg, #10b981 0%, #84cc16 100%)",
+      "linear-gradient(135deg, #059669 0%, #14b8a6 100%)",
+      "linear-gradient(135deg, #0d9488 0%, #06b6d4 100%)",
+      "linear-gradient(135deg, #0284c7 0%, #2563eb 100%)",
+      "linear-gradient(135deg, #2563eb 0%, #4f46e5 100%)",
+      "linear-gradient(135deg, #f43f5e 0%, #ec4899 100%)",
+      "linear-gradient(135deg, #be123c 0%, #7c2d12 100%)",
+      "linear-gradient(135deg, #a16207 0%, #ca8a04 100%)",
+      "linear-gradient(135deg, #16a34a 0%, #0f766e 100%)",
+      "linear-gradient(135deg, #0891b2 0%, #4338ca 100%)",
+      "linear-gradient(135deg, #6d28d9 0%, #be185d 100%)",
+      "linear-gradient(135deg, #475569 0%, #0f766e 100%)",
+      "linear-gradient(135deg, #334155 0%, #7c3aed 100%)"
+    ];
     APPROVAL_TYPES = [
       "hire_agent",
       "approve_ceo_strategy",
@@ -377,7 +398,7 @@ var init_observability = __esm({
 
 // ../packages/shared/src/validators/instance.ts
 import { z } from "zod";
-var instanceLocaleSchema, instanceGeneralSettingsSchema, patchInstanceGeneralSettingsSchema, instanceNotificationSettingsSchema, patchInstanceNotificationSettingsSchema, instanceLangfuseSettingsSchema, patchInstanceLangfuseSettingsSchema, operatorProfileSettingsSchema, patchOperatorProfileSettingsSchema, instanceExperimentalSettingsSchema, patchInstanceExperimentalSettingsSchema, instancePathPickerSelectionTypeSchema, instancePathPickerRequestSchema, instancePathPickerResultSchema;
+var instanceLocaleSchema, instanceGeneralSettingsSchema, patchInstanceGeneralSettingsSchema, instanceNotificationSettingsSchema, patchInstanceNotificationSettingsSchema, instanceLangfuseSettingsSchema, patchInstanceLangfuseSettingsSchema, operatorProfileSettingsSchema, patchOperatorProfileSettingsSchema, instancePathPickerSelectionTypeSchema, instancePathPickerRequestSchema, instancePathPickerResultSchema;
 var init_instance = __esm({
   "../packages/shared/src/validators/instance.ts"() {
     "use strict";
@@ -415,10 +436,6 @@ var init_instance = __esm({
       moreAboutYou: z.string().max(2e3).default("")
     }).strict();
     patchOperatorProfileSettingsSchema = operatorProfileSettingsSchema.partial();
-    instanceExperimentalSettingsSchema = z.object({
-      autoRestartDevServerWhenIdle: z.boolean().default(false)
-    }).strict();
-    patchInstanceExperimentalSettingsSchema = instanceExperimentalSettingsSchema.partial();
     instancePathPickerSelectionTypeSchema = z.enum(["file", "directory"]);
     instancePathPickerRequestSchema = z.object({
       selectionType: instancePathPickerSelectionTypeSchema
@@ -464,174 +481,252 @@ var init_budget = __esm({
   }
 });
 
-// ../packages/shared/src/validators/organization.ts
+// ../packages/shared/src/validators/model-fallbacks.ts
 import { z as z3 } from "zod";
-var logoAssetIdSchema, brandColorSchema, createOrganizationSchema, updateOrganizationSchema, updateOrganizationBrandingSchema, updateOrganizationWorkspaceFileSchema;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateModelFallbacksConfig(value, ctx, pathPrefix) {
+  const fallbackModels = value.modelFallbacks;
+  if (fallbackModels === void 0) return;
+  if (!Array.isArray(fallbackModels)) {
+    ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      message: "modelFallbacks must be an array",
+      path: [...pathPrefix, "modelFallbacks"]
+    });
+    return;
+  }
+  fallbackModels.forEach((fallback, index63) => {
+    if (typeof fallback === "string") {
+      if (fallback.trim().length === 0) {
+        ctx.addIssue({
+          code: z3.ZodIssueCode.custom,
+          message: "modelFallbacks string entries must be non-empty",
+          path: [...pathPrefix, "modelFallbacks", index63]
+        });
+      }
+      return;
+    }
+    if (!isRecord(fallback)) {
+      ctx.addIssue({
+        code: z3.ZodIssueCode.custom,
+        message: "modelFallbacks entries must be strings or runtime/model objects",
+        path: [...pathPrefix, "modelFallbacks", index63]
+      });
+      return;
+    }
+    if (typeof fallback.agentRuntimeType !== "string" || fallback.agentRuntimeType.trim().length === 0) {
+      ctx.addIssue({
+        code: z3.ZodIssueCode.custom,
+        message: "modelFallbacks entries must include agentRuntimeType",
+        path: [...pathPrefix, "modelFallbacks", index63, "agentRuntimeType"]
+      });
+    } else if (!agentRuntimeTypes.has(fallback.agentRuntimeType)) {
+      ctx.addIssue({
+        code: z3.ZodIssueCode.custom,
+        message: "modelFallbacks entries must include a valid agentRuntimeType",
+        path: [...pathPrefix, "modelFallbacks", index63, "agentRuntimeType"]
+      });
+    }
+    if (typeof fallback.model !== "string" || fallback.model.trim().length === 0) {
+      ctx.addIssue({
+        code: z3.ZodIssueCode.custom,
+        message: "modelFallbacks entries must include model",
+        path: [...pathPrefix, "modelFallbacks", index63, "model"]
+      });
+    }
+    if (fallback.config !== void 0 && !isRecord(fallback.config)) {
+      ctx.addIssue({
+        code: z3.ZodIssueCode.custom,
+        message: "modelFallbacks entry config must be an object",
+        path: [...pathPrefix, "modelFallbacks", index63, "config"]
+      });
+    }
+  });
+}
+var agentRuntimeTypes;
+var init_model_fallbacks = __esm({
+  "../packages/shared/src/validators/model-fallbacks.ts"() {
+    "use strict";
+    init_constants();
+    agentRuntimeTypes = new Set(AGENT_RUNTIME_TYPES);
+  }
+});
+
+// ../packages/shared/src/validators/organization.ts
+import { z as z4 } from "zod";
+var logoAssetIdSchema, brandColorSchema, defaultChatRuntimeConfigSchema, createOrganizationSchema, updateOrganizationSchema, updateOrganizationBrandingSchema, updateOrganizationWorkspaceFileSchema;
 var init_organization = __esm({
   "../packages/shared/src/validators/organization.ts"() {
     "use strict";
     init_constants();
-    logoAssetIdSchema = z3.string().uuid().nullable().optional();
-    brandColorSchema = z3.string().regex(/^#[0-9a-fA-F]{6}$/).nullable().optional();
-    createOrganizationSchema = z3.object({
-      name: z3.string().min(1),
-      description: z3.string().optional().nullable(),
-      budgetMonthlyCents: z3.number().int().nonnegative().optional().default(0),
-      defaultChatIssueCreationMode: z3.enum(CHAT_ISSUE_CREATION_MODES).optional().default("manual_approval"),
-      defaultChatAgentRuntimeType: z3.enum(AGENT_RUNTIME_TYPES).optional().nullable(),
-      defaultChatAgentRuntimeConfig: z3.record(z3.unknown()).optional().nullable(),
+    init_model_fallbacks();
+    logoAssetIdSchema = z4.string().uuid().nullable().optional();
+    brandColorSchema = z4.string().regex(/^#[0-9a-fA-F]{6}$/).nullable().optional();
+    defaultChatRuntimeConfigSchema = z4.record(z4.unknown()).superRefine((value, ctx) => {
+      validateModelFallbacksConfig(value, ctx, []);
+    });
+    createOrganizationSchema = z4.object({
+      name: z4.string().min(1),
+      description: z4.string().optional().nullable(),
+      budgetMonthlyCents: z4.number().int().nonnegative().optional().default(0),
+      defaultChatIssueCreationMode: z4.enum(CHAT_ISSUE_CREATION_MODES).optional().default("manual_approval"),
+      defaultChatAgentRuntimeType: z4.enum(AGENT_RUNTIME_TYPES).optional().nullable(),
+      defaultChatAgentRuntimeConfig: defaultChatRuntimeConfigSchema.optional().nullable(),
       brandColor: brandColorSchema,
-      requireBoardApprovalForNewAgents: z3.boolean().optional()
+      requireBoardApprovalForNewAgents: z4.boolean().optional()
     });
     updateOrganizationSchema = createOrganizationSchema.partial().extend({
-      status: z3.enum(ORGANIZATION_STATUSES).optional(),
-      spentMonthlyCents: z3.number().int().nonnegative().optional(),
-      requireBoardApprovalForNewAgents: z3.boolean().optional(),
-      defaultChatIssueCreationMode: z3.enum(CHAT_ISSUE_CREATION_MODES).optional(),
-      defaultChatAgentRuntimeType: z3.enum(AGENT_RUNTIME_TYPES).optional().nullable(),
-      defaultChatAgentRuntimeConfig: z3.record(z3.unknown()).optional().nullable(),
+      status: z4.enum(ORGANIZATION_STATUSES).optional(),
+      spentMonthlyCents: z4.number().int().nonnegative().optional(),
+      requireBoardApprovalForNewAgents: z4.boolean().optional(),
+      defaultChatIssueCreationMode: z4.enum(CHAT_ISSUE_CREATION_MODES).optional(),
+      defaultChatAgentRuntimeType: z4.enum(AGENT_RUNTIME_TYPES).optional().nullable(),
+      defaultChatAgentRuntimeConfig: defaultChatRuntimeConfigSchema.optional().nullable(),
       brandColor: brandColorSchema,
       logoAssetId: logoAssetIdSchema
     });
-    updateOrganizationBrandingSchema = z3.object({
-      name: z3.string().min(1).optional(),
-      description: z3.string().nullable().optional(),
+    updateOrganizationBrandingSchema = z4.object({
+      name: z4.string().min(1).optional(),
+      description: z4.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 = z3.object({
-      content: z3.string()
+    updateOrganizationWorkspaceFileSchema = z4.object({
+      content: z4.string()
     });
   }
 });
 
 // ../packages/shared/src/validators/resource.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var organizationResourceKindSchema, projectResourceAttachmentRoleSchema, createOrganizationResourceSchema, updateOrganizationResourceSchema, projectResourceAttachmentInputSchema, updateProjectResourceAttachmentSchema, createProjectInlineResourceSchema;
 var init_resource = __esm({
   "../packages/shared/src/validators/resource.ts"() {
     "use strict";
     init_constants();
-    organizationResourceKindSchema = z4.enum(ORGANIZATION_RESOURCE_KINDS);
-    projectResourceAttachmentRoleSchema = z4.enum(PROJECT_RESOURCE_ATTACHMENT_ROLES);
-    createOrganizationResourceSchema = z4.object({
-      name: z4.string().min(1),
+    organizationResourceKindSchema = z5.enum(ORGANIZATION_RESOURCE_KINDS);
+    projectResourceAttachmentRoleSchema = z5.enum(PROJECT_RESOURCE_ATTACHMENT_ROLES);
+    createOrganizationResourceSchema = z5.object({
+      name: z5.string().min(1),
       kind: organizationResourceKindSchema,
-      locator: z4.string().min(1),
-      description: z4.string().optional().nullable(),
-      metadata: z4.record(z4.unknown()).optional().nullable()
+      locator: z5.string().min(1),
+      description: z5.string().optional().nullable(),
+      metadata: z5.record(z5.unknown()).optional().nullable()
     });
-    updateOrganizationResourceSchema = z4.object({
-      name: z4.string().min(1).optional(),
+    updateOrganizationResourceSchema = z5.object({
+      name: z5.string().min(1).optional(),
       kind: organizationResourceKindSchema.optional(),
-      locator: z4.string().min(1).optional(),
-      description: z4.string().optional().nullable(),
-      metadata: z4.record(z4.unknown()).optional().nullable()
+      locator: z5.string().min(1).optional(),
+      description: z5.string().optional().nullable(),
+      metadata: z5.record(z5.unknown()).optional().nullable()
     }).strict();
-    projectResourceAttachmentInputSchema = z4.object({
-      resourceId: z4.string().uuid(),
+    projectResourceAttachmentInputSchema = z5.object({
+      resourceId: z5.string().uuid(),
       role: projectResourceAttachmentRoleSchema.optional(),
-      note: z4.string().optional().nullable(),
-      sortOrder: z4.number().int().nonnegative().optional()
+      note: z5.string().optional().nullable(),
+      sortOrder: z5.number().int().nonnegative().optional()
     }).strict();
-    updateProjectResourceAttachmentSchema = z4.object({
+    updateProjectResourceAttachmentSchema = z5.object({
       role: projectResourceAttachmentRoleSchema.optional(),
-      note: z4.string().optional().nullable(),
-      sortOrder: z4.number().int().nonnegative().optional()
+      note: z5.string().optional().nullable(),
+      sortOrder: z5.number().int().nonnegative().optional()
     }).strict();
     createProjectInlineResourceSchema = createOrganizationResourceSchema.extend({
       role: projectResourceAttachmentRoleSchema.optional(),
-      note: z4.string().optional().nullable(),
-      sortOrder: z4.number().int().nonnegative().optional()
+      note: z5.string().optional().nullable(),
+      sortOrder: z5.number().int().nonnegative().optional()
     }).strict();
   }
 });
 
 // ../packages/shared/src/validators/chat.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var chatConversationStatusSchema, chatIssueCreationModeSchema, chatMessageRoleSchema, chatMessageKindSchema, chatMessageStatusSchema, chatContextEntityTypeSchema, createChatContextLinkSchema, createChatConversationSchema, setChatProjectContextSchema, updateChatConversationSchema, addChatMessageSchema, createChatAttachmentMetadataSchema, chatIssueProposalSchema, convertChatToIssueSchema, chatOperationProposalSchema, resolveChatOperationProposalSchema, updateChatConversationUserStateSchema;
 var init_chat = __esm({
   "../packages/shared/src/validators/chat.ts"() {
     "use strict";
     init_constants();
-    chatConversationStatusSchema = z5.enum(CHAT_CONVERSATION_STATUSES);
-    chatIssueCreationModeSchema = z5.enum(CHAT_ISSUE_CREATION_MODES);
-    chatMessageRoleSchema = z5.enum(CHAT_MESSAGE_ROLES);
-    chatMessageKindSchema = z5.enum(CHAT_MESSAGE_KINDS);
-    chatMessageStatusSchema = z5.enum(CHAT_MESSAGE_STATUSES);
-    chatContextEntityTypeSchema = z5.enum(CHAT_CONTEXT_ENTITY_TYPES);
-    createChatContextLinkSchema = z5.object({
+    chatConversationStatusSchema = z6.enum(CHAT_CONVERSATION_STATUSES);
+    chatIssueCreationModeSchema = z6.enum(CHAT_ISSUE_CREATION_MODES);
+    chatMessageRoleSchema = z6.enum(CHAT_MESSAGE_ROLES);
+    chatMessageKindSchema = z6.enum(CHAT_MESSAGE_KINDS);
+    chatMessageStatusSchema = z6.enum(CHAT_MESSAGE_STATUSES);
+    chatContextEntityTypeSchema = z6.enum(CHAT_CONTEXT_ENTITY_TYPES);
+    createChatContextLinkSchema = z6.object({
       entityType: chatContextEntityTypeSchema,
-      entityId: z5.string().min(1),
-      metadata: z5.record(z5.unknown()).optional().nullable()
+      entityId: z6.string().min(1),
+      metadata: z6.record(z6.unknown()).optional().nullable()
     });
-    createChatConversationSchema = z5.object({
-      title: z5.string().trim().min(1).max(200).optional(),
-      summary: z5.string().trim().max(5e3).optional().nullable(),
-      preferredAgentId: z5.string().uuid().optional().nullable(),
+    createChatConversationSchema = z6.object({
+      title: z6.string().trim().min(1).max(200).optional(),
+      summary: z6.string().trim().max(5e3).optional().nullable(),
+      preferredAgentId: z6.string().uuid().optional().nullable(),
       issueCreationMode: chatIssueCreationModeSchema.optional(),
-      planMode: z5.boolean().optional(),
-      contextLinks: z5.array(createChatContextLinkSchema).optional().default([])
+      planMode: z6.boolean().optional(),
+      contextLinks: z6.array(createChatContextLinkSchema).optional().default([])
     });
-    setChatProjectContextSchema = z5.object({
-      projectId: z5.string().uuid().optional().nullable()
+    setChatProjectContextSchema = z6.object({
+      projectId: z6.string().uuid().optional().nullable()
     });
     updateChatConversationSchema = createChatConversationSchema.partial().extend({
       status: chatConversationStatusSchema.optional(),
-      routedAgentId: z5.string().uuid().optional().nullable(),
-      primaryIssueId: z5.string().uuid().optional().nullable(),
-      resolvedAt: z5.string().datetime().optional().nullable()
+      routedAgentId: z6.string().uuid().optional().nullable(),
+      primaryIssueId: z6.string().uuid().optional().nullable(),
+      resolvedAt: z6.string().datetime().optional().nullable()
     });
-    addChatMessageSchema = z5.object({
-      body: z5.string().trim().min(1).max(2e4),
-      editUserMessageId: z5.string().uuid().optional().nullable()
+    addChatMessageSchema = z6.object({
+      body: z6.string().trim().min(1).max(2e4),
+      editUserMessageId: z6.string().uuid().optional().nullable()
     });
-    createChatAttachmentMetadataSchema = z5.object({
-      messageId: z5.string().uuid()
+    createChatAttachmentMetadataSchema = z6.object({
+      messageId: z6.string().uuid()
     });
-    chatIssueProposalSchema = z5.object({
-      title: z5.string().trim().min(1).max(200),
-      description: z5.string().trim().min(1).max(2e4),
-      priority: z5.enum(["critical", "high", "medium", "low"]).optional().default("medium"),
-      projectId: z5.string().uuid().optional().nullable(),
-      goalId: z5.string().uuid().optional().nullable(),
-      parentId: z5.string().uuid().optional().nullable(),
-      assigneeAgentId: z5.string().uuid().optional().nullable(),
-      assigneeUserId: z5.string().trim().optional().nullable()
+    chatIssueProposalSchema = z6.object({
+      title: z6.string().trim().min(1).max(200),
+      description: z6.string().trim().min(1).max(2e4),
+      priority: z6.enum(["critical", "high", "medium", "low"]).optional().default("medium"),
+      status: z6.enum(ISSUE_STATUSES).optional(),
+      projectId: z6.string().uuid().optional().nullable(),
+      goalId: z6.string().uuid().optional().nullable(),
+      parentId: z6.string().uuid().optional().nullable(),
+      assigneeAgentId: z6.string().uuid().optional().nullable(),
+      assigneeUserId: z6.string().trim().optional().nullable()
     });
-    convertChatToIssueSchema = z5.object({
-      messageId: z5.string().uuid().optional().nullable(),
+    convertChatToIssueSchema = z6.object({
+      messageId: z6.string().uuid().optional().nullable(),
       proposal: chatIssueProposalSchema.optional()
     });
-    chatOperationProposalSchema = z5.object({
-      targetType: z5.enum(["organization", "agent"]),
-      targetId: z5.string().min(1),
-      summary: z5.string().trim().min(1).max(500),
-      patch: z5.record(z5.unknown())
+    chatOperationProposalSchema = z6.object({
+      targetType: z6.enum(["organization", "agent"]),
+      targetId: z6.string().min(1),
+      summary: z6.string().trim().min(1).max(500),
+      patch: z6.record(z6.unknown())
     });
-    resolveChatOperationProposalSchema = z5.object({
-      action: z5.enum(["approve", "reject", "requestRevision"]),
-      decisionNote: z5.string().trim().max(5e3).optional().nullable()
+    resolveChatOperationProposalSchema = z6.object({
+      action: z6.enum(["approve", "reject", "requestRevision"]),
+      decisionNote: z6.string().trim().max(5e3).optional().nullable()
     });
-    updateChatConversationUserStateSchema = z5.object({
-      pinned: z5.boolean().optional()
+    updateChatConversationUserStateSchema = z6.object({
+      pinned: z6.boolean().optional()
     });
   }
 });
 
 // ../packages/shared/src/validators/organization-skill.ts
-import { z as z6 } from "zod";
+import { z as z7 } 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/src/validators/organization-skill.ts"() {
     "use strict";
-    organizationSkillSourceTypeSchema = z6.enum(["local_path", "github", "url", "catalog", "skills_sh"]);
-    organizationSkillTrustLevelSchema = z6.enum(["markdown_only", "assets", "scripts_executables"]);
-    organizationSkillCompatibilitySchema = z6.enum(["compatible", "unknown", "invalid"]);
-    organizationSkillSourceBadgeSchema = z6.enum([
+    organizationSkillSourceTypeSchema = z7.enum(["local_path", "github", "url", "catalog", "skills_sh"]);
+    organizationSkillTrustLevelSchema = z7.enum(["markdown_only", "assets", "scripts_executables"]);
+    organizationSkillCompatibilitySchema = z7.enum(["compatible", "unknown", "invalid"]);
+    organizationSkillSourceBadgeSchema = z7.enum([
       "rudder",
       "community",
       "github",
@@ -640,157 +735,157 @@ var init_organization_skill = __esm({
       "catalog",
       "skills_sh"
     ]);
-    organizationSkillFileInventoryEntrySchema = z6.object({
-      path: z6.string().min(1),
-      kind: z6.enum(["skill", "markdown", "reference", "script", "asset", "other"])
+    organizationSkillFileInventoryEntrySchema = z7.object({
+      path: z7.string().min(1),
+      kind: z7.enum(["skill", "markdown", "reference", "script", "asset", "other"])
     });
-    organizationSkillSchema = z6.object({
-      id: z6.string().uuid(),
-      orgId: z6.string().uuid(),
-      key: z6.string().min(1),
-      slug: z6.string().min(1),
-      name: z6.string().min(1),
-      description: z6.string().nullable(),
-      markdown: z6.string(),
+    organizationSkillSchema = z7.object({
+      id: z7.string().uuid(),
+      orgId: z7.string().uuid(),
+      key: z7.string().min(1),
+      slug: z7.string().min(1),
+      name: z7.string().min(1),
+      description: z7.string().nullable(),
+      markdown: z7.string(),
       sourceType: organizationSkillSourceTypeSchema,
-      sourceLocator: z6.string().nullable(),
-      sourceRef: z6.string().nullable(),
+      sourceLocator: z7.string().nullable(),
+      sourceRef: z7.string().nullable(),
       trustLevel: organizationSkillTrustLevelSchema,
       compatibility: organizationSkillCompatibilitySchema,
-      fileInventory: z6.array(organizationSkillFileInventoryEntrySchema).default([]),
-      metadata: z6.record(z6.unknown()).nullable(),
-      createdAt: z6.coerce.date(),
-      updatedAt: z6.coerce.date()
+      fileInventory: z7.array(organizationSkillFileInventoryEntrySchema).default([]),
+      metadata: z7.record(z7.unknown()).nullable(),
+      createdAt: z7.coerce.date(),
+      updatedAt: z7.coerce.date()
     });
     organizationSkillListItemSchema = organizationSkillSchema.extend({
-      attachedAgentCount: z6.number().int().nonnegative(),
-      editable: z6.boolean(),
-      editableReason: z6.string().nullable(),
-      sourceLabel: z6.string().nullable(),
+      attachedAgentCount: z7.number().int().nonnegative(),
+      editable: z7.boolean(),
+      editableReason: z7.string().nullable(),
+      sourceLabel: z7.string().nullable(),
       sourceBadge: organizationSkillSourceBadgeSchema,
-      sourcePath: z6.string().nullable(),
-      workspaceEditPath: z6.string().nullable()
+      sourcePath: z7.string().nullable(),
+      workspaceEditPath: z7.string().nullable()
     });
-    organizationSkillUsageAgentSchema = z6.object({
-      id: z6.string().uuid(),
-      name: z6.string().min(1),
-      urlKey: z6.string().min(1),
-      agentRuntimeType: z6.string().min(1),
-      desired: z6.boolean(),
-      actualState: z6.string().nullable()
+    organizationSkillUsageAgentSchema = z7.object({
+      id: z7.string().uuid(),
+      name: z7.string().min(1),
+      urlKey: z7.string().min(1),
+      agentRuntimeType: z7.string().min(1),
+      desired: z7.boolean(),
+      actualState: z7.string().nullable()
     });
     organizationSkillDetailSchema = organizationSkillSchema.extend({
-      attachedAgentCount: z6.number().int().nonnegative(),
-      usedByAgents: z6.array(organizationSkillUsageAgentSchema).default([]),
-      editable: z6.boolean(),
-      editableReason: z6.string().nullable(),
-      sourceLabel: z6.string().nullable(),
+      attachedAgentCount: z7.number().int().nonnegative(),
+      usedByAgents: z7.array(organizationSkillUsageAgentSchema).default([]),
+      editable: z7.boolean(),
+      editableReason: z7.string().nullable(),
+      sourceLabel: z7.string().nullable(),
       sourceBadge: organizationSkillSourceBadgeSchema,
-      sourcePath: z6.string().nullable(),
-      workspaceEditPath: z6.string().nullable()
+      sourcePath: z7.string().nullable(),
+      workspaceEditPath: z7.string().nullable()
     });
-    organizationSkillUpdateStatusSchema = z6.object({
-      supported: z6.boolean(),
-      reason: z6.string().nullable(),
-      trackingRef: z6.string().nullable(),
-      currentRef: z6.string().nullable(),
-      latestRef: z6.string().nullable(),
-      hasUpdate: z6.boolean()
+    organizationSkillUpdateStatusSchema = z7.object({
+      supported: z7.boolean(),
+      reason: z7.string().nullable(),
+      trackingRef: z7.string().nullable(),
+      currentRef: z7.string().nullable(),
+      latestRef: z7.string().nullable(),
+      hasUpdate: z7.boolean()
     });
-    organizationSkillImportSchema = z6.object({
-      source: z6.string().min(1)
+    organizationSkillImportSchema = z7.object({
+      source: z7.string().min(1)
     });
-    organizationSkillProjectScanRequestSchema = z6.object({
-      projectIds: z6.array(z6.string().uuid()).optional(),
-      workspaceIds: z6.array(z6.string().uuid()).optional()
+    organizationSkillProjectScanRequestSchema = z7.object({
+      projectIds: z7.array(z7.string().uuid()).optional(),
+      workspaceIds: z7.array(z7.string().uuid()).optional()
     });
-    organizationSkillProjectScanSkippedSchema = z6.object({
-      projectId: z6.string().uuid(),
-      projectName: z6.string().min(1),
-      workspaceId: z6.string().uuid().nullable(),
-      workspaceName: z6.string().nullable(),
-      path: z6.string().nullable(),
-      reason: z6.string().min(1)
+    organizationSkillProjectScanSkippedSchema = z7.object({
+      projectId: z7.string().uuid(),
+      projectName: z7.string().min(1),
+      workspaceId: z7.string().uuid().nullable(),
+      workspaceName: z7.string().nullable(),
+      path: z7.string().nullable(),
+      reason: z7.string().min(1)
     });
-    organizationSkillProjectScanConflictSchema = z6.object({
-      slug: z6.string().min(1),
-      key: z6.string().min(1),
-      projectId: z6.string().uuid(),
-      projectName: z6.string().min(1),
-      workspaceId: z6.string().uuid(),
-      workspaceName: z6.string().min(1),
-      path: z6.string().min(1),
-      existingSkillId: z6.string().uuid(),
-      existingSkillKey: z6.string().min(1),
-      existingSourceLocator: z6.string().nullable(),
-      reason: z6.string().min(1)
+    organizationSkillProjectScanConflictSchema = z7.object({
+      slug: z7.string().min(1),
+      key: z7.string().min(1),
+      projectId: z7.string().uuid(),
+      projectName: z7.string().min(1),
+      workspaceId: z7.string().uuid(),
+      workspaceName: z7.string().min(1),
+      path: z7.string().min(1),
+      existingSkillId: z7.string().uuid(),
+      existingSkillKey: z7.string().min(1),
+      existingSourceLocator: z7.string().nullable(),
+      reason: z7.string().min(1)
     });
-    organizationSkillProjectScanResultSchema = z6.object({
-      scannedProjects: z6.number().int().nonnegative(),
-      scannedWorkspaces: z6.number().int().nonnegative(),
-      discovered: z6.number().int().nonnegative(),
-      imported: z6.array(organizationSkillSchema),
-      updated: z6.array(organizationSkillSchema),
-      skipped: z6.array(organizationSkillProjectScanSkippedSchema),
-      conflicts: z6.array(organizationSkillProjectScanConflictSchema),
-      warnings: z6.array(z6.string())
+    organizationSkillProjectScanResultSchema = z7.object({
+      scannedProjects: z7.number().int().nonnegative(),
+      scannedWorkspaces: z7.number().int().nonnegative(),
+      discovered: z7.number().int().nonnegative(),
+      imported: z7.array(organizationSkillSchema),
+      updated: z7.array(organizationSkillSchema),
+      skipped: z7.array(organizationSkillProjectScanSkippedSchema),
+      conflicts: z7.array(organizationSkillProjectScanConflictSchema),
+      warnings: z7.array(z7.string())
     });
-    organizationSkillLocalScanRequestSchema = z6.object({
-      roots: z6.array(z6.string().min(1)).optional()
+    organizationSkillLocalScanRequestSchema = z7.object({
+      roots: z7.array(z7.string().min(1)).optional()
     });
-    organizationSkillLocalScanSkippedSchema = z6.object({
-      root: z6.string().min(1),
-      path: z6.string().nullable(),
-      reason: z6.string().min(1)
+    organizationSkillLocalScanSkippedSchema = z7.object({
+      root: z7.string().min(1),
+      path: z7.string().nullable(),
+      reason: z7.string().min(1)
     });
-    organizationSkillLocalScanConflictSchema = z6.object({
-      root: z6.string().min(1),
-      path: z6.string().min(1),
-      slug: z6.string().min(1),
-      key: z6.string().min(1),
-      existingSkillId: z6.string().uuid(),
-      existingSkillKey: z6.string().min(1),
-      existingSourceLocator: z6.string().nullable(),
-      reason: z6.string().min(1)
+    organizationSkillLocalScanConflictSchema = z7.object({
+      root: z7.string().min(1),
+      path: z7.string().min(1),
+      slug: z7.string().min(1),
+      key: z7.string().min(1),
+      existingSkillId: z7.string().uuid(),
+      existingSkillKey: z7.string().min(1),
+      existingSourceLocator: z7.string().nullable(),
+      reason: z7.string().min(1)
     });
-    organizationSkillLocalScanResultSchema = z6.object({
-      scannedRoots: z6.number().int().nonnegative(),
-      discovered: z6.number().int().nonnegative(),
-      imported: z6.array(organizationSkillSchema),
-      updated: z6.array(organizationSkillSchema),
-      skipped: z6.array(organizationSkillLocalScanSkippedSchema),
-      conflicts: z6.array(organizationSkillLocalScanConflictSchema),
-      warnings: z6.array(z6.string())
+    organizationSkillLocalScanResultSchema = z7.object({
+      scannedRoots: z7.number().int().nonnegative(),
+      discovered: z7.number().int().nonnegative(),
+      imported: z7.array(organizationSkillSchema),
+      updated: z7.array(organizationSkillSchema),
+      skipped: z7.array(organizationSkillLocalScanSkippedSchema),
+      conflicts: z7.array(organizationSkillLocalScanConflictSchema),
+      warnings: z7.array(z7.string())
     });
-    organizationSkillCreateSchema = z6.object({
-      name: z6.string().min(1),
-      slug: z6.string().min(1).nullable().optional(),
-      description: z6.string().nullable().optional(),
-      markdown: z6.string().nullable().optional()
+    organizationSkillCreateSchema = z7.object({
+      name: z7.string().min(1),
+      slug: z7.string().min(1).nullable().optional(),
+      description: z7.string().nullable().optional(),
+      markdown: z7.string().nullable().optional()
     });
-    organizationSkillFileDetailSchema = z6.object({
-      skillId: z6.string().uuid(),
-      path: z6.string().min(1),
-      kind: z6.enum(["skill", "markdown", "reference", "script", "asset", "other"]),
-      content: z6.string(),
-      language: z6.string().nullable(),
-      markdown: z6.boolean(),
-      editable: z6.boolean()
+    organizationSkillFileDetailSchema = z7.object({
+      skillId: z7.string().uuid(),
+      path: z7.string().min(1),
+      kind: z7.enum(["skill", "markdown", "reference", "script", "asset", "other"]),
+      content: z7.string(),
+      language: z7.string().nullable(),
+      markdown: z7.boolean(),
+      editable: z7.boolean()
     });
-    organizationSkillFileUpdateSchema = z6.object({
-      path: z6.string().min(1),
-      content: z6.string()
+    organizationSkillFileUpdateSchema = z7.object({
+      path: z7.string().min(1),
+      content: z7.string()
     });
   }
 });
 
 // ../packages/shared/src/validators/adapter-skills.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var agentSkillStateSchema, agentSkillOriginSchema, agentSkillSourceClassSchema, agentSkillSyncModeSchema, agentSkillEntrySchema, agentSkillSnapshotSchema, agentSkillSyncSchema;
 var init_adapter_skills = __esm({
   "../packages/shared/src/validators/adapter-skills.ts"() {
     "use strict";
-    agentSkillStateSchema = z7.enum([
+    agentSkillStateSchema = z8.enum([
       "available",
       "configured",
       "installed",
@@ -798,416 +893,436 @@ var init_adapter_skills = __esm({
       "stale",
       "external"
     ]);
-    agentSkillOriginSchema = z7.preprocess((value) => {
+    agentSkillOriginSchema = z8.preprocess((value) => {
       if (value === "company_managed") return "organization_managed";
       return value;
-    }, z7.enum([
+    }, z8.enum([
       "organization_managed",
       "user_installed",
       "external_unknown"
     ]));
-    agentSkillSourceClassSchema = z7.enum([
+    agentSkillSourceClassSchema = z8.enum([
       "bundled",
       "organization",
       "agent_home",
       "global",
       "adapter_home"
     ]);
-    agentSkillSyncModeSchema = z7.enum([
+    agentSkillSyncModeSchema = z8.enum([
       "unsupported",
       "persistent",
       "ephemeral"
     ]);
-    agentSkillEntrySchema = z7.object({
-      key: z7.string().min(1),
-      selectionKey: z7.string().min(1),
-      runtimeName: z7.string().min(1).nullable(),
-      description: z7.string().nullable().optional(),
-      desired: z7.boolean(),
-      configurable: z7.boolean(),
-      alwaysEnabled: z7.boolean(),
-      managed: z7.boolean(),
+    agentSkillEntrySchema = z8.object({
+      key: z8.string().min(1),
+      selectionKey: z8.string().min(1),
+      runtimeName: z8.string().min(1).nullable(),
+      description: z8.string().nullable().optional(),
+      desired: z8.boolean(),
+      configurable: z8.boolean(),
+      alwaysEnabled: z8.boolean(),
+      managed: z8.boolean(),
       state: agentSkillStateSchema,
       sourceClass: agentSkillSourceClassSchema,
       origin: agentSkillOriginSchema.optional(),
-      originLabel: z7.string().nullable().optional(),
-      locationLabel: z7.string().nullable().optional(),
-      readOnly: z7.boolean().optional(),
-      sourcePath: z7.string().nullable().optional(),
-      targetPath: z7.string().nullable().optional(),
-      workspaceEditPath: z7.string().nullable().optional(),
-      detail: z7.string().nullable().optional()
+      originLabel: z8.string().nullable().optional(),
+      locationLabel: z8.string().nullable().optional(),
+      readOnly: z8.boolean().optional(),
+      sourcePath: z8.string().nullable().optional(),
+      targetPath: z8.string().nullable().optional(),
+      workspaceEditPath: z8.string().nullable().optional(),
+      detail: z8.string().nullable().optional()
     });
-    agentSkillSnapshotSchema = z7.object({
-      agentRuntimeType: z7.string().min(1),
-      supported: z7.boolean(),
+    agentSkillSnapshotSchema = z8.object({
+      agentRuntimeType: z8.string().min(1),
+      supported: z8.boolean(),
       mode: agentSkillSyncModeSchema,
-      desiredSkills: z7.array(z7.string().min(1)),
-      entries: z7.array(agentSkillEntrySchema),
-      warnings: z7.array(z7.string())
+      desiredSkills: z8.array(z8.string().min(1)),
+      entries: z8.array(agentSkillEntrySchema),
+      warnings: z8.array(z8.string())
     });
-    agentSkillSyncSchema = z7.object({
-      desiredSkills: z7.array(z7.string().min(1))
+    agentSkillSyncSchema = z8.object({
+      desiredSkills: z8.array(z8.string().min(1))
     });
   }
 });
 
 // ../packages/shared/src/validators/organization-portability.ts
-import { z as z8 } from "zod";
+import { z as z9 } 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/src/validators/organization-portability.ts"() {
     "use strict";
-    portabilityIncludeSchema = z8.object({
-      organization: z8.boolean().optional(),
-      agents: z8.boolean().optional(),
-      projects: z8.boolean().optional(),
-      issues: z8.boolean().optional(),
-      skills: z8.boolean().optional()
+    portabilityIncludeSchema = z9.object({
+      organization: z9.boolean().optional(),
+      agents: z9.boolean().optional(),
+      projects: z9.boolean().optional(),
+      issues: z9.boolean().optional(),
+      skills: z9.boolean().optional()
     }).partial();
-    portabilityEnvInputSchema = z8.object({
-      key: z8.string().min(1),
-      description: z8.string().nullable(),
-      agentSlug: z8.string().min(1).nullable(),
-      kind: z8.enum(["secret", "plain"]),
-      requirement: z8.enum(["required", "optional"]),
-      defaultValue: z8.string().nullable(),
-      portability: z8.enum(["portable", "system_dependent"])
+    portabilityEnvInputSchema = z9.object({
+      key: z9.string().min(1),
+      description: z9.string().nullable(),
+      agentSlug: z9.string().min(1).nullable(),
+      kind: z9.enum(["secret", "plain"]),
+      requirement: z9.enum(["required", "optional"]),
+      defaultValue: z9.string().nullable(),
+      portability: z9.enum(["portable", "system_dependent"])
     });
-    portabilityFileEntrySchema = z8.union([
-      z8.string(),
-      z8.object({
-        encoding: z8.literal("base64"),
-        data: z8.string(),
-        contentType: z8.string().min(1).optional().nullable()
+    portabilityFileEntrySchema = z9.union([
+      z9.string(),
+      z9.object({
+        encoding: z9.literal("base64"),
+        data: z9.string(),
+        contentType: z9.string().min(1).optional().nullable()
       })
     ]);
-    portabilityOrganizationManifestEntrySchema = z8.object({
-      path: z8.string().min(1),
-      name: z8.string().min(1),
-      description: z8.string().nullable(),
-      brandColor: z8.string().nullable(),
-      logoPath: z8.string().nullable(),
-      requireBoardApprovalForNewAgents: z8.boolean()
+    portabilityOrganizationManifestEntrySchema = z9.object({
+      path: z9.string().min(1),
+      name: z9.string().min(1),
+      description: z9.string().nullable(),
+      brandColor: z9.string().nullable(),
+      logoPath: z9.string().nullable(),
+      requireBoardApprovalForNewAgents: z9.boolean()
     });
-    portabilitySidebarOrderSchema = z8.object({
-      agents: z8.array(z8.string().min(1)).default([]),
-      projects: z8.array(z8.string().min(1)).default([])
+    portabilitySidebarOrderSchema = z9.object({
+      agents: z9.array(z9.string().min(1)).default([]),
+      projects: z9.array(z9.string().min(1)).default([])
     });
-    portabilityAgentManifestEntrySchema = z8.object({
-      slug: z8.string().min(1),
-      name: z8.string().min(1),
-      path: z8.string().min(1),
-      skills: z8.array(z8.string().min(1)).default([]),
-      role: z8.string().min(1),
-      title: z8.string().nullable(),
-      icon: z8.string().nullable(),
-      capabilities: z8.string().nullable(),
-      reportsToSlug: z8.string().min(1).nullable(),
-      agentRuntimeType: z8.string().min(1),
-      agentRuntimeConfig: z8.record(z8.unknown()),
-      runtimeConfig: z8.record(z8.unknown()),
-      permissions: z8.record(z8.unknown()),
-      budgetMonthlyCents: z8.number().int().nonnegative(),
-      metadata: z8.record(z8.unknown()).nullable()
+    portabilityAgentManifestEntrySchema = z9.object({
+      slug: z9.string().min(1),
+      name: z9.string().min(1),
+      path: z9.string().min(1),
+      skills: z9.array(z9.string().min(1)).default([]),
+      role: z9.string().min(1),
+      title: z9.string().nullable(),
+      icon: z9.string().nullable(),
+      capabilities: z9.string().nullable(),
+      reportsToSlug: z9.string().min(1).nullable(),
+      agentRuntimeType: z9.string().min(1),
+      agentRuntimeConfig: z9.record(z9.unknown()),
+      runtimeConfig: z9.record(z9.unknown()),
+      permissions: z9.record(z9.unknown()),
+      budgetMonthlyCents: z9.number().int().nonnegative(),
+      metadata: z9.record(z9.unknown()).nullable()
     });
-    portabilitySkillManifestEntrySchema = z8.object({
-      key: z8.string().min(1),
-      slug: z8.string().min(1),
-      name: z8.string().min(1),
-      path: z8.string().min(1),
-      description: z8.string().nullable(),
-      sourceType: z8.string().min(1),
-      sourceLocator: z8.string().nullable(),
-      sourceRef: z8.string().nullable(),
-      trustLevel: z8.string().nullable(),
-      compatibility: z8.string().nullable(),
-      metadata: z8.record(z8.unknown()).nullable(),
-      fileInventory: z8.array(z8.object({
-        path: z8.string().min(1),
-        kind: z8.string().min(1)
+    portabilitySkillManifestEntrySchema = z9.object({
+      key: z9.string().min(1),
+      slug: z9.string().min(1),
+      name: z9.string().min(1),
+      path: z9.string().min(1),
+      description: z9.string().nullable(),
+      sourceType: z9.string().min(1),
+      sourceLocator: z9.string().nullable(),
+      sourceRef: z9.string().nullable(),
+      trustLevel: z9.string().nullable(),
+      compatibility: z9.string().nullable(),
+      metadata: z9.record(z9.unknown()).nullable(),
+      fileInventory: z9.array(z9.object({
+        path: z9.string().min(1),
+        kind: z9.string().min(1)
       })).default([])
     });
-    portabilityProjectManifestEntrySchema = z8.object({
-      slug: z8.string().min(1),
-      name: z8.string().min(1),
-      path: z8.string().min(1),
-      description: z8.string().nullable(),
-      ownerAgentSlug: z8.string().min(1).nullable(),
-      leadAgentSlug: z8.string().min(1).nullable(),
-      targetDate: z8.string().nullable(),
-      color: z8.string().nullable(),
-      status: z8.string().nullable(),
-      executionWorkspacePolicy: z8.record(z8.unknown()).nullable(),
-      workspaces: z8.array(z8.object({
-        key: z8.string().min(1),
-        name: z8.string().min(1),
-        sourceType: z8.string().nullable(),
-        repoUrl: z8.string().nullable(),
-        repoRef: z8.string().nullable(),
-        defaultRef: z8.string().nullable(),
-        visibility: z8.string().nullable(),
-        setupCommand: z8.string().nullable(),
-        cleanupCommand: z8.string().nullable(),
-        metadata: z8.record(z8.unknown()).nullable(),
-        isPrimary: z8.boolean()
+    portabilityProjectManifestEntrySchema = z9.object({
+      slug: z9.string().min(1),
+      name: z9.string().min(1),
+      path: z9.string().min(1),
+      description: z9.string().nullable(),
+      ownerAgentSlug: z9.string().min(1).nullable(),
+      leadAgentSlug: z9.string().min(1).nullable(),
+      targetDate: z9.string().nullable(),
+      color: z9.string().nullable(),
+      status: z9.string().nullable(),
+      executionWorkspacePolicy: z9.record(z9.unknown()).nullable(),
+      workspaces: z9.array(z9.object({
+        key: z9.string().min(1),
+        name: z9.string().min(1),
+        sourceType: z9.string().nullable(),
+        repoUrl: z9.string().nullable(),
+        repoRef: z9.string().nullable(),
+        defaultRef: z9.string().nullable(),
+        visibility: z9.string().nullable(),
+        setupCommand: z9.string().nullable(),
+        cleanupCommand: z9.string().nullable(),
+        metadata: z9.record(z9.unknown()).nullable(),
+        isPrimary: z9.boolean()
       })).default([]),
-      metadata: z8.record(z8.unknown()).nullable()
+      metadata: z9.record(z9.unknown()).nullable()
     });
-    portabilityIssueAutomationTriggerManifestEntrySchema = z8.object({
-      kind: z8.string().min(1),
-      label: z8.string().nullable(),
-      enabled: z8.boolean(),
-      cronExpression: z8.string().nullable(),
-      timezone: z8.string().nullable(),
-      signingMode: z8.string().nullable(),
-      replayWindowSec: z8.number().int().nullable()
+    portabilityIssueAutomationTriggerManifestEntrySchema = z9.object({
+      kind: z9.string().min(1),
+      label: z9.string().nullable(),
+      enabled: z9.boolean(),
+      cronExpression: z9.string().nullable(),
+      timezone: z9.string().nullable(),
+      signingMode: z9.string().nullable(),
+      replayWindowSec: z9.number().int().nullable()
     });
-    portabilityIssueAutomationManifestEntrySchema = z8.object({
-      concurrencyPolicy: z8.string().nullable(),
-      catchUpPolicy: z8.string().nullable(),
-      triggers: z8.array(portabilityIssueAutomationTriggerManifestEntrySchema).default([])
+    portabilityIssueAutomationManifestEntrySchema = z9.object({
+      concurrencyPolicy: z9.string().nullable(),
+      catchUpPolicy: z9.string().nullable(),
+      triggers: z9.array(portabilityIssueAutomationTriggerManifestEntrySchema).default([])
     });
-    portabilityIssueManifestEntrySchema = z8.object({
-      slug: z8.string().min(1),
-      identifier: z8.string().min(1).nullable(),
-      title: z8.string().min(1),
-      path: z8.string().min(1),
-      projectSlug: z8.string().min(1).nullable(),
-      projectWorkspaceKey: z8.string().min(1).nullable(),
-      assigneeAgentSlug: z8.string().min(1).nullable(),
-      description: z8.string().nullable(),
-      recurring: z8.boolean().default(false),
+    portabilityIssueManifestEntrySchema = z9.object({
+      slug: z9.string().min(1),
+      identifier: z9.string().min(1).nullable(),
+      title: z9.string().min(1),
+      path: z9.string().min(1),
+      projectSlug: z9.string().min(1).nullable(),
+      projectWorkspaceKey: z9.string().min(1).nullable(),
+      assigneeAgentSlug: z9.string().min(1).nullable(),
+      description: z9.string().nullable(),
+      recurring: z9.boolean().default(false),
       automation: portabilityIssueAutomationManifestEntrySchema.nullable(),
-      legacyRecurrence: z8.record(z8.unknown()).nullable(),
-      status: z8.string().nullable(),
-      priority: z8.string().nullable(),
-      labelIds: z8.array(z8.string().min(1)).default([]),
-      billingCode: z8.string().nullable(),
-      executionWorkspaceSettings: z8.record(z8.unknown()).nullable(),
-      assigneeAgentRuntimeOverrides: z8.record(z8.unknown()).nullable(),
-      metadata: z8.record(z8.unknown()).nullable()
+      legacyRecurrence: z9.record(z9.unknown()).nullable(),
+      status: z9.string().nullable(),
+      priority: z9.string().nullable(),
+      labelIds: z9.array(z9.string().min(1)).default([]),
+      billingCode: z9.string().nullable(),
+      executionWorkspaceSettings: z9.record(z9.unknown()).nullable(),
+      assigneeAgentRuntimeOverrides: z9.record(z9.unknown()).nullable(),
+      metadata: z9.record(z9.unknown()).nullable()
     });
-    portabilityManifestSchema = z8.object({
-      schemaVersion: z8.number().int().positive(),
-      generatedAt: z8.string().datetime(),
-      source: z8.object({
-        orgId: z8.string().uuid(),
-        organizationName: z8.string().min(1)
+    portabilityManifestSchema = z9.object({
+      schemaVersion: z9.number().int().positive(),
+      generatedAt: z9.string().datetime(),
+      source: z9.object({
+        orgId: z9.string().uuid(),
+        organizationName: z9.string().min(1)
       }).nullable(),
-      includes: z8.object({
-        organization: z8.boolean(),
-        agents: z8.boolean(),
-        projects: z8.boolean(),
-        issues: z8.boolean(),
-        skills: z8.boolean()
+      includes: z9.object({
+        organization: z9.boolean(),
+        agents: z9.boolean(),
+        projects: z9.boolean(),
+        issues: z9.boolean(),
+        skills: z9.boolean()
       }),
       organization: portabilityOrganizationManifestEntrySchema.nullable(),
       sidebar: portabilitySidebarOrderSchema.nullable(),
-      agents: z8.array(portabilityAgentManifestEntrySchema),
-      skills: z8.array(portabilitySkillManifestEntrySchema).default([]),
-      projects: z8.array(portabilityProjectManifestEntrySchema).default([]),
-      issues: z8.array(portabilityIssueManifestEntrySchema).default([]),
-      envInputs: z8.array(portabilityEnvInputSchema).default([])
+      agents: z9.array(portabilityAgentManifestEntrySchema),
+      skills: z9.array(portabilitySkillManifestEntrySchema).default([]),
+      projects: z9.array(portabilityProjectManifestEntrySchema).default([]),
+      issues: z9.array(portabilityIssueManifestEntrySchema).default([]),
+      envInputs: z9.array(portabilityEnvInputSchema).default([])
     });
-    portabilitySourceSchema = z8.discriminatedUnion("type", [
-      z8.object({
-        type: z8.literal("inline"),
-        rootPath: z8.string().min(1).optional().nullable(),
-        files: z8.record(portabilityFileEntrySchema)
+    portabilitySourceSchema = z9.discriminatedUnion("type", [
+      z9.object({
+        type: z9.literal("inline"),
+        rootPath: z9.string().min(1).optional().nullable(),
+        files: z9.record(portabilityFileEntrySchema)
       }),
-      z8.object({
-        type: z8.literal("github"),
-        url: z8.string().url()
+      z9.object({
+        type: z9.literal("github"),
+        url: z9.string().url()
       })
     ]);
-    portabilityTargetSchema = z8.discriminatedUnion("mode", [
-      z8.object({
-        mode: z8.literal("new_organization"),
-        newOrganizationName: z8.string().min(1).optional().nullable()
+    portabilityTargetSchema = z9.discriminatedUnion("mode", [
+      z9.object({
+        mode: z9.literal("new_organization"),
+        newOrganizationName: z9.string().min(1).optional().nullable()
       }),
-      z8.object({
-        mode: z8.literal("existing_organization"),
-        orgId: z8.string().uuid()
+      z9.object({
+        mode: z9.literal("existing_organization"),
+        orgId: z9.string().uuid()
       })
     ]);
-    portabilityAgentSelectionSchema = z8.union([
-      z8.literal("all"),
-      z8.array(z8.string().min(1))
+    portabilityAgentSelectionSchema = z9.union([
+      z9.literal("all"),
+      z9.array(z9.string().min(1))
     ]);
-    portabilityCollisionStrategySchema = z8.enum(["rename", "skip", "replace"]);
-    organizationPortabilityExportSchema = z8.object({
+    portabilityCollisionStrategySchema = z9.enum(["rename", "skip", "replace"]);
+    organizationPortabilityExportSchema = z9.object({
       include: portabilityIncludeSchema.optional(),
-      agents: z8.array(z8.string().min(1)).optional(),
-      skills: z8.array(z8.string().min(1)).optional(),
-      projects: z8.array(z8.string().min(1)).optional(),
-      issues: z8.array(z8.string().min(1)).optional(),
-      projectIssues: z8.array(z8.string().min(1)).optional(),
-      selectedFiles: z8.array(z8.string().min(1)).optional(),
-      expandReferencedSkills: z8.boolean().optional(),
+      agents: z9.array(z9.string().min(1)).optional(),
+      skills: z9.array(z9.string().min(1)).optional(),
+      projects: z9.array(z9.string().min(1)).optional(),
+      issues: z9.array(z9.string().min(1)).optional(),
+      projectIssues: z9.array(z9.string().min(1)).optional(),
+      selectedFiles: z9.array(z9.string().min(1)).optional(),
+      expandReferencedSkills: z9.boolean().optional(),
       sidebarOrder: portabilitySidebarOrderSchema.partial().optional()
     });
-    organizationPortabilityPreviewSchema = z8.object({
+    organizationPortabilityPreviewSchema = z9.object({
       source: portabilitySourceSchema,
       include: portabilityIncludeSchema.optional(),
       target: portabilityTargetSchema,
       agents: portabilityAgentSelectionSchema.optional(),
       collisionStrategy: portabilityCollisionStrategySchema.optional(),
-      nameOverrides: z8.record(z8.string().min(1), z8.string().min(1)).optional(),
-      selectedFiles: z8.array(z8.string().min(1)).optional()
+      nameOverrides: z9.record(z9.string().min(1), z9.string().min(1)).optional(),
+      selectedFiles: z9.array(z9.string().min(1)).optional()
     });
-    portabilityAdapterOverrideSchema = z8.object({
-      agentRuntimeType: z8.string().min(1),
-      agentRuntimeConfig: z8.record(z8.unknown()).optional()
+    portabilityAdapterOverrideSchema = z9.object({
+      agentRuntimeType: z9.string().min(1),
+      agentRuntimeConfig: z9.record(z9.unknown()).optional()
     });
     organizationPortabilityImportSchema = organizationPortabilityPreviewSchema.extend({
-      agentRuntimeOverrides: z8.record(z8.string().min(1), portabilityAdapterOverrideSchema).optional()
+      agentRuntimeOverrides: z9.record(z9.string().min(1), portabilityAdapterOverrideSchema).optional()
     });
   }
 });
 
 // ../packages/shared/src/validators/secret.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var envBindingPlainSchema, envBindingSecretRefSchema, envBindingSchema, envConfigSchema, createSecretSchema, rotateSecretSchema, updateSecretSchema;
 var init_secret = __esm({
   "../packages/shared/src/validators/secret.ts"() {
     "use strict";
     init_constants();
-    envBindingPlainSchema = z9.object({
-      type: z9.literal("plain"),
-      value: z9.string()
+    envBindingPlainSchema = z10.object({
+      type: z10.literal("plain"),
+      value: z10.string()
     });
-    envBindingSecretRefSchema = z9.object({
-      type: z9.literal("secret_ref"),
-      secretId: z9.string().uuid(),
-      version: z9.union([z9.literal("latest"), z9.number().int().positive()]).optional()
+    envBindingSecretRefSchema = z10.object({
+      type: z10.literal("secret_ref"),
+      secretId: z10.string().uuid(),
+      version: z10.union([z10.literal("latest"), z10.number().int().positive()]).optional()
     });
-    envBindingSchema = z9.union([
-      z9.string(),
+    envBindingSchema = z10.union([
+      z10.string(),
       envBindingPlainSchema,
       envBindingSecretRefSchema
     ]);
-    envConfigSchema = z9.record(envBindingSchema);
-    createSecretSchema = z9.object({
-      name: z9.string().min(1),
-      provider: z9.enum(SECRET_PROVIDERS).optional(),
-      value: z9.string().min(1),
-      description: z9.string().optional().nullable(),
-      externalRef: z9.string().optional().nullable()
+    envConfigSchema = z10.record(envBindingSchema);
+    createSecretSchema = z10.object({
+      name: z10.string().min(1),
+      provider: z10.enum(SECRET_PROVIDERS).optional(),
+      value: z10.string().min(1),
+      description: z10.string().optional().nullable(),
+      externalRef: z10.string().optional().nullable()
     });
-    rotateSecretSchema = z9.object({
-      value: z9.string().min(1),
-      externalRef: z9.string().optional().nullable()
+    rotateSecretSchema = z10.object({
+      value: z10.string().min(1),
+      externalRef: z10.string().optional().nullable()
     });
-    updateSecretSchema = z9.object({
-      name: z9.string().min(1).optional(),
-      description: z9.string().optional().nullable(),
-      externalRef: z9.string().optional().nullable()
+    updateSecretSchema = z10.object({
+      name: z10.string().min(1).optional(),
+      description: z10.string().optional().nullable(),
+      externalRef: z10.string().optional().nullable()
     });
   }
 });
 
 // ../packages/shared/src/validators/agent.ts
-import { z as z10 } from "zod";
-var agentPermissionsSchema, agentInstructionsBundleModeSchema, updateAgentInstructionsBundleSchema, upsertAgentInstructionsFileSchema, agentRuntimeConfigSchema, optionalAgentNameSchema, createAgentSchema, createAgentHireSchema, updateAgentSchema, updateAgentInstructionsPathSchema, createAgentKeySchema, wakeAgentSchema, resetAgentSessionSchema, testAgentRuntimeEnvironmentSchema, updateAgentPermissionsSchema;
+import { z as z11 } from "zod";
+var agentPermissionsSchema, agentInstructionsBundleModeSchema, updateAgentInstructionsBundleSchema, upsertAgentInstructionsFileSchema, agentRuntimeConfigSchema, optionalAgentNameSchema, uploadedAgentIconSchema, customAgentIconSchema, agentIconSchema, createAgentSchema, createAgentHireSchema, updateAgentSchema, updateAgentInstructionsPathSchema, createAgentKeySchema, wakeAgentSchema, resetAgentSessionSchema, testAgentRuntimeEnvironmentSchema, updateAgentPermissionsSchema;
 var init_agent = __esm({
   "../packages/shared/src/validators/agent.ts"() {
     "use strict";
     init_constants();
     init_secret();
-    agentPermissionsSchema = z10.object({
-      canCreateAgents: z10.boolean().optional().default(false)
+    init_model_fallbacks();
+    agentPermissionsSchema = z11.object({
+      canCreateAgents: z11.boolean().optional().default(false)
     });
-    agentInstructionsBundleModeSchema = z10.enum(["managed", "external"]);
-    updateAgentInstructionsBundleSchema = z10.object({
+    agentInstructionsBundleModeSchema = z11.enum(["managed", "external"]);
+    updateAgentInstructionsBundleSchema = z11.object({
       mode: agentInstructionsBundleModeSchema.optional(),
-      rootPath: z10.string().trim().min(1).nullable().optional(),
-      entryFile: z10.string().trim().min(1).optional(),
-      clearLegacyPromptTemplate: z10.boolean().optional().default(false)
+      rootPath: z11.string().trim().min(1).nullable().optional(),
+      entryFile: z11.string().trim().min(1).optional(),
+      clearLegacyPromptTemplate: z11.boolean().optional().default(false)
     });
-    upsertAgentInstructionsFileSchema = z10.object({
-      path: z10.string().trim().min(1),
-      content: z10.string(),
-      clearLegacyPromptTemplate: z10.boolean().optional().default(false)
+    upsertAgentInstructionsFileSchema = z11.object({
+      path: z11.string().trim().min(1),
+      content: z11.string(),
+      clearLegacyPromptTemplate: z11.boolean().optional().default(false)
     });
-    agentRuntimeConfigSchema = z10.record(z10.unknown()).superRefine((value, ctx) => {
+    agentRuntimeConfigSchema = z11.record(z11.unknown()).superRefine((value, ctx) => {
       const envValue = value.env;
-      if (envValue === void 0) return;
-      const parsed = envConfigSchema.safeParse(envValue);
-      if (!parsed.success) {
-        ctx.addIssue({
-          code: z10.ZodIssueCode.custom,
-          message: "agentRuntimeConfig.env must be a map of valid env bindings",
-          path: ["env"]
-        });
+      if (envValue !== void 0) {
+        const parsed = envConfigSchema.safeParse(envValue);
+        if (!parsed.success) {
+          ctx.addIssue({
+            code: z11.ZodIssueCode.custom,
+            message: "agentRuntimeConfig.env must be a map of valid env bindings",
+            path: ["env"]
+          });
+        }
       }
+      validateModelFallbacksConfig(value, ctx, []);
     });
-    optionalAgentNameSchema = z10.preprocess(
+    optionalAgentNameSchema = z11.preprocess(
       (value) => {
         if (typeof value !== "string") return value;
         const trimmed = value.trim();
         return trimmed.length > 0 ? trimmed : void 0;
       },
-      z10.string().trim().min(1).optional()
+      z11.string().trim().min(1).optional()
     );
-    createAgentSchema = z10.object({
+    uploadedAgentIconSchema = z11.string().regex(
+      /^asset:[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 uploaded avatar reference"
+    );
+    customAgentIconSchema = z11.string().trim().min(1).max(24).refine((value) => !value.toLowerCase().startsWith("asset:"), "Invalid uploaded avatar reference").refine((value) => !/[<>\u0000-\u001f\u007f]/u.test(value), "Icon cannot contain markup or control characters");
+    agentIconSchema = z11.preprocess(
+      (value) => {
+        if (typeof value !== "string") return value;
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : null;
+      },
+      z11.union([
+        z11.enum(AGENT_ICON_NAMES),
+        uploadedAgentIconSchema,
+        customAgentIconSchema
+      ]).nullable()
+    );
+    createAgentSchema = z11.object({
       name: optionalAgentNameSchema,
-      role: z10.enum(AGENT_ROLES).optional().default("general"),
-      title: z10.string().optional().nullable(),
-      icon: z10.enum(AGENT_ICON_NAMES).optional().nullable(),
-      reportsTo: z10.string().uuid().optional().nullable(),
-      capabilities: z10.string().optional().nullable(),
-      desiredSkills: z10.array(z10.string().min(1)).optional(),
-      agentRuntimeType: z10.enum(AGENT_RUNTIME_TYPES).optional().default("process"),
+      role: z11.enum(AGENT_ROLES).optional().default("general"),
+      title: z11.string().optional().nullable(),
+      icon: agentIconSchema.optional(),
+      reportsTo: z11.string().uuid().optional().nullable(),
+      capabilities: z11.string().optional().nullable(),
+      desiredSkills: z11.array(z11.string().min(1)).optional(),
+      agentRuntimeType: z11.enum(AGENT_RUNTIME_TYPES).optional().default("process"),
       agentRuntimeConfig: agentRuntimeConfigSchema.optional().default({}),
-      runtimeConfig: z10.record(z10.unknown()).optional().default({}),
-      budgetMonthlyCents: z10.number().int().nonnegative().optional().default(0),
+      runtimeConfig: z11.record(z11.unknown()).optional().default({}),
+      budgetMonthlyCents: z11.number().int().nonnegative().optional().default(0),
       permissions: agentPermissionsSchema.optional(),
-      metadata: z10.record(z10.unknown()).optional().nullable()
+      metadata: z11.record(z11.unknown()).optional().nullable()
     });
     createAgentHireSchema = createAgentSchema.extend({
-      sourceIssueId: z10.string().uuid().optional().nullable(),
-      sourceIssueIds: z10.array(z10.string().uuid()).optional()
+      sourceIssueId: z11.string().uuid().optional().nullable(),
+      sourceIssueIds: z11.array(z11.string().uuid()).optional()
     });
     updateAgentSchema = createAgentSchema.omit({ permissions: true }).partial().extend({
-      permissions: z10.never().optional(),
-      replaceAgentRuntimeConfig: z10.boolean().optional(),
-      status: z10.enum(AGENT_STATUSES).optional(),
-      spentMonthlyCents: z10.number().int().nonnegative().optional()
+      permissions: z11.never().optional(),
+      replaceAgentRuntimeConfig: z11.boolean().optional(),
+      status: z11.enum(AGENT_STATUSES).optional(),
+      spentMonthlyCents: z11.number().int().nonnegative().optional()
     });
-    updateAgentInstructionsPathSchema = z10.object({
-      path: z10.string().trim().min(1).nullable(),
-      agentRuntimeConfigKey: z10.string().trim().min(1).optional()
+    updateAgentInstructionsPathSchema = z11.object({
+      path: z11.string().trim().min(1).nullable(),
+      agentRuntimeConfigKey: z11.string().trim().min(1).optional()
     });
-    createAgentKeySchema = z10.object({
-      name: z10.string().min(1).default("default")
+    createAgentKeySchema = z11.object({
+      name: z11.string().min(1).default("default")
     });
-    wakeAgentSchema = z10.object({
-      source: z10.enum(["timer", "assignment", "on_demand", "automation"]).optional().default("on_demand"),
-      triggerDetail: z10.enum(["manual", "ping", "callback", "system"]).optional(),
-      reason: z10.string().optional().nullable(),
-      payload: z10.record(z10.unknown()).optional().nullable(),
-      idempotencyKey: z10.string().optional().nullable(),
-      forceFreshSession: z10.preprocess(
+    wakeAgentSchema = z11.object({
+      source: z11.enum(["timer", "assignment", "on_demand", "automation"]).optional().default("on_demand"),
+      triggerDetail: z11.enum(["manual", "ping", "callback", "system"]).optional(),
+      reason: z11.string().optional().nullable(),
+      payload: z11.record(z11.unknown()).optional().nullable(),
+      idempotencyKey: z11.string().optional().nullable(),
+      forceFreshSession: z11.preprocess(
         (value) => value === null ? void 0 : value,
-        z10.boolean().optional().default(false)
+        z11.boolean().optional().default(false)
       )
     });
-    resetAgentSessionSchema = z10.object({
-      taskKey: z10.string().min(1).optional().nullable()
+    resetAgentSessionSchema = z11.object({
+      taskKey: z11.string().min(1).optional().nullable()
     });
-    testAgentRuntimeEnvironmentSchema = z10.object({
+    testAgentRuntimeEnvironmentSchema = z11.object({
       agentRuntimeConfig: agentRuntimeConfigSchema.optional().default({})
     });
-    updateAgentPermissionsSchema = z10.object({
-      canCreateAgents: z10.boolean(),
-      canAssignTasks: z10.boolean()
+    updateAgentPermissionsSchema = z11.object({
+      canCreateAgents: z11.boolean(),
+      canAssignTasks: z11.boolean()
     });
   }
 });
 
 // ../packages/shared/src/validators/project.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 function validateProjectWorkspace(value, ctx) {
   const sourceType = value.sourceType ?? "local_path";
   const hasCwd = typeof value.cwd === "string" && value.cwd.trim().length > 0;
@@ -1216,7 +1331,7 @@ function validateProjectWorkspace(value, ctx) {
   if (sourceType === "remote_managed") {
     if (!hasRemoteRef && !hasRepo) {
       ctx.addIssue({
-        code: z11.ZodIssueCode.custom,
+        code: z12.ZodIssueCode.custom,
         message: "Remote-managed workspace requires remoteWorkspaceRef or repoUrl.",
         path: ["remoteWorkspaceRef"]
       });
@@ -1225,125 +1340,131 @@ function validateProjectWorkspace(value, ctx) {
   }
   if (!hasCwd && !hasRepo) {
     ctx.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z12.ZodIssueCode.custom,
       message: "Workspace requires at least one of cwd or repoUrl.",
       path: ["cwd"]
     });
   }
 }
-var executionWorkspaceStrategySchema, projectExecutionWorkspacePolicySchema, projectWorkspaceSourceTypeSchema, projectWorkspaceVisibilitySchema, projectWorkspaceFields, createProjectWorkspaceSchema, updateProjectWorkspaceSchema, projectFields, createProjectSchema, updateProjectSchema;
+var executionWorkspaceStrategySchema, projectExecutionWorkspacePolicySchema, projectWorkspaceSourceTypeSchema, projectWorkspaceVisibilitySchema, projectWorkspaceFields, projectColorValues, legacyProjectColorSchema, projectColorSchema, createProjectWorkspaceSchema, updateProjectWorkspaceSchema, projectFields, createProjectSchema, updateProjectSchema;
 var init_project = __esm({
   "../packages/shared/src/validators/project.ts"() {
     "use strict";
     init_constants();
     init_resource();
-    executionWorkspaceStrategySchema = z11.object({
-      type: z11.enum(["project_primary", "git_worktree", "adapter_managed", "cloud_sandbox"]).optional(),
-      baseRef: z11.string().optional().nullable(),
-      branchTemplate: z11.string().optional().nullable(),
-      worktreeParentDir: z11.string().optional().nullable(),
-      provisionCommand: z11.string().optional().nullable(),
-      teardownCommand: z11.string().optional().nullable()
+    executionWorkspaceStrategySchema = z12.object({
+      type: z12.enum(["project_primary", "git_worktree", "adapter_managed", "cloud_sandbox"]).optional(),
+      baseRef: z12.string().optional().nullable(),
+      branchTemplate: z12.string().optional().nullable(),
+      worktreeParentDir: z12.string().optional().nullable(),
+      provisionCommand: z12.string().optional().nullable(),
+      teardownCommand: z12.string().optional().nullable()
     }).strict();
-    projectExecutionWorkspacePolicySchema = z11.object({
-      enabled: z11.boolean(),
-      defaultMode: z11.enum(["shared_workspace", "isolated_workspace", "operator_branch", "adapter_default"]).optional(),
-      allowIssueOverride: z11.boolean().optional(),
-      defaultProjectWorkspaceId: z11.string().uuid().optional().nullable(),
+    projectExecutionWorkspacePolicySchema = z12.object({
+      enabled: z12.boolean(),
+      defaultMode: z12.enum(["shared_workspace", "isolated_workspace", "operator_branch", "adapter_default"]).optional(),
+      allowIssueOverride: z12.boolean().optional(),
+      defaultProjectWorkspaceId: z12.string().uuid().optional().nullable(),
       workspaceStrategy: executionWorkspaceStrategySchema.optional().nullable(),
-      workspaceRuntime: z11.record(z11.unknown()).optional().nullable(),
-      branchPolicy: z11.record(z11.unknown()).optional().nullable(),
-      pullRequestPolicy: z11.record(z11.unknown()).optional().nullable(),
-      runtimePolicy: z11.record(z11.unknown()).optional().nullable(),
-      cleanupPolicy: z11.record(z11.unknown()).optional().nullable()
+      workspaceRuntime: z12.record(z12.unknown()).optional().nullable(),
+      branchPolicy: z12.record(z12.unknown()).optional().nullable(),
+      pullRequestPolicy: z12.record(z12.unknown()).optional().nullable(),
+      runtimePolicy: z12.record(z12.unknown()).optional().nullable(),
+      cleanupPolicy: z12.record(z12.unknown()).optional().nullable()
     }).strict();
-    projectWorkspaceSourceTypeSchema = z11.enum(["local_path", "git_repo", "remote_managed", "non_git_path"]);
-    projectWorkspaceVisibilitySchema = z11.enum(["default", "advanced"]);
+    projectWorkspaceSourceTypeSchema = z12.enum(["local_path", "git_repo", "remote_managed", "non_git_path"]);
+    projectWorkspaceVisibilitySchema = z12.enum(["default", "advanced"]);
     projectWorkspaceFields = {
-      name: z11.string().min(1).optional(),
+      name: z12.string().min(1).optional(),
       sourceType: projectWorkspaceSourceTypeSchema.optional(),
-      cwd: z11.string().min(1).optional().nullable(),
-      repoUrl: z11.string().url().optional().nullable(),
-      repoRef: z11.string().optional().nullable(),
-      defaultRef: z11.string().optional().nullable(),
+      cwd: z12.string().min(1).optional().nullable(),
+      repoUrl: z12.string().url().optional().nullable(),
+      repoRef: z12.string().optional().nullable(),
+      defaultRef: z12.string().optional().nullable(),
       visibility: projectWorkspaceVisibilitySchema.optional(),
-      setupCommand: z11.string().optional().nullable(),
-      cleanupCommand: z11.string().optional().nullable(),
-      remoteProvider: z11.string().optional().nullable(),
-      remoteWorkspaceRef: z11.string().optional().nullable(),
-      sharedWorkspaceKey: z11.string().optional().nullable(),
-      metadata: z11.record(z11.unknown()).optional().nullable()
+      setupCommand: z12.string().optional().nullable(),
+      cleanupCommand: z12.string().optional().nullable(),
+      remoteProvider: z12.string().optional().nullable(),
+      remoteWorkspaceRef: z12.string().optional().nullable(),
+      sharedWorkspaceKey: z12.string().optional().nullable(),
+      metadata: z12.record(z12.unknown()).optional().nullable()
     };
-    createProjectWorkspaceSchema = z11.object({
+    projectColorValues = new Set(PROJECT_COLORS);
+    legacyProjectColorSchema = z12.string().regex(/^#[0-9a-fA-F]{6}$/);
+    projectColorSchema = z12.string().refine(
+      (value) => legacyProjectColorSchema.safeParse(value).success || projectColorValues.has(value),
+      "Color must be a 6-digit hex value or a supported project gradient"
+    );
+    createProjectWorkspaceSchema = z12.object({
       ...projectWorkspaceFields,
-      isPrimary: z11.boolean().optional().default(false)
+      isPrimary: z12.boolean().optional().default(false)
     }).superRefine(validateProjectWorkspace);
-    updateProjectWorkspaceSchema = z11.object({
+    updateProjectWorkspaceSchema = z12.object({
       ...projectWorkspaceFields,
-      isPrimary: z11.boolean().optional()
+      isPrimary: z12.boolean().optional()
     }).partial();
     projectFields = {
       /** @deprecated Use goalIds instead */
-      goalId: z11.string().uuid().optional().nullable(),
-      goalIds: z11.array(z11.string().uuid()).optional(),
-      name: z11.string().min(1),
-      description: z11.string().optional().nullable(),
-      status: z11.enum(PROJECT_STATUSES).optional().default("backlog"),
-      leadAgentId: z11.string().uuid().optional().nullable(),
-      targetDate: z11.string().optional().nullable(),
-      color: z11.string().optional().nullable(),
+      goalId: z12.string().uuid().optional().nullable(),
+      goalIds: z12.array(z12.string().uuid()).optional(),
+      name: z12.string().min(1),
+      description: z12.string().optional().nullable(),
+      status: z12.enum(PROJECT_STATUSES).optional().default("backlog"),
+      leadAgentId: z12.string().uuid().optional().nullable(),
+      targetDate: z12.string().optional().nullable(),
+      color: projectColorSchema.optional().nullable(),
       executionWorkspacePolicy: projectExecutionWorkspacePolicySchema.optional().nullable(),
-      resourceAttachments: z11.array(projectResourceAttachmentInputSchema).optional(),
-      newResources: z11.array(createProjectInlineResourceSchema).optional(),
-      archivedAt: z11.string().datetime().optional().nullable()
+      resourceAttachments: z12.array(projectResourceAttachmentInputSchema).optional(),
+      newResources: z12.array(createProjectInlineResourceSchema).optional(),
+      archivedAt: z12.string().datetime().optional().nullable()
     };
-    createProjectSchema = z11.object({
+    createProjectSchema = z12.object({
       ...projectFields
     });
-    updateProjectSchema = z11.object(projectFields).partial();
+    updateProjectSchema = z12.object(projectFields).partial();
   }
 });
 
 // ../packages/shared/src/validators/issue.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var executionWorkspaceStrategySchema2, issueExecutionWorkspaceSettingsSchema, issueAssigneeAdapterOverridesSchema, createIssueSchema, createIssueLabelSchema, updateIssueLabelSchema, updateIssueSchema, checkoutIssueSchema, addIssueCommentSchema, linkIssueApprovalSchema, createIssueAttachmentMetadataSchema, ISSUE_DOCUMENT_FORMATS, issueDocumentFormatSchema, issueDocumentKeySchema, upsertIssueDocumentSchema;
 var init_issue = __esm({
   "../packages/shared/src/validators/issue.ts"() {
     "use strict";
     init_constants();
-    executionWorkspaceStrategySchema2 = z12.object({
-      type: z12.enum(["project_primary", "git_worktree", "adapter_managed", "cloud_sandbox"]).optional(),
-      baseRef: z12.string().optional().nullable(),
-      branchTemplate: z12.string().optional().nullable(),
-      worktreeParentDir: z12.string().optional().nullable(),
-      provisionCommand: z12.string().optional().nullable(),
-      teardownCommand: z12.string().optional().nullable()
+    executionWorkspaceStrategySchema2 = z13.object({
+      type: z13.enum(["project_primary", "git_worktree", "adapter_managed", "cloud_sandbox"]).optional(),
+      baseRef: z13.string().optional().nullable(),
+      branchTemplate: z13.string().optional().nullable(),
+      worktreeParentDir: z13.string().optional().nullable(),
+      provisionCommand: z13.string().optional().nullable(),
+      teardownCommand: z13.string().optional().nullable()
     }).strict();
-    issueExecutionWorkspaceSettingsSchema = z12.object({
-      mode: z12.enum(["inherit", "shared_workspace", "isolated_workspace", "operator_branch", "reuse_existing", "agent_default"]).optional(),
+    issueExecutionWorkspaceSettingsSchema = z13.object({
+      mode: z13.enum(["inherit", "shared_workspace", "isolated_workspace", "operator_branch", "reuse_existing", "agent_default"]).optional(),
       workspaceStrategy: executionWorkspaceStrategySchema2.optional().nullable(),
-      workspaceRuntime: z12.record(z12.unknown()).optional().nullable()
+      workspaceRuntime: z13.record(z13.unknown()).optional().nullable()
     }).strict();
-    issueAssigneeAdapterOverridesSchema = z12.object({
-      agentRuntimeConfig: z12.record(z12.unknown()).optional(),
-      useProjectWorkspace: z12.boolean().optional()
+    issueAssigneeAdapterOverridesSchema = z13.object({
+      agentRuntimeConfig: z13.record(z13.unknown()).optional(),
+      useProjectWorkspace: z13.boolean().optional()
     }).strict();
-    createIssueSchema = z12.object({
-      projectId: z12.string().uuid().optional().nullable(),
-      projectWorkspaceId: z12.string().uuid().optional().nullable(),
-      goalId: z12.string().uuid().optional().nullable(),
-      parentId: z12.string().uuid().optional().nullable(),
-      title: z12.string().min(1),
-      description: z12.string().optional().nullable(),
-      status: z12.enum(ISSUE_STATUSES).optional().default("backlog"),
-      priority: z12.enum(ISSUE_PRIORITIES).optional().default("medium"),
-      assigneeAgentId: z12.string().uuid().optional().nullable(),
-      assigneeUserId: z12.string().optional().nullable(),
-      requestDepth: z12.number().int().nonnegative().optional().default(0),
-      billingCode: z12.string().optional().nullable(),
+    createIssueSchema = z13.object({
+      projectId: z13.string().uuid().optional().nullable(),
+      projectWorkspaceId: z13.string().uuid().optional().nullable(),
+      goalId: z13.string().uuid().optional().nullable(),
+      parentId: z13.string().uuid().optional().nullable(),
+      title: z13.string().min(1),
+      description: z13.string().optional().nullable(),
+      status: z13.enum(ISSUE_STATUSES).optional().default("backlog"),
+      priority: z13.enum(ISSUE_PRIORITIES).optional().default("medium"),
+      assigneeAgentId: z13.string().uuid().optional().nullable(),
+      assigneeUserId: z13.string().optional().nullable(),
+      requestDepth: z13.number().int().nonnegative().optional().default(0),
+      billingCode: z13.string().optional().nullable(),
       assigneeAgentRuntimeOverrides: issueAssigneeAdapterOverridesSchema.optional().nullable(),
-      executionWorkspaceId: z12.string().uuid().optional().nullable(),
-      executionWorkspacePreference: z12.enum([
+      executionWorkspaceId: z13.string().uuid().optional().nullable(),
+      executionWorkspacePreference: z13.enum([
         "inherit",
         "shared_workspace",
         "isolated_workspace",
@@ -1352,11 +1473,11 @@ var init_issue = __esm({
         "agent_default"
       ]).optional().nullable(),
       executionWorkspaceSettings: issueExecutionWorkspaceSettingsSchema.optional().nullable(),
-      labelIds: z12.array(z12.string().uuid()).optional()
+      labelIds: z13.array(z13.string().uuid()).optional()
     });
-    createIssueLabelSchema = z12.object({
-      name: z12.string().trim().min(1).max(48),
-      color: z12.string().regex(/^#(?:[0-9a-fA-F]{6})$/, "Color must be a 6-digit hex value")
+    createIssueLabelSchema = z13.object({
+      name: z13.string().trim().min(1).max(48),
+      color: z13.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,
@@ -1365,45 +1486,45 @@ var init_issue = __esm({
       }
     );
     updateIssueSchema = createIssueSchema.partial().extend({
-      comment: z12.string().min(1).optional(),
-      reopen: z12.boolean().optional(),
-      hiddenAt: z12.string().datetime().nullable().optional()
+      comment: z13.string().min(1).optional(),
+      reopen: z13.boolean().optional(),
+      hiddenAt: z13.string().datetime().nullable().optional()
     });
-    checkoutIssueSchema = z12.object({
-      agentId: z12.string().uuid(),
-      expectedStatuses: z12.array(z12.enum(ISSUE_STATUSES)).nonempty()
+    checkoutIssueSchema = z13.object({
+      agentId: z13.string().uuid(),
+      expectedStatuses: z13.array(z13.enum(ISSUE_STATUSES)).nonempty()
     });
-    addIssueCommentSchema = z12.object({
-      body: z12.string().min(1),
-      reopen: z12.boolean().optional(),
-      interrupt: z12.boolean().optional()
+    addIssueCommentSchema = z13.object({
+      body: z13.string().min(1),
+      reopen: z13.boolean().optional(),
+      interrupt: z13.boolean().optional()
     });
-    linkIssueApprovalSchema = z12.object({
-      approvalId: z12.string().uuid()
+    linkIssueApprovalSchema = z13.object({
+      approvalId: z13.string().uuid()
     });
-    createIssueAttachmentMetadataSchema = z12.object({
-      issueCommentId: z12.string().uuid().optional().nullable()
+    createIssueAttachmentMetadataSchema = z13.object({
+      issueCommentId: z13.string().uuid().optional().nullable()
     });
     ISSUE_DOCUMENT_FORMATS = ["markdown"];
-    issueDocumentFormatSchema = z12.enum(ISSUE_DOCUMENT_FORMATS);
-    issueDocumentKeySchema = z12.string().trim().min(1).max(64).regex(/^[a-z0-9][a-z0-9_-]*$/, "Document key must be lowercase letters, numbers, _ or -");
-    upsertIssueDocumentSchema = z12.object({
-      title: z12.string().trim().max(200).nullable().optional(),
+    issueDocumentFormatSchema = z13.enum(ISSUE_DOCUMENT_FORMATS);
+    issueDocumentKeySchema = z13.string().trim().min(1).max(64).regex(/^[a-z0-9][a-z0-9_-]*$/, "Document key must be lowercase letters, numbers, _ or -");
+    upsertIssueDocumentSchema = z13.object({
+      title: z13.string().trim().max(200).nullable().optional(),
       format: issueDocumentFormatSchema,
-      body: z12.string().max(524288),
-      changeSummary: z12.string().trim().max(500).nullable().optional(),
-      baseRevisionId: z12.string().uuid().nullable().optional()
+      body: z13.string().max(524288),
+      changeSummary: z13.string().trim().max(500).nullable().optional(),
+      baseRevisionId: z13.string().uuid().nullable().optional()
     });
   }
 });
 
 // ../packages/shared/src/validators/work-product.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var issueWorkProductTypeSchema, issueWorkProductStatusSchema, issueWorkProductReviewStateSchema, createIssueWorkProductSchema, updateIssueWorkProductSchema;
 var init_work_product = __esm({
   "../packages/shared/src/validators/work-product.ts"() {
     "use strict";
-    issueWorkProductTypeSchema = z13.enum([
+    issueWorkProductTypeSchema = z14.enum([
       "preview_url",
       "runtime_service",
       "pull_request",
@@ -1412,7 +1533,7 @@ var init_work_product = __esm({
       "artifact",
       "document"
     ]);
-    issueWorkProductStatusSchema = z13.enum([
+    issueWorkProductStatusSchema = z14.enum([
       "active",
       "ready_for_review",
       "approved",
@@ -1423,226 +1544,226 @@ var init_work_product = __esm({
       "archived",
       "draft"
     ]);
-    issueWorkProductReviewStateSchema = z13.enum([
+    issueWorkProductReviewStateSchema = z14.enum([
       "none",
       "needs_board_review",
       "approved",
       "changes_requested"
     ]);
-    createIssueWorkProductSchema = z13.object({
-      projectId: z13.string().uuid().optional().nullable(),
-      executionWorkspaceId: z13.string().uuid().optional().nullable(),
-      runtimeServiceId: z13.string().uuid().optional().nullable(),
+    createIssueWorkProductSchema = z14.object({
+      projectId: z14.string().uuid().optional().nullable(),
+      executionWorkspaceId: z14.string().uuid().optional().nullable(),
+      runtimeServiceId: z14.string().uuid().optional().nullable(),
       type: issueWorkProductTypeSchema,
-      provider: z13.string().min(1),
-      externalId: z13.string().optional().nullable(),
-      title: z13.string().min(1),
-      url: z13.string().url().optional().nullable(),
+      provider: z14.string().min(1),
+      externalId: z14.string().optional().nullable(),
+      title: z14.string().min(1),
+      url: z14.string().url().optional().nullable(),
       status: issueWorkProductStatusSchema.default("active"),
       reviewState: issueWorkProductReviewStateSchema.optional().default("none"),
-      isPrimary: z13.boolean().optional().default(false),
-      healthStatus: z13.enum(["unknown", "healthy", "unhealthy"]).optional().default("unknown"),
-      summary: z13.string().optional().nullable(),
-      metadata: z13.record(z13.unknown()).optional().nullable(),
-      createdByRunId: z13.string().uuid().optional().nullable()
+      isPrimary: z14.boolean().optional().default(false),
+      healthStatus: z14.enum(["unknown", "healthy", "unhealthy"]).optional().default("unknown"),
+      summary: z14.string().optional().nullable(),
+      metadata: z14.record(z14.unknown()).optional().nullable(),
+      createdByRunId: z14.string().uuid().optional().nullable()
     });
     updateIssueWorkProductSchema = createIssueWorkProductSchema.partial();
   }
 });
 
 // ../packages/shared/src/validators/execution-workspace.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var executionWorkspaceStatusSchema, updateExecutionWorkspaceSchema;
 var init_execution_workspace = __esm({
   "../packages/shared/src/validators/execution-workspace.ts"() {
     "use strict";
-    executionWorkspaceStatusSchema = z14.enum([
+    executionWorkspaceStatusSchema = z15.enum([
       "active",
       "idle",
       "in_review",
       "archived",
       "cleanup_failed"
     ]);
-    updateExecutionWorkspaceSchema = z14.object({
+    updateExecutionWorkspaceSchema = z15.object({
       status: executionWorkspaceStatusSchema.optional(),
-      cleanupEligibleAt: z14.string().datetime().optional().nullable(),
-      cleanupReason: z14.string().optional().nullable(),
-      metadata: z14.record(z14.unknown()).optional().nullable()
+      cleanupEligibleAt: z15.string().datetime().optional().nullable(),
+      cleanupReason: z15.string().optional().nullable(),
+      metadata: z15.record(z15.unknown()).optional().nullable()
     }).strict();
   }
 });
 
 // ../packages/shared/src/validators/goal.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var createGoalSchema, updateGoalSchema;
 var init_goal = __esm({
   "../packages/shared/src/validators/goal.ts"() {
     "use strict";
     init_constants();
-    createGoalSchema = z15.object({
-      title: z15.string().min(1),
-      description: z15.string().optional().nullable(),
-      level: z15.enum(GOAL_LEVELS).optional().default("task"),
-      status: z15.enum(GOAL_STATUSES).optional().default("planned"),
-      parentId: z15.string().uuid().optional().nullable(),
-      ownerAgentId: z15.string().uuid().optional().nullable()
+    createGoalSchema = z16.object({
+      title: z16.string().min(1),
+      description: z16.string().optional().nullable(),
+      level: z16.enum(GOAL_LEVELS).optional().default("task"),
+      status: z16.enum(GOAL_STATUSES).optional().default("planned"),
+      parentId: z16.string().uuid().optional().nullable(),
+      ownerAgentId: z16.string().uuid().optional().nullable()
     });
     updateGoalSchema = createGoalSchema.partial();
   }
 });
 
 // ../packages/shared/src/validators/approval.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var createApprovalSchema, resolveApprovalSchema, requestApprovalRevisionSchema, resubmitApprovalSchema, addApprovalCommentSchema;
 var init_approval = __esm({
   "../packages/shared/src/validators/approval.ts"() {
     "use strict";
     init_constants();
-    createApprovalSchema = z16.object({
-      type: z16.enum(APPROVAL_TYPES),
-      requestedByAgentId: z16.string().uuid().optional().nullable(),
-      payload: z16.record(z16.unknown()),
-      issueIds: z16.array(z16.string().uuid()).optional()
+    createApprovalSchema = z17.object({
+      type: z17.enum(APPROVAL_TYPES),
+      requestedByAgentId: z17.string().uuid().optional().nullable(),
+      payload: z17.record(z17.unknown()),
+      issueIds: z17.array(z17.string().uuid()).optional()
     });
-    resolveApprovalSchema = z16.object({
-      decisionNote: z16.string().optional().nullable(),
-      decidedByUserId: z16.string().optional().default("board")
+    resolveApprovalSchema = z17.object({
+      decisionNote: z17.string().optional().nullable(),
+      decidedByUserId: z17.string().optional().default("board")
     });
-    requestApprovalRevisionSchema = z16.object({
-      decisionNote: z16.string().optional().nullable(),
-      decidedByUserId: z16.string().optional().default("board")
+    requestApprovalRevisionSchema = z17.object({
+      decisionNote: z17.string().optional().nullable(),
+      decidedByUserId: z17.string().optional().default("board")
     });
-    resubmitApprovalSchema = z16.object({
-      payload: z16.record(z16.unknown()).optional()
+    resubmitApprovalSchema = z17.object({
+      payload: z17.record(z17.unknown()).optional()
     });
-    addApprovalCommentSchema = z16.object({
-      body: z16.string().min(1)
+    addApprovalCommentSchema = z17.object({
+      body: z17.string().min(1)
     });
   }
 });
 
 // ../packages/shared/src/validators/automation.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var createAutomationSchema, updateAutomationSchema, baseTriggerSchema, createAutomationTriggerSchema, updateAutomationTriggerSchema, runAutomationSchema, rotateAutomationTriggerSecretSchema;
 var init_automation = __esm({
   "../packages/shared/src/validators/automation.ts"() {
     "use strict";
     init_constants();
-    createAutomationSchema = z17.object({
-      projectId: z17.string().uuid(),
-      goalId: z17.string().uuid().optional().nullable(),
-      parentIssueId: z17.string().uuid().optional().nullable(),
-      title: z17.string().trim().min(1).max(200),
-      description: z17.string().optional().nullable(),
-      assigneeAgentId: z17.string().uuid(),
-      priority: z17.enum(ISSUE_PRIORITIES).optional().default("medium"),
-      status: z17.enum(AUTOMATION_STATUSES).optional().default("active"),
-      concurrencyPolicy: z17.enum(AUTOMATION_CONCURRENCY_POLICIES).optional().default("coalesce_if_active"),
-      catchUpPolicy: z17.enum(AUTOMATION_CATCH_UP_POLICIES).optional().default("skip_missed")
+    createAutomationSchema = z18.object({
+      projectId: z18.string().uuid(),
+      goalId: z18.string().uuid().optional().nullable(),
+      parentIssueId: z18.string().uuid().optional().nullable(),
+      title: z18.string().trim().min(1).max(200),
+      description: z18.string().optional().nullable(),
+      assigneeAgentId: z18.string().uuid(),
+      priority: z18.enum(ISSUE_PRIORITIES).optional().default("medium"),
+      status: z18.enum(AUTOMATION_STATUSES).optional().default("active"),
+      concurrencyPolicy: z18.enum(AUTOMATION_CONCURRENCY_POLICIES).optional().default("coalesce_if_active"),
+      catchUpPolicy: z18.enum(AUTOMATION_CATCH_UP_POLICIES).optional().default("skip_missed")
     });
     updateAutomationSchema = createAutomationSchema.partial();
-    baseTriggerSchema = z17.object({
-      label: z17.string().trim().max(120).optional().nullable(),
-      enabled: z17.boolean().optional().default(true)
+    baseTriggerSchema = z18.object({
+      label: z18.string().trim().max(120).optional().nullable(),
+      enabled: z18.boolean().optional().default(true)
     });
-    createAutomationTriggerSchema = z17.discriminatedUnion("kind", [
+    createAutomationTriggerSchema = z18.discriminatedUnion("kind", [
       baseTriggerSchema.extend({
-        kind: z17.literal("schedule"),
-        cronExpression: z17.string().trim().min(1),
-        timezone: z17.string().trim().min(1).default("UTC")
+        kind: z18.literal("schedule"),
+        cronExpression: z18.string().trim().min(1),
+        timezone: z18.string().trim().min(1).default("UTC")
       }),
       baseTriggerSchema.extend({
-        kind: z17.literal("webhook"),
-        signingMode: z17.enum(AUTOMATION_TRIGGER_SIGNING_MODES).optional().default("bearer"),
-        replayWindowSec: z17.number().int().min(30).max(86400).optional().default(300)
+        kind: z18.literal("webhook"),
+        signingMode: z18.enum(AUTOMATION_TRIGGER_SIGNING_MODES).optional().default("bearer"),
+        replayWindowSec: z18.number().int().min(30).max(86400).optional().default(300)
       }),
       baseTriggerSchema.extend({
-        kind: z17.literal("api")
+        kind: z18.literal("api")
       })
     ]);
-    updateAutomationTriggerSchema = z17.object({
-      label: z17.string().trim().max(120).optional().nullable(),
-      enabled: z17.boolean().optional(),
-      cronExpression: z17.string().trim().min(1).optional().nullable(),
-      timezone: z17.string().trim().min(1).optional().nullable(),
-      signingMode: z17.enum(AUTOMATION_TRIGGER_SIGNING_MODES).optional().nullable(),
-      replayWindowSec: z17.number().int().min(30).max(86400).optional().nullable()
+    updateAutomationTriggerSchema = z18.object({
+      label: z18.string().trim().max(120).optional().nullable(),
+      enabled: z18.boolean().optional(),
+      cronExpression: z18.string().trim().min(1).optional().nullable(),
+      timezone: z18.string().trim().min(1).optional().nullable(),
+      signingMode: z18.enum(AUTOMATION_TRIGGER_SIGNING_MODES).optional().nullable(),
+      replayWindowSec: z18.number().int().min(30).max(86400).optional().nullable()
     });
-    runAutomationSchema = z17.object({
-      triggerId: z17.string().uuid().optional().nullable(),
-      payload: z17.record(z17.unknown()).optional().nullable(),
-      idempotencyKey: z17.string().trim().max(255).optional().nullable(),
-      source: z17.enum(["manual", "api"]).optional().default("manual")
+    runAutomationSchema = z18.object({
+      triggerId: z18.string().uuid().optional().nullable(),
+      payload: z18.record(z18.unknown()).optional().nullable(),
+      idempotencyKey: z18.string().trim().max(255).optional().nullable(),
+      source: z18.enum(["manual", "api"]).optional().default("manual")
     });
-    rotateAutomationTriggerSecretSchema = z17.object({});
+    rotateAutomationTriggerSecretSchema = z18.object({});
   }
 });
 
 // ../packages/shared/src/validators/cost.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var createCostEventSchema, updateBudgetSchema;
 var init_cost = __esm({
   "../packages/shared/src/validators/cost.ts"() {
     "use strict";
     init_constants();
-    createCostEventSchema = z18.object({
-      agentId: z18.string().uuid(),
-      issueId: z18.string().uuid().optional().nullable(),
-      projectId: z18.string().uuid().optional().nullable(),
-      goalId: z18.string().uuid().optional().nullable(),
-      heartbeatRunId: z18.string().uuid().optional().nullable(),
-      billingCode: z18.string().optional().nullable(),
-      provider: z18.string().min(1),
-      biller: z18.string().min(1).optional(),
-      billingType: z18.enum(BILLING_TYPES).optional().default("unknown"),
-      model: z18.string().min(1),
-      inputTokens: z18.number().int().nonnegative().optional().default(0),
-      cachedInputTokens: z18.number().int().nonnegative().optional().default(0),
-      outputTokens: z18.number().int().nonnegative().optional().default(0),
-      costCents: z18.number().int().nonnegative(),
-      occurredAt: z18.string().datetime()
+    createCostEventSchema = z19.object({
+      agentId: z19.string().uuid(),
+      issueId: z19.string().uuid().optional().nullable(),
+      projectId: z19.string().uuid().optional().nullable(),
+      goalId: z19.string().uuid().optional().nullable(),
+      heartbeatRunId: z19.string().uuid().optional().nullable(),
+      billingCode: z19.string().optional().nullable(),
+      provider: z19.string().min(1),
+      biller: z19.string().min(1).optional(),
+      billingType: z19.enum(BILLING_TYPES).optional().default("unknown"),
+      model: z19.string().min(1),
+      inputTokens: z19.number().int().nonnegative().optional().default(0),
+      cachedInputTokens: z19.number().int().nonnegative().optional().default(0),
+      outputTokens: z19.number().int().nonnegative().optional().default(0),
+      costCents: z19.number().int().nonnegative(),
+      occurredAt: z19.string().datetime()
     }).transform((value) => ({
       ...value,
       biller: value.biller ?? value.provider
     }));
-    updateBudgetSchema = z18.object({
-      budgetMonthlyCents: z18.number().int().nonnegative()
+    updateBudgetSchema = z19.object({
+      budgetMonthlyCents: z19.number().int().nonnegative()
     });
   }
 });
 
 // ../packages/shared/src/validators/finance.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var createFinanceEventSchema;
 var init_finance = __esm({
   "../packages/shared/src/validators/finance.ts"() {
     "use strict";
     init_constants();
-    createFinanceEventSchema = z19.object({
-      agentId: z19.string().uuid().optional().nullable(),
-      issueId: z19.string().uuid().optional().nullable(),
-      projectId: z19.string().uuid().optional().nullable(),
-      goalId: z19.string().uuid().optional().nullable(),
-      heartbeatRunId: z19.string().uuid().optional().nullable(),
-      costEventId: z19.string().uuid().optional().nullable(),
-      billingCode: z19.string().optional().nullable(),
-      description: z19.string().max(500).optional().nullable(),
-      eventKind: z19.enum(FINANCE_EVENT_KINDS),
-      direction: z19.enum(FINANCE_DIRECTIONS).optional().default("debit"),
-      biller: z19.string().min(1),
-      provider: z19.string().min(1).optional().nullable(),
-      executionAgentRuntimeType: z19.enum(AGENT_RUNTIME_TYPES).optional().nullable(),
-      pricingTier: z19.string().min(1).optional().nullable(),
-      region: z19.string().min(1).optional().nullable(),
-      model: z19.string().min(1).optional().nullable(),
-      quantity: z19.number().int().nonnegative().optional().nullable(),
-      unit: z19.enum(FINANCE_UNITS).optional().nullable(),
-      amountCents: z19.number().int().nonnegative(),
-      currency: z19.string().length(3).optional().default("USD"),
-      estimated: z19.boolean().optional().default(false),
-      externalInvoiceId: z19.string().optional().nullable(),
-      metadataJson: z19.record(z19.string(), z19.unknown()).optional().nullable(),
-      occurredAt: z19.string().datetime()
+    createFinanceEventSchema = z20.object({
+      agentId: z20.string().uuid().optional().nullable(),
+      issueId: z20.string().uuid().optional().nullable(),
+      projectId: z20.string().uuid().optional().nullable(),
+      goalId: z20.string().uuid().optional().nullable(),
+      heartbeatRunId: z20.string().uuid().optional().nullable(),
+      costEventId: z20.string().uuid().optional().nullable(),
+      billingCode: z20.string().optional().nullable(),
+      description: z20.string().max(500).optional().nullable(),
+      eventKind: z20.enum(FINANCE_EVENT_KINDS),
+      direction: z20.enum(FINANCE_DIRECTIONS).optional().default("debit"),
+      biller: z20.string().min(1),
+      provider: z20.string().min(1).optional().nullable(),
+      executionAgentRuntimeType: z20.enum(AGENT_RUNTIME_TYPES).optional().nullable(),
+      pricingTier: z20.string().min(1).optional().nullable(),
+      region: z20.string().min(1).optional().nullable(),
+      model: z20.string().min(1).optional().nullable(),
+      quantity: z20.number().int().nonnegative().optional().nullable(),
+      unit: z20.enum(FINANCE_UNITS).optional().nullable(),
+      amountCents: z20.number().int().nonnegative(),
+      currency: z20.string().length(3).optional().default("USD"),
+      estimated: z20.boolean().optional().default(false),
+      externalInvoiceId: z20.string().optional().nullable(),
+      metadataJson: z20.record(z20.string(), z20.unknown()).optional().nullable(),
+      occurredAt: z20.string().datetime()
     }).transform((value) => ({
       ...value,
       currency: value.currency.toUpperCase()
@@ -1651,81 +1772,81 @@ var init_finance = __esm({
 });
 
 // ../packages/shared/src/validators/asset.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var createAssetImageMetadataSchema;
 var init_asset = __esm({
   "../packages/shared/src/validators/asset.ts"() {
     "use strict";
-    createAssetImageMetadataSchema = z20.object({
-      namespace: z20.string().trim().min(1).max(120).regex(/^[a-zA-Z0-9/_-]+$/).optional()
+    createAssetImageMetadataSchema = z21.object({
+      namespace: z21.string().trim().min(1).max(120).regex(/^[a-zA-Z0-9/_-]+$/).optional()
     });
   }
 });
 
 // ../packages/shared/src/validators/access.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var createCompanyInviteSchema, createOpenClawInvitePromptSchema, acceptInviteSchema, listJoinRequestsQuerySchema, claimJoinRequestApiKeySchema, boardCliAuthAccessLevelSchema, createCliAuthChallengeSchema, resolveCliAuthChallengeSchema, updateMemberPermissionsSchema, updateUserCompanyAccessSchema;
 var init_access = __esm({
   "../packages/shared/src/validators/access.ts"() {
     "use strict";
     init_constants();
-    createCompanyInviteSchema = z21.object({
-      allowedJoinTypes: z21.enum(INVITE_JOIN_TYPES).default("both"),
-      defaultsPayload: z21.record(z21.string(), z21.unknown()).optional().nullable(),
-      agentMessage: z21.string().max(4e3).optional().nullable()
+    createCompanyInviteSchema = z22.object({
+      allowedJoinTypes: z22.enum(INVITE_JOIN_TYPES).default("both"),
+      defaultsPayload: z22.record(z22.string(), z22.unknown()).optional().nullable(),
+      agentMessage: z22.string().max(4e3).optional().nullable()
     });
-    createOpenClawInvitePromptSchema = z21.object({
-      agentMessage: z21.string().max(4e3).optional().nullable()
+    createOpenClawInvitePromptSchema = z22.object({
+      agentMessage: z22.string().max(4e3).optional().nullable()
     });
-    acceptInviteSchema = z21.object({
-      requestType: z21.enum(JOIN_REQUEST_TYPES),
-      agentName: z21.string().min(1).max(120).optional(),
-      agentRuntimeType: z21.enum(AGENT_RUNTIME_TYPES).optional(),
-      capabilities: z21.string().max(4e3).optional().nullable(),
-      agentDefaultsPayload: z21.record(z21.string(), z21.unknown()).optional().nullable(),
+    acceptInviteSchema = z22.object({
+      requestType: z22.enum(JOIN_REQUEST_TYPES),
+      agentName: z22.string().min(1).max(120).optional(),
+      agentRuntimeType: z22.enum(AGENT_RUNTIME_TYPES).optional(),
+      capabilities: z22.string().max(4e3).optional().nullable(),
+      agentDefaultsPayload: z22.record(z22.string(), z22.unknown()).optional().nullable(),
       // OpenClaw join compatibility fields accepted at top level.
-      responsesWebhookUrl: z21.string().max(4e3).optional().nullable(),
-      responsesWebhookMethod: z21.string().max(32).optional().nullable(),
-      responsesWebhookHeaders: z21.record(z21.string(), z21.unknown()).optional().nullable(),
-      rudderApiUrl: z21.string().max(4e3).optional().nullable(),
-      webhookAuthHeader: z21.string().max(4e3).optional().nullable()
+      responsesWebhookUrl: z22.string().max(4e3).optional().nullable(),
+      responsesWebhookMethod: z22.string().max(32).optional().nullable(),
+      responsesWebhookHeaders: z22.record(z22.string(), z22.unknown()).optional().nullable(),
+      rudderApiUrl: z22.string().max(4e3).optional().nullable(),
+      webhookAuthHeader: z22.string().max(4e3).optional().nullable()
     });
-    listJoinRequestsQuerySchema = z21.object({
-      status: z21.enum(JOIN_REQUEST_STATUSES).optional(),
-      requestType: z21.enum(JOIN_REQUEST_TYPES).optional()
+    listJoinRequestsQuerySchema = z22.object({
+      status: z22.enum(JOIN_REQUEST_STATUSES).optional(),
+      requestType: z22.enum(JOIN_REQUEST_TYPES).optional()
     });
-    claimJoinRequestApiKeySchema = z21.object({
-      claimSecret: z21.string().min(16).max(256)
+    claimJoinRequestApiKeySchema = z22.object({
+      claimSecret: z22.string().min(16).max(256)
     });
-    boardCliAuthAccessLevelSchema = z21.enum([
+    boardCliAuthAccessLevelSchema = z22.enum([
       "board",
       "instance_admin_required"
     ]);
-    createCliAuthChallengeSchema = z21.object({
-      command: z21.string().min(1).max(240),
-      clientName: z21.string().max(120).optional().nullable(),
+    createCliAuthChallengeSchema = z22.object({
+      command: z22.string().min(1).max(240),
+      clientName: z22.string().max(120).optional().nullable(),
       requestedAccess: boardCliAuthAccessLevelSchema.default("board"),
-      requestedCompanyId: z21.string().uuid().optional().nullable()
+      requestedCompanyId: z22.string().uuid().optional().nullable()
     });
-    resolveCliAuthChallengeSchema = z21.object({
-      token: z21.string().min(16).max(256)
+    resolveCliAuthChallengeSchema = z22.object({
+      token: z22.string().min(16).max(256)
     });
-    updateMemberPermissionsSchema = z21.object({
-      grants: z21.array(
-        z21.object({
-          permissionKey: z21.enum(PERMISSION_KEYS),
-          scope: z21.record(z21.string(), z21.unknown()).optional().nullable()
+    updateMemberPermissionsSchema = z22.object({
+      grants: z22.array(
+        z22.object({
+          permissionKey: z22.enum(PERMISSION_KEYS),
+          scope: z22.record(z22.string(), z22.unknown()).optional().nullable()
         })
       )
     });
-    updateUserCompanyAccessSchema = z21.object({
-      orgIds: z21.array(z21.string().uuid()).default([])
+    updateUserCompanyAccessSchema = z22.object({
+      orgIds: z22.array(z22.string().uuid()).default([])
     });
   }
 });
 
 // ../packages/shared/src/validators/plugin.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 function isValidCronExpression(expression) {
   const trimmed = expression.trim();
   if (!trimmed) return false;
@@ -1738,7 +1859,7 @@ var init_plugin = __esm({
   "../packages/shared/src/validators/plugin.ts"() {
     "use strict";
     init_constants();
-    jsonSchemaSchema = z22.record(z22.unknown()).refine(
+    jsonSchemaSchema = z23.record(z23.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;
@@ -1746,76 +1867,76 @@ var init_plugin = __esm({
       { 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 = z22.object({
-      jobKey: z22.string().min(1),
-      displayName: z22.string().min(1),
-      description: z22.string().optional(),
-      schedule: z22.string().refine(
+    pluginJobDeclarationSchema = z23.object({
+      jobKey: z23.string().min(1),
+      displayName: z23.string().min(1),
+      description: z23.string().optional(),
+      schedule: z23.string().refine(
         (val) => isValidCronExpression(val),
         { message: "schedule must be a valid 5-field cron expression (e.g. '*/15 * * * *')" }
       ).optional()
     });
-    pluginWebhookDeclarationSchema = z22.object({
-      endpointKey: z22.string().min(1),
-      displayName: z22.string().min(1),
-      description: z22.string().optional()
+    pluginWebhookDeclarationSchema = z23.object({
+      endpointKey: z23.string().min(1),
+      displayName: z23.string().min(1),
+      description: z23.string().optional()
     });
-    pluginToolDeclarationSchema = z22.object({
-      name: z22.string().min(1),
-      displayName: z22.string().min(1),
-      description: z22.string().min(1),
+    pluginToolDeclarationSchema = z23.object({
+      name: z23.string().min(1),
+      displayName: z23.string().min(1),
+      description: z23.string().min(1),
       parametersSchema: jsonSchemaSchema
     });
-    pluginUiSlotDeclarationSchema = z22.object({
-      type: z22.enum(PLUGIN_UI_SLOT_TYPES),
-      id: z22.string().min(1),
-      displayName: z22.string().min(1),
-      exportName: z22.string().min(1),
-      entityTypes: z22.array(z22.enum(PLUGIN_UI_SLOT_ENTITY_TYPES)).optional(),
-      routePath: z22.string().regex(/^[a-z0-9][a-z0-9-]*$/, {
+    pluginUiSlotDeclarationSchema = z23.object({
+      type: z23.enum(PLUGIN_UI_SLOT_TYPES),
+      id: z23.string().min(1),
+      displayName: z23.string().min(1),
+      exportName: z23.string().min(1),
+      entityTypes: z23.array(z23.enum(PLUGIN_UI_SLOT_ENTITY_TYPES)).optional(),
+      routePath: z23.string().regex(/^[a-z0-9][a-z0-9-]*$/, {
         message: "routePath must be a lowercase single-segment slug (letters, numbers, hyphens)"
       }).optional(),
-      order: z22.number().int().optional()
+      order: z23.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: z22.ZodIssueCode.custom,
+          code: z23.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: z22.ZodIssueCode.custom,
+          code: z23.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: z22.ZodIssueCode.custom,
+          code: z23.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: z22.ZodIssueCode.custom,
+          code: z23.ZodIssueCode.custom,
           message: 'commentContextMenuItem slots require entityTypes to include "comment"',
           path: ["entityTypes"]
         });
       }
       if (value.routePath && value.type !== "page") {
         ctx.addIssue({
-          code: z22.ZodIssueCode.custom,
+          code: z23.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: z22.ZodIssueCode.custom,
+          code: z23.ZodIssueCode.custom,
           message: `routePath "${value.routePath}" is reserved by the host`,
           path: ["routePath"]
         });
@@ -1836,29 +1957,29 @@ var init_plugin = __esm({
       external: [],
       iframe: ["compact", "default", "wide", "full"]
     };
-    pluginLauncherActionDeclarationSchema = z22.object({
-      type: z22.enum(PLUGIN_LAUNCHER_ACTIONS),
-      target: z22.string().min(1),
-      params: z22.record(z22.unknown()).optional()
+    pluginLauncherActionDeclarationSchema = z23.object({
+      type: z23.enum(PLUGIN_LAUNCHER_ACTIONS),
+      target: z23.string().min(1),
+      params: z23.record(z23.unknown()).optional()
     }).superRefine((value, ctx) => {
       if (value.type === "performAction" && value.target.includes("/")) {
         ctx.addIssue({
-          code: z22.ZodIssueCode.custom,
+          code: z23.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: z22.ZodIssueCode.custom,
+          code: z23.ZodIssueCode.custom,
           message: "navigate launchers must target a host route, not an absolute URL",
           path: ["target"]
         });
       }
     });
-    pluginLauncherRenderDeclarationSchema = z22.object({
-      environment: z22.enum(PLUGIN_LAUNCHER_RENDER_ENVIRONMENTS),
-      bounds: z22.enum(PLUGIN_LAUNCHER_BOUNDS).optional()
+    pluginLauncherRenderDeclarationSchema = z23.object({
+      environment: z23.enum(PLUGIN_LAUNCHER_RENDER_ENVIRONMENTS),
+      bounds: z23.enum(PLUGIN_LAUNCHER_BOUNDS).optional()
     }).superRefine((value, ctx) => {
       if (!value.bounds) {
         return;
@@ -1866,122 +1987,122 @@ var init_plugin = __esm({
       const supportedBounds = launcherBoundsByEnvironment[value.environment];
       if (!supportedBounds.includes(value.bounds)) {
         ctx.addIssue({
-          code: z22.ZodIssueCode.custom,
+          code: z23.ZodIssueCode.custom,
           message: `bounds "${value.bounds}" is not supported for render environment "${value.environment}"`,
           path: ["bounds"]
         });
       }
     });
-    pluginLauncherDeclarationSchema = z22.object({
-      id: z22.string().min(1),
-      displayName: z22.string().min(1),
-      description: z22.string().optional(),
-      placementZone: z22.enum(PLUGIN_LAUNCHER_PLACEMENT_ZONES),
-      exportName: z22.string().min(1).optional(),
-      entityTypes: z22.array(z22.enum(PLUGIN_UI_SLOT_ENTITY_TYPES)).optional(),
-      order: z22.number().int().optional(),
+    pluginLauncherDeclarationSchema = z23.object({
+      id: z23.string().min(1),
+      displayName: z23.string().min(1),
+      description: z23.string().optional(),
+      placementZone: z23.enum(PLUGIN_LAUNCHER_PLACEMENT_ZONES),
+      exportName: z23.string().min(1).optional(),
+      entityTypes: z23.array(z23.enum(PLUGIN_UI_SLOT_ENTITY_TYPES)).optional(),
+      order: z23.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: z22.ZodIssueCode.custom,
+          code: z23.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: z22.ZodIssueCode.custom,
+          code: z23.ZodIssueCode.custom,
           message: 'projectSidebarItem launchers require entityTypes to include "project"',
           path: ["entityTypes"]
         });
       }
       if (value.action.type === "performAction" && value.render) {
         ctx.addIssue({
-          code: z22.ZodIssueCode.custom,
+          code: z23.ZodIssueCode.custom,
           message: "performAction launchers cannot declare render hints",
           path: ["render"]
         });
       }
       if (["openModal", "openDrawer", "openPopover"].includes(value.action.type) && !value.render) {
         ctx.addIssue({
-          code: z22.ZodIssueCode.custom,
+          code: z23.ZodIssueCode.custom,
           message: `${value.action.type} launchers require render metadata`,
           path: ["render"]
         });
       }
       if (value.action.type === "openModal" && value.render?.environment === "hostInline") {
         ctx.addIssue({
-          code: z22.ZodIssueCode.custom,
+          code: z23.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: z22.ZodIssueCode.custom,
+          code: z23.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: z22.ZodIssueCode.custom,
+          code: z23.ZodIssueCode.custom,
           message: "openPopover launchers cannot use the hostRoute render environment",
           path: ["render", "environment"]
         });
       }
     });
-    pluginManifestV1Schema = z22.object({
-      id: z22.string().min(1).regex(
+    pluginManifestV1Schema = z23.object({
+      id: z23.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: z22.literal(1),
-      version: z22.string().min(1).regex(
+      apiVersion: z23.literal(1),
+      version: z23.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: z22.string().min(1).max(100),
-      description: z22.string().min(1).max(500),
-      author: z22.string().min(1).max(200),
-      categories: z22.array(z22.enum(PLUGIN_CATEGORIES)).min(1),
-      minimumHostVersion: z22.string().regex(
+      displayName: z23.string().min(1).max(100),
+      description: z23.string().min(1).max(500),
+      author: z23.string().min(1).max(200),
+      categories: z23.array(z23.enum(PLUGIN_CATEGORIES)).min(1),
+      minimumHostVersion: z23.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: z22.string().regex(
+      minimumPaperclipVersion: z23.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: z22.array(z22.enum(PLUGIN_CAPABILITIES)).min(1),
-      entrypoints: z22.object({
-        worker: z22.string().min(1),
-        ui: z22.string().min(1).optional()
+      capabilities: z23.array(z23.enum(PLUGIN_CAPABILITIES)).min(1),
+      entrypoints: z23.object({
+        worker: z23.string().min(1),
+        ui: z23.string().min(1).optional()
       }),
       instanceConfigSchema: jsonSchemaSchema.optional(),
-      jobs: z22.array(pluginJobDeclarationSchema).optional(),
-      webhooks: z22.array(pluginWebhookDeclarationSchema).optional(),
-      tools: z22.array(pluginToolDeclarationSchema).optional(),
-      launchers: z22.array(pluginLauncherDeclarationSchema).optional(),
-      ui: z22.object({
-        slots: z22.array(pluginUiSlotDeclarationSchema).min(1).optional(),
-        launchers: z22.array(pluginLauncherDeclarationSchema).optional()
+      jobs: z23.array(pluginJobDeclarationSchema).optional(),
+      webhooks: z23.array(pluginWebhookDeclarationSchema).optional(),
+      tools: z23.array(pluginToolDeclarationSchema).optional(),
+      launchers: z23.array(pluginLauncherDeclarationSchema).optional(),
+      ui: z23.object({
+        slots: z23.array(pluginUiSlotDeclarationSchema).min(1).optional(),
+        launchers: z23.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: z22.ZodIssueCode.custom,
+          code: z23.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: z22.ZodIssueCode.custom,
+          code: z23.ZodIssueCode.custom,
           message: "minimumHostVersion and minimumPaperclipVersion must match when both are declared",
           path: ["minimumHostVersion"]
         });
@@ -1989,7 +2110,7 @@ var init_plugin = __esm({
       if (manifest.tools && manifest.tools.length > 0) {
         if (!manifest.capabilities.includes("agent.tools.register")) {
           ctx.addIssue({
-            code: z22.ZodIssueCode.custom,
+            code: z23.ZodIssueCode.custom,
             message: "Capability 'agent.tools.register' is required when tools are declared",
             path: ["capabilities"]
           });
@@ -1998,7 +2119,7 @@ var init_plugin = __esm({
       if (manifest.jobs && manifest.jobs.length > 0) {
         if (!manifest.capabilities.includes("jobs.schedule")) {
           ctx.addIssue({
-            code: z22.ZodIssueCode.custom,
+            code: z23.ZodIssueCode.custom,
             message: "Capability 'jobs.schedule' is required when jobs are declared",
             path: ["capabilities"]
           });
@@ -2007,7 +2128,7 @@ var init_plugin = __esm({
       if (manifest.webhooks && manifest.webhooks.length > 0) {
         if (!manifest.capabilities.includes("webhooks.receive")) {
           ctx.addIssue({
-            code: z22.ZodIssueCode.custom,
+            code: z23.ZodIssueCode.custom,
             message: "Capability 'webhooks.receive' is required when webhooks are declared",
             path: ["capabilities"]
           });
@@ -2018,7 +2139,7 @@ var init_plugin = __esm({
         const duplicates = jobKeys.filter((key, i) => jobKeys.indexOf(key) !== i);
         if (duplicates.length > 0) {
           ctx.addIssue({
-            code: z22.ZodIssueCode.custom,
+            code: z23.ZodIssueCode.custom,
             message: `Duplicate job keys: ${[...new Set(duplicates)].join(", ")}`,
             path: ["jobs"]
           });
@@ -2029,7 +2150,7 @@ var init_plugin = __esm({
         const duplicates = endpointKeys.filter((key, i) => endpointKeys.indexOf(key) !== i);
         if (duplicates.length > 0) {
           ctx.addIssue({
-            code: z22.ZodIssueCode.custom,
+            code: z23.ZodIssueCode.custom,
             message: `Duplicate webhook endpoint keys: ${[...new Set(duplicates)].join(", ")}`,
             path: ["webhooks"]
           });
@@ -2040,7 +2161,7 @@ var init_plugin = __esm({
         const duplicates = toolNames.filter((name, i) => toolNames.indexOf(name) !== i);
         if (duplicates.length > 0) {
           ctx.addIssue({
-            code: z22.ZodIssueCode.custom,
+            code: z23.ZodIssueCode.custom,
             message: `Duplicate tool names: ${[...new Set(duplicates)].join(", ")}`,
             path: ["tools"]
           });
@@ -2052,7 +2173,7 @@ var init_plugin = __esm({
           const duplicates = slotIds.filter((id, i) => slotIds.indexOf(id) !== i);
           if (duplicates.length > 0) {
             ctx.addIssue({
-              code: z22.ZodIssueCode.custom,
+              code: z23.ZodIssueCode.custom,
               message: `Duplicate UI slot ids: ${[...new Set(duplicates)].join(", ")}`,
               path: ["ui", "slots"]
             });
@@ -2068,50 +2189,50 @@ var init_plugin = __esm({
         const duplicates = launcherIds.filter((id, i) => launcherIds.indexOf(id) !== i);
         if (duplicates.length > 0) {
           ctx.addIssue({
-            code: z22.ZodIssueCode.custom,
+            code: z23.ZodIssueCode.custom,
             message: `Duplicate launcher ids: ${[...new Set(duplicates)].join(", ")}`,
             path: manifest.ui?.launchers ? ["ui", "launchers"] : ["launchers"]
           });
         }
       }
     });
-    installPluginSchema = z22.object({
-      packageName: z22.string().min(1),
-      version: z22.string().min(1).optional(),
+    installPluginSchema = z23.object({
+      packageName: z23.string().min(1),
+      version: z23.string().min(1).optional(),
       /** Set by loader for local-path installs so the worker can be resolved. */
-      packagePath: z22.string().min(1).optional()
+      packagePath: z23.string().min(1).optional()
     });
-    upsertPluginConfigSchema = z22.object({
-      configJson: z22.record(z22.unknown())
+    upsertPluginConfigSchema = z23.object({
+      configJson: z23.record(z23.unknown())
     });
-    patchPluginConfigSchema = z22.object({
-      configJson: z22.record(z22.unknown())
+    patchPluginConfigSchema = z23.object({
+      configJson: z23.record(z23.unknown())
     });
-    updatePluginStatusSchema = z22.object({
-      status: z22.enum(PLUGIN_STATUSES),
-      lastError: z22.string().nullable().optional()
+    updatePluginStatusSchema = z23.object({
+      status: z23.enum(PLUGIN_STATUSES),
+      lastError: z23.string().nullable().optional()
     });
-    uninstallPluginSchema = z22.object({
-      removeData: z22.boolean().optional().default(false)
+    uninstallPluginSchema = z23.object({
+      removeData: z23.boolean().optional().default(false)
     });
-    pluginStateScopeKeySchema = z22.object({
-      scopeKind: z22.enum(PLUGIN_STATE_SCOPE_KINDS),
-      scopeId: z22.string().min(1).optional(),
-      namespace: z22.string().min(1).optional(),
-      stateKey: z22.string().min(1)
+    pluginStateScopeKeySchema = z23.object({
+      scopeKind: z23.enum(PLUGIN_STATE_SCOPE_KINDS),
+      scopeId: z23.string().min(1).optional(),
+      namespace: z23.string().min(1).optional(),
+      stateKey: z23.string().min(1)
     });
-    setPluginStateSchema = z22.object({
-      scopeKind: z22.enum(PLUGIN_STATE_SCOPE_KINDS),
-      scopeId: z22.string().min(1).optional(),
-      namespace: z22.string().min(1).optional(),
-      stateKey: z22.string().min(1),
+    setPluginStateSchema = z23.object({
+      scopeKind: z23.enum(PLUGIN_STATE_SCOPE_KINDS),
+      scopeId: z23.string().min(1).optional(),
+      namespace: z23.string().min(1).optional(),
+      stateKey: z23.string().min(1),
       /** JSON-serializable value to store. */
-      value: z22.unknown()
+      value: z23.unknown()
     });
-    listPluginStateSchema = z22.object({
-      scopeKind: z22.enum(PLUGIN_STATE_SCOPE_KINDS).optional(),
-      scopeId: z22.string().min(1).optional(),
-      namespace: z22.string().min(1).optional()
+    listPluginStateSchema = z23.object({
+      scopeKind: z23.enum(PLUGIN_STATE_SCOPE_KINDS).optional(),
+      scopeId: z23.string().min(1).optional(),
+      namespace: z23.string().min(1).optional()
     });
   }
 });
@@ -2215,39 +2336,42 @@ var init_organization_skill_reference = __esm({
 });
 
 // ../packages/shared/src/project-mentions.ts
+var PROJECT_COLOR_VALUES;
 var init_project_mentions = __esm({
   "../packages/shared/src/project-mentions.ts"() {
     "use strict";
+    init_constants();
+    PROJECT_COLOR_VALUES = new Set(PROJECT_COLORS);
   }
 });
 
 // ../packages/shared/src/config-schema.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var configMetaSchema, llmConfigSchema, databaseBackupConfigSchema, databaseConfigSchema, loggingConfigSchema, serverConfigSchema, authConfigSchema, storageLocalDiskConfigSchema, storageS3ConfigSchema, storageConfigSchema, secretsLocalEncryptedConfigSchema, secretsConfigSchema, langfuseConfigSchema, rudderConfigSchema;
 var init_config_schema = __esm({
   "../packages/shared/src/config-schema.ts"() {
     "use strict";
     init_constants();
-    configMetaSchema = z23.object({
-      version: z23.literal(1),
-      updatedAt: z23.string(),
-      source: z23.enum(["onboard", "configure", "doctor"])
+    configMetaSchema = z24.object({
+      version: z24.literal(1),
+      updatedAt: z24.string(),
+      source: z24.enum(["onboard", "configure", "doctor"])
     });
-    llmConfigSchema = z23.object({
-      provider: z23.enum(["claude", "openai"]),
-      apiKey: z23.string().optional()
+    llmConfigSchema = z24.object({
+      provider: z24.enum(["claude", "openai"]),
+      apiKey: z24.string().optional()
     });
-    databaseBackupConfigSchema = z23.object({
-      enabled: z23.boolean().default(true),
-      intervalMinutes: z23.number().int().min(1).max(7 * 24 * 60).default(60),
-      retentionDays: z23.number().int().min(1).max(3650).default(30),
-      dir: z23.string().default("~/.rudder/instances/default/data/backups")
+    databaseBackupConfigSchema = z24.object({
+      enabled: z24.boolean().default(true),
+      intervalMinutes: z24.number().int().min(1).max(7 * 24 * 60).default(60),
+      retentionDays: z24.number().int().min(1).max(3650).default(30),
+      dir: z24.string().default("~/.rudder/instances/default/data/backups")
     });
-    databaseConfigSchema = z23.object({
-      mode: z23.enum(["embedded-postgres", "postgres"]).default("embedded-postgres"),
-      connectionString: z23.string().optional(),
-      embeddedPostgresDataDir: z23.string().default("~/.rudder/instances/default/db"),
-      embeddedPostgresPort: z23.number().int().min(1).max(65535).default(54329),
+    databaseConfigSchema = z24.object({
+      mode: z24.enum(["embedded-postgres", "postgres"]).default("embedded-postgres"),
+      connectionString: z24.string().optional(),
+      embeddedPostgresDataDir: z24.string().default("~/.rudder/instances/default/db"),
+      embeddedPostgresPort: z24.number().int().min(1).max(65535).default(54329),
       backup: databaseBackupConfigSchema.default({
         enabled: true,
         intervalMinutes: 60,
@@ -2255,35 +2379,35 @@ var init_config_schema = __esm({
         dir: "~/.rudder/instances/default/data/backups"
       })
     });
-    loggingConfigSchema = z23.object({
-      mode: z23.enum(["file", "cloud"]),
-      logDir: z23.string().default("~/.rudder/instances/default/logs")
+    loggingConfigSchema = z24.object({
+      mode: z24.enum(["file", "cloud"]),
+      logDir: z24.string().default("~/.rudder/instances/default/logs")
     });
-    serverConfigSchema = z23.object({
-      deploymentMode: z23.enum(DEPLOYMENT_MODES).default("local_trusted"),
-      exposure: z23.enum(DEPLOYMENT_EXPOSURES).default("private"),
-      host: z23.string().default("127.0.0.1"),
-      port: z23.number().int().min(1).max(65535).default(3100),
-      allowedHostnames: z23.array(z23.string().min(1)).default([]),
-      serveUi: z23.boolean().default(true)
+    serverConfigSchema = z24.object({
+      deploymentMode: z24.enum(DEPLOYMENT_MODES).default("local_trusted"),
+      exposure: z24.enum(DEPLOYMENT_EXPOSURES).default("private"),
+      host: z24.string().default("127.0.0.1"),
+      port: z24.number().int().min(1).max(65535).default(3100),
+      allowedHostnames: z24.array(z24.string().min(1)).default([]),
+      serveUi: z24.boolean().default(true)
     });
-    authConfigSchema = z23.object({
-      baseUrlMode: z23.enum(AUTH_BASE_URL_MODES).default("auto"),
-      publicBaseUrl: z23.string().url().optional(),
-      disableSignUp: z23.boolean().default(false)
+    authConfigSchema = z24.object({
+      baseUrlMode: z24.enum(AUTH_BASE_URL_MODES).default("auto"),
+      publicBaseUrl: z24.string().url().optional(),
+      disableSignUp: z24.boolean().default(false)
     });
-    storageLocalDiskConfigSchema = z23.object({
-      baseDir: z23.string().default("~/.rudder/instances/default/data/storage")
+    storageLocalDiskConfigSchema = z24.object({
+      baseDir: z24.string().default("~/.rudder/instances/default/data/storage")
     });
-    storageS3ConfigSchema = z23.object({
-      bucket: z23.string().min(1).default("rudder"),
-      region: z23.string().min(1).default("us-east-1"),
-      endpoint: z23.string().optional(),
-      prefix: z23.string().default(""),
-      forcePathStyle: z23.boolean().default(false)
+    storageS3ConfigSchema = z24.object({
+      bucket: z24.string().min(1).default("rudder"),
+      region: z24.string().min(1).default("us-east-1"),
+      endpoint: z24.string().optional(),
+      prefix: z24.string().default(""),
+      forcePathStyle: z24.boolean().default(false)
     });
-    storageConfigSchema = z23.object({
-      provider: z23.enum(STORAGE_PROVIDERS).default("local_disk"),
+    storageConfigSchema = z24.object({
+      provider: z24.enum(STORAGE_PROVIDERS).default("local_disk"),
       localDisk: storageLocalDiskConfigSchema.default({
         baseDir: "~/.rudder/instances/default/data/storage"
       }),
@@ -2294,24 +2418,24 @@ var init_config_schema = __esm({
         forcePathStyle: false
       })
     });
-    secretsLocalEncryptedConfigSchema = z23.object({
-      keyFilePath: z23.string().default("~/.rudder/instances/default/secrets/master.key")
+    secretsLocalEncryptedConfigSchema = z24.object({
+      keyFilePath: z24.string().default("~/.rudder/instances/default/secrets/master.key")
     });
-    secretsConfigSchema = z23.object({
-      provider: z23.enum(SECRET_PROVIDERS).default("local_encrypted"),
-      strictMode: z23.boolean().default(false),
+    secretsConfigSchema = z24.object({
+      provider: z24.enum(SECRET_PROVIDERS).default("local_encrypted"),
+      strictMode: z24.boolean().default(false),
       localEncrypted: secretsLocalEncryptedConfigSchema.default({
         keyFilePath: "~/.rudder/instances/default/secrets/master.key"
       })
     });
-    langfuseConfigSchema = z23.object({
-      enabled: z23.boolean().default(false),
-      baseUrl: z23.string().url().default("http://localhost:3000"),
-      publicKey: z23.string().optional(),
-      secretKey: z23.string().optional(),
-      environment: z23.string().optional()
+    langfuseConfigSchema = z24.object({
+      enabled: z24.boolean().default(false),
+      baseUrl: z24.string().url().default("http://localhost:3000"),
+      publicKey: z24.string().optional(),
+      secretKey: z24.string().optional(),
+      environment: z24.string().optional()
     });
-    rudderConfigSchema = z23.object({
+    rudderConfigSchema = z24.object({
       $meta: configMetaSchema,
       llm: llmConfigSchema.optional(),
       database: databaseConfigSchema,
@@ -2345,7 +2469,7 @@ var init_config_schema = __esm({
       if (value.server.deploymentMode === "local_trusted") {
         if (value.server.exposure !== "private") {
           ctx.addIssue({
-            code: z23.ZodIssueCode.custom,
+            code: z24.ZodIssueCode.custom,
             message: "server.exposure must be private when deploymentMode is local_trusted",
             path: ["server", "exposure"]
           });
@@ -2354,21 +2478,21 @@ var init_config_schema = __esm({
       }
       if (value.auth.baseUrlMode === "explicit" && !value.auth.publicBaseUrl) {
         ctx.addIssue({
-          code: z23.ZodIssueCode.custom,
+          code: z24.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: z23.ZodIssueCode.custom,
+          code: z24.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: z23.ZodIssueCode.custom,
+          code: z24.ZodIssueCode.custom,
           message: "auth.publicBaseUrl is required when deploymentMode=authenticated and exposure=public",
           path: ["auth", "publicBaseUrl"]
         });
@@ -3619,7 +3743,6 @@ var init_instance_settings = __esm({
         singletonKey: text11("singleton_key").notNull().default("default"),
         general: jsonb4("general").$type().notNull().default({}),
         notifications: jsonb4("notifications").$type().notNull().default({}),
-        experimental: jsonb4("experimental").$type().notNull().default({}),
         createdAt: timestamp7("created_at", { withTimezone: true }).notNull().defaultNow(),
         updatedAt: timestamp7("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
@@ -7866,6 +7989,9 @@ function isTransientBinaryPath(candidatePath) {
   return normalized.includes("/_npx/");
 }
 function hasGlobalInstalledPackage(packageName, execFileSyncImpl = execFileSync) {
+  return getGlobalInstalledPackageVersion(packageName, execFileSyncImpl) !== null;
+}
+function getGlobalInstalledPackageVersion(packageName, execFileSyncImpl = execFileSync) {
   try {
     const output = execFileSyncImpl(
       process.platform === "win32" ? "npm.cmd" : "npm",
@@ -7876,9 +8002,9 @@ function hasGlobalInstalledPackage(packageName, execFileSyncImpl = execFileSync)
       }
     );
     const parsed = JSON.parse(output);
-    return Boolean(parsed.dependencies?.[packageName]?.version);
+    return parsed.dependencies?.[packageName]?.version ?? null;
   } catch {
-    return false;
+    return null;
   }
 }
 function hasPersistentBinaryOnPath(execFileSyncImpl = execFileSync) {
@@ -7918,16 +8044,36 @@ function detectPersistentCliState(options = {}) {
 function installPersistentCli(options) {
   const spawnSyncImpl = options.spawnSyncImpl ?? spawnSync;
   const command = `npm install --global ${options.installSpec}`;
-  const result = spawnSyncImpl(process.platform === "win32" ? "npm.cmd" : "npm", ["install", "--global", options.installSpec], {
+  const initialResult = runNpmGlobalInstall(spawnSyncImpl, ["install", "--global", options.installSpec]);
+  const initialOutput = collectSpawnOutput(initialResult);
+  if (initialResult.status === 0 || !isRudderBinConflict(initialOutput)) {
+    return {
+      ok: initialResult.status === 0,
+      command,
+      output: initialOutput
+    };
+  }
+  const forcedCommand = `npm install --global --force ${options.installSpec}`;
+  const forcedResult = runNpmGlobalInstall(spawnSyncImpl, ["install", "--global", "--force", options.installSpec]);
+  const forcedOutput = collectSpawnOutput(forcedResult);
+  return {
+    ok: forcedResult.status === 0,
+    command: forcedCommand,
+    output: forcedOutput || initialOutput
+  };
+}
+function runNpmGlobalInstall(spawnSyncImpl, args) {
+  return spawnSyncImpl(process.platform === "win32" ? "npm.cmd" : "npm", args, {
     encoding: "utf8",
     stdio: ["inherit", "pipe", "pipe"]
   });
-  const output = [result.stdout, result.stderr].filter((value) => typeof value === "string" && value.trim().length > 0).join("\n").trim();
-  return {
-    ok: result.status === 0,
-    command,
-    output
-  };
+}
+function collectSpawnOutput(result) {
+  return [result.stdout, result.stderr].filter((value) => typeof value === "string" && value.trim().length > 0).join("\n").trim();
+}
+function isRudderBinConflict(output) {
+  const normalized = output.toLowerCase().replaceAll("\\", "/");
+  return normalized.includes("eexist") && (normalized.includes(`/${CLI_BIN_NAME}`) || normalized.includes(`/${CLI_BIN_NAME}.cmd`) || normalized.includes(`/${CLI_BIN_NAME}.ps1`));
 }
 var CLI_NPM_PACKAGE_NAME, CLI_BIN_NAME;
 var init_install = __esm({
@@ -9878,44 +10024,179 @@ ${err instanceof Error ? err.message : String(err)}`
 
 // src/commands/start.ts
 init_install();
-import { spawnSync as spawnSync2 } from "node:child_process";
+import { spawn, spawnSync as spawnSync2 } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
-import { createWriteStream, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync } from "node:fs";
-import { chmod, mkdtemp } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path9 from "node:path";
-import { Readable } from "node:stream";
+import { constants as fsConstants, createWriteStream, mkdirSync as mkdirSync2, readFileSync as readFileSync2 } from "node:fs";
+import { access, chmod, copyFile, cp, mkdtemp, mkdir, readFile as readFile3, readdir as readdir2, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import path10 from "node:path";
+import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { setTimeout as delay } from "node:timers/promises";
 import * as p13 from "@clack/prompts";
 import pc8 from "picocolors";
-var DEFAULT_DESKTOP_RELEASE_REPO = "Undertone0809/rudder";
-var STABLE_SEMVER_RE = /^[0-9]+\.[0-9]+\.[0-9]+$/;
-var CANARY_SEMVER_RE = /^[0-9]+\.[0-9]+\.[0-9]+-canary\.[0-9]+$/;
-var CLI_REGISTRY_LATEST_URL = "https://registry.npmjs.org/@rudderhq%2fcli/latest";
-function resolveCurrentCliVersion(env = process.env) {
-  const envPackageName = env.npm_package_name?.trim();
-  const envPackageVersion = env.npm_package_version?.trim();
-  if (envPackageName === CLI_NPM_PACKAGE_NAME && envPackageVersion) return envPackageVersion;
-  const moduleDir = path9.dirname(fileURLToPath3(import.meta.url));
+
+// src/utils/progress.ts
+var BYTE_UNITS = ["B", "KB", "MB", "GB", "TB"];
+function formatBytes(bytes) {
+  let value = Math.max(0, bytes);
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < BYTE_UNITS.length - 1) {
+    value /= 1024;
+    unitIndex += 1;
+  }
+  if (unitIndex === 0) return `${Math.round(value)} ${BYTE_UNITS[unitIndex]}`;
+  return `${value.toFixed(1)} ${BYTE_UNITS[unitIndex]}`;
+}
+function normalizeTotalBytes(totalBytes) {
+  if (typeof totalBytes !== "number" || !Number.isFinite(totalBytes) || totalBytes <= 0) {
+    return null;
+  }
+  return totalBytes;
+}
+function formatByteProgress(state) {
+  const width = Math.max(4, state.width ?? 20);
+  const receivedBytes = Math.max(0, state.receivedBytes);
+  const totalBytes = normalizeTotalBytes(state.totalBytes);
+  if (totalBytes === null) {
+    return `[downloaded ${formatBytes(receivedBytes)}]`;
+  }
+  const ratio = Math.max(0, Math.min(1, receivedBytes / totalBytes));
+  const filled = Math.round(ratio * width);
+  const percent = Math.floor(ratio * 100);
+  return `[${"#".repeat(filled)}${"-".repeat(width - filled)}] ${percent}% ${formatBytes(receivedBytes)}/${formatBytes(totalBytes)}`;
+}
+function progressSummary(receivedBytes, totalBytes) {
+  const total = normalizeTotalBytes(totalBytes);
+  if (total === null) return formatBytes(receivedBytes);
+  return `${formatBytes(receivedBytes)}/${formatBytes(total)}`;
+}
+function createByteProgress(label, options = {}) {
+  const stream = options.stream ?? process.stdout;
+  const isTty = options.isTty ?? Boolean(stream.isTTY);
+  const width = options.width ?? 20;
+  const minIntervalMs = options.minIntervalMs ?? 80;
+  const now = options.now ?? (() => Date.now());
+  let started = false;
+  let finished = false;
+  let lastRenderAt = 0;
+  let lastLineLength = 0;
+  let latestReceivedBytes = 0;
+  let latestTotalBytes = null;
+  function render(receivedBytes, totalBytes, force = false) {
+    if (finished) return;
+    latestReceivedBytes = receivedBytes;
+    latestTotalBytes = totalBytes;
+    if (!isTty) return;
+    const currentTime = now();
+    const total = normalizeTotalBytes(totalBytes);
+    const complete = total !== null && receivedBytes >= total;
+    if (!force && currentTime - lastRenderAt < minIntervalMs && !complete) return;
+    const line = `${label} ${formatByteProgress({ receivedBytes, totalBytes, width })}`;
+    const padding = lastLineLength > line.length ? " ".repeat(lastLineLength - line.length) : "";
+    stream.write(`\r${line}${padding}`);
+    lastLineLength = line.length;
+    lastRenderAt = currentTime;
+  }
+  function start(totalBytes) {
+    if (started || finished) return;
+    started = true;
+    latestTotalBytes = totalBytes;
+    if (isTty) {
+      render(0, totalBytes, true);
+    } else {
+      stream.write(`${label}...
+`);
+    }
+  }
+  function update(receivedBytes, totalBytes) {
+    if (!started) start(totalBytes);
+    render(receivedBytes, totalBytes, false);
+  }
+  function finish(receivedBytes = latestReceivedBytes, totalBytes = latestTotalBytes) {
+    if (finished) return;
+    if (!started) start(totalBytes);
+    if (isTty) {
+      render(receivedBytes, totalBytes, true);
+      stream.write("\n");
+    } else {
+      stream.write(`${label} complete (${progressSummary(receivedBytes, totalBytes)}).
+`);
+    }
+    finished = true;
+  }
+  function fail() {
+    if (finished) return;
+    if (isTty && started) {
+      stream.write("\n");
+    } else if (!isTty && started) {
+      stream.write(`${label} failed.
+`);
+    }
+    finished = true;
+  }
+  return {
+    start,
+    update,
+    finish,
+    fail
+  };
+}
+
+// src/version.ts
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import path9 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+var CLI_PACKAGE_NAME = "@rudderhq/cli";
+var CLI_VERSION_MANIFEST = "rudder-cli-package.json";
+function readPackageVersion(packagePath, expectedName) {
+  if (!existsSync2(packagePath)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(packagePath, "utf8"));
+    if (parsed.name === expectedName && parsed.version) return parsed.version;
+  } catch {
+    return null;
+  }
+  return null;
+}
+function resolveCliVersion(moduleUrl = import.meta.url, env = process.env) {
+  if (env.npm_package_name === CLI_PACKAGE_NAME && env.npm_package_version) {
+    return env.npm_package_version;
+  }
+  const moduleDir = path9.dirname(fileURLToPath3(moduleUrl));
   const candidates = [
+    path9.resolve(moduleDir, CLI_VERSION_MANIFEST),
+    path9.resolve(moduleDir, "package.json"),
     path9.resolve(moduleDir, "../package.json"),
     path9.resolve(moduleDir, "../../package.json")
   ];
   for (const candidate of candidates) {
-    if (!existsSync2(candidate)) continue;
-    try {
-      const parsed = JSON.parse(readFileSync(candidate, "utf8"));
-      if (parsed.name === CLI_NPM_PACKAGE_NAME && parsed.version) return parsed.version;
-    } catch {
-    }
+    const version = readPackageVersion(candidate, CLI_PACKAGE_NAME);
+    if (version) return version;
   }
-  return "latest";
+  return "0.0.0";
+}
+
+// src/commands/start.ts
+var DEFAULT_DESKTOP_RELEASE_REPO = "Undertone0809/rudder";
+var DESKTOP_UPDATE_QUIT_ARG = "--rudder-update-quit";
+var STABLE_SEMVER_RE = /^[0-9]+\.[0-9]+\.[0-9]+$/;
+var CANARY_SEMVER_RE = /^[0-9]+\.[0-9]+\.[0-9]+-canary\.[0-9]+$/;
+var CLI_REGISTRY_LATEST_URL = "https://registry.npmjs.org/@rudderhq%2fcli/latest";
+var DESKTOP_APP_NAME = "Rudder";
+var DESKTOP_METADATA_FILE = ".rudder-desktop-install.json";
+var DESKTOP_CHECKSUM_ASSET_NAME = "SHASUMS256.txt";
+function resolveCurrentCliVersion(env = process.env) {
+  const version = resolveCliVersion(import.meta.url, env);
+  return version === "0.0.0" ? "latest" : version;
 }
 function resolveCliInstallSpec(version, env = process.env) {
   if (version && version !== "latest") return `${CLI_NPM_PACKAGE_NAME}@${version}`;
   return resolvePersistentCliInstallSpec(env);
 }
+function isPersistentCliVersionCurrent(version, installedVersion) {
+  return Boolean(version && version !== "latest" && installedVersion === version);
+}
 function compareStableSemver(a, b) {
   const aMatch = a.match(/^([0-9]+)\.([0-9]+)\.([0-9]+)$/);
   const bMatch = b.match(/^([0-9]+)\.([0-9]+)\.([0-9]+)$/);
@@ -9955,18 +10236,59 @@ function resolveDesktopReleaseTag(version) {
   if (STABLE_SEMVER_RE.test(version)) return `v${version}`;
   if (CANARY_SEMVER_RE.test(version)) return `canary/v${version}`;
   throw new Error(
-    `Desktop installer lookup requires a release version like 0.1.0 or 0.1.0-canary.0. Received ${version}.`
+    `Desktop release lookup requires a release version like 0.1.0 or 0.1.0-canary.0. Received ${version}.`
   );
 }
 function resolveDesktopAssetTarget(platform = process.platform, arch = process.arch) {
-  const normalizedArch = arch === "x64" || arch === "arm64" ? arch : null;
-  if (!normalizedArch) {
-    throw new Error(`Rudder Desktop does not publish installers for ${platform}/${arch}.`);
+  if (platform === "darwin") {
+    if (arch !== "x64" && arch !== "arm64") {
+      throw new Error(`Rudder Desktop does not publish portable assets for ${platform}/${arch}.`);
+    }
+    return { platform: "macos", arch, extension: ".zip" };
   }
-  if (platform === "darwin") return { platform: "macos", arch: normalizedArch, extension: ".dmg" };
-  if (platform === "win32") return { platform: "windows", arch: normalizedArch, extension: ".exe" };
-  if (platform === "linux") return { platform: "linux", arch: normalizedArch, extension: ".AppImage" };
-  throw new Error(`Rudder Desktop does not publish installers for ${platform}.`);
+  if (platform === "win32") return { platform: "windows", arch: "x64", extension: ".zip" };
+  if (platform === "linux") {
+    if (arch !== "x64") {
+      throw new Error(`Rudder Desktop does not publish portable assets for ${platform}/${arch}.`);
+    }
+    return { platform: "linux", arch: "x64", extension: ".AppImage" };
+  }
+  throw new Error(`Rudder Desktop does not publish portable assets for ${platform}.`);
+}
+function resolveDefaultDesktopInstallRoot(target, env = process.env, homeDir = homedir()) {
+  if (target.platform === "macos") return path10.join(homeDir, "Applications");
+  if (target.platform === "windows") {
+    const localAppData = env.LOCALAPPDATA?.trim() || path10.join(homeDir, "AppData", "Local");
+    return path10.join(localAppData, "Programs", DESKTOP_APP_NAME);
+  }
+  return path10.join(homeDir, ".local", "share", "rudder");
+}
+function resolveDesktopInstallPaths(target, installRoot) {
+  const root = path10.resolve(installRoot);
+  if (target.platform === "macos") {
+    const appPath2 = path10.join(root, `${DESKTOP_APP_NAME}.app`);
+    return {
+      installRoot: root,
+      appPath: appPath2,
+      executablePath: path10.join(appPath2, "Contents", "MacOS", DESKTOP_APP_NAME),
+      metadataPath: path10.join(root, DESKTOP_METADATA_FILE)
+    };
+  }
+  if (target.platform === "windows") {
+    return {
+      installRoot: root,
+      appPath: root,
+      executablePath: path10.join(root, `${DESKTOP_APP_NAME}.exe`),
+      metadataPath: path10.join(root, DESKTOP_METADATA_FILE)
+    };
+  }
+  const appPath = path10.join(root, `${DESKTOP_APP_NAME}.AppImage`);
+  return {
+    installRoot: root,
+    appPath,
+    executablePath: appPath,
+    metadataPath: path10.join(root, DESKTOP_METADATA_FILE)
+  };
 }
 function normalizeAssetName(name) {
   return name.toLowerCase().replaceAll("_", "-").replaceAll(" ", "-");
@@ -9979,6 +10301,7 @@ function scoreDesktopAsset(asset, target) {
   let score = 1;
   if (normalized.includes("rudder")) score += 2;
   if (normalized.includes(target.platform)) score += 4;
+  if (normalized.includes("portable")) score += 6;
   if (target.platform === "macos" && (normalized.includes("macos") || normalized.includes("darwin") || normalized.includes("mac-"))) {
     score += 4;
   }
@@ -10002,7 +10325,7 @@ function selectDesktopAsset(assets2, target) {
   return exactArch?.asset ?? best.asset;
 }
 function selectChecksumAsset(assets2) {
-  return assets2.find((asset) => /^SHASUMS256\.txt$/i.test(asset.name)) ?? null;
+  return assets2.find((asset) => asset.name.toLowerCase() === DESKTOP_CHECKSUM_ASSET_NAME.toLowerCase()) ?? null;
 }
 function githubApiHeaders() {
   return {
@@ -10018,21 +10341,70 @@ async function fetchGithubRelease(repo, tag) {
   }
   return await response.json();
 }
-async function downloadAsset(asset, outputDir) {
+function resolveDesktopReleaseVersion(tag) {
+  if (!tag || tag === "latest") return null;
+  const name = tag.split("/").pop() ?? tag;
+  if (!name.startsWith("v")) return null;
+  const version = name.slice(1);
+  if (STABLE_SEMVER_RE.test(version) || CANARY_SEMVER_RE.test(version)) return version;
+  return null;
+}
+function resolveDesktopAssetName(version, target) {
+  if (target.platform === "macos") return `${DESKTOP_APP_NAME}-${version}-macos-${target.arch}-portable.zip`;
+  if (target.platform === "windows") return `${DESKTOP_APP_NAME}-${version}-windows-x64-portable.zip`;
+  return `${DESKTOP_APP_NAME}-${version}-linux-x64.AppImage`;
+}
+function encodeReleaseTagForDownloadUrl(tag) {
+  return tag.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+}
+function buildGithubReleaseAssetDownloadUrl(repo, tag, assetName) {
+  const encodedTag = encodeReleaseTagForDownloadUrl(tag);
+  return `https://github.com/${repo}/releases/download/${encodedTag}/${encodeURIComponent(assetName)}`;
+}
+function buildGithubReleaseAsset(repo, tag, assetName) {
+  return {
+    name: assetName,
+    browser_download_url: buildGithubReleaseAssetDownloadUrl(repo, tag, assetName)
+  };
+}
+function contentLengthFromHeaders(headers) {
+  const raw = headers.get("content-length");
+  if (!raw) return null;
+  const value = Number(raw);
+  return Number.isFinite(value) && value > 0 ? value : null;
+}
+async function downloadAsset(asset, outputDir, progressFactory = createByteProgress) {
   mkdirSync2(outputDir, { recursive: true });
-  const outputPath = path9.join(outputDir, path9.basename(asset.name));
+  const outputPath = path10.join(outputDir, path10.basename(asset.name));
   const response = await fetch(asset.browser_download_url, {
     headers: { "User-Agent": "rudder-cli-installer" }
   });
   if (!response.ok || !response.body) {
-    throw new Error(`Failed to download ${asset.name} (${response.status}).`);
+    throw new Error(`Failed to download ${asset.name} from ${asset.browser_download_url} (${response.status}).`);
+  }
+  const totalBytes = contentLengthFromHeaders(response.headers);
+  const progress = progressFactory(`Downloading ${asset.name}`);
+  let receivedBytes = 0;
+  const monitor = new Transform({
+    transform(chunk, _encoding, callback) {
+      receivedBytes += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
+      progress.update(receivedBytes, totalBytes);
+      callback(null, chunk);
+    }
+  });
+  progress.start(totalBytes);
+  try {
+    await pipeline(Readable.fromWeb(response.body), monitor, createWriteStream(outputPath));
+    progress.finish(receivedBytes, totalBytes);
+  } catch (error) {
+    progress.fail();
+    throw error;
   }
-  await pipeline(Readable.fromWeb(response.body), createWriteStream(outputPath));
   return outputPath;
 }
 function checksumForFile(filePath) {
   const hash = createHash3("sha256");
-  hash.update(readFileSync(filePath));
+  hash.update(readFileSync2(filePath));
   return hash.digest("hex");
 }
 function parseChecksumFile(contents) {
@@ -10044,28 +10416,299 @@ function parseChecksumFile(contents) {
   }
   return checksums;
 }
-async function verifyChecksum(installerPath, checksumAsset, outputDir) {
-  if (!checksumAsset) return false;
-  const checksumPath = await downloadAsset(checksumAsset, outputDir);
-  const checksums = parseChecksumFile(readFileSync(checksumPath, "utf8"));
-  const expected = checksums.get(path9.basename(installerPath));
-  if (!expected) return false;
-  const actual = checksumForFile(installerPath);
-  if (actual !== expected) {
-    throw new Error(`Checksum mismatch for ${path9.basename(installerPath)}.`);
+function resolveAssetChecksum(checksums, assetName) {
+  const expected = checksums.get(path10.basename(assetName));
+  if (!expected) {
+    throw new Error(`Desktop release checksums do not include ${path10.basename(assetName)}.`);
   }
-  return true;
+  return expected;
+}
+function assertChecksumMatch(filePath, expected) {
+  const actual = checksumForFile(filePath);
+  if (actual !== expected.toLowerCase()) {
+    throw new Error(`Checksum mismatch for ${path10.basename(filePath)}.`);
+  }
+  return actual;
+}
+async function downloadChecksums(checksumAsset, outputDir, progressFactory = createByteProgress) {
+  if (!checksumAsset) {
+    throw new Error("Desktop release is missing SHASUMS256.txt.");
+  }
+  const checksumPath = await downloadAsset(checksumAsset, outputDir, progressFactory);
+  return parseChecksumFile(readFileSync2(checksumPath, "utf8"));
+}
+async function pathExists(targetPath) {
+  try {
+    await access(targetPath, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function runChecked(command, args, options = {}) {
+  const result = spawnSync2(command, args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    ...options
+  });
+  if (result.status === 0) return;
+  const output = [result.stdout, result.stderr].filter((value) => typeof value === "string" && value.trim().length > 0).join("\n").trim();
+  throw new Error(`${command} ${args.join(" ")} failed${output ? `: ${output}` : ""}`);
+}
+function powershellQuote(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+async function extractZip(zipPath, outputDir, target) {
+  await rm(outputDir, { recursive: true, force: true });
+  await mkdir(outputDir, { recursive: true });
+  if (target.platform === "macos") {
+    runChecked("ditto", ["-x", "-k", zipPath, outputDir]);
+    return;
+  }
+  if (target.platform === "windows") {
+    runChecked("powershell.exe", [
+      "-NoProfile",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-Command",
+      `Expand-Archive -LiteralPath ${powershellQuote(zipPath)} -DestinationPath ${powershellQuote(outputDir)} -Force`
+    ]);
+    return;
+  }
+  throw new Error(`Zip assets are not supported for ${target.platform}.`);
+}
+async function findPath(root, predicate, maxDepth = 5) {
+  async function visit(dir, depth) {
+    const entries = await readdir2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path10.join(dir, entry.name);
+      if (predicate(fullPath, entry.isDirectory())) return fullPath;
+      if (entry.isDirectory() && depth < maxDepth) {
+        const nested = await visit(fullPath, depth + 1);
+        if (nested) return nested;
+      }
+    }
+    return null;
+  }
+  return await visit(root, 0);
 }
-function openInstaller(installerPath, target) {
+async function findMacApp(extractDir) {
+  const direct = path10.join(extractDir, `${DESKTOP_APP_NAME}.app`);
+  if (await pathExists(direct)) return direct;
+  const found = await findPath(extractDir, (filePath, isDirectory) => isDirectory && path10.basename(filePath) === `${DESKTOP_APP_NAME}.app`);
+  if (!found) throw new Error(`Portable macOS archive did not contain ${DESKTOP_APP_NAME}.app.`);
+  return found;
+}
+async function findWindowsAppDir(extractDir) {
+  const direct = path10.join(extractDir, `${DESKTOP_APP_NAME}.exe`);
+  if (await pathExists(direct)) return extractDir;
+  const executable = await findPath(extractDir, (filePath, isDirectory) => !isDirectory && path10.basename(filePath).toLowerCase() === `${DESKTOP_APP_NAME.toLowerCase()}.exe`);
+  if (!executable) throw new Error(`Portable Windows archive did not contain ${DESKTOP_APP_NAME}.exe.`);
+  return path10.dirname(executable);
+}
+async function readInstallMetadata(metadataPath) {
+  try {
+    const parsed = JSON.parse(await readFile3(metadataPath, "utf8"));
+    if (parsed.version !== 1) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function isInstalledDesktopCurrent(metadata, releaseTag, assetName, assetChecksum) {
+  return Boolean(
+    metadata && metadata.releaseTag === releaseTag && metadata.assetName === assetName && metadata.assetChecksum === assetChecksum
+  );
+}
+function buildForceQuitCommand(target) {
+  if (target.platform === "windows") return { command: "taskkill.exe", args: ["/IM", `${DESKTOP_APP_NAME}.exe`, "/T", "/F"] };
+  return { command: "pkill", args: ["-x", DESKTOP_APP_NAME] };
+}
+function forceQuitDesktopProcesses(target) {
+  const command = buildForceQuitCommand(target);
+  spawnSync2(command.command, command.args, { stdio: "ignore" });
+}
+function isRunningInsideDesktopExecutable() {
+  return path10.basename(process.execPath).toLowerCase().startsWith(DESKTOP_APP_NAME.toLowerCase());
+}
+async function waitForUpdateQuitResponse(responsePath, timeoutMs = 8e3) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (await pathExists(responsePath)) {
+      return JSON.parse(await readFile3(responsePath, "utf8"));
+    }
+    await delay(200);
+  }
+  return null;
+}
+async function requestDesktopQuit(executablePath, target) {
+  if (!await pathExists(executablePath)) return { ok: true, status: "not_running" };
+  const responsePath = path10.join(tmpdir(), `rudder-update-quit-${process.pid}-${Date.now()}.json`);
+  const result = spawnSync2(executablePath, [`${DESKTOP_UPDATE_QUIT_ARG}=${responsePath}`], {
+    stdio: "ignore",
+    timeout: 5e3
+  });
+  if (result.error && target.platform === "windows") {
+    return null;
+  }
+  try {
+    return await waitForUpdateQuitResponse(responsePath);
+  } finally {
+    await rm(responsePath, { force: true });
+  }
+}
+async function removePathWithRetry(targetPath, attempts = 5) {
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    try {
+      await rm(targetPath, { recursive: true, force: true });
+      if (!await pathExists(targetPath)) return true;
+    } catch {
+    }
+    await delay(500);
+  }
+  return false;
+}
+async function prepareForDesktopReplace(paths, target) {
+  const hasManagedExecutable = await pathExists(paths.executablePath);
+  if (hasManagedExecutable) {
+    const quitResponse = await requestDesktopQuit(paths.executablePath, target);
+    if (quitResponse && !quitResponse.ok && quitResponse.status === "active_runs") {
+      throw new Error(
+        `Rudder Desktop has ${quitResponse.totalRuns} active run${quitResponse.totalRuns === 1 ? "" : "s"}. Stop active work, then rerun start.`
+      );
+    }
+    await delay(1e3);
+  } else if (!isRunningInsideDesktopExecutable()) {
+    forceQuitDesktopProcesses(target);
+  }
+  const replacePath = target.platform === "windows" ? paths.installRoot : paths.appPath;
+  if (await removePathWithRetry(replacePath)) return;
+  forceQuitDesktopProcesses(target);
+  await delay(1e3);
+  if (await removePathWithRetry(replacePath, 6)) return;
+  throw new Error(`Failed to replace existing Rudder Desktop at ${replacePath}. Close Rudder and rerun start.`);
+}
+async function installPortableDesktop(installerPath, paths, target) {
+  await mkdir(paths.installRoot, { recursive: true });
+  if (target.platform === "linux") {
+    await copyFile(installerPath, paths.appPath);
+    await chmod(paths.appPath, 493);
+    return;
+  }
+  const extractDir = await mkdtemp(path10.join(tmpdir(), "rudder-desktop-extract."));
+  try {
+    await extractZip(installerPath, extractDir, target);
+    if (target.platform === "macos") {
+      const appSource2 = await findMacApp(extractDir);
+      await copyPortableAppBundle(appSource2, paths.appPath);
+      return;
+    }
+    const appSource = await findWindowsAppDir(extractDir);
+    await mkdir(path10.dirname(paths.installRoot), { recursive: true });
+    await copyPortableAppBundle(appSource, paths.installRoot);
+  } finally {
+    await rm(extractDir, { recursive: true, force: true });
+  }
+}
+async function copyPortableAppBundle(sourcePath, destinationPath) {
+  await cp(sourcePath, destinationPath, { recursive: true, verbatimSymlinks: true });
+}
+async function removeMacQuarantine(paths, target) {
+  if (target.platform !== "macos") return;
+  const result = spawnSync2("xattr", ["-dr", "com.apple.quarantine", paths.appPath], { stdio: "ignore" });
+  if (result.status !== 0) {
+    p13.log.warn(`Could not remove macOS quarantine attributes from ${paths.appPath}.`);
+  }
+}
+function quoteDesktopExec(value) {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+function buildLinuxDesktopEntry(executablePath) {
+  return [
+    "[Desktop Entry]",
+    "Type=Application",
+    "Name=Rudder",
+    `Exec=${quoteDesktopExec(executablePath)}`,
+    "Terminal=false",
+    "Categories=Development;",
+    ""
+  ].join("\n");
+}
+async function writeLinuxLaunchers(paths) {
+  const desktopDir = path10.join(homedir(), ".local", "share", "applications");
+  await mkdir(desktopDir, { recursive: true });
+  await writeFile2(path10.join(desktopDir, "rudder.desktop"), buildLinuxDesktopEntry(paths.executablePath), "utf8");
+  const binDir = path10.join(homedir(), ".local", "bin");
+  await mkdir(binDir, { recursive: true });
+  const wrapperPath = path10.join(binDir, "rudder-desktop");
+  const escaped = paths.executablePath.replaceAll("'", `'"'"'`);
+  await writeFile2(wrapperPath, `#!/bin/sh
+exec '${escaped}' "$@"
+`, "utf8");
+  await chmod(wrapperPath, 493);
+}
+function buildWindowsShortcutScript(executablePath) {
+  const appData = process.env.APPDATA?.trim() || path10.join(homedir(), "AppData", "Roaming");
+  const shortcutPath = path10.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Rudder.lnk");
+  return [
+    "$shell = New-Object -ComObject WScript.Shell",
+    `$shortcut = $shell.CreateShortcut(${powershellQuote(shortcutPath)})`,
+    `$shortcut.TargetPath = ${powershellQuote(executablePath)}`,
+    `$shortcut.WorkingDirectory = ${powershellQuote(path10.dirname(executablePath))}`,
+    "$shortcut.Save()"
+  ].join("; ");
+}
+async function createPlatformLaunchers(paths, target) {
+  if (target.platform === "linux") {
+    await writeLinuxLaunchers(paths);
+    return;
+  }
+  if (target.platform === "windows") {
+    const result = spawnSync2("powershell.exe", [
+      "-NoProfile",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-Command",
+      buildWindowsShortcutScript(paths.executablePath)
+    ], { stdio: "ignore" });
+    if (result.status !== 0) p13.log.warn("Could not create the Windows Start Menu shortcut.");
+  }
+}
+function launchDesktop(paths, target) {
   if (target.platform === "macos") {
-    spawnSync2("open", [installerPath], { stdio: "inherit" });
+    spawn("open", [paths.appPath], { detached: true, stdio: "ignore" }).unref();
     return;
   }
   if (target.platform === "windows") {
-    spawnSync2("cmd.exe", ["/c", "start", "", installerPath], { stdio: "inherit" });
+    spawn("cmd.exe", ["/c", "start", "", paths.executablePath], { detached: true, stdio: "ignore" }).unref();
     return;
   }
-  spawnSync2("xdg-open", [installerPath], { stdio: "inherit" });
+  spawn(paths.executablePath, [], { detached: true, stdio: "ignore" }).unref();
+}
+async function writeInstallMetadata(paths, releaseTag, assetName, assetChecksum) {
+  mkdirSync2(path10.dirname(paths.metadataPath), { recursive: true });
+  const metadata = {
+    version: 1,
+    releaseTag,
+    assetName,
+    assetChecksum,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  mkdirSync2(paths.installRoot, { recursive: true });
+  await writeFile2(paths.metadataPath, `${JSON.stringify(metadata, null, 2)}
+`, "utf8");
+}
+async function runStartPhase(message, successMessage, task) {
+  const spinner5 = p13.spinner();
+  spinner5.start(message);
+  try {
+    const result = await task();
+    spinner5.stop(successMessage);
+    return result;
+  } catch (error) {
+    spinner5.stop(pc8.red(`${message} failed.`));
+    throw error;
+  }
 }
 async function startCommand(opts) {
   const installCli = opts.cli !== false;
@@ -10084,48 +10727,108 @@ async function startCommand(opts) {
   if (installCli) {
     const installSpec = resolveCliInstallSpec(version);
     const command = `npm install --global ${installSpec}`;
+    const installedVersion = getGlobalInstalledPackageVersion(CLI_NPM_PACKAGE_NAME);
     p13.log.step("Preparing persistent CLI");
-    if (dryRun) {
+    if (isPersistentCliVersionCurrent(version, installedVersion)) {
+      p13.log.success(`${pc8.cyan("rudder")} CLI ${version} is already installed.`);
+    } else if (dryRun) {
       p13.log.message(`[dry-run] ${command}`);
     } else {
       p13.log.message(pc8.dim(`Running: ${command}`));
-      const result = installPersistentCli({ installSpec });
+      const spinner5 = p13.spinner();
+      spinner5.start("Installing persistent CLI...");
+      let result;
+      try {
+        result = installPersistentCli({ installSpec });
+      } catch (error) {
+        spinner5.stop(pc8.red("Persistent CLI installation failed."));
+        throw error;
+      }
       if (!result.ok) {
+        spinner5.stop(pc8.red("Persistent CLI installation failed."));
         if (result.output) p13.log.message(pc8.dim(result.output));
         throw new Error(`Persistent CLI installation failed. Re-run manually: ${result.command}`);
       }
-      p13.log.success(`${pc8.cyan("rudder")} CLI installed.`);
+      spinner5.stop(`${pc8.cyan("rudder")} CLI installed.`);
     }
   }
   if (installDesktop) {
     const target = resolveDesktopAssetTarget();
     const tag = resolveDesktopReleaseTag(version);
-    const outputDir = opts.outputDir ? path9.resolve(opts.outputDir) : await mkdtemp(path9.join(tmpdir(), "rudder-desktop-installer."));
-    p13.log.step("Starting desktop app");
+    const installRoot = opts.desktopInstallDir ? path10.resolve(opts.desktopInstallDir) : resolveDefaultDesktopInstallRoot(target);
+    const installPaths = resolveDesktopInstallPaths(target, installRoot);
+    const outputDir = opts.outputDir ? path10.resolve(opts.outputDir) : await mkdtemp(path10.join(tmpdir(), "rudder-desktop-installer."));
+    p13.log.step("Installing desktop app");
     p13.log.message(`Release: ${pc8.cyan(`${repo}@${tag}`)}`);
     p13.log.message(`Target: ${pc8.cyan(`${target.platform}/${target.arch}`)}`);
+    p13.log.message(`Install: ${pc8.cyan(installPaths.appPath)}`);
     if (dryRun) {
-      p13.log.message(`[dry-run] Would resolve and download/open the matching desktop installer to ${outputDir}`);
+      p13.log.message(`[dry-run] Would resolve, download, verify, install, and ${opts.open === false ? "not launch" : "launch"} Rudder Desktop.`);
       p13.outro(pc8.green("Dry run complete."));
       return;
     }
-    const release = await fetchGithubRelease(repo, tag);
-    const asset = selectDesktopAsset(release.assets ?? [], target);
-    if (!asset) {
-      throw new Error(`No Rudder Desktop installer found for ${target.platform}/${target.arch} in ${repo}@${release.tag_name}.`);
+    const directReleaseVersion = resolveDesktopReleaseVersion(tag);
+    const progressFactory = createByteProgress;
+    const release = directReleaseVersion ? null : await runStartPhase(
+      "Resolving Desktop release...",
+      "Desktop release resolved.",
+      () => fetchGithubRelease(repo, tag)
+    );
+    const releaseTag = directReleaseVersion ? tag : release?.tag_name;
+    if (!releaseTag) {
+      throw new Error(`Unable to resolve Rudder Desktop release tag for ${repo}@${tag}.`);
     }
-    const installerPath = await downloadAsset(asset, outputDir);
-    const checksumVerified = await verifyChecksum(installerPath, selectChecksumAsset(release.assets ?? []), outputDir);
-    if (target.platform === "linux") {
-      await chmod(installerPath, 493);
+    const asset = directReleaseVersion ? buildGithubReleaseAsset(repo, tag, resolveDesktopAssetName(directReleaseVersion, target)) : selectDesktopAsset(release?.assets ?? [], target);
+    if (!asset) {
+      throw new Error(`No Rudder Desktop portable asset found for ${target.platform}/${target.arch} in ${repo}@${releaseTag}.`);
+    }
+    const checksumAsset = directReleaseVersion ? buildGithubReleaseAsset(repo, tag, DESKTOP_CHECKSUM_ASSET_NAME) : selectChecksumAsset(release?.assets ?? []);
+    const checksums = await downloadChecksums(checksumAsset, outputDir, progressFactory);
+    const expectedChecksum = resolveAssetChecksum(checksums, asset.name);
+    const metadata = await readInstallMetadata(installPaths.metadataPath);
+    if (isInstalledDesktopCurrent(metadata, releaseTag, asset.name, expectedChecksum) && await pathExists(installPaths.executablePath)) {
+      p13.log.success(`Rudder Desktop is already installed at ${pc8.cyan(installPaths.appPath)}.`);
+      await runStartPhase(
+        "Refreshing Desktop launchers...",
+        "Desktop launchers ready.",
+        async () => {
+          await removeMacQuarantine(installPaths, target);
+          await createPlatformLaunchers(installPaths, target);
+        }
+      );
+    } else {
+      const installerPath = await downloadAsset(asset, outputDir, progressFactory);
+      const checksum = await runStartPhase(
+        "Verifying Desktop checksum...",
+        `Verified ${pc8.cyan(path10.basename(installerPath))}.`,
+        () => assertChecksumMatch(installerPath, expectedChecksum)
+      );
+      await runStartPhase(
+        "Replacing existing Rudder Desktop if needed...",
+        "Existing Desktop install is ready for replacement.",
+        () => prepareForDesktopReplace(installPaths, target)
+      );
+      await runStartPhase(
+        "Installing portable Desktop app...",
+        `Installed Rudder Desktop to ${pc8.cyan(installPaths.appPath)}.`,
+        () => installPortableDesktop(installerPath, installPaths, target)
+      );
+      await runStartPhase(
+        "Preparing Desktop launchers...",
+        "Desktop launchers ready.",
+        async () => {
+          await removeMacQuarantine(installPaths, target);
+          await createPlatformLaunchers(installPaths, target);
+        }
+      );
+      await writeInstallMetadata(installPaths, releaseTag, asset.name, checksum);
     }
-    p13.log.success(`Downloaded ${pc8.cyan(path9.basename(installerPath))}`);
-    if (checksumVerified) p13.log.success("Verified SHA-256 checksum.");
     if (opts.open !== false) {
-      openInstaller(installerPath, target);
-      p13.log.message(`Installer path: ${pc8.cyan(installerPath)}`);
-    } else {
-      p13.log.message(`Installer path: ${pc8.cyan(installerPath)}`);
+      await runStartPhase(
+        "Launching Rudder Desktop...",
+        "Rudder Desktop launched.",
+        () => launchDesktop(installPaths, target)
+      );
     }
   }
   p13.outro(pc8.green("Rudder start complete."));
@@ -10167,7 +10870,7 @@ async function addAllowedHostname(host, opts) {
 }
 
 // src/commands/heartbeat-run.ts
-import { setTimeout as delay } from "node:timers/promises";
+import { setTimeout as delay2 } from "node:timers/promises";
 import pc19 from "picocolors";
 
 // ../packages/agent-runtimes/claude-local/src/cli/format-event.ts
@@ -10343,8 +11046,8 @@ function printItemCompleted(item) {
     const changes = Array.isArray(item.changes) ? item.changes : [];
     const entries = changes.map((changeRaw) => asRecord(changeRaw)).filter((change) => Boolean(change)).map((change) => {
       const kind = asString(change.kind, "update");
-      const path22 = asString(change.path, "unknown");
-      return `${kind} ${path22}`;
+      const path23 = asString(change.path, "unknown");
+      return `${kind} ${path23}`;
     });
     const preview = entries.length > 0 ? entries.slice(0, 6).join(", ") : "none";
     const more = entries.length > 6 ? ` (+${entries.length - 6} more)` : "";
@@ -11160,9 +11863,9 @@ function getCLIAdapter(type) {
 import pc18 from "picocolors";
 
 // src/client/board-auth.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import fs10 from "node:fs";
-import path10 from "node:path";
+import path11 from "node:path";
 import pc17 from "picocolors";
 
 // src/client/command-label.ts
@@ -11186,8 +11889,8 @@ function normalizeApiBase(apiBase) {
   return apiBase.trim().replace(/\/+$/, "");
 }
 function resolveBoardAuthStorePath(overridePath) {
-  if (overridePath?.trim()) return path10.resolve(overridePath.trim());
-  if (process.env.RUDDER_AUTH_STORE?.trim()) return path10.resolve(process.env.RUDDER_AUTH_STORE.trim());
+  if (overridePath?.trim()) return path11.resolve(overridePath.trim());
+  if (process.env.RUDDER_AUTH_STORE?.trim()) return path11.resolve(process.env.RUDDER_AUTH_STORE.trim());
   return resolveDefaultCliAuthPath();
 }
 function readBoardAuthStore(storePath) {
@@ -11219,7 +11922,7 @@ function readBoardAuthStore(storePath) {
 }
 function writeBoardAuthStore(store, storePath) {
   const filePath = resolveBoardAuthStorePath(storePath);
-  fs10.mkdirSync(path10.dirname(filePath), { recursive: true });
+  fs10.mkdirSync(path11.dirname(filePath), { recursive: true });
   fs10.writeFileSync(filePath, `${JSON.stringify(store, null, 2)}
 `, { mode: 384 });
 }
@@ -11277,16 +11980,16 @@ function openUrl(url) {
   const platform = process.platform;
   try {
     if (platform === "darwin") {
-      const child2 = spawn("open", [url], { detached: true, stdio: "ignore" });
+      const child2 = spawn2("open", [url], { detached: true, stdio: "ignore" });
       child2.unref();
       return true;
     }
     if (platform === "win32") {
-      const child2 = spawn("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" });
+      const child2 = spawn2("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" });
       child2.unref();
       return true;
     }
-    const child = spawn("xdg-open", [url], { detached: true, stdio: "ignore" });
+    const child = spawn2("xdg-open", [url], { detached: true, stdio: "ignore" });
     child.unref();
     return true;
   } catch {
@@ -11370,26 +12073,26 @@ init_store();
 // src/client/context.ts
 init_home();
 import fs11 from "node:fs";
-import path11 from "node:path";
+import path12 from "node:path";
 var DEFAULT_CONTEXT_BASENAME = "context.json";
 var DEFAULT_PROFILE = "default";
 function findContextFileFromAncestors(startDir) {
-  const absoluteStartDir = path11.resolve(startDir);
+  const absoluteStartDir = path12.resolve(startDir);
   let currentDir = absoluteStartDir;
   while (true) {
-    const candidate = path11.resolve(currentDir, ".rudder", DEFAULT_CONTEXT_BASENAME);
+    const candidate = path12.resolve(currentDir, ".rudder", DEFAULT_CONTEXT_BASENAME);
     if (fs11.existsSync(candidate)) {
       return candidate;
     }
-    const nextDir = path11.resolve(currentDir, "..");
+    const nextDir = path12.resolve(currentDir, "..");
     if (nextDir === currentDir) break;
     currentDir = nextDir;
   }
   return null;
 }
 function resolveContextPath(overridePath) {
-  if (overridePath) return path11.resolve(overridePath);
-  if (process.env.RUDDER_CONTEXT) return path11.resolve(process.env.RUDDER_CONTEXT);
+  if (overridePath) return path12.resolve(overridePath);
+  if (process.env.RUDDER_CONTEXT) return path12.resolve(process.env.RUDDER_CONTEXT);
   return findContextFileFromAncestors(process.cwd()) ?? resolveDefaultContextPath();
 }
 function defaultClientContext() {
@@ -11457,7 +12160,7 @@ function readContext(contextPath) {
 }
 function writeContext(context, contextPath) {
   const filePath = resolveContextPath(contextPath);
-  const dir = path11.dirname(filePath);
+  const dir = path12.dirname(filePath);
   fs11.mkdirSync(dir, { recursive: true });
   const normalized = normalizeContext(context);
   fs11.writeFileSync(filePath, `${JSON.stringify(normalized, null, 2)}
@@ -11525,35 +12228,35 @@ var RudderApiClient = class {
     this.runId = opts.runId?.trim() || void 0;
     this.recoverAuth = opts.recoverAuth;
   }
-  get(path22, opts) {
-    return this.request(path22, { method: "GET" }, opts);
+  get(path23, opts) {
+    return this.request(path23, { method: "GET" }, opts);
   }
-  post(path22, body, opts) {
-    return this.request(path22, {
+  post(path23, body, opts) {
+    return this.request(path23, {
       method: "POST",
       body: body === void 0 ? void 0 : JSON.stringify(body)
     }, opts);
   }
-  patch(path22, body, opts) {
-    return this.request(path22, {
+  patch(path23, body, opts) {
+    return this.request(path23, {
       method: "PATCH",
       body: body === void 0 ? void 0 : JSON.stringify(body)
     }, opts);
   }
-  put(path22, body, opts) {
-    return this.request(path22, {
+  put(path23, body, opts) {
+    return this.request(path23, {
       method: "PUT",
       body: body === void 0 ? void 0 : JSON.stringify(body)
     }, opts);
   }
-  delete(path22, opts) {
-    return this.request(path22, { method: "DELETE" }, opts);
+  delete(path23, opts) {
+    return this.request(path23, { method: "DELETE" }, opts);
   }
   setApiKey(apiKey) {
     this.apiKey = apiKey?.trim() || void 0;
   }
-  async request(path22, init, opts, hasRetriedAuth = false) {
-    const url = buildUrl(this.apiBase, path22);
+  async request(path23, init, opts, hasRetriedAuth = false) {
+    const url = buildUrl(this.apiBase, path23);
     const headers = {
       accept: "application/json",
       ...toStringRecord(init.headers)
@@ -11578,13 +12281,13 @@ var RudderApiClient = class {
       const apiError = await toApiError(response);
       if (!hasRetriedAuth && this.recoverAuth) {
         const recoveredToken = await this.recoverAuth({
-          path: path22,
+          path: path23,
           method: String(init.method ?? "GET").toUpperCase(),
           error: apiError
         });
         if (recoveredToken) {
           this.setApiKey(recoveredToken);
-          return this.request(path22, init, opts, true);
+          return this.request(path23, init, opts, true);
         }
       }
       throw apiError;
@@ -11603,8 +12306,8 @@ function shouldAttachRunId(method) {
   const normalized = String(method ?? "GET").toUpperCase();
   return normalized !== "GET" && normalized !== "HEAD";
 }
-function buildUrl(apiBase, path22) {
-  const normalizedPath = path22.startsWith("/") ? path22 : `/${path22}`;
+function buildUrl(apiBase, path23) {
+  const normalizedPath = path23.startsWith("/") ? path23 : `/${path23}`;
   const [pathname, query] = normalizedPath.split("?");
   const url = new URL2(apiBase);
   url.pathname = `${url.pathname.replace(/\/+$/, "")}${pathname}`;
@@ -12015,7 +12718,7 @@ async function heartbeatRun(opts) {
         logOffset += Buffer.byteLength(logResult.content, "utf8");
       }
     }
-    await delay(POLL_INTERVAL_MS);
+    await delay2(POLL_INTERVAL_MS);
   }
   if (finalStatus) {
     if (!debug && stdoutJsonBuffer.trim()) {
@@ -12087,7 +12790,7 @@ init_src2();
 init_home();
 init_store();
 init_banner();
-import path12 from "node:path";
+import path13 from "node:path";
 import * as p15 from "@clack/prompts";
 import pc20 from "picocolors";
 function resolveConnectionString(configPath) {
@@ -12111,7 +12814,7 @@ function normalizeRetentionDays(value, fallback) {
   return candidate;
 }
 function resolveBackupDir(raw) {
-  return path12.resolve(expandHomePrefix(raw.trim()));
+  return path13.resolve(expandHomePrefix(raw.trim()));
 }
 async function dbBackupCommand(opts) {
   printRudderCliBanner();
@@ -12131,8 +12834,8 @@ async function dbBackupCommand(opts) {
   p15.log.message(pc20.dim(`Connection source: ${connection.source}`));
   p15.log.message(pc20.dim(`Backup dir: ${backupDir}`));
   p15.log.message(pc20.dim(`Retention: ${retentionDays} day(s)`));
-  const spinner4 = p15.spinner();
-  spinner4.start("Creating database backup...");
+  const spinner5 = p15.spinner();
+  spinner5.start("Creating database backup...");
   try {
     const result = await runDatabaseBackup({
       connectionString: connection.value,
@@ -12140,7 +12843,7 @@ async function dbBackupCommand(opts) {
       retentionDays,
       filenamePrefix
     });
-    spinner4.stop(`Backup saved: ${formatDatabaseBackupResult(result)}`);
+    spinner5.stop(`Backup saved: ${formatDatabaseBackupResult(result)}`);
     if (opts.json) {
       console.log(
         JSON.stringify(
@@ -12159,7 +12862,7 @@ async function dbBackupCommand(opts) {
     }
     p15.outro(pc20.green("Backup completed."));
   } catch (err) {
-    spinner4.stop(pc20.red("Backup failed."));
+    spinner5.stop(pc20.red("Backup failed."));
     throw err;
   }
 }
@@ -12230,14 +12933,14 @@ function registerContextCommands(program) {
 }
 
 // src/commands/client/company.ts
-import { mkdir, readdir as readdir2, readFile as readFile3, stat, writeFile as writeFile2 } from "node:fs/promises";
-import path14 from "node:path";
+import { mkdir as mkdir2, readdir as readdir3, readFile as readFile4, stat, writeFile as writeFile3 } from "node:fs/promises";
+import path15 from "node:path";
 import * as p16 from "@clack/prompts";
 import pc22 from "picocolors";
 
 // src/commands/client/zip.ts
 import { inflateRawSync } from "node:zlib";
-import path13 from "node:path";
+import path14 from "node:path";
 var textDecoder = new TextDecoder();
 var binaryContentTypeByExtension = {
   ".gif": "image/gif",
@@ -12264,7 +12967,7 @@ function sharedArchiveRoot(paths) {
   return firstSegments.every((parts) => parts.length > 1 && parts[0] === candidate) ? candidate : null;
 }
 function bytesToPortableFileEntry(pathValue, bytes) {
-  const contentType = binaryContentTypeByExtension[path13.extname(pathValue).toLowerCase()];
+  const contentType = binaryContentTypeByExtension[path14.extname(pathValue).toLowerCase()];
   if (!contentType) return textDecoder.decode(bytes);
   return {
     encoding: "base64",
@@ -12352,7 +13055,7 @@ var IMPORT_INCLUDE_OPTIONS = [
 ];
 var IMPORT_PREVIEW_SAMPLE_LIMIT = 6;
 function readPortableFileEntry(filePath, contents) {
-  const contentType = binaryContentTypeByExtension[path14.extname(filePath).toLowerCase()];
+  const contentType = binaryContentTypeByExtension[path15.extname(filePath).toLowerCase()];
   if (!contentType) return contents.toString("utf8");
   return {
     encoding: "base64",
@@ -12407,10 +13110,10 @@ function normalizePortablePath(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function shouldIncludePortableFile(filePath) {
-  const baseName = path14.basename(filePath);
+  const baseName = path15.basename(filePath);
   const isMarkdown = baseName.endsWith(".md");
   const isPaperclipYaml = baseName === ".rudder.yaml" || baseName === ".rudder.yml";
-  const contentType = binaryContentTypeByExtension[path14.extname(baseName).toLowerCase()];
+  const contentType = binaryContentTypeByExtension[path15.extname(baseName).toLowerCase()];
   return isMarkdown || isPaperclipYaml || Boolean(contentType);
 }
 function findPortableExtensionPath(files) {
@@ -12558,10 +13261,10 @@ function buildDefaultImportAdapterOverrides(preview) {
 }
 function buildDefaultImportAdapterMessages(overrides) {
   if (!overrides) return [];
-  const agentRuntimeTypes = Array.from(new Set(Object.values(overrides).map((override) => override.agentRuntimeType))).map((agentRuntimeType) => agentRuntimeType.replace(/_/g, "-"));
+  const agentRuntimeTypes2 = Array.from(new Set(Object.values(overrides).map((override) => override.agentRuntimeType))).map((agentRuntimeType) => agentRuntimeType.replace(/_/g, "-"));
   const agentCount = Object.keys(overrides).length;
   return [
-    `Using ${agentRuntimeTypes.join(", ")} adapter${agentRuntimeTypes.length === 1 ? "" : "s"} for ${agentCount} imported ${pluralize(agentCount, "agent")} without an explicit adapter.`
+    `Using ${agentRuntimeTypes2.join(", ")} adapter${agentRuntimeTypes2.length === 1 ? "" : "s"} for ${agentCount} imported ${pluralize(agentCount, "agent")} without an explicit adapter.`
   ];
 }
 async function promptForImportSelection(preview) {
@@ -12963,73 +13666,73 @@ function normalizeGithubImportSource(input, refOverride) {
   }
   return buildGithubImportUrl({ owner, repo, ref });
 }
-async function pathExists(inputPath) {
+async function pathExists2(inputPath) {
   try {
-    await stat(path14.resolve(inputPath));
+    await stat(path15.resolve(inputPath));
     return true;
   } catch {
     return false;
   }
 }
 async function collectPackageFiles(root, current, files) {
-  const entries = await readdir2(current, { withFileTypes: true });
+  const entries = await readdir3(current, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name.startsWith(".git")) continue;
-    const absolutePath = path14.join(current, entry.name);
+    const absolutePath = path15.join(current, entry.name);
     if (entry.isDirectory()) {
       await collectPackageFiles(root, absolutePath, files);
       continue;
     }
     if (!entry.isFile()) continue;
-    const relativePath = path14.relative(root, absolutePath).replace(/\\/g, "/");
+    const relativePath = path15.relative(root, absolutePath).replace(/\\/g, "/");
     if (!shouldIncludePortableFile(relativePath)) continue;
-    files[relativePath] = readPortableFileEntry(relativePath, await readFile3(absolutePath));
+    files[relativePath] = readPortableFileEntry(relativePath, await readFile4(absolutePath));
   }
 }
 async function resolveInlineSourceFromPath(inputPath) {
-  const resolved = path14.resolve(inputPath);
+  const resolved = path15.resolve(inputPath);
   const resolvedStat = await stat(resolved);
-  if (resolvedStat.isFile() && path14.extname(resolved).toLowerCase() === ".zip") {
-    const archive = await readZipArchive(await readFile3(resolved));
+  if (resolvedStat.isFile() && path15.extname(resolved).toLowerCase() === ".zip") {
+    const archive = await readZipArchive(await readFile4(resolved));
     const filteredFiles = Object.fromEntries(
       Object.entries(archive.files).filter(([relativePath]) => shouldIncludePortableFile(relativePath))
     );
     return {
-      rootPath: archive.rootPath ?? path14.basename(resolved, ".zip"),
+      rootPath: archive.rootPath ?? path15.basename(resolved, ".zip"),
       files: filteredFiles
     };
   }
-  const rootDir = resolvedStat.isDirectory() ? resolved : path14.dirname(resolved);
+  const rootDir = resolvedStat.isDirectory() ? resolved : path15.dirname(resolved);
   const files = {};
   await collectPackageFiles(rootDir, rootDir, files);
   return {
-    rootPath: path14.basename(rootDir),
+    rootPath: path15.basename(rootDir),
     files
   };
 }
 async function writeExportToFolder(outDir, exported) {
-  const root = path14.resolve(outDir);
-  await mkdir(root, { recursive: true });
+  const root = path15.resolve(outDir);
+  await mkdir2(root, { recursive: true });
   for (const [relativePath, content] of Object.entries(exported.files)) {
     const normalized = relativePath.replace(/\\/g, "/");
-    const filePath = path14.join(root, normalized);
-    await mkdir(path14.dirname(filePath), { recursive: true });
+    const filePath = path15.join(root, normalized);
+    await mkdir2(path15.dirname(filePath), { recursive: true });
     const writeValue = portableFileEntryToWriteValue(content);
     if (typeof writeValue === "string") {
-      await writeFile2(filePath, writeValue, "utf8");
+      await writeFile3(filePath, writeValue, "utf8");
     } else {
-      await writeFile2(filePath, writeValue);
+      await writeFile3(filePath, writeValue);
     }
   }
 }
 async function confirmOverwriteExportDirectory(outDir) {
-  const root = path14.resolve(outDir);
+  const root = path15.resolve(outDir);
   const stats = await stat(root).catch(() => null);
   if (!stats) return;
   if (!stats.isDirectory()) {
     throw new Error(`Export output path ${root} exists and is not a directory.`);
   }
-  const entries = await readdir2(root);
+  const entries = await readdir3(root);
   if (entries.length === 0) return;
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
     throw new Error(`Export output directory ${root} already contains files. Re-run interactively or choose an empty directory.`);
@@ -13173,7 +13876,7 @@ function registerCompanyCommands(program) {
         printOutput(
           {
             ok: true,
-            out: path14.resolve(opts.out),
+            out: path15.resolve(opts.out),
             rootPath: exported.rootPath,
             filesWritten: Object.keys(exported.files).length,
             rudderExtensionPath: exported.rudderExtensionPath,
@@ -13226,7 +13929,7 @@ function registerCompanyCommands(program) {
           throw new Error("Target existing organization requires --org-id (or context default orgId).");
         }
         let sourcePayload;
-        const treatAsLocalPath = !isHttpUrl(from) && await pathExists(from);
+        const treatAsLocalPath = !isHttpUrl(from) && await pathExists2(from);
         const isGithubSource = isGithubUrl(from) || isGithubShorthand(from) && !treatAsLocalPath;
         if (isHttpUrl(from) || isGithubSource) {
           if (!isGithubUrl(from) && !isGithubShorthand(from)) {
@@ -13977,8 +14680,8 @@ function registerIssueCommands(program) {
         if (opts.assigneeAgentId) params.set("assigneeAgentId", opts.assigneeAgentId);
         if (opts.projectId) params.set("projectId", opts.projectId);
         const query = params.toString();
-        const path22 = `/api/orgs/${ctx.orgId}/issues${query ? `?${query}` : ""}`;
-        const rows = await ctx.api.get(path22) ?? [];
+        const path23 = `/api/orgs/${ctx.orgId}/issues${query ? `?${query}` : ""}`;
+        const rows = await ctx.api.get(path23) ?? [];
         const filtered = filterIssueRows(rows, opts.match);
         if (ctx.json) {
           printOutput(filtered, { json: true });
@@ -14272,8 +14975,8 @@ function filterIssueRows(rows, match) {
 init_src();
 
 // ../packages/agent-runtime-utils/src/server-utils.ts
-import { constants as fsConstants, promises as fs12 } from "node:fs";
-import path15 from "node:path";
+import { constants as fsConstants2, promises as fs12 } from "node:fs";
+import path16 from "node:path";
 var MAX_CAPTURE_BYTES = 4 * 1024 * 1024;
 var MAX_EXCERPT_BYTES = 32 * 1024;
 var RUDDER_SKILL_ROOT_RELATIVE_CANDIDATES = [
@@ -14290,8 +14993,8 @@ function isMaintainerOnlySkillTarget(candidate) {
 }
 async function resolveRudderSkillsDir(moduleDir, additionalCandidates = []) {
   const candidates = [
-    ...RUDDER_SKILL_ROOT_RELATIVE_CANDIDATES.map((relativePath) => path15.resolve(moduleDir, relativePath)),
-    ...additionalCandidates.map((candidate) => path15.resolve(candidate))
+    ...RUDDER_SKILL_ROOT_RELATIVE_CANDIDATES.map((relativePath) => path16.resolve(moduleDir, relativePath)),
+    ...additionalCandidates.map((candidate) => path16.resolve(candidate))
   ];
   const seenRoots = /* @__PURE__ */ new Set();
   for (const root of candidates) {
@@ -14309,12 +15012,12 @@ async function removeMaintainerOnlySkillSymlinks(skillsHome, allowedSkillNames)
     const removed = [];
     for (const entry of entries) {
       if (allowed.has(entry.name)) continue;
-      const target = path15.join(skillsHome, entry.name);
+      const target = path16.join(skillsHome, entry.name);
       const existing = await fs12.lstat(target).catch(() => null);
       if (!existing?.isSymbolicLink()) continue;
       const linkedPath = await fs12.readlink(target).catch(() => null);
       if (!linkedPath) continue;
-      const resolvedLinkedPath = path15.isAbsolute(linkedPath) ? linkedPath : path15.resolve(path15.dirname(target), linkedPath);
+      const resolvedLinkedPath = path16.isAbsolute(linkedPath) ? linkedPath : path16.resolve(path16.dirname(target), linkedPath);
       if (!isMaintainerOnlySkillTarget(linkedPath) && !isMaintainerOnlySkillTarget(resolvedLinkedPath)) {
         continue;
       }
@@ -14330,18 +15033,18 @@ async function removeMaintainerOnlySkillSymlinks(skillsHome, allowedSkillNames)
 // src/commands/client/agent.ts
 import fs13 from "node:fs/promises";
 import os2 from "node:os";
-import path16 from "node:path";
+import path17 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
-var __moduleDir = path16.dirname(fileURLToPath4(import.meta.url));
+var __moduleDir = path17.dirname(fileURLToPath4(import.meta.url));
 function codexSkillsHome() {
   const fromEnv = process.env.CODEX_HOME?.trim();
-  const base = fromEnv && fromEnv.length > 0 ? fromEnv : path16.join(os2.homedir(), ".codex");
-  return path16.join(base, "skills");
+  const base = fromEnv && fromEnv.length > 0 ? fromEnv : path17.join(os2.homedir(), ".codex");
+  return path17.join(base, "skills");
 }
 function claudeSkillsHome() {
   const fromEnv = process.env.CLAUDE_HOME?.trim();
-  const base = fromEnv && fromEnv.length > 0 ? fromEnv : path16.join(os2.homedir(), ".claude");
-  return path16.join(base, "skills");
+  const base = fromEnv && fromEnv.length > 0 ? fromEnv : path17.join(os2.homedir(), ".claude");
+  return path17.join(base, "skills");
 }
 async function installSkillsForTarget(sourceSkillsDir, targetSkillsDir, tool) {
   const summary = {
@@ -14360,8 +15063,8 @@ async function installSkillsForTarget(sourceSkillsDir, targetSkillsDir, tool) {
   );
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const source = path16.join(sourceSkillsDir, entry.name);
-    const target = path16.join(targetSkillsDir, entry.name);
+    const source = path17.join(sourceSkillsDir, entry.name);
+    const target = path17.join(targetSkillsDir, entry.name);
     const existing = await fs13.lstat(target).catch(() => null);
     if (existing) {
       if (existing.isSymbolicLink()) {
@@ -14382,7 +15085,7 @@ async function installSkillsForTarget(sourceSkillsDir, targetSkillsDir, tool) {
             continue;
           }
         }
-        const resolvedLinkedPath = path16.isAbsolute(linkedPath) ? linkedPath : path16.resolve(path16.dirname(target), linkedPath);
+        const resolvedLinkedPath = path17.isAbsolute(linkedPath) ? linkedPath : path17.resolve(path17.dirname(target), linkedPath);
         const linkedTargetExists = await fs13.stat(resolvedLinkedPath).then(() => true).catch(() => false);
         if (!linkedTargetExists) {
           await fs13.unlink(target);
@@ -14662,7 +15365,7 @@ function registerAgentCommands(program) {
         }
         const installSummaries = [];
         if (opts.installSkills !== false) {
-          const skillsDir = await resolveRudderSkillsDir(__moduleDir, [path16.resolve(process.cwd(), "skills")]);
+          const skillsDir = await resolveRudderSkillsDir(__moduleDir, [path17.resolve(process.cwd(), "skills")]);
           if (!skillsDir) {
             throw new Error(
               "Could not locate local Rudder skills directory. Expected ./skills in the repo checkout."
@@ -14919,8 +15622,8 @@ function registerActivityCommands(program) {
         if (opts.entityType) params.set("entityType", opts.entityType);
         if (opts.entityId) params.set("entityId", opts.entityId);
         const query = params.toString();
-        const path22 = `/api/orgs/${ctx.orgId}/activity${query ? `?${query}` : ""}`;
-        const rows = await ctx.api.get(path22) ?? [];
+        const path23 = `/api/orgs/${ctx.orgId}/activity${query ? `?${query}` : ""}`;
+        const rows = await ctx.api.get(path23) ?? [];
         if (ctx.json) {
           printOutput(rows, { json: true });
           return;
@@ -15089,11 +15792,11 @@ function parseCsv4(value) {
 
 // src/config/data-dir.ts
 init_home();
-import path17 from "node:path";
+import path18 from "node:path";
 function applyDataDirOverride(options, support = {}) {
   const rawDataDir = options.dataDir?.trim();
   if (!rawDataDir) return null;
-  const resolvedDataDir = path17.resolve(expandHomePrefix(rawDataDir));
+  const resolvedDataDir = path18.resolve(expandHomePrefix(rawDataDir));
   process.env.RUDDER_HOME = resolvedDataDir;
   if (support.hasConfigOption) {
     const hasConfigOverride = Boolean(options.config?.trim()) || Boolean(process.env.RUDDER_CONFIG?.trim());
@@ -15130,7 +15833,7 @@ import {
   mkdirSync as mkdirSync3,
   promises as fsPromises,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   readlinkSync,
   rmSync,
   statSync as statSync2,
@@ -15138,7 +15841,7 @@ import {
   writeFileSync
 } from "node:fs";
 import os3 from "node:os";
-import path19 from "node:path";
+import path20 from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { createServer } from "node:net";
 import { Readable as Readable2 } from "node:stream";
@@ -15149,7 +15852,7 @@ import { and as and2, eq as eq2, inArray, sql as sql3 } from "drizzle-orm";
 // src/commands/worktree-lib.ts
 init_home();
 import { randomInt } from "node:crypto";
-import path18 from "node:path";
+import path19 from "node:path";
 var DEFAULT_WORKTREE_HOME = "~/.rudder-worktrees";
 var WORKTREE_SEED_MODES = ["minimal", "full"];
 var MINIMAL_WORKTREE_EXCLUDED_TABLES = [
@@ -15197,7 +15900,7 @@ function sanitizeWorktreeInstanceId(rawValue) {
   return normalized || "worktree";
 }
 function resolveSuggestedWorktreeName(cwd, explicitName) {
-  return nonEmpty(explicitName) ?? path18.basename(path18.resolve(cwd));
+  return nonEmpty(explicitName) ?? path19.basename(path19.resolve(cwd));
 }
 function hslComponentToHex(n) {
   return Math.round(Math.max(0, Math.min(255, n))).toString(16).padStart(2, "0");
@@ -15237,24 +15940,24 @@ function generateWorktreeColor() {
   return hslToHex(randomInt(0, 360), 68, 56);
 }
 function resolveWorktreeLocalPaths(opts) {
-  const cwd = path18.resolve(opts.cwd);
-  const homeDir = path18.resolve(expandHomePrefix(opts.homeDir ?? DEFAULT_WORKTREE_HOME));
-  const instanceRoot = path18.resolve(homeDir, "instances", opts.instanceId);
-  const repoConfigDir = path18.resolve(cwd, ".rudder");
+  const cwd = path19.resolve(opts.cwd);
+  const homeDir = path19.resolve(expandHomePrefix(opts.homeDir ?? DEFAULT_WORKTREE_HOME));
+  const instanceRoot = path19.resolve(homeDir, "instances", opts.instanceId);
+  const repoConfigDir = path19.resolve(cwd, ".rudder");
   return {
     cwd,
     repoConfigDir,
-    configPath: path18.resolve(repoConfigDir, "config.json"),
-    envPath: path18.resolve(repoConfigDir, ".env"),
+    configPath: path19.resolve(repoConfigDir, "config.json"),
+    envPath: path19.resolve(repoConfigDir, ".env"),
     homeDir,
     instanceId: opts.instanceId,
     instanceRoot,
-    contextPath: path18.resolve(homeDir, "context.json"),
-    embeddedPostgresDataDir: path18.resolve(instanceRoot, "db"),
-    backupDir: path18.resolve(instanceRoot, "data", "backups"),
-    logDir: path18.resolve(instanceRoot, "logs"),
-    secretsKeyFilePath: path18.resolve(instanceRoot, "secrets", "master.key"),
-    storageDir: path18.resolve(instanceRoot, "data", "storage")
+    contextPath: path19.resolve(homeDir, "context.json"),
+    embeddedPostgresDataDir: path19.resolve(instanceRoot, "db"),
+    backupDir: path19.resolve(instanceRoot, "data", "backups"),
+    logDir: path19.resolve(instanceRoot, "logs"),
+    secretsKeyFilePath: path19.resolve(instanceRoot, "secrets", "master.key"),
+    storageDir: path19.resolve(instanceRoot, "data", "storage")
   };
 }
 function rewriteLocalUrlPort(rawUrl, port) {
@@ -15778,7 +16481,7 @@ function isCurrentSourceConfigPath(sourceConfigPath) {
   if (!currentConfigPath || currentConfigPath.trim().length === 0) {
     return false;
   }
-  return path19.resolve(currentConfigPath) === path19.resolve(sourceConfigPath);
+  return path20.resolve(currentConfigPath) === path20.resolve(sourceConfigPath);
 }
 var WORKTREE_NAME_PREFIX = "rudder-";
 function resolveWorktreeMakeName(name) {
@@ -15816,9 +16519,9 @@ function normalizeStorageObjectKey(objectKey) {
   return parts.join("/");
 }
 function resolveLocalStoragePath(baseDir, objectKey) {
-  const resolved = path19.resolve(baseDir, normalizeStorageObjectKey(objectKey));
-  const root = path19.resolve(baseDir);
-  if (resolved !== root && !resolved.startsWith(`${root}${path19.sep}`)) {
+  const resolved = path20.resolve(baseDir, normalizeStorageObjectKey(objectKey));
+  const root = path20.resolve(baseDir);
+  if (resolved !== root && !resolved.startsWith(`${root}${path20.sep}`)) {
     throw new Error("Invalid object key path.");
   }
   return resolved;
@@ -15869,7 +16572,7 @@ function createConfiguredStorageFromRudderConfig(config) {
       async putObject(orgId, objectKey, body) {
         assertStorageCompanyPrefix(orgId, objectKey);
         const filePath = resolveLocalStoragePath(baseDir, objectKey);
-        await fsPromises.mkdir(path19.dirname(filePath), { recursive: true });
+        await fsPromises.mkdir(path20.dirname(filePath), { recursive: true });
         await fsPromises.writeFile(filePath, body);
       }
     };
@@ -15953,7 +16656,7 @@ async function readSourceAttachmentBody(sourceStorages, orgId, objectKey) {
   return null;
 }
 function resolveWorktreeMakeTargetPath(name) {
-  return path19.resolve(os3.homedir(), resolveWorktreeMakeName(name));
+  return path20.resolve(os3.homedir(), resolveWorktreeMakeName(name));
 }
 function extractExecSyncErrorMessage(error) {
   if (!error || typeof error !== "object") {
@@ -15989,7 +16692,7 @@ function resolveGitWorktreeAddArgs(input) {
 function readPidFilePort(postmasterPidFile) {
   if (!existsSync3(postmasterPidFile)) return null;
   try {
-    const lines = readFileSync2(postmasterPidFile, "utf8").split("\n");
+    const lines = readFileSync3(postmasterPidFile, "utf8").split("\n");
     const port = Number(lines[3]?.trim());
     return Number.isInteger(port) && port > 0 ? port : null;
   } catch {
@@ -15999,7 +16702,7 @@ function readPidFilePort(postmasterPidFile) {
 function readRunningPostmasterPid(postmasterPidFile) {
   if (!existsSync3(postmasterPidFile)) return null;
   try {
-    const pid = Number(readFileSync2(postmasterPidFile, "utf8").split("\n")[0]?.trim());
+    const pid = Number(readFileSync3(postmasterPidFile, "utf8").split("\n")[0]?.trim());
     if (!Number.isInteger(pid) || pid <= 0) return null;
     process.kill(pid, 0);
     return pid;
@@ -16059,10 +16762,10 @@ function detectGitWorkspaceInfo(cwd) {
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
     return {
-      root: path19.resolve(root),
-      commonDir: path19.resolve(root, commonDirRaw),
-      gitDir: path19.resolve(root, gitDirRaw),
-      hooksPath: path19.resolve(root, hooksPathRaw)
+      root: path20.resolve(root),
+      commonDir: path20.resolve(root, commonDirRaw),
+      gitDir: path20.resolve(root, gitDirRaw),
+      hooksPath: path20.resolve(root, hooksPathRaw)
     };
   } catch {
     return null;
@@ -16075,8 +16778,8 @@ function copyDirectoryContents(sourceDir, targetDir) {
   mkdirSync3(targetDir, { recursive: true });
   let copied = false;
   for (const entry of entries) {
-    const sourcePath = path19.resolve(sourceDir, entry.name);
-    const targetPath = path19.resolve(targetDir, entry.name);
+    const sourcePath = path20.resolve(sourceDir, entry.name);
+    const targetPath = path20.resolve(targetDir, entry.name);
     if (entry.isDirectory()) {
       mkdirSync3(targetPath, { recursive: true });
       copyDirectoryContents(sourcePath, targetPath);
@@ -16102,7 +16805,7 @@ function copyGitHooksToWorktreeGitDir(cwd) {
   const workspace = detectGitWorkspaceInfo(cwd);
   if (!workspace) return null;
   const sourceHooksPath = workspace.hooksPath;
-  const targetHooksPath = path19.resolve(workspace.gitDir, "hooks");
+  const targetHooksPath = path20.resolve(workspace.gitDir, "hooks");
   if (sourceHooksPath === targetHooksPath) {
     return {
       sourceHooksPath,
@@ -16117,17 +16820,17 @@ function copyGitHooksToWorktreeGitDir(cwd) {
   };
 }
 function rebindWorkspaceCwd(input) {
-  const sourceRepoRoot = path19.resolve(input.sourceRepoRoot);
-  const targetRepoRoot = path19.resolve(input.targetRepoRoot);
-  const workspaceCwd = path19.resolve(input.workspaceCwd);
-  const relative = path19.relative(sourceRepoRoot, workspaceCwd);
+  const sourceRepoRoot = path20.resolve(input.sourceRepoRoot);
+  const targetRepoRoot = path20.resolve(input.targetRepoRoot);
+  const workspaceCwd = path20.resolve(input.workspaceCwd);
+  const relative = path20.relative(sourceRepoRoot, workspaceCwd);
   if (!relative || relative === "") {
     return targetRepoRoot;
   }
-  if (relative.startsWith("..") || path19.isAbsolute(relative)) {
+  if (relative.startsWith("..") || path20.isAbsolute(relative)) {
     return null;
   }
-  return path19.resolve(targetRepoRoot, relative);
+  return path20.resolve(targetRepoRoot, relative);
 }
 async function rebindSeededProjectWorkspaces(input) {
   const targetRepo = detectGitWorkspaceInfo(input.currentCwd);
@@ -16153,7 +16856,7 @@ async function rebindSeededProjectWorkspaces(input) {
         workspaceCwd
       });
       if (!reboundCwd) continue;
-      const normalizedCurrent = path19.resolve(workspaceCwd);
+      const normalizedCurrent = path20.resolve(workspaceCwd);
       if (reboundCwd === normalizedCurrent) continue;
       if (!existsSync3(reboundCwd)) continue;
       await db.update(projectWorkspaces).set({
@@ -16172,14 +16875,14 @@ async function rebindSeededProjectWorkspaces(input) {
   }
 }
 function resolveSourceConfigPath(opts) {
-  if (opts.sourceConfigPathOverride) return path19.resolve(opts.sourceConfigPathOverride);
-  if (opts.fromConfig) return path19.resolve(opts.fromConfig);
+  if (opts.sourceConfigPathOverride) return path20.resolve(opts.sourceConfigPathOverride);
+  if (opts.fromConfig) return path20.resolve(opts.fromConfig);
   if (!opts.fromDataDir && !opts.fromInstance) {
     return resolveConfigPath();
   }
-  const sourceHome = path19.resolve(expandHomePrefix(opts.fromDataDir ?? "~/.rudder"));
+  const sourceHome = path20.resolve(expandHomePrefix(opts.fromDataDir ?? "~/.rudder"));
   const sourceInstanceId = sanitizeWorktreeInstanceId(opts.fromInstance ?? "default");
-  return path19.resolve(sourceHome, "instances", sourceInstanceId, "config.json");
+  return path20.resolve(sourceHome, "instances", sourceInstanceId, "config.json");
 }
 function resolveSourceConnectionString(config, envEntries, portOverride) {
   if (config.database.mode === "postgres") {
@@ -16198,7 +16901,7 @@ function copySeededSecretsKey(input) {
   if (input.sourceConfig.secrets.provider !== "local_encrypted") {
     return;
   }
-  mkdirSync3(path19.dirname(input.targetKeyFilePath), { recursive: true });
+  mkdirSync3(path20.dirname(input.targetKeyFilePath), { recursive: true });
   const allowProcessEnvFallback = isCurrentSourceConfigPath(input.sourceConfigPath);
   const sourceInlineMasterKey = nonEmpty2(input.sourceEnvEntries.RUDDER_SECRETS_MASTER_KEY) ?? (allowProcessEnvFallback ? nonEmpty2(process.env.RUDDER_SECRETS_MASTER_KEY) : null);
   if (sourceInlineMasterKey) {
@@ -16237,7 +16940,7 @@ async function ensureEmbeddedPostgres(dataDir, preferredPort) {
       "Embedded PostgreSQL support requires dependency `embedded-postgres`. Reinstall dependencies and try again."
     );
   }
-  const postmasterPidFile = path19.resolve(dataDir, "postmaster.pid");
+  const postmasterPidFile = path20.resolve(dataDir, "postmaster.pid");
   const runningPid = readRunningPostmasterPid(postmasterPidFile);
   if (runningPid) {
     return {
@@ -16260,7 +16963,7 @@ async function ensureEmbeddedPostgres(dataDir, preferredPort) {
     onError: () => {
     }
   });
-  if (!existsSync3(path19.resolve(dataDir, "PG_VERSION"))) {
+  if (!existsSync3(path20.resolve(dataDir, "PG_VERSION"))) {
     await instance.initialise();
   }
   if (existsSync3(postmasterPidFile)) {
@@ -16301,7 +17004,7 @@ async function seedWorktreeDatabase(input) {
     );
     const backup = await runDatabaseBackup({
       connectionString: sourceConnectionString,
-      backupDir: path19.resolve(input.targetPaths.backupDir, "seed"),
+      backupDir: path20.resolve(input.targetPaths.backupDir, "seed"),
       retentionDays: 7,
       filenamePrefix: `${input.instanceId}-seed`,
       includeMigrationJournal: true,
@@ -16399,8 +17102,8 @@ async function runWorktreeInit(opts) {
         `Cannot seed worktree database because source config was not found at ${sourceConfigPath}. Use --no-seed or provide --from-config.`
       );
     }
-    const spinner4 = p17.spinner();
-    spinner4.start(`Seeding isolated worktree database from source instance (${seedMode})...`);
+    const spinner5 = p17.spinner();
+    spinner5.start(`Seeding isolated worktree database from source instance (${seedMode})...`);
     try {
       const seeded = await seedWorktreeDatabase({
         sourceConfigPath,
@@ -16412,9 +17115,9 @@ async function runWorktreeInit(opts) {
       });
       seedSummary = seeded.backupSummary;
       reboundWorkspaceSummary = seeded.reboundWorkspaces;
-      spinner4.stop(`Seeded isolated worktree database (${seedMode}).`);
+      spinner5.stop(`Seeded isolated worktree database (${seedMode}).`);
     } catch (error) {
-      spinner4.stop(pc23.red("Failed to seed worktree database."));
+      spinner5.stop(pc23.red("Failed to seed worktree database."));
       throw error;
     }
   }
@@ -16460,7 +17163,7 @@ async function worktreeMakeCommand(nameArg, opts) {
   if (existsSync3(targetPath)) {
     throw new Error(`Target path already exists: ${targetPath}`);
   }
-  mkdirSync3(path19.dirname(targetPath), { recursive: true });
+  mkdirSync3(path20.dirname(targetPath), { recursive: true });
   if (startPoint) {
     const [remote] = startPoint.split("/", 1);
     try {
@@ -16480,16 +17183,16 @@ async function worktreeMakeCommand(nameArg, opts) {
     branchExists: !startPoint && localBranchExists(sourceCwd, name),
     startPoint
   });
-  const spinner4 = p17.spinner();
-  spinner4.start(`Creating git worktree at ${targetPath}...`);
+  const spinner5 = p17.spinner();
+  spinner5.start(`Creating git worktree at ${targetPath}...`);
   try {
     execFileSync2("git", worktreeArgs, {
       cwd: sourceCwd,
       stdio: ["ignore", "pipe", "pipe"]
     });
-    spinner4.stop(`Created git worktree at ${targetPath}.`);
+    spinner5.stop(`Created git worktree at ${targetPath}.`);
   } catch (error) {
-    spinner4.stop(pc23.red("Failed to create git worktree."));
+    spinner5.stop(pc23.red("Failed to create git worktree."));
     throw new Error(extractExecSyncErrorMessage(error) ?? String(error));
   }
   const installSpinner = p17.spinner();
@@ -16556,15 +17259,15 @@ function parseGitWorktreeList(cwd) {
   return entries;
 }
 function toMergeSourceChoices(cwd) {
-  const currentCwd = path19.resolve(cwd);
+  const currentCwd = path20.resolve(cwd);
   return parseGitWorktreeList(cwd).map((entry) => {
     const branchLabel = entry.branch?.replace(/^refs\/heads\//, "") ?? "(detached)";
-    const worktreePath = path19.resolve(entry.worktree);
+    const worktreePath = path20.resolve(entry.worktree);
     return {
       worktree: worktreePath,
       branch: entry.branch,
       branchLabel,
-      hasRudderConfig: existsSync3(path19.resolve(worktreePath, ".rudder", "config.json")),
+      hasRudderConfig: existsSync3(path20.resolve(worktreePath, ".rudder", "config.json")),
       isCurrent: worktreePath === currentCwd
     };
   });
@@ -16612,14 +17315,14 @@ async function worktreeCleanupCommand(nameArg, opts) {
   const sourceCwd = process.cwd();
   const targetPath = resolveWorktreeMakeTargetPath(name);
   const instanceId = sanitizeWorktreeInstanceId(opts.instance ?? name);
-  const homeDir = path19.resolve(expandHomePrefix(resolveWorktreeHome(opts.home)));
-  const instanceRoot = path19.resolve(homeDir, "instances", instanceId);
+  const homeDir = path20.resolve(expandHomePrefix(resolveWorktreeHome(opts.home)));
+  const instanceRoot = path20.resolve(homeDir, "instances", instanceId);
   const hasBranch = localBranchExists(sourceCwd, name);
   const hasTargetDir = existsSync3(targetPath);
   const hasInstanceData = existsSync3(instanceRoot);
   const worktrees = parseGitWorktreeList(sourceCwd);
   const linkedWorktree = worktrees.find(
-    (wt) => wt.branch === `refs/heads/${name}` || path19.resolve(wt.worktree) === path19.resolve(targetPath)
+    (wt) => wt.branch === `refs/heads/${name}` || path20.resolve(wt.worktree) === path20.resolve(targetPath)
   );
   if (!hasBranch && !hasTargetDir && !hasInstanceData && !linkedWorktree) {
     p17.log.info("Nothing to clean up \u2014 no branch, worktree directory, or instance data found.");
@@ -16657,9 +17360,9 @@ async function worktreeCleanupCommand(nameArg, opts) {
   }
   if (linkedWorktree) {
     const worktreeDirExists = existsSync3(linkedWorktree.worktree);
-    const spinner4 = p17.spinner();
+    const spinner5 = p17.spinner();
     if (worktreeDirExists) {
-      spinner4.start(`Removing git worktree at ${linkedWorktree.worktree}...`);
+      spinner5.start(`Removing git worktree at ${linkedWorktree.worktree}...`);
       try {
         const removeArgs = ["worktree", "remove", linkedWorktree.worktree];
         if (opts.force) removeArgs.push("--force");
@@ -16667,18 +17370,18 @@ async function worktreeCleanupCommand(nameArg, opts) {
           cwd: sourceCwd,
           stdio: ["ignore", "pipe", "pipe"]
         });
-        spinner4.stop(`Removed git worktree at ${linkedWorktree.worktree}.`);
+        spinner5.stop(`Removed git worktree at ${linkedWorktree.worktree}.`);
       } catch (error) {
-        spinner4.stop(pc23.yellow(`Could not remove worktree cleanly, will prune instead.`));
+        spinner5.stop(pc23.yellow(`Could not remove worktree cleanly, will prune instead.`));
         p17.log.warning(extractExecSyncErrorMessage(error) ?? String(error));
       }
     } else {
-      spinner4.start("Pruning stale worktree entry...");
+      spinner5.start("Pruning stale worktree entry...");
       execFileSync2("git", ["worktree", "prune"], {
         cwd: sourceCwd,
         stdio: ["ignore", "pipe", "pipe"]
       });
-      spinner4.stop("Pruned stale worktree entry.");
+      spinner5.stop("Pruned stale worktree entry.");
     }
   } else {
     execFileSync2("git", ["worktree", "prune"], {
@@ -16687,31 +17390,31 @@ async function worktreeCleanupCommand(nameArg, opts) {
     });
   }
   if (existsSync3(targetPath)) {
-    const spinner4 = p17.spinner();
-    spinner4.start(`Removing worktree directory ${targetPath}...`);
+    const spinner5 = p17.spinner();
+    spinner5.start(`Removing worktree directory ${targetPath}...`);
     rmSync(targetPath, { recursive: true, force: true });
-    spinner4.stop(`Removed worktree directory ${targetPath}.`);
+    spinner5.stop(`Removed worktree directory ${targetPath}.`);
   }
   if (localBranchExists(sourceCwd, name)) {
-    const spinner4 = p17.spinner();
-    spinner4.start(`Deleting local branch "${name}"...`);
+    const spinner5 = p17.spinner();
+    spinner5.start(`Deleting local branch "${name}"...`);
     try {
       const deleteFlag = opts.force ? "-D" : "-d";
       execFileSync2("git", ["branch", deleteFlag, name], {
         cwd: sourceCwd,
         stdio: ["ignore", "pipe", "pipe"]
       });
-      spinner4.stop(`Deleted local branch "${name}".`);
+      spinner5.stop(`Deleted local branch "${name}".`);
     } catch (error) {
-      spinner4.stop(pc23.yellow(`Could not delete branch "${name}".`));
+      spinner5.stop(pc23.yellow(`Could not delete branch "${name}".`));
       p17.log.warning(extractExecSyncErrorMessage(error) ?? String(error));
     }
   }
   if (existsSync3(instanceRoot)) {
-    const spinner4 = p17.spinner();
-    spinner4.start(`Removing instance data at ${instanceRoot}...`);
+    const spinner5 = p17.spinner();
+    spinner5.start(`Removing instance data at ${instanceRoot}...`);
     rmSync(instanceRoot, { recursive: true, force: true });
-    spinner4.stop(`Removed instance data at ${instanceRoot}.`);
+    spinner5.stop(`Removed instance data at ${instanceRoot}.`);
   }
   p17.outro(pc23.green("Cleanup complete."));
 }
@@ -16737,7 +17440,7 @@ async function closeDb(db) {
 }
 function resolveCurrentEndpoint() {
   return {
-    rootPath: path19.resolve(process.cwd()),
+    rootPath: path20.resolve(process.cwd()),
     configPath: resolveConfigPath(),
     label: "current",
     isCurrent: true
@@ -16748,12 +17451,12 @@ function resolveAttachmentLookupStorages(input) {
     input.sourceEndpoint.configPath,
     resolveCurrentEndpoint().configPath,
     input.targetEndpoint.configPath,
-    ...toMergeSourceChoices(process.cwd()).filter((choice) => choice.hasRudderConfig).map((choice) => path19.resolve(choice.worktree, ".rudder", "config.json"))
+    ...toMergeSourceChoices(process.cwd()).filter((choice) => choice.hasRudderConfig).map((choice) => path20.resolve(choice.worktree, ".rudder", "config.json"))
   ];
   const seen = /* @__PURE__ */ new Set();
   const storages = [];
   for (const configPath of orderedConfigPaths) {
-    const resolved = path19.resolve(configPath);
+    const resolved = path20.resolve(configPath);
     if (seen.has(resolved) || !existsSync3(resolved)) continue;
     seen.add(resolved);
     storages.push(openConfiguredStorage(resolved));
@@ -17172,7 +17875,7 @@ function resolveEndpointFromChoice(choice) {
   }
   return {
     rootPath: choice.worktree,
-    configPath: path19.resolve(choice.worktree, ".rudder", "config.json"),
+    configPath: path20.resolve(choice.worktree, ".rudder", "config.json"),
     label: choice.branchLabel,
     isCurrent: false
   };
@@ -17188,24 +17891,24 @@ function resolveWorktreeEndpointFromSelector(selector, opts) {
     return currentEndpoint;
   }
   const choices = toMergeSourceChoices(process.cwd());
-  const directPath = path19.resolve(trimmed);
+  const directPath = path20.resolve(trimmed);
   if (existsSync3(directPath)) {
     if (allowCurrent && directPath === currentEndpoint.rootPath) {
       return currentEndpoint;
     }
-    const configPath = path19.resolve(directPath, ".rudder", "config.json");
+    const configPath = path20.resolve(directPath, ".rudder", "config.json");
     if (!existsSync3(configPath)) {
       throw new Error(`Resolved worktree path ${directPath} does not contain .rudder/config.json.`);
     }
     return {
       rootPath: directPath,
       configPath,
-      label: path19.basename(directPath),
+      label: path20.basename(directPath),
       isCurrent: false
     };
   }
   const matched = choices.find(
-    (choice) => (allowCurrent || !choice.isCurrent) && (choice.worktree === directPath || path19.basename(choice.worktree) === trimmed || choice.branchLabel === trimmed)
+    (choice) => (allowCurrent || !choice.isCurrent) && (choice.worktree === directPath || path20.basename(choice.worktree) === trimmed || choice.branchLabel === trimmed)
   );
   if (!matched) {
     throw new Error(
@@ -17218,9 +17921,9 @@ function resolveWorktreeEndpointFromSelector(selector, opts) {
   return resolveEndpointFromChoice(matched);
 }
 async function promptForSourceEndpoint(excludeWorktreePath) {
-  const excluded = excludeWorktreePath ? path19.resolve(excludeWorktreePath) : null;
+  const excluded = excludeWorktreePath ? path20.resolve(excludeWorktreePath) : null;
   const currentEndpoint = resolveCurrentEndpoint();
-  const choices = toMergeSourceChoices(process.cwd()).filter((choice) => choice.hasRudderConfig || choice.isCurrent).filter((choice) => path19.resolve(choice.worktree) !== excluded).map((choice) => ({
+  const choices = toMergeSourceChoices(process.cwd()).filter((choice) => choice.hasRudderConfig || choice.isCurrent).filter((choice) => path20.resolve(choice.worktree) !== excluded).map((choice) => ({
     value: choice.isCurrent ? "__current__" : choice.worktree,
     label: choice.branchLabel,
     hint: `${choice.worktree}${choice.isCurrent ? " (current)" : ""}`
@@ -17544,7 +18247,7 @@ async function worktreeMergeHistoryCommand(sourceArg, opts) {
   }
   const targetEndpoint = opts.to ? resolveWorktreeEndpointFromSelector(opts.to, { allowCurrent: true }) : resolveCurrentEndpoint();
   const sourceEndpoint = opts.from ? resolveWorktreeEndpointFromSelector(opts.from, { allowCurrent: true }) : sourceArg ? resolveWorktreeEndpointFromSelector(sourceArg, { allowCurrent: true }) : await promptForSourceEndpoint(targetEndpoint.rootPath);
-  if (path19.resolve(sourceEndpoint.configPath) === path19.resolve(targetEndpoint.configPath)) {
+  if (path20.resolve(sourceEndpoint.configPath) === path20.resolve(targetEndpoint.configPath)) {
     throw new Error("Source and target Rudder configs are the same. Choose different --from/--to worktrees.");
   }
   const scopes = parseWorktreeMergeScopes(opts.scope);
@@ -17633,16 +18336,16 @@ function registerWorktreeCommands(program) {
 }
 
 // src/commands/client/plugin.ts
-import path20 from "node:path";
+import path21 from "node:path";
 import pc24 from "picocolors";
 function resolvePackageArg(packageArg, isLocal) {
   if (!isLocal) return packageArg;
-  if (path20.isAbsolute(packageArg)) return packageArg;
+  if (path21.isAbsolute(packageArg)) return packageArg;
   if (packageArg.startsWith("~")) {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    return path20.resolve(home, packageArg.slice(1).replace(/^[\\/]/, ""));
+    return path21.resolve(home, packageArg.slice(1).replace(/^[\\/]/, ""));
   }
-  return path20.resolve(process.cwd(), packageArg);
+  return path21.resolve(process.cwd(), packageArg);
 }
 function formatPlugin(p18) {
   const statusColor = p18.status === "ready" ? pc24.green(p18.status) : p18.status === "error" ? pc24.red(p18.status) : p18.status === "disabled" ? pc24.dim(p18.status) : pc24.yellow(p18.status);
@@ -17914,7 +18617,7 @@ function registerClientAuthCommands(auth) {
 
 // src/commands/benchmark-create-agent.ts
 import fs14 from "node:fs/promises";
-import path21 from "node:path";
+import path22 from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { LangfuseClient } from "@langfuse/client";
 
@@ -18463,11 +19166,11 @@ function createAgentEvalCheckToScoreValue(check) {
 }
 
 // src/commands/benchmark-create-agent.ts
-var __moduleDir2 = path21.dirname(fileURLToPath5(import.meta.url));
-var repoRoot = path21.resolve(__moduleDir2, "../../..");
-var defaultCasesDir = path21.join(repoRoot, "benchmark", "create-agent", "cases");
-var defaultSetsDir = path21.join(repoRoot, "benchmark", "create-agent", "sets");
-var defaultArtifactsDir = path21.join(repoRoot, ".artifacts", "create-agent-benchmark");
+var __moduleDir2 = path22.dirname(fileURLToPath5(import.meta.url));
+var repoRoot = path22.resolve(__moduleDir2, "../../..");
+var defaultCasesDir = path22.join(repoRoot, "benchmark", "create-agent", "cases");
+var defaultSetsDir = path22.join(repoRoot, "benchmark", "create-agent", "sets");
+var defaultArtifactsDir = path22.join(repoRoot, ".artifacts", "create-agent-benchmark");
 var TERMINAL_RUN_STATUSES2 = /* @__PURE__ */ new Set(["succeeded", "failed", "cancelled", "timed_out"]);
 var DEFAULT_JUDGE_PROMPT_NAME = "judge-create-agent";
 var DEFAULT_JUDGE_MODEL = "gpt-5-mini";
@@ -18517,16 +19220,16 @@ async function readJsonFile(filePath) {
   return JSON.parse(content);
 }
 async function writeJsonFile(filePath, value) {
-  await fs14.mkdir(path21.dirname(filePath), { recursive: true });
+  await fs14.mkdir(path22.dirname(filePath), { recursive: true });
   await fs14.writeFile(filePath, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 async function loadCaseById(caseId, casesDir) {
-  const filePath = path21.join(casesDir, `${caseId}.json`);
+  const filePath = path22.join(casesDir, `${caseId}.json`);
   return parseCreateAgentCase(await readJsonFile(filePath));
 }
 async function loadSet(setName, setsDir) {
-  const filePath = path21.join(setsDir, `${setName}.json`);
+  const filePath = path22.join(setsDir, `${setName}.json`);
   const raw = await readJsonFile(filePath);
   if (!Array.isArray(raw) || raw.some((item) => typeof item !== "string")) {
     throw new Error(`Benchmark set ${setName} must be a JSON array of case IDs.`);
@@ -18614,13 +19317,13 @@ async function captureCreatedApprovals(api, approvals2) {
   );
 }
 function resultRunDir(artifactsDir, testCase, runId) {
-  return path21.join(artifactsDir, "runs", `${testCase.id}-${runId}`);
+  return path22.join(artifactsDir, "runs", `${testCase.id}-${runId}`);
 }
 function resultJsonPath(artifactsDir, testCase, runId) {
-  return path21.join(resultRunDir(artifactsDir, testCase, runId), "result.json");
+  return path22.join(resultRunDir(artifactsDir, testCase, runId), "result.json");
 }
 function reportMarkdownPath(artifactsDir, testCase, runId) {
-  return path21.join(resultRunDir(artifactsDir, testCase, runId), "report.md");
+  return path22.join(resultRunDir(artifactsDir, testCase, runId), "report.md");
 }
 function averageJudgeScore(judge) {
   if (!judge || judge.status !== "completed") return null;
@@ -19029,7 +19732,7 @@ async function executeBenchmarkCase(caseId, opts) {
   const jsonPath = resultJsonPath(artifactsDir, testCase, runDetail.run.id);
   const markdownPath = reportMarkdownPath(artifactsDir, testCase, runDetail.run.id);
   await writeJsonFile(jsonPath, provisionalResult);
-  await fs14.mkdir(path21.dirname(markdownPath), { recursive: true });
+  await fs14.mkdir(path22.dirname(markdownPath), { recursive: true });
   await fs14.writeFile(markdownPath, buildMarkdownReport(provisionalResult), "utf8");
   return provisionalResult;
 }
@@ -19052,7 +19755,7 @@ async function rescoreStoredResult(resultPath, opts) {
     result.langfuse.scoreSyncError = sync.scoreSyncError;
   }
   await writeJsonFile(resultPath, result);
-  await fs14.writeFile(path21.join(path21.dirname(resultPath), "report.md"), buildMarkdownReport(result), "utf8");
+  await fs14.writeFile(path22.join(path22.dirname(resultPath), "report.md"), buildMarkdownReport(result), "utf8");
   return result;
 }
 function printBenchmarkSummary(result, json = false) {
@@ -19121,7 +19824,7 @@ function registerCreateAgentBenchmarkCommands(program) {
   addCommonClientOptions(
     createAgent.command("rescore").description("Re-run deterministic scoring and optional judge for an existing result.json").argument("<resultPath>", "Path to a stored create-agent benchmark result.json").option("--queue-id <id>", "Langfuse annotation queue id for low-quality runs").option("--judge-model <model>", "Override the judge model").option("--no-sync-langfuse", "Skip Langfuse score sync").option("--no-judge", "Skip optional quality judge").action(async (resultPath, opts) => {
       try {
-        const result = await rescoreStoredResult(path21.resolve(resultPath), opts);
+        const result = await rescoreStoredResult(path22.resolve(resultPath), opts);
         printBenchmarkSummary(result, Boolean(opts.json));
       } catch (error) {
         handleCommandError(error);
@@ -19131,11 +19834,11 @@ function registerCreateAgentBenchmarkCommands(program) {
   addCommonClientOptions(
     createAgent.command("sync-langfuse").description("Sync one stored create-agent benchmark result to Langfuse").argument("<resultPath>", "Path to a stored create-agent benchmark result.json").option("--queue-id <id>", "Langfuse annotation queue id for low-quality runs").action(async (resultPath, opts) => {
       try {
-        const result = await readJsonFile(path21.resolve(resultPath));
+        const result = await readJsonFile(path22.resolve(resultPath));
         const sync = await syncResultToLangfuse(result, { queueId: asString6(opts.queueId) });
         result.langfuse.scoreSync = sync.scoreSync;
         result.langfuse.scoreSyncError = sync.scoreSyncError;
-        await writeJsonFile(path21.resolve(resultPath), result);
+        await writeJsonFile(path22.resolve(resultPath), result);
         printOutput({
           caseId: result.case.id,
           runId: result.runDetail.run.id,
@@ -19151,7 +19854,7 @@ function registerCreateAgentBenchmarkCommands(program) {
   addCommonClientOptions(
     createAgent.command("report").description("Render the markdown summary for an existing result.json").argument("<resultPath>", "Path to a stored create-agent benchmark result.json").option("--markdown", "Print report markdown instead of the parsed result summary", false).action(async (resultPath, opts) => {
       try {
-        const result = await readJsonFile(path21.resolve(resultPath));
+        const result = await readJsonFile(path22.resolve(resultPath));
         if (opts.markdown) {
           process.stdout.write(buildMarkdownReport(result));
           return;
@@ -19173,7 +19876,7 @@ var DATA_DIR_OPTION_HELP = "Rudder data directory root (isolates state from ~/.r
 var LOCAL_ENV_OPTION_HELP = "Local environment profile (dev, prod_local, e2e)";
 function createProgram() {
   const program = new Command();
-  program.name("rudder").description("Rudder CLI \u2014 setup, diagnose, and configure your instance").version("0.1.0-canary.2");
+  program.name("rudder").description("Rudder CLI \u2014 setup, diagnose, and configure your instance").version(resolveCliVersion());
   program.option("--local-env <name>", LOCAL_ENV_OPTION_HELP);
   program.hook("preAction", (_thisCommand, actionCommand) => {
     const options = actionCommand.optsWithGlobals();
@@ -19185,7 +19888,7 @@ function createProgram() {
     });
     loadRudderEnvFile(options.config);
   });
-  program.command("start").description("Start Rudder Desktop and prepare the matching persistent CLI").option("--no-cli", "Skip persistent CLI installation").option("--no-desktop", "Skip desktop app installation").option("--version <version>", "Rudder version to start (default: current CLI version)").option("--repo <owner/repo>", "GitHub repository that hosts desktop releases").option("--output-dir <path>", "Directory for the downloaded desktop installer").option("--no-open", "Download the desktop installer without opening it").option("--no-version-check", "Skip checking npm for a newer Rudder CLI version").option("--dry-run", "Print the start actions without changing the machine", false).action(startCommand);
+  program.command("start").description("Start Rudder Desktop and prepare the matching persistent CLI").option("--no-cli", "Skip persistent CLI installation").option("--no-desktop", "Skip desktop app installation").option("--version <version>", "Rudder version to start (default: current CLI version)").option("--repo <owner/repo>", "GitHub repository that hosts desktop releases").option("--output-dir <path>", "Directory for downloaded desktop release assets").option("--desktop-install-dir <path>", "Directory for the portable Desktop install").option("--no-open", "Install Desktop without launching it").option("--no-version-check", "Skip checking npm for a newer Rudder CLI version").option("--dry-run", "Print the start actions without changing the machine", false).action(startCommand);
   program.command("onboard").description("Interactive first-run setup wizard").option("-c, --config <path>", "Path to config file").option("-d, --data-dir <path>", DATA_DIR_OPTION_HELP).option("-y, --yes", "Accept defaults (quickstart + start immediately)", false).option("--run", "Start Rudder immediately after saving config", false).action(onboard);
   program.command("doctor").description("Run diagnostic checks on your Rudder setup").option("-c, --config <path>", "Path to config file").option("-d, --data-dir <path>", DATA_DIR_OPTION_HELP).option("--repair", "Attempt to repair issues automatically").alias("--fix").option("-y, --yes", "Skip repair confirmation prompts").action(async (opts) => {
     await doctor(opts);