@vm0/cli 9.59.5 → 9.59.6

package/index.js

@@ -45,7 +45,7 @@ if (DSN) {
   Sentry.init({
     dsn: DSN,
     environment: process.env.SENTRY_ENVIRONMENT ?? "production",
-    release: "9.59.5",
+    release: "9.59.6",
     sendDefaultPii: false,
     tracesSampleRate: 0,
     shutdownTimeout: 500,
@@ -64,7 +64,7 @@ if (DSN) {
     }
   });
   Sentry.setContext("cli", {
-    version: "9.59.5",
+    version: "9.59.6",
     command: process.argv.slice(2).join(" ")
   });
   Sentry.setContext("runtime", {
@@ -673,7 +673,7 @@ function getConfigPath() {
   return join2(homedir2(), ".vm0", "config.json");
 }
 var infoCommand = new Command6().name("info").description("Display environment and debug information").action(async () => {
-  console.log(chalk4.bold(`VM0 CLI v${"9.59.5"}`));
+  console.log(chalk4.bold(`VM0 CLI v${"9.59.6"}`));
   console.log();
   const config = await loadConfig();
   const hasEnvToken = !!process.env.VM0_TOKEN;
@@ -780,161 +780,9 @@ var apiErrorSchema = z2.object({
 });
 
 // ../../packages/core/src/contracts/composes.ts
-import { z as z4 } from "zod";
-
-// ../../packages/core/src/contracts/runners.ts
 import { z as z3 } from "zod";
 var c = initContract();
-var runnerGroupSchema = z3.string().regex(
-  /^[a-z0-9-]+\/[a-z0-9-]+$/,
-  "Runner group must be in org/name format (e.g., acme/production)"
-);
-var jobSchema = z3.object({
-  runId: z3.string().uuid(),
-  prompt: z3.string(),
-  agentComposeVersionId: z3.string().nullable(),
-  vars: z3.record(z3.string(), z3.string()).nullable(),
-  checkpointId: z3.string().uuid().nullable()
-});
-var runnersPollContract = c.router({
-  poll: {
-    method: "POST",
-    path: "/api/runners/poll",
-    headers: authHeadersSchema,
-    body: z3.object({
-      group: runnerGroupSchema
-    }),
-    responses: {
-      200: z3.object({
-        job: jobSchema.nullable()
-      }),
-      400: apiErrorSchema,
-      401: apiErrorSchema,
-      500: apiErrorSchema
-    },
-    summary: "Poll for pending jobs (long-polling with 30s timeout)"
-  }
-});
-var servicePermissionSchema = z3.object({
-  name: z3.string(),
-  description: z3.string().optional(),
-  rules: z3.array(z3.string())
-});
-var serviceApiEntrySchema = z3.object({
-  base: z3.string(),
-  auth: z3.object({
-    headers: z3.record(z3.string(), z3.string())
-  }),
-  permissions: z3.array(servicePermissionSchema).optional()
-});
-var serviceEntrySchema = z3.object({
-  name: z3.string(),
-  ref: z3.string(),
-  apis: z3.array(serviceApiEntrySchema)
-});
-var experimentalServicesSchema = z3.array(serviceEntrySchema);
-var storageEntrySchema = z3.object({
-  mountPath: z3.string(),
-  archiveUrl: z3.string().nullable()
-});
-var artifactEntrySchema = z3.object({
-  mountPath: z3.string(),
-  archiveUrl: z3.string().nullable(),
-  vasStorageName: z3.string(),
-  vasVersionId: z3.string()
-});
-var storageManifestSchema = z3.object({
-  storages: z3.array(storageEntrySchema),
-  artifact: artifactEntrySchema.nullable(),
-  memory: artifactEntrySchema.nullable()
-});
-var resumeSessionSchema = z3.object({
-  sessionId: z3.string(),
-  sessionHistory: z3.string()
-});
-var storedExecutionContextSchema = z3.object({
-  workingDir: z3.string(),
-  storageManifest: storageManifestSchema.nullable(),
-  environment: z3.record(z3.string(), z3.string()).nullable(),
-  resumeSession: resumeSessionSchema.nullable(),
-  encryptedSecrets: z3.string().nullable(),
-  // AES-256-GCM encrypted Record<string, string> (secret name → value)
-  // Maps secret names to OAuth connector types for runtime token refresh (e.g. { "GMAIL_ACCESS_TOKEN": "gmail" })
-  secretConnectorMap: z3.record(z3.string(), z3.string()).nullable().optional(),
-  cliAgentType: z3.string(),
-  // Debug flag to force real Claude in mock environments (internal use only)
-  debugNoMockClaude: z3.boolean().optional(),
-  // Dispatch timestamp for E2E timing metrics
-  apiStartTime: z3.number().optional(),
-  // User's timezone preference (IANA format, e.g., "Asia/Shanghai")
-  userTimezone: z3.string().optional(),
-  // Agent metadata for VM0_AGENT_NAME and VM0_AGENT_ORG env vars
-  agentName: z3.string().optional(),
-  agentOrgSlug: z3.string().optional(),
-  // Memory storage name (for first-run when manifest.memory is null)
-  memoryName: z3.string().optional(),
-  // Experimental services for proxy-side token replacement
-  experimentalServices: experimentalServicesSchema.optional()
-});
-var executionContextSchema = z3.object({
-  runId: z3.string().uuid(),
-  prompt: z3.string(),
-  agentComposeVersionId: z3.string().nullable(),
-  vars: z3.record(z3.string(), z3.string()).nullable(),
-  checkpointId: z3.string().uuid().nullable(),
-  sandboxToken: z3.string(),
-  // New fields for E2B parity:
-  workingDir: z3.string(),
-  storageManifest: storageManifestSchema.nullable(),
-  environment: z3.record(z3.string(), z3.string()).nullable(),
-  resumeSession: resumeSessionSchema.nullable(),
-  secretValues: z3.array(z3.string()).nullable(),
-  // AES-256-GCM encrypted Record<string, string> — passed through to mitm-addon for auth resolution
-  encryptedSecrets: z3.string().nullable(),
-  // Maps secret names to OAuth connector types for runtime token refresh
-  secretConnectorMap: z3.record(z3.string(), z3.string()).nullable().optional(),
-  cliAgentType: z3.string(),
-  // Debug flag to force real Claude in mock environments (internal use only)
-  debugNoMockClaude: z3.boolean().optional(),
-  // Dispatch timestamp for E2E timing metrics
-  apiStartTime: z3.number().optional(),
-  // User's timezone preference (IANA format, e.g., "Asia/Shanghai")
-  userTimezone: z3.string().optional(),
-  // Agent metadata
-  agentName: z3.string().optional(),
-  agentOrgSlug: z3.string().optional(),
-  // Memory storage name (for first-run when manifest.memory is null)
-  memoryName: z3.string().optional(),
-  // Experimental services for proxy-side token replacement
-  experimentalServices: experimentalServicesSchema.optional()
-});
-var runnersJobClaimContract = c.router({
-  claim: {
-    method: "POST",
-    path: "/api/runners/jobs/:id/claim",
-    headers: authHeadersSchema,
-    pathParams: z3.object({
-      id: z3.string().uuid()
-    }),
-    body: z3.object({}),
-    responses: {
-      200: executionContextSchema,
-      400: apiErrorSchema,
-      401: apiErrorSchema,
-      403: apiErrorSchema,
-      // Job does not belong to user
-      404: apiErrorSchema,
-      409: apiErrorSchema,
-      // Already claimed
-      500: apiErrorSchema
-    },
-    summary: "Claim a pending job for execution"
-  }
-});
-
-// ../../packages/core/src/contracts/composes.ts
-var c2 = initContract();
-var composeVersionQuerySchema = z4.string().min(1, "Missing version query parameter").regex(
+var composeVersionQuerySchema = z3.string().min(1, "Missing version query parameter").regex(
   /^[a-f0-9]{8,64}$|^latest$/i,
   "Version must be 8-64 hex characters or 'latest'"
 );
@@ -953,26 +801,31 @@ var VALID_CAPABILITIES = [
   "schedule:read",
   "schedule:write"
 ];
-var agentNameSchema = z4.string().min(3, "Agent name must be at least 3 characters").max(64, "Agent name must be 64 characters or less").regex(
+var firewallPermissionSchema = z3.object({
+  name: z3.string(),
+  description: z3.string().optional(),
+  rules: z3.array(z3.string())
+});
+var agentNameSchema = z3.string().min(3, "Agent name must be at least 3 characters").max(64, "Agent name must be 64 characters or less").regex(
   AGENT_NAME_REGEX,
   "Agent name must start and end with letter or number, and contain only letters, numbers, and hyphens"
 );
-var volumeConfigSchema = z4.object({
-  name: z4.string().min(1, "Volume name is required"),
-  version: z4.string().min(1, "Volume version is required"),
+var volumeConfigSchema = z3.object({
+  name: z3.string().min(1, "Volume name is required"),
+  version: z3.string().min(1, "Volume version is required"),
   /** When true, skip mounting without error if volume doesn't exist */
-  optional: z4.boolean().optional()
+  optional: z3.boolean().optional()
 });
-var agentDefinitionSchema = z4.object({
-  description: z4.string().optional(),
-  framework: z4.string().min(1, "Framework is required"),
-  volumes: z4.array(z4.string()).optional(),
-  environment: z4.record(z4.string(), z4.string()).optional(),
+var agentDefinitionSchema = z3.object({
+  description: z3.string().optional(),
+  framework: z3.string().min(1, "Framework is required"),
+  volumes: z3.array(z3.string()).optional(),
+  environment: z3.record(z3.string(), z3.string()).optional(),
   /**
    * Path to instructions file (e.g., AGENTS.md).
    * Auto-uploaded as volume and mounted at /home/user/.claude/CLAUDE.md
    */
-  instructions: z4.string().min(1, "Instructions path cannot be empty").refine(
+  instructions: z3.string().min(1, "Instructions path cannot be empty").refine(
     (val) => !val.includes("..") && !val.startsWith("/") && !val.startsWith("\\"),
     "Instructions path must be a relative path without '..' segments"
   ).optional(),
@@ -980,33 +833,33 @@ var agentDefinitionSchema = z4.object({
    * Array of GitHub tree URLs for agent skills.
    * Each skill is auto-downloaded and mounted at /home/user/.claude/skills/{skillName}/
    */
-  skills: z4.array(z4.string()).optional(),
+  skills: z3.array(z3.string()).optional(),
   /**
    * Route this agent to a self-hosted runner instead of E2B.
    * When specified, runs will be queued for the specified runner group.
    */
-  experimental_runner: z4.object({
-    group: z4.string().regex(
+  experimental_runner: z3.object({
+    group: z3.string().regex(
       /^[a-z0-9-]+\/[a-z0-9-]+$/,
       "Runner group must be in org/name format (e.g., acme/production)"
     )
   }).optional(),
   /**
-   * External services for proxy-side token replacement.
+   * External firewall rules for proxy-side token replacement.
    * CLI input: map format { slack: { permissions: [...] | "all" } }
-   * — expanded by CLI to full ExpandedServiceConfig[] before API call.
+   * — expanded by CLI to full ExpandedFirewallConfig[] before API call.
    */
-  experimental_services: z4.record(
-    z4.string(),
-    z4.object({
-      permissions: z4.union([z4.literal("all"), z4.array(z4.string()).min(1)])
+  experimental_firewall: z3.record(
+    z3.string(),
+    z3.object({
+      permissions: z3.union([z3.literal("all"), z3.array(z3.string()).min(1)])
     })
   ).optional(),
   /**
    * Capabilities that the agent is allowed to use.
    * Validated against VALID_CAPABILITIES at compose time.
    */
-  experimental_capabilities: z4.array(z4.enum(VALID_CAPABILITIES)).refine((arr) => new Set(arr).size === arr.length, {
+  experimental_capabilities: z3.array(z3.enum(VALID_CAPABILITIES)).refine((arr) => new Set(arr).size === arr.length, {
     message: "Duplicate capabilities are not allowed"
   }).optional(),
   /**
@@ -1014,68 +867,68 @@ var agentDefinitionSchema = z4.object({
    * - displayName: Human-readable name shown in the UI (preserves original casing).
    * - sound: Communication tone (e.g., "professional", "friendly").
    */
-  metadata: z4.object({
-    displayName: z4.string().optional(),
-    description: z4.string().optional(),
-    sound: z4.string().optional()
+  metadata: z3.object({
+    displayName: z3.string().optional(),
+    description: z3.string().optional(),
+    sound: z3.string().optional()
   }).optional(),
   /**
    * @deprecated Server-resolved field. User input is ignored.
    * @internal
    */
-  image: z4.string().optional(),
+  image: z3.string().optional(),
   /**
    * @deprecated Server-resolved field. User input is ignored.
    * @internal
    */
-  working_dir: z4.string().optional()
+  working_dir: z3.string().optional()
 });
-var agentComposeContentSchema = z4.object({
-  version: z4.string().min(1, "Version is required"),
-  agents: z4.record(z4.string(), agentDefinitionSchema),
-  volumes: z4.record(z4.string(), volumeConfigSchema).optional()
+var agentComposeContentSchema = z3.object({
+  version: z3.string().min(1, "Version is required"),
+  agents: z3.record(z3.string(), agentDefinitionSchema),
+  volumes: z3.record(z3.string(), volumeConfigSchema).optional()
 });
-var expandedServiceConfigSchema = z4.object({
-  name: z4.string(),
-  ref: z4.string(),
-  description: z4.string().optional(),
-  apis: z4.array(
-    z4.object({
-      base: z4.string(),
-      auth: z4.object({
-        headers: z4.record(z4.string(), z4.string())
+var expandedFirewallConfigSchema = z3.object({
+  name: z3.string(),
+  ref: z3.string(),
+  description: z3.string().optional(),
+  apis: z3.array(
+    z3.object({
+      base: z3.string(),
+      auth: z3.object({
+        headers: z3.record(z3.string(), z3.string())
       }),
-      permissions: z4.array(servicePermissionSchema).optional()
+      permissions: z3.array(firewallPermissionSchema).optional()
     })
   ),
-  placeholders: z4.record(z4.string(), z4.string()).optional()
+  placeholders: z3.record(z3.string(), z3.string()).optional()
 });
-var agentComposeApiContentSchema = z4.object({
-  version: z4.string().min(1, "Version is required"),
-  agents: z4.record(
-    z4.string(),
+var agentComposeApiContentSchema = z3.object({
+  version: z3.string().min(1, "Version is required"),
+  agents: z3.record(
+    z3.string(),
     agentDefinitionSchema.extend({
-      experimental_services: z4.array(expandedServiceConfigSchema).optional()
+      experimental_firewall: z3.array(expandedFirewallConfigSchema).optional()
     })
   ),
-  volumes: z4.record(z4.string(), volumeConfigSchema).optional()
+  volumes: z3.record(z3.string(), volumeConfigSchema).optional()
 });
-var composeResponseSchema = z4.object({
-  id: z4.string(),
-  name: z4.string(),
-  headVersionId: z4.string().nullable(),
+var composeResponseSchema = z3.object({
+  id: z3.string(),
+  name: z3.string(),
+  headVersionId: z3.string().nullable(),
   content: agentComposeApiContentSchema.nullable(),
-  createdAt: z4.string(),
-  updatedAt: z4.string()
+  createdAt: z3.string(),
+  updatedAt: z3.string()
 });
-var createComposeResponseSchema = z4.object({
-  composeId: z4.string(),
-  name: z4.string(),
-  versionId: z4.string(),
-  action: z4.enum(["created", "existing"]),
-  updatedAt: z4.string()
+var createComposeResponseSchema = z3.object({
+  composeId: z3.string(),
+  name: z3.string(),
+  versionId: z3.string(),
+  action: z3.enum(["created", "existing"]),
+  updatedAt: z3.string()
 });
-var composesMainContract = c2.router({
+var composesMainContract = c.router({
   /**
    * GET /api/agent/composes?name={name}&org={org}
    * Get agent compose by name with HEAD version content
@@ -1085,9 +938,9 @@ var composesMainContract = c2.router({
     method: "GET",
     path: "/api/agent/composes",
     headers: authHeadersSchema,
-    query: z4.object({
-      name: z4.string().min(1, "Missing name query parameter"),
-      org: z4.string().optional()
+    query: z3.object({
+      name: z3.string().min(1, "Missing name query parameter"),
+      org: z3.string().optional()
     }),
     responses: {
       200: composeResponseSchema,
@@ -1107,7 +960,7 @@ var composesMainContract = c2.router({
     method: "POST",
     path: "/api/agent/composes",
     headers: authHeadersSchema,
-    body: z4.object({
+    body: z3.object({
       content: agentComposeApiContentSchema
     }),
     responses: {
@@ -1119,7 +972,7 @@ var composesMainContract = c2.router({
     summary: "Create or update agent compose version"
   }
 });
-var composesByIdContract = c2.router({
+var composesByIdContract = c.router({
   /**
    * GET /api/agent/composes/:id
    * Get agent compose by ID with HEAD version content
@@ -1128,8 +981,8 @@ var composesByIdContract = c2.router({
     method: "GET",
     path: "/api/agent/composes/:id",
     headers: authHeadersSchema,
-    pathParams: z4.object({
-      id: z4.string().min(1, "Compose ID is required")
+    pathParams: z3.object({
+      id: z3.string().min(1, "Compose ID is required")
     }),
     responses: {
       200: composeResponseSchema,
@@ -1147,12 +1000,12 @@ var composesByIdContract = c2.router({
     method: "DELETE",
     path: "/api/agent/composes/:id",
     headers: authHeadersSchema,
-    pathParams: z4.object({
-      id: z4.string().uuid("Compose ID is required")
+    pathParams: z3.object({
+      id: z3.string().uuid("Compose ID is required")
     }),
-    body: c2.noBody(),
+    body: c.noBody(),
     responses: {
-      204: c2.noBody(),
+      204: c.noBody(),
       401: apiErrorSchema,
       404: apiErrorSchema,
       409: apiErrorSchema
@@ -1160,7 +1013,7 @@ var composesByIdContract = c2.router({
     summary: "Delete agent compose"
   }
 });
-var composesVersionsContract = c2.router({
+var composesVersionsContract = c.router({
   /**
    * GET /api/agent/composes/versions?composeId={id}&version={hash|tag}
    * Resolve a version specifier to a full version ID
@@ -1169,14 +1022,14 @@ var composesVersionsContract = c2.router({
     method: "GET",
     path: "/api/agent/composes/versions",
     headers: authHeadersSchema,
-    query: z4.object({
-      composeId: z4.string().min(1, "Missing composeId query parameter"),
+    query: z3.object({
+      composeId: z3.string().min(1, "Missing composeId query parameter"),
       version: composeVersionQuerySchema
     }),
     responses: {
-      200: z4.object({
-        versionId: z4.string(),
-        tag: z4.string().optional()
+      200: z3.object({
+        versionId: z3.string(),
+        tag: z3.string().optional()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -1185,16 +1038,16 @@ var composesVersionsContract = c2.router({
     summary: "Resolve version specifier to full version ID"
   }
 });
-var composeListItemSchema = z4.object({
-  id: z4.string(),
-  name: z4.string(),
-  displayName: z4.string().nullable().optional(),
-  description: z4.string().nullable().optional(),
-  headVersionId: z4.string().nullable(),
-  updatedAt: z4.string(),
-  isOwner: z4.boolean()
+var composeListItemSchema = z3.object({
+  id: z3.string(),
+  name: z3.string(),
+  displayName: z3.string().nullable().optional(),
+  description: z3.string().nullable().optional(),
+  headVersionId: z3.string().nullable(),
+  updatedAt: z3.string(),
+  isOwner: z3.boolean()
 });
-var composesListContract = c2.router({
+var composesListContract = c.router({
   /**
    * GET /api/agent/composes/list?org={org}
    * List all agent composes for an org
@@ -1204,12 +1057,12 @@ var composesListContract = c2.router({
     method: "GET",
     path: "/api/agent/composes/list",
     headers: authHeadersSchema,
-    query: z4.object({
-      org: z4.string().optional()
+    query: z3.object({
+      org: z3.string().optional()
     }),
     responses: {
-      200: z4.object({
-        composes: z4.array(composeListItemSchema)
+      200: z3.object({
+        composes: z3.array(composeListItemSchema)
       }),
       400: apiErrorSchema,
       401: apiErrorSchema
@@ -1219,8 +1072,8 @@ var composesListContract = c2.router({
 });
 
 // ../../packages/core/src/contracts/runs.ts
-import { z as z5 } from "zod";
-var c3 = initContract();
+import { z as z4 } from "zod";
+var c2 = initContract();
 var ALL_RUN_STATUSES = [
   "queued",
   "pending",
@@ -1230,94 +1083,94 @@ var ALL_RUN_STATUSES = [
   "timeout",
   "cancelled"
 ];
-var runStatusSchema = z5.enum(ALL_RUN_STATUSES);
-var unifiedRunRequestSchema = z5.object({
+var runStatusSchema = z4.enum(ALL_RUN_STATUSES);
+var unifiedRunRequestSchema = z4.object({
   // High-level shortcuts (mutually exclusive with each other)
-  checkpointId: z5.string().optional(),
-  sessionId: z5.string().optional(),
+  checkpointId: z4.string().optional(),
+  sessionId: z4.string().optional(),
   // Base parameters (can be used directly or overridden after shortcut expansion)
-  agentComposeId: z5.string().optional(),
-  agentComposeVersionId: z5.string().optional(),
-  conversationId: z5.string().optional(),
-  artifactName: z5.string().optional(),
-  artifactVersion: z5.string().optional(),
-  vars: z5.record(z5.string(), z5.string()).optional(),
-  secrets: z5.record(z5.string(), z5.string()).optional(),
-  volumeVersions: z5.record(z5.string(), z5.string()).optional(),
-  memoryName: z5.string().optional(),
+  agentComposeId: z4.string().optional(),
+  agentComposeVersionId: z4.string().optional(),
+  conversationId: z4.string().optional(),
+  artifactName: z4.string().optional(),
+  artifactVersion: z4.string().optional(),
+  vars: z4.record(z4.string(), z4.string()).optional(),
+  secrets: z4.record(z4.string(), z4.string()).optional(),
+  volumeVersions: z4.record(z4.string(), z4.string()).optional(),
+  memoryName: z4.string().optional(),
   // Debug flag to force real Claude in mock environments (internal use only)
-  debugNoMockClaude: z5.boolean().optional(),
+  debugNoMockClaude: z4.boolean().optional(),
   // Model provider for automatic secret injection
-  modelProvider: z5.string().optional(),
+  modelProvider: z4.string().optional(),
   // Environment validation flag - when true, validates secrets/vars before running
-  checkEnv: z5.boolean().optional(),
+  checkEnv: z4.boolean().optional(),
   // Required
-  prompt: z5.string().min(1, "Missing prompt")
+  prompt: z4.string().min(1, "Missing prompt")
 });
-var createRunResponseSchema = z5.object({
-  runId: z5.string(),
+var createRunResponseSchema = z4.object({
+  runId: z4.string(),
   status: runStatusSchema,
-  sandboxId: z5.string().optional(),
-  output: z5.string().optional(),
-  error: z5.string().optional(),
-  executionTimeMs: z5.number().optional(),
-  createdAt: z5.string()
+  sandboxId: z4.string().optional(),
+  output: z4.string().optional(),
+  error: z4.string().optional(),
+  executionTimeMs: z4.number().optional(),
+  createdAt: z4.string()
 });
-var getRunResponseSchema = z5.object({
-  runId: z5.string(),
-  agentComposeVersionId: z5.string().nullable(),
+var getRunResponseSchema = z4.object({
+  runId: z4.string(),
+  agentComposeVersionId: z4.string().nullable(),
   status: runStatusSchema,
-  prompt: z5.string(),
-  vars: z5.record(z5.string(), z5.string()).optional(),
-  sandboxId: z5.string().optional(),
-  result: z5.object({
-    output: z5.string(),
-    executionTimeMs: z5.number()
+  prompt: z4.string(),
+  vars: z4.record(z4.string(), z4.string()).optional(),
+  sandboxId: z4.string().optional(),
+  result: z4.object({
+    output: z4.string(),
+    executionTimeMs: z4.number()
   }).optional(),
-  error: z5.string().optional(),
-  createdAt: z5.string(),
-  startedAt: z5.string().optional(),
-  completedAt: z5.string().optional()
+  error: z4.string().optional(),
+  createdAt: z4.string(),
+  startedAt: z4.string().optional(),
+  completedAt: z4.string().optional()
 });
-var runEventSchema = z5.object({
-  sequenceNumber: z5.number(),
-  eventType: z5.string(),
-  eventData: z5.unknown(),
-  createdAt: z5.string()
+var runEventSchema = z4.object({
+  sequenceNumber: z4.number(),
+  eventType: z4.string(),
+  eventData: z4.unknown(),
+  createdAt: z4.string()
 });
-var runResultSchema = z5.object({
-  checkpointId: z5.string(),
-  agentSessionId: z5.string(),
-  conversationId: z5.string(),
-  artifact: z5.record(z5.string(), z5.string()).optional(),
+var runResultSchema = z4.object({
+  checkpointId: z4.string(),
+  agentSessionId: z4.string(),
+  conversationId: z4.string(),
+  artifact: z4.record(z4.string(), z4.string()).optional(),
   // optional when run has no artifact
-  volumes: z5.record(z5.string(), z5.string()).optional(),
-  memory: z5.record(z5.string(), z5.string()).optional()
+  volumes: z4.record(z4.string(), z4.string()).optional(),
+  memory: z4.record(z4.string(), z4.string()).optional()
 });
-var runStateSchema = z5.object({
+var runStateSchema = z4.object({
   status: runStatusSchema,
   result: runResultSchema.optional(),
-  error: z5.string().optional()
+  error: z4.string().optional()
 });
-var eventsResponseSchema = z5.object({
-  events: z5.array(runEventSchema),
-  hasMore: z5.boolean(),
-  nextSequence: z5.number(),
+var eventsResponseSchema = z4.object({
+  events: z4.array(runEventSchema),
+  hasMore: z4.boolean(),
+  nextSequence: z4.number(),
   run: runStateSchema,
-  framework: z5.string()
+  framework: z4.string()
 });
-var runListItemSchema = z5.object({
-  id: z5.string(),
-  agentName: z5.string(),
+var runListItemSchema = z4.object({
+  id: z4.string(),
+  agentName: z4.string(),
   status: runStatusSchema,
-  prompt: z5.string(),
-  createdAt: z5.string(),
-  startedAt: z5.string().nullable()
+  prompt: z4.string(),
+  createdAt: z4.string(),
+  startedAt: z4.string().nullable()
 });
-var runsListResponseSchema = z5.object({
-  runs: z5.array(runListItemSchema)
+var runsListResponseSchema = z4.object({
+  runs: z4.array(runListItemSchema)
 });
-var runsMainContract = c3.router({
+var runsMainContract = c2.router({
   /**
    * GET /api/agent/runs
    * List agent runs (pending and running by default)
@@ -1326,16 +1179,16 @@ var runsMainContract = c3.router({
     method: "GET",
     path: "/api/agent/runs",
     headers: authHeadersSchema,
-    query: z5.object({
-      status: z5.string().optional(),
+    query: z4.object({
+      status: z4.string().optional(),
       // comma-separated: "pending,running"
-      agent: z5.string().optional(),
+      agent: z4.string().optional(),
       // agent name filter
-      since: z5.string().optional(),
+      since: z4.string().optional(),
       // ISO timestamp
-      until: z5.string().optional(),
+      until: z4.string().optional(),
       // ISO timestamp
-      limit: z5.coerce.number().min(1).max(100).default(50)
+      limit: z4.coerce.number().min(1).max(100).default(50)
     }),
     responses: {
       200: runsListResponseSchema,
@@ -1362,7 +1215,7 @@ var runsMainContract = c3.router({
     summary: "Create and execute agent run"
   }
 });
-var runsByIdContract = c3.router({
+var runsByIdContract = c2.router({
   /**
    * GET /api/agent/runs/:id
    * Get agent run status and results
@@ -1371,8 +1224,8 @@ var runsByIdContract = c3.router({
     method: "GET",
     path: "/api/agent/runs/:id",
     headers: authHeadersSchema,
-    pathParams: z5.object({
-      id: z5.string().min(1, "Run ID is required")
+    pathParams: z4.object({
+      id: z4.string().min(1, "Run ID is required")
     }),
     responses: {
       200: getRunResponseSchema,
@@ -1383,12 +1236,12 @@ var runsByIdContract = c3.router({
     summary: "Get agent run by ID"
   }
 });
-var cancelRunResponseSchema = z5.object({
-  id: z5.string(),
-  status: z5.literal("cancelled"),
-  message: z5.string()
+var cancelRunResponseSchema = z4.object({
+  id: z4.string(),
+  status: z4.literal("cancelled"),
+  message: z4.string()
 });
-var runsCancelContract = c3.router({
+var runsCancelContract = c2.router({
   /**
    * POST /api/agent/runs/:id/cancel
    * Cancel a pending or running run
@@ -1397,10 +1250,10 @@ var runsCancelContract = c3.router({
     method: "POST",
     path: "/api/agent/runs/:id/cancel",
     headers: authHeadersSchema,
-    pathParams: z5.object({
-      id: z5.string().min(1, "Run ID is required")
+    pathParams: z4.object({
+      id: z4.string().min(1, "Run ID is required")
     }),
-    body: z5.undefined(),
+    body: z4.undefined(),
     responses: {
       200: cancelRunResponseSchema,
       400: apiErrorSchema,
@@ -1410,7 +1263,7 @@ var runsCancelContract = c3.router({
     summary: "Cancel a pending or running run"
   }
 });
-var runEventsContract = c3.router({
+var runEventsContract = c2.router({
   /**
    * GET /api/agent/runs/:id/events
    * Poll for agent run events with pagination
@@ -1419,12 +1272,12 @@ var runEventsContract = c3.router({
     method: "GET",
     path: "/api/agent/runs/:id/events",
     headers: authHeadersSchema,
-    pathParams: z5.object({
-      id: z5.string().min(1, "Run ID is required")
+    pathParams: z4.object({
+      id: z4.string().min(1, "Run ID is required")
     }),
-    query: z5.object({
-      since: z5.coerce.number().default(-1),
-      limit: z5.coerce.number().default(100)
+    query: z4.object({
+      since: z4.coerce.number().default(-1),
+      limit: z4.coerce.number().default(100)
     }),
     responses: {
       200: eventsResponseSchema,
@@ -1434,50 +1287,50 @@ var runEventsContract = c3.router({
     summary: "Get agent run events"
   }
 });
-var telemetryMetricSchema = z5.object({
-  ts: z5.string(),
-  cpu: z5.number(),
-  mem_used: z5.number(),
-  mem_total: z5.number(),
-  disk_used: z5.number(),
-  disk_total: z5.number()
+var telemetryMetricSchema = z4.object({
+  ts: z4.string(),
+  cpu: z4.number(),
+  mem_used: z4.number(),
+  mem_total: z4.number(),
+  disk_used: z4.number(),
+  disk_total: z4.number()
 });
-var systemLogResponseSchema = z5.object({
-  systemLog: z5.string(),
-  hasMore: z5.boolean()
+var systemLogResponseSchema = z4.object({
+  systemLog: z4.string(),
+  hasMore: z4.boolean()
 });
-var metricsResponseSchema = z5.object({
-  metrics: z5.array(telemetryMetricSchema),
-  hasMore: z5.boolean()
+var metricsResponseSchema = z4.object({
+  metrics: z4.array(telemetryMetricSchema),
+  hasMore: z4.boolean()
 });
-var agentEventsResponseSchema = z5.object({
-  events: z5.array(runEventSchema),
-  hasMore: z5.boolean(),
-  framework: z5.string()
+var agentEventsResponseSchema = z4.object({
+  events: z4.array(runEventSchema),
+  hasMore: z4.boolean(),
+  framework: z4.string()
 });
-var networkLogEntrySchema = z5.object({
-  timestamp: z5.string(),
-  mode: z5.literal("mitm").optional(),
-  action: z5.enum(["ALLOW", "DENY"]).optional(),
-  host: z5.string().optional(),
-  port: z5.number().optional(),
-  rule_matched: z5.string().nullable().optional(),
-  method: z5.string().optional(),
-  url: z5.string().optional(),
-  status: z5.number().optional(),
-  latency_ms: z5.number().optional(),
-  request_size: z5.number().optional(),
-  response_size: z5.number().optional()
+var networkLogEntrySchema = z4.object({
+  timestamp: z4.string(),
+  mode: z4.literal("mitm").optional(),
+  action: z4.enum(["ALLOW", "DENY"]).optional(),
+  host: z4.string().optional(),
+  port: z4.number().optional(),
+  rule_matched: z4.string().nullable().optional(),
+  method: z4.string().optional(),
+  url: z4.string().optional(),
+  status: z4.number().optional(),
+  latency_ms: z4.number().optional(),
+  request_size: z4.number().optional(),
+  response_size: z4.number().optional()
 });
-var networkLogsResponseSchema = z5.object({
-  networkLogs: z5.array(networkLogEntrySchema),
-  hasMore: z5.boolean()
+var networkLogsResponseSchema = z4.object({
+  networkLogs: z4.array(networkLogEntrySchema),
+  hasMore: z4.boolean()
 });
-var telemetryResponseSchema = z5.object({
-  systemLog: z5.string(),
-  metrics: z5.array(telemetryMetricSchema)
+var telemetryResponseSchema = z4.object({
+  systemLog: z4.string(),
+  metrics: z4.array(telemetryMetricSchema)
 });
-var runTelemetryContract = c3.router({
+var runTelemetryContract = c2.router({
   /**
    * GET /api/agent/runs/:id/telemetry
    * Get aggregated telemetry data for a run (legacy combined format)
@@ -1486,8 +1339,8 @@ var runTelemetryContract = c3.router({
     method: "GET",
     path: "/api/agent/runs/:id/telemetry",
     headers: authHeadersSchema,
-    pathParams: z5.object({
-      id: z5.string().min(1, "Run ID is required")
+    pathParams: z4.object({
+      id: z4.string().min(1, "Run ID is required")
     }),
     responses: {
       200: telemetryResponseSchema,
@@ -1497,7 +1350,7 @@ var runTelemetryContract = c3.router({
     summary: "Get run telemetry data"
   }
 });
-var runSystemLogContract = c3.router({
+var runSystemLogContract = c2.router({
   /**
    * GET /api/agent/runs/:id/telemetry/system-log
    * Get system log with pagination
@@ -1506,13 +1359,13 @@ var runSystemLogContract = c3.router({
     method: "GET",
     path: "/api/agent/runs/:id/telemetry/system-log",
     headers: authHeadersSchema,
-    pathParams: z5.object({
-      id: z5.string().min(1, "Run ID is required")
+    pathParams: z4.object({
+      id: z4.string().min(1, "Run ID is required")
     }),
-    query: z5.object({
-      since: z5.coerce.number().optional(),
-      limit: z5.coerce.number().min(1).max(100).default(5),
-      order: z5.enum(["asc", "desc"]).default("desc")
+    query: z4.object({
+      since: z4.coerce.number().optional(),
+      limit: z4.coerce.number().min(1).max(100).default(5),
+      order: z4.enum(["asc", "desc"]).default("desc")
     }),
     responses: {
       200: systemLogResponseSchema,
@@ -1522,7 +1375,7 @@ var runSystemLogContract = c3.router({
     summary: "Get system log with pagination"
   }
 });
-var runMetricsContract = c3.router({
+var runMetricsContract = c2.router({
   /**
    * GET /api/agent/runs/:id/telemetry/metrics
    * Get metrics with pagination
@@ -1531,13 +1384,13 @@ var runMetricsContract = c3.router({
     method: "GET",
     path: "/api/agent/runs/:id/telemetry/metrics",
     headers: authHeadersSchema,
-    pathParams: z5.object({
-      id: z5.string().min(1, "Run ID is required")
+    pathParams: z4.object({
+      id: z4.string().min(1, "Run ID is required")
     }),
-    query: z5.object({
-      since: z5.coerce.number().optional(),
-      limit: z5.coerce.number().min(1).max(100).default(5),
-      order: z5.enum(["asc", "desc"]).default("desc")
+    query: z4.object({
+      since: z4.coerce.number().optional(),
+      limit: z4.coerce.number().min(1).max(100).default(5),
+      order: z4.enum(["asc", "desc"]).default("desc")
     }),
     responses: {
       200: metricsResponseSchema,
@@ -1547,7 +1400,7 @@ var runMetricsContract = c3.router({
     summary: "Get metrics with pagination"
   }
 });
-var runAgentEventsContract = c3.router({
+var runAgentEventsContract = c2.router({
   /**
    * GET /api/agent/runs/:id/telemetry/agent
    * Get agent events with pagination (for vm0 logs default)
@@ -1556,13 +1409,13 @@ var runAgentEventsContract = c3.router({
     method: "GET",
     path: "/api/agent/runs/:id/telemetry/agent",
     headers: authHeadersSchema,
-    pathParams: z5.object({
-      id: z5.string().min(1, "Run ID is required")
+    pathParams: z4.object({
+      id: z4.string().min(1, "Run ID is required")
     }),
-    query: z5.object({
-      since: z5.coerce.number().optional(),
-      limit: z5.coerce.number().min(1).max(100).default(5),
-      order: z5.enum(["asc", "desc"]).default("desc")
+    query: z4.object({
+      since: z4.coerce.number().optional(),
+      limit: z4.coerce.number().min(1).max(100).default(5),
+      order: z4.enum(["asc", "desc"]).default("desc")
     }),
     responses: {
       200: agentEventsResponseSchema,
@@ -1572,7 +1425,7 @@ var runAgentEventsContract = c3.router({
     summary: "Get agent events with pagination"
   }
 });
-var runNetworkLogsContract = c3.router({
+var runNetworkLogsContract = c2.router({
   /**
    * GET /api/agent/runs/:id/telemetry/network
    * Get network logs with pagination (for vm0 logs --network)
@@ -1581,13 +1434,13 @@ var runNetworkLogsContract = c3.router({
     method: "GET",
     path: "/api/agent/runs/:id/telemetry/network",
     headers: authHeadersSchema,
-    pathParams: z5.object({
-      id: z5.string().min(1, "Run ID is required")
+    pathParams: z4.object({
+      id: z4.string().min(1, "Run ID is required")
     }),
-    query: z5.object({
-      since: z5.coerce.number().optional(),
-      limit: z5.coerce.number().min(1).max(100).default(5),
-      order: z5.enum(["asc", "desc"]).default("desc")
+    query: z4.object({
+      since: z4.coerce.number().optional(),
+      limit: z4.coerce.number().min(1).max(100).default(5),
+      order: z4.enum(["asc", "desc"]).default("desc")
     }),
     responses: {
       200: networkLogsResponseSchema,
@@ -1597,18 +1450,18 @@ var runNetworkLogsContract = c3.router({
     summary: "Get network logs with pagination"
   }
 });
-var searchResultSchema = z5.object({
-  runId: z5.string(),
-  agentName: z5.string(),
+var searchResultSchema = z4.object({
+  runId: z4.string(),
+  agentName: z4.string(),
   matchedEvent: runEventSchema,
-  contextBefore: z5.array(runEventSchema),
-  contextAfter: z5.array(runEventSchema)
+  contextBefore: z4.array(runEventSchema),
+  contextAfter: z4.array(runEventSchema)
 });
-var logsSearchResponseSchema = z5.object({
-  results: z5.array(searchResultSchema),
-  hasMore: z5.boolean()
+var logsSearchResponseSchema = z4.object({
+  results: z4.array(searchResultSchema),
+  hasMore: z4.boolean()
 });
-var logsSearchContract = c3.router({
+var logsSearchContract = c2.router({
   /**
    * GET /api/logs/search
    * Search agent events across runs using keyword matching
@@ -1617,14 +1470,14 @@ var logsSearchContract = c3.router({
     method: "GET",
     path: "/api/logs/search",
     headers: authHeadersSchema,
-    query: z5.object({
-      keyword: z5.string().min(1),
-      agent: z5.string().optional(),
-      runId: z5.string().optional(),
-      since: z5.coerce.number().optional(),
-      limit: z5.coerce.number().min(1).max(50).default(20),
-      before: z5.coerce.number().min(0).max(10).default(0),
-      after: z5.coerce.number().min(0).max(10).default(0)
+    query: z4.object({
+      keyword: z4.string().min(1),
+      agent: z4.string().optional(),
+      runId: z4.string().optional(),
+      since: z4.coerce.number().optional(),
+      limit: z4.coerce.number().min(1).max(50).default(20),
+      before: z4.coerce.number().min(0).max(10).default(0),
+      after: z4.coerce.number().min(0).max(10).default(0)
     }),
     responses: {
       200: logsSearchResponseSchema,
@@ -1635,19 +1488,19 @@ var logsSearchContract = c3.router({
 });
 
 // ../../packages/core/src/contracts/storages.ts
-import { z as z6 } from "zod";
-var c4 = initContract();
-var storageTypeSchema = z6.enum(["volume", "artifact", "memory"]);
-var versionQuerySchema = z6.string().regex(/^[a-f0-9]{8,64}$/i, "Version must be 8-64 hex characters").optional();
-var uploadStorageResponseSchema = z6.object({
-  name: z6.string(),
-  versionId: z6.string(),
-  size: z6.number(),
-  fileCount: z6.number(),
+import { z as z5 } from "zod";
+var c3 = initContract();
+var storageTypeSchema = z5.enum(["volume", "artifact", "memory"]);
+var versionQuerySchema = z5.string().regex(/^[a-f0-9]{8,64}$/i, "Version must be 8-64 hex characters").optional();
+var uploadStorageResponseSchema = z5.object({
+  name: z5.string(),
+  versionId: z5.string(),
+  size: z5.number(),
+  fileCount: z5.number(),
   type: storageTypeSchema,
-  deduplicated: z6.boolean()
+  deduplicated: z5.boolean()
 });
-var storagesContract = c4.router({
+var storagesContract = c3.router({
   /**
    * POST /api/storages
    * Upload a storage (tar.gz file)
@@ -1664,7 +1517,7 @@ var storagesContract = c4.router({
     path: "/api/storages",
     headers: authHeadersSchema,
     contentType: "multipart/form-data",
-    body: c4.type(),
+    body: c3.type(),
     responses: {
       200: uploadStorageResponseSchema,
       400: apiErrorSchema,
@@ -1687,15 +1540,15 @@ var storagesContract = c4.router({
     method: "GET",
     path: "/api/storages",
     headers: authHeadersSchema,
-    query: z6.object({
-      name: z6.string().min(1, "Storage name is required"),
+    query: z5.object({
+      name: z5.string().min(1, "Storage name is required"),
       version: versionQuerySchema
     }),
     responses: {
       // Binary response - actual handling done at route level
-      200: c4.otherResponse({
+      200: c3.otherResponse({
         contentType: "application/gzip",
-        body: c4.type()
+        body: c3.type()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -1706,41 +1559,41 @@ var storagesContract = c4.router({
   }
 });
 var MAX_FILE_SIZE_BYTES = 104857600;
-var fileEntryWithHashSchema = z6.object({
-  path: z6.string().min(1, "File path is required"),
-  hash: z6.string().length(64, "Hash must be SHA-256 (64 hex chars)"),
-  size: z6.number().int().min(0, "Size must be non-negative").max(MAX_FILE_SIZE_BYTES, "File size exceeds 100MB limit")
+var fileEntryWithHashSchema = z5.object({
+  path: z5.string().min(1, "File path is required"),
+  hash: z5.string().length(64, "Hash must be SHA-256 (64 hex chars)"),
+  size: z5.number().int().min(0, "Size must be non-negative").max(MAX_FILE_SIZE_BYTES, "File size exceeds 100MB limit")
 });
-var storageChangesSchema = z6.object({
-  added: z6.array(z6.string()),
-  modified: z6.array(z6.string()),
-  deleted: z6.array(z6.string())
+var storageChangesSchema = z5.object({
+  added: z5.array(z5.string()),
+  modified: z5.array(z5.string()),
+  deleted: z5.array(z5.string())
 });
-var presignedUploadSchema = z6.object({
-  key: z6.string(),
-  presignedUrl: z6.string().url()
+var presignedUploadSchema = z5.object({
+  key: z5.string(),
+  presignedUrl: z5.string().url()
 });
-var storagesPrepareContract = c4.router({
+var storagesPrepareContract = c3.router({
   prepare: {
     method: "POST",
     path: "/api/storages/prepare",
     headers: authHeadersSchema,
-    body: z6.object({
-      storageName: z6.string().min(1, "Storage name is required"),
+    body: z5.object({
+      storageName: z5.string().min(1, "Storage name is required"),
       storageType: storageTypeSchema,
-      files: z6.array(fileEntryWithHashSchema),
-      force: z6.boolean().optional(),
-      runId: z6.string().optional(),
+      files: z5.array(fileEntryWithHashSchema),
+      force: z5.boolean().optional(),
+      runId: z5.string().optional(),
       // For sandbox auth
-      baseVersion: z6.string().optional(),
+      baseVersion: z5.string().optional(),
       // For incremental uploads
       changes: storageChangesSchema.optional()
     }),
     responses: {
-      200: z6.object({
-        versionId: z6.string(),
-        existing: z6.boolean(),
-        uploads: z6.object({
+      200: z5.object({
+        versionId: z5.string(),
+        existing: z5.boolean(),
+        uploads: z5.object({
           archive: presignedUploadSchema,
           manifest: presignedUploadSchema
         }).optional()
@@ -1754,27 +1607,27 @@ var storagesPrepareContract = c4.router({
     summary: "Prepare for direct S3 upload"
   }
 });
-var storagesCommitContract = c4.router({
+var storagesCommitContract = c3.router({
   commit: {
     method: "POST",
     path: "/api/storages/commit",
     headers: authHeadersSchema,
-    body: z6.object({
-      storageName: z6.string().min(1, "Storage name is required"),
+    body: z5.object({
+      storageName: z5.string().min(1, "Storage name is required"),
       storageType: storageTypeSchema,
-      versionId: z6.string().min(1, "Version ID is required"),
-      files: z6.array(fileEntryWithHashSchema),
-      runId: z6.string().optional(),
-      message: z6.string().optional()
+      versionId: z5.string().min(1, "Version ID is required"),
+      files: z5.array(fileEntryWithHashSchema),
+      runId: z5.string().optional(),
+      message: z5.string().optional()
     }),
     responses: {
-      200: z6.object({
-        success: z6.literal(true),
-        versionId: z6.string(),
-        storageName: z6.string(),
-        size: z6.number(),
-        fileCount: z6.number(),
-        deduplicated: z6.boolean().optional()
+      200: z5.object({
+        success: z5.literal(true),
+        versionId: z5.string(),
+        storageName: z5.string(),
+        size: z5.number(),
+        fileCount: z5.number(),
+        deduplicated: z5.boolean().optional()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -1787,31 +1640,31 @@ var storagesCommitContract = c4.router({
     summary: "Commit uploaded storage"
   }
 });
-var storagesDownloadContract = c4.router({
+var storagesDownloadContract = c3.router({
   download: {
     method: "GET",
     path: "/api/storages/download",
     headers: authHeadersSchema,
-    query: z6.object({
-      name: z6.string().min(1, "Storage name is required"),
+    query: z5.object({
+      name: z5.string().min(1, "Storage name is required"),
       type: storageTypeSchema,
       version: versionQuerySchema
     }),
     responses: {
       // Normal response with presigned URL
-      200: z6.union([
-        z6.object({
-          url: z6.string().url(),
-          versionId: z6.string(),
-          fileCount: z6.number(),
-          size: z6.number()
+      200: z5.union([
+        z5.object({
+          url: z5.string().url(),
+          versionId: z5.string(),
+          fileCount: z5.number(),
+          size: z5.number()
         }),
         // Empty artifact response
-        z6.object({
-          empty: z6.literal(true),
-          versionId: z6.string(),
-          fileCount: z6.literal(0),
-          size: z6.literal(0)
+        z5.object({
+          empty: z5.literal(true),
+          versionId: z5.string(),
+          fileCount: z5.literal(0),
+          size: z5.literal(0)
         })
       ]),
       400: apiErrorSchema,
@@ -1822,21 +1675,21 @@ var storagesDownloadContract = c4.router({
     summary: "Get presigned download URL"
   }
 });
-var storagesListContract = c4.router({
+var storagesListContract = c3.router({
   list: {
     method: "GET",
     path: "/api/storages/list",
     headers: authHeadersSchema,
-    query: z6.object({
+    query: z5.object({
       type: storageTypeSchema
     }),
     responses: {
-      200: z6.array(
-        z6.object({
-          name: z6.string(),
-          size: z6.number(),
-          fileCount: z6.number(),
-          updatedAt: z6.string()
+      200: z5.array(
+        z5.object({
+          name: z5.string(),
+          size: z5.number(),
+          fileCount: z5.number(),
+          updatedAt: z5.string()
         })
       ),
       401: apiErrorSchema,
@@ -1847,24 +1700,24 @@ var storagesListContract = c4.router({
 });
 
 // ../../packages/core/src/contracts/webhooks.ts
-import { z as z7 } from "zod";
-var c5 = initContract();
-var agentEventSchema = z7.object({
-  type: z7.string(),
-  sequenceNumber: z7.number().int().nonnegative()
+import { z as z6 } from "zod";
+var c4 = initContract();
+var agentEventSchema = z6.object({
+  type: z6.string(),
+  sequenceNumber: z6.number().int().nonnegative()
 }).passthrough();
-var artifactSnapshotSchema = z7.object({
-  artifactName: z7.string(),
-  artifactVersion: z7.string()
+var artifactSnapshotSchema = z6.object({
+  artifactName: z6.string(),
+  artifactVersion: z6.string()
 });
-var memorySnapshotSchema = z7.object({
-  memoryName: z7.string(),
-  memoryVersion: z7.string()
+var memorySnapshotSchema = z6.object({
+  memoryName: z6.string(),
+  memoryVersion: z6.string()
 });
-var volumeVersionsSnapshotSchema = z7.object({
-  versions: z7.record(z7.string(), z7.string())
+var volumeVersionsSnapshotSchema = z6.object({
+  versions: z6.record(z6.string(), z6.string())
 });
-var webhookEventsContract = c5.router({
+var webhookEventsContract = c4.router({
   /**
    * POST /api/webhooks/agent/events
    * Receive agent events from sandbox
@@ -1873,15 +1726,15 @@ var webhookEventsContract = c5.router({
     method: "POST",
     path: "/api/webhooks/agent/events",
     headers: authHeadersSchema,
-    body: z7.object({
-      runId: z7.string().min(1, "runId is required"),
-      events: z7.array(agentEventSchema).min(1, "events array cannot be empty")
+    body: z6.object({
+      runId: z6.string().min(1, "runId is required"),
+      events: z6.array(agentEventSchema).min(1, "events array cannot be empty")
     }),
     responses: {
-      200: z7.object({
-        received: z7.number(),
-        firstSequence: z7.number(),
-        lastSequence: z7.number()
+      200: z6.object({
+        received: z6.number(),
+        firstSequence: z6.number(),
+        lastSequence: z6.number()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -1891,7 +1744,7 @@ var webhookEventsContract = c5.router({
     summary: "Receive agent events from sandbox"
   }
 });
-var webhookCompleteContract = c5.router({
+var webhookCompleteContract = c4.router({
   /**
    * POST /api/webhooks/agent/complete
    * Handle agent run completion (success or failure)
@@ -1900,15 +1753,15 @@ var webhookCompleteContract = c5.router({
     method: "POST",
     path: "/api/webhooks/agent/complete",
     headers: authHeadersSchema,
-    body: z7.object({
-      runId: z7.string().min(1, "runId is required"),
-      exitCode: z7.number(),
-      error: z7.string().optional()
+    body: z6.object({
+      runId: z6.string().min(1, "runId is required"),
+      exitCode: z6.number(),
+      error: z6.string().optional()
     }),
     responses: {
-      200: z7.object({
-        success: z7.boolean(),
-        status: z7.enum(["completed", "failed"])
+      200: z6.object({
+        success: z6.boolean(),
+        status: z6.enum(["completed", "failed"])
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -1918,7 +1771,7 @@ var webhookCompleteContract = c5.router({
     summary: "Handle agent run completion"
   }
 });
-var webhookCheckpointsContract = c5.router({
+var webhookCheckpointsContract = c4.router({
   /**
    * POST /api/webhooks/agent/checkpoints
    * Create checkpoint for completed agent run
@@ -1927,23 +1780,23 @@ var webhookCheckpointsContract = c5.router({
     method: "POST",
     path: "/api/webhooks/agent/checkpoints",
     headers: authHeadersSchema,
-    body: z7.object({
-      runId: z7.string().min(1, "runId is required"),
-      cliAgentType: z7.string().min(1, "cliAgentType is required"),
-      cliAgentSessionId: z7.string().min(1, "cliAgentSessionId is required"),
-      cliAgentSessionHistory: z7.string().min(1, "cliAgentSessionHistory is required"),
+    body: z6.object({
+      runId: z6.string().min(1, "runId is required"),
+      cliAgentType: z6.string().min(1, "cliAgentType is required"),
+      cliAgentSessionId: z6.string().min(1, "cliAgentSessionId is required"),
+      cliAgentSessionHistory: z6.string().min(1, "cliAgentSessionHistory is required"),
       artifactSnapshot: artifactSnapshotSchema.optional(),
       memorySnapshot: memorySnapshotSchema.optional(),
       volumeVersionsSnapshot: volumeVersionsSnapshotSchema.optional()
     }),
     responses: {
-      200: z7.object({
-        checkpointId: z7.string(),
-        agentSessionId: z7.string(),
-        conversationId: z7.string(),
+      200: z6.object({
+        checkpointId: z6.string(),
+        agentSessionId: z6.string(),
+        conversationId: z6.string(),
         artifact: artifactSnapshotSchema.optional(),
         memory: memorySnapshotSchema.optional(),
-        volumes: z7.record(z7.string(), z7.string()).optional()
+        volumes: z6.record(z6.string(), z6.string()).optional()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -1953,7 +1806,7 @@ var webhookCheckpointsContract = c5.router({
     summary: "Create checkpoint for agent run"
   }
 });
-var webhookHeartbeatContract = c5.router({
+var webhookHeartbeatContract = c4.router({
   /**
    * POST /api/webhooks/agent/heartbeat
    * Receive heartbeat signals from sandbox
@@ -1962,12 +1815,12 @@ var webhookHeartbeatContract = c5.router({
     method: "POST",
     path: "/api/webhooks/agent/heartbeat",
     headers: authHeadersSchema,
-    body: z7.object({
-      runId: z7.string().min(1, "runId is required")
+    body: z6.object({
+      runId: z6.string().min(1, "runId is required")
     }),
     responses: {
-      200: z7.object({
-        ok: z7.boolean()
+      200: z6.object({
+        ok: z6.boolean()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -1977,7 +1830,7 @@ var webhookHeartbeatContract = c5.router({
     summary: "Receive heartbeat from sandbox"
   }
 });
-var webhookStoragesContract = c5.router({
+var webhookStoragesContract = c4.router({
   /**
    * POST /api/webhooks/agent/storages
    * Create a new version of a storage from sandbox
@@ -1993,13 +1846,13 @@ var webhookStoragesContract = c5.router({
     path: "/api/webhooks/agent/storages",
     headers: authHeadersSchema,
     contentType: "multipart/form-data",
-    body: c5.type(),
+    body: c4.type(),
     responses: {
-      200: z7.object({
-        versionId: z7.string(),
-        storageName: z7.string(),
-        size: z7.number(),
-        fileCount: z7.number()
+      200: z6.object({
+        versionId: z6.string(),
+        storageName: z6.string(),
+        size: z6.number(),
+        fileCount: z6.number()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -2009,7 +1862,7 @@ var webhookStoragesContract = c5.router({
     summary: "Upload storage version from sandbox"
   }
 });
-var webhookStoragesIncrementalContract = c5.router({
+var webhookStoragesIncrementalContract = c4.router({
   /**
    * POST /api/webhooks/agent/storages/incremental
    * Create a new version using incremental upload
@@ -2027,19 +1880,19 @@ var webhookStoragesIncrementalContract = c5.router({
     path: "/api/webhooks/agent/storages/incremental",
     headers: authHeadersSchema,
     contentType: "multipart/form-data",
-    body: c5.type(),
+    body: c4.type(),
     responses: {
-      200: z7.object({
-        versionId: z7.string(),
-        storageName: z7.string(),
-        size: z7.number(),
-        fileCount: z7.number(),
-        incrementalStats: z7.object({
-          addedFiles: z7.number(),
-          modifiedFiles: z7.number(),
-          deletedFiles: z7.number(),
-          unchangedFiles: z7.number(),
-          bytesUploaded: z7.number()
+      200: z6.object({
+        versionId: z6.string(),
+        storageName: z6.string(),
+        size: z6.number(),
+        fileCount: z6.number(),
+        incrementalStats: z6.object({
+          addedFiles: z6.number(),
+          modifiedFiles: z6.number(),
+          deletedFiles: z6.number(),
+          unchangedFiles: z6.number(),
+          bytesUploaded: z6.number()
         }).optional()
       }),
       400: apiErrorSchema,
@@ -2050,36 +1903,36 @@ var webhookStoragesIncrementalContract = c5.router({
     summary: "Upload storage version incrementally from sandbox"
   }
 });
-var metricDataSchema = z7.object({
-  ts: z7.string(),
-  cpu: z7.number(),
-  mem_used: z7.number(),
-  mem_total: z7.number(),
-  disk_used: z7.number(),
-  disk_total: z7.number()
+var metricDataSchema = z6.object({
+  ts: z6.string(),
+  cpu: z6.number(),
+  mem_used: z6.number(),
+  mem_total: z6.number(),
+  disk_used: z6.number(),
+  disk_total: z6.number()
 });
-var sandboxOperationSchema = z7.object({
-  ts: z7.string(),
-  action_type: z7.string(),
-  duration_ms: z7.number(),
-  success: z7.boolean(),
-  error: z7.string().optional()
+var sandboxOperationSchema = z6.object({
+  ts: z6.string(),
+  action_type: z6.string(),
+  duration_ms: z6.number(),
+  success: z6.boolean(),
+  error: z6.string().optional()
 });
-var networkLogSchema = z7.object({
-  timestamp: z7.string(),
-  mode: z7.literal("mitm").optional(),
-  action: z7.enum(["ALLOW", "DENY"]).optional(),
-  host: z7.string().optional(),
-  port: z7.number().optional(),
-  rule_matched: z7.string().nullable().optional(),
-  method: z7.string().optional(),
-  url: z7.string().optional(),
-  status: z7.number().optional(),
-  latency_ms: z7.number().optional(),
-  request_size: z7.number().optional(),
-  response_size: z7.number().optional()
+var networkLogSchema = z6.object({
+  timestamp: z6.string(),
+  mode: z6.literal("mitm").optional(),
+  action: z6.enum(["ALLOW", "DENY"]).optional(),
+  host: z6.string().optional(),
+  port: z6.number().optional(),
+  rule_matched: z6.string().nullable().optional(),
+  method: z6.string().optional(),
+  url: z6.string().optional(),
+  status: z6.number().optional(),
+  latency_ms: z6.number().optional(),
+  request_size: z6.number().optional(),
+  response_size: z6.number().optional()
 });
-var webhookTelemetryContract = c5.router({
+var webhookTelemetryContract = c4.router({
   /**
    * POST /api/webhooks/agent/telemetry
    * Receive telemetry data (system log, metrics, network logs, and sandbox operations) from sandbox
@@ -2088,17 +1941,17 @@ var webhookTelemetryContract = c5.router({
     method: "POST",
     path: "/api/webhooks/agent/telemetry",
     headers: authHeadersSchema,
-    body: z7.object({
-      runId: z7.string().min(1, "runId is required"),
-      systemLog: z7.string().optional(),
-      metrics: z7.array(metricDataSchema).optional(),
-      networkLogs: z7.array(networkLogSchema).optional(),
-      sandboxOperations: z7.array(sandboxOperationSchema).optional()
+    body: z6.object({
+      runId: z6.string().min(1, "runId is required"),
+      systemLog: z6.string().optional(),
+      metrics: z6.array(metricDataSchema).optional(),
+      networkLogs: z6.array(networkLogSchema).optional(),
+      sandboxOperations: z6.array(sandboxOperationSchema).optional()
     }),
     responses: {
-      200: z7.object({
-        success: z7.boolean(),
-        id: z7.string()
+      200: z6.object({
+        success: z6.boolean(),
+        id: z6.string()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -2108,26 +1961,26 @@ var webhookTelemetryContract = c5.router({
     summary: "Receive telemetry data from sandbox"
   }
 });
-var webhookStoragesPrepareContract = c5.router({
+var webhookStoragesPrepareContract = c4.router({
   prepare: {
     method: "POST",
     path: "/api/webhooks/agent/storages/prepare",
     headers: authHeadersSchema,
-    body: z7.object({
-      runId: z7.string().min(1, "runId is required"),
+    body: z6.object({
+      runId: z6.string().min(1, "runId is required"),
       // Required for webhook auth
-      storageName: z7.string().min(1, "Storage name is required"),
+      storageName: z6.string().min(1, "Storage name is required"),
       storageType: storageTypeSchema,
-      files: z7.array(fileEntryWithHashSchema),
-      force: z7.boolean().optional(),
-      baseVersion: z7.string().optional(),
+      files: z6.array(fileEntryWithHashSchema),
+      force: z6.boolean().optional(),
+      baseVersion: z6.string().optional(),
       changes: storageChangesSchema.optional()
     }),
     responses: {
-      200: z7.object({
-        versionId: z7.string(),
-        existing: z7.boolean(),
-        uploads: z7.object({
+      200: z6.object({
+        versionId: z6.string(),
+        existing: z6.boolean(),
+        uploads: z6.object({
           archive: presignedUploadSchema,
           manifest: presignedUploadSchema
         }).optional()
@@ -2141,28 +1994,28 @@ var webhookStoragesPrepareContract = c5.router({
     summary: "Prepare for direct S3 upload from sandbox"
   }
 });
-var webhookStoragesCommitContract = c5.router({
+var webhookStoragesCommitContract = c4.router({
   commit: {
     method: "POST",
     path: "/api/webhooks/agent/storages/commit",
     headers: authHeadersSchema,
-    body: z7.object({
-      runId: z7.string().min(1, "runId is required"),
+    body: z6.object({
+      runId: z6.string().min(1, "runId is required"),
       // Required for webhook auth
-      storageName: z7.string().min(1, "Storage name is required"),
+      storageName: z6.string().min(1, "Storage name is required"),
       storageType: storageTypeSchema,
-      versionId: z7.string().min(1, "Version ID is required"),
-      files: z7.array(fileEntryWithHashSchema),
-      message: z7.string().optional()
+      versionId: z6.string().min(1, "Version ID is required"),
+      files: z6.array(fileEntryWithHashSchema),
+      message: z6.string().optional()
     }),
     responses: {
-      200: z7.object({
-        success: z7.literal(true),
-        versionId: z7.string(),
-        storageName: z7.string(),
-        size: z7.number(),
-        fileCount: z7.number(),
-        deduplicated: z7.boolean().optional()
+      200: z6.object({
+        success: z6.literal(true),
+        versionId: z6.string(),
+        storageName: z6.string(),
+        size: z6.number(),
+        fileCount: z6.number(),
+        deduplicated: z6.boolean().optional()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -2177,13 +2030,13 @@ var webhookStoragesCommitContract = c5.router({
 });
 
 // ../../packages/core/src/contracts/cli-auth.ts
-import { z as z8 } from "zod";
-var c6 = initContract();
-var oauthErrorSchema = z8.object({
-  error: z8.string(),
-  error_description: z8.string()
+import { z as z7 } from "zod";
+var c5 = initContract();
+var oauthErrorSchema = z7.object({
+  error: z7.string(),
+  error_description: z7.string()
 });
-var cliAuthDeviceContract = c6.router({
+var cliAuthDeviceContract = c5.router({
   /**
    * POST /api/cli/auth/device
    * Initiate device authorization flow
@@ -2191,21 +2044,21 @@ var cliAuthDeviceContract = c6.router({
   create: {
     method: "POST",
     path: "/api/cli/auth/device",
-    body: z8.object({}).optional(),
+    body: z7.object({}).optional(),
     responses: {
-      200: z8.object({
-        device_code: z8.string(),
-        user_code: z8.string(),
-        verification_path: z8.string(),
-        expires_in: z8.number(),
-        interval: z8.number()
+      200: z7.object({
+        device_code: z7.string(),
+        user_code: z7.string(),
+        verification_path: z7.string(),
+        expires_in: z7.number(),
+        interval: z7.number()
       }),
       500: oauthErrorSchema
     },
     summary: "Initiate device authorization flow"
   }
 });
-var cliAuthTokenContract = c6.router({
+var cliAuthTokenContract = c5.router({
   /**
    * POST /api/cli/auth/token
    * Exchange device code for access token
@@ -2213,16 +2066,16 @@ var cliAuthTokenContract = c6.router({
   exchange: {
     method: "POST",
     path: "/api/cli/auth/token",
-    body: z8.object({
-      device_code: z8.string().min(1, "device_code is required")
+    body: z7.object({
+      device_code: z7.string().min(1, "device_code is required")
     }),
     responses: {
       // Success - token issued
-      200: z8.object({
-        access_token: z8.string(),
-        token_type: z8.literal("Bearer"),
-        expires_in: z8.number(),
-        org_slug: z8.string().optional()
+      200: z7.object({
+        access_token: z7.string(),
+        token_type: z7.literal("Bearer"),
+        expires_in: z7.number(),
+        org_slug: z7.string().optional()
       }),
       // Authorization pending
       202: oauthErrorSchema,
@@ -2235,9 +2088,9 @@ var cliAuthTokenContract = c6.router({
 });
 
 // ../../packages/core/src/contracts/auth.ts
-import { z as z9 } from "zod";
-var c7 = initContract();
-var authContract = c7.router({
+import { z as z8 } from "zod";
+var c6 = initContract();
+var authContract = c6.router({
   /**
    * GET /api/auth/me
    * Get current user information
@@ -2247,9 +2100,9 @@ var authContract = c7.router({
     path: "/api/auth/me",
     headers: authHeadersSchema,
     responses: {
-      200: z9.object({
-        userId: z9.string(),
-        email: z9.string()
+      200: z8.object({
+        userId: z8.string(),
+        email: z8.string()
       }),
       401: apiErrorSchema,
       404: apiErrorSchema,
@@ -2260,23 +2113,23 @@ var authContract = c7.router({
 });
 
 // ../../packages/core/src/contracts/cron.ts
-import { z as z10 } from "zod";
-var c8 = initContract();
-var cleanupResultSchema = z10.object({
-  runId: z10.string(),
-  sandboxId: z10.string().nullable(),
-  status: z10.enum(["cleaned", "error"]),
-  error: z10.string().optional(),
-  reason: z10.string().optional()
+import { z as z9 } from "zod";
+var c7 = initContract();
+var cleanupResultSchema = z9.object({
+  runId: z9.string(),
+  sandboxId: z9.string().nullable(),
+  status: z9.enum(["cleaned", "error"]),
+  error: z9.string().optional(),
+  reason: z9.string().optional()
 });
-var cleanupResponseSchema = z10.object({
-  cleaned: z10.number(),
-  errors: z10.number(),
-  results: z10.array(cleanupResultSchema),
-  composeJobsCleaned: z10.number(),
-  composeJobErrors: z10.number()
+var cleanupResponseSchema = z9.object({
+  cleaned: z9.number(),
+  errors: z9.number(),
+  results: z9.array(cleanupResultSchema),
+  composeJobsCleaned: z9.number(),
+  composeJobErrors: z9.number()
 });
-var cronCleanupSandboxesContract = c8.router({
+var cronCleanupSandboxesContract = c7.router({
   /**
    * GET /api/cron/cleanup-sandboxes
    * Cron job to cleanup sandboxes that have stopped sending heartbeats
@@ -2295,23 +2148,23 @@ var cronCleanupSandboxesContract = c8.router({
 });
 
 // ../../packages/core/src/contracts/orgs.ts
-import { z as z11 } from "zod";
-var c9 = initContract();
-var orgTierSchema = z11.enum(["free", "pro", "max"]);
-var orgSlugSchema = z11.string().min(3, "Org slug must be at least 3 characters").max(64, "Org slug must be at most 64 characters").regex(
+import { z as z10 } from "zod";
+var c8 = initContract();
+var orgTierSchema = z10.enum(["free", "pro", "max"]);
+var orgSlugSchema = z10.string().min(3, "Org slug must be at least 3 characters").max(64, "Org slug must be at most 64 characters").regex(
   /^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]{1,2}$/,
   "Org slug must contain only lowercase letters, numbers, and hyphens, and must start and end with an alphanumeric character"
 ).transform((s) => s.toLowerCase());
-var orgResponseSchema = z11.object({
-  id: z11.string(),
-  slug: z11.string(),
-  tier: z11.string().optional()
+var orgResponseSchema = z10.object({
+  id: z10.string(),
+  slug: z10.string(),
+  tier: z10.string().optional()
 });
-var updateOrgRequestSchema = z11.object({
+var updateOrgRequestSchema = z10.object({
   slug: orgSlugSchema,
-  force: z11.boolean().optional().default(false)
+  force: z10.boolean().optional().default(false)
 });
-var orgContract = c9.router({
+var orgContract = c8.router({
   /**
    * GET /api/org
    * Get current user's default org
@@ -2349,7 +2202,7 @@ var orgContract = c9.router({
     summary: "Update org slug"
   }
 });
-var orgDefaultAgentContract = c9.router({
+var orgDefaultAgentContract = c8.router({
   /**
    * PUT /api/orgs/default-agent?org={slug}
    * Set or unset the default agent for an org.
@@ -2360,15 +2213,15 @@ var orgDefaultAgentContract = c9.router({
     method: "PUT",
     path: "/api/orgs/default-agent",
     headers: authHeadersSchema,
-    query: z11.object({
-      org: z11.string().optional()
+    query: z10.object({
+      org: z10.string().optional()
     }),
-    body: z11.object({
-      agentComposeId: z11.string().uuid().nullable()
+    body: z10.object({
+      agentComposeId: z10.string().uuid().nullable()
     }),
     responses: {
-      200: z11.object({
-        agentComposeId: z11.string().uuid().nullable()
+      200: z10.object({
+        agentComposeId: z10.string().uuid().nullable()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -2380,30 +2233,30 @@ var orgDefaultAgentContract = c9.router({
 });
 
 // ../../packages/core/src/contracts/secrets.ts
-import { z as z12 } from "zod";
-var c10 = initContract();
-var secretNameSchema = z12.string().min(1, "Secret name is required").max(255, "Secret name must be at most 255 characters").regex(
+import { z as z11 } from "zod";
+var c9 = initContract();
+var secretNameSchema = z11.string().min(1, "Secret name is required").max(255, "Secret name must be at most 255 characters").regex(
   /^[A-Z][A-Z0-9_]*$/,
   "Secret name must contain only uppercase letters, numbers, and underscores, and must start with a letter (e.g., MY_API_KEY)"
 );
-var secretTypeSchema = z12.enum(["user", "model-provider", "connector"]);
-var secretResponseSchema = z12.object({
-  id: z12.string().uuid(),
-  name: z12.string(),
-  description: z12.string().nullable(),
+var secretTypeSchema = z11.enum(["user", "model-provider", "connector"]);
+var secretResponseSchema = z11.object({
+  id: z11.string().uuid(),
+  name: z11.string(),
+  description: z11.string().nullable(),
   type: secretTypeSchema,
-  createdAt: z12.string(),
-  updatedAt: z12.string()
+  createdAt: z11.string(),
+  updatedAt: z11.string()
 });
-var secretListResponseSchema = z12.object({
-  secrets: z12.array(secretResponseSchema)
+var secretListResponseSchema = z11.object({
+  secrets: z11.array(secretResponseSchema)
 });
-var setSecretRequestSchema = z12.object({
+var setSecretRequestSchema = z11.object({
   name: secretNameSchema,
-  value: z12.string().min(1, "Secret value is required"),
-  description: z12.string().max(1e3).optional()
+  value: z11.string().min(1, "Secret value is required"),
+  description: z11.string().max(1e3).optional()
 });
-var secretsMainContract = c10.router({
+var secretsMainContract = c9.router({
   /**
    * GET /api/secrets
    * List all secrets for the current user's org (metadata only)
@@ -2438,7 +2291,7 @@ var secretsMainContract = c10.router({
     summary: "Create or update a secret"
   }
 });
-var secretsByNameContract = c10.router({
+var secretsByNameContract = c9.router({
   /**
    * GET /api/secrets/:name
    * Get a secret by name (metadata only)
@@ -2447,7 +2300,7 @@ var secretsByNameContract = c10.router({
     method: "GET",
     path: "/api/secrets/:name",
     headers: authHeadersSchema,
-    pathParams: z12.object({
+    pathParams: z11.object({
       name: secretNameSchema
     }),
     responses: {
@@ -2466,11 +2319,11 @@ var secretsByNameContract = c10.router({
     method: "DELETE",
     path: "/api/secrets/:name",
     headers: authHeadersSchema,
-    pathParams: z12.object({
+    pathParams: z11.object({
       name: secretNameSchema
     }),
     responses: {
-      204: c10.noBody(),
+      204: c9.noBody(),
       401: apiErrorSchema,
       404: apiErrorSchema,
       500: apiErrorSchema
@@ -2480,29 +2333,29 @@ var secretsByNameContract = c10.router({
 });
 
 // ../../packages/core/src/contracts/variables.ts
-import { z as z13 } from "zod";
-var c11 = initContract();
-var variableNameSchema = z13.string().min(1, "Variable name is required").max(255, "Variable name must be at most 255 characters").regex(
+import { z as z12 } from "zod";
+var c10 = initContract();
+var variableNameSchema = z12.string().min(1, "Variable name is required").max(255, "Variable name must be at most 255 characters").regex(
   /^[A-Z][A-Z0-9_]*$/,
   "Variable name must contain only uppercase letters, numbers, and underscores, and must start with a letter (e.g., MY_VAR)"
 );
-var variableResponseSchema = z13.object({
-  id: z13.string().uuid(),
-  name: z13.string(),
-  value: z13.string(),
-  description: z13.string().nullable(),
-  createdAt: z13.string(),
-  updatedAt: z13.string()
+var variableResponseSchema = z12.object({
+  id: z12.string().uuid(),
+  name: z12.string(),
+  value: z12.string(),
+  description: z12.string().nullable(),
+  createdAt: z12.string(),
+  updatedAt: z12.string()
 });
-var variableListResponseSchema = z13.object({
-  variables: z13.array(variableResponseSchema)
+var variableListResponseSchema = z12.object({
+  variables: z12.array(variableResponseSchema)
 });
-var setVariableRequestSchema = z13.object({
+var setVariableRequestSchema = z12.object({
   name: variableNameSchema,
-  value: z13.string().min(1, "Variable value is required"),
-  description: z13.string().max(1e3).optional()
+  value: z12.string().min(1, "Variable value is required"),
+  description: z12.string().max(1e3).optional()
 });
-var variablesMainContract = c11.router({
+var variablesMainContract = c10.router({
   /**
    * GET /api/variables
    * List all variables for the current user's org (includes values)
@@ -2537,7 +2390,7 @@ var variablesMainContract = c11.router({
     summary: "Create or update a variable"
   }
 });
-var variablesByNameContract = c11.router({
+var variablesByNameContract = c10.router({
   /**
    * GET /api/variables/:name
    * Get a variable by name (includes value)
@@ -2546,7 +2399,7 @@ var variablesByNameContract = c11.router({
     method: "GET",
     path: "/api/variables/:name",
     headers: authHeadersSchema,
-    pathParams: z13.object({
+    pathParams: z12.object({
       name: variableNameSchema
     }),
     responses: {
@@ -2565,11 +2418,11 @@ var variablesByNameContract = c11.router({
     method: "DELETE",
     path: "/api/variables/:name",
     headers: authHeadersSchema,
-    pathParams: z13.object({
+    pathParams: z12.object({
       name: variableNameSchema
     }),
     responses: {
-      204: c11.noBody(),
+      204: c10.noBody(),
       401: apiErrorSchema,
       404: apiErrorSchema,
       500: apiErrorSchema
@@ -2579,8 +2432,8 @@ var variablesByNameContract = c11.router({
 });
 
 // ../../packages/core/src/contracts/model-providers.ts
-import { z as z14 } from "zod";
-var c12 = initContract();
+import { z as z13 } from "zod";
+var c11 = initContract();
 var MODEL_PROVIDER_TYPES = {
   "claude-code-oauth-token": {
     framework: "claude-code",
@@ -2801,7 +2654,7 @@ var MODEL_PROVIDER_TYPES = {
     customModelPlaceholder: "anthropic.claude-sonnet-4-20250514-v1:0"
   }
 };
-var modelProviderTypeSchema = z14.enum([
+var modelProviderTypeSchema = z13.enum([
   "claude-code-oauth-token",
   "anthropic-api-key",
   "openrouter-api-key",
@@ -2812,7 +2665,7 @@ var modelProviderTypeSchema = z14.enum([
   "azure-foundry",
   "aws-bedrock"
 ]);
-var modelProviderFrameworkSchema = z14.enum(["claude-code", "codex"]);
+var modelProviderFrameworkSchema = z13.enum(["claude-code", "codex"]);
 function hasAuthMethods(type2) {
   const config = MODEL_PROVIDER_TYPES[type2];
   return "authMethods" in config;
@@ -2853,43 +2706,43 @@ function getCustomModelPlaceholder(type2) {
   const config = MODEL_PROVIDER_TYPES[type2];
   return "customModelPlaceholder" in config ? config.customModelPlaceholder : void 0;
 }
-var modelProviderResponseSchema = z14.object({
-  id: z14.string().uuid(),
+var modelProviderResponseSchema = z13.object({
+  id: z13.string().uuid(),
   type: modelProviderTypeSchema,
   framework: modelProviderFrameworkSchema,
-  secretName: z14.string().nullable(),
+  secretName: z13.string().nullable(),
   // Legacy single-secret (deprecated for multi-auth)
-  authMethod: z14.string().nullable(),
+  authMethod: z13.string().nullable(),
   // For multi-auth providers
-  secretNames: z14.array(z14.string()).nullable(),
+  secretNames: z13.array(z13.string()).nullable(),
   // For multi-auth providers
-  isDefault: z14.boolean(),
-  selectedModel: z14.string().nullable(),
-  createdAt: z14.string(),
-  updatedAt: z14.string()
+  isDefault: z13.boolean(),
+  selectedModel: z13.string().nullable(),
+  createdAt: z13.string(),
+  updatedAt: z13.string()
 });
-var modelProviderListResponseSchema = z14.object({
-  modelProviders: z14.array(modelProviderResponseSchema)
+var modelProviderListResponseSchema = z13.object({
+  modelProviders: z13.array(modelProviderResponseSchema)
 });
-var upsertModelProviderRequestSchema = z14.object({
+var upsertModelProviderRequestSchema = z13.object({
   type: modelProviderTypeSchema,
-  secret: z14.string().min(1).optional(),
+  secret: z13.string().min(1).optional(),
   // Legacy single secret
-  authMethod: z14.string().optional(),
+  authMethod: z13.string().optional(),
   // For multi-auth providers
-  secrets: z14.record(z14.string(), z14.string()).optional(),
+  secrets: z13.record(z13.string(), z13.string()).optional(),
   // For multi-auth providers
-  selectedModel: z14.string().optional()
+  selectedModel: z13.string().optional()
 });
-var upsertModelProviderResponseSchema = z14.object({
+var upsertModelProviderResponseSchema = z13.object({
   provider: modelProviderResponseSchema,
-  created: z14.boolean()
+  created: z13.boolean()
 });
-var checkSecretResponseSchema = z14.object({
-  exists: z14.boolean(),
-  secretName: z14.string()
+var checkSecretResponseSchema = z13.object({
+  exists: z13.boolean(),
+  secretName: z13.string()
 });
-var modelProvidersMainContract = c12.router({
+var modelProvidersMainContract = c11.router({
   list: {
     method: "GET",
     path: "/api/model-providers",
@@ -2917,12 +2770,12 @@ var modelProvidersMainContract = c12.router({
     summary: "Create or update a model provider"
   }
 });
-var modelProvidersCheckContract = c12.router({
+var modelProvidersCheckContract = c11.router({
   check: {
     method: "GET",
     path: "/api/model-providers/check/:type",
     headers: authHeadersSchema,
-    pathParams: z14.object({
+    pathParams: z13.object({
       type: modelProviderTypeSchema
     }),
     responses: {
@@ -2933,16 +2786,16 @@ var modelProvidersCheckContract = c12.router({
     summary: "Check if secret exists for a model provider type"
   }
 });
-var modelProvidersByTypeContract = c12.router({
+var modelProvidersByTypeContract = c11.router({
   delete: {
     method: "DELETE",
     path: "/api/model-providers/:type",
     headers: authHeadersSchema,
-    pathParams: z14.object({
+    pathParams: z13.object({
       type: modelProviderTypeSchema
     }),
     responses: {
-      204: c12.noBody(),
+      204: c11.noBody(),
       401: apiErrorSchema,
       404: apiErrorSchema,
       500: apiErrorSchema
@@ -2950,15 +2803,15 @@ var modelProvidersByTypeContract = c12.router({
     summary: "Delete a model provider"
   }
 });
-var modelProvidersConvertContract = c12.router({
+var modelProvidersConvertContract = c11.router({
   convert: {
     method: "POST",
     path: "/api/model-providers/:type/convert",
     headers: authHeadersSchema,
-    pathParams: z14.object({
+    pathParams: z13.object({
       type: modelProviderTypeSchema
     }),
-    body: z14.undefined(),
+    body: z13.undefined(),
     responses: {
       200: modelProviderResponseSchema,
       400: apiErrorSchema,
@@ -2969,15 +2822,15 @@ var modelProvidersConvertContract = c12.router({
     summary: "Convert existing user secret to model provider"
   }
 });
-var modelProvidersSetDefaultContract = c12.router({
+var modelProvidersSetDefaultContract = c11.router({
   setDefault: {
     method: "POST",
     path: "/api/model-providers/:type/set-default",
     headers: authHeadersSchema,
-    pathParams: z14.object({
+    pathParams: z13.object({
       type: modelProviderTypeSchema
     }),
-    body: z14.undefined(),
+    body: z13.undefined(),
     responses: {
       200: modelProviderResponseSchema,
       401: apiErrorSchema,
@@ -2987,15 +2840,15 @@ var modelProvidersSetDefaultContract = c12.router({
     summary: "Set a model provider as default for its framework"
   }
 });
-var updateModelRequestSchema = z14.object({
-  selectedModel: z14.string().optional()
+var updateModelRequestSchema = z13.object({
+  selectedModel: z13.string().optional()
 });
-var modelProvidersUpdateModelContract = c12.router({
+var modelProvidersUpdateModelContract = c11.router({
   updateModel: {
     method: "PATCH",
     path: "/api/model-providers/:type/model",
     headers: authHeadersSchema,
-    pathParams: z14.object({
+    pathParams: z13.object({
       type: modelProviderTypeSchema
     }),
     body: updateModelRequestSchema,
@@ -3010,53 +2863,53 @@ var modelProvidersUpdateModelContract = c12.router({
 });
 
 // ../../packages/core/src/contracts/sessions.ts
-import { z as z15 } from "zod";
-var c13 = initContract();
-var storedChatMessageSchema = z15.object({
-  role: z15.enum(["user", "assistant"]),
-  content: z15.string(),
-  runId: z15.string().optional(),
-  createdAt: z15.string()
+import { z as z14 } from "zod";
+var c12 = initContract();
+var storedChatMessageSchema = z14.object({
+  role: z14.enum(["user", "assistant"]),
+  content: z14.string(),
+  runId: z14.string().optional(),
+  createdAt: z14.string()
 });
-var sessionResponseSchema = z15.object({
-  id: z15.string(),
-  agentComposeId: z15.string(),
-  conversationId: z15.string().nullable(),
-  artifactName: z15.string().nullable(),
-  secretNames: z15.array(z15.string()).nullable(),
-  chatMessages: z15.array(storedChatMessageSchema).optional(),
-  createdAt: z15.string(),
-  updatedAt: z15.string()
+var sessionResponseSchema = z14.object({
+  id: z14.string(),
+  agentComposeId: z14.string(),
+  conversationId: z14.string().nullable(),
+  artifactName: z14.string().nullable(),
+  secretNames: z14.array(z14.string()).nullable(),
+  chatMessages: z14.array(storedChatMessageSchema).optional(),
+  createdAt: z14.string(),
+  updatedAt: z14.string()
 });
-var sessionListItemSchema = z15.object({
-  id: z15.string(),
-  createdAt: z15.string(),
-  updatedAt: z15.string(),
-  messageCount: z15.number(),
-  preview: z15.string().nullable()
+var sessionListItemSchema = z14.object({
+  id: z14.string(),
+  createdAt: z14.string(),
+  updatedAt: z14.string(),
+  messageCount: z14.number(),
+  preview: z14.string().nullable()
 });
-var agentComposeSnapshotSchema = z15.object({
-  agentComposeVersionId: z15.string(),
-  vars: z15.record(z15.string(), z15.string()).optional(),
-  secretNames: z15.array(z15.string()).optional()
+var agentComposeSnapshotSchema = z14.object({
+  agentComposeVersionId: z14.string(),
+  vars: z14.record(z14.string(), z14.string()).optional(),
+  secretNames: z14.array(z14.string()).optional()
 });
-var artifactSnapshotSchema2 = z15.object({
-  artifactName: z15.string(),
-  artifactVersion: z15.string()
+var artifactSnapshotSchema2 = z14.object({
+  artifactName: z14.string(),
+  artifactVersion: z14.string()
 });
-var volumeVersionsSnapshotSchema2 = z15.object({
-  versions: z15.record(z15.string(), z15.string())
+var volumeVersionsSnapshotSchema2 = z14.object({
+  versions: z14.record(z14.string(), z14.string())
 });
-var checkpointResponseSchema = z15.object({
-  id: z15.string(),
-  runId: z15.string(),
-  conversationId: z15.string(),
+var checkpointResponseSchema = z14.object({
+  id: z14.string(),
+  runId: z14.string(),
+  conversationId: z14.string(),
   agentComposeSnapshot: agentComposeSnapshotSchema,
   artifactSnapshot: artifactSnapshotSchema2.nullable(),
   volumeVersionsSnapshot: volumeVersionsSnapshotSchema2.nullable(),
-  createdAt: z15.string()
+  createdAt: z14.string()
 });
-var sessionsContract = c13.router({
+var sessionsContract = c12.router({
   /**
    * GET /api/agent/sessions?agentComposeId=X
    * List chat sessions for an agent
@@ -3065,17 +2918,17 @@ var sessionsContract = c13.router({
     method: "GET",
     path: "/api/agent/sessions",
     headers: authHeadersSchema,
-    query: z15.object({
-      agentComposeId: z15.string().min(1, "agentComposeId is required")
+    query: z14.object({
+      agentComposeId: z14.string().min(1, "agentComposeId is required")
     }),
     responses: {
-      200: z15.object({ sessions: z15.array(sessionListItemSchema) }),
+      200: z14.object({ sessions: z14.array(sessionListItemSchema) }),
       401: apiErrorSchema
     },
     summary: "List chat sessions for an agent"
   }
 });
-var sessionsByIdContract = c13.router({
+var sessionsByIdContract = c12.router({
   /**
    * GET /api/agent/sessions/:id
    * Get session by ID
@@ -3084,8 +2937,8 @@ var sessionsByIdContract = c13.router({
     method: "GET",
     path: "/api/agent/sessions/:id",
     headers: authHeadersSchema,
-    pathParams: z15.object({
-      id: z15.string().min(1, "Session ID is required")
+    pathParams: z14.object({
+      id: z14.string().min(1, "Session ID is required")
     }),
     responses: {
       200: sessionResponseSchema,
@@ -3096,7 +2949,7 @@ var sessionsByIdContract = c13.router({
     summary: "Get session by ID"
   }
 });
-var sessionMessagesContract = c13.router({
+var sessionMessagesContract = c12.router({
   /**
    * POST /api/agent/sessions/:id/messages
    * Append chat messages to a session
@@ -3105,20 +2958,20 @@ var sessionMessagesContract = c13.router({
     method: "POST",
     path: "/api/agent/sessions/:id/messages",
     headers: authHeadersSchema,
-    pathParams: z15.object({
-      id: z15.string().min(1, "Session ID is required")
+    pathParams: z14.object({
+      id: z14.string().min(1, "Session ID is required")
     }),
-    body: z15.object({
-      messages: z15.array(
-        z15.object({
-          role: z15.enum(["user", "assistant"]),
-          content: z15.string(),
-          runId: z15.string().optional()
+    body: z14.object({
+      messages: z14.array(
+        z14.object({
+          role: z14.enum(["user", "assistant"]),
+          content: z14.string(),
+          runId: z14.string().optional()
         })
       )
     }),
     responses: {
-      200: z15.object({ success: z15.literal(true) }),
+      200: z14.object({ success: z14.literal(true) }),
       401: apiErrorSchema,
       403: apiErrorSchema,
       404: apiErrorSchema
@@ -3126,7 +2979,7 @@ var sessionMessagesContract = c13.router({
     summary: "Append chat messages to a session"
   }
 });
-var checkpointsByIdContract = c13.router({
+var checkpointsByIdContract = c12.router({
   /**
    * GET /api/agent/checkpoints/:id
    * Get checkpoint by ID
@@ -3135,8 +2988,8 @@ var checkpointsByIdContract = c13.router({
     method: "GET",
     path: "/api/agent/checkpoints/:id",
     headers: authHeadersSchema,
-    pathParams: z15.object({
-      id: z15.string().min(1, "Checkpoint ID is required")
+    pathParams: z14.object({
+      id: z14.string().min(1, "Checkpoint ID is required")
     }),
     responses: {
       200: checkpointResponseSchema,
@@ -3148,6 +3001,155 @@ var checkpointsByIdContract = c13.router({
   }
 });
 
+// ../../packages/core/src/contracts/runners.ts
+import { z as z15 } from "zod";
+var c13 = initContract();
+var runnerGroupSchema = z15.string().regex(
+  /^[a-z0-9-]+\/[a-z0-9-]+$/,
+  "Runner group must be in org/name format (e.g., acme/production)"
+);
+var jobSchema = z15.object({
+  runId: z15.string().uuid(),
+  prompt: z15.string(),
+  agentComposeVersionId: z15.string().nullable(),
+  vars: z15.record(z15.string(), z15.string()).nullable(),
+  checkpointId: z15.string().uuid().nullable()
+});
+var runnersPollContract = c13.router({
+  poll: {
+    method: "POST",
+    path: "/api/runners/poll",
+    headers: authHeadersSchema,
+    body: z15.object({
+      group: runnerGroupSchema
+    }),
+    responses: {
+      200: z15.object({
+        job: jobSchema.nullable()
+      }),
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Poll for pending jobs (long-polling with 30s timeout)"
+  }
+});
+var firewallApiSchema = z15.object({
+  base: z15.string(),
+  auth: z15.object({
+    headers: z15.record(z15.string(), z15.string())
+  }),
+  permissions: z15.array(firewallPermissionSchema).optional()
+});
+var firewallSchema = z15.object({
+  name: z15.string(),
+  ref: z15.string(),
+  apis: z15.array(firewallApiSchema)
+});
+var experimentalFirewallSchema = z15.array(firewallSchema);
+var storageEntrySchema = z15.object({
+  mountPath: z15.string(),
+  archiveUrl: z15.string().nullable()
+});
+var artifactEntrySchema = z15.object({
+  mountPath: z15.string(),
+  archiveUrl: z15.string().nullable(),
+  vasStorageName: z15.string(),
+  vasVersionId: z15.string()
+});
+var storageManifestSchema = z15.object({
+  storages: z15.array(storageEntrySchema),
+  artifact: artifactEntrySchema.nullable(),
+  memory: artifactEntrySchema.nullable()
+});
+var resumeSessionSchema = z15.object({
+  sessionId: z15.string(),
+  sessionHistory: z15.string()
+});
+var storedExecutionContextSchema = z15.object({
+  workingDir: z15.string(),
+  storageManifest: storageManifestSchema.nullable(),
+  environment: z15.record(z15.string(), z15.string()).nullable(),
+  resumeSession: resumeSessionSchema.nullable(),
+  encryptedSecrets: z15.string().nullable(),
+  // AES-256-GCM encrypted Record<string, string> (secret name → value)
+  // Maps secret names to OAuth connector types for runtime token refresh (e.g. { "GMAIL_ACCESS_TOKEN": "gmail" })
+  secretConnectorMap: z15.record(z15.string(), z15.string()).nullable().optional(),
+  cliAgentType: z15.string(),
+  // Debug flag to force real Claude in mock environments (internal use only)
+  debugNoMockClaude: z15.boolean().optional(),
+  // Dispatch timestamp for E2E timing metrics
+  apiStartTime: z15.number().optional(),
+  // User's timezone preference (IANA format, e.g., "Asia/Shanghai")
+  userTimezone: z15.string().optional(),
+  // Agent metadata for VM0_AGENT_NAME and VM0_AGENT_ORG env vars
+  agentName: z15.string().optional(),
+  agentOrgSlug: z15.string().optional(),
+  // Memory storage name (for first-run when manifest.memory is null)
+  memoryName: z15.string().optional(),
+  // Experimental firewall for proxy-side token replacement
+  experimentalFirewall: experimentalFirewallSchema.optional(),
+  // Experimental capabilities for agent permission enforcement
+  experimentalCapabilities: z15.array(z15.enum(VALID_CAPABILITIES)).optional()
+});
+var executionContextSchema = z15.object({
+  runId: z15.string().uuid(),
+  prompt: z15.string(),
+  agentComposeVersionId: z15.string().nullable(),
+  vars: z15.record(z15.string(), z15.string()).nullable(),
+  checkpointId: z15.string().uuid().nullable(),
+  sandboxToken: z15.string(),
+  // New fields for E2B parity:
+  workingDir: z15.string(),
+  storageManifest: storageManifestSchema.nullable(),
+  environment: z15.record(z15.string(), z15.string()).nullable(),
+  resumeSession: resumeSessionSchema.nullable(),
+  secretValues: z15.array(z15.string()).nullable(),
+  // AES-256-GCM encrypted Record<string, string> — passed through to mitm-addon for auth resolution
+  encryptedSecrets: z15.string().nullable(),
+  // Maps secret names to OAuth connector types for runtime token refresh
+  secretConnectorMap: z15.record(z15.string(), z15.string()).nullable().optional(),
+  cliAgentType: z15.string(),
+  // Debug flag to force real Claude in mock environments (internal use only)
+  debugNoMockClaude: z15.boolean().optional(),
+  // Dispatch timestamp for E2E timing metrics
+  apiStartTime: z15.number().optional(),
+  // User's timezone preference (IANA format, e.g., "Asia/Shanghai")
+  userTimezone: z15.string().optional(),
+  // Agent metadata
+  agentName: z15.string().optional(),
+  agentOrgSlug: z15.string().optional(),
+  // Memory storage name (for first-run when manifest.memory is null)
+  memoryName: z15.string().optional(),
+  // Experimental firewall for proxy-side token replacement
+  experimentalFirewall: experimentalFirewallSchema.optional(),
+  // Experimental capabilities for agent permission enforcement
+  experimentalCapabilities: z15.array(z15.enum(VALID_CAPABILITIES)).optional()
+});
+var runnersJobClaimContract = c13.router({
+  claim: {
+    method: "POST",
+    path: "/api/runners/jobs/:id/claim",
+    headers: authHeadersSchema,
+    pathParams: z15.object({
+      id: z15.string().uuid()
+    }),
+    body: z15.object({}),
+    responses: {
+      200: executionContextSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      // Job does not belong to user
+      404: apiErrorSchema,
+      409: apiErrorSchema,
+      // Already claimed
+      500: apiErrorSchema
+    },
+    summary: "Claim a pending job for execution"
+  }
+});
+
 // ../../packages/core/src/contracts/schedules.ts
 import { z as z16 } from "zod";
 var c14 = initContract();
@@ -6449,7 +6451,7 @@ var computerConnectorContract = c18.router({
   }
 });
 
-// ../../packages/core/src/contracts/services.ts
+// ../../packages/core/src/contracts/firewall.ts
 function bearerAuth(secretName) {
   return { headers: { Authorization: `Bearer \${{ secrets.${secretName} }}` } };
 }
@@ -6460,7 +6462,7 @@ var FULL_ACCESS_PERMISSION = {
 function api(base, auth) {
   return { base, auth, permissions: [FULL_ACCESS_PERMISSION] };
 }
-var SERVICE_CONFIGS = {
+var FIREWALL_CONFIGS = {
   ahrefs: {
     apis: [api("https://api.ahrefs.com", bearerAuth("AHREFS_TOKEN"))]
   },
@@ -7027,13 +7029,13 @@ var SERVICE_CONFIGS = {
     ]
   }
 };
-function getServiceConfig(type2) {
-  const config = SERVICE_CONFIGS[type2];
+function getFirewallConfig(type2) {
+  const config = FIREWALL_CONFIGS[type2];
   if (!config) return void 0;
   return { ...config, name: type2 };
 }
 
-// ../../packages/core/src/contracts/service-expander.ts
+// ../../packages/core/src/contracts/firewall-expander.ts
 var VALID_RULE_METHODS = /* @__PURE__ */ new Set([
   "GET",
   "POST",
@@ -7048,23 +7050,23 @@ function validateRule(rule, permName, serviceName) {
   const parts = rule.split(" ", 2);
   if (parts.length !== 2 || !parts[1]) {
     throw new Error(
-      `Invalid rule "${rule}" in permission "${permName}" of service "${serviceName}": must be "METHOD /path"`
+      `Invalid rule "${rule}" in permission "${permName}" of firewall "${serviceName}": must be "METHOD /path"`
     );
   }
   const [method, path18] = parts;
   if (!VALID_RULE_METHODS.has(method)) {
     throw new Error(
-      `Invalid rule "${rule}" in permission "${permName}" of service "${serviceName}": unknown method "${method}" (must be uppercase)`
+      `Invalid rule "${rule}" in permission "${permName}" of firewall "${serviceName}": unknown method "${method}" (must be uppercase)`
     );
   }
   if (!path18.startsWith("/")) {
     throw new Error(
-      `Invalid rule "${rule}" in permission "${permName}" of service "${serviceName}": path must start with "/"`
+      `Invalid rule "${rule}" in permission "${permName}" of firewall "${serviceName}": path must start with "/"`
     );
   }
   if (path18.includes("?") || path18.includes("#")) {
     throw new Error(
-      `Invalid rule "${rule}" in permission "${permName}" of service "${serviceName}": path must not contain query string or fragment`
+      `Invalid rule "${rule}" in permission "${permName}" of firewall "${serviceName}": path must not contain query string or fragment`
     );
   }
   const segments = path18.split("/").filter(Boolean);
@@ -7076,18 +7078,18 @@ function validateRule(rule, permName, serviceName) {
       const baseName = name.endsWith("+") ? name.slice(0, -1) : name;
       if (!baseName) {
         throw new Error(
-          `Invalid rule "${rule}" in permission "${permName}" of service "${serviceName}": empty parameter name`
+          `Invalid rule "${rule}" in permission "${permName}" of firewall "${serviceName}": empty parameter name`
         );
       }
       if (paramNames.has(baseName)) {
         throw new Error(
-          `Invalid rule "${rule}" in permission "${permName}" of service "${serviceName}": duplicate parameter name "{${baseName}}"`
+          `Invalid rule "${rule}" in permission "${permName}" of firewall "${serviceName}": duplicate parameter name "{${baseName}}"`
         );
       }
       paramNames.add(baseName);
       if (name.endsWith("+") && i !== segments.length - 1) {
         throw new Error(
-          `Invalid rule "${rule}" in permission "${permName}" of service "${serviceName}": {${name}} must be the last segment`
+          `Invalid rule "${rule}" in permission "${permName}" of firewall "${serviceName}": {${name}} must be the last segment`
         );
       }
     }
@@ -7099,31 +7101,31 @@ function validateBaseUrl(base, serviceName) {
     url = new URL(base);
   } catch {
     throw new Error(
-      `Invalid base URL "${base}" in service "${serviceName}": not a valid URL`
+      `Invalid base URL "${base}" in firewall "${serviceName}": not a valid URL`
     );
   }
   if (url.search) {
     throw new Error(
-      `Invalid base URL "${base}" in service "${serviceName}": must not contain query string`
+      `Invalid base URL "${base}" in firewall "${serviceName}": must not contain query string`
     );
   }
   if (url.hash) {
     throw new Error(
-      `Invalid base URL "${base}" in service "${serviceName}": must not contain fragment`
+      `Invalid base URL "${base}" in firewall "${serviceName}": must not contain fragment`
     );
   }
 }
-function resolveServiceConfig(ref) {
+function resolveFirewallConfig(ref) {
   const parsed = connectorTypeSchema.safeParse(ref);
   if (!parsed.success) {
     throw new Error(
-      `Cannot resolve service ref "${ref}": no built-in service with this name`
+      `Cannot resolve firewall ref "${ref}": no built-in firewall config with this name`
     );
   }
-  const serviceConfig = getServiceConfig(parsed.data);
+  const serviceConfig = getFirewallConfig(parsed.data);
   if (!serviceConfig) {
     throw new Error(
-      `Service ref "${ref}" resolved to "${parsed.data}" but it does not support proxy-side token replacement`
+      `Firewall ref "${ref}" resolved to "${parsed.data}" but it does not support proxy-side token replacement`
     );
   }
   return serviceConfig;
@@ -7131,7 +7133,7 @@ function resolveServiceConfig(ref) {
 function collectAndValidatePermissions(ref, serviceConfig) {
   if (serviceConfig.apis.length === 0) {
     throw new Error(
-      `Service "${serviceConfig.name}" (ref "${ref}") has no api entries`
+      `Firewall "${serviceConfig.name}" (ref "${ref}") has no api entries`
     );
   }
   const available = /* @__PURE__ */ new Set();
@@ -7139,29 +7141,29 @@ function collectAndValidatePermissions(ref, serviceConfig) {
     validateBaseUrl(api2.base, serviceConfig.name);
     if (!api2.permissions || api2.permissions.length === 0) {
       throw new Error(
-        `API entry "${api2.base}" in service "${serviceConfig.name}" (ref "${ref}") has no permissions`
+        `API entry "${api2.base}" in firewall "${serviceConfig.name}" (ref "${ref}") has no permissions`
       );
     }
     const seen = /* @__PURE__ */ new Set();
     for (const perm of api2.permissions) {
       if (!perm.name) {
         throw new Error(
-          `Service "${serviceConfig.name}" (ref "${ref}") has a permission with empty name`
+          `Firewall "${serviceConfig.name}" (ref "${ref}") has a permission with empty name`
         );
       }
       if (perm.name === "all") {
         throw new Error(
-          `Service "${serviceConfig.name}" (ref "${ref}") has a permission named "all", which is a reserved keyword`
+          `Firewall "${serviceConfig.name}" (ref "${ref}") has a permission named "all", which is a reserved keyword`
         );
       }
       if (seen.has(perm.name)) {
         throw new Error(
-          `Duplicate permission name "${perm.name}" in API entry "${api2.base}" of service "${serviceConfig.name}" (ref "${ref}")`
+          `Duplicate permission name "${perm.name}" in API entry "${api2.base}" of firewall "${serviceConfig.name}" (ref "${ref}")`
         );
       }
       if (perm.rules.length === 0) {
         throw new Error(
-          `Permission "${perm.name}" in service "${serviceConfig.name}" (ref "${ref}") has no rules`
+          `Permission "${perm.name}" in firewall "${serviceConfig.name}" (ref "${ref}") has no rules`
         );
       }
       for (const rule of perm.rules) {
@@ -7173,16 +7175,16 @@ function collectAndValidatePermissions(ref, serviceConfig) {
   }
   return available;
 }
-function expandServiceConfigs(config) {
+function expandFirewallConfigs(config) {
   const compose = config;
   if (!compose?.agents) return;
   for (const agent of Object.values(compose.agents)) {
-    const services = agent.experimental_services;
-    if (!services) continue;
-    if (Array.isArray(services)) continue;
+    const configs = agent.experimental_firewall;
+    if (!configs) continue;
+    if (Array.isArray(configs)) continue;
     const expanded = [];
-    for (const [ref, selection] of Object.entries(services)) {
-      const serviceConfig = resolveServiceConfig(ref);
+    for (const [ref, selection] of Object.entries(configs)) {
+      const serviceConfig = resolveFirewallConfig(ref);
       const availablePermissions = collectAndValidatePermissions(
         ref,
         serviceConfig
@@ -7192,7 +7194,7 @@ function expandServiceConfigs(config) {
           if (!availablePermissions.has(name)) {
             const available = [...availablePermissions].join(", ");
             throw new Error(
-              `Permission "${name}" does not exist in service "${serviceConfig.name}" (ref "${ref}"). Available: ${available}`
+              `Permission "${name}" does not exist in firewall "${serviceConfig.name}" (ref "${ref}"). Available: ${available}`
             );
           }
         }
@@ -7214,7 +7216,7 @@ function expandServiceConfigs(config) {
         entry.placeholders = serviceConfig.placeholders;
       expanded.push(entry);
     }
-    agent.experimental_services = expanded;
+    agent.experimental_firewall = expanded;
   }
 }
 
@@ -7810,7 +7812,8 @@ var FEATURE_SWITCHES = {
   },
   ["zero" /* Zero */]: {
     maintainer: "ethan@vm0.ai",
-    enabled: false
+    enabled: false,
+    enabledUserHashes: STAFF_USER_HASHES
   }
 };
 async function isFeatureEnabled(key, userId) {
@@ -9805,7 +9808,7 @@ async function finalizeCompose(config, agent, variables, options) {
     process.exit(0);
   }
   mergeSkillVariables(agent, variables);
-  expandServiceConfigs(config);
+  expandFirewallConfigs(config);
   if (!options.json) {
     console.log("Uploading compose...");
   }
@@ -9945,7 +9948,7 @@ var composeCommand = new Command7().name("compose").description("Create or updat
         options.autoUpdate = false;
       }
       if (options.autoUpdate !== false) {
-        await startSilentUpgrade("9.59.5");
+        await startSilentUpgrade("9.59.6");
       }
       try {
         let result;
@@ -11119,7 +11122,7 @@ var mainRunCommand = new Command8().name("run").description("Run an agent").argu
   withErrorHandler(
     async (identifier, prompt, options) => {
       if (options.autoUpdate !== false) {
-        await startSilentUpgrade("9.59.5");
+        await startSilentUpgrade("9.59.6");
       }
       const { org, name, version } = parseIdentifier(identifier);
       if (org && !options.experimentalSharedAgent) {
@@ -12806,7 +12809,7 @@ var cookAction = new Command34().name("cook").description("Quick start: prepare,
   withErrorHandler(
     async (prompt, options) => {
       if (options.autoUpdate !== false) {
-        const shouldExit = await checkAndUpgrade("9.59.5", prompt);
+        const shouldExit = await checkAndUpgrade("9.59.6", prompt);
         if (shouldExit) {
           process.exit(0);
         }
@@ -18157,13 +18160,13 @@ var upgradeCommand = new Command90().name("upgrade").description("Upgrade vm0 CL
     if (latestVersion === null) {
       throw new Error("Could not check for updates. Please try again later.");
     }
-    if (latestVersion === "9.59.5") {
-      console.log(chalk84.green(`\u2713 Already up to date (${"9.59.5"})`));
+    if (latestVersion === "9.59.6") {
+      console.log(chalk84.green(`\u2713 Already up to date (${"9.59.6"})`));
       return;
     }
     console.log(
       chalk84.yellow(
-        `Current version: ${"9.59.5"} -> Latest version: ${latestVersion}`
+        `Current version: ${"9.59.6"} -> Latest version: ${latestVersion}`
       )
     );
     console.log();
@@ -18190,7 +18193,7 @@ var upgradeCommand = new Command90().name("upgrade").description("Upgrade vm0 CL
     const success = await performUpgrade(packageManager);
     if (success) {
       console.log(
-        chalk84.green(`\u2713 Upgraded from ${"9.59.5"} to ${latestVersion}`)
+        chalk84.green(`\u2713 Upgraded from ${"9.59.6"} to ${latestVersion}`)
       );
       return;
     }
@@ -18204,7 +18207,7 @@ var upgradeCommand = new Command90().name("upgrade").description("Upgrade vm0 CL
 
 // src/index.ts
 var program = new Command91();
-program.name("vm0").description("VM0 CLI - Build and run agents with natural language").version("9.59.5");
+program.name("vm0").description("VM0 CLI - Build and run agents with natural language").version("9.59.6");
 program.addCommand(authCommand);
 program.addCommand(infoCommand);
 program.addCommand(composeCommand);