@rudderhq/cli 0.2.0-canary.7 → 0.2.0-canary.9

package/dist/index.js

@@ -495,302 +495,170 @@ var init_budget = __esm({
   }
 });
 
-// ../packages/shared/src/validators/secret.ts
-import { z as z3 } 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 = z3.object({
-      type: z3.literal("plain"),
-      value: z3.string()
-    });
-    envBindingSecretRefSchema = z3.object({
-      type: z3.literal("secret_ref"),
-      secretId: z3.string().uuid(),
-      version: z3.union([z3.literal("latest"), z3.number().int().positive()]).optional()
-    });
-    envBindingSchema = z3.union([
-      z3.string(),
-      envBindingPlainSchema,
-      envBindingSecretRefSchema
-    ]);
-    envConfigSchema = z3.record(envBindingSchema);
-    createSecretSchema = z3.object({
-      name: z3.string().min(1),
-      provider: z3.enum(SECRET_PROVIDERS).optional(),
-      value: z3.string().min(1),
-      description: z3.string().optional().nullable(),
-      externalRef: z3.string().optional().nullable()
-    });
-    rotateSecretSchema = z3.object({
-      value: z3.string().min(1),
-      externalRef: z3.string().optional().nullable()
-    });
-    updateSecretSchema = z3.object({
-      name: z3.string().min(1).optional(),
-      description: z3.string().optional().nullable(),
-      externalRef: z3.string().optional().nullable()
-    });
-  }
-});
-
-// ../packages/shared/src/validators/model-fallbacks.ts
-import { z as z4 } from "zod";
-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: z4.ZodIssueCode.custom,
-      message: "modelFallbacks must be an array",
-      path: [...pathPrefix, "modelFallbacks"]
-    });
-    return;
-  }
-  fallbackModels.forEach((fallback, index66) => {
-    if (typeof fallback === "string") {
-      if (fallback.trim().length === 0) {
-        ctx.addIssue({
-          code: z4.ZodIssueCode.custom,
-          message: "modelFallbacks string entries must be non-empty",
-          path: [...pathPrefix, "modelFallbacks", index66]
-        });
-      }
-      return;
-    }
-    if (!isRecord(fallback)) {
-      ctx.addIssue({
-        code: z4.ZodIssueCode.custom,
-        message: "modelFallbacks entries must be strings or runtime/model objects",
-        path: [...pathPrefix, "modelFallbacks", index66]
-      });
-      return;
-    }
-    if (typeof fallback.agentRuntimeType !== "string" || fallback.agentRuntimeType.trim().length === 0) {
-      ctx.addIssue({
-        code: z4.ZodIssueCode.custom,
-        message: "modelFallbacks entries must include agentRuntimeType",
-        path: [...pathPrefix, "modelFallbacks", index66, "agentRuntimeType"]
-      });
-    } else if (!agentRuntimeTypes.has(fallback.agentRuntimeType)) {
-      ctx.addIssue({
-        code: z4.ZodIssueCode.custom,
-        message: "modelFallbacks entries must include a valid agentRuntimeType",
-        path: [...pathPrefix, "modelFallbacks", index66, "agentRuntimeType"]
-      });
-    }
-    if (typeof fallback.model !== "string" || fallback.model.trim().length === 0) {
-      ctx.addIssue({
-        code: z4.ZodIssueCode.custom,
-        message: "modelFallbacks entries must include model",
-        path: [...pathPrefix, "modelFallbacks", index66, "model"]
-      });
-    }
-    if (fallback.config !== void 0 && !isRecord(fallback.config)) {
-      ctx.addIssue({
-        code: z4.ZodIssueCode.custom,
-        message: "modelFallbacks entry config must be an object",
-        path: [...pathPrefix, "modelFallbacks", index66, "config"]
-      });
-    } else if (isRecord(fallback.config) && fallback.config.env !== void 0) {
-      const parsed = envConfigSchema.safeParse(fallback.config.env);
-      if (!parsed.success) {
-        ctx.addIssue({
-          code: z4.ZodIssueCode.custom,
-          message: "modelFallbacks entry config.env must be a map of valid env bindings",
-          path: [...pathPrefix, "modelFallbacks", index66, "config", "env"]
-        });
-      }
-    }
-  });
-}
-var agentRuntimeTypes;
-var init_model_fallbacks = __esm({
-  "../packages/shared/src/validators/model-fallbacks.ts"() {
-    "use strict";
-    init_constants();
-    init_secret();
-    agentRuntimeTypes = new Set(AGENT_RUNTIME_TYPES);
-  }
-});
-
 // ../packages/shared/src/validators/organization.ts
-import { z as z5 } from "zod";
-var logoAssetIdSchema, brandColorSchema, defaultChatRuntimeConfigSchema, createOrganizationSchema, updateOrganizationSchema, updateOrganizationBrandingSchema, updateOrganizationWorkspaceFileSchema;
+import { z as z3 } from "zod";
+var logoAssetIdSchema, brandColorSchema, createOrganizationSchema, updateOrganizationSchema, updateOrganizationBrandingSchema, updateOrganizationWorkspaceFileSchema;
 var init_organization = __esm({
   "../packages/shared/src/validators/organization.ts"() {
     "use strict";
     init_constants();
-    init_model_fallbacks();
-    logoAssetIdSchema = z5.string().uuid().nullable().optional();
-    brandColorSchema = z5.string().regex(/^#[0-9a-fA-F]{6}$/).nullable().optional();
-    defaultChatRuntimeConfigSchema = z5.record(z5.unknown()).superRefine((value, ctx) => {
-      validateModelFallbacksConfig(value, ctx, []);
-    });
-    createOrganizationSchema = z5.object({
-      name: z5.string().min(1),
-      description: z5.string().optional().nullable(),
-      budgetMonthlyCents: z5.number().int().nonnegative().optional().default(0),
-      defaultChatIssueCreationMode: z5.enum(CHAT_ISSUE_CREATION_MODES).optional().default("manual_approval"),
-      defaultChatAgentRuntimeType: z5.enum(AGENT_RUNTIME_TYPES).optional().nullable(),
-      defaultChatAgentRuntimeConfig: defaultChatRuntimeConfigSchema.optional().nullable(),
+    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"),
       brandColor: brandColorSchema,
-      requireBoardApprovalForNewAgents: z5.boolean().optional()
+      requireBoardApprovalForNewAgents: z3.boolean().optional()
     });
     updateOrganizationSchema = createOrganizationSchema.partial().extend({
-      status: z5.enum(ORGANIZATION_STATUSES).optional(),
-      spentMonthlyCents: z5.number().int().nonnegative().optional(),
-      requireBoardApprovalForNewAgents: z5.boolean().optional(),
-      defaultChatIssueCreationMode: z5.enum(CHAT_ISSUE_CREATION_MODES).optional(),
-      defaultChatAgentRuntimeType: z5.enum(AGENT_RUNTIME_TYPES).optional().nullable(),
-      defaultChatAgentRuntimeConfig: defaultChatRuntimeConfigSchema.optional().nullable(),
+      status: z3.enum(ORGANIZATION_STATUSES).optional(),
+      spentMonthlyCents: z3.number().int().nonnegative().optional(),
+      requireBoardApprovalForNewAgents: z3.boolean().optional(),
+      defaultChatIssueCreationMode: z3.enum(CHAT_ISSUE_CREATION_MODES).optional(),
       brandColor: brandColorSchema,
       logoAssetId: logoAssetIdSchema
     });
-    updateOrganizationBrandingSchema = z5.object({
-      name: z5.string().min(1).optional(),
-      description: z5.string().nullable().optional(),
+    updateOrganizationBrandingSchema = z3.object({
+      name: z3.string().min(1).optional(),
+      description: z3.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 = z5.object({
-      content: z5.string()
+    updateOrganizationWorkspaceFileSchema = z3.object({
+      content: z3.string()
     });
   }
 });
 
 // ../packages/shared/src/validators/resource.ts
-import { z as z6 } from "zod";
+import { z as z4 } 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 = z6.enum(ORGANIZATION_RESOURCE_KINDS);
-    projectResourceAttachmentRoleSchema = z6.enum(PROJECT_RESOURCE_ATTACHMENT_ROLES);
-    createOrganizationResourceSchema = z6.object({
-      name: z6.string().min(1),
+    organizationResourceKindSchema = z4.enum(ORGANIZATION_RESOURCE_KINDS);
+    projectResourceAttachmentRoleSchema = z4.enum(PROJECT_RESOURCE_ATTACHMENT_ROLES);
+    createOrganizationResourceSchema = z4.object({
+      name: z4.string().min(1),
       kind: organizationResourceKindSchema,
-      locator: z6.string().min(1),
-      description: z6.string().optional().nullable(),
-      metadata: z6.record(z6.unknown()).optional().nullable()
+      locator: z4.string().min(1),
+      description: z4.string().optional().nullable(),
+      metadata: z4.record(z4.unknown()).optional().nullable()
     });
-    updateOrganizationResourceSchema = z6.object({
-      name: z6.string().min(1).optional(),
+    updateOrganizationResourceSchema = z4.object({
+      name: z4.string().min(1).optional(),
       kind: organizationResourceKindSchema.optional(),
-      locator: z6.string().min(1).optional(),
-      description: z6.string().optional().nullable(),
-      metadata: z6.record(z6.unknown()).optional().nullable()
+      locator: z4.string().min(1).optional(),
+      description: z4.string().optional().nullable(),
+      metadata: z4.record(z4.unknown()).optional().nullable()
     }).strict();
-    projectResourceAttachmentInputSchema = z6.object({
-      resourceId: z6.string().uuid(),
+    projectResourceAttachmentInputSchema = z4.object({
+      resourceId: z4.string().uuid(),
       role: projectResourceAttachmentRoleSchema.optional(),
-      note: z6.string().optional().nullable(),
-      sortOrder: z6.number().int().nonnegative().optional()
+      note: z4.string().optional().nullable(),
+      sortOrder: z4.number().int().nonnegative().optional()
     }).strict();
-    updateProjectResourceAttachmentSchema = z6.object({
+    updateProjectResourceAttachmentSchema = z4.object({
       role: projectResourceAttachmentRoleSchema.optional(),
-      note: z6.string().optional().nullable(),
-      sortOrder: z6.number().int().nonnegative().optional()
+      note: z4.string().optional().nullable(),
+      sortOrder: z4.number().int().nonnegative().optional()
     }).strict();
     createProjectInlineResourceSchema = createOrganizationResourceSchema.extend({
       role: projectResourceAttachmentRoleSchema.optional(),
-      note: z6.string().optional().nullable(),
-      sortOrder: z6.number().int().nonnegative().optional()
+      note: z4.string().optional().nullable(),
+      sortOrder: z4.number().int().nonnegative().optional()
     }).strict();
   }
 });
 
 // ../packages/shared/src/validators/chat.ts
-import { z as z7 } from "zod";
+import { z as z5 } 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 = z7.enum(CHAT_CONVERSATION_STATUSES);
-    chatIssueCreationModeSchema = z7.enum(CHAT_ISSUE_CREATION_MODES);
-    chatMessageRoleSchema = z7.enum(CHAT_MESSAGE_ROLES);
-    chatMessageKindSchema = z7.enum(CHAT_MESSAGE_KINDS);
-    chatMessageStatusSchema = z7.enum(CHAT_MESSAGE_STATUSES);
-    chatContextEntityTypeSchema = z7.enum(CHAT_CONTEXT_ENTITY_TYPES);
-    createChatContextLinkSchema = z7.object({
+    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({
       entityType: chatContextEntityTypeSchema,
-      entityId: z7.string().min(1),
-      metadata: z7.record(z7.unknown()).optional().nullable()
+      entityId: z5.string().min(1),
+      metadata: z5.record(z5.unknown()).optional().nullable()
     });
-    createChatConversationSchema = z7.object({
-      title: z7.string().trim().min(1).max(200).optional(),
-      summary: z7.string().trim().max(5e3).optional().nullable(),
-      preferredAgentId: z7.string().uuid().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(),
       issueCreationMode: chatIssueCreationModeSchema.optional(),
-      planMode: z7.boolean().optional(),
-      contextLinks: z7.array(createChatContextLinkSchema).optional().default([])
+      planMode: z5.boolean().optional(),
+      contextLinks: z5.array(createChatContextLinkSchema).optional().default([])
     });
-    setChatProjectContextSchema = z7.object({
-      projectId: z7.string().uuid().optional().nullable()
+    setChatProjectContextSchema = z5.object({
+      projectId: z5.string().uuid().optional().nullable()
     });
     updateChatConversationSchema = createChatConversationSchema.partial().extend({
       status: chatConversationStatusSchema.optional(),
-      routedAgentId: z7.string().uuid().optional().nullable(),
-      primaryIssueId: z7.string().uuid().optional().nullable(),
-      resolvedAt: z7.string().datetime().optional().nullable()
+      routedAgentId: z5.string().uuid().optional().nullable(),
+      primaryIssueId: z5.string().uuid().optional().nullable(),
+      resolvedAt: z5.string().datetime().optional().nullable()
     });
-    addChatMessageSchema = z7.object({
-      body: z7.string().trim().min(1).max(2e4),
-      editUserMessageId: z7.string().uuid().optional().nullable()
+    addChatMessageSchema = z5.object({
+      body: z5.string().trim().min(1).max(2e4),
+      editUserMessageId: z5.string().uuid().optional().nullable()
     });
-    createChatAttachmentMetadataSchema = z7.object({
-      messageId: z7.string().uuid()
+    createChatAttachmentMetadataSchema = z5.object({
+      messageId: z5.string().uuid()
     });
-    chatIssueProposalSchema = z7.object({
-      title: z7.string().trim().min(1).max(200),
-      description: z7.string().trim().min(1).max(2e4),
-      priority: z7.enum(["critical", "high", "medium", "low"]).optional().default("medium"),
-      projectId: z7.string().uuid().optional().nullable(),
-      goalId: z7.string().uuid().optional().nullable(),
-      parentId: z7.string().uuid().optional().nullable(),
-      assigneeAgentId: z7.string().uuid().optional().nullable(),
-      assigneeUserId: z7.string().trim().optional().nullable()
+    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()
     });
-    convertChatToIssueSchema = z7.object({
-      messageId: z7.string().uuid().optional().nullable(),
+    convertChatToIssueSchema = z5.object({
+      messageId: z5.string().uuid().optional().nullable(),
       proposal: chatIssueProposalSchema.optional()
     });
-    chatOperationProposalSchema = z7.object({
-      targetType: z7.enum(["organization", "agent"]),
-      targetId: z7.string().min(1),
-      summary: z7.string().trim().min(1).max(500),
-      patch: z7.record(z7.unknown())
+    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())
     });
-    resolveChatOperationProposalSchema = z7.object({
-      action: z7.enum(["approve", "reject", "requestRevision"]),
-      decisionNote: z7.string().trim().max(5e3).optional().nullable()
+    resolveChatOperationProposalSchema = z5.object({
+      action: z5.enum(["approve", "reject", "requestRevision"]),
+      decisionNote: z5.string().trim().max(5e3).optional().nullable()
     });
-    updateChatConversationUserStateSchema = z7.object({
-      pinned: z7.boolean().optional()
+    updateChatConversationUserStateSchema = z5.object({
+      pinned: z5.boolean().optional()
     });
   }
 });
 
 // ../packages/shared/src/validators/organization-skill.ts
-import { z as z8 } from "zod";
+import { z as z6 } 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 = z8.enum(["local_path", "github", "url", "catalog", "skills_sh"]);
-    organizationSkillTrustLevelSchema = z8.enum(["markdown_only", "assets", "scripts_executables"]);
-    organizationSkillCompatibilitySchema = z8.enum(["compatible", "unknown", "invalid"]);
-    organizationSkillSourceBadgeSchema = z8.enum([
+    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([
       "rudder",
       "community",
       "github",
@@ -799,157 +667,157 @@ var init_organization_skill = __esm({
       "catalog",
       "skills_sh"
     ]);
-    organizationSkillFileInventoryEntrySchema = z8.object({
-      path: z8.string().min(1),
-      kind: z8.enum(["skill", "markdown", "reference", "script", "asset", "other"])
+    organizationSkillFileInventoryEntrySchema = z6.object({
+      path: z6.string().min(1),
+      kind: z6.enum(["skill", "markdown", "reference", "script", "asset", "other"])
     });
-    organizationSkillSchema = z8.object({
-      id: z8.string().uuid(),
-      orgId: z8.string().uuid(),
-      key: z8.string().min(1),
-      slug: z8.string().min(1),
-      name: z8.string().min(1),
-      description: z8.string().nullable(),
-      markdown: z8.string(),
+    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(),
       sourceType: organizationSkillSourceTypeSchema,
-      sourceLocator: z8.string().nullable(),
-      sourceRef: z8.string().nullable(),
+      sourceLocator: z6.string().nullable(),
+      sourceRef: z6.string().nullable(),
       trustLevel: organizationSkillTrustLevelSchema,
       compatibility: organizationSkillCompatibilitySchema,
-      fileInventory: z8.array(organizationSkillFileInventoryEntrySchema).default([]),
-      metadata: z8.record(z8.unknown()).nullable(),
-      createdAt: z8.coerce.date(),
-      updatedAt: z8.coerce.date()
+      fileInventory: z6.array(organizationSkillFileInventoryEntrySchema).default([]),
+      metadata: z6.record(z6.unknown()).nullable(),
+      createdAt: z6.coerce.date(),
+      updatedAt: z6.coerce.date()
     });
     organizationSkillListItemSchema = organizationSkillSchema.extend({
-      attachedAgentCount: z8.number().int().nonnegative(),
-      editable: z8.boolean(),
-      editableReason: z8.string().nullable(),
-      sourceLabel: z8.string().nullable(),
+      attachedAgentCount: z6.number().int().nonnegative(),
+      editable: z6.boolean(),
+      editableReason: z6.string().nullable(),
+      sourceLabel: z6.string().nullable(),
       sourceBadge: organizationSkillSourceBadgeSchema,
-      sourcePath: z8.string().nullable(),
-      workspaceEditPath: z8.string().nullable()
+      sourcePath: z6.string().nullable(),
+      workspaceEditPath: z6.string().nullable()
     });
-    organizationSkillUsageAgentSchema = z8.object({
-      id: z8.string().uuid(),
-      name: z8.string().min(1),
-      urlKey: z8.string().min(1),
-      agentRuntimeType: z8.string().min(1),
-      desired: z8.boolean(),
-      actualState: z8.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()
     });
     organizationSkillDetailSchema = organizationSkillSchema.extend({
-      attachedAgentCount: z8.number().int().nonnegative(),
-      usedByAgents: z8.array(organizationSkillUsageAgentSchema).default([]),
-      editable: z8.boolean(),
-      editableReason: z8.string().nullable(),
-      sourceLabel: z8.string().nullable(),
+      attachedAgentCount: z6.number().int().nonnegative(),
+      usedByAgents: z6.array(organizationSkillUsageAgentSchema).default([]),
+      editable: z6.boolean(),
+      editableReason: z6.string().nullable(),
+      sourceLabel: z6.string().nullable(),
       sourceBadge: organizationSkillSourceBadgeSchema,
-      sourcePath: z8.string().nullable(),
-      workspaceEditPath: z8.string().nullable()
+      sourcePath: z6.string().nullable(),
+      workspaceEditPath: z6.string().nullable()
     });
-    organizationSkillUpdateStatusSchema = z8.object({
-      supported: z8.boolean(),
-      reason: z8.string().nullable(),
-      trackingRef: z8.string().nullable(),
-      currentRef: z8.string().nullable(),
-      latestRef: z8.string().nullable(),
-      hasUpdate: z8.boolean()
+    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()
     });
-    organizationSkillImportSchema = z8.object({
-      source: z8.string().min(1)
+    organizationSkillImportSchema = z6.object({
+      source: z6.string().min(1)
     });
-    organizationSkillProjectScanRequestSchema = z8.object({
-      projectIds: z8.array(z8.string().uuid()).optional(),
-      workspaceIds: z8.array(z8.string().uuid()).optional()
+    organizationSkillProjectScanRequestSchema = z6.object({
+      projectIds: z6.array(z6.string().uuid()).optional(),
+      workspaceIds: z6.array(z6.string().uuid()).optional()
     });
-    organizationSkillProjectScanSkippedSchema = z8.object({
-      projectId: z8.string().uuid(),
-      projectName: z8.string().min(1),
-      workspaceId: z8.string().uuid().nullable(),
-      workspaceName: z8.string().nullable(),
-      path: z8.string().nullable(),
-      reason: z8.string().min(1)
+    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)
     });
-    organizationSkillProjectScanConflictSchema = z8.object({
-      slug: z8.string().min(1),
-      key: z8.string().min(1),
-      projectId: z8.string().uuid(),
-      projectName: z8.string().min(1),
-      workspaceId: z8.string().uuid(),
-      workspaceName: z8.string().min(1),
-      path: z8.string().min(1),
-      existingSkillId: z8.string().uuid(),
-      existingSkillKey: z8.string().min(1),
-      existingSourceLocator: z8.string().nullable(),
-      reason: z8.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)
     });
-    organizationSkillProjectScanResultSchema = z8.object({
-      scannedProjects: z8.number().int().nonnegative(),
-      scannedWorkspaces: z8.number().int().nonnegative(),
-      discovered: z8.number().int().nonnegative(),
-      imported: z8.array(organizationSkillSchema),
-      updated: z8.array(organizationSkillSchema),
-      skipped: z8.array(organizationSkillProjectScanSkippedSchema),
-      conflicts: z8.array(organizationSkillProjectScanConflictSchema),
-      warnings: z8.array(z8.string())
+    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())
     });
-    organizationSkillLocalScanRequestSchema = z8.object({
-      roots: z8.array(z8.string().min(1)).optional()
+    organizationSkillLocalScanRequestSchema = z6.object({
+      roots: z6.array(z6.string().min(1)).optional()
     });
-    organizationSkillLocalScanSkippedSchema = z8.object({
-      root: z8.string().min(1),
-      path: z8.string().nullable(),
-      reason: z8.string().min(1)
+    organizationSkillLocalScanSkippedSchema = z6.object({
+      root: z6.string().min(1),
+      path: z6.string().nullable(),
+      reason: z6.string().min(1)
     });
-    organizationSkillLocalScanConflictSchema = z8.object({
-      root: z8.string().min(1),
-      path: z8.string().min(1),
-      slug: z8.string().min(1),
-      key: z8.string().min(1),
-      existingSkillId: z8.string().uuid(),
-      existingSkillKey: z8.string().min(1),
-      existingSourceLocator: z8.string().nullable(),
-      reason: z8.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)
     });
-    organizationSkillLocalScanResultSchema = z8.object({
-      scannedRoots: z8.number().int().nonnegative(),
-      discovered: z8.number().int().nonnegative(),
-      imported: z8.array(organizationSkillSchema),
-      updated: z8.array(organizationSkillSchema),
-      skipped: z8.array(organizationSkillLocalScanSkippedSchema),
-      conflicts: z8.array(organizationSkillLocalScanConflictSchema),
-      warnings: z8.array(z8.string())
+    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())
     });
-    organizationSkillCreateSchema = z8.object({
-      name: z8.string().min(1),
-      slug: z8.string().min(1).nullable().optional(),
-      description: z8.string().nullable().optional(),
-      markdown: z8.string().nullable().optional()
+    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()
     });
-    organizationSkillFileDetailSchema = z8.object({
-      skillId: z8.string().uuid(),
-      path: z8.string().min(1),
-      kind: z8.enum(["skill", "markdown", "reference", "script", "asset", "other"]),
-      content: z8.string(),
-      language: z8.string().nullable(),
-      markdown: z8.boolean(),
-      editable: z8.boolean()
+    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()
     });
-    organizationSkillFileUpdateSchema = z8.object({
-      path: z8.string().min(1),
-      content: z8.string()
+    organizationSkillFileUpdateSchema = z6.object({
+      path: z6.string().min(1),
+      content: z6.string()
     });
   }
 });
 
 // ../packages/shared/src/validators/adapter-skills.ts
-import { z as z9 } from "zod";
+import { z as z7 } 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 = z9.enum([
+    agentSkillStateSchema = z7.enum([
       "available",
       "configured",
       "installed",
@@ -957,271 +825,395 @@ var init_adapter_skills = __esm({
       "stale",
       "external"
     ]);
-    agentSkillOriginSchema = z9.preprocess((value) => {
+    agentSkillOriginSchema = z7.preprocess((value) => {
       if (value === "company_managed") return "organization_managed";
       return value;
-    }, z9.enum([
+    }, z7.enum([
       "organization_managed",
       "user_installed",
       "external_unknown"
     ]));
-    agentSkillSourceClassSchema = z9.enum([
+    agentSkillSourceClassSchema = z7.enum([
       "bundled",
       "organization",
       "agent_home",
       "global",
       "adapter_home"
     ]);
-    agentSkillSyncModeSchema = z9.enum([
+    agentSkillSyncModeSchema = z7.enum([
       "unsupported",
       "persistent",
       "ephemeral"
     ]);
-    agentSkillEntrySchema = z9.object({
-      key: z9.string().min(1),
-      selectionKey: z9.string().min(1),
-      runtimeName: z9.string().min(1).nullable(),
-      description: z9.string().nullable().optional(),
-      desired: z9.boolean(),
-      configurable: z9.boolean(),
-      alwaysEnabled: z9.boolean(),
-      managed: z9.boolean(),
+    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(),
       state: agentSkillStateSchema,
       sourceClass: agentSkillSourceClassSchema,
       origin: agentSkillOriginSchema.optional(),
-      originLabel: z9.string().nullable().optional(),
-      locationLabel: z9.string().nullable().optional(),
-      readOnly: z9.boolean().optional(),
-      sourcePath: z9.string().nullable().optional(),
-      targetPath: z9.string().nullable().optional(),
-      workspaceEditPath: z9.string().nullable().optional(),
-      detail: z9.string().nullable().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()
     });
-    agentSkillSnapshotSchema = z9.object({
-      agentRuntimeType: z9.string().min(1),
-      supported: z9.boolean(),
+    agentSkillSnapshotSchema = z7.object({
+      agentRuntimeType: z7.string().min(1),
+      supported: z7.boolean(),
       mode: agentSkillSyncModeSchema,
-      desiredSkills: z9.array(z9.string().min(1)),
-      entries: z9.array(agentSkillEntrySchema),
-      warnings: z9.array(z9.string())
+      desiredSkills: z7.array(z7.string().min(1)),
+      entries: z7.array(agentSkillEntrySchema),
+      warnings: z7.array(z7.string())
     });
-    agentSkillSyncSchema = z9.object({
-      desiredSkills: z9.array(z9.string().min(1))
+    agentSkillSyncSchema = z7.object({
+      desiredSkills: z7.array(z7.string().min(1))
     });
   }
 });
 
 // ../packages/shared/src/validators/organization-portability.ts
-import { z as z10 } from "zod";
+import { z as z8 } 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 = z10.object({
-      organization: z10.boolean().optional(),
-      agents: z10.boolean().optional(),
-      projects: z10.boolean().optional(),
-      issues: z10.boolean().optional(),
-      skills: z10.boolean().optional()
+    portabilityIncludeSchema = z8.object({
+      organization: z8.boolean().optional(),
+      agents: z8.boolean().optional(),
+      projects: z8.boolean().optional(),
+      issues: z8.boolean().optional(),
+      skills: z8.boolean().optional()
     }).partial();
-    portabilityEnvInputSchema = z10.object({
-      key: z10.string().min(1),
-      description: z10.string().nullable(),
-      agentSlug: z10.string().min(1).nullable(),
-      kind: z10.enum(["secret", "plain"]),
-      requirement: z10.enum(["required", "optional"]),
-      defaultValue: z10.string().nullable(),
-      portability: z10.enum(["portable", "system_dependent"])
+    portabilityEnvInputSchema = 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"])
     });
-    portabilityFileEntrySchema = z10.union([
-      z10.string(),
-      z10.object({
-        encoding: z10.literal("base64"),
-        data: z10.string(),
-        contentType: z10.string().min(1).optional().nullable()
+    portabilityFileEntrySchema = z8.union([
+      z8.string(),
+      z8.object({
+        encoding: z8.literal("base64"),
+        data: z8.string(),
+        contentType: z8.string().min(1).optional().nullable()
       })
     ]);
-    portabilityOrganizationManifestEntrySchema = z10.object({
-      path: z10.string().min(1),
-      name: z10.string().min(1),
-      description: z10.string().nullable(),
-      brandColor: z10.string().nullable(),
-      logoPath: z10.string().nullable(),
-      requireBoardApprovalForNewAgents: z10.boolean()
+    portabilityOrganizationManifestEntrySchema = 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()
     });
-    portabilitySidebarOrderSchema = z10.object({
-      agents: z10.array(z10.string().min(1)).default([]),
-      projects: z10.array(z10.string().min(1)).default([])
+    portabilitySidebarOrderSchema = z8.object({
+      agents: z8.array(z8.string().min(1)).default([]),
+      projects: z8.array(z8.string().min(1)).default([])
     });
-    portabilityAgentManifestEntrySchema = z10.object({
-      slug: z10.string().min(1),
-      name: z10.string().min(1),
-      path: z10.string().min(1),
-      skills: z10.array(z10.string().min(1)).default([]),
-      role: z10.string().min(1),
-      title: z10.string().nullable(),
-      icon: z10.string().nullable(),
-      capabilities: z10.string().nullable(),
-      reportsToSlug: z10.string().min(1).nullable(),
-      agentRuntimeType: z10.string().min(1),
-      agentRuntimeConfig: z10.record(z10.unknown()),
-      runtimeConfig: z10.record(z10.unknown()),
-      permissions: z10.record(z10.unknown()),
-      budgetMonthlyCents: z10.number().int().nonnegative(),
-      metadata: z10.record(z10.unknown()).nullable()
+    portabilityAgentManifestEntrySchema = 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()
     });
-    portabilitySkillManifestEntrySchema = z10.object({
-      key: z10.string().min(1),
-      slug: z10.string().min(1),
-      name: z10.string().min(1),
-      path: z10.string().min(1),
-      description: z10.string().nullable(),
-      sourceType: z10.string().min(1),
-      sourceLocator: z10.string().nullable(),
-      sourceRef: z10.string().nullable(),
-      trustLevel: z10.string().nullable(),
-      compatibility: z10.string().nullable(),
-      metadata: z10.record(z10.unknown()).nullable(),
-      fileInventory: z10.array(z10.object({
-        path: z10.string().min(1),
-        kind: z10.string().min(1)
+    portabilitySkillManifestEntrySchema = 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)
       })).default([])
     });
-    portabilityProjectManifestEntrySchema = z10.object({
-      slug: z10.string().min(1),
-      name: z10.string().min(1),
-      path: z10.string().min(1),
-      description: z10.string().nullable(),
-      ownerAgentSlug: z10.string().min(1).nullable(),
-      leadAgentSlug: z10.string().min(1).nullable(),
-      targetDate: z10.string().nullable(),
-      color: z10.string().nullable(),
-      status: z10.string().nullable(),
-      executionWorkspacePolicy: z10.record(z10.unknown()).nullable(),
-      workspaces: z10.array(z10.object({
-        key: z10.string().min(1),
-        name: z10.string().min(1),
-        sourceType: z10.string().nullable(),
-        repoUrl: z10.string().nullable(),
-        repoRef: z10.string().nullable(),
-        defaultRef: z10.string().nullable(),
-        visibility: z10.string().nullable(),
-        setupCommand: z10.string().nullable(),
-        cleanupCommand: z10.string().nullable(),
-        metadata: z10.record(z10.unknown()).nullable(),
-        isPrimary: z10.boolean()
+    portabilityProjectManifestEntrySchema = 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()
       })).default([]),
-      metadata: z10.record(z10.unknown()).nullable()
+      metadata: z8.record(z8.unknown()).nullable()
     });
-    portabilityIssueAutomationTriggerManifestEntrySchema = z10.object({
-      kind: z10.string().min(1),
-      label: z10.string().nullable(),
-      enabled: z10.boolean(),
-      cronExpression: z10.string().nullable(),
-      timezone: z10.string().nullable(),
-      signingMode: z10.string().nullable(),
-      replayWindowSec: z10.number().int().nullable()
+    portabilityIssueAutomationTriggerManifestEntrySchema = 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()
     });
-    portabilityIssueAutomationManifestEntrySchema = z10.object({
-      concurrencyPolicy: z10.string().nullable(),
-      catchUpPolicy: z10.string().nullable(),
-      triggers: z10.array(portabilityIssueAutomationTriggerManifestEntrySchema).default([])
+    portabilityIssueAutomationManifestEntrySchema = z8.object({
+      concurrencyPolicy: z8.string().nullable(),
+      catchUpPolicy: z8.string().nullable(),
+      triggers: z8.array(portabilityIssueAutomationTriggerManifestEntrySchema).default([])
     });
-    portabilityIssueManifestEntrySchema = z10.object({
-      slug: z10.string().min(1),
-      identifier: z10.string().min(1).nullable(),
-      title: z10.string().min(1),
-      path: z10.string().min(1),
-      projectSlug: z10.string().min(1).nullable(),
-      projectWorkspaceKey: z10.string().min(1).nullable(),
-      assigneeAgentSlug: z10.string().min(1).nullable(),
-      description: z10.string().nullable(),
-      recurring: z10.boolean().default(false),
+    portabilityIssueManifestEntrySchema = 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),
       automation: portabilityIssueAutomationManifestEntrySchema.nullable(),
-      legacyRecurrence: z10.record(z10.unknown()).nullable(),
-      status: z10.string().nullable(),
-      priority: z10.string().nullable(),
-      labelIds: z10.array(z10.string().min(1)).default([]),
-      billingCode: z10.string().nullable(),
-      executionWorkspaceSettings: z10.record(z10.unknown()).nullable(),
-      assigneeAgentRuntimeOverrides: z10.record(z10.unknown()).nullable(),
-      metadata: z10.record(z10.unknown()).nullable()
+      legacyRecurrence: 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()
     });
-    portabilityManifestSchema = z10.object({
-      schemaVersion: z10.number().int().positive(),
-      generatedAt: z10.string().datetime(),
-      source: z10.object({
-        orgId: z10.string().uuid(),
-        organizationName: z10.string().min(1)
+    portabilityManifestSchema = z8.object({
+      schemaVersion: z8.number().int().positive(),
+      generatedAt: z8.string().datetime(),
+      source: z8.object({
+        orgId: z8.string().uuid(),
+        organizationName: z8.string().min(1)
       }).nullable(),
-      includes: z10.object({
-        organization: z10.boolean(),
-        agents: z10.boolean(),
-        projects: z10.boolean(),
-        issues: z10.boolean(),
-        skills: z10.boolean()
+      includes: z8.object({
+        organization: z8.boolean(),
+        agents: z8.boolean(),
+        projects: z8.boolean(),
+        issues: z8.boolean(),
+        skills: z8.boolean()
       }),
       organization: portabilityOrganizationManifestEntrySchema.nullable(),
       sidebar: portabilitySidebarOrderSchema.nullable(),
-      agents: z10.array(portabilityAgentManifestEntrySchema),
-      skills: z10.array(portabilitySkillManifestEntrySchema).default([]),
-      projects: z10.array(portabilityProjectManifestEntrySchema).default([]),
-      issues: z10.array(portabilityIssueManifestEntrySchema).default([]),
-      envInputs: z10.array(portabilityEnvInputSchema).default([])
+      agents: z8.array(portabilityAgentManifestEntrySchema),
+      skills: z8.array(portabilitySkillManifestEntrySchema).default([]),
+      projects: z8.array(portabilityProjectManifestEntrySchema).default([]),
+      issues: z8.array(portabilityIssueManifestEntrySchema).default([]),
+      envInputs: z8.array(portabilityEnvInputSchema).default([])
     });
-    portabilitySourceSchema = z10.discriminatedUnion("type", [
-      z10.object({
-        type: z10.literal("inline"),
-        rootPath: z10.string().min(1).optional().nullable(),
-        files: z10.record(portabilityFileEntrySchema)
+    portabilitySourceSchema = z8.discriminatedUnion("type", [
+      z8.object({
+        type: z8.literal("inline"),
+        rootPath: z8.string().min(1).optional().nullable(),
+        files: z8.record(portabilityFileEntrySchema)
       }),
-      z10.object({
-        type: z10.literal("github"),
-        url: z10.string().url()
+      z8.object({
+        type: z8.literal("github"),
+        url: z8.string().url()
       })
     ]);
-    portabilityTargetSchema = z10.discriminatedUnion("mode", [
-      z10.object({
-        mode: z10.literal("new_organization"),
-        newOrganizationName: z10.string().min(1).optional().nullable()
+    portabilityTargetSchema = z8.discriminatedUnion("mode", [
+      z8.object({
+        mode: z8.literal("new_organization"),
+        newOrganizationName: z8.string().min(1).optional().nullable()
       }),
-      z10.object({
-        mode: z10.literal("existing_organization"),
-        orgId: z10.string().uuid()
+      z8.object({
+        mode: z8.literal("existing_organization"),
+        orgId: z8.string().uuid()
       })
     ]);
-    portabilityAgentSelectionSchema = z10.union([
-      z10.literal("all"),
-      z10.array(z10.string().min(1))
+    portabilityAgentSelectionSchema = z8.union([
+      z8.literal("all"),
+      z8.array(z8.string().min(1))
     ]);
-    portabilityCollisionStrategySchema = z10.enum(["rename", "skip", "replace"]);
-    organizationPortabilityExportSchema = z10.object({
+    portabilityCollisionStrategySchema = z8.enum(["rename", "skip", "replace"]);
+    organizationPortabilityExportSchema = z8.object({
       include: portabilityIncludeSchema.optional(),
-      agents: z10.array(z10.string().min(1)).optional(),
-      skills: z10.array(z10.string().min(1)).optional(),
-      projects: z10.array(z10.string().min(1)).optional(),
-      issues: z10.array(z10.string().min(1)).optional(),
-      projectIssues: z10.array(z10.string().min(1)).optional(),
-      selectedFiles: z10.array(z10.string().min(1)).optional(),
-      expandReferencedSkills: z10.boolean().optional(),
+      agents: 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(),
       sidebarOrder: portabilitySidebarOrderSchema.partial().optional()
     });
-    organizationPortabilityPreviewSchema = z10.object({
+    organizationPortabilityPreviewSchema = z8.object({
       source: portabilitySourceSchema,
       include: portabilityIncludeSchema.optional(),
       target: portabilityTargetSchema,
       agents: portabilityAgentSelectionSchema.optional(),
       collisionStrategy: portabilityCollisionStrategySchema.optional(),
-      nameOverrides: z10.record(z10.string().min(1), z10.string().min(1)).optional(),
-      selectedFiles: z10.array(z10.string().min(1)).optional()
+      nameOverrides: z8.record(z8.string().min(1), z8.string().min(1)).optional(),
+      selectedFiles: z8.array(z8.string().min(1)).optional()
     });
-    portabilityAdapterOverrideSchema = z10.object({
-      agentRuntimeType: z10.string().min(1),
-      agentRuntimeConfig: z10.record(z10.unknown()).optional()
+    portabilityAdapterOverrideSchema = z8.object({
+      agentRuntimeType: z8.string().min(1),
+      agentRuntimeConfig: z8.record(z8.unknown()).optional()
     });
     organizationPortabilityImportSchema = organizationPortabilityPreviewSchema.extend({
-      agentRuntimeOverrides: z10.record(z10.string().min(1), portabilityAdapterOverrideSchema).optional()
+      agentRuntimeOverrides: z8.record(z8.string().min(1), portabilityAdapterOverrideSchema).optional()
+    });
+  }
+});
+
+// ../packages/shared/src/validators/secret.ts
+import { z as z9 } 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()
+    });
+    envBindingSecretRefSchema = z9.object({
+      type: z9.literal("secret_ref"),
+      secretId: z9.string().uuid(),
+      version: z9.union([z9.literal("latest"), z9.number().int().positive()]).optional()
+    });
+    envBindingSchema = z9.union([
+      z9.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()
+    });
+    rotateSecretSchema = z9.object({
+      value: z9.string().min(1),
+      externalRef: z9.string().optional().nullable()
+    });
+    updateSecretSchema = z9.object({
+      name: z9.string().min(1).optional(),
+      description: z9.string().optional().nullable(),
+      externalRef: z9.string().optional().nullable()
+    });
+  }
+});
+
+// ../packages/shared/src/validators/model-fallbacks.ts
+import { z as z10 } from "zod";
+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: z10.ZodIssueCode.custom,
+      message: "modelFallbacks must be an array",
+      path: [...pathPrefix, "modelFallbacks"]
     });
+    return;
+  }
+  fallbackModels.forEach((fallback, index66) => {
+    if (typeof fallback === "string") {
+      if (fallback.trim().length === 0) {
+        ctx.addIssue({
+          code: z10.ZodIssueCode.custom,
+          message: "modelFallbacks string entries must be non-empty",
+          path: [...pathPrefix, "modelFallbacks", index66]
+        });
+      }
+      return;
+    }
+    if (!isRecord(fallback)) {
+      ctx.addIssue({
+        code: z10.ZodIssueCode.custom,
+        message: "modelFallbacks entries must be strings or runtime/model objects",
+        path: [...pathPrefix, "modelFallbacks", index66]
+      });
+      return;
+    }
+    if (typeof fallback.agentRuntimeType !== "string" || fallback.agentRuntimeType.trim().length === 0) {
+      ctx.addIssue({
+        code: z10.ZodIssueCode.custom,
+        message: "modelFallbacks entries must include agentRuntimeType",
+        path: [...pathPrefix, "modelFallbacks", index66, "agentRuntimeType"]
+      });
+    } else if (!agentRuntimeTypes.has(fallback.agentRuntimeType)) {
+      ctx.addIssue({
+        code: z10.ZodIssueCode.custom,
+        message: "modelFallbacks entries must include a valid agentRuntimeType",
+        path: [...pathPrefix, "modelFallbacks", index66, "agentRuntimeType"]
+      });
+    }
+    if (typeof fallback.model !== "string" || fallback.model.trim().length === 0) {
+      ctx.addIssue({
+        code: z10.ZodIssueCode.custom,
+        message: "modelFallbacks entries must include model",
+        path: [...pathPrefix, "modelFallbacks", index66, "model"]
+      });
+    }
+    if (fallback.config !== void 0 && !isRecord(fallback.config)) {
+      ctx.addIssue({
+        code: z10.ZodIssueCode.custom,
+        message: "modelFallbacks entry config must be an object",
+        path: [...pathPrefix, "modelFallbacks", index66, "config"]
+      });
+    } else if (isRecord(fallback.config) && fallback.config.env !== void 0) {
+      const parsed = envConfigSchema.safeParse(fallback.config.env);
+      if (!parsed.success) {
+        ctx.addIssue({
+          code: z10.ZodIssueCode.custom,
+          message: "modelFallbacks entry config.env must be a map of valid env bindings",
+          path: [...pathPrefix, "modelFallbacks", index66, "config", "env"]
+        });
+      }
+    }
+  });
+}
+var agentRuntimeTypes;
+var init_model_fallbacks = __esm({
+  "../packages/shared/src/validators/model-fallbacks.ts"() {
+    "use strict";
+    init_constants();
+    init_secret();
+    agentRuntimeTypes = new Set(AGENT_RUNTIME_TYPES);
   }
 });
 
@@ -3679,8 +3671,6 @@ var init_organizations = __esm({
         spentMonthlyCents: integer("spent_monthly_cents").notNull().default(0),
         requireBoardApprovalForNewAgents: boolean("require_board_approval_for_new_agents").notNull().default(true),
         defaultChatIssueCreationMode: text6("default_chat_issue_creation_mode").notNull().default("manual_approval"),
-        defaultChatAgentRuntimeType: text6("default_chat_agent_runtime_type"),
-        defaultChatAgentRuntimeConfig: jsonb("default_chat_agent_runtime_config").$type(),
         workspaceConfig: jsonb("workspace_config").$type(),
         brandColor: text6("brand_color"),
         createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),