@vm0/cli 9.16.0 → 9.17.0

package/index.js

@@ -1887,9 +1887,109 @@ var credentialsByNameContract = c10.router({
   }
 });
 
-// ../../packages/core/src/contracts/model-providers.ts
+// ../../packages/core/src/contracts/secrets.ts
 import { z as z14 } from "zod";
 var c11 = initContract();
+var secretNameSchema = z14.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 = z14.enum(["user", "model-provider"]);
+var secretResponseSchema = z14.object({
+  id: z14.string().uuid(),
+  name: z14.string(),
+  description: z14.string().nullable(),
+  type: secretTypeSchema,
+  createdAt: z14.string(),
+  updatedAt: z14.string()
+});
+var secretListResponseSchema = z14.object({
+  secrets: z14.array(secretResponseSchema)
+});
+var setSecretRequestSchema = z14.object({
+  name: secretNameSchema,
+  value: z14.string().min(1, "Secret value is required"),
+  description: z14.string().max(1e3).optional()
+});
+var secretsMainContract = c11.router({
+  /**
+   * GET /api/secrets
+   * List all secrets for the current user's scope (metadata only)
+   */
+  list: {
+    method: "GET",
+    path: "/api/secrets",
+    headers: authHeadersSchema,
+    responses: {
+      200: secretListResponseSchema,
+      401: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "List all secrets (metadata only)"
+  },
+  /**
+   * PUT /api/secrets
+   * Create or update a secret
+   */
+  set: {
+    method: "PUT",
+    path: "/api/secrets",
+    headers: authHeadersSchema,
+    body: setSecretRequestSchema,
+    responses: {
+      200: secretResponseSchema,
+      201: secretResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Create or update a secret"
+  }
+});
+var secretsByNameContract = c11.router({
+  /**
+   * GET /api/secrets/:name
+   * Get a secret by name (metadata only)
+   */
+  get: {
+    method: "GET",
+    path: "/api/secrets/:name",
+    headers: authHeadersSchema,
+    pathParams: z14.object({
+      name: secretNameSchema
+    }),
+    responses: {
+      200: secretResponseSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Get secret metadata by name"
+  },
+  /**
+   * DELETE /api/secrets/:name
+   * Delete a secret by name
+   */
+  delete: {
+    method: "DELETE",
+    path: "/api/secrets/:name",
+    headers: authHeadersSchema,
+    pathParams: z14.object({
+      name: secretNameSchema
+    }),
+    responses: {
+      204: c11.noBody(),
+      401: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Delete a secret"
+  }
+});
+
+// ../../packages/core/src/contracts/model-providers.ts
+import { z as z15 } from "zod";
+var c12 = initContract();
 var MODEL_PROVIDER_TYPES = {
   "claude-code-oauth-token": {
     framework: "claude-code",
@@ -1990,6 +2090,25 @@ var MODEL_PROVIDER_TYPES = {
     models: ["deepseek-chat"],
     defaultModel: "deepseek-chat"
   },
+  "zai-api-key": {
+    framework: "claude-code",
+    credentialName: "ZAI_API_KEY",
+    label: "Z.AI (GLM)",
+    credentialLabel: "API key",
+    helpText: "Get your API key at: https://z.ai/model-api",
+    environmentMapping: {
+      ANTHROPIC_AUTH_TOKEN: "$credential",
+      ANTHROPIC_BASE_URL: "https://api.z.ai/api/anthropic",
+      ANTHROPIC_MODEL: "$model",
+      ANTHROPIC_DEFAULT_OPUS_MODEL: "$model",
+      ANTHROPIC_DEFAULT_SONNET_MODEL: "$model",
+      ANTHROPIC_DEFAULT_HAIKU_MODEL: "$model",
+      CLAUDE_CODE_SUBAGENT_MODEL: "$model",
+      API_TIMEOUT_MS: "3000000"
+    },
+    models: ["GLM-4.7", "GLM-4.5-Air"],
+    defaultModel: "GLM-4.7"
+  },
   "aws-bedrock": {
     framework: "claude-code",
     label: "AWS Bedrock",
@@ -2056,16 +2175,17 @@ var MODEL_PROVIDER_TYPES = {
     customModelPlaceholder: "anthropic.claude-sonnet-4-20250514-v1:0"
   }
 };
-var modelProviderTypeSchema = z14.enum([
+var modelProviderTypeSchema = z15.enum([
   "claude-code-oauth-token",
   "anthropic-api-key",
   "openrouter-api-key",
   "moonshot-api-key",
   "minimax-api-key",
   "deepseek-api-key",
+  "zai-api-key",
   "aws-bedrock"
 ]);
-var modelProviderFrameworkSchema = z14.enum(["claude-code", "codex"]);
+var modelProviderFrameworkSchema = z15.enum(["claude-code", "codex"]);
 function hasAuthMethods(type) {
   const config = MODEL_PROVIDER_TYPES[type];
   return "authMethods" in config;
@@ -2106,45 +2226,45 @@ function getCustomModelPlaceholder(type) {
   const config = MODEL_PROVIDER_TYPES[type];
   return "customModelPlaceholder" in config ? config.customModelPlaceholder : void 0;
 }
-var modelProviderResponseSchema = z14.object({
-  id: z14.string().uuid(),
+var modelProviderResponseSchema = z15.object({
+  id: z15.string().uuid(),
   type: modelProviderTypeSchema,
   framework: modelProviderFrameworkSchema,
-  credentialName: z14.string().nullable(),
+  credentialName: z15.string().nullable(),
   // Legacy single-credential (deprecated for multi-auth)
-  authMethod: z14.string().nullable(),
+  authMethod: z15.string().nullable(),
   // For multi-auth providers
-  credentialNames: z14.array(z14.string()).nullable(),
+  credentialNames: z15.array(z15.string()).nullable(),
   // For multi-auth providers
-  isDefault: z14.boolean(),
-  selectedModel: z14.string().nullable(),
-  createdAt: z14.string(),
-  updatedAt: z14.string()
+  isDefault: z15.boolean(),
+  selectedModel: z15.string().nullable(),
+  createdAt: z15.string(),
+  updatedAt: z15.string()
 });
-var modelProviderListResponseSchema = z14.object({
-  modelProviders: z14.array(modelProviderResponseSchema)
+var modelProviderListResponseSchema = z15.object({
+  modelProviders: z15.array(modelProviderResponseSchema)
 });
-var upsertModelProviderRequestSchema = z14.object({
+var upsertModelProviderRequestSchema = z15.object({
   type: modelProviderTypeSchema,
-  credential: z14.string().min(1).optional(),
+  credential: z15.string().min(1).optional(),
   // Legacy single credential
-  authMethod: z14.string().optional(),
+  authMethod: z15.string().optional(),
   // For multi-auth providers
-  credentials: z14.record(z14.string(), z14.string()).optional(),
+  credentials: z15.record(z15.string(), z15.string()).optional(),
   // For multi-auth providers
-  convert: z14.boolean().optional(),
-  selectedModel: z14.string().optional()
+  convert: z15.boolean().optional(),
+  selectedModel: z15.string().optional()
 });
-var upsertModelProviderResponseSchema = z14.object({
+var upsertModelProviderResponseSchema = z15.object({
   provider: modelProviderResponseSchema,
-  created: z14.boolean()
+  created: z15.boolean()
 });
-var checkCredentialResponseSchema = z14.object({
-  exists: z14.boolean(),
-  credentialName: z14.string(),
-  currentType: z14.enum(["user", "model-provider"]).optional()
+var checkCredentialResponseSchema = z15.object({
+  exists: z15.boolean(),
+  credentialName: z15.string(),
+  currentType: z15.enum(["user", "model-provider"]).optional()
 });
-var modelProvidersMainContract = c11.router({
+var modelProvidersMainContract = c12.router({
   list: {
     method: "GET",
     path: "/api/model-providers",
@@ -2172,12 +2292,12 @@ var modelProvidersMainContract = c11.router({
     summary: "Create or update a model provider"
   }
 });
-var modelProvidersCheckContract = c11.router({
+var modelProvidersCheckContract = c12.router({
   check: {
     method: "GET",
     path: "/api/model-providers/check/:type",
     headers: authHeadersSchema,
-    pathParams: z14.object({
+    pathParams: z15.object({
       type: modelProviderTypeSchema
     }),
     responses: {
@@ -2188,16 +2308,16 @@ var modelProvidersCheckContract = c11.router({
     summary: "Check if credential exists for a model provider type"
   }
 });
-var modelProvidersByTypeContract = c11.router({
+var modelProvidersByTypeContract = c12.router({
   delete: {
     method: "DELETE",
     path: "/api/model-providers/:type",
     headers: authHeadersSchema,
-    pathParams: z14.object({
+    pathParams: z15.object({
       type: modelProviderTypeSchema
     }),
     responses: {
-      204: c11.noBody(),
+      204: c12.noBody(),
       401: apiErrorSchema,
       404: apiErrorSchema,
       500: apiErrorSchema
@@ -2205,15 +2325,15 @@ var modelProvidersByTypeContract = c11.router({
     summary: "Delete a model provider"
   }
 });
-var modelProvidersConvertContract = c11.router({
+var modelProvidersConvertContract = c12.router({
   convert: {
     method: "POST",
     path: "/api/model-providers/:type/convert",
     headers: authHeadersSchema,
-    pathParams: z14.object({
+    pathParams: z15.object({
       type: modelProviderTypeSchema
     }),
-    body: z14.undefined(),
+    body: z15.undefined(),
     responses: {
       200: modelProviderResponseSchema,
       400: apiErrorSchema,
@@ -2224,15 +2344,15 @@ var modelProvidersConvertContract = c11.router({
     summary: "Convert existing user credential to model provider"
   }
 });
-var modelProvidersSetDefaultContract = c11.router({
+var modelProvidersSetDefaultContract = c12.router({
   setDefault: {
     method: "POST",
     path: "/api/model-providers/:type/set-default",
     headers: authHeadersSchema,
-    pathParams: z14.object({
+    pathParams: z15.object({
       type: modelProviderTypeSchema
     }),
-    body: z14.undefined(),
+    body: z15.undefined(),
     responses: {
       200: modelProviderResponseSchema,
       401: apiErrorSchema,
@@ -2242,15 +2362,15 @@ var modelProvidersSetDefaultContract = c11.router({
     summary: "Set a model provider as default for its framework"
   }
 });
-var updateModelRequestSchema = z14.object({
-  selectedModel: z14.string().optional()
+var updateModelRequestSchema = z15.object({
+  selectedModel: z15.string().optional()
 });
-var modelProvidersUpdateModelContract = c11.router({
+var modelProvidersUpdateModelContract = c12.router({
   updateModel: {
     method: "PATCH",
     path: "/api/model-providers/:type/model",
     headers: authHeadersSchema,
-    pathParams: z14.object({
+    pathParams: z15.object({
       type: modelProviderTypeSchema
     }),
     body: updateModelRequestSchema,
@@ -2265,42 +2385,42 @@ var modelProvidersUpdateModelContract = c11.router({
 });
 
 // ../../packages/core/src/contracts/sessions.ts
-import { z as z15 } from "zod";
-var c12 = initContract();
-var sessionResponseSchema = z15.object({
-  id: z15.string(),
-  agentComposeId: z15.string(),
-  agentComposeVersionId: z15.string().nullable(),
-  conversationId: z15.string().nullable(),
-  artifactName: z15.string().nullable(),
-  vars: z15.record(z15.string(), z15.string()).nullable(),
-  secretNames: z15.array(z15.string()).nullable(),
-  volumeVersions: z15.record(z15.string(), z15.string()).nullable(),
-  createdAt: z15.string(),
-  updatedAt: z15.string()
+import { z as z16 } from "zod";
+var c13 = initContract();
+var sessionResponseSchema = z16.object({
+  id: z16.string(),
+  agentComposeId: z16.string(),
+  agentComposeVersionId: z16.string().nullable(),
+  conversationId: z16.string().nullable(),
+  artifactName: z16.string().nullable(),
+  vars: z16.record(z16.string(), z16.string()).nullable(),
+  secretNames: z16.array(z16.string()).nullable(),
+  volumeVersions: z16.record(z16.string(), z16.string()).nullable(),
+  createdAt: z16.string(),
+  updatedAt: z16.string()
 });
-var agentComposeSnapshotSchema = z15.object({
-  agentComposeVersionId: z15.string(),
-  vars: z15.record(z15.string(), z15.string()).optional(),
-  secretNames: z15.array(z15.string()).optional()
+var agentComposeSnapshotSchema = z16.object({
+  agentComposeVersionId: z16.string(),
+  vars: z16.record(z16.string(), z16.string()).optional(),
+  secretNames: z16.array(z16.string()).optional()
 });
-var artifactSnapshotSchema2 = z15.object({
-  artifactName: z15.string(),
-  artifactVersion: z15.string()
+var artifactSnapshotSchema2 = z16.object({
+  artifactName: z16.string(),
+  artifactVersion: z16.string()
 });
-var volumeVersionsSnapshotSchema2 = z15.object({
-  versions: z15.record(z15.string(), z15.string())
+var volumeVersionsSnapshotSchema2 = z16.object({
+  versions: z16.record(z16.string(), z16.string())
 });
-var checkpointResponseSchema = z15.object({
-  id: z15.string(),
-  runId: z15.string(),
-  conversationId: z15.string(),
+var checkpointResponseSchema = z16.object({
+  id: z16.string(),
+  runId: z16.string(),
+  conversationId: z16.string(),
   agentComposeSnapshot: agentComposeSnapshotSchema,
   artifactSnapshot: artifactSnapshotSchema2.nullable(),
   volumeVersionsSnapshot: volumeVersionsSnapshotSchema2.nullable(),
-  createdAt: z15.string()
+  createdAt: z16.string()
 });
-var sessionsByIdContract = c12.router({
+var sessionsByIdContract = c13.router({
   /**
    * GET /api/agent/sessions/:id
    * Get session by ID
@@ -2309,8 +2429,8 @@ var sessionsByIdContract = c12.router({
     method: "GET",
     path: "/api/agent/sessions/:id",
     headers: authHeadersSchema,
-    pathParams: z15.object({
-      id: z15.string().min(1, "Session ID is required")
+    pathParams: z16.object({
+      id: z16.string().min(1, "Session ID is required")
     }),
     responses: {
       200: sessionResponseSchema,
@@ -2321,7 +2441,7 @@ var sessionsByIdContract = c12.router({
     summary: "Get session by ID"
   }
 });
-var checkpointsByIdContract = c12.router({
+var checkpointsByIdContract = c13.router({
   /**
    * GET /api/agent/checkpoints/:id
    * Get checkpoint by ID
@@ -2330,8 +2450,8 @@ var checkpointsByIdContract = c12.router({
     method: "GET",
     path: "/api/agent/checkpoints/:id",
     headers: authHeadersSchema,
-    pathParams: z15.object({
-      id: z15.string().min(1, "Checkpoint ID is required")
+    pathParams: z16.object({
+      id: z16.string().min(1, "Checkpoint ID is required")
     }),
     responses: {
       200: checkpointResponseSchema,
@@ -2344,93 +2464,93 @@ var checkpointsByIdContract = c12.router({
 });
 
 // ../../packages/core/src/contracts/schedules.ts
-import { z as z16 } from "zod";
-var c13 = initContract();
-var scheduleTriggerSchema = z16.object({
-  cron: z16.string().optional(),
-  at: z16.string().optional(),
-  timezone: z16.string().default("UTC")
+import { z as z17 } from "zod";
+var c14 = initContract();
+var scheduleTriggerSchema = z17.object({
+  cron: z17.string().optional(),
+  at: z17.string().optional(),
+  timezone: z17.string().default("UTC")
 }).refine((data) => data.cron && !data.at || !data.cron && data.at, {
   message: "Exactly one of 'cron' or 'at' must be specified"
 });
-var scheduleRunConfigSchema = z16.object({
-  agent: z16.string().min(1, "Agent reference required"),
-  prompt: z16.string().min(1, "Prompt required"),
-  vars: z16.record(z16.string(), z16.string()).optional(),
-  secrets: z16.record(z16.string(), z16.string()).optional(),
-  artifactName: z16.string().optional(),
-  artifactVersion: z16.string().optional(),
-  volumeVersions: z16.record(z16.string(), z16.string()).optional()
+var scheduleRunConfigSchema = z17.object({
+  agent: z17.string().min(1, "Agent reference required"),
+  prompt: z17.string().min(1, "Prompt required"),
+  vars: z17.record(z17.string(), z17.string()).optional(),
+  secrets: z17.record(z17.string(), z17.string()).optional(),
+  artifactName: z17.string().optional(),
+  artifactVersion: z17.string().optional(),
+  volumeVersions: z17.record(z17.string(), z17.string()).optional()
 });
-var scheduleDefinitionSchema = z16.object({
+var scheduleDefinitionSchema = z17.object({
   on: scheduleTriggerSchema,
   run: scheduleRunConfigSchema
 });
-var scheduleYamlSchema = z16.object({
-  version: z16.literal("1.0"),
-  schedules: z16.record(z16.string(), scheduleDefinitionSchema)
-});
-var deployScheduleRequestSchema = z16.object({
-  name: z16.string().min(1).max(64, "Schedule name max 64 chars"),
-  cronExpression: z16.string().optional(),
-  atTime: z16.string().optional(),
-  timezone: z16.string().default("UTC"),
-  prompt: z16.string().min(1, "Prompt required"),
-  vars: z16.record(z16.string(), z16.string()).optional(),
-  secrets: z16.record(z16.string(), z16.string()).optional(),
-  artifactName: z16.string().optional(),
-  artifactVersion: z16.string().optional(),
-  volumeVersions: z16.record(z16.string(), z16.string()).optional(),
+var scheduleYamlSchema = z17.object({
+  version: z17.literal("1.0"),
+  schedules: z17.record(z17.string(), scheduleDefinitionSchema)
+});
+var deployScheduleRequestSchema = z17.object({
+  name: z17.string().min(1).max(64, "Schedule name max 64 chars"),
+  cronExpression: z17.string().optional(),
+  atTime: z17.string().optional(),
+  timezone: z17.string().default("UTC"),
+  prompt: z17.string().min(1, "Prompt required"),
+  vars: z17.record(z17.string(), z17.string()).optional(),
+  secrets: z17.record(z17.string(), z17.string()).optional(),
+  artifactName: z17.string().optional(),
+  artifactVersion: z17.string().optional(),
+  volumeVersions: z17.record(z17.string(), z17.string()).optional(),
   // Resolved agent compose ID (CLI resolves scope/name:version → composeId)
-  composeId: z16.string().uuid("Invalid compose ID")
+  composeId: z17.string().uuid("Invalid compose ID")
 }).refine(
   (data) => data.cronExpression && !data.atTime || !data.cronExpression && data.atTime,
   {
     message: "Exactly one of 'cronExpression' or 'atTime' must be specified"
   }
 );
-var scheduleResponseSchema = z16.object({
-  id: z16.string().uuid(),
-  composeId: z16.string().uuid(),
-  composeName: z16.string(),
-  scopeSlug: z16.string(),
-  name: z16.string(),
-  cronExpression: z16.string().nullable(),
-  atTime: z16.string().nullable(),
-  timezone: z16.string(),
-  prompt: z16.string(),
-  vars: z16.record(z16.string(), z16.string()).nullable(),
+var scheduleResponseSchema = z17.object({
+  id: z17.string().uuid(),
+  composeId: z17.string().uuid(),
+  composeName: z17.string(),
+  scopeSlug: z17.string(),
+  name: z17.string(),
+  cronExpression: z17.string().nullable(),
+  atTime: z17.string().nullable(),
+  timezone: z17.string(),
+  prompt: z17.string(),
+  vars: z17.record(z17.string(), z17.string()).nullable(),
   // Secret names only (values are never returned)
-  secretNames: z16.array(z16.string()).nullable(),
-  artifactName: z16.string().nullable(),
-  artifactVersion: z16.string().nullable(),
-  volumeVersions: z16.record(z16.string(), z16.string()).nullable(),
-  enabled: z16.boolean(),
-  nextRunAt: z16.string().nullable(),
-  lastRunAt: z16.string().nullable(),
-  retryStartedAt: z16.string().nullable(),
-  createdAt: z16.string(),
-  updatedAt: z16.string()
-});
-var runSummarySchema = z16.object({
-  id: z16.string().uuid(),
-  status: z16.enum(["pending", "running", "completed", "failed", "timeout"]),
-  createdAt: z16.string(),
-  completedAt: z16.string().nullable(),
-  error: z16.string().nullable()
-});
-var scheduleRunsResponseSchema = z16.object({
-  runs: z16.array(runSummarySchema)
-});
-var scheduleListResponseSchema = z16.object({
-  schedules: z16.array(scheduleResponseSchema)
-});
-var deployScheduleResponseSchema = z16.object({
+  secretNames: z17.array(z17.string()).nullable(),
+  artifactName: z17.string().nullable(),
+  artifactVersion: z17.string().nullable(),
+  volumeVersions: z17.record(z17.string(), z17.string()).nullable(),
+  enabled: z17.boolean(),
+  nextRunAt: z17.string().nullable(),
+  lastRunAt: z17.string().nullable(),
+  retryStartedAt: z17.string().nullable(),
+  createdAt: z17.string(),
+  updatedAt: z17.string()
+});
+var runSummarySchema = z17.object({
+  id: z17.string().uuid(),
+  status: z17.enum(["pending", "running", "completed", "failed", "timeout"]),
+  createdAt: z17.string(),
+  completedAt: z17.string().nullable(),
+  error: z17.string().nullable()
+});
+var scheduleRunsResponseSchema = z17.object({
+  runs: z17.array(runSummarySchema)
+});
+var scheduleListResponseSchema = z17.object({
+  schedules: z17.array(scheduleResponseSchema)
+});
+var deployScheduleResponseSchema = z17.object({
   schedule: scheduleResponseSchema,
-  created: z16.boolean()
+  created: z17.boolean()
   // true if created, false if updated
 });
-var schedulesMainContract = c13.router({
+var schedulesMainContract = c14.router({
   /**
    * POST /api/agent/schedules
    * Deploy (create or update) a schedule
@@ -2468,7 +2588,7 @@ var schedulesMainContract = c13.router({
     summary: "List all schedules"
   }
 });
-var schedulesByNameContract = c13.router({
+var schedulesByNameContract = c14.router({
   /**
    * GET /api/agent/schedules/:name
    * Get schedule by name
@@ -2477,11 +2597,11 @@ var schedulesByNameContract = c13.router({
     method: "GET",
     path: "/api/agent/schedules/:name",
     headers: authHeadersSchema,
-    pathParams: z16.object({
-      name: z16.string().min(1, "Schedule name required")
+    pathParams: z17.object({
+      name: z17.string().min(1, "Schedule name required")
     }),
-    query: z16.object({
-      composeId: z16.string().uuid("Compose ID required")
+    query: z17.object({
+      composeId: z17.string().uuid("Compose ID required")
     }),
     responses: {
       200: scheduleResponseSchema,
@@ -2498,21 +2618,21 @@ var schedulesByNameContract = c13.router({
     method: "DELETE",
     path: "/api/agent/schedules/:name",
     headers: authHeadersSchema,
-    pathParams: z16.object({
-      name: z16.string().min(1, "Schedule name required")
+    pathParams: z17.object({
+      name: z17.string().min(1, "Schedule name required")
     }),
-    query: z16.object({
-      composeId: z16.string().uuid("Compose ID required")
+    query: z17.object({
+      composeId: z17.string().uuid("Compose ID required")
     }),
     responses: {
-      204: c13.noBody(),
+      204: c14.noBody(),
       401: apiErrorSchema,
       404: apiErrorSchema
     },
     summary: "Delete schedule"
   }
 });
-var schedulesEnableContract = c13.router({
+var schedulesEnableContract = c14.router({
   /**
    * POST /api/agent/schedules/:name/enable
    * Enable a disabled schedule
@@ -2521,11 +2641,11 @@ var schedulesEnableContract = c13.router({
     method: "POST",
     path: "/api/agent/schedules/:name/enable",
     headers: authHeadersSchema,
-    pathParams: z16.object({
-      name: z16.string().min(1, "Schedule name required")
+    pathParams: z17.object({
+      name: z17.string().min(1, "Schedule name required")
     }),
-    body: z16.object({
-      composeId: z16.string().uuid("Compose ID required")
+    body: z17.object({
+      composeId: z17.string().uuid("Compose ID required")
     }),
     responses: {
       200: scheduleResponseSchema,
@@ -2542,11 +2662,11 @@ var schedulesEnableContract = c13.router({
     method: "POST",
     path: "/api/agent/schedules/:name/disable",
     headers: authHeadersSchema,
-    pathParams: z16.object({
-      name: z16.string().min(1, "Schedule name required")
+    pathParams: z17.object({
+      name: z17.string().min(1, "Schedule name required")
     }),
-    body: z16.object({
-      composeId: z16.string().uuid("Compose ID required")
+    body: z17.object({
+      composeId: z17.string().uuid("Compose ID required")
     }),
     responses: {
       200: scheduleResponseSchema,
@@ -2556,7 +2676,7 @@ var schedulesEnableContract = c13.router({
     summary: "Disable schedule"
   }
 });
-var scheduleRunsContract = c13.router({
+var scheduleRunsContract = c14.router({
   /**
    * GET /api/agent/schedules/:name/runs
    * List recent runs for a schedule
@@ -2565,12 +2685,12 @@ var scheduleRunsContract = c13.router({
     method: "GET",
     path: "/api/agent/schedules/:name/runs",
     headers: authHeadersSchema,
-    pathParams: z16.object({
-      name: z16.string().min(1, "Schedule name required")
+    pathParams: z17.object({
+      name: z17.string().min(1, "Schedule name required")
     }),
-    query: z16.object({
-      composeId: z16.string().uuid("Compose ID required"),
-      limit: z16.coerce.number().min(0).max(100).default(5)
+    query: z17.object({
+      composeId: z17.string().uuid("Compose ID required"),
+      limit: z17.coerce.number().min(0).max(100).default(5)
     }),
     responses: {
       200: scheduleRunsResponseSchema,
@@ -2582,18 +2702,18 @@ var scheduleRunsContract = c13.router({
 });
 
 // ../../packages/core/src/contracts/realtime.ts
-import { z as z17 } from "zod";
-var c14 = initContract();
-var ablyTokenRequestSchema = z17.object({
-  keyName: z17.string(),
-  ttl: z17.number().optional(),
-  timestamp: z17.number(),
-  capability: z17.string(),
-  clientId: z17.string().optional(),
-  nonce: z17.string(),
-  mac: z17.string()
-});
-var realtimeTokenContract = c14.router({
+import { z as z18 } from "zod";
+var c15 = initContract();
+var ablyTokenRequestSchema = z18.object({
+  keyName: z18.string(),
+  ttl: z18.number().optional(),
+  timestamp: z18.number(),
+  capability: z18.string(),
+  clientId: z18.string().optional(),
+  nonce: z18.string(),
+  mac: z18.string()
+});
+var realtimeTokenContract = c15.router({
   /**
    * POST /api/realtime/token
    * Get an Ably token to subscribe to a run's events channel
@@ -2602,8 +2722,8 @@ var realtimeTokenContract = c14.router({
     method: "POST",
     path: "/api/realtime/token",
     headers: authHeadersSchema,
-    body: z17.object({
-      runId: z17.string().uuid("runId must be a valid UUID")
+    body: z18.object({
+      runId: z18.string().uuid("runId must be a valid UUID")
     }),
     responses: {
       200: ablyTokenRequestSchema,
@@ -2615,7 +2735,7 @@ var realtimeTokenContract = c14.router({
     summary: "Get Ably token for run event subscription"
   }
 });
-var runnerRealtimeTokenContract = c14.router({
+var runnerRealtimeTokenContract = c15.router({
   /**
    * POST /api/runners/realtime/token
    * Get an Ably token to subscribe to a runner group's job notification channel
@@ -2624,7 +2744,7 @@ var runnerRealtimeTokenContract = c14.router({
     method: "POST",
     path: "/api/runners/realtime/token",
     headers: authHeadersSchema,
-    body: z17.object({
+    body: z18.object({
       group: runnerGroupSchema
     }),
     responses: {
@@ -2638,11 +2758,11 @@ var runnerRealtimeTokenContract = c14.router({
 });
 
 // ../../packages/core/src/contracts/platform.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // ../../packages/core/src/contracts/public/common.ts
-import { z as z18 } from "zod";
-var publicApiErrorTypeSchema = z18.enum([
+import { z as z19 } from "zod";
+var publicApiErrorTypeSchema = z19.enum([
   "api_error",
   // Internal server error (5xx)
   "invalid_request_error",
@@ -2656,40 +2776,40 @@ var publicApiErrorTypeSchema = z18.enum([
   "rate_limit_error"
   // Rate limit exceeded (429)
 ]);
-var publicApiErrorSchema = z18.object({
-  error: z18.object({
+var publicApiErrorSchema = z19.object({
+  error: z19.object({
     type: publicApiErrorTypeSchema,
-    code: z18.string(),
-    message: z18.string(),
-    param: z18.string().optional(),
-    docUrl: z18.string().url().optional()
+    code: z19.string(),
+    message: z19.string(),
+    param: z19.string().optional(),
+    docUrl: z19.string().url().optional()
   })
 });
-var paginationSchema = z18.object({
-  hasMore: z18.boolean(),
-  nextCursor: z18.string().nullable()
+var paginationSchema = z19.object({
+  hasMore: z19.boolean(),
+  nextCursor: z19.string().nullable()
 });
 function createPaginatedResponseSchema(dataSchema) {
-  return z18.object({
-    data: z18.array(dataSchema),
+  return z19.object({
+    data: z19.array(dataSchema),
     pagination: paginationSchema
   });
 }
-var listQuerySchema = z18.object({
-  cursor: z18.string().optional(),
-  limit: z18.coerce.number().min(1).max(100).default(20)
+var listQuerySchema = z19.object({
+  cursor: z19.string().optional(),
+  limit: z19.coerce.number().min(1).max(100).default(20)
 });
-var requestIdSchema = z18.string().uuid();
-var timestampSchema = z18.string().datetime();
+var requestIdSchema = z19.string().uuid();
+var timestampSchema = z19.string().datetime();
 
 // ../../packages/core/src/contracts/platform.ts
-var c15 = initContract();
-var platformPaginationSchema = z19.object({
-  hasMore: z19.boolean(),
-  nextCursor: z19.string().nullable(),
-  totalPages: z19.number()
+var c16 = initContract();
+var platformPaginationSchema = z20.object({
+  hasMore: z20.boolean(),
+  nextCursor: z20.string().nullable(),
+  totalPages: z20.number()
 });
-var platformLogStatusSchema = z19.enum([
+var platformLogStatusSchema = z20.enum([
   "pending",
   "running",
   "completed",
@@ -2697,41 +2817,41 @@ var platformLogStatusSchema = z19.enum([
   "timeout",
   "cancelled"
 ]);
-var platformLogEntrySchema = z19.object({
-  id: z19.string().uuid(),
-  sessionId: z19.string().nullable(),
-  agentName: z19.string(),
-  framework: z19.string().nullable(),
+var platformLogEntrySchema = z20.object({
+  id: z20.string().uuid(),
+  sessionId: z20.string().nullable(),
+  agentName: z20.string(),
+  framework: z20.string().nullable(),
   status: platformLogStatusSchema,
-  createdAt: z19.string()
+  createdAt: z20.string()
 });
-var platformLogsListResponseSchema = z19.object({
-  data: z19.array(platformLogEntrySchema),
+var platformLogsListResponseSchema = z20.object({
+  data: z20.array(platformLogEntrySchema),
   pagination: platformPaginationSchema
 });
-var artifactSchema = z19.object({
-  name: z19.string().nullable(),
-  version: z19.string().nullable()
+var artifactSchema = z20.object({
+  name: z20.string().nullable(),
+  version: z20.string().nullable()
 });
-var platformLogDetailSchema = z19.object({
-  id: z19.string().uuid(),
-  sessionId: z19.string().nullable(),
-  agentName: z19.string(),
-  framework: z19.string().nullable(),
+var platformLogDetailSchema = z20.object({
+  id: z20.string().uuid(),
+  sessionId: z20.string().nullable(),
+  agentName: z20.string(),
+  framework: z20.string().nullable(),
   status: platformLogStatusSchema,
-  prompt: z19.string(),
-  error: z19.string().nullable(),
-  createdAt: z19.string(),
-  startedAt: z19.string().nullable(),
-  completedAt: z19.string().nullable(),
+  prompt: z20.string(),
+  error: z20.string().nullable(),
+  createdAt: z20.string(),
+  startedAt: z20.string().nullable(),
+  completedAt: z20.string().nullable(),
   artifact: artifactSchema
 });
-var platformLogsListContract = c15.router({
+var platformLogsListContract = c16.router({
   list: {
     method: "GET",
     path: "/api/platform/logs",
     query: listQuerySchema.extend({
-      search: z19.string().optional()
+      search: z20.string().optional()
     }),
     responses: {
       200: platformLogsListResponseSchema,
@@ -2740,12 +2860,12 @@ var platformLogsListContract = c15.router({
     summary: "List agent run logs with pagination"
   }
 });
-var platformLogsByIdContract = c15.router({
+var platformLogsByIdContract = c16.router({
   getById: {
     method: "GET",
     path: "/api/platform/logs/:id",
-    pathParams: z19.object({
-      id: z19.string().uuid("Invalid log ID")
+    pathParams: z20.object({
+      id: z20.string().uuid("Invalid log ID")
     }),
     responses: {
       200: platformLogDetailSchema,
@@ -2755,17 +2875,17 @@ var platformLogsByIdContract = c15.router({
     summary: "Get agent run log details by ID"
   }
 });
-var artifactDownloadResponseSchema = z19.object({
-  url: z19.string().url(),
-  expiresAt: z19.string()
+var artifactDownloadResponseSchema = z20.object({
+  url: z20.string().url(),
+  expiresAt: z20.string()
 });
-var platformArtifactDownloadContract = c15.router({
+var platformArtifactDownloadContract = c16.router({
   getDownloadUrl: {
     method: "GET",
     path: "/api/platform/artifacts/download",
-    query: z19.object({
-      name: z19.string().min(1, "Artifact name is required"),
-      version: z19.string().optional()
+    query: z20.object({
+      name: z20.string().min(1, "Artifact name is required"),
+      version: z20.string().optional()
     }),
     responses: {
       200: artifactDownloadResponseSchema,
@@ -2777,29 +2897,29 @@ var platformArtifactDownloadContract = c15.router({
 });
 
 // ../../packages/core/src/contracts/llm.ts
-import { z as z20 } from "zod";
-var c16 = initContract();
-var messageRoleSchema = z20.enum(["user", "assistant", "system"]);
-var chatMessageSchema = z20.object({
+import { z as z21 } from "zod";
+var c17 = initContract();
+var messageRoleSchema = z21.enum(["user", "assistant", "system"]);
+var chatMessageSchema = z21.object({
   role: messageRoleSchema,
-  content: z20.string()
+  content: z21.string()
 });
-var tokenUsageSchema = z20.object({
-  promptTokens: z20.number(),
-  completionTokens: z20.number(),
-  totalTokens: z20.number()
+var tokenUsageSchema = z21.object({
+  promptTokens: z21.number(),
+  completionTokens: z21.number(),
+  totalTokens: z21.number()
 });
-var llmChatRequestSchema = z20.object({
-  model: z20.string().min(1).optional(),
-  messages: z20.array(chatMessageSchema).min(1, "At least one message is required"),
-  stream: z20.boolean().optional().default(false)
+var llmChatRequestSchema = z21.object({
+  model: z21.string().min(1).optional(),
+  messages: z21.array(chatMessageSchema).min(1, "At least one message is required"),
+  stream: z21.boolean().optional().default(false)
 });
-var llmChatResponseSchema = z20.object({
-  content: z20.string(),
-  model: z20.string(),
+var llmChatResponseSchema = z21.object({
+  content: z21.string(),
+  model: z21.string(),
   usage: tokenUsageSchema
 });
-var llmChatContract = c16.router({
+var llmChatContract = c17.router({
   chat: {
     method: "POST",
     path: "/api/llm/chat",
@@ -2815,28 +2935,28 @@ var llmChatContract = c16.router({
 });
 
 // ../../packages/core/src/contracts/public/agents.ts
-import { z as z21 } from "zod";
-var c17 = initContract();
-var publicAgentSchema = z21.object({
-  id: z21.string(),
-  name: z21.string(),
-  currentVersionId: z21.string().nullable(),
+import { z as z22 } from "zod";
+var c18 = initContract();
+var publicAgentSchema = z22.object({
+  id: z22.string(),
+  name: z22.string(),
+  currentVersionId: z22.string().nullable(),
   createdAt: timestampSchema,
   updatedAt: timestampSchema
 });
-var agentVersionSchema = z21.object({
-  id: z21.string(),
-  agentId: z21.string(),
-  versionNumber: z21.number(),
+var agentVersionSchema = z22.object({
+  id: z22.string(),
+  agentId: z22.string(),
+  versionNumber: z22.number(),
   createdAt: timestampSchema
 });
 var publicAgentDetailSchema = publicAgentSchema;
 var paginatedAgentsSchema = createPaginatedResponseSchema(publicAgentSchema);
 var paginatedAgentVersionsSchema = createPaginatedResponseSchema(agentVersionSchema);
 var agentListQuerySchema = listQuerySchema.extend({
-  name: z21.string().optional()
+  name: z22.string().optional()
 });
-var publicAgentsListContract = c17.router({
+var publicAgentsListContract = c18.router({
   list: {
     method: "GET",
     path: "/v1/agents",
@@ -2851,13 +2971,13 @@ var publicAgentsListContract = c17.router({
     description: "List all agents in the current scope with pagination. Use the `name` query parameter to filter by agent name."
   }
 });
-var publicAgentByIdContract = c17.router({
+var publicAgentByIdContract = c18.router({
   get: {
     method: "GET",
     path: "/v1/agents/:id",
     headers: authHeadersSchema,
-    pathParams: z21.object({
-      id: z21.string().min(1, "Agent ID is required")
+    pathParams: z22.object({
+      id: z22.string().min(1, "Agent ID is required")
     }),
     responses: {
       200: publicAgentDetailSchema,
@@ -2869,13 +2989,13 @@ var publicAgentByIdContract = c17.router({
     description: "Get agent details by ID"
   }
 });
-var publicAgentVersionsContract = c17.router({
+var publicAgentVersionsContract = c18.router({
   list: {
     method: "GET",
     path: "/v1/agents/:id/versions",
     headers: authHeadersSchema,
-    pathParams: z21.object({
-      id: z21.string().min(1, "Agent ID is required")
+    pathParams: z22.object({
+      id: z22.string().min(1, "Agent ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -2890,9 +3010,9 @@ var publicAgentVersionsContract = c17.router({
 });
 
 // ../../packages/core/src/contracts/public/runs.ts
-import { z as z22 } from "zod";
-var c18 = initContract();
-var publicRunStatusSchema = z22.enum([
+import { z as z23 } from "zod";
+var c19 = initContract();
+var publicRunStatusSchema = z23.enum([
   "pending",
   "running",
   "completed",
@@ -2900,54 +3020,54 @@ var publicRunStatusSchema = z22.enum([
   "timeout",
   "cancelled"
 ]);
-var publicRunSchema = z22.object({
-  id: z22.string(),
-  agentId: z22.string(),
-  agentName: z22.string(),
+var publicRunSchema = z23.object({
+  id: z23.string(),
+  agentId: z23.string(),
+  agentName: z23.string(),
   status: publicRunStatusSchema,
-  prompt: z22.string(),
+  prompt: z23.string(),
   createdAt: timestampSchema,
   startedAt: timestampSchema.nullable(),
   completedAt: timestampSchema.nullable()
 });
 var publicRunDetailSchema = publicRunSchema.extend({
-  error: z22.string().nullable(),
-  executionTimeMs: z22.number().nullable(),
-  checkpointId: z22.string().nullable(),
-  sessionId: z22.string().nullable(),
-  artifactName: z22.string().nullable(),
-  artifactVersion: z22.string().nullable(),
-  volumes: z22.record(z22.string(), z22.string()).optional()
+  error: z23.string().nullable(),
+  executionTimeMs: z23.number().nullable(),
+  checkpointId: z23.string().nullable(),
+  sessionId: z23.string().nullable(),
+  artifactName: z23.string().nullable(),
+  artifactVersion: z23.string().nullable(),
+  volumes: z23.record(z23.string(), z23.string()).optional()
 });
 var paginatedRunsSchema = createPaginatedResponseSchema(publicRunSchema);
-var createRunRequestSchema = z22.object({
+var createRunRequestSchema = z23.object({
   // Agent identification (one of: agent, agentId, sessionId, checkpointId)
-  agent: z22.string().optional(),
+  agent: z23.string().optional(),
   // Agent name
-  agentId: z22.string().optional(),
+  agentId: z23.string().optional(),
   // Agent ID
-  agentVersion: z22.string().optional(),
+  agentVersion: z23.string().optional(),
   // Version specifier (e.g., "latest", "v1", specific ID)
   // Continue session
-  sessionId: z22.string().optional(),
+  sessionId: z23.string().optional(),
   // Resume from checkpoint
-  checkpointId: z22.string().optional(),
+  checkpointId: z23.string().optional(),
   // Required
-  prompt: z22.string().min(1, "Prompt is required"),
+  prompt: z23.string().min(1, "Prompt is required"),
   // Optional configuration
-  variables: z22.record(z22.string(), z22.string()).optional(),
-  secrets: z22.record(z22.string(), z22.string()).optional(),
-  artifactName: z22.string().optional(),
+  variables: z23.record(z23.string(), z23.string()).optional(),
+  secrets: z23.record(z23.string(), z23.string()).optional(),
+  artifactName: z23.string().optional(),
   // Artifact name to mount
-  artifactVersion: z22.string().optional(),
+  artifactVersion: z23.string().optional(),
   // Artifact version (defaults to latest)
-  volumes: z22.record(z22.string(), z22.string()).optional()
+  volumes: z23.record(z23.string(), z23.string()).optional()
   // volume_name -> version
 });
 var runListQuerySchema = listQuerySchema.extend({
   status: publicRunStatusSchema.optional()
 });
-var publicRunsListContract = c18.router({
+var publicRunsListContract = c19.router({
   list: {
     method: "GET",
     path: "/v1/runs",
@@ -2979,13 +3099,13 @@ var publicRunsListContract = c18.router({
     description: "Create and execute a new agent run. Returns 202 Accepted as runs execute asynchronously."
   }
 });
-var publicRunByIdContract = c18.router({
+var publicRunByIdContract = c19.router({
   get: {
     method: "GET",
     path: "/v1/runs/:id",
     headers: authHeadersSchema,
-    pathParams: z22.object({
-      id: z22.string().min(1, "Run ID is required")
+    pathParams: z23.object({
+      id: z23.string().min(1, "Run ID is required")
     }),
     responses: {
       200: publicRunDetailSchema,
@@ -2997,15 +3117,15 @@ var publicRunByIdContract = c18.router({
     description: "Get run details by ID"
   }
 });
-var publicRunCancelContract = c18.router({
+var publicRunCancelContract = c19.router({
   cancel: {
     method: "POST",
     path: "/v1/runs/:id/cancel",
     headers: authHeadersSchema,
-    pathParams: z22.object({
-      id: z22.string().min(1, "Run ID is required")
+    pathParams: z23.object({
+      id: z23.string().min(1, "Run ID is required")
     }),
-    body: z22.undefined(),
+    body: z23.undefined(),
     responses: {
       200: publicRunDetailSchema,
       400: publicApiErrorSchema,
@@ -3018,27 +3138,27 @@ var publicRunCancelContract = c18.router({
     description: "Cancel a pending or running execution"
   }
 });
-var logEntrySchema = z22.object({
+var logEntrySchema = z23.object({
   timestamp: timestampSchema,
-  type: z22.enum(["agent", "system", "network"]),
-  level: z22.enum(["debug", "info", "warn", "error"]),
-  message: z22.string(),
-  metadata: z22.record(z22.string(), z22.unknown()).optional()
+  type: z23.enum(["agent", "system", "network"]),
+  level: z23.enum(["debug", "info", "warn", "error"]),
+  message: z23.string(),
+  metadata: z23.record(z23.string(), z23.unknown()).optional()
 });
 var paginatedLogsSchema = createPaginatedResponseSchema(logEntrySchema);
 var logsQuerySchema = listQuerySchema.extend({
-  type: z22.enum(["agent", "system", "network", "all"]).default("all"),
+  type: z23.enum(["agent", "system", "network", "all"]).default("all"),
   since: timestampSchema.optional(),
   until: timestampSchema.optional(),
-  order: z22.enum(["asc", "desc"]).default("asc")
+  order: z23.enum(["asc", "desc"]).default("asc")
 });
-var publicRunLogsContract = c18.router({
+var publicRunLogsContract = c19.router({
   getLogs: {
     method: "GET",
     path: "/v1/runs/:id/logs",
     headers: authHeadersSchema,
-    pathParams: z22.object({
-      id: z22.string().min(1, "Run ID is required")
+    pathParams: z23.object({
+      id: z23.string().min(1, "Run ID is required")
     }),
     query: logsQuerySchema,
     responses: {
@@ -3051,30 +3171,30 @@ var publicRunLogsContract = c18.router({
     description: "Get unified logs for a run. Combines agent, system, and network logs."
   }
 });
-var metricPointSchema = z22.object({
+var metricPointSchema = z23.object({
   timestamp: timestampSchema,
-  cpuPercent: z22.number(),
-  memoryUsedMb: z22.number(),
-  memoryTotalMb: z22.number(),
-  diskUsedMb: z22.number(),
-  diskTotalMb: z22.number()
-});
-var metricsSummarySchema = z22.object({
-  avgCpuPercent: z22.number(),
-  maxMemoryUsedMb: z22.number(),
-  totalDurationMs: z22.number().nullable()
-});
-var metricsResponseSchema2 = z22.object({
-  data: z22.array(metricPointSchema),
+  cpuPercent: z23.number(),
+  memoryUsedMb: z23.number(),
+  memoryTotalMb: z23.number(),
+  diskUsedMb: z23.number(),
+  diskTotalMb: z23.number()
+});
+var metricsSummarySchema = z23.object({
+  avgCpuPercent: z23.number(),
+  maxMemoryUsedMb: z23.number(),
+  totalDurationMs: z23.number().nullable()
+});
+var metricsResponseSchema2 = z23.object({
+  data: z23.array(metricPointSchema),
   summary: metricsSummarySchema
 });
-var publicRunMetricsContract = c18.router({
+var publicRunMetricsContract = c19.router({
   getMetrics: {
     method: "GET",
     path: "/v1/runs/:id/metrics",
     headers: authHeadersSchema,
-    pathParams: z22.object({
-      id: z22.string().min(1, "Run ID is required")
+    pathParams: z23.object({
+      id: z23.string().min(1, "Run ID is required")
     }),
     responses: {
       200: metricsResponseSchema2,
@@ -3086,7 +3206,7 @@ var publicRunMetricsContract = c18.router({
     description: "Get CPU, memory, and disk metrics for a run"
   }
 });
-var sseEventTypeSchema = z22.enum([
+var sseEventTypeSchema = z23.enum([
   "status",
   // Run status change
   "output",
@@ -3098,26 +3218,26 @@ var sseEventTypeSchema = z22.enum([
   "heartbeat"
   // Keep-alive
 ]);
-var sseEventSchema = z22.object({
+var sseEventSchema = z23.object({
   event: sseEventTypeSchema,
-  data: z22.unknown(),
-  id: z22.string().optional()
+  data: z23.unknown(),
+  id: z23.string().optional()
   // For Last-Event-ID reconnection
 });
-var publicRunEventsContract = c18.router({
+var publicRunEventsContract = c19.router({
   streamEvents: {
     method: "GET",
     path: "/v1/runs/:id/events",
     headers: authHeadersSchema,
-    pathParams: z22.object({
-      id: z22.string().min(1, "Run ID is required")
+    pathParams: z23.object({
+      id: z23.string().min(1, "Run ID is required")
     }),
-    query: z22.object({
-      lastEventId: z22.string().optional()
+    query: z23.object({
+      lastEventId: z23.string().optional()
       // For reconnection
     }),
     responses: {
-      200: z22.any(),
+      200: z23.any(),
       // SSE stream - actual content is text/event-stream
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -3129,28 +3249,28 @@ var publicRunEventsContract = c18.router({
 });
 
 // ../../packages/core/src/contracts/public/artifacts.ts
-import { z as z23 } from "zod";
-var c19 = initContract();
-var publicArtifactSchema = z23.object({
-  id: z23.string(),
-  name: z23.string(),
-  currentVersionId: z23.string().nullable(),
-  size: z23.number(),
+import { z as z24 } from "zod";
+var c20 = initContract();
+var publicArtifactSchema = z24.object({
+  id: z24.string(),
+  name: z24.string(),
+  currentVersionId: z24.string().nullable(),
+  size: z24.number(),
   // Total size in bytes
-  fileCount: z23.number(),
+  fileCount: z24.number(),
   createdAt: timestampSchema,
   updatedAt: timestampSchema
 });
-var artifactVersionSchema = z23.object({
-  id: z23.string(),
+var artifactVersionSchema = z24.object({
+  id: z24.string(),
   // SHA-256 content hash
-  artifactId: z23.string(),
-  size: z23.number(),
+  artifactId: z24.string(),
+  size: z24.number(),
   // Size in bytes
-  fileCount: z23.number(),
-  message: z23.string().nullable(),
+  fileCount: z24.number(),
+  message: z24.string().nullable(),
   // Optional commit message
-  createdBy: z23.string(),
+  createdBy: z24.string(),
   createdAt: timestampSchema
 });
 var publicArtifactDetailSchema = publicArtifactSchema.extend({
@@ -3160,7 +3280,7 @@ var paginatedArtifactsSchema = createPaginatedResponseSchema(publicArtifactSchem
 var paginatedArtifactVersionsSchema = createPaginatedResponseSchema(
   artifactVersionSchema
 );
-var publicArtifactsListContract = c19.router({
+var publicArtifactsListContract = c20.router({
   list: {
     method: "GET",
     path: "/v1/artifacts",
@@ -3175,13 +3295,13 @@ var publicArtifactsListContract = c19.router({
     description: "List all artifacts in the current scope with pagination"
   }
 });
-var publicArtifactByIdContract = c19.router({
+var publicArtifactByIdContract = c20.router({
   get: {
     method: "GET",
     path: "/v1/artifacts/:id",
     headers: authHeadersSchema,
-    pathParams: z23.object({
-      id: z23.string().min(1, "Artifact ID is required")
+    pathParams: z24.object({
+      id: z24.string().min(1, "Artifact ID is required")
     }),
     responses: {
       200: publicArtifactDetailSchema,
@@ -3193,13 +3313,13 @@ var publicArtifactByIdContract = c19.router({
     description: "Get artifact details by ID"
   }
 });
-var publicArtifactVersionsContract = c19.router({
+var publicArtifactVersionsContract = c20.router({
   list: {
     method: "GET",
     path: "/v1/artifacts/:id/versions",
     headers: authHeadersSchema,
-    pathParams: z23.object({
-      id: z23.string().min(1, "Artifact ID is required")
+    pathParams: z24.object({
+      id: z24.string().min(1, "Artifact ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -3212,20 +3332,20 @@ var publicArtifactVersionsContract = c19.router({
     description: "List all versions of an artifact with pagination"
   }
 });
-var publicArtifactDownloadContract = c19.router({
+var publicArtifactDownloadContract = c20.router({
   download: {
     method: "GET",
     path: "/v1/artifacts/:id/download",
     headers: authHeadersSchema,
-    pathParams: z23.object({
-      id: z23.string().min(1, "Artifact ID is required")
+    pathParams: z24.object({
+      id: z24.string().min(1, "Artifact ID is required")
     }),
-    query: z23.object({
-      versionId: z23.string().optional()
+    query: z24.object({
+      versionId: z24.string().optional()
       // Defaults to current version
     }),
     responses: {
-      302: z23.undefined(),
+      302: z24.undefined(),
       // Redirect to presigned URL
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -3237,28 +3357,28 @@ var publicArtifactDownloadContract = c19.router({
 });
 
 // ../../packages/core/src/contracts/public/volumes.ts
-import { z as z24 } from "zod";
-var c20 = initContract();
-var publicVolumeSchema = z24.object({
-  id: z24.string(),
-  name: z24.string(),
-  currentVersionId: z24.string().nullable(),
-  size: z24.number(),
+import { z as z25 } from "zod";
+var c21 = initContract();
+var publicVolumeSchema = z25.object({
+  id: z25.string(),
+  name: z25.string(),
+  currentVersionId: z25.string().nullable(),
+  size: z25.number(),
   // Total size in bytes
-  fileCount: z24.number(),
+  fileCount: z25.number(),
   createdAt: timestampSchema,
   updatedAt: timestampSchema
 });
-var volumeVersionSchema = z24.object({
-  id: z24.string(),
+var volumeVersionSchema = z25.object({
+  id: z25.string(),
   // SHA-256 content hash
-  volumeId: z24.string(),
-  size: z24.number(),
+  volumeId: z25.string(),
+  size: z25.number(),
   // Size in bytes
-  fileCount: z24.number(),
-  message: z24.string().nullable(),
+  fileCount: z25.number(),
+  message: z25.string().nullable(),
   // Optional commit message
-  createdBy: z24.string(),
+  createdBy: z25.string(),
   createdAt: timestampSchema
 });
 var publicVolumeDetailSchema = publicVolumeSchema.extend({
@@ -3266,7 +3386,7 @@ var publicVolumeDetailSchema = publicVolumeSchema.extend({
 });
 var paginatedVolumesSchema = createPaginatedResponseSchema(publicVolumeSchema);
 var paginatedVolumeVersionsSchema = createPaginatedResponseSchema(volumeVersionSchema);
-var publicVolumesListContract = c20.router({
+var publicVolumesListContract = c21.router({
   list: {
     method: "GET",
     path: "/v1/volumes",
@@ -3281,13 +3401,13 @@ var publicVolumesListContract = c20.router({
     description: "List all volumes in the current scope with pagination"
   }
 });
-var publicVolumeByIdContract = c20.router({
+var publicVolumeByIdContract = c21.router({
   get: {
     method: "GET",
     path: "/v1/volumes/:id",
     headers: authHeadersSchema,
-    pathParams: z24.object({
-      id: z24.string().min(1, "Volume ID is required")
+    pathParams: z25.object({
+      id: z25.string().min(1, "Volume ID is required")
     }),
     responses: {
       200: publicVolumeDetailSchema,
@@ -3299,13 +3419,13 @@ var publicVolumeByIdContract = c20.router({
     description: "Get volume details by ID"
   }
 });
-var publicVolumeVersionsContract = c20.router({
+var publicVolumeVersionsContract = c21.router({
   list: {
     method: "GET",
     path: "/v1/volumes/:id/versions",
     headers: authHeadersSchema,
-    pathParams: z24.object({
-      id: z24.string().min(1, "Volume ID is required")
+    pathParams: z25.object({
+      id: z25.string().min(1, "Volume ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -3318,20 +3438,20 @@ var publicVolumeVersionsContract = c20.router({
     description: "List all versions of a volume with pagination"
   }
 });
-var publicVolumeDownloadContract = c20.router({
+var publicVolumeDownloadContract = c21.router({
   download: {
     method: "GET",
     path: "/v1/volumes/:id/download",
     headers: authHeadersSchema,
-    pathParams: z24.object({
-      id: z24.string().min(1, "Volume ID is required")
+    pathParams: z25.object({
+      id: z25.string().min(1, "Volume ID is required")
     }),
-    query: z24.object({
-      versionId: z24.string().optional()
+    query: z25.object({
+      versionId: z25.string().optional()
       // Defaults to current version
     }),
     responses: {
-      302: z24.undefined(),
+      302: z25.undefined(),
       // Redirect to presigned URL
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -3952,8 +4072,8 @@ async function getUsage(options) {
 }
 
 // src/lib/domain/yaml-validator.ts
-import { z as z25 } from "zod";
-var cliAgentNameSchema = z25.string().min(3, "Agent name must be at least 3 characters").max(64, "Agent name must be 64 characters or less").regex(
+import { z as z26 } from "zod";
+var cliAgentNameSchema = z26.string().min(3, "Agent name must be at least 3 characters").max(64, "Agent name must be 64 characters or less").regex(
   /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,62}[a-zA-Z0-9])?$/,
   "Agent name must start and end with letter or number, and contain only letters, numbers, and hyphens"
 );
@@ -3968,7 +4088,7 @@ var cliAgentDefinitionSchema = agentDefinitionSchema.superRefine(
         const skillUrl = agent.skills[i];
         if (skillUrl && !validateGitHubTreeUrl(skillUrl)) {
           ctx.addIssue({
-            code: z25.ZodIssueCode.custom,
+            code: z26.ZodIssueCode.custom,
             message: `Invalid skill URL: ${skillUrl}. Expected format: https://github.com/{owner}/{repo}/tree/{branch}/{path}`,
             path: ["skills", i]
           });
@@ -3977,15 +4097,15 @@ var cliAgentDefinitionSchema = agentDefinitionSchema.superRefine(
     }
   }
 );
-var cliComposeSchema = z25.object({
-  version: z25.string().min(1, "Missing config.version"),
-  agents: z25.record(cliAgentNameSchema, cliAgentDefinitionSchema),
-  volumes: z25.record(z25.string(), volumeConfigSchema).optional()
+var cliComposeSchema = z26.object({
+  version: z26.string().min(1, "Missing config.version"),
+  agents: z26.record(cliAgentNameSchema, cliAgentDefinitionSchema),
+  volumes: z26.record(z26.string(), volumeConfigSchema).optional()
 }).superRefine((config, ctx) => {
   const agentKeys = Object.keys(config.agents);
   if (agentKeys.length === 0) {
     ctx.addIssue({
-      code: z25.ZodIssueCode.custom,
+      code: z26.ZodIssueCode.custom,
       message: "agents must have at least one agent defined",
       path: ["agents"]
     });
@@ -3993,7 +4113,7 @@ var cliComposeSchema = z25.object({
   }
   if (agentKeys.length > 1) {
     ctx.addIssue({
-      code: z25.ZodIssueCode.custom,
+      code: z26.ZodIssueCode.custom,
       message: "Multiple agents not supported yet. Only one agent allowed.",
       path: ["agents"]
     });
@@ -4005,7 +4125,7 @@ var cliComposeSchema = z25.object({
   if (agentVolumes && agentVolumes.length > 0) {
     if (!config.volumes) {
       ctx.addIssue({
-        code: z25.ZodIssueCode.custom,
+        code: z26.ZodIssueCode.custom,
         message: "Agent references volumes but no volumes section defined. Each volume must have explicit name and version.",
         path: ["volumes"]
       });
@@ -4015,7 +4135,7 @@ var cliComposeSchema = z25.object({
       const parts = volDeclaration.split(":");
       if (parts.length !== 2) {
         ctx.addIssue({
-          code: z25.ZodIssueCode.custom,
+          code: z26.ZodIssueCode.custom,
           message: `Invalid volume declaration: ${volDeclaration}. Expected format: volume-key:/mount/path`,
           path: ["agents", agentName, "volumes"]
         });
@@ -4024,7 +4144,7 @@ var cliComposeSchema = z25.object({
       const volumeKey = parts[0].trim();
       if (!config.volumes[volumeKey]) {
         ctx.addIssue({
-          code: z25.ZodIssueCode.custom,
+          code: z26.ZodIssueCode.custom,
           message: `Volume "${volumeKey}" is not defined in volumes section. Each volume must have explicit name and version.`,
           path: ["volumes", volumeKey]
         });
@@ -4840,6 +4960,7 @@ async function silentUpgradeAfterCommand(currentVersion) {
 }
 
 // src/commands/compose/index.ts
+var DEFAULT_CONFIG_FILE = "vm0.yaml";
 function getSecretsFromComposeContent(content) {
   const refs = extractVariableReferences(content);
   const grouped = groupVariablesBySource(refs);
@@ -5022,10 +5143,14 @@ function mergeSkillVariables(agent, variables) {
     agent.environment = environment;
   }
 }
-var composeCommand = new Command7().name("compose").description("Create or update agent compose (e.g., vm0.yaml)").argument("<agent-yaml>", "Path to agent YAML file").option("-y, --yes", "Skip confirmation prompts for skill requirements").addOption(new Option("--no-auto-update").hideHelp()).action(
+var composeCommand = new Command7().name("compose").description("Create or update agent compose (e.g., vm0.yaml)").argument(
+  "[agent-yaml]",
+  `Path to agent YAML file (default: ${DEFAULT_CONFIG_FILE})`
+).option("-y, --yes", "Skip confirmation prompts for skill requirements").addOption(new Option("--no-auto-update").hideHelp()).action(
   async (configFile, options) => {
+    const resolvedConfigFile = configFile ?? DEFAULT_CONFIG_FILE;
     try {
-      const { config, agentName, agent, basePath } = await loadAndValidateConfig(configFile);
+      const { config, agentName, agent, basePath } = await loadAndValidateConfig(resolvedConfigFile);
       checkLegacyImageFormat(config);
       const skillResults = await uploadAssets(agentName, agent, basePath);
       const environment = agent.environment || {};
@@ -5058,7 +5183,7 @@ var composeCommand = new Command7().name("compose").description("Create or updat
         )
       );
       if (options.autoUpdate !== false) {
-        await silentUpgradeAfterCommand("9.16.0");
+        await silentUpgradeAfterCommand("9.17.0");
       }
     } catch (error) {
       if (error instanceof Error) {
@@ -5813,9 +5938,9 @@ var CodexEventParser = class {
       }
     }
     if (itemType === "file_change" && item.changes && item.changes.length > 0) {
-      const changes = item.changes.map((c21) => {
-        const action = c21.kind === "add" ? "Created" : c21.kind === "modify" ? "Modified" : "Deleted";
-        return `${action}: ${c21.path}`;
+      const changes = item.changes.map((c22) => {
+        const action = c22.kind === "add" ? "Created" : c22.kind === "modify" ? "Modified" : "Deleted";
+        return `${action}: ${c22.path}`;
       }).join("\n");
       return {
         type: "text",
@@ -5969,9 +6094,9 @@ var CodexEventRenderer = class {
       return;
     }
     if (itemType === "file_change" && item.changes && item.changes.length > 0) {
-      const summary = item.changes.map((c21) => {
-        const icon = c21.kind === "add" ? "+" : c21.kind === "delete" ? "-" : "~";
-        return `${icon}${c21.path}`;
+      const summary = item.changes.map((c22) => {
+        const icon = c22.kind === "add" ? "+" : c22.kind === "delete" ? "-" : "~";
+        return `${icon}${c22.path}`;
       }).join(", ");
       console.log(chalk7.green("[files]") + ` ${summary}`);
       return;
@@ -7289,7 +7414,7 @@ var mainRunCommand = new Command8().name("run").description("Run an agent").argu
       }
       showNextSteps(result);
       if (options.autoUpdate !== false) {
-        await silentUpgradeAfterCommand("9.16.0");
+        await silentUpgradeAfterCommand("9.17.0");
       }
     } catch (error) {
       handleRunError(error, identifier);
@@ -8795,7 +8920,7 @@ var cookAction = new Command27().name("cook").description("Quick start: prepare,
 ).option("-y, --yes", "Skip confirmation prompts").option("-v, --verbose", "Show full tool inputs and outputs").addOption(new Option5("--debug-no-mock-claude").hideHelp()).addOption(new Option5("--no-auto-update").hideHelp()).action(
   async (prompt, options) => {
     if (options.autoUpdate !== false) {
-      const shouldExit = await checkAndUpgrade("9.16.0", prompt);
+      const shouldExit = await checkAndUpgrade("9.17.0", prompt);
       if (shouldExit) {
         process.exit(0);
       }
@@ -9509,7 +9634,7 @@ var listCommand4 = new Command36().name("list").alias("ls").description("List al
       );
       return;
     }
-    const nameWidth = Math.max(4, ...data.composes.map((c21) => c21.name.length));
+    const nameWidth = Math.max(4, ...data.composes.map((c22) => c22.name.length));
     const header = ["NAME".padEnd(nameWidth), "VERSION", "UPDATED"].join(
       "  "
     );
@@ -10291,7 +10416,7 @@ async function gatherFrequency(optionFrequency, existingFrequency) {
     );
     process.exit(1);
   }
-  const defaultIndex = existingFrequency ? FREQUENCY_CHOICES.findIndex((c21) => c21.value === existingFrequency) : 0;
+  const defaultIndex = existingFrequency ? FREQUENCY_CHOICES.findIndex((c22) => c22.value === existingFrequency) : 0;
   frequency = await promptSelect(
     "Schedule frequency",
     FREQUENCY_CHOICES,
@@ -10320,7 +10445,7 @@ async function gatherDay(frequency, optionDay, existingDay) {
     process.exit(1);
   }
   if (frequency === "weekly") {
-    const defaultDayIndex = existingDay !== void 0 ? DAY_OF_WEEK_CHOICES.findIndex((c21) => c21.value === existingDay) : 0;
+    const defaultDayIndex = existingDay !== void 0 ? DAY_OF_WEEK_CHOICES.findIndex((c22) => c22.value === existingDay) : 0;
     const day2 = await promptSelect(
       "Day of week",
       DAY_OF_WEEK_CHOICES,
@@ -12379,16 +12504,16 @@ async function handleModelProvider(ctx) {
     const providerType = await step.prompt(
       () => promptSelect(
         "Select provider type:",
-        choices.map((c21) => ({
-          title: c21.label,
-          value: c21.type
+        choices.map((c22) => ({
+          title: c22.label,
+          value: c22.type
         }))
       )
     );
     if (!providerType) {
       process.exit(0);
     }
-    const selectedChoice = choices.find((c21) => c21.type === providerType);
+    const selectedChoice = choices.find((c22) => c22.type === providerType);
     if (selectedChoice?.helpText) {
       for (const line of selectedChoice.helpText.split("\n")) {
         step.detail(chalk58.dim(line));
@@ -12578,7 +12703,7 @@ var setupClaudeCommand = new Command58().name("setup-claude").description("Insta
 
 // src/index.ts
 var program = new Command59();
-program.name("vm0").description("VM0 CLI - Build and run agents with natural language").version("9.16.0");
+program.name("vm0").description("VM0 CLI - Build and run agents with natural language").version("9.17.0");
 program.addCommand(authCommand);
 program.addCommand(infoCommand);
 program.addCommand(composeCommand);