@vm0/cli 9.102.1 → 9.102.3

package/{chunk-DJWH2DJQ.js → chunk-Y46LDOHW.js}

@@ -49,7 +49,7 @@ if (DSN) {
   Sentry.init({
     dsn: DSN,
     environment: process.env.SENTRY_ENVIRONMENT ?? "production",
-    release: "9.102.1",
+    release: "9.102.3",
     sendDefaultPii: false,
     tracesSampleRate: 0,
     shutdownTimeout: 500,
@@ -68,7 +68,7 @@ if (DSN) {
     }
   });
   Sentry.setContext("cli", {
-    version: "9.102.1",
+    version: "9.102.3",
     command: process.argv.slice(2).join(" ")
   });
   Sentry.setContext("runtime", {
@@ -5210,6 +5210,8 @@ var CONNECTOR_TYPES = CONNECTOR_TYPES_DEF;
 var connectorTypeSchema = z.enum(
   Object.keys(CONNECTOR_TYPES_DEF)
 );
+
+// ../../packages/core/src/contracts/connector-utils.ts
 function getConnectorEnvironmentMapping(type) {
   return CONNECTOR_TYPES[type].environmentMapping;
 }
@@ -5287,56 +5289,6 @@ function getConnectorTypeForSecretName(name) {
   }
   return null;
 }
-var connectorResponseSchema = z.object({
-  id: z.uuid().nullable(),
-  type: connectorTypeSchema,
-  authMethod: z.string(),
-  externalId: z.string().nullable(),
-  externalUsername: z.string().nullable(),
-  externalEmail: z.string().nullable(),
-  oauthScopes: z.array(z.string()).nullable(),
-  needsReconnect: z.boolean(),
-  createdAt: z.string(),
-  updatedAt: z.string()
-});
-var connectorListResponseSchema = z.object({
-  connectors: z.array(connectorResponseSchema),
-  configuredTypes: z.array(connectorTypeSchema),
-  connectorProvidedSecretNames: z.array(z.string())
-});
-var scopeDiffResponseSchema = z.object({
-  addedScopes: z.array(z.string()),
-  removedScopes: z.array(z.string()),
-  currentScopes: z.array(z.string()),
-  storedScopes: z.array(z.string())
-});
-var connectorSessionStatusSchema = z.enum([
-  "pending",
-  "complete",
-  "expired",
-  "error"
-]);
-var connectorSessionResponseSchema = z.object({
-  id: z.uuid(),
-  code: z.string(),
-  type: connectorTypeSchema,
-  status: connectorSessionStatusSchema,
-  verificationUrl: z.string(),
-  expiresIn: z.number(),
-  interval: z.number(),
-  errorMessage: z.string().nullable().optional()
-});
-var connectorSessionStatusResponseSchema = z.object({
-  status: connectorSessionStatusSchema,
-  errorMessage: z.string().nullable().optional()
-});
-var computerConnectorCreateResponseSchema = z.object({
-  id: z.uuid(),
-  ngrokToken: z.string(),
-  bridgeToken: z.string(),
-  endpointPrefix: z.string(),
-  domain: z.string()
-});
 
 // ../../packages/core/src/firewalls/agentmail.generated.ts
 var agentmailFirewall = {
@@ -27174,6 +27126,59 @@ var runnerRealtimeTokenContract = c13.router({
   }
 });
 
+// ../../packages/core/src/contracts/connector-schemas.ts
+import { z as z22 } from "zod";
+var connectorResponseSchema = z22.object({
+  id: z22.uuid().nullable(),
+  type: connectorTypeSchema,
+  authMethod: z22.string(),
+  externalId: z22.string().nullable(),
+  externalUsername: z22.string().nullable(),
+  externalEmail: z22.string().nullable(),
+  oauthScopes: z22.array(z22.string()).nullable(),
+  needsReconnect: z22.boolean(),
+  createdAt: z22.string(),
+  updatedAt: z22.string()
+});
+var connectorListResponseSchema = z22.object({
+  connectors: z22.array(connectorResponseSchema),
+  configuredTypes: z22.array(connectorTypeSchema),
+  connectorProvidedSecretNames: z22.array(z22.string())
+});
+var scopeDiffResponseSchema = z22.object({
+  addedScopes: z22.array(z22.string()),
+  removedScopes: z22.array(z22.string()),
+  currentScopes: z22.array(z22.string()),
+  storedScopes: z22.array(z22.string())
+});
+var connectorSessionStatusSchema = z22.enum([
+  "pending",
+  "complete",
+  "expired",
+  "error"
+]);
+var connectorSessionResponseSchema = z22.object({
+  id: z22.uuid(),
+  code: z22.string(),
+  type: connectorTypeSchema,
+  status: connectorSessionStatusSchema,
+  verificationUrl: z22.string(),
+  expiresIn: z22.number(),
+  interval: z22.number(),
+  errorMessage: z22.string().nullable().optional()
+});
+var connectorSessionStatusResponseSchema = z22.object({
+  status: connectorSessionStatusSchema,
+  errorMessage: z22.string().nullable().optional()
+});
+var computerConnectorCreateResponseSchema = z22.object({
+  id: z22.uuid(),
+  ngrokToken: z22.string(),
+  bridgeToken: z22.string(),
+  endpointPrefix: z22.string(),
+  domain: z22.string()
+});
+
 // ../../packages/core/src/firewall-loader.ts
 import { parse as parseYaml } from "yaml";
 var MAX_RESPONSE_SIZE = 128 * 1024;
@@ -27271,17 +27276,17 @@ function findMatchingPermissions(method, path, config, graphqlBody) {
 }
 
 // ../../packages/core/src/contracts/zero-user-preferences.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var c14 = initContract();
-var sendModeSchema = z22.enum(["enter", "cmd-enter"]);
-var userPreferencesResponseSchema = z22.object({
-  timezone: z22.string().nullable(),
-  pinnedAgentIds: z22.array(z22.string()),
+var sendModeSchema = z23.enum(["enter", "cmd-enter"]);
+var userPreferencesResponseSchema = z23.object({
+  timezone: z23.string().nullable(),
+  pinnedAgentIds: z23.array(z23.string()),
   sendMode: sendModeSchema
 });
-var updateUserPreferencesRequestSchema = z22.object({
-  timezone: z22.string().min(1).optional(),
-  pinnedAgentIds: z22.array(z22.string()).optional(),
+var updateUserPreferencesRequestSchema = z23.object({
+  timezone: z23.string().min(1).optional(),
+  pinnedAgentIds: z23.array(z23.string()).optional(),
   sendMode: sendModeSchema.optional()
 }).refine(
   (data) => {
@@ -27319,31 +27324,31 @@ var zeroUserPreferencesContract = c14.router({
 });
 
 // ../../packages/core/src/contracts/org-list.ts
-import { z as z23 } from "zod";
-var orgListItemSchema = z23.object({
-  slug: z23.string(),
-  role: z23.string()
+import { z as z24 } from "zod";
+var orgListItemSchema = z24.object({
+  slug: z24.string(),
+  role: z24.string()
 });
-var orgListResponseSchema = z23.object({
-  orgs: z23.array(orgListItemSchema),
-  active: z23.string().optional()
+var orgListResponseSchema = z24.object({
+  orgs: z24.array(orgListItemSchema),
+  active: z24.string().optional()
 });
 
 // ../../packages/core/src/contracts/onboarding.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var c15 = initContract();
-var onboardingStatusResponseSchema = z24.object({
-  needsOnboarding: z24.boolean(),
-  isAdmin: z24.boolean(),
-  hasOrg: z24.boolean(),
-  hasDefaultAgent: z24.boolean(),
-  defaultAgentId: z24.string().nullable(),
-  defaultAgentMetadata: z24.object({
-    displayName: z24.string().optional(),
-    description: z24.string().optional(),
-    sound: z24.string().optional()
+var onboardingStatusResponseSchema = z25.object({
+  needsOnboarding: z25.boolean(),
+  isAdmin: z25.boolean(),
+  hasOrg: z25.boolean(),
+  hasDefaultAgent: z25.boolean(),
+  defaultAgentId: z25.string().nullable(),
+  defaultAgentMetadata: z25.object({
+    displayName: z25.string().optional(),
+    description: z25.string().optional(),
+    sound: z25.string().optional()
   }).nullable(),
-  defaultAgentSkills: z24.array(z24.string())
+  defaultAgentSkills: z25.array(z25.string())
 });
 var onboardingStatusContract = c15.router({
   getStatus: {
@@ -27364,7 +27369,7 @@ var onboardingCompleteContract = c15.router({
     headers: authHeadersSchema,
     body: c15.noBody(),
     responses: {
-      200: z24.object({ ok: z24.boolean() }),
+      200: z25.object({ ok: z25.boolean() }),
       401: apiErrorSchema
     },
     summary: "Mark member onboarding as complete"
@@ -27375,15 +27380,15 @@ var onboardingSetupContract = c15.router({
     method: "POST",
     path: "/api/zero/onboarding/setup",
     headers: authHeadersSchema,
-    body: z24.object({
-      displayName: z24.string(),
-      workspaceName: z24.string().optional(),
-      sound: z24.string().optional(),
-      avatarUrl: z24.string().optional(),
-      selectedConnectors: z24.array(z24.string()).optional()
+    body: z25.object({
+      displayName: z25.string(),
+      workspaceName: z25.string().optional(),
+      sound: z25.string().optional(),
+      avatarUrl: z25.string().optional(),
+      selectedConnectors: z25.array(z25.string()).optional()
     }),
     responses: {
-      200: z24.object({ agentId: z24.string() }),
+      200: z25.object({ agentId: z25.string() }),
       401: apiErrorSchema,
       422: apiErrorSchema
     },
@@ -27392,15 +27397,15 @@ var onboardingSetupContract = c15.router({
 });
 
 // ../../packages/core/src/contracts/skills.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var c16 = initContract();
-var skillFrontmatterSchema = z25.object({
-  name: z25.string().optional(),
-  description: z25.string().optional()
+var skillFrontmatterSchema = z26.object({
+  name: z26.string().optional(),
+  description: z26.string().optional()
 });
-var resolvedSkillSchema = z25.object({
-  storageName: z25.string(),
-  versionHash: z25.string(),
+var resolvedSkillSchema = z26.object({
+  storageName: z26.string(),
+  versionHash: z26.string(),
   frontmatter: skillFrontmatterSchema
 });
 var skillsResolveContract = c16.router({
@@ -27408,13 +27413,13 @@ var skillsResolveContract = c16.router({
     method: "POST",
     path: "/api/skills/resolve",
     headers: authHeadersSchema,
-    body: z25.object({
-      skills: z25.array(z25.url()).min(1).max(100)
+    body: z26.object({
+      skills: z26.array(z26.url()).min(1).max(100)
     }),
     responses: {
-      200: z25.object({
-        resolved: z25.record(z25.string(), resolvedSkillSchema),
-        unresolved: z25.array(z25.string())
+      200: z26.object({
+        resolved: z26.record(z26.string(), resolvedSkillSchema),
+        unresolved: z26.array(z26.string())
       }),
       400: apiErrorSchema,
       401: apiErrorSchema
@@ -27424,38 +27429,38 @@ var skillsResolveContract = c16.router({
 });
 
 // ../../packages/core/src/contracts/zero-agents.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var c17 = initContract();
-var zeroAgentCustomSkillNameSchema = z26.string().min(2).max(64).regex(/^[a-z0-9][a-z0-9-]*[a-z0-9]$/);
-var zeroAgentResponseSchema = z26.object({
-  agentId: z26.string(),
-  ownerId: z26.string(),
-  description: z26.string().nullable(),
-  displayName: z26.string().nullable(),
-  sound: z26.string().nullable(),
-  avatarUrl: z26.string().nullable(),
+var zeroAgentCustomSkillNameSchema = z27.string().min(2).max(64).regex(/^[a-z0-9][a-z0-9-]*[a-z0-9]$/);
+var zeroAgentResponseSchema = z27.object({
+  agentId: z27.string(),
+  ownerId: z27.string(),
+  description: z27.string().nullable(),
+  displayName: z27.string().nullable(),
+  sound: z27.string().nullable(),
+  avatarUrl: z27.string().nullable(),
   firewallPolicies: firewallPoliciesSchema.nullable(),
-  customSkills: z26.array(z26.string()).default([])
+  customSkills: z27.array(z27.string()).default([])
 });
-var zeroAgentRequestSchema = z26.object({
-  description: z26.string().optional(),
-  displayName: z26.string().optional(),
-  sound: z26.string().optional(),
-  avatarUrl: z26.string().optional(),
-  customSkills: z26.array(zeroAgentCustomSkillNameSchema).optional()
+var zeroAgentRequestSchema = z27.object({
+  description: z27.string().optional(),
+  displayName: z27.string().optional(),
+  sound: z27.string().optional(),
+  avatarUrl: z27.string().optional(),
+  customSkills: z27.array(zeroAgentCustomSkillNameSchema).optional()
 });
-var zeroAgentMetadataRequestSchema = z26.object({
-  displayName: z26.string().optional(),
-  description: z26.string().optional(),
-  sound: z26.string().optional(),
-  avatarUrl: z26.string().nullable().optional()
+var zeroAgentMetadataRequestSchema = z27.object({
+  displayName: z27.string().optional(),
+  description: z27.string().optional(),
+  sound: z27.string().optional(),
+  avatarUrl: z27.string().nullable().optional()
 });
-var zeroAgentInstructionsResponseSchema = z26.object({
-  content: z26.string().nullable(),
-  filename: z26.string().nullable()
+var zeroAgentInstructionsResponseSchema = z27.object({
+  content: z27.string().nullable(),
+  filename: z27.string().nullable()
 });
-var zeroAgentInstructionsRequestSchema = z26.object({
-  content: z26.string()
+var zeroAgentInstructionsRequestSchema = z27.object({
+  content: z27.string()
 });
 var zeroAgentsMainContract = c17.router({
   create: {
@@ -27477,7 +27482,7 @@ var zeroAgentsMainContract = c17.router({
     path: "/api/zero/agents",
     headers: authHeadersSchema,
     responses: {
-      200: z26.array(zeroAgentResponseSchema),
+      200: z27.array(zeroAgentResponseSchema),
       401: apiErrorSchema,
       403: apiErrorSchema
     },
@@ -27489,7 +27494,7 @@ var zeroAgentsByIdContract = c17.router({
     method: "GET",
     path: "/api/zero/agents/:id",
     headers: authHeadersSchema,
-    pathParams: z26.object({ id: z26.string().uuid() }),
+    pathParams: z27.object({ id: z27.string().uuid() }),
     responses: {
       200: zeroAgentResponseSchema,
       401: apiErrorSchema,
@@ -27502,7 +27507,7 @@ var zeroAgentsByIdContract = c17.router({
     method: "PUT",
     path: "/api/zero/agents/:id",
     headers: authHeadersSchema,
-    pathParams: z26.object({ id: z26.string().uuid() }),
+    pathParams: z27.object({ id: z27.string().uuid() }),
     body: zeroAgentRequestSchema,
     responses: {
       200: zeroAgentResponseSchema,
@@ -27518,7 +27523,7 @@ var zeroAgentsByIdContract = c17.router({
     method: "PATCH",
     path: "/api/zero/agents/:id",
     headers: authHeadersSchema,
-    pathParams: z26.object({ id: z26.string().uuid() }),
+    pathParams: z27.object({ id: z27.string().uuid() }),
     body: zeroAgentMetadataRequestSchema,
     responses: {
       200: zeroAgentResponseSchema,
@@ -27532,7 +27537,7 @@ var zeroAgentsByIdContract = c17.router({
     method: "DELETE",
     path: "/api/zero/agents/:id",
     headers: authHeadersSchema,
-    pathParams: z26.object({ id: z26.string().uuid() }),
+    pathParams: z27.object({ id: z27.string().uuid() }),
     body: c17.noBody(),
     responses: {
       204: c17.noBody(),
@@ -27544,8 +27549,8 @@ var zeroAgentsByIdContract = c17.router({
     summary: "Delete zero agent by id"
   }
 });
-var zeroAgentFirewallPoliciesRequestSchema = z26.object({
-  agentId: z26.string().uuid(),
+var zeroAgentFirewallPoliciesRequestSchema = z27.object({
+  agentId: z27.string().uuid(),
   policies: firewallPoliciesSchema
 });
 var zeroAgentFirewallPoliciesContract = c17.router({
@@ -27569,7 +27574,7 @@ var zeroAgentInstructionsContract = c17.router({
     method: "GET",
     path: "/api/zero/agents/:id/instructions",
     headers: authHeadersSchema,
-    pathParams: z26.object({ id: z26.string().uuid() }),
+    pathParams: z27.object({ id: z27.string().uuid() }),
     responses: {
       200: zeroAgentInstructionsResponseSchema,
       401: apiErrorSchema,
@@ -27582,7 +27587,7 @@ var zeroAgentInstructionsContract = c17.router({
     method: "PUT",
     path: "/api/zero/agents/:id/instructions",
     headers: authHeadersSchema,
-    pathParams: z26.object({ id: z26.string().uuid() }),
+    pathParams: z27.object({ id: z27.string().uuid() }),
     body: zeroAgentInstructionsRequestSchema,
     responses: {
       200: zeroAgentResponseSchema,
@@ -27594,13 +27599,13 @@ var zeroAgentInstructionsContract = c17.router({
     summary: "Update zero agent instructions"
   }
 });
-var zeroAgentCustomSkillSchema = z26.object({
+var zeroAgentCustomSkillSchema = z27.object({
   name: zeroAgentCustomSkillNameSchema,
-  displayName: z26.string().max(256).nullable(),
-  description: z26.string().max(1024).nullable()
+  displayName: z27.string().max(256).nullable(),
+  description: z27.string().max(1024).nullable()
 });
-var skillFileEntrySchema = z26.object({
-  path: z26.string().min(1).max(256).refine(
+var skillFileEntrySchema = z27.object({
+  path: z27.string().min(1).max(256).refine(
     (p) => {
       return !p.startsWith("/");
     },
@@ -27613,12 +27618,12 @@ var skillFileEntrySchema = z26.object({
       message: "Path must not contain .."
     }
   ),
-  content: z26.string()
+  content: z27.string()
 });
 var SKILL_FILES_MAX_BYTES = 5 * 1024 * 1024;
 var SKILL_FILES_MAX_COUNT = 500;
-var zeroAgentSkillFilesRequestSchema = z26.object({
-  files: z26.array(skillFileEntrySchema).min(1, "At least one file is required").max(
+var zeroAgentSkillFilesRequestSchema = z27.object({
+  files: z27.array(skillFileEntrySchema).min(1, "At least one file is required").max(
     SKILL_FILES_MAX_COUNT,
     `Maximum ${SKILL_FILES_MAX_COUNT} files allowed`
   ).refine(
@@ -27640,18 +27645,18 @@ var zeroAgentSkillFilesRequestSchema = z26.object({
     { message: "Total file size must not exceed 5MB" }
   )
 });
-var skillFileMetadataSchema = z26.object({
-  path: z26.string(),
-  size: z26.number()
+var skillFileMetadataSchema = z27.object({
+  path: z27.string(),
+  size: z27.number()
 });
-var zeroAgentSkillContentResponseSchema = z26.object({
-  name: z26.string(),
-  displayName: z26.string().nullable(),
-  description: z26.string().nullable(),
-  content: z26.string().nullable(),
-  files: z26.array(skillFileMetadataSchema).nullable()
+var zeroAgentSkillContentResponseSchema = z27.object({
+  name: z27.string(),
+  displayName: z27.string().nullable(),
+  description: z27.string().nullable(),
+  content: z27.string().nullable(),
+  files: z27.array(skillFileMetadataSchema).nullable()
 });
-var zeroAgentSkillListResponseSchema = z26.array(
+var zeroAgentSkillListResponseSchema = z27.array(
   zeroAgentCustomSkillSchema
 );
 var zeroSkillsCollectionContract = c17.router({
@@ -27672,8 +27677,8 @@ var zeroSkillsCollectionContract = c17.router({
     headers: authHeadersSchema,
     body: zeroAgentSkillFilesRequestSchema.extend({
       name: zeroAgentCustomSkillNameSchema,
-      displayName: z26.string().max(256).optional(),
-      description: z26.string().max(1024).optional()
+      displayName: z27.string().max(256).optional(),
+      description: z27.string().max(1024).optional()
     }),
     responses: {
       201: zeroAgentCustomSkillSchema,
@@ -27690,7 +27695,7 @@ var zeroSkillsDetailContract = c17.router({
     method: "GET",
     path: "/api/zero/skills/:name",
     headers: authHeadersSchema,
-    pathParams: z26.object({ name: zeroAgentCustomSkillNameSchema }),
+    pathParams: z27.object({ name: zeroAgentCustomSkillNameSchema }),
     responses: {
       200: zeroAgentSkillContentResponseSchema,
       401: apiErrorSchema,
@@ -27703,7 +27708,7 @@ var zeroSkillsDetailContract = c17.router({
     method: "PUT",
     path: "/api/zero/skills/:name",
     headers: authHeadersSchema,
-    pathParams: z26.object({ name: zeroAgentCustomSkillNameSchema }),
+    pathParams: z27.object({ name: zeroAgentCustomSkillNameSchema }),
     body: zeroAgentSkillFilesRequestSchema,
     responses: {
       200: zeroAgentSkillContentResponseSchema,
@@ -27717,7 +27722,7 @@ var zeroSkillsDetailContract = c17.router({
     method: "DELETE",
     path: "/api/zero/skills/:name",
     headers: authHeadersSchema,
-    pathParams: z26.object({ name: zeroAgentCustomSkillNameSchema }),
+    pathParams: z27.object({ name: zeroAgentCustomSkillNameSchema }),
     body: c17.noBody(),
     responses: {
       204: c17.noBody(),
@@ -27728,37 +27733,37 @@ var zeroSkillsDetailContract = c17.router({
     summary: "Delete custom skill from the organization"
   }
 });
-var firewallAccessRequestStatusSchema = z26.enum([
+var firewallAccessRequestStatusSchema = z27.enum([
   "pending",
   "approved",
   "rejected"
 ]);
-var firewallAccessRequestResponseSchema = z26.object({
-  id: z26.string().uuid(),
-  agentId: z26.string().uuid(),
-  firewallRef: z26.string(),
-  permission: z26.string(),
-  method: z26.string().nullable(),
-  path: z26.string().nullable(),
-  reason: z26.string().nullable(),
+var firewallAccessRequestResponseSchema = z27.object({
+  id: z27.string().uuid(),
+  agentId: z27.string().uuid(),
+  firewallRef: z27.string(),
+  permission: z27.string(),
+  method: z27.string().nullable(),
+  path: z27.string().nullable(),
+  reason: z27.string().nullable(),
   status: firewallAccessRequestStatusSchema,
-  requesterUserId: z26.string(),
-  requesterName: z26.string().nullable(),
-  resolvedBy: z26.string().nullable(),
-  resolvedAt: z26.string().nullable(),
-  createdAt: z26.string()
-});
-var createFirewallAccessRequestSchema = z26.object({
-  agentId: z26.string().uuid(),
-  firewallRef: z26.string(),
-  permission: z26.string(),
-  method: z26.string().optional(),
-  path: z26.string().optional(),
-  reason: z26.string().optional()
-});
-var resolveFirewallAccessRequestSchema = z26.object({
-  requestId: z26.string().uuid(),
-  action: z26.enum(["approve", "reject"])
+  requesterUserId: z27.string(),
+  requesterName: z27.string().nullable(),
+  resolvedBy: z27.string().nullable(),
+  resolvedAt: z27.string().nullable(),
+  createdAt: z27.string()
+});
+var createFirewallAccessRequestSchema = z27.object({
+  agentId: z27.string().uuid(),
+  firewallRef: z27.string(),
+  permission: z27.string(),
+  method: z27.string().optional(),
+  path: z27.string().optional(),
+  reason: z27.string().optional()
+});
+var resolveFirewallAccessRequestSchema = z27.object({
+  requestId: z27.string().uuid(),
+  action: z27.enum(["approve", "reject"])
 });
 var firewallAccessRequestsCreateContract = c17.router({
   create: {
@@ -27776,9 +27781,9 @@ var firewallAccessRequestsCreateContract = c17.router({
     summary: "Create firewall access request"
   }
 });
-var firewallAccessRequestsListQuerySchema = z26.object({
-  agentId: z26.string(),
-  status: z26.string().optional()
+var firewallAccessRequestsListQuerySchema = z27.object({
+  agentId: z27.string(),
+  status: z27.string().optional()
 });
 var firewallAccessRequestsListContract = c17.router({
   list: {
@@ -27787,7 +27792,7 @@ var firewallAccessRequestsListContract = c17.router({
     headers: authHeadersSchema,
     query: firewallAccessRequestsListQuerySchema,
     responses: {
-      200: z26.array(firewallAccessRequestResponseSchema),
+      200: z27.array(firewallAccessRequestResponseSchema),
       400: apiErrorSchema,
       401: apiErrorSchema,
       403: apiErrorSchema
@@ -27813,17 +27818,17 @@ var firewallAccessRequestsResolveContract = c17.router({
 });
 
 // ../../packages/core/src/contracts/user-connectors.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var c18 = initContract();
-var userConnectorEnabledTypesSchema = z27.object({
-  enabledTypes: z27.array(z27.string())
+var userConnectorEnabledTypesSchema = z28.object({
+  enabledTypes: z28.array(z28.string())
 });
 var zeroUserConnectorsContract = c18.router({
   get: {
     method: "GET",
     path: "/api/zero/agents/:id/user-connectors",
     headers: authHeadersSchema,
-    pathParams: z27.object({ id: z27.string().uuid() }),
+    pathParams: z28.object({ id: z28.string().uuid() }),
     responses: {
       200: userConnectorEnabledTypesSchema,
       401: apiErrorSchema,
@@ -27836,7 +27841,7 @@ var zeroUserConnectorsContract = c18.router({
     method: "PUT",
     path: "/api/zero/agents/:id/user-connectors",
     headers: authHeadersSchema,
-    pathParams: z27.object({ id: z27.string().uuid() }),
+    pathParams: z28.object({ id: z28.string().uuid() }),
     body: userConnectorEnabledTypesSchema,
     responses: {
       200: userConnectorEnabledTypesSchema,
@@ -27850,7 +27855,7 @@ var zeroUserConnectorsContract = c18.router({
 });
 
 // ../../packages/core/src/contracts/zero-connectors.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 var c19 = initContract();
 var zeroConnectorsMainContract = c19.router({
   list: {
@@ -27870,7 +27875,7 @@ var zeroConnectorsByTypeContract = c19.router({
     method: "GET",
     path: "/api/zero/connectors/:type",
     headers: authHeadersSchema,
-    pathParams: z28.object({ type: connectorTypeSchema }),
+    pathParams: z29.object({ type: connectorTypeSchema }),
     responses: {
       200: connectorResponseSchema,
       401: apiErrorSchema,
@@ -27882,7 +27887,7 @@ var zeroConnectorsByTypeContract = c19.router({
     method: "DELETE",
     path: "/api/zero/connectors/:type",
     headers: authHeadersSchema,
-    pathParams: z28.object({ type: connectorTypeSchema }),
+    pathParams: z29.object({ type: connectorTypeSchema }),
     responses: {
       204: c19.noBody(),
       401: apiErrorSchema,
@@ -27896,7 +27901,7 @@ var zeroConnectorScopeDiffContract = c19.router({
     method: "GET",
     path: "/api/zero/connectors/:type/scope-diff",
     headers: authHeadersSchema,
-    pathParams: z28.object({ type: connectorTypeSchema }),
+    pathParams: z29.object({ type: connectorTypeSchema }),
     responses: {
       200: scopeDiffResponseSchema,
       401: apiErrorSchema,
@@ -27905,22 +27910,22 @@ var zeroConnectorScopeDiffContract = c19.router({
     summary: "Get scope diff for a connector"
   }
 });
-var connectorSearchAuthMethodSchema = z28.enum(["oauth", "api-token"]);
-var connectorSearchItemSchema = z28.object({
-  id: z28.string(),
-  label: z28.string(),
-  description: z28.string(),
-  authMethods: z28.array(connectorSearchAuthMethodSchema)
+var connectorSearchAuthMethodSchema = z29.enum(["oauth", "api-token"]);
+var connectorSearchItemSchema = z29.object({
+  id: z29.string(),
+  label: z29.string(),
+  description: z29.string(),
+  authMethods: z29.array(connectorSearchAuthMethodSchema)
 });
-var connectorSearchResponseSchema = z28.object({
-  connectors: z28.array(connectorSearchItemSchema)
+var connectorSearchResponseSchema = z29.object({
+  connectors: z29.array(connectorSearchItemSchema)
 });
 var zeroConnectorsSearchContract = c19.router({
   search: {
     method: "GET",
     path: "/api/zero/connectors/search",
     headers: authHeadersSchema,
-    query: z28.object({ keyword: z28.string().optional() }),
+    query: z29.object({ keyword: z29.string().optional() }),
     responses: {
       200: connectorSearchResponseSchema,
       401: apiErrorSchema
@@ -27933,8 +27938,8 @@ var zeroConnectorSessionsContract = c19.router({
     method: "POST",
     path: "/api/zero/connectors/:type/sessions",
     headers: authHeadersSchema,
-    pathParams: z28.object({ type: connectorTypeSchema }),
-    body: z28.object({}).optional(),
+    pathParams: z29.object({ type: connectorTypeSchema }),
+    body: z29.object({}).optional(),
     responses: {
       200: connectorSessionResponseSchema,
       400: apiErrorSchema,
@@ -27948,9 +27953,9 @@ var zeroConnectorSessionByIdContract = c19.router({
     method: "GET",
     path: "/api/zero/connectors/:type/sessions/:sessionId",
     headers: authHeadersSchema,
-    pathParams: z28.object({
+    pathParams: z29.object({
       type: connectorTypeSchema,
-      sessionId: z28.uuid()
+      sessionId: z29.uuid()
     }),
     responses: {
       200: connectorSessionStatusResponseSchema,
@@ -27966,7 +27971,7 @@ var zeroComputerConnectorContract = c19.router({
     method: "POST",
     path: "/api/zero/connectors/computer",
     headers: authHeadersSchema,
-    body: z28.object({}).optional(),
+    body: z29.object({}).optional(),
     responses: {
       200: computerConnectorCreateResponseSchema,
       400: apiErrorSchema,
@@ -28000,7 +28005,7 @@ var zeroComputerConnectorContract = c19.router({
 });
 
 // ../../packages/core/src/contracts/zero-org.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var c20 = initContract();
 var zeroOrgContract = c20.router({
   get: {
@@ -28036,7 +28041,7 @@ var zeroOrgLeaveContract = c20.router({
     method: "POST",
     path: "/api/zero/org/leave",
     headers: authHeadersSchema,
-    body: z29.object({}),
+    body: z30.object({}),
     responses: {
       200: orgMessageResponseSchema,
       401: apiErrorSchema,
@@ -28051,7 +28056,7 @@ var zeroOrgDeleteContract = c20.router({
     method: "POST",
     path: "/api/zero/org/delete",
     headers: authHeadersSchema,
-    body: z29.object({ slug: z29.string() }),
+    body: z30.object({ slug: z30.string() }),
     responses: {
       200: orgMessageResponseSchema,
       400: apiErrorSchema,
@@ -28243,15 +28248,15 @@ var zeroOrgDomainsContract = c23.router({
 });
 
 // ../../packages/core/src/contracts/zero-composes.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 var c24 = initContract();
 var zeroComposesMainContract = c24.router({
   getByName: {
     method: "GET",
     path: "/api/zero/composes",
     headers: authHeadersSchema,
-    query: z30.object({
-      name: z30.string().min(1, "Missing name query parameter")
+    query: z31.object({
+      name: z31.string().min(1, "Missing name query parameter")
     }),
     responses: {
       200: composeResponseSchema,
@@ -28267,8 +28272,8 @@ var zeroComposesByIdContract = c24.router({
     method: "GET",
     path: "/api/zero/composes/:id",
     headers: authHeadersSchema,
-    pathParams: z30.object({
-      id: z30.string().min(1, "Compose ID is required")
+    pathParams: z31.object({
+      id: z31.string().min(1, "Compose ID is required")
     }),
     responses: {
       200: composeResponseSchema,
@@ -28282,8 +28287,8 @@ var zeroComposesByIdContract = c24.router({
     method: "DELETE",
     path: "/api/zero/composes/:id",
     headers: authHeadersSchema,
-    pathParams: z30.object({
-      id: z30.string().uuid("Compose ID is required")
+    pathParams: z31.object({
+      id: z31.string().uuid("Compose ID is required")
     }),
     body: c24.noBody(),
     responses: {
@@ -28301,10 +28306,10 @@ var zeroComposesListContract = c24.router({
     method: "GET",
     path: "/api/zero/composes/list",
     headers: authHeadersSchema,
-    query: z30.object({}),
+    query: z31.object({}),
     responses: {
-      200: z30.object({
-        composes: z30.array(composeListItemSchema)
+      200: z31.object({
+        composes: z31.array(composeListItemSchema)
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -28315,7 +28320,7 @@ var zeroComposesListContract = c24.router({
 });
 
 // ../../packages/core/src/contracts/zero-runs.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 var zeroRunRequestSchema = unifiedRunRequestSchema.omit({
   triggerSource: true,
   memoryName: true,
@@ -28328,8 +28333,8 @@ var zeroRunRequestSchema = unifiedRunRequestSchema.omit({
   agentComposeId: true,
   appendSystemPrompt: true
 }).extend({
-  agentId: z31.string().optional(),
-  modelProvider: z31.string().optional()
+  agentId: z32.string().optional(),
+  modelProvider: z32.string().optional()
 });
 var c25 = initContract();
 var zeroRunsMainContract = c25.router({
@@ -28353,8 +28358,8 @@ var zeroRunsByIdContract = c25.router({
     method: "GET",
     path: "/api/zero/runs/:id",
     headers: authHeadersSchema,
-    pathParams: z31.object({
-      id: z31.string().min(1, "Run ID is required")
+    pathParams: z32.object({
+      id: z32.string().min(1, "Run ID is required")
     }),
     responses: {
       200: getRunResponseSchema,
@@ -28370,10 +28375,10 @@ var zeroRunsCancelContract = c25.router({
     method: "POST",
     path: "/api/zero/runs/:id/cancel",
     headers: authHeadersSchema,
-    pathParams: z31.object({
-      id: z31.string().min(1, "Run ID is required")
+    pathParams: z32.object({
+      id: z32.string().min(1, "Run ID is required")
     }),
-    body: z31.undefined(),
+    body: z32.undefined(),
     responses: {
       200: cancelRunResponseSchema,
       400: apiErrorSchema,
@@ -28402,13 +28407,13 @@ var zeroRunAgentEventsContract = c25.router({
     method: "GET",
     path: "/api/zero/runs/:id/telemetry/agent",
     headers: authHeadersSchema,
-    pathParams: z31.object({
-      id: z31.string().min(1, "Run ID is required")
+    pathParams: z32.object({
+      id: z32.string().min(1, "Run ID is required")
     }),
-    query: z31.object({
-      since: z31.coerce.number().optional(),
-      limit: z31.coerce.number().min(1).max(100).default(5),
-      order: z31.enum(["asc", "desc"]).default("desc")
+    query: z32.object({
+      since: z32.coerce.number().optional(),
+      limit: z32.coerce.number().min(1).max(100).default(5),
+      order: z32.enum(["asc", "desc"]).default("desc")
     }),
     responses: {
       200: agentEventsResponseSchema,
@@ -28418,41 +28423,41 @@ var zeroRunAgentEventsContract = c25.router({
     summary: "Get agent events with pagination (zero proxy)"
   }
 });
-var runContextVolumeSchema = z31.object({
-  name: z31.string(),
-  mountPath: z31.string(),
-  vasStorageName: z31.string(),
-  vasVersionId: z31.string()
-});
-var runContextArtifactSchema = z31.object({
-  mountPath: z31.string(),
-  vasStorageName: z31.string(),
-  vasVersionId: z31.string()
-});
-var runContextFirewallSchema = z31.object({
-  name: z31.string(),
-  ref: z31.string(),
-  apis: z31.array(
-    z31.object({
-      base: z31.string(),
-      permissions: z31.array(
-        z31.object({
-          name: z31.string(),
-          description: z31.string().optional(),
-          rules: z31.array(z31.string())
+var runContextVolumeSchema = z32.object({
+  name: z32.string(),
+  mountPath: z32.string(),
+  vasStorageName: z32.string(),
+  vasVersionId: z32.string()
+});
+var runContextArtifactSchema = z32.object({
+  mountPath: z32.string(),
+  vasStorageName: z32.string(),
+  vasVersionId: z32.string()
+});
+var runContextFirewallSchema = z32.object({
+  name: z32.string(),
+  ref: z32.string(),
+  apis: z32.array(
+    z32.object({
+      base: z32.string(),
+      permissions: z32.array(
+        z32.object({
+          name: z32.string(),
+          description: z32.string().optional(),
+          rules: z32.array(z32.string())
         })
       ).optional()
     })
   )
 });
-var runContextResponseSchema = z31.object({
-  prompt: z31.string(),
-  appendSystemPrompt: z31.string().nullable(),
-  secretNames: z31.array(z31.string()),
-  vars: z31.record(z31.string(), z31.string()).nullable(),
-  environment: z31.record(z31.string(), z31.string()),
-  firewalls: z31.array(runContextFirewallSchema),
-  volumes: z31.array(runContextVolumeSchema),
+var runContextResponseSchema = z32.object({
+  prompt: z32.string(),
+  appendSystemPrompt: z32.string().nullable(),
+  secretNames: z32.array(z32.string()),
+  vars: z32.record(z32.string(), z32.string()).nullable(),
+  environment: z32.record(z32.string(), z32.string()),
+  firewalls: z32.array(runContextFirewallSchema),
+  volumes: z32.array(runContextVolumeSchema),
   artifact: runContextArtifactSchema.nullable(),
   memory: runContextArtifactSchema.nullable()
 });
@@ -28461,8 +28466,8 @@ var zeroRunContextContract = c25.router({
     method: "GET",
     path: "/api/zero/runs/:id/context",
     headers: authHeadersSchema,
-    pathParams: z31.object({
-      id: z31.string().min(1, "Run ID is required")
+    pathParams: z32.object({
+      id: z32.string().min(1, "Run ID is required")
     }),
     responses: {
       200: runContextResponseSchema,
@@ -28478,13 +28483,13 @@ var zeroRunNetworkLogsContract = c25.router({
     method: "GET",
     path: "/api/zero/runs/:id/network",
     headers: authHeadersSchema,
-    pathParams: z31.object({
-      id: z31.string().min(1, "Run ID is required")
+    pathParams: z32.object({
+      id: z32.string().min(1, "Run ID is required")
     }),
-    query: z31.object({
-      since: z31.coerce.number().optional(),
-      limit: z31.coerce.number().min(1).max(500).default(500),
-      order: z31.enum(["asc", "desc"]).default("asc")
+    query: z32.object({
+      since: z32.coerce.number().optional(),
+      limit: z32.coerce.number().min(1).max(500).default(500),
+      order: z32.enum(["asc", "desc"]).default("asc")
     }),
     responses: {
       200: networkLogsResponseSchema,
@@ -28500,14 +28505,14 @@ var zeroLogsSearchContract = c25.router({
     method: "GET",
     path: "/api/zero/logs/search",
     headers: authHeadersSchema,
-    query: z31.object({
-      keyword: z31.string().min(1),
-      agent: z31.string().optional(),
-      runId: z31.string().optional(),
-      since: z31.coerce.number().optional(),
-      limit: z31.coerce.number().min(1).max(50).default(20),
-      before: z31.coerce.number().min(0).max(10).default(0),
-      after: z31.coerce.number().min(0).max(10).default(0)
+    query: z32.object({
+      keyword: z32.string().min(1),
+      agent: z32.string().optional(),
+      runId: z32.string().optional(),
+      since: z32.coerce.number().optional(),
+      limit: z32.coerce.number().min(1).max(50).default(20),
+      before: z32.coerce.number().min(0).max(10).default(0),
+      after: z32.coerce.number().min(0).max(10).default(0)
     }),
     responses: {
       200: logsSearchResponseSchema,
@@ -28519,52 +28524,52 @@ var zeroLogsSearchContract = c25.router({
 });
 
 // ../../packages/core/src/contracts/zero-schedules.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 var c26 = initContract();
-var scheduleResponseSchema = z32.object({
-  id: z32.string().uuid(),
-  agentId: z32.string().uuid(),
-  displayName: z32.string().nullable(),
-  userId: z32.string(),
-  name: z32.string(),
-  triggerType: z32.enum(["cron", "once", "loop"]),
-  cronExpression: z32.string().nullable(),
-  atTime: z32.string().nullable(),
-  intervalSeconds: z32.number().nullable(),
-  timezone: z32.string(),
-  prompt: z32.string(),
-  description: z32.string().nullable(),
-  appendSystemPrompt: z32.string().nullable(),
-  vars: z32.record(z32.string(), z32.string()).nullable(),
-  secretNames: z32.array(z32.string()).nullable(),
-  volumeVersions: z32.record(z32.string(), z32.string()).nullable(),
-  enabled: z32.boolean(),
-  nextRunAt: z32.string().nullable(),
-  lastRunAt: z32.string().nullable(),
-  retryStartedAt: z32.string().nullable(),
-  consecutiveFailures: z32.number(),
-  createdAt: z32.string(),
-  updatedAt: z32.string()
-});
-var scheduleListResponseSchema = z32.object({
-  schedules: z32.array(scheduleResponseSchema)
-});
-var deployScheduleResponseSchema = z32.object({
+var scheduleResponseSchema = z33.object({
+  id: z33.string().uuid(),
+  agentId: z33.string().uuid(),
+  displayName: z33.string().nullable(),
+  userId: z33.string(),
+  name: z33.string(),
+  triggerType: z33.enum(["cron", "once", "loop"]),
+  cronExpression: z33.string().nullable(),
+  atTime: z33.string().nullable(),
+  intervalSeconds: z33.number().nullable(),
+  timezone: z33.string(),
+  prompt: z33.string(),
+  description: z33.string().nullable(),
+  appendSystemPrompt: z33.string().nullable(),
+  vars: z33.record(z33.string(), z33.string()).nullable(),
+  secretNames: z33.array(z33.string()).nullable(),
+  volumeVersions: z33.record(z33.string(), z33.string()).nullable(),
+  enabled: z33.boolean(),
+  nextRunAt: z33.string().nullable(),
+  lastRunAt: z33.string().nullable(),
+  retryStartedAt: z33.string().nullable(),
+  consecutiveFailures: z33.number(),
+  createdAt: z33.string(),
+  updatedAt: z33.string()
+});
+var scheduleListResponseSchema = z33.object({
+  schedules: z33.array(scheduleResponseSchema)
+});
+var deployScheduleResponseSchema = z33.object({
   schedule: scheduleResponseSchema,
-  created: z32.boolean()
-});
-var zeroDeployScheduleRequestSchema = z32.object({
-  name: z32.string().min(1).max(64, "Schedule name max 64 chars"),
-  cronExpression: z32.string().optional(),
-  atTime: z32.string().optional(),
-  intervalSeconds: z32.number().int().min(0).optional(),
-  timezone: z32.string().default("UTC"),
-  prompt: z32.string().min(1, "Prompt required"),
-  description: z32.string().optional(),
-  appendSystemPrompt: z32.string().optional(),
-  volumeVersions: z32.record(z32.string(), z32.string()).optional(),
-  agentId: z32.string().uuid("Invalid agent ID"),
-  enabled: z32.boolean().optional()
+  created: z33.boolean()
+});
+var zeroDeployScheduleRequestSchema = z33.object({
+  name: z33.string().min(1).max(64, "Schedule name max 64 chars"),
+  cronExpression: z33.string().optional(),
+  atTime: z33.string().optional(),
+  intervalSeconds: z33.number().int().min(0).optional(),
+  timezone: z33.string().default("UTC"),
+  prompt: z33.string().min(1, "Prompt required"),
+  description: z33.string().optional(),
+  appendSystemPrompt: z33.string().optional(),
+  volumeVersions: z33.record(z33.string(), z33.string()).optional(),
+  agentId: z33.string().uuid("Invalid agent ID"),
+  enabled: z33.boolean().optional()
 }).refine(
   (data) => {
     const triggers = [
@@ -28613,11 +28618,11 @@ var zeroSchedulesByNameContract = c26.router({
     method: "DELETE",
     path: "/api/zero/schedules/:name",
     headers: authHeadersSchema,
-    pathParams: z32.object({
-      name: z32.string().min(1, "Schedule name required")
+    pathParams: z33.object({
+      name: z33.string().min(1, "Schedule name required")
     }),
-    query: z32.object({
-      agentId: z32.string().uuid("Invalid agent ID")
+    query: z33.object({
+      agentId: z33.string().uuid("Invalid agent ID")
     }),
     responses: {
       204: c26.noBody(),
@@ -28633,11 +28638,11 @@ var zeroSchedulesEnableContract = c26.router({
     method: "POST",
     path: "/api/zero/schedules/:name/enable",
     headers: authHeadersSchema,
-    pathParams: z32.object({
-      name: z32.string().min(1, "Schedule name required")
+    pathParams: z33.object({
+      name: z33.string().min(1, "Schedule name required")
     }),
-    body: z32.object({
-      agentId: z32.string().uuid("Invalid agent ID")
+    body: z33.object({
+      agentId: z33.string().uuid("Invalid agent ID")
     }),
     responses: {
       200: scheduleResponseSchema,
@@ -28652,11 +28657,11 @@ var zeroSchedulesEnableContract = c26.router({
     method: "POST",
     path: "/api/zero/schedules/:name/disable",
     headers: authHeadersSchema,
-    pathParams: z32.object({
-      name: z32.string().min(1, "Schedule name required")
+    pathParams: z33.object({
+      name: z33.string().min(1, "Schedule name required")
     }),
-    body: z32.object({
-      agentId: z32.string().uuid("Invalid agent ID")
+    body: z33.object({
+      agentId: z33.string().uuid("Invalid agent ID")
     }),
     responses: {
       200: scheduleResponseSchema,
@@ -28673,11 +28678,11 @@ var zeroScheduleRunContract = c26.router({
     method: "POST",
     path: "/api/zero/schedules/run",
     headers: authHeadersSchema,
-    body: z32.object({
-      scheduleId: z32.string().uuid("Invalid schedule ID")
+    body: z33.object({
+      scheduleId: z33.string().uuid("Invalid schedule ID")
     }),
     responses: {
-      201: z32.object({ runId: z32.string() }),
+      201: z33.object({ runId: z33.string() }),
       400: apiErrorSchema,
       401: apiErrorSchema,
       404: apiErrorSchema,
@@ -28688,7 +28693,7 @@ var zeroScheduleRunContract = c26.router({
 });
 
 // ../../packages/core/src/contracts/zero-model-providers.ts
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 var c27 = initContract();
 var zeroModelProvidersMainContract = c27.router({
   list: {
@@ -28723,7 +28728,7 @@ var zeroModelProvidersByTypeContract = c27.router({
     method: "DELETE",
     path: "/api/zero/model-providers/:type",
     headers: authHeadersSchema,
-    pathParams: z33.object({
+    pathParams: z34.object({
       type: modelProviderTypeSchema
     }),
     responses: {
@@ -28741,10 +28746,10 @@ var zeroModelProvidersDefaultContract = c27.router({
     method: "POST",
     path: "/api/zero/model-providers/:type/default",
     headers: authHeadersSchema,
-    pathParams: z33.object({
+    pathParams: z34.object({
       type: modelProviderTypeSchema
     }),
-    body: z33.undefined(),
+    body: z34.undefined(),
     responses: {
       200: modelProviderResponseSchema,
       401: apiErrorSchema,
@@ -28760,7 +28765,7 @@ var zeroModelProvidersUpdateModelContract = c27.router({
     method: "PATCH",
     path: "/api/zero/model-providers/:type/model",
     headers: authHeadersSchema,
-    pathParams: z33.object({
+    pathParams: z34.object({
       type: modelProviderTypeSchema
     }),
     body: updateModelRequestSchema,
@@ -28776,7 +28781,7 @@ var zeroModelProvidersUpdateModelContract = c27.router({
 });
 
 // ../../packages/core/src/contracts/zero-secrets.ts
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 var c28 = initContract();
 var zeroSecretsContract = c28.router({
   list: {
@@ -28810,7 +28815,7 @@ var zeroSecretsByNameContract = c28.router({
     method: "DELETE",
     path: "/api/zero/secrets/:name",
     headers: authHeadersSchema,
-    pathParams: z34.object({
+    pathParams: z35.object({
       name: secretNameSchema
     }),
     responses: {
@@ -28854,7 +28859,7 @@ var zeroVariablesByNameContract = c28.router({
     method: "DELETE",
     path: "/api/zero/variables/:name",
     headers: authHeadersSchema,
-    pathParams: z34.object({
+    pathParams: z35.object({
       name: variableNameSchema
     }),
     responses: {
@@ -28868,25 +28873,25 @@ var zeroVariablesByNameContract = c28.router({
 });
 
 // ../../packages/core/src/contracts/zero-sessions.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 var c29 = initContract();
-var zeroSessionResponseSchema = z35.object({
-  id: z35.string(),
-  agentId: z35.string(),
-  conversationId: z35.string().nullable(),
-  artifactName: z35.string().nullable(),
-  secretNames: z35.array(z35.string()).nullable(),
-  chatMessages: z35.array(storedChatMessageSchema2).optional(),
-  createdAt: z35.string(),
-  updatedAt: z35.string()
+var zeroSessionResponseSchema = z36.object({
+  id: z36.string(),
+  agentId: z36.string(),
+  conversationId: z36.string().nullable(),
+  artifactName: z36.string().nullable(),
+  secretNames: z36.array(z36.string()).nullable(),
+  chatMessages: z36.array(storedChatMessageSchema2).optional(),
+  createdAt: z36.string(),
+  updatedAt: z36.string()
 });
 var zeroSessionsByIdContract = c29.router({
   getById: {
     method: "GET",
     path: "/api/zero/sessions/:id",
     headers: authHeadersSchema,
-    pathParams: z35.object({
-      id: z35.string().min(1, "Session ID is required")
+    pathParams: z36.object({
+      id: z36.string().min(1, "Session ID is required")
     }),
     responses: {
       200: zeroSessionResponseSchema,
@@ -28899,18 +28904,18 @@ var zeroSessionsByIdContract = c29.router({
 });
 
 // ../../packages/core/src/contracts/integrations.ts
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 var c30 = initContract();
-var sendSlackMessageBodySchema = z36.object({
-  channel: z36.string().min(1, "Channel ID is required"),
-  text: z36.string().optional(),
-  threadTs: z36.string().optional(),
-  blocks: z36.array(z36.object({ type: z36.string() }).passthrough()).optional()
+var sendSlackMessageBodySchema = z37.object({
+  channel: z37.string().min(1, "Channel ID is required"),
+  text: z37.string().optional(),
+  threadTs: z37.string().optional(),
+  blocks: z37.array(z37.object({ type: z37.string() }).passthrough()).optional()
 });
-var sendSlackMessageResponseSchema = z36.object({
-  ok: z36.literal(true),
-  ts: z36.string().optional(),
-  channel: z36.string().optional()
+var sendSlackMessageResponseSchema = z37.object({
+  ok: z37.literal(true),
+  ts: z37.string().optional(),
+  channel: z37.string().optional()
 });
 var integrationsSlackMessageContract = c30.router({
   sendMessage: {
@@ -28928,13 +28933,13 @@ var integrationsSlackMessageContract = c30.router({
     summary: "Send a Slack message via org bot token"
   }
 });
-var slackUploadInitBodySchema = z36.object({
-  filename: z36.string().min(1, "Filename is required"),
-  length: z36.number().int().positive("File length must be a positive integer")
+var slackUploadInitBodySchema = z37.object({
+  filename: z37.string().min(1, "Filename is required"),
+  length: z37.number().int().positive("File length must be a positive integer")
 });
-var slackUploadInitResponseSchema = z36.object({
-  uploadUrl: z36.string(),
-  fileId: z36.string()
+var slackUploadInitResponseSchema = z37.object({
+  uploadUrl: z37.string(),
+  fileId: z37.string()
 });
 var integrationsSlackUploadInitContract = c30.router({
   init: {
@@ -28952,16 +28957,16 @@ var integrationsSlackUploadInitContract = c30.router({
     summary: "Get a pre-signed Slack upload URL via org bot token"
   }
 });
-var slackUploadCompleteBodySchema = z36.object({
-  fileId: z36.string().min(1, "File ID is required"),
-  channel: z36.string().min(1, "Channel ID is required"),
-  threadTs: z36.string().optional(),
-  title: z36.string().optional(),
-  initialComment: z36.string().optional()
+var slackUploadCompleteBodySchema = z37.object({
+  fileId: z37.string().min(1, "File ID is required"),
+  channel: z37.string().min(1, "Channel ID is required"),
+  threadTs: z37.string().optional(),
+  title: z37.string().optional(),
+  initialComment: z37.string().optional()
 });
-var slackUploadCompleteResponseSchema = z36.object({
-  fileId: z36.string(),
-  permalink: z36.string()
+var slackUploadCompleteResponseSchema = z37.object({
+  fileId: z37.string(),
+  permalink: z37.string()
 });
 var integrationsSlackUploadCompleteContract = c30.router({
   complete: {
@@ -28981,45 +28986,45 @@ var integrationsSlackUploadCompleteContract = c30.router({
 });
 
 // ../../packages/core/src/contracts/zero-billing.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 var c31 = initContract();
-var autoRechargeSchema = z37.object({
-  enabled: z37.boolean(),
-  threshold: z37.number().nullable(),
-  amount: z37.number().nullable()
-});
-var creditExpirySchema = z37.object({
-  expiringNextCycle: z37.number(),
-  nextExpiryDate: z37.string().nullable()
-});
-var billingStatusResponseSchema = z37.object({
-  tier: z37.string(),
-  credits: z37.number(),
-  subscriptionStatus: z37.string().nullable(),
-  currentPeriodEnd: z37.string().nullable(),
-  cancelAtPeriodEnd: z37.boolean(),
-  hasSubscription: z37.boolean(),
+var autoRechargeSchema = z38.object({
+  enabled: z38.boolean(),
+  threshold: z38.number().nullable(),
+  amount: z38.number().nullable()
+});
+var creditExpirySchema = z38.object({
+  expiringNextCycle: z38.number(),
+  nextExpiryDate: z38.string().nullable()
+});
+var billingStatusResponseSchema = z38.object({
+  tier: z38.string(),
+  credits: z38.number(),
+  subscriptionStatus: z38.string().nullable(),
+  currentPeriodEnd: z38.string().nullable(),
+  cancelAtPeriodEnd: z38.boolean(),
+  hasSubscription: z38.boolean(),
   autoRecharge: autoRechargeSchema,
   creditExpiry: creditExpirySchema
 });
-var checkoutResponseSchema = z37.object({
-  url: z37.string()
+var checkoutResponseSchema = z38.object({
+  url: z38.string()
 });
-var portalResponseSchema = z37.object({
-  url: z37.string()
+var portalResponseSchema = z38.object({
+  url: z38.string()
 });
-var checkoutRequestSchema = z37.object({
-  tier: z37.enum(["pro", "team"]),
-  successUrl: z37.string().url(),
-  cancelUrl: z37.string().url()
+var checkoutRequestSchema = z38.object({
+  tier: z38.enum(["pro", "team"]),
+  successUrl: z38.string().url(),
+  cancelUrl: z38.string().url()
 });
-var portalRequestSchema = z37.object({
-  returnUrl: z37.string().min(1)
+var portalRequestSchema = z38.object({
+  returnUrl: z38.string().min(1)
 });
-var autoRechargeUpdateRequestSchema = z37.object({
-  enabled: z37.boolean(),
-  threshold: z37.number().int().positive().optional(),
-  amount: z37.number().int().min(1e3).optional()
+var autoRechargeUpdateRequestSchema = z38.object({
+  enabled: z38.boolean(),
+  threshold: z38.number().int().positive().optional(),
+  amount: z38.number().int().min(1e3).optional()
 });
 var zeroBillingStatusContract = c31.router({
   get: {
@@ -29093,16 +29098,16 @@ var zeroBillingAutoRechargeContract = c31.router({
     summary: "Update auto-recharge configuration"
   }
 });
-var invoiceSchema = z37.object({
-  id: z37.string(),
-  number: z37.string().nullable(),
-  date: z37.number(),
-  amount: z37.number(),
-  status: z37.string().nullable(),
-  hostedInvoiceUrl: z37.string().nullable()
+var invoiceSchema = z38.object({
+  id: z38.string(),
+  number: z38.string().nullable(),
+  date: z38.number(),
+  amount: z38.number(),
+  status: z38.string().nullable(),
+  hostedInvoiceUrl: z38.string().nullable()
 });
-var billingInvoicesResponseSchema = z37.object({
-  invoices: z37.array(invoiceSchema)
+var billingInvoicesResponseSchema = z38.object({
+  invoices: z38.array(invoiceSchema)
 });
 var zeroBillingInvoicesContract = c31.router({
   get: {
@@ -29117,12 +29122,12 @@ var zeroBillingInvoicesContract = c31.router({
     summary: "Get invoices for current org"
   }
 });
-var downgradeRequestSchema = z37.object({
-  targetTier: z37.enum(["free", "pro"])
+var downgradeRequestSchema = z38.object({
+  targetTier: z38.enum(["free", "pro"])
 });
-var downgradeResponseSchema = z37.object({
-  success: z37.boolean(),
-  effectiveDate: z37.string().nullable()
+var downgradeResponseSchema = z38.object({
+  success: z38.boolean(),
+  effectiveDate: z38.string().nullable()
 });
 var zeroBillingDowngradeContract = c31.router({
   create: {
@@ -29143,24 +29148,24 @@ var zeroBillingDowngradeContract = c31.router({
 });
 
 // ../../packages/core/src/contracts/zero-usage.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 var c32 = initContract();
-var memberUsageSchema = z38.object({
-  userId: z38.string(),
-  email: z38.string(),
-  inputTokens: z38.number(),
-  outputTokens: z38.number(),
-  cacheReadInputTokens: z38.number(),
-  cacheCreationInputTokens: z38.number(),
-  creditsCharged: z38.number(),
-  creditCap: z38.number().nullable()
-});
-var usageMembersResponseSchema = z38.object({
-  period: z38.object({
-    start: z38.string(),
-    end: z38.string()
+var memberUsageSchema = z39.object({
+  userId: z39.string(),
+  email: z39.string(),
+  inputTokens: z39.number(),
+  outputTokens: z39.number(),
+  cacheReadInputTokens: z39.number(),
+  cacheCreationInputTokens: z39.number(),
+  creditsCharged: z39.number(),
+  creditCap: z39.number().nullable()
+});
+var usageMembersResponseSchema = z39.object({
+  period: z39.object({
+    start: z39.string(),
+    end: z39.string()
   }).nullable(),
-  members: z38.array(memberUsageSchema)
+  members: z39.array(memberUsageSchema)
 });
 var zeroUsageMembersContract = c32.router({
   get: {
@@ -29177,16 +29182,16 @@ var zeroUsageMembersContract = c32.router({
 });
 
 // ../../packages/core/src/contracts/zero-team.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 var c33 = initContract();
-var teamComposeItemSchema = z39.object({
-  id: z39.string(),
-  displayName: z39.string().nullable(),
-  description: z39.string().nullable(),
-  sound: z39.string().nullable(),
-  avatarUrl: z39.string().nullable(),
-  headVersionId: z39.string().nullable(),
-  updatedAt: z39.string()
+var teamComposeItemSchema = z40.object({
+  id: z40.string(),
+  displayName: z40.string().nullable(),
+  description: z40.string().nullable(),
+  sound: z40.string().nullable(),
+  avatarUrl: z40.string().nullable(),
+  headVersionId: z40.string().nullable(),
+  updatedAt: z40.string()
 });
 var zeroTeamContract = c33.router({
   list: {
@@ -29194,7 +29199,7 @@ var zeroTeamContract = c33.router({
     path: "/api/zero/team",
     headers: authHeadersSchema,
     responses: {
-      200: z39.array(teamComposeItemSchema),
+      200: z40.array(teamComposeItemSchema),
       401: apiErrorSchema,
       403: apiErrorSchema,
       404: apiErrorSchema
@@ -29204,28 +29209,28 @@ var zeroTeamContract = c33.router({
 });
 
 // ../../packages/core/src/contracts/zero-integrations-slack.ts
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 var c34 = initContract();
-var slackEnvironmentSchema = z40.object({
-  requiredSecrets: z40.array(z40.string()),
-  requiredVars: z40.array(z40.string()),
-  missingSecrets: z40.array(z40.string()),
-  missingVars: z40.array(z40.string())
-});
-var slackOrgStatusSchema = z40.object({
-  isConnected: z40.boolean(),
-  isInstalled: z40.boolean().optional(),
-  workspaceName: z40.string().nullable().optional(),
-  isAdmin: z40.boolean(),
-  installUrl: z40.string().nullable().optional(),
-  connectUrl: z40.string().nullable().optional(),
-  defaultAgentName: z40.string().nullable().optional(),
-  agentOrgSlug: z40.string().nullable().optional(),
+var slackEnvironmentSchema = z41.object({
+  requiredSecrets: z41.array(z41.string()),
+  requiredVars: z41.array(z41.string()),
+  missingSecrets: z41.array(z41.string()),
+  missingVars: z41.array(z41.string())
+});
+var slackOrgStatusSchema = z41.object({
+  isConnected: z41.boolean(),
+  isInstalled: z41.boolean().optional(),
+  workspaceName: z41.string().nullable().optional(),
+  isAdmin: z41.boolean(),
+  installUrl: z41.string().nullable().optional(),
+  connectUrl: z41.string().nullable().optional(),
+  defaultAgentName: z41.string().nullable().optional(),
+  agentOrgSlug: z41.string().nullable().optional(),
   environment: slackEnvironmentSchema.optional(),
   /** True when the installation's granted scopes are outdated (admin-only). */
-  scopeMismatch: z40.boolean().optional(),
+  scopeMismatch: z41.boolean().optional(),
   /** OAuth install URL for re-authorization (admin-only, when scopeMismatch). */
-  reinstallUrl: z40.string().nullable().optional()
+  reinstallUrl: z41.string().nullable().optional()
 });
 var zeroIntegrationsSlackContract = c34.router({
   getStatus: {
@@ -29243,11 +29248,11 @@ var zeroIntegrationsSlackContract = c34.router({
     path: "/api/zero/integrations/slack",
     headers: authHeadersSchema,
     body: c34.noBody(),
-    query: z40.object({
-      action: z40.string().optional()
+    query: z41.object({
+      action: z41.string().optional()
     }),
     responses: {
-      200: z40.object({ ok: z40.boolean() }),
+      200: z41.object({ ok: z41.boolean() }),
       401: apiErrorSchema,
       403: apiErrorSchema,
       404: apiErrorSchema
@@ -29257,18 +29262,18 @@ var zeroIntegrationsSlackContract = c34.router({
 });
 
 // ../../packages/core/src/contracts/zero-slack-connect.ts
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 var c35 = initContract();
-var slackConnectStatusSchema = z41.object({
-  isConnected: z41.boolean(),
-  isAdmin: z41.boolean(),
-  workspaceName: z41.string().nullable().optional(),
-  defaultAgentName: z41.string().nullable().optional()
+var slackConnectStatusSchema = z42.object({
+  isConnected: z42.boolean(),
+  isAdmin: z42.boolean(),
+  workspaceName: z42.string().nullable().optional(),
+  defaultAgentName: z42.string().nullable().optional()
 });
-var slackConnectResponseSchema = z41.object({
-  success: z41.boolean(),
-  connectionId: z41.string(),
-  role: z41.string()
+var slackConnectResponseSchema = z42.object({
+  success: z42.boolean(),
+  connectionId: z42.string(),
+  role: z42.string()
 });
 var zeroSlackConnectContract = c35.router({
   getStatus: {
@@ -29285,11 +29290,11 @@ var zeroSlackConnectContract = c35.router({
     method: "POST",
     path: "/api/zero/integrations/slack/connect",
     headers: authHeadersSchema,
-    body: z41.object({
-      workspaceId: z41.string().min(1),
-      slackUserId: z41.string().min(1),
-      channelId: z41.string().optional(),
-      threadTs: z41.string().optional()
+    body: z42.object({
+      workspaceId: z42.string().min(1),
+      slackUserId: z42.string().min(1),
+      channelId: z42.string().optional(),
+      threadTs: z42.string().optional()
     }),
     responses: {
       200: slackConnectResponseSchema,
@@ -29303,11 +29308,11 @@ var zeroSlackConnectContract = c35.router({
 });
 
 // ../../packages/core/src/contracts/zero-slack-channels.ts
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 var c36 = initContract();
-var slackChannelSchema = z42.object({
-  id: z42.string(),
-  name: z42.string()
+var slackChannelSchema = z43.object({
+  id: z43.string(),
+  name: z43.string()
 });
 var zeroSlackChannelsContract = c36.router({
   list: {
@@ -29315,7 +29320,7 @@ var zeroSlackChannelsContract = c36.router({
     path: "/api/zero/slack/channels",
     headers: authHeadersSchema,
     responses: {
-      200: z42.object({ channels: z42.array(slackChannelSchema) }),
+      200: z43.object({ channels: z43.array(slackChannelSchema) }),
       401: apiErrorSchema,
       404: apiErrorSchema
     },
@@ -29324,19 +29329,19 @@ var zeroSlackChannelsContract = c36.router({
 });
 
 // ../../packages/core/src/contracts/zero-queue-position.ts
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 var c37 = initContract();
-var queuePositionResponseSchema = z43.object({
-  position: z43.number(),
-  total: z43.number()
+var queuePositionResponseSchema = z44.object({
+  position: z44.number(),
+  total: z44.number()
 });
 var zeroQueuePositionContract = c37.router({
   getPosition: {
     method: "GET",
     path: "/api/zero/queue-position",
     headers: authHeadersSchema,
-    query: z43.object({
-      runId: z43.string().min(1, "runId is required")
+    query: z44.object({
+      runId: z44.string().min(1, "runId is required")
     }),
     responses: {
       200: queuePositionResponseSchema,
@@ -29349,20 +29354,20 @@ var zeroQueuePositionContract = c37.router({
 });
 
 // ../../packages/core/src/contracts/zero-member-credit-cap.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 var c38 = initContract();
-var memberCreditCapResponseSchema = z44.object({
-  userId: z44.string(),
-  creditCap: z44.number().nullable(),
-  creditEnabled: z44.boolean()
+var memberCreditCapResponseSchema = z45.object({
+  userId: z45.string(),
+  creditCap: z45.number().nullable(),
+  creditEnabled: z45.boolean()
 });
 var zeroMemberCreditCapContract = c38.router({
   get: {
     method: "GET",
     path: "/api/zero/org/members/credit-cap",
     headers: authHeadersSchema,
-    query: z44.object({
-      userId: z44.string().min(1, "userId is required")
+    query: z45.object({
+      userId: z45.string().min(1, "userId is required")
     }),
     responses: {
       200: memberCreditCapResponseSchema,
@@ -29375,9 +29380,9 @@ var zeroMemberCreditCapContract = c38.router({
     method: "PUT",
     path: "/api/zero/org/members/credit-cap",
     headers: authHeadersSchema,
-    body: z44.object({
-      userId: z44.string().min(1),
-      creditCap: z44.number().int().positive().nullable()
+    body: z45.object({
+      userId: z45.string().min(1),
+      creditCap: z45.number().int().positive().nullable()
     }),
     responses: {
       200: memberCreditCapResponseSchema,
@@ -29390,33 +29395,33 @@ var zeroMemberCreditCapContract = c38.router({
 });
 
 // ../../packages/core/src/contracts/zero-ask-user.ts
-import { z as z45 } from "zod";
+import { z as z46 } from "zod";
 var c39 = initContract();
-var askUserQuestionItemSchema = z45.object({
-  question: z45.string().min(1),
-  header: z45.string().max(12).optional(),
-  options: z45.array(
-    z45.object({
-      label: z45.string(),
-      description: z45.string().optional()
+var askUserQuestionItemSchema = z46.object({
+  question: z46.string().min(1),
+  header: z46.string().max(12).optional(),
+  options: z46.array(
+    z46.object({
+      label: z46.string(),
+      description: z46.string().optional()
     })
   ).min(1),
-  multiSelect: z45.boolean().optional()
+  multiSelect: z46.boolean().optional()
 });
-var askUserQuestionBodySchema = z45.object({
-  questions: z45.array(askUserQuestionItemSchema).min(1)
+var askUserQuestionBodySchema = z46.object({
+  questions: z46.array(askUserQuestionItemSchema).min(1)
 });
-var askUserQuestionResponseSchema = z45.object({
-  pendingId: z45.string().uuid()
+var askUserQuestionResponseSchema = z46.object({
+  pendingId: z46.string().uuid()
 });
-var askUserAnswerStatusSchema = z45.enum([
+var askUserAnswerStatusSchema = z46.enum([
   "pending",
   "answered",
   "expired"
 ]);
-var askUserAnswerResponseSchema = z45.object({
+var askUserAnswerResponseSchema = z46.object({
   status: askUserAnswerStatusSchema,
-  answer: z45.string().optional()
+  answer: z46.string().optional()
 });
 var zeroAskUserQuestionContract = c39.router({
   postQuestion: {
@@ -29437,8 +29442,8 @@ var zeroAskUserAnswerContract = c39.router({
     method: "GET",
     path: "/api/zero/ask-user/answer",
     headers: authHeadersSchema,
-    query: z45.object({
-      pendingId: z45.string().uuid()
+    query: z46.object({
+      pendingId: z46.string().uuid()
     }),
     responses: {
       200: askUserAnswerResponseSchema,
@@ -29450,18 +29455,18 @@ var zeroAskUserAnswerContract = c39.router({
 });
 
 // ../../packages/core/src/contracts/zero-developer-support.ts
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 var c40 = initContract();
-var developerSupportBodySchema = z46.object({
-  title: z46.string().min(1, "Title is required"),
-  description: z46.string().min(1, "Description is required"),
-  consentCode: z46.string().optional()
+var developerSupportBodySchema = z47.object({
+  title: z47.string().min(1, "Title is required"),
+  description: z47.string().min(1, "Description is required"),
+  consentCode: z47.string().optional()
 });
-var consentCodeResponseSchema = z46.object({
-  consentCode: z46.string()
+var consentCodeResponseSchema = z47.object({
+  consentCode: z47.string()
 });
-var submitResponseSchema = z46.object({
-  reference: z46.string()
+var submitResponseSchema = z47.object({
+  reference: z47.string()
 });
 var zeroDeveloperSupportContract = c40.router({
   submit: {
@@ -29470,7 +29475,7 @@ var zeroDeveloperSupportContract = c40.router({
     headers: authHeadersSchema,
     body: developerSupportBodySchema,
     responses: {
-      200: z46.union([consentCodeResponseSchema, submitResponseSchema]),
+      200: z47.union([consentCodeResponseSchema, submitResponseSchema]),
       400: apiErrorSchema,
       401: apiErrorSchema
     },
@@ -29479,18 +29484,18 @@ var zeroDeveloperSupportContract = c40.router({
 });
 
 // ../../packages/core/src/contracts/zero-computer-use.ts
-import { z as z47 } from "zod";
+import { z as z48 } from "zod";
 var c41 = initContract();
-var registerResponseSchema = z47.object({
-  id: z47.string(),
-  domain: z47.string(),
-  token: z47.string(),
-  ngrokToken: z47.string(),
-  endpointPrefix: z47.string()
+var registerResponseSchema = z48.object({
+  id: z48.string(),
+  domain: z48.string(),
+  token: z48.string(),
+  ngrokToken: z48.string(),
+  endpointPrefix: z48.string()
 });
-var hostResponseSchema = z47.object({
-  domain: z47.string(),
-  token: z47.string()
+var hostResponseSchema = z48.object({
+  domain: z48.string(),
+  token: z48.string()
 });
 var zeroComputerUseRegisterContract = c41.router({
   register: {
@@ -29582,29 +29587,17 @@ function getInstructionsFilename(framework) {
 }
 
 // ../../packages/core/src/feature-switch.ts
-var sha1Cache = /* @__PURE__ */ new Map();
-async function sha1(input) {
-  const cached = sha1Cache.get(input);
-  if (cached) return cached;
-  const data = new TextEncoder().encode(input);
-  const hashBuffer = await crypto.subtle.digest("SHA-1", data);
-  const hashArray = Array.from(new Uint8Array(hashBuffer));
-  const hex = hashArray.map((b) => {
-    return b.toString(16).padStart(2, "0");
-  }).join("");
-  sha1Cache.set(input, hex);
-  return hex;
+function fnv1a(input) {
+  let h = 2166136261 >>> 0;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
 }
-var STAFF_USER_HASHES = [
-  "afc25aa601481d794372ed765038148d3a160e2a",
-  "1e7de00267c699185653df499f68e8383013ca08",
-  "b397fa9b0330b421a5113ac88dd2b01ca2067cfe",
-  "d938bb6e49cb8ccfaa962942d69c9ccd1ee239af",
-  "67a65740246389d7fecf7702f8b7d6914ad38dc5",
-  "55651a8b2c85b35ff0629fa3d4718b9476069d0f"
-];
+var STAFF_USER_HASHES = [];
 var STAFF_ORG_ID_HASHES = [
-  "65de87977d6d1712cd88d7768209f33f7ed12e0b"
+  "afce210e"
   // org_3ANttyrbWYJk6JKRSTRLEsbsDLe
 ];
 var FEATURE_SWITCHES = {
@@ -29824,22 +29817,22 @@ var FEATURE_SWITCHES = {
     enabledOrgIdHashes: STAFF_ORG_ID_HASHES
   }
 };
-async function isFeatureEnabled(key, ctx) {
+function isFeatureEnabled(key, ctx) {
   const featureSwitch = FEATURE_SWITCHES[key];
   if (featureSwitch.enabled) {
     return true;
   }
   if (ctx?.userId && featureSwitch.enabledUserHashes?.length) {
-    const hash = await sha1(ctx.userId);
-    if (featureSwitch.enabledUserHashes.includes(hash)) return true;
+    if (featureSwitch.enabledUserHashes.includes(fnv1a(ctx.userId)))
+      return true;
   }
   if (ctx?.email && featureSwitch.enabledEmailHashes?.length) {
-    const hash = await sha1(ctx.email.toLowerCase());
-    if (featureSwitch.enabledEmailHashes.includes(hash)) return true;
+    if (featureSwitch.enabledEmailHashes.includes(fnv1a(ctx.email.toLowerCase())))
+      return true;
   }
   if (ctx?.orgId && featureSwitch.enabledOrgIdHashes?.length) {
-    const hash = await sha1(ctx.orgId);
-    if (featureSwitch.enabledOrgIdHashes.includes(hash)) return true;
+    if (featureSwitch.enabledOrgIdHashes.includes(fnv1a(ctx.orgId)))
+      return true;
   }
   return false;
 }
@@ -32112,4 +32105,4 @@ export {
   parseTime,
   paginate
 };
-//# sourceMappingURL=chunk-DJWH2DJQ.js.map
+//# sourceMappingURL=chunk-Y46LDOHW.js.map