@vm0/cli 9.60.1 → 9.61.0

package/index.js

@@ -45,7 +45,7 @@ if (DSN) {
   Sentry.init({
     dsn: DSN,
     environment: process.env.SENTRY_ENVIRONMENT ?? "production",
-    release: "9.60.1",
+    release: "9.61.0",
     sendDefaultPii: false,
     tracesSampleRate: 0,
     shutdownTimeout: 500,
@@ -64,7 +64,7 @@ if (DSN) {
     }
   });
   Sentry.setContext("cli", {
-    version: "9.60.1",
+    version: "9.61.0",
     command: process.argv.slice(2).join(" ")
   });
   Sentry.setContext("runtime", {
@@ -83,7 +83,7 @@ process.stdout.on("error", handleEpipe);
 process.stderr.on("error", handleEpipe);
 
 // src/index.ts
-import { Command as Command86 } from "commander";
+import { Command as Command87 } from "commander";
 
 // src/lib/network/proxy.ts
 import { EnvHttpProxyAgent, setGlobalDispatcher } from "undici";
@@ -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.60.1"}`));
+  console.log(chalk4.bold(`VM0 CLI v${"9.61.0"}`));
   console.log();
   const config = await loadConfig();
   const hasEnvToken = !!process.env.VM0_TOKEN;
@@ -1071,8 +1071,95 @@ var composesListContract = c.router({
 });
 
 // ../../packages/core/src/contracts/runs.ts
+import { z as z5 } from "zod";
+
+// ../../packages/core/src/contracts/orgs.ts
 import { z as z4 } from "zod";
 var c2 = initContract();
+var orgTierSchema = z4.enum(["free", "pro", "max"]);
+var orgSlugSchema = z4.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 = z4.object({
+  id: z4.string(),
+  slug: z4.string(),
+  tier: z4.string().optional()
+});
+var updateOrgRequestSchema = z4.object({
+  slug: orgSlugSchema,
+  force: z4.boolean().optional().default(false)
+});
+var orgContract = c2.router({
+  /**
+   * GET /api/org
+   * Get current user's default org
+   */
+  get: {
+    method: "GET",
+    path: "/api/org",
+    headers: authHeadersSchema,
+    responses: {
+      200: orgResponseSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Get current user's default org"
+  },
+  /**
+   * PUT /api/org
+   * Update org slug
+   */
+  update: {
+    method: "PUT",
+    path: "/api/org",
+    headers: authHeadersSchema,
+    body: updateOrgRequestSchema,
+    responses: {
+      200: orgResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      409: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Update org slug"
+  }
+});
+var orgDefaultAgentContract = c2.router({
+  /**
+   * PUT /api/orgs/default-agent?org={slug}
+   * Set or unset the default agent for an org.
+   * Only org admins can perform this action.
+   * The agent must belong to the same org.
+   */
+  setDefaultAgent: {
+    method: "PUT",
+    path: "/api/orgs/default-agent",
+    headers: authHeadersSchema,
+    query: z4.object({
+      org: z4.string().optional()
+    }),
+    body: z4.object({
+      agentComposeId: z4.string().uuid().nullable()
+    }),
+    responses: {
+      200: z4.object({
+        agentComposeId: z4.string().uuid().nullable()
+      }),
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Set or unset the default agent for an org"
+  }
+});
+
+// ../../packages/core/src/contracts/runs.ts
+var c3 = initContract();
 var ALL_RUN_STATUSES = [
   "queued",
   "pending",
@@ -1082,94 +1169,97 @@ var ALL_RUN_STATUSES = [
   "timeout",
   "cancelled"
 ];
-var runStatusSchema = z4.enum(ALL_RUN_STATUSES);
-var unifiedRunRequestSchema = z4.object({
+var runStatusSchema = z5.enum(ALL_RUN_STATUSES);
+var unifiedRunRequestSchema = z5.object({
   // High-level shortcuts (mutually exclusive with each other)
-  checkpointId: z4.string().optional(),
-  sessionId: z4.string().optional(),
+  checkpointId: z5.string().optional(),
+  sessionId: z5.string().optional(),
   // Base parameters (can be used directly or overridden after shortcut expansion)
-  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(),
+  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(),
   // Debug flag to force real Claude in mock environments (internal use only)
-  debugNoMockClaude: z4.boolean().optional(),
+  debugNoMockClaude: z5.boolean().optional(),
   // Model provider for automatic secret injection
-  modelProvider: z4.string().optional(),
+  modelProvider: z5.string().optional(),
   // Environment validation flag - when true, validates secrets/vars before running
-  checkEnv: z4.boolean().optional(),
+  checkEnv: z5.boolean().optional(),
   // Required
-  prompt: z4.string().min(1, "Missing prompt")
+  prompt: z5.string().min(1, "Missing prompt")
 });
-var createRunResponseSchema = z4.object({
-  runId: z4.string(),
+var createRunResponseSchema = z5.object({
+  runId: z5.string(),
   status: runStatusSchema,
-  sandboxId: z4.string().optional(),
-  output: z4.string().optional(),
-  error: z4.string().optional(),
-  executionTimeMs: z4.number().optional(),
-  createdAt: z4.string()
+  sandboxId: z5.string().optional(),
+  output: z5.string().optional(),
+  error: z5.string().optional(),
+  executionTimeMs: z5.number().optional(),
+  createdAt: z5.string()
 });
-var getRunResponseSchema = z4.object({
-  runId: z4.string(),
-  agentComposeVersionId: z4.string().nullable(),
+var getRunResponseSchema = z5.object({
+  runId: z5.string(),
+  agentComposeVersionId: z5.string().nullable(),
   status: runStatusSchema,
-  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: z4.string().optional(),
-  createdAt: z4.string(),
-  startedAt: z4.string().optional(),
-  completedAt: z4.string().optional()
+  prompt: z5.string(),
+  vars: z5.record(z5.string(), z5.string()).optional(),
+  sandboxId: z5.string().optional(),
+  result: z5.object({
+    output: z5.string().optional(),
+    executionTimeMs: z5.number().optional(),
+    agentSessionId: z5.string().optional(),
+    checkpointId: z5.string().optional(),
+    conversationId: z5.string().optional()
+  }).passthrough().optional(),
+  error: z5.string().optional(),
+  createdAt: z5.string(),
+  startedAt: z5.string().optional(),
+  completedAt: z5.string().optional()
 });
-var runEventSchema = z4.object({
-  sequenceNumber: z4.number(),
-  eventType: z4.string(),
-  eventData: z4.unknown(),
-  createdAt: z4.string()
+var runEventSchema = z5.object({
+  sequenceNumber: z5.number(),
+  eventType: z5.string(),
+  eventData: z5.unknown(),
+  createdAt: z5.string()
 });
-var runResultSchema = z4.object({
-  checkpointId: z4.string(),
-  agentSessionId: z4.string(),
-  conversationId: z4.string(),
-  artifact: z4.record(z4.string(), z4.string()).optional(),
+var runResultSchema = z5.object({
+  checkpointId: z5.string(),
+  agentSessionId: z5.string(),
+  conversationId: z5.string(),
+  artifact: z5.record(z5.string(), z5.string()).optional(),
   // optional when run has no artifact
-  volumes: z4.record(z4.string(), z4.string()).optional(),
-  memory: z4.record(z4.string(), z4.string()).optional()
+  volumes: z5.record(z5.string(), z5.string()).optional(),
+  memory: z5.record(z5.string(), z5.string()).optional()
 });
-var runStateSchema = z4.object({
+var runStateSchema = z5.object({
   status: runStatusSchema,
   result: runResultSchema.optional(),
-  error: z4.string().optional()
+  error: z5.string().optional()
 });
-var eventsResponseSchema = z4.object({
-  events: z4.array(runEventSchema),
-  hasMore: z4.boolean(),
-  nextSequence: z4.number(),
+var eventsResponseSchema = z5.object({
+  events: z5.array(runEventSchema),
+  hasMore: z5.boolean(),
+  nextSequence: z5.number(),
   run: runStateSchema,
-  framework: z4.string()
+  framework: z5.string()
 });
-var runListItemSchema = z4.object({
-  id: z4.string(),
-  agentName: z4.string(),
+var runListItemSchema = z5.object({
+  id: z5.string(),
+  agentName: z5.string(),
   status: runStatusSchema,
-  prompt: z4.string(),
-  createdAt: z4.string(),
-  startedAt: z4.string().nullable()
+  prompt: z5.string(),
+  createdAt: z5.string(),
+  startedAt: z5.string().nullable()
 });
-var runsListResponseSchema = z4.object({
-  runs: z4.array(runListItemSchema)
+var runsListResponseSchema = z5.object({
+  runs: z5.array(runListItemSchema)
 });
-var runsMainContract = c2.router({
+var runsMainContract = c3.router({
   /**
    * GET /api/agent/runs
    * List agent runs (pending and running by default)
@@ -1178,16 +1268,16 @@ var runsMainContract = c2.router({
     method: "GET",
     path: "/api/agent/runs",
     headers: authHeadersSchema,
-    query: z4.object({
-      status: z4.string().optional(),
+    query: z5.object({
+      status: z5.string().optional(),
       // comma-separated: "pending,running"
-      agent: z4.string().optional(),
+      agent: z5.string().optional(),
       // agent name filter
-      since: z4.string().optional(),
+      since: z5.string().optional(),
       // ISO timestamp
-      until: z4.string().optional(),
+      until: z5.string().optional(),
       // ISO timestamp
-      limit: z4.coerce.number().min(1).max(100).default(50)
+      limit: z5.coerce.number().min(1).max(100).default(50)
     }),
     responses: {
       200: runsListResponseSchema,
@@ -1214,7 +1304,7 @@ var runsMainContract = c2.router({
     summary: "Create and execute agent run"
   }
 });
-var runsByIdContract = c2.router({
+var runsByIdContract = c3.router({
   /**
    * GET /api/agent/runs/:id
    * Get agent run status and results
@@ -1223,8 +1313,8 @@ var runsByIdContract = c2.router({
     method: "GET",
     path: "/api/agent/runs/:id",
     headers: authHeadersSchema,
-    pathParams: z4.object({
-      id: z4.string().min(1, "Run ID is required")
+    pathParams: z5.object({
+      id: z5.string().min(1, "Run ID is required")
     }),
     responses: {
       200: getRunResponseSchema,
@@ -1235,12 +1325,12 @@ var runsByIdContract = c2.router({
     summary: "Get agent run by ID"
   }
 });
-var cancelRunResponseSchema = z4.object({
-  id: z4.string(),
-  status: z4.literal("cancelled"),
-  message: z4.string()
+var cancelRunResponseSchema = z5.object({
+  id: z5.string(),
+  status: z5.literal("cancelled"),
+  message: z5.string()
 });
-var runsCancelContract = c2.router({
+var runsCancelContract = c3.router({
   /**
    * POST /api/agent/runs/:id/cancel
    * Cancel a pending or running run
@@ -1249,10 +1339,10 @@ var runsCancelContract = c2.router({
     method: "POST",
     path: "/api/agent/runs/:id/cancel",
     headers: authHeadersSchema,
-    pathParams: z4.object({
-      id: z4.string().min(1, "Run ID is required")
+    pathParams: z5.object({
+      id: z5.string().min(1, "Run ID is required")
     }),
-    body: z4.undefined(),
+    body: z5.undefined(),
     responses: {
       200: cancelRunResponseSchema,
       400: apiErrorSchema,
@@ -1262,7 +1352,7 @@ var runsCancelContract = c2.router({
     summary: "Cancel a pending or running run"
   }
 });
-var runEventsContract = c2.router({
+var runEventsContract = c3.router({
   /**
    * GET /api/agent/runs/:id/events
    * Poll for agent run events with pagination
@@ -1271,12 +1361,12 @@ var runEventsContract = c2.router({
     method: "GET",
     path: "/api/agent/runs/:id/events",
     headers: authHeadersSchema,
-    pathParams: z4.object({
-      id: z4.string().min(1, "Run ID is required")
+    pathParams: z5.object({
+      id: z5.string().min(1, "Run ID is required")
     }),
-    query: z4.object({
-      since: z4.coerce.number().default(-1),
-      limit: z4.coerce.number().default(100)
+    query: z5.object({
+      since: z5.coerce.number().default(-1),
+      limit: z5.coerce.number().default(100)
     }),
     responses: {
       200: eventsResponseSchema,
@@ -1286,50 +1376,50 @@ var runEventsContract = c2.router({
     summary: "Get agent run events"
   }
 });
-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 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 systemLogResponseSchema = z4.object({
-  systemLog: z4.string(),
-  hasMore: z4.boolean()
+var systemLogResponseSchema = z5.object({
+  systemLog: z5.string(),
+  hasMore: z5.boolean()
 });
-var metricsResponseSchema = z4.object({
-  metrics: z4.array(telemetryMetricSchema),
-  hasMore: z4.boolean()
+var metricsResponseSchema = z5.object({
+  metrics: z5.array(telemetryMetricSchema),
+  hasMore: z5.boolean()
 });
-var agentEventsResponseSchema = z4.object({
-  events: z4.array(runEventSchema),
-  hasMore: z4.boolean(),
-  framework: z4.string()
+var agentEventsResponseSchema = z5.object({
+  events: z5.array(runEventSchema),
+  hasMore: z5.boolean(),
+  framework: z5.string()
 });
-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 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 networkLogsResponseSchema = z4.object({
-  networkLogs: z4.array(networkLogEntrySchema),
-  hasMore: z4.boolean()
+var networkLogsResponseSchema = z5.object({
+  networkLogs: z5.array(networkLogEntrySchema),
+  hasMore: z5.boolean()
 });
-var telemetryResponseSchema = z4.object({
-  systemLog: z4.string(),
-  metrics: z4.array(telemetryMetricSchema)
+var telemetryResponseSchema = z5.object({
+  systemLog: z5.string(),
+  metrics: z5.array(telemetryMetricSchema)
 });
-var runTelemetryContract = c2.router({
+var runTelemetryContract = c3.router({
   /**
    * GET /api/agent/runs/:id/telemetry
    * Get aggregated telemetry data for a run (legacy combined format)
@@ -1338,8 +1428,8 @@ var runTelemetryContract = c2.router({
     method: "GET",
     path: "/api/agent/runs/:id/telemetry",
     headers: authHeadersSchema,
-    pathParams: z4.object({
-      id: z4.string().min(1, "Run ID is required")
+    pathParams: z5.object({
+      id: z5.string().min(1, "Run ID is required")
     }),
     responses: {
       200: telemetryResponseSchema,
@@ -1349,7 +1439,7 @@ var runTelemetryContract = c2.router({
     summary: "Get run telemetry data"
   }
 });
-var runSystemLogContract = c2.router({
+var runSystemLogContract = c3.router({
   /**
    * GET /api/agent/runs/:id/telemetry/system-log
    * Get system log with pagination
@@ -1358,13 +1448,13 @@ var runSystemLogContract = c2.router({
     method: "GET",
     path: "/api/agent/runs/:id/telemetry/system-log",
     headers: authHeadersSchema,
-    pathParams: z4.object({
-      id: z4.string().min(1, "Run ID is required")
+    pathParams: z5.object({
+      id: z5.string().min(1, "Run ID is required")
     }),
-    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")
+    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")
     }),
     responses: {
       200: systemLogResponseSchema,
@@ -1374,7 +1464,7 @@ var runSystemLogContract = c2.router({
     summary: "Get system log with pagination"
   }
 });
-var runMetricsContract = c2.router({
+var runMetricsContract = c3.router({
   /**
    * GET /api/agent/runs/:id/telemetry/metrics
    * Get metrics with pagination
@@ -1383,13 +1473,13 @@ var runMetricsContract = c2.router({
     method: "GET",
     path: "/api/agent/runs/:id/telemetry/metrics",
     headers: authHeadersSchema,
-    pathParams: z4.object({
-      id: z4.string().min(1, "Run ID is required")
+    pathParams: z5.object({
+      id: z5.string().min(1, "Run ID is required")
     }),
-    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")
+    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")
     }),
     responses: {
       200: metricsResponseSchema,
@@ -1399,7 +1489,7 @@ var runMetricsContract = c2.router({
     summary: "Get metrics with pagination"
   }
 });
-var runAgentEventsContract = c2.router({
+var runAgentEventsContract = c3.router({
   /**
    * GET /api/agent/runs/:id/telemetry/agent
    * Get agent events with pagination (for vm0 logs default)
@@ -1408,13 +1498,13 @@ var runAgentEventsContract = c2.router({
     method: "GET",
     path: "/api/agent/runs/:id/telemetry/agent",
     headers: authHeadersSchema,
-    pathParams: z4.object({
-      id: z4.string().min(1, "Run ID is required")
+    pathParams: z5.object({
+      id: z5.string().min(1, "Run ID is required")
     }),
-    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")
+    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")
     }),
     responses: {
       200: agentEventsResponseSchema,
@@ -1424,7 +1514,7 @@ var runAgentEventsContract = c2.router({
     summary: "Get agent events with pagination"
   }
 });
-var runNetworkLogsContract = c2.router({
+var runNetworkLogsContract = c3.router({
   /**
    * GET /api/agent/runs/:id/telemetry/network
    * Get network logs with pagination (for vm0 logs --network)
@@ -1433,13 +1523,13 @@ var runNetworkLogsContract = c2.router({
     method: "GET",
     path: "/api/agent/runs/:id/telemetry/network",
     headers: authHeadersSchema,
-    pathParams: z4.object({
-      id: z4.string().min(1, "Run ID is required")
+    pathParams: z5.object({
+      id: z5.string().min(1, "Run ID is required")
     }),
-    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")
+    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")
     }),
     responses: {
       200: networkLogsResponseSchema,
@@ -1449,18 +1539,18 @@ var runNetworkLogsContract = c2.router({
     summary: "Get network logs with pagination"
   }
 });
-var searchResultSchema = z4.object({
-  runId: z4.string(),
-  agentName: z4.string(),
+var searchResultSchema = z5.object({
+  runId: z5.string(),
+  agentName: z5.string(),
   matchedEvent: runEventSchema,
-  contextBefore: z4.array(runEventSchema),
-  contextAfter: z4.array(runEventSchema)
+  contextBefore: z5.array(runEventSchema),
+  contextAfter: z5.array(runEventSchema)
 });
-var logsSearchResponseSchema = z4.object({
-  results: z4.array(searchResultSchema),
-  hasMore: z4.boolean()
+var logsSearchResponseSchema = z5.object({
+  results: z5.array(searchResultSchema),
+  hasMore: z5.boolean()
 });
-var logsSearchContract = c2.router({
+var logsSearchContract = c3.router({
   /**
    * GET /api/logs/search
    * Search agent events across runs using keyword matching
@@ -1469,14 +1559,14 @@ var logsSearchContract = c2.router({
     method: "GET",
     path: "/api/logs/search",
     headers: authHeadersSchema,
-    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)
+    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)
     }),
     responses: {
       200: logsSearchResponseSchema,
@@ -1485,21 +1575,56 @@ var logsSearchContract = c2.router({
     summary: "Search agent events across runs"
   }
 });
+var queueEntrySchema = z5.object({
+  position: z5.number(),
+  agentName: z5.string(),
+  userEmail: z5.string(),
+  createdAt: z5.string(),
+  isOwner: z5.boolean(),
+  runId: z5.string().nullable()
+});
+var concurrencyInfoSchema = z5.object({
+  tier: orgTierSchema,
+  limit: z5.number(),
+  active: z5.number(),
+  available: z5.number()
+});
+var queueResponseSchema = z5.object({
+  concurrency: concurrencyInfoSchema,
+  queue: z5.array(queueEntrySchema)
+});
+var runsQueueContract = c3.router({
+  /**
+   * GET /api/agent/runs/queue
+   * Get org run queue status including concurrency context and queued entries
+   */
+  getQueue: {
+    method: "GET",
+    path: "/api/agent/runs/queue",
+    headers: authHeadersSchema,
+    responses: {
+      200: queueResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema
+    },
+    summary: "Get org run queue status"
+  }
+});
 
 // ../../packages/core/src/contracts/storages.ts
-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(),
+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(),
   type: storageTypeSchema,
-  deduplicated: z5.boolean()
+  deduplicated: z6.boolean()
 });
-var storagesContract = c3.router({
+var storagesContract = c4.router({
   /**
    * POST /api/storages
    * Upload a storage (tar.gz file)
@@ -1516,7 +1641,7 @@ var storagesContract = c3.router({
     path: "/api/storages",
     headers: authHeadersSchema,
     contentType: "multipart/form-data",
-    body: c3.type(),
+    body: c4.type(),
     responses: {
       200: uploadStorageResponseSchema,
       400: apiErrorSchema,
@@ -1539,15 +1664,15 @@ var storagesContract = c3.router({
     method: "GET",
     path: "/api/storages",
     headers: authHeadersSchema,
-    query: z5.object({
-      name: z5.string().min(1, "Storage name is required"),
+    query: z6.object({
+      name: z6.string().min(1, "Storage name is required"),
       version: versionQuerySchema
     }),
     responses: {
       // Binary response - actual handling done at route level
-      200: c3.otherResponse({
+      200: c4.otherResponse({
         contentType: "application/gzip",
-        body: c3.type()
+        body: c4.type()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -1558,41 +1683,41 @@ var storagesContract = c3.router({
   }
 });
 var MAX_FILE_SIZE_BYTES = 104857600;
-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 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 storageChangesSchema = z5.object({
-  added: z5.array(z5.string()),
-  modified: z5.array(z5.string()),
-  deleted: z5.array(z5.string())
+var storageChangesSchema = z6.object({
+  added: z6.array(z6.string()),
+  modified: z6.array(z6.string()),
+  deleted: z6.array(z6.string())
 });
-var presignedUploadSchema = z5.object({
-  key: z5.string(),
-  presignedUrl: z5.string().url()
+var presignedUploadSchema = z6.object({
+  key: z6.string(),
+  presignedUrl: z6.string().url()
 });
-var storagesPrepareContract = c3.router({
+var storagesPrepareContract = c4.router({
   prepare: {
     method: "POST",
     path: "/api/storages/prepare",
     headers: authHeadersSchema,
-    body: z5.object({
-      storageName: z5.string().min(1, "Storage name is required"),
+    body: z6.object({
+      storageName: z6.string().min(1, "Storage name is required"),
       storageType: storageTypeSchema,
-      files: z5.array(fileEntryWithHashSchema),
-      force: z5.boolean().optional(),
-      runId: z5.string().optional(),
+      files: z6.array(fileEntryWithHashSchema),
+      force: z6.boolean().optional(),
+      runId: z6.string().optional(),
       // For sandbox auth
-      baseVersion: z5.string().optional(),
+      baseVersion: z6.string().optional(),
       // For incremental uploads
       changes: storageChangesSchema.optional()
     }),
     responses: {
-      200: z5.object({
-        versionId: z5.string(),
-        existing: z5.boolean(),
-        uploads: z5.object({
+      200: z6.object({
+        versionId: z6.string(),
+        existing: z6.boolean(),
+        uploads: z6.object({
           archive: presignedUploadSchema,
           manifest: presignedUploadSchema
         }).optional()
@@ -1606,27 +1731,27 @@ var storagesPrepareContract = c3.router({
     summary: "Prepare for direct S3 upload"
   }
 });
-var storagesCommitContract = c3.router({
+var storagesCommitContract = c4.router({
   commit: {
     method: "POST",
     path: "/api/storages/commit",
     headers: authHeadersSchema,
-    body: z5.object({
-      storageName: z5.string().min(1, "Storage name is required"),
+    body: z6.object({
+      storageName: z6.string().min(1, "Storage name is required"),
       storageType: storageTypeSchema,
-      versionId: z5.string().min(1, "Version ID is required"),
-      files: z5.array(fileEntryWithHashSchema),
-      runId: z5.string().optional(),
-      message: z5.string().optional()
+      versionId: z6.string().min(1, "Version ID is required"),
+      files: z6.array(fileEntryWithHashSchema),
+      runId: z6.string().optional(),
+      message: z6.string().optional()
     }),
     responses: {
-      200: z5.object({
-        success: z5.literal(true),
-        versionId: z5.string(),
-        storageName: z5.string(),
-        size: z5.number(),
-        fileCount: z5.number(),
-        deduplicated: z5.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,
@@ -1639,31 +1764,31 @@ var storagesCommitContract = c3.router({
     summary: "Commit uploaded storage"
   }
 });
-var storagesDownloadContract = c3.router({
+var storagesDownloadContract = c4.router({
   download: {
     method: "GET",
     path: "/api/storages/download",
     headers: authHeadersSchema,
-    query: z5.object({
-      name: z5.string().min(1, "Storage name is required"),
+    query: z6.object({
+      name: z6.string().min(1, "Storage name is required"),
       type: storageTypeSchema,
       version: versionQuerySchema
     }),
     responses: {
       // Normal response with presigned URL
-      200: z5.union([
-        z5.object({
-          url: z5.string().url(),
-          versionId: z5.string(),
-          fileCount: z5.number(),
-          size: z5.number()
+      200: z6.union([
+        z6.object({
+          url: z6.string().url(),
+          versionId: z6.string(),
+          fileCount: z6.number(),
+          size: z6.number()
         }),
         // Empty artifact response
-        z5.object({
-          empty: z5.literal(true),
-          versionId: z5.string(),
-          fileCount: z5.literal(0),
-          size: z5.literal(0)
+        z6.object({
+          empty: z6.literal(true),
+          versionId: z6.string(),
+          fileCount: z6.literal(0),
+          size: z6.literal(0)
         })
       ]),
       400: apiErrorSchema,
@@ -1674,21 +1799,21 @@ var storagesDownloadContract = c3.router({
     summary: "Get presigned download URL"
   }
 });
-var storagesListContract = c3.router({
+var storagesListContract = c4.router({
   list: {
     method: "GET",
     path: "/api/storages/list",
     headers: authHeadersSchema,
-    query: z5.object({
+    query: z6.object({
       type: storageTypeSchema
     }),
     responses: {
-      200: z5.array(
-        z5.object({
-          name: z5.string(),
-          size: z5.number(),
-          fileCount: z5.number(),
-          updatedAt: z5.string()
+      200: z6.array(
+        z6.object({
+          name: z6.string(),
+          size: z6.number(),
+          fileCount: z6.number(),
+          updatedAt: z6.string()
         })
       ),
       401: apiErrorSchema,
@@ -1699,24 +1824,24 @@ var storagesListContract = c3.router({
 });
 
 // ../../packages/core/src/contracts/webhooks.ts
-import { z as z6 } from "zod";
-var c4 = initContract();
-var agentEventSchema = z6.object({
-  type: z6.string(),
-  sequenceNumber: z6.number().int().nonnegative()
+import { z as z7 } from "zod";
+var c5 = initContract();
+var agentEventSchema = z7.object({
+  type: z7.string(),
+  sequenceNumber: z7.number().int().nonnegative()
 }).passthrough();
-var artifactSnapshotSchema = z6.object({
-  artifactName: z6.string(),
-  artifactVersion: z6.string()
+var artifactSnapshotSchema = z7.object({
+  artifactName: z7.string(),
+  artifactVersion: z7.string()
 });
-var memorySnapshotSchema = z6.object({
-  memoryName: z6.string(),
-  memoryVersion: z6.string()
+var memorySnapshotSchema = z7.object({
+  memoryName: z7.string(),
+  memoryVersion: z7.string()
 });
-var volumeVersionsSnapshotSchema = z6.object({
-  versions: z6.record(z6.string(), z6.string())
+var volumeVersionsSnapshotSchema = z7.object({
+  versions: z7.record(z7.string(), z7.string())
 });
-var webhookEventsContract = c4.router({
+var webhookEventsContract = c5.router({
   /**
    * POST /api/webhooks/agent/events
    * Receive agent events from sandbox
@@ -1725,15 +1850,15 @@ var webhookEventsContract = c4.router({
     method: "POST",
     path: "/api/webhooks/agent/events",
     headers: authHeadersSchema,
-    body: z6.object({
-      runId: z6.string().min(1, "runId is required"),
-      events: z6.array(agentEventSchema).min(1, "events array cannot be empty")
+    body: z7.object({
+      runId: z7.string().min(1, "runId is required"),
+      events: z7.array(agentEventSchema).min(1, "events array cannot be empty")
     }),
     responses: {
-      200: z6.object({
-        received: z6.number(),
-        firstSequence: z6.number(),
-        lastSequence: z6.number()
+      200: z7.object({
+        received: z7.number(),
+        firstSequence: z7.number(),
+        lastSequence: z7.number()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -1743,7 +1868,7 @@ var webhookEventsContract = c4.router({
     summary: "Receive agent events from sandbox"
   }
 });
-var webhookCompleteContract = c4.router({
+var webhookCompleteContract = c5.router({
   /**
    * POST /api/webhooks/agent/complete
    * Handle agent run completion (success or failure)
@@ -1752,15 +1877,15 @@ var webhookCompleteContract = c4.router({
     method: "POST",
     path: "/api/webhooks/agent/complete",
     headers: authHeadersSchema,
-    body: z6.object({
-      runId: z6.string().min(1, "runId is required"),
-      exitCode: z6.number(),
-      error: z6.string().optional()
+    body: z7.object({
+      runId: z7.string().min(1, "runId is required"),
+      exitCode: z7.number(),
+      error: z7.string().optional()
     }),
     responses: {
-      200: z6.object({
-        success: z6.boolean(),
-        status: z6.enum(["completed", "failed"])
+      200: z7.object({
+        success: z7.boolean(),
+        status: z7.enum(["completed", "failed"])
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -1770,7 +1895,7 @@ var webhookCompleteContract = c4.router({
     summary: "Handle agent run completion"
   }
 });
-var webhookCheckpointsContract = c4.router({
+var webhookCheckpointsContract = c5.router({
   /**
    * POST /api/webhooks/agent/checkpoints
    * Create checkpoint for completed agent run
@@ -1779,23 +1904,23 @@ var webhookCheckpointsContract = c4.router({
     method: "POST",
     path: "/api/webhooks/agent/checkpoints",
     headers: authHeadersSchema,
-    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"),
+    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"),
       artifactSnapshot: artifactSnapshotSchema.optional(),
       memorySnapshot: memorySnapshotSchema.optional(),
       volumeVersionsSnapshot: volumeVersionsSnapshotSchema.optional()
     }),
     responses: {
-      200: z6.object({
-        checkpointId: z6.string(),
-        agentSessionId: z6.string(),
-        conversationId: z6.string(),
+      200: z7.object({
+        checkpointId: z7.string(),
+        agentSessionId: z7.string(),
+        conversationId: z7.string(),
         artifact: artifactSnapshotSchema.optional(),
         memory: memorySnapshotSchema.optional(),
-        volumes: z6.record(z6.string(), z6.string()).optional()
+        volumes: z7.record(z7.string(), z7.string()).optional()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -1805,7 +1930,7 @@ var webhookCheckpointsContract = c4.router({
     summary: "Create checkpoint for agent run"
   }
 });
-var webhookHeartbeatContract = c4.router({
+var webhookHeartbeatContract = c5.router({
   /**
    * POST /api/webhooks/agent/heartbeat
    * Receive heartbeat signals from sandbox
@@ -1814,12 +1939,12 @@ var webhookHeartbeatContract = c4.router({
     method: "POST",
     path: "/api/webhooks/agent/heartbeat",
     headers: authHeadersSchema,
-    body: z6.object({
-      runId: z6.string().min(1, "runId is required")
+    body: z7.object({
+      runId: z7.string().min(1, "runId is required")
     }),
     responses: {
-      200: z6.object({
-        ok: z6.boolean()
+      200: z7.object({
+        ok: z7.boolean()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -1829,7 +1954,7 @@ var webhookHeartbeatContract = c4.router({
     summary: "Receive heartbeat from sandbox"
   }
 });
-var webhookStoragesContract = c4.router({
+var webhookStoragesContract = c5.router({
   /**
    * POST /api/webhooks/agent/storages
    * Create a new version of a storage from sandbox
@@ -1845,13 +1970,13 @@ var webhookStoragesContract = c4.router({
     path: "/api/webhooks/agent/storages",
     headers: authHeadersSchema,
     contentType: "multipart/form-data",
-    body: c4.type(),
+    body: c5.type(),
     responses: {
-      200: z6.object({
-        versionId: z6.string(),
-        storageName: z6.string(),
-        size: z6.number(),
-        fileCount: z6.number()
+      200: z7.object({
+        versionId: z7.string(),
+        storageName: z7.string(),
+        size: z7.number(),
+        fileCount: z7.number()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -1861,7 +1986,7 @@ var webhookStoragesContract = c4.router({
     summary: "Upload storage version from sandbox"
   }
 });
-var webhookStoragesIncrementalContract = c4.router({
+var webhookStoragesIncrementalContract = c5.router({
   /**
    * POST /api/webhooks/agent/storages/incremental
    * Create a new version using incremental upload
@@ -1879,19 +2004,19 @@ var webhookStoragesIncrementalContract = c4.router({
     path: "/api/webhooks/agent/storages/incremental",
     headers: authHeadersSchema,
     contentType: "multipart/form-data",
-    body: c4.type(),
+    body: c5.type(),
     responses: {
-      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()
+      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()
         }).optional()
       }),
       400: apiErrorSchema,
@@ -1902,36 +2027,36 @@ var webhookStoragesIncrementalContract = c4.router({
     summary: "Upload storage version incrementally from sandbox"
   }
 });
-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 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 sandboxOperationSchema = z6.object({
-  ts: z6.string(),
-  action_type: z6.string(),
-  duration_ms: z6.number(),
-  success: z6.boolean(),
-  error: z6.string().optional()
+var sandboxOperationSchema = z7.object({
+  ts: z7.string(),
+  action_type: z7.string(),
+  duration_ms: z7.number(),
+  success: z7.boolean(),
+  error: z7.string().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 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 webhookTelemetryContract = c4.router({
+var webhookTelemetryContract = c5.router({
   /**
    * POST /api/webhooks/agent/telemetry
    * Receive telemetry data (system log, metrics, network logs, and sandbox operations) from sandbox
@@ -1940,17 +2065,17 @@ var webhookTelemetryContract = c4.router({
     method: "POST",
     path: "/api/webhooks/agent/telemetry",
     headers: authHeadersSchema,
-    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()
+    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()
     }),
     responses: {
-      200: z6.object({
-        success: z6.boolean(),
-        id: z6.string()
+      200: z7.object({
+        success: z7.boolean(),
+        id: z7.string()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -1960,26 +2085,26 @@ var webhookTelemetryContract = c4.router({
     summary: "Receive telemetry data from sandbox"
   }
 });
-var webhookStoragesPrepareContract = c4.router({
+var webhookStoragesPrepareContract = c5.router({
   prepare: {
     method: "POST",
     path: "/api/webhooks/agent/storages/prepare",
     headers: authHeadersSchema,
-    body: z6.object({
-      runId: z6.string().min(1, "runId is required"),
+    body: z7.object({
+      runId: z7.string().min(1, "runId is required"),
       // Required for webhook auth
-      storageName: z6.string().min(1, "Storage name is required"),
+      storageName: z7.string().min(1, "Storage name is required"),
       storageType: storageTypeSchema,
-      files: z6.array(fileEntryWithHashSchema),
-      force: z6.boolean().optional(),
-      baseVersion: z6.string().optional(),
+      files: z7.array(fileEntryWithHashSchema),
+      force: z7.boolean().optional(),
+      baseVersion: z7.string().optional(),
       changes: storageChangesSchema.optional()
     }),
     responses: {
-      200: z6.object({
-        versionId: z6.string(),
-        existing: z6.boolean(),
-        uploads: z6.object({
+      200: z7.object({
+        versionId: z7.string(),
+        existing: z7.boolean(),
+        uploads: z7.object({
           archive: presignedUploadSchema,
           manifest: presignedUploadSchema
         }).optional()
@@ -1993,28 +2118,28 @@ var webhookStoragesPrepareContract = c4.router({
     summary: "Prepare for direct S3 upload from sandbox"
   }
 });
-var webhookStoragesCommitContract = c4.router({
+var webhookStoragesCommitContract = c5.router({
   commit: {
     method: "POST",
     path: "/api/webhooks/agent/storages/commit",
     headers: authHeadersSchema,
-    body: z6.object({
-      runId: z6.string().min(1, "runId is required"),
+    body: z7.object({
+      runId: z7.string().min(1, "runId is required"),
       // Required for webhook auth
-      storageName: z6.string().min(1, "Storage name is required"),
+      storageName: z7.string().min(1, "Storage name is required"),
       storageType: storageTypeSchema,
-      versionId: z6.string().min(1, "Version ID is required"),
-      files: z6.array(fileEntryWithHashSchema),
-      message: z6.string().optional()
+      versionId: z7.string().min(1, "Version ID is required"),
+      files: z7.array(fileEntryWithHashSchema),
+      message: z7.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: z7.object({
+        success: z7.literal(true),
+        versionId: z7.string(),
+        storageName: z7.string(),
+        size: z7.number(),
+        fileCount: z7.number(),
+        deduplicated: z7.boolean().optional()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -2029,13 +2154,13 @@ var webhookStoragesCommitContract = c4.router({
 });
 
 // ../../packages/core/src/contracts/cli-auth.ts
-import { z as z7 } from "zod";
-var c5 = initContract();
-var oauthErrorSchema = z7.object({
-  error: z7.string(),
-  error_description: z7.string()
+import { z as z8 } from "zod";
+var c6 = initContract();
+var oauthErrorSchema = z8.object({
+  error: z8.string(),
+  error_description: z8.string()
 });
-var cliAuthDeviceContract = c5.router({
+var cliAuthDeviceContract = c6.router({
   /**
    * POST /api/cli/auth/device
    * Initiate device authorization flow
@@ -2043,21 +2168,21 @@ var cliAuthDeviceContract = c5.router({
   create: {
     method: "POST",
     path: "/api/cli/auth/device",
-    body: z7.object({}).optional(),
+    body: z8.object({}).optional(),
     responses: {
-      200: z7.object({
-        device_code: z7.string(),
-        user_code: z7.string(),
-        verification_path: z7.string(),
-        expires_in: z7.number(),
-        interval: z7.number()
+      200: z8.object({
+        device_code: z8.string(),
+        user_code: z8.string(),
+        verification_path: z8.string(),
+        expires_in: z8.number(),
+        interval: z8.number()
       }),
       500: oauthErrorSchema
     },
     summary: "Initiate device authorization flow"
   }
 });
-var cliAuthTokenContract = c5.router({
+var cliAuthTokenContract = c6.router({
   /**
    * POST /api/cli/auth/token
    * Exchange device code for access token
@@ -2065,16 +2190,16 @@ var cliAuthTokenContract = c5.router({
   exchange: {
     method: "POST",
     path: "/api/cli/auth/token",
-    body: z7.object({
-      device_code: z7.string().min(1, "device_code is required")
+    body: z8.object({
+      device_code: z8.string().min(1, "device_code is required")
     }),
     responses: {
       // Success - token issued
-      200: z7.object({
-        access_token: z7.string(),
-        token_type: z7.literal("Bearer"),
-        expires_in: z7.number(),
-        org_slug: z7.string().optional()
+      200: z8.object({
+        access_token: z8.string(),
+        token_type: z8.literal("Bearer"),
+        expires_in: z8.number(),
+        org_slug: z8.string().optional()
       }),
       // Authorization pending
       202: oauthErrorSchema,
@@ -2087,9 +2212,9 @@ var cliAuthTokenContract = c5.router({
 });
 
 // ../../packages/core/src/contracts/auth.ts
-import { z as z8 } from "zod";
-var c6 = initContract();
-var authContract = c6.router({
+import { z as z9 } from "zod";
+var c7 = initContract();
+var authContract = c7.router({
   /**
    * GET /api/auth/me
    * Get current user information
@@ -2099,9 +2224,9 @@ var authContract = c6.router({
     path: "/api/auth/me",
     headers: authHeadersSchema,
     responses: {
-      200: z8.object({
-        userId: z8.string(),
-        email: z8.string()
+      200: z9.object({
+        userId: z9.string(),
+        email: z9.string()
       }),
       401: apiErrorSchema,
       404: apiErrorSchema,
@@ -2112,23 +2237,23 @@ var authContract = c6.router({
 });
 
 // ../../packages/core/src/contracts/cron.ts
-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()
+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()
 });
-var cleanupResponseSchema = z9.object({
-  cleaned: z9.number(),
-  errors: z9.number(),
-  results: z9.array(cleanupResultSchema),
-  composeJobsCleaned: z9.number(),
-  composeJobErrors: z9.number()
+var cleanupResponseSchema = z10.object({
+  cleaned: z10.number(),
+  errors: z10.number(),
+  results: z10.array(cleanupResultSchema),
+  composeJobsCleaned: z10.number(),
+  composeJobErrors: z10.number()
 });
-var cronCleanupSandboxesContract = c7.router({
+var cronCleanupSandboxesContract = c8.router({
   /**
    * GET /api/cron/cleanup-sandboxes
    * Cron job to cleanup sandboxes that have stopped sending heartbeats
@@ -2146,91 +2271,6 @@ var cronCleanupSandboxesContract = c7.router({
   }
 });
 
-// ../../packages/core/src/contracts/orgs.ts
-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 = z10.object({
-  id: z10.string(),
-  slug: z10.string(),
-  tier: z10.string().optional()
-});
-var updateOrgRequestSchema = z10.object({
-  slug: orgSlugSchema,
-  force: z10.boolean().optional().default(false)
-});
-var orgContract = c8.router({
-  /**
-   * GET /api/org
-   * Get current user's default org
-   */
-  get: {
-    method: "GET",
-    path: "/api/org",
-    headers: authHeadersSchema,
-    responses: {
-      200: orgResponseSchema,
-      401: apiErrorSchema,
-      404: apiErrorSchema,
-      500: apiErrorSchema
-    },
-    summary: "Get current user's default org"
-  },
-  /**
-   * PUT /api/org
-   * Update org slug
-   */
-  update: {
-    method: "PUT",
-    path: "/api/org",
-    headers: authHeadersSchema,
-    body: updateOrgRequestSchema,
-    responses: {
-      200: orgResponseSchema,
-      400: apiErrorSchema,
-      401: apiErrorSchema,
-      403: apiErrorSchema,
-      404: apiErrorSchema,
-      409: apiErrorSchema,
-      500: apiErrorSchema
-    },
-    summary: "Update org slug"
-  }
-});
-var orgDefaultAgentContract = c8.router({
-  /**
-   * PUT /api/orgs/default-agent?org={slug}
-   * Set or unset the default agent for an org.
-   * Only org admins can perform this action.
-   * The agent must belong to the same org.
-   */
-  setDefaultAgent: {
-    method: "PUT",
-    path: "/api/orgs/default-agent",
-    headers: authHeadersSchema,
-    query: z10.object({
-      org: z10.string().optional()
-    }),
-    body: z10.object({
-      agentComposeId: z10.string().uuid().nullable()
-    }),
-    responses: {
-      200: z10.object({
-        agentComposeId: z10.string().uuid().nullable()
-      }),
-      400: apiErrorSchema,
-      401: apiErrorSchema,
-      403: apiErrorSchema,
-      404: apiErrorSchema
-    },
-    summary: "Set or unset the default agent for an org"
-  }
-});
-
 // ../../packages/core/src/contracts/secrets.ts
 import { z as z11 } from "zod";
 var c9 = initContract();
@@ -7227,19 +7267,22 @@ function expandFirewallConfigs(config) {
 // ../../packages/core/src/contracts/user-preferences.ts
 import { z as z21 } from "zod";
 var c19 = initContract();
+var sendModeSchema = z21.enum(["enter", "cmd-enter"]);
 var userPreferencesResponseSchema = z21.object({
   timezone: z21.string().nullable(),
   notifyEmail: z21.boolean(),
   notifySlack: z21.boolean(),
-  pinnedAgentIds: z21.array(z21.string())
+  pinnedAgentIds: z21.array(z21.string()),
+  sendMode: sendModeSchema
 });
 var updateUserPreferencesRequestSchema = z21.object({
   timezone: z21.string().min(1).optional(),
   notifyEmail: z21.boolean().optional(),
   notifySlack: z21.boolean().optional(),
-  pinnedAgentIds: z21.array(z21.string()).max(4).optional()
+  pinnedAgentIds: z21.array(z21.string()).max(4).optional(),
+  sendMode: sendModeSchema.optional()
 }).refine(
-  (data) => data.timezone !== void 0 || data.notifyEmail !== void 0 || data.notifySlack !== void 0 || data.pinnedAgentIds !== void 0,
+  (data) => data.timezone !== void 0 || data.notifyEmail !== void 0 || data.notifySlack !== void 0 || data.pinnedAgentIds !== void 0 || data.sendMode !== void 0,
   {
     message: "At least one preference must be provided"
   }
@@ -8110,6 +8153,15 @@ async function listRuns(params) {
   }
   handleError(result, "Failed to list runs");
 }
+async function getRunQueue() {
+  const config = await getClientConfig();
+  const client = initClient2(runsQueueContract, config);
+  const result = await client.getQueue({});
+  if (result.status === 200) {
+    return result.body;
+  }
+  handleError(result, "Failed to get run queue");
+}
 async function cancelRun(runId) {
   const config = await getClientConfig();
   const client = initClient2(runsCancelContract, config);
@@ -9943,7 +9995,7 @@ var composeCommand = new Command7().name("compose").description("Create or updat
         options.autoUpdate = false;
       }
       if (options.autoUpdate !== false) {
-        await startSilentUpgrade("9.60.1");
+        await startSilentUpgrade("9.61.0");
       }
       try {
         let result;
@@ -11114,7 +11166,7 @@ var mainRunCommand = new Command8().name("run").description("Run an agent").argu
   withErrorHandler(
     async (identifier, prompt, options) => {
       if (options.autoUpdate !== false) {
-        await startSilentUpgrade("9.60.1");
+        await startSilentUpgrade("9.61.0");
       }
       const { org, name, version } = parseIdentifier(identifier);
       let composeId;
@@ -11493,19 +11545,60 @@ var killCommand = new Command12().name("kill").description("Kill (cancel) a pend
   })
 );
 
+// src/commands/run/queue.ts
+import { Command as Command13 } from "commander";
+import chalk13 from "chalk";
+var queueCommand = new Command13().name("queue").description("Show org run queue status").action(
+  withErrorHandler(async () => {
+    const data = await getRunQueue();
+    const { concurrency, queue } = data;
+    const limitDisplay = concurrency.limit === 0 ? "unlimited" : `${concurrency.active}/${concurrency.limit} slots used`;
+    console.log(`Concurrency: ${limitDisplay} (${concurrency.tier} tier)`);
+    if (queue.length === 0) {
+      console.log(chalk13.dim("Queue: empty \u2014 all slots available"));
+      return;
+    }
+    console.log(
+      `Queue: ${queue.length} run${queue.length > 1 ? "s" : ""} waiting`
+    );
+    console.log();
+    const posWidth = Math.max(1, String(queue.length).length);
+    const agentWidth = Math.max(5, ...queue.map((e) => e.agentName.length));
+    const emailWidth = Math.max(4, ...queue.map((e) => e.userEmail.length));
+    const header = [
+      "#".padEnd(posWidth),
+      "AGENT".padEnd(agentWidth),
+      "USER".padEnd(emailWidth),
+      "CREATED"
+    ].join("  ");
+    console.log(chalk13.dim(header));
+    for (const entry of queue) {
+      const marker = entry.isOwner ? chalk13.cyan("  \u2190 you") : "";
+      const row = [
+        String(entry.position).padEnd(posWidth),
+        entry.agentName.padEnd(agentWidth),
+        entry.userEmail.padEnd(emailWidth),
+        formatRelativeTime(entry.createdAt)
+      ].join("  ");
+      console.log(row + marker);
+    }
+  })
+);
+
 // src/commands/run/index.ts
 mainRunCommand.addCommand(resumeCommand);
 mainRunCommand.addCommand(continueCommand);
 mainRunCommand.addCommand(listCommand);
 mainRunCommand.addCommand(killCommand);
+mainRunCommand.addCommand(queueCommand);
 var runCommand = mainRunCommand;
 
 // src/commands/volume/index.ts
-import { Command as Command19 } from "commander";
+import { Command as Command20 } from "commander";
 
 // src/commands/volume/init.ts
-import { Command as Command13 } from "commander";
-import chalk13 from "chalk";
+import { Command as Command14 } from "commander";
+import chalk14 from "chalk";
 import path7 from "path";
 
 // src/lib/storage/storage-utils.ts
@@ -11556,17 +11649,17 @@ async function writeStorageConfig(storageName, basePath = process.cwd(), type2 =
 }
 
 // src/commands/volume/init.ts
-var initCommand = new Command13().name("init").description("Initialize a volume in the current directory").option("-n, --name <name>", "Volume name (required in non-interactive mode)").action(
+var initCommand = new Command14().name("init").description("Initialize a volume in the current directory").option("-n, --name <name>", "Volume name (required in non-interactive mode)").action(
   withErrorHandler(async (options) => {
     const cwd = process.cwd();
     const dirName = path7.basename(cwd);
     const existingConfig = await readStorageConfig(cwd);
     if (existingConfig) {
       console.log(
-        chalk13.yellow(`Volume already initialized: ${existingConfig.name}`)
+        chalk14.yellow(`Volume already initialized: ${existingConfig.name}`)
       );
       console.log(
-        chalk13.dim(`Config file: ${path7.join(cwd, ".vm0", "storage.yaml")}`)
+        chalk14.dim(`Config file: ${path7.join(cwd, ".vm0", "storage.yaml")}`)
       );
       return;
     }
@@ -11590,7 +11683,7 @@ var initCommand = new Command13().name("init").description("Initialize a volume
         }
       );
       if (name === void 0) {
-        console.log(chalk13.dim("Cancelled"));
+        console.log(chalk14.dim("Cancelled"));
         return;
       }
       volumeName = name;
@@ -11603,9 +11696,9 @@ var initCommand = new Command13().name("init").description("Initialize a volume
       });
     }
     await writeStorageConfig(volumeName, cwd);
-    console.log(chalk13.green(`\u2713 Initialized volume: ${volumeName}`));
+    console.log(chalk14.green(`\u2713 Initialized volume: ${volumeName}`));
     console.log(
-      chalk13.dim(
+      chalk14.dim(
         `  Config saved to ${path7.join(cwd, ".vm0", "storage.yaml")}`
       )
     );
@@ -11613,9 +11706,9 @@ var initCommand = new Command13().name("init").description("Initialize a volume
 );
 
 // src/commands/volume/push.ts
-import { Command as Command14 } from "commander";
-import chalk14 from "chalk";
-var pushCommand = new Command14().name("push").description("Push local files to cloud volume").option(
+import { Command as Command15 } from "commander";
+import chalk15 from "chalk";
+var pushCommand = new Command15().name("push").description("Push local files to cloud volume").option(
   "-f, --force",
   "Force upload even if content unchanged (recreate archive)"
 ).action(
@@ -11630,46 +11723,46 @@ var pushCommand = new Command14().name("push").description("Push local files to
     console.log(`Pushing volume: ${config.name}`);
     const result = await directUpload(config.name, "volume", cwd, {
       onProgress: (message) => {
-        console.log(chalk14.dim(message));
+        console.log(chalk15.dim(message));
       },
       force: options.force
     });
     const shortVersion = result.versionId.slice(0, 8);
     if (result.empty) {
-      console.log(chalk14.dim("No files found (empty volume)"));
+      console.log(chalk15.dim("No files found (empty volume)"));
     } else if (result.deduplicated) {
-      console.log(chalk14.green("\u2713 Content unchanged (deduplicated)"));
+      console.log(chalk15.green("\u2713 Content unchanged (deduplicated)"));
     } else {
-      console.log(chalk14.green("\u2713 Upload complete"));
+      console.log(chalk15.green("\u2713 Upload complete"));
     }
-    console.log(chalk14.dim(`  Version: ${shortVersion}`));
-    console.log(chalk14.dim(`  Files: ${result.fileCount.toLocaleString()}`));
-    console.log(chalk14.dim(`  Size: ${formatBytes(result.size)}`));
+    console.log(chalk15.dim(`  Version: ${shortVersion}`));
+    console.log(chalk15.dim(`  Files: ${result.fileCount.toLocaleString()}`));
+    console.log(chalk15.dim(`  Size: ${formatBytes(result.size)}`));
   })
 );
 
 // src/commands/volume/pull.ts
-import { Command as Command15 } from "commander";
-import chalk16 from "chalk";
+import { Command as Command16 } from "commander";
+import chalk17 from "chalk";
 import path8 from "path";
 import * as fs7 from "fs";
 import * as os5 from "os";
 import * as tar3 from "tar";
 
 // src/lib/storage/pull-utils.ts
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 async function handleEmptyStorageResponse(cwd) {
-  console.log(chalk15.dim("Syncing local files..."));
+  console.log(chalk16.dim("Syncing local files..."));
   const removedCount = await removeExtraFiles(cwd, /* @__PURE__ */ new Set());
   if (removedCount > 0) {
-    console.log(chalk15.green(`\u2713 Removed ${removedCount} files not in remote`));
+    console.log(chalk16.green(`\u2713 Removed ${removedCount} files not in remote`));
   }
-  console.log(chalk15.green("\u2713 Synced (0 files)"));
+  console.log(chalk16.green("\u2713 Synced (0 files)"));
   return { removedCount };
 }
 
 // src/commands/volume/pull.ts
-var pullCommand = new Command15().name("pull").description("Pull cloud files to local directory").argument("[versionId]", "Version ID to pull (default: latest)").action(
+var pullCommand = new Command16().name("pull").description("Pull cloud files to local directory").argument("[versionId]", "Version ID to pull (default: latest)").action(
   withErrorHandler(async (versionId) => {
     const cwd = process.cwd();
     const config = await readStorageConfig(cwd);
@@ -11683,7 +11776,7 @@ var pullCommand = new Command15().name("pull").description("Pull cloud files to
     } else {
       console.log(`Pulling volume: ${config.name}`);
     }
-    console.log(chalk16.dim("Getting download URL..."));
+    console.log(chalk17.dim("Getting download URL..."));
     const downloadInfo = await getStorageDownload({
       name: config.name,
       type: "volume",
@@ -11697,18 +11790,18 @@ var pullCommand = new Command15().name("pull").description("Pull cloud files to
     if (!downloadUrl) {
       throw new Error("No download URL returned");
     }
-    console.log(chalk16.dim("Downloading from S3..."));
+    console.log(chalk17.dim("Downloading from S3..."));
     const s3Response = await fetch(downloadUrl);
     if (!s3Response.ok) {
       throw new Error(`S3 download failed: ${s3Response.status}`);
     }
     const arrayBuffer = await s3Response.arrayBuffer();
     const tarBuffer = Buffer.from(arrayBuffer);
-    console.log(chalk16.green(`\u2713 Downloaded ${formatBytes(tarBuffer.length)}`));
+    console.log(chalk17.green(`\u2713 Downloaded ${formatBytes(tarBuffer.length)}`));
     const tmpDir = fs7.mkdtempSync(path8.join(os5.tmpdir(), "vm0-"));
     const tarPath = path8.join(tmpDir, "volume.tar.gz");
     await fs7.promises.writeFile(tarPath, tarBuffer);
-    console.log(chalk16.dim("Syncing local files..."));
+    console.log(chalk17.dim("Syncing local files..."));
     const remoteFiles = await listTarFiles(tarPath);
     const remoteFilesSet = new Set(
       remoteFiles.map((f) => f.replace(/\\/g, "/"))
@@ -11716,10 +11809,10 @@ var pullCommand = new Command15().name("pull").description("Pull cloud files to
     const removedCount = await removeExtraFiles(cwd, remoteFilesSet);
     if (removedCount > 0) {
       console.log(
-        chalk16.green(`\u2713 Removed ${removedCount} files not in remote`)
+        chalk17.green(`\u2713 Removed ${removedCount} files not in remote`)
       );
     }
-    console.log(chalk16.dim("Extracting files..."));
+    console.log(chalk17.dim("Extracting files..."));
     await tar3.extract({
       file: tarPath,
       cwd,
@@ -11727,14 +11820,14 @@ var pullCommand = new Command15().name("pull").description("Pull cloud files to
     });
     await fs7.promises.unlink(tarPath);
     await fs7.promises.rmdir(tmpDir);
-    console.log(chalk16.green(`\u2713 Extracted ${remoteFiles.length} files`));
+    console.log(chalk17.green(`\u2713 Extracted ${remoteFiles.length} files`));
   })
 );
 
 // src/commands/volume/status.ts
-import { Command as Command16 } from "commander";
-import chalk17 from "chalk";
-var statusCommand2 = new Command16().name("status").description("Show status of cloud volume").action(
+import { Command as Command17 } from "commander";
+import chalk18 from "chalk";
+var statusCommand2 = new Command17().name("status").description("Show status of cloud volume").action(
   withErrorHandler(async () => {
     const cwd = process.cwd();
     const config = await readStorageConfig(cwd);
@@ -11757,13 +11850,13 @@ var statusCommand2 = new Command16().name("status").description("Show status of
       });
       const shortVersion = info.versionId.slice(0, 8);
       if ("empty" in info) {
-        console.log(chalk17.green("\u2713 Found (empty)"));
-        console.log(chalk17.dim(`  Version: ${shortVersion}`));
+        console.log(chalk18.green("\u2713 Found (empty)"));
+        console.log(chalk18.dim(`  Version: ${shortVersion}`));
       } else {
-        console.log(chalk17.green("\u2713 Found"));
-        console.log(chalk17.dim(`  Version: ${shortVersion}`));
-        console.log(chalk17.dim(`  Files: ${info.fileCount.toLocaleString()}`));
-        console.log(chalk17.dim(`  Size: ${formatBytes(info.size)}`));
+        console.log(chalk18.green("\u2713 Found"));
+        console.log(chalk18.dim(`  Version: ${shortVersion}`));
+        console.log(chalk18.dim(`  Files: ${info.fileCount.toLocaleString()}`));
+        console.log(chalk18.dim(`  Size: ${formatBytes(info.size)}`));
       }
     } catch (error) {
       if (error instanceof ApiRequestError && error.status === 404) {
@@ -11777,15 +11870,15 @@ var statusCommand2 = new Command16().name("status").description("Show status of
 );
 
 // src/commands/volume/list.ts
-import { Command as Command17 } from "commander";
-import chalk18 from "chalk";
-var listCommand2 = new Command17().name("list").alias("ls").description("List all remote volumes").action(
+import { Command as Command18 } from "commander";
+import chalk19 from "chalk";
+var listCommand2 = new Command18().name("list").alias("ls").description("List all remote volumes").action(
   withErrorHandler(async () => {
     const items = await listStorages({ type: "volume" });
     if (items.length === 0) {
-      console.log(chalk18.dim("No volumes found"));
+      console.log(chalk19.dim("No volumes found"));
       console.log(
-        chalk18.dim("  Create one with: vm0 volume init && vm0 volume push")
+        chalk19.dim("  Create one with: vm0 volume init && vm0 volume push")
       );
       return;
     }
@@ -11804,7 +11897,7 @@ var listCommand2 = new Command17().name("list").alias("ls").description("List al
       "FILES".padStart(filesWidth),
       "UPDATED"
     ].join("  ");
-    console.log(chalk18.dim(header));
+    console.log(chalk19.dim(header));
     for (const item of items) {
       const row = [
         item.name.padEnd(nameWidth),
@@ -11818,11 +11911,11 @@ var listCommand2 = new Command17().name("list").alias("ls").description("List al
 );
 
 // src/commands/volume/clone.ts
-import { Command as Command18 } from "commander";
-import chalk20 from "chalk";
+import { Command as Command19 } from "commander";
+import chalk21 from "chalk";
 
 // src/lib/storage/clone-utils.ts
-import chalk19 from "chalk";
+import chalk20 from "chalk";
 import path9 from "path";
 import * as fs8 from "fs";
 import * as os6 from "os";
@@ -11833,18 +11926,18 @@ async function cloneStorage(name, type2, destination, options = {}) {
   if (dirStatus.exists && !dirStatus.empty) {
     throw new Error(`Directory "${destination}" is not empty`);
   }
-  console.log(chalk19.dim(`Checking remote ${typeLabel}...`));
+  console.log(chalk20.dim(`Checking remote ${typeLabel}...`));
   const downloadInfo = await getStorageDownload({
     name,
     type: type2,
     version: options.version
   });
-  console.log(chalk19.dim(`Creating directory: ${destination}/`));
+  console.log(chalk20.dim(`Creating directory: ${destination}/`));
   await fs8.promises.mkdir(destination, { recursive: true });
   if ("empty" in downloadInfo) {
     await writeStorageConfig(name, destination, type2);
-    console.log(chalk19.green(`\u2713 Cloned empty ${typeLabel}: ${name}`));
-    console.log(chalk19.dim(`\u2713 Initialized .vm0/storage.yaml`));
+    console.log(chalk20.green(`\u2713 Cloned empty ${typeLabel}: ${name}`));
+    console.log(chalk20.dim(`\u2713 Initialized .vm0/storage.yaml`));
     return {
       success: true,
       fileCount: 0,
@@ -11856,7 +11949,7 @@ async function cloneStorage(name, type2, destination, options = {}) {
   if (!downloadUrl) {
     throw new Error("No download URL returned");
   }
-  console.log(chalk19.dim("Downloading from S3..."));
+  console.log(chalk20.dim("Downloading from S3..."));
   const s3Response = await fetch(downloadUrl);
   if (!s3Response.ok) {
     await fs8.promises.rm(destination, { recursive: true, force: true });
@@ -11864,12 +11957,12 @@ async function cloneStorage(name, type2, destination, options = {}) {
   }
   const arrayBuffer = await s3Response.arrayBuffer();
   const tarBuffer = Buffer.from(arrayBuffer);
-  console.log(chalk19.green(`\u2713 Downloaded ${formatBytes(tarBuffer.length)}`));
+  console.log(chalk20.green(`\u2713 Downloaded ${formatBytes(tarBuffer.length)}`));
   const tmpDir = fs8.mkdtempSync(path9.join(os6.tmpdir(), "vm0-clone-"));
   const tarPath = path9.join(tmpDir, "archive.tar.gz");
   await fs8.promises.writeFile(tarPath, tarBuffer);
   const files = await listTarFiles(tarPath);
-  console.log(chalk19.dim("Extracting files..."));
+  console.log(chalk20.dim("Extracting files..."));
   await tar4.extract({
     file: tarPath,
     cwd: destination,
@@ -11877,9 +11970,9 @@ async function cloneStorage(name, type2, destination, options = {}) {
   });
   await fs8.promises.unlink(tarPath);
   await fs8.promises.rmdir(tmpDir);
-  console.log(chalk19.green(`\u2713 Extracted ${files.length} files`));
+  console.log(chalk20.green(`\u2713 Extracted ${files.length} files`));
   await writeStorageConfig(name, destination, type2);
-  console.log(chalk19.green(`\u2713 Initialized .vm0/storage.yaml`));
+  console.log(chalk20.green(`\u2713 Initialized .vm0/storage.yaml`));
   return {
     success: true,
     fileCount: downloadInfo.fileCount,
@@ -11889,29 +11982,29 @@ async function cloneStorage(name, type2, destination, options = {}) {
 }
 
 // src/commands/volume/clone.ts
-var cloneCommand = new Command18().name("clone").description("Clone a remote volume to local directory (latest version)").argument("<name>", "Volume name to clone").argument("[destination]", "Destination directory (default: volume name)").action(
+var cloneCommand = new Command19().name("clone").description("Clone a remote volume to local directory (latest version)").argument("<name>", "Volume name to clone").argument("[destination]", "Destination directory (default: volume name)").action(
   withErrorHandler(async (name, destination) => {
     const targetDir = destination || name;
     console.log(`Cloning volume: ${name}`);
     const result = await cloneStorage(name, "volume", targetDir);
-    console.log(chalk20.green(`
+    console.log(chalk21.green(`
 \u2713 Successfully cloned volume: ${name}`));
-    console.log(chalk20.dim(`  Location: ${targetDir}/`));
-    console.log(chalk20.dim(`  Version: ${result.versionId.slice(0, 8)}`));
+    console.log(chalk21.dim(`  Location: ${targetDir}/`));
+    console.log(chalk21.dim(`  Version: ${result.versionId.slice(0, 8)}`));
   })
 );
 
 // src/commands/volume/index.ts
-var volumeCommand = new Command19().name("volume").description("Manage volumes (defined in compose, not versioned after run)").addCommand(initCommand).addCommand(pushCommand).addCommand(pullCommand).addCommand(statusCommand2).addCommand(listCommand2).addCommand(cloneCommand);
+var volumeCommand = new Command20().name("volume").description("Manage volumes (defined in compose, not versioned after run)").addCommand(initCommand).addCommand(pushCommand).addCommand(pullCommand).addCommand(statusCommand2).addCommand(listCommand2).addCommand(cloneCommand);
 
 // src/commands/artifact/index.ts
-import { Command as Command26 } from "commander";
+import { Command as Command27 } from "commander";
 
 // src/commands/artifact/init.ts
-import { Command as Command20 } from "commander";
-import chalk21 from "chalk";
+import { Command as Command21 } from "commander";
+import chalk22 from "chalk";
 import path10 from "path";
-var initCommand2 = new Command20().name("init").description("Initialize an artifact in the current directory").option(
+var initCommand2 = new Command21().name("init").description("Initialize an artifact in the current directory").option(
   "-n, --name <name>",
   "Artifact name (required in non-interactive mode)"
 ).action(
@@ -11922,24 +12015,24 @@ var initCommand2 = new Command20().name("init").description("Initialize an artif
     if (existingConfig) {
       if (existingConfig.type === "artifact") {
         console.log(
-          chalk21.yellow(
+          chalk22.yellow(
             `Artifact already initialized: ${existingConfig.name}`
           )
         );
       } else {
         console.log(
-          chalk21.yellow(
+          chalk22.yellow(
             `Directory already initialized as volume: ${existingConfig.name}`
           )
         );
         console.log(
-          chalk21.dim(
+          chalk22.dim(
             "  To change type, delete .vm0/storage.yaml and reinitialize"
           )
         );
       }
       console.log(
-        chalk21.dim(`Config file: ${path10.join(cwd, ".vm0", "storage.yaml")}`)
+        chalk22.dim(`Config file: ${path10.join(cwd, ".vm0", "storage.yaml")}`)
       );
       return;
     }
@@ -11963,7 +12056,7 @@ var initCommand2 = new Command20().name("init").description("Initialize an artif
         }
       );
       if (name === void 0) {
-        console.log(chalk21.dim("Cancelled"));
+        console.log(chalk22.dim("Cancelled"));
         return;
       }
       artifactName = name;
@@ -11976,9 +12069,9 @@ var initCommand2 = new Command20().name("init").description("Initialize an artif
       });
     }
     await writeStorageConfig(artifactName, cwd, "artifact");
-    console.log(chalk21.green(`\u2713 Initialized artifact: ${artifactName}`));
+    console.log(chalk22.green(`\u2713 Initialized artifact: ${artifactName}`));
     console.log(
-      chalk21.dim(
+      chalk22.dim(
         `  Config saved to ${path10.join(cwd, ".vm0", "storage.yaml")}`
       )
     );
@@ -11986,9 +12079,9 @@ var initCommand2 = new Command20().name("init").description("Initialize an artif
 );
 
 // src/commands/artifact/push.ts
-import { Command as Command21 } from "commander";
-import chalk22 from "chalk";
-var pushCommand2 = new Command21().name("push").description("Push local files to cloud artifact").option(
+import { Command as Command22 } from "commander";
+import chalk23 from "chalk";
+var pushCommand2 = new Command22().name("push").description("Push local files to cloud artifact").option(
   "-f, --force",
   "Force upload even if content unchanged (recreate archive)"
 ).action(
@@ -12009,32 +12102,32 @@ var pushCommand2 = new Command21().name("push").description("Push local files to
     console.log(`Pushing artifact: ${config.name}`);
     const result = await directUpload(config.name, "artifact", cwd, {
       onProgress: (message) => {
-        console.log(chalk22.dim(message));
+        console.log(chalk23.dim(message));
       },
       force: options.force
     });
     const shortVersion = result.versionId.slice(0, 8);
     if (result.empty) {
-      console.log(chalk22.dim("No files found (empty artifact)"));
+      console.log(chalk23.dim("No files found (empty artifact)"));
     } else if (result.deduplicated) {
-      console.log(chalk22.green("\u2713 Content unchanged (deduplicated)"));
+      console.log(chalk23.green("\u2713 Content unchanged (deduplicated)"));
     } else {
-      console.log(chalk22.green("\u2713 Upload complete"));
+      console.log(chalk23.green("\u2713 Upload complete"));
     }
-    console.log(chalk22.dim(`  Version: ${shortVersion}`));
-    console.log(chalk22.dim(`  Files: ${result.fileCount.toLocaleString()}`));
-    console.log(chalk22.dim(`  Size: ${formatBytes(result.size)}`));
+    console.log(chalk23.dim(`  Version: ${shortVersion}`));
+    console.log(chalk23.dim(`  Files: ${result.fileCount.toLocaleString()}`));
+    console.log(chalk23.dim(`  Size: ${formatBytes(result.size)}`));
   })
 );
 
 // src/commands/artifact/pull.ts
-import { Command as Command22 } from "commander";
-import chalk23 from "chalk";
+import { Command as Command23 } from "commander";
+import chalk24 from "chalk";
 import path11 from "path";
 import * as fs9 from "fs";
 import * as os7 from "os";
 import * as tar5 from "tar";
-var pullCommand2 = new Command22().name("pull").description("Pull cloud artifact to local directory").argument("[versionId]", "Version ID to pull (default: latest)").action(
+var pullCommand2 = new Command23().name("pull").description("Pull cloud artifact to local directory").argument("[versionId]", "Version ID to pull (default: latest)").action(
   withErrorHandler(async (versionId) => {
     const cwd = process.cwd();
     const config = await readStorageConfig(cwd);
@@ -12054,7 +12147,7 @@ var pullCommand2 = new Command22().name("pull").description("Pull cloud artifact
     } else {
       console.log(`Pulling artifact: ${config.name}`);
     }
-    console.log(chalk23.dim("Getting download URL..."));
+    console.log(chalk24.dim("Getting download URL..."));
     const downloadInfo = await getStorageDownload({
       name: config.name,
       type: "artifact",
@@ -12068,18 +12161,18 @@ var pullCommand2 = new Command22().name("pull").description("Pull cloud artifact
     if (!downloadUrl) {
       throw new Error("No download URL returned");
     }
-    console.log(chalk23.dim("Downloading from S3..."));
+    console.log(chalk24.dim("Downloading from S3..."));
     const s3Response = await fetch(downloadUrl);
     if (!s3Response.ok) {
       throw new Error(`S3 download failed: ${s3Response.status}`);
     }
     const arrayBuffer = await s3Response.arrayBuffer();
     const tarBuffer = Buffer.from(arrayBuffer);
-    console.log(chalk23.green(`\u2713 Downloaded ${formatBytes(tarBuffer.length)}`));
+    console.log(chalk24.green(`\u2713 Downloaded ${formatBytes(tarBuffer.length)}`));
     const tmpDir = fs9.mkdtempSync(path11.join(os7.tmpdir(), "vm0-"));
     const tarPath = path11.join(tmpDir, "artifact.tar.gz");
     await fs9.promises.writeFile(tarPath, tarBuffer);
-    console.log(chalk23.dim("Syncing local files..."));
+    console.log(chalk24.dim("Syncing local files..."));
     const remoteFiles = await listTarFiles(tarPath);
     const remoteFilesSet = new Set(
       remoteFiles.map((f) => f.replace(/\\/g, "/"))
@@ -12087,10 +12180,10 @@ var pullCommand2 = new Command22().name("pull").description("Pull cloud artifact
     const removedCount = await removeExtraFiles(cwd, remoteFilesSet);
     if (removedCount > 0) {
       console.log(
-        chalk23.green(`\u2713 Removed ${removedCount} files not in remote`)
+        chalk24.green(`\u2713 Removed ${removedCount} files not in remote`)
       );
     }
-    console.log(chalk23.dim("Extracting files..."));
+    console.log(chalk24.dim("Extracting files..."));
     await tar5.extract({
       file: tarPath,
       cwd,
@@ -12098,14 +12191,14 @@ var pullCommand2 = new Command22().name("pull").description("Pull cloud artifact
     });
     await fs9.promises.unlink(tarPath);
     await fs9.promises.rmdir(tmpDir);
-    console.log(chalk23.green(`\u2713 Extracted ${remoteFiles.length} files`));
+    console.log(chalk24.green(`\u2713 Extracted ${remoteFiles.length} files`));
   })
 );
 
 // src/commands/artifact/status.ts
-import { Command as Command23 } from "commander";
-import chalk24 from "chalk";
-var statusCommand3 = new Command23().name("status").description("Show status of cloud artifact").action(
+import { Command as Command24 } from "commander";
+import chalk25 from "chalk";
+var statusCommand3 = new Command24().name("status").description("Show status of cloud artifact").action(
   withErrorHandler(async () => {
     const cwd = process.cwd();
     const config = await readStorageConfig(cwd);
@@ -12128,13 +12221,13 @@ var statusCommand3 = new Command23().name("status").description("Show status of
       });
       const shortVersion = info.versionId.slice(0, 8);
       if ("empty" in info) {
-        console.log(chalk24.green("\u2713 Found (empty)"));
-        console.log(chalk24.dim(`  Version: ${shortVersion}`));
+        console.log(chalk25.green("\u2713 Found (empty)"));
+        console.log(chalk25.dim(`  Version: ${shortVersion}`));
       } else {
-        console.log(chalk24.green("\u2713 Found"));
-        console.log(chalk24.dim(`  Version: ${shortVersion}`));
-        console.log(chalk24.dim(`  Files: ${info.fileCount.toLocaleString()}`));
-        console.log(chalk24.dim(`  Size: ${formatBytes(info.size)}`));
+        console.log(chalk25.green("\u2713 Found"));
+        console.log(chalk25.dim(`  Version: ${shortVersion}`));
+        console.log(chalk25.dim(`  Files: ${info.fileCount.toLocaleString()}`));
+        console.log(chalk25.dim(`  Size: ${formatBytes(info.size)}`));
       }
     } catch (error) {
       if (error instanceof ApiRequestError && error.status === 404) {
@@ -12148,15 +12241,15 @@ var statusCommand3 = new Command23().name("status").description("Show status of
 );
 
 // src/commands/artifact/list.ts
-import { Command as Command24 } from "commander";
-import chalk25 from "chalk";
-var listCommand3 = new Command24().name("list").alias("ls").description("List all remote artifacts").action(
+import { Command as Command25 } from "commander";
+import chalk26 from "chalk";
+var listCommand3 = new Command25().name("list").alias("ls").description("List all remote artifacts").action(
   withErrorHandler(async () => {
     const items = await listStorages({ type: "artifact" });
     if (items.length === 0) {
-      console.log(chalk25.dim("No artifacts found"));
+      console.log(chalk26.dim("No artifacts found"));
       console.log(
-        chalk25.dim(
+        chalk26.dim(
           "  Create one with: vm0 artifact init && vm0 artifact push"
         )
       );
@@ -12177,7 +12270,7 @@ var listCommand3 = new Command24().name("list").alias("ls").description("List al
       "FILES".padStart(filesWidth),
       "UPDATED"
     ].join("  ");
-    console.log(chalk25.dim(header));
+    console.log(chalk26.dim(header));
     for (const item of items) {
       const row = [
         item.name.padEnd(nameWidth),
@@ -12191,31 +12284,31 @@ var listCommand3 = new Command24().name("list").alias("ls").description("List al
 );
 
 // src/commands/artifact/clone.ts
-import { Command as Command25 } from "commander";
-import chalk26 from "chalk";
-var cloneCommand2 = new Command25().name("clone").description("Clone a remote artifact to local directory (latest version)").argument("<name>", "Artifact name to clone").argument("[destination]", "Destination directory (default: artifact name)").action(
+import { Command as Command26 } from "commander";
+import chalk27 from "chalk";
+var cloneCommand2 = new Command26().name("clone").description("Clone a remote artifact to local directory (latest version)").argument("<name>", "Artifact name to clone").argument("[destination]", "Destination directory (default: artifact name)").action(
   withErrorHandler(async (name, destination) => {
     const targetDir = destination || name;
     console.log(`Cloning artifact: ${name}`);
     const result = await cloneStorage(name, "artifact", targetDir);
-    console.log(chalk26.green(`
+    console.log(chalk27.green(`
 \u2713 Successfully cloned artifact: ${name}`));
-    console.log(chalk26.dim(`  Location: ${targetDir}/`));
-    console.log(chalk26.dim(`  Version: ${result.versionId.slice(0, 8)}`));
+    console.log(chalk27.dim(`  Location: ${targetDir}/`));
+    console.log(chalk27.dim(`  Version: ${result.versionId.slice(0, 8)}`));
   })
 );
 
 // src/commands/artifact/index.ts
-var artifactCommand = new Command26().name("artifact").description("Manage artifacts (specified at run, versioned after run)").addCommand(initCommand2).addCommand(pushCommand2).addCommand(pullCommand2).addCommand(statusCommand3).addCommand(listCommand3).addCommand(cloneCommand2);
+var artifactCommand = new Command27().name("artifact").description("Manage artifacts (specified at run, versioned after run)").addCommand(initCommand2).addCommand(pushCommand2).addCommand(pullCommand2).addCommand(statusCommand3).addCommand(listCommand3).addCommand(cloneCommand2);
 
 // src/commands/memory/index.ts
-import { Command as Command33 } from "commander";
+import { Command as Command34 } from "commander";
 
 // src/commands/memory/init.ts
-import { Command as Command27 } from "commander";
-import chalk27 from "chalk";
+import { Command as Command28 } from "commander";
+import chalk28 from "chalk";
 import path12 from "path";
-var initCommand3 = new Command27().name("init").description("Initialize a memory in the current directory").option("-n, --name <name>", "Memory name (required in non-interactive mode)").action(
+var initCommand3 = new Command28().name("init").description("Initialize a memory in the current directory").option("-n, --name <name>", "Memory name (required in non-interactive mode)").action(
   withErrorHandler(async (options) => {
     const cwd = process.cwd();
     const dirName = path12.basename(cwd);
@@ -12223,22 +12316,22 @@ var initCommand3 = new Command27().name("init").description("Initialize a memory
     if (existingConfig) {
       if (existingConfig.type === "memory") {
         console.log(
-          chalk27.yellow(`Memory already initialized: ${existingConfig.name}`)
+          chalk28.yellow(`Memory already initialized: ${existingConfig.name}`)
         );
       } else {
         console.log(
-          chalk27.yellow(
+          chalk28.yellow(
             `Directory already initialized as ${existingConfig.type}: ${existingConfig.name}`
           )
         );
         console.log(
-          chalk27.dim(
+          chalk28.dim(
             "  To change type, delete .vm0/storage.yaml and reinitialize"
           )
         );
       }
       console.log(
-        chalk27.dim(`Config file: ${path12.join(cwd, ".vm0", "storage.yaml")}`)
+        chalk28.dim(`Config file: ${path12.join(cwd, ".vm0", "storage.yaml")}`)
       );
       return;
     }
@@ -12262,7 +12355,7 @@ var initCommand3 = new Command27().name("init").description("Initialize a memory
         }
       );
       if (name === void 0) {
-        console.log(chalk27.dim("Cancelled"));
+        console.log(chalk28.dim("Cancelled"));
         return;
       }
       memoryName = name;
@@ -12275,9 +12368,9 @@ var initCommand3 = new Command27().name("init").description("Initialize a memory
       });
     }
     await writeStorageConfig(memoryName, cwd, "memory");
-    console.log(chalk27.green(`\u2713 Initialized memory: ${memoryName}`));
+    console.log(chalk28.green(`\u2713 Initialized memory: ${memoryName}`));
     console.log(
-      chalk27.dim(
+      chalk28.dim(
         `  Config saved to ${path12.join(cwd, ".vm0", "storage.yaml")}`
       )
     );
@@ -12285,9 +12378,9 @@ var initCommand3 = new Command27().name("init").description("Initialize a memory
 );
 
 // src/commands/memory/push.ts
-import { Command as Command28 } from "commander";
-import chalk28 from "chalk";
-var pushCommand3 = new Command28().name("push").description("Push local files to cloud memory").option(
+import { Command as Command29 } from "commander";
+import chalk29 from "chalk";
+var pushCommand3 = new Command29().name("push").description("Push local files to cloud memory").option(
   "-f, --force",
   "Force upload even if content unchanged (recreate archive)"
 ).action(
@@ -12308,43 +12401,43 @@ var pushCommand3 = new Command28().name("push").description("Push local files to
     console.log(`Pushing memory: ${config.name}`);
     const result = await directUpload(config.name, "memory", cwd, {
       onProgress: (message) => {
-        console.log(chalk28.dim(message));
+        console.log(chalk29.dim(message));
       },
       force: options.force
     });
     const shortVersion = result.versionId.slice(0, 8);
     if (result.empty) {
-      console.log(chalk28.dim("No files found (empty memory)"));
+      console.log(chalk29.dim("No files found (empty memory)"));
     } else if (result.deduplicated) {
-      console.log(chalk28.green("\u2713 Content unchanged (deduplicated)"));
+      console.log(chalk29.green("\u2713 Content unchanged (deduplicated)"));
     } else {
-      console.log(chalk28.green("\u2713 Upload complete"));
+      console.log(chalk29.green("\u2713 Upload complete"));
     }
-    console.log(chalk28.dim(`  Version: ${shortVersion}`));
-    console.log(chalk28.dim(`  Files: ${result.fileCount.toLocaleString()}`));
-    console.log(chalk28.dim(`  Size: ${formatBytes(result.size)}`));
+    console.log(chalk29.dim(`  Version: ${shortVersion}`));
+    console.log(chalk29.dim(`  Files: ${result.fileCount.toLocaleString()}`));
+    console.log(chalk29.dim(`  Size: ${formatBytes(result.size)}`));
   })
 );
 
 // src/commands/memory/pull.ts
-import { Command as Command29 } from "commander";
-import chalk29 from "chalk";
-var pullCommand3 = new Command29().name("pull").description("Pull remote memory to local directory (latest version)").argument("[name]", "Memory name to pull", "memory").argument("[destination]", "Destination directory (default: memory name)").action(
+import { Command as Command30 } from "commander";
+import chalk30 from "chalk";
+var pullCommand3 = new Command30().name("pull").description("Pull remote memory to local directory (latest version)").argument("[name]", "Memory name to pull", "memory").argument("[destination]", "Destination directory (default: memory name)").action(
   withErrorHandler(async (name, destination) => {
     const targetDir = destination || name;
     console.log(`Pulling memory: ${name}`);
     const result = await cloneStorage(name, "memory", targetDir);
-    console.log(chalk29.green(`
+    console.log(chalk30.green(`
 \u2713 Successfully pulled memory: ${name}`));
-    console.log(chalk29.dim(`  Location: ${targetDir}/`));
-    console.log(chalk29.dim(`  Version: ${result.versionId.slice(0, 8)}`));
+    console.log(chalk30.dim(`  Location: ${targetDir}/`));
+    console.log(chalk30.dim(`  Version: ${result.versionId.slice(0, 8)}`));
   })
 );
 
 // src/commands/memory/status.ts
-import { Command as Command30 } from "commander";
-import chalk30 from "chalk";
-var statusCommand4 = new Command30().name("status").description("Show status of cloud memory").action(
+import { Command as Command31 } from "commander";
+import chalk31 from "chalk";
+var statusCommand4 = new Command31().name("status").description("Show status of cloud memory").action(
   withErrorHandler(async () => {
     const cwd = process.cwd();
     const config = await readStorageConfig(cwd);
@@ -12367,13 +12460,13 @@ var statusCommand4 = new Command30().name("status").description("Show status of
       });
       const shortVersion = info.versionId.slice(0, 8);
       if ("empty" in info) {
-        console.log(chalk30.green("\u2713 Found (empty)"));
-        console.log(chalk30.dim(`  Version: ${shortVersion}`));
+        console.log(chalk31.green("\u2713 Found (empty)"));
+        console.log(chalk31.dim(`  Version: ${shortVersion}`));
       } else {
-        console.log(chalk30.green("\u2713 Found"));
-        console.log(chalk30.dim(`  Version: ${shortVersion}`));
-        console.log(chalk30.dim(`  Files: ${info.fileCount.toLocaleString()}`));
-        console.log(chalk30.dim(`  Size: ${formatBytes(info.size)}`));
+        console.log(chalk31.green("\u2713 Found"));
+        console.log(chalk31.dim(`  Version: ${shortVersion}`));
+        console.log(chalk31.dim(`  Files: ${info.fileCount.toLocaleString()}`));
+        console.log(chalk31.dim(`  Size: ${formatBytes(info.size)}`));
       }
     } catch (error) {
       if (error instanceof ApiRequestError && error.status === 404) {
@@ -12387,15 +12480,15 @@ var statusCommand4 = new Command30().name("status").description("Show status of
 );
 
 // src/commands/memory/list.ts
-import { Command as Command31 } from "commander";
-import chalk31 from "chalk";
-var listCommand4 = new Command31().name("list").alias("ls").description("List all remote memory storages").action(
+import { Command as Command32 } from "commander";
+import chalk32 from "chalk";
+var listCommand4 = new Command32().name("list").alias("ls").description("List all remote memory storages").action(
   withErrorHandler(async () => {
     const items = await listStorages({ type: "memory" });
     if (items.length === 0) {
-      console.log(chalk31.dim("No memory storages found"));
+      console.log(chalk32.dim("No memory storages found"));
       console.log(
-        chalk31.dim("  Memory is created automatically on first agent run")
+        chalk32.dim("  Memory is created automatically on first agent run")
       );
       return;
     }
@@ -12414,7 +12507,7 @@ var listCommand4 = new Command31().name("list").alias("ls").description("List al
       "FILES".padStart(filesWidth),
       "UPDATED"
     ].join("  ");
-    console.log(chalk31.dim(header));
+    console.log(chalk32.dim(header));
     for (const item of items) {
       const row = [
         item.name.padEnd(nameWidth),
@@ -12428,26 +12521,26 @@ var listCommand4 = new Command31().name("list").alias("ls").description("List al
 );
 
 // src/commands/memory/clone.ts
-import { Command as Command32 } from "commander";
-import chalk32 from "chalk";
-var cloneCommand3 = new Command32().name("clone").description("Clone a remote memory to local directory (latest version)").argument("<name>", "Memory name to clone").argument("[destination]", "Destination directory (default: memory name)").action(
+import { Command as Command33 } from "commander";
+import chalk33 from "chalk";
+var cloneCommand3 = new Command33().name("clone").description("Clone a remote memory to local directory (latest version)").argument("<name>", "Memory name to clone").argument("[destination]", "Destination directory (default: memory name)").action(
   withErrorHandler(async (name, destination) => {
     const targetDir = destination || name;
     console.log(`Cloning memory: ${name}`);
     const result = await cloneStorage(name, "memory", targetDir);
-    console.log(chalk32.green(`
+    console.log(chalk33.green(`
 \u2713 Successfully cloned memory: ${name}`));
-    console.log(chalk32.dim(`  Location: ${targetDir}/`));
-    console.log(chalk32.dim(`  Version: ${result.versionId.slice(0, 8)}`));
+    console.log(chalk33.dim(`  Location: ${targetDir}/`));
+    console.log(chalk33.dim(`  Version: ${result.versionId.slice(0, 8)}`));
   })
 );
 
 // src/commands/memory/index.ts
-var memoryCommand = new Command33().name("memory").description("Manage agent long-term memory").addCommand(initCommand3).addCommand(pushCommand3).addCommand(pullCommand3).addCommand(statusCommand4).addCommand(listCommand4).addCommand(cloneCommand3);
+var memoryCommand = new Command34().name("memory").description("Manage agent long-term memory").addCommand(initCommand3).addCommand(pushCommand3).addCommand(pullCommand3).addCommand(statusCommand4).addCommand(listCommand4).addCommand(cloneCommand3);
 
 // src/commands/cook/cook.ts
-import { Command as Command34, Option as Option5 } from "commander";
-import chalk34 from "chalk";
+import { Command as Command35, Option as Option5 } from "commander";
+import chalk35 from "chalk";
 import { readFile as readFile7, mkdir as mkdir6 } from "fs/promises";
 import { existsSync as existsSync10 } from "fs";
 import path13 from "path";
@@ -12519,12 +12612,12 @@ async function saveCookState(state) {
 }
 
 // src/commands/cook/utils.ts
-import chalk33 from "chalk";
+import chalk34 from "chalk";
 import { existsSync as existsSync9 } from "fs";
 var CONFIG_FILE2 = "vm0.yaml";
 var ARTIFACT_DIR = "artifact";
 function printCommand(cmd) {
-  console.log(chalk33.dim(`> ${cmd}`));
+  console.log(chalk34.dim(`> ${cmd}`));
 }
 function execVm0Command(args, options = {}) {
   return new Promise((resolve2, reject) => {
@@ -12623,7 +12716,7 @@ async function autoPullArtifact(runOutput, artifactDir) {
   );
   if (serverVersion && existsSync9(artifactDir)) {
     console.log();
-    console.log(chalk33.bold("Pulling updated artifact:"));
+    console.log(chalk34.bold("Pulling updated artifact:"));
     printCommand(`cd ${ARTIFACT_DIR}`);
     printCommand(`vm0 artifact pull ${serverVersion}`);
     try {
@@ -12633,9 +12726,9 @@ async function autoPullArtifact(runOutput, artifactDir) {
       });
       printCommand("cd ..");
     } catch (error) {
-      console.error(chalk33.red(`\u2717 Artifact pull failed`));
+      console.error(chalk34.red(`\u2717 Artifact pull failed`));
       if (error instanceof Error) {
-        console.error(chalk33.dim(`  ${error.message}`));
+        console.error(chalk34.dim(`  ${error.message}`));
       }
     }
   }
@@ -12643,7 +12736,7 @@ async function autoPullArtifact(runOutput, artifactDir) {
 
 // src/commands/cook/cook.ts
 async function loadAndValidateConfig2() {
-  console.log(chalk34.bold(`Reading config: ${CONFIG_FILE2}`));
+  console.log(chalk35.bold(`Reading config: ${CONFIG_FILE2}`));
   if (!existsSync10(CONFIG_FILE2)) {
     throw new Error(`Config file not found: ${CONFIG_FILE2}`);
   }
@@ -12665,7 +12758,7 @@ async function loadAndValidateConfig2() {
   const agentName = agentNames[0];
   const volumeCount = config.volumes ? Object.keys(config.volumes).length : 0;
   console.log(
-    chalk34.green(`\u2713 Config validated: 1 agent, ${volumeCount} volume(s)`)
+    chalk35.green(`\u2713 Config validated: 1 agent, ${volumeCount} volume(s)`)
   );
   return { config, agentName, volumeCount };
 }
@@ -12674,7 +12767,7 @@ async function processVolumes(config, cwd) {
     return;
   }
   console.log();
-  console.log(chalk34.bold("Processing volumes:"));
+  console.log(chalk35.bold("Processing volumes:"));
   for (const volumeConfig of Object.values(config.volumes)) {
     const volumeDir = path13.join(cwd, volumeConfig.name);
     if (!existsSync10(volumeDir)) {
@@ -12708,7 +12801,7 @@ async function processVolumes(config, cwd) {
 }
 async function processArtifact(cwd) {
   console.log();
-  console.log(chalk34.bold("Processing artifact:"));
+  console.log(chalk35.bold("Processing artifact:"));
   const artifactDir = path13.join(cwd, ARTIFACT_DIR);
   try {
     if (!existsSync10(artifactDir)) {
@@ -12740,7 +12833,7 @@ async function processArtifact(cwd) {
 }
 async function composeAgent(cwd, skipConfirm) {
   console.log();
-  console.log(chalk34.bold("Composing agent:"));
+  console.log(chalk35.bold("Composing agent:"));
   const composeArgs = skipConfirm ? ["compose", "--yes", CONFIG_FILE2] : ["compose", CONFIG_FILE2];
   printCommand(`vm0 ${composeArgs.join(" ")}`);
   try {
@@ -12754,7 +12847,7 @@ async function composeAgent(cwd, skipConfirm) {
 }
 async function runAgent(agentName, artifactDir, prompt, cwd, options) {
   console.log();
-  console.log(chalk34.bold("Running agent:"));
+  console.log(chalk35.bold("Running agent:"));
   printCommand(
     `vm0 run ${agentName} --artifact-name ${ARTIFACT_DIR} "${prompt}"`
   );
@@ -12780,14 +12873,14 @@ async function runAgent(agentName, artifactDir, prompt, cwd, options) {
   }
   await autoPullArtifact(runOutput, artifactDir);
 }
-var cookAction = new Command34().name("cook").description("Quick start: prepare, compose and run agent from vm0.yaml").argument("[prompt]", "Prompt for the agent").option(
+var cookAction = new Command35().name("cook").description("Quick start: prepare, compose and run agent from vm0.yaml").argument("[prompt]", "Prompt for the agent").option(
   "--env-file <path>",
   "Load environment variables from file (priority: CLI flags > file > env vars)"
 ).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(
   withErrorHandler(
     async (prompt, options) => {
       if (options.autoUpdate !== false) {
-        const shouldExit = await checkAndUpgrade("9.60.1", prompt);
+        const shouldExit = await checkAndUpgrade("9.61.0", prompt);
         if (shouldExit) {
           process.exit(0);
         }
@@ -12815,8 +12908,8 @@ var cookAction = new Command34().name("cook").description("Quick start: prepare,
 );
 
 // src/commands/cook/logs.ts
-import { Command as Command35 } from "commander";
-var logsCommand = new Command35().name("logs").description("View logs from the last cook run").option("-a, --agent", "Show agent events (default)").option("-s, --system", "Show system log").option("-m, --metrics", "Show metrics").option("-n, --network", "Show network logs (proxy traffic)").option(
+import { Command as Command36 } from "commander";
+var logsCommand = new Command36().name("logs").description("View logs from the last cook run").option("-a, --agent", "Show agent events (default)").option("-s, --system", "Show system log").option("-m, --metrics", "Show metrics").option("-n, --network", "Show network logs (proxy traffic)").option(
   "--since <time>",
   "Show logs since timestamp (e.g., 5m, 2h, 1d, 2024-01-15T10:30:00Z)"
 ).option("--tail <n>", "Show last N entries (default: 5, max: 100)").option("--head <n>", "Show first N entries (max: 100)").action(
@@ -12865,9 +12958,9 @@ var logsCommand = new Command35().name("logs").description("View logs from the l
 );
 
 // src/commands/cook/continue.ts
-import { Command as Command36, Option as Option6 } from "commander";
+import { Command as Command37, Option as Option6 } from "commander";
 import path14 from "path";
-var continueCommand2 = new Command36().name("continue").description(
+var continueCommand2 = new Command37().name("continue").description(
   "Continue from the last session (latest conversation and artifact)"
 ).argument("<prompt>", "Prompt for the continued agent").option(
   "--env-file <path>",
@@ -12914,9 +13007,9 @@ var continueCommand2 = new Command36().name("continue").description(
 );
 
 // src/commands/cook/resume.ts
-import { Command as Command37, Option as Option7 } from "commander";
+import { Command as Command38, Option as Option7 } from "commander";
 import path15 from "path";
-var resumeCommand2 = new Command37().name("resume").description(
+var resumeCommand2 = new Command38().name("resume").description(
   "Resume from the last checkpoint (snapshotted conversation and artifact)"
 ).argument("<prompt>", "Prompt for the resumed agent").option(
   "--env-file <path>",
@@ -12969,8 +13062,8 @@ cookAction.addCommand(resumeCommand2);
 var cookCommand = cookAction;
 
 // src/commands/logs/index.ts
-import { Command as Command39 } from "commander";
-import chalk36 from "chalk";
+import { Command as Command40 } from "commander";
+import chalk37 from "chalk";
 
 // src/lib/api/api-client.ts
 import { initClient as initClient12 } from "@ts-rest/core";
@@ -13667,8 +13760,8 @@ async function paginate(options) {
 }
 
 // src/commands/logs/search.ts
-import { Command as Command38 } from "commander";
-import chalk35 from "chalk";
+import { Command as Command39 } from "commander";
+import chalk36 from "chalk";
 var SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1e3;
 function renderEvent(event, renderer) {
   const eventData = event.eventData;
@@ -13724,7 +13817,7 @@ function renderResults(response) {
     isFirstGroup = false;
     const firstTimestamp = group.results[0].matchedEvent.createdAt;
     console.log(
-      chalk35.bold(formatRunHeader(runId, group.agentName, firstTimestamp))
+      chalk36.bold(formatRunHeader(runId, group.agentName, firstTimestamp))
     );
     for (const result of group.results) {
       const renderer = new EventRenderer({
@@ -13744,13 +13837,13 @@ function renderResults(response) {
   if (response.hasMore) {
     console.log();
     console.log(
-      chalk35.dim(
+      chalk36.dim(
         `  Showing first ${response.results.length} matches. Use --limit to see more.`
       )
     );
   }
 }
-var searchCommand = new Command38().name("search").description("Search agent events across runs").argument("<keyword>", "Search keyword").option("-A, --after-context <n>", "Show n events after each match").option("-B, --before-context <n>", "Show n events before each match").option("-C, --context <n>", "Show n events before and after each match").option("--agent <name>", "Filter by agent name").option("--run <id>", "Filter by specific run ID").option("--since <time>", "Search logs since (default: 7d)").option("--limit <n>", "Maximum number of matches (default: 20)").action(
+var searchCommand = new Command39().name("search").description("Search agent events across runs").argument("<keyword>", "Search keyword").option("-A, --after-context <n>", "Show n events after each match").option("-B, --before-context <n>", "Show n events before each match").option("-C, --context <n>", "Show n events before and after each match").option("--agent <name>", "Filter by agent name").option("--run <id>", "Filter by specific run ID").option("--since <time>", "Search logs since (default: 7d)").option("--limit <n>", "Maximum number of matches (default: 20)").action(
   withErrorHandler(async (keyword, options) => {
     const { before, after } = parseContextOptions(options);
     const since = options.since ? parseTime(options.since) : Date.now() - SEVEN_DAYS_MS;
@@ -13765,9 +13858,9 @@ var searchCommand = new Command38().name("search").description("Search agent eve
       after
     });
     if (response.results.length === 0) {
-      console.log(chalk35.dim("No matches found"));
+      console.log(chalk36.dim("No matches found"));
       console.log(
-        chalk35.dim(
+        chalk36.dim(
           "  Try a broader search with --since 30d or a different keyword"
         )
       );
@@ -13804,28 +13897,28 @@ function formatNetworkLog(entry) {
   let statusColor;
   const status = entry.status || 0;
   if (status >= 200 && status < 300) {
-    statusColor = chalk36.green;
+    statusColor = chalk37.green;
   } else if (status >= 300 && status < 400) {
-    statusColor = chalk36.yellow;
+    statusColor = chalk37.yellow;
   } else if (status >= 400) {
-    statusColor = chalk36.red;
+    statusColor = chalk37.red;
   } else {
-    statusColor = chalk36.gray;
+    statusColor = chalk37.gray;
   }
   let latencyColor;
   const latencyMs = entry.latency_ms || 0;
   if (latencyMs < 500) {
-    latencyColor = chalk36.green;
+    latencyColor = chalk37.green;
   } else if (latencyMs < 2e3) {
-    latencyColor = chalk36.yellow;
+    latencyColor = chalk37.yellow;
   } else {
-    latencyColor = chalk36.red;
+    latencyColor = chalk37.red;
   }
   const method = entry.method || "???";
   const requestSize = entry.request_size || 0;
   const responseSize = entry.response_size || 0;
   const url = entry.url || entry.host || "unknown";
-  return `[${entry.timestamp}] ${method.padEnd(6)} ${statusColor(status)} ${latencyColor(latencyMs + "ms")} ${formatBytes(requestSize)}/${formatBytes(responseSize)} ${chalk36.dim(url)}`;
+  return `[${entry.timestamp}] ${method.padEnd(6)} ${statusColor(status)} ${latencyColor(latencyMs + "ms")} ${formatBytes(requestSize)}/${formatBytes(responseSize)} ${chalk37.dim(url)}`;
 }
 function createLogRenderer(verbose) {
   return new EventRenderer({
@@ -13862,7 +13955,7 @@ function getLogType(options) {
   if (options.network) return "network";
   return "agent";
 }
-var logsCommand2 = new Command39().name("logs").description("View and search agent run logs").argument("[runId]", "Run ID to fetch logs for").addCommand(searchCommand).option("-a, --agent", "Show agent events (default)").option("-s, --system", "Show system log").option("-m, --metrics", "Show metrics").option("-n, --network", "Show network logs (proxy traffic)").option(
+var logsCommand2 = new Command40().name("logs").description("View and search agent run logs").argument("[runId]", "Run ID to fetch logs for").addCommand(searchCommand).option("-a, --agent", "Show agent events (default)").option("-s, --system", "Show system log").option("-m, --metrics", "Show metrics").option("-n, --network", "Show network logs (proxy traffic)").option(
   "--since <time>",
   "Show logs since timestamp (e.g., 5m, 2h, 1d, 2024-01-15T10:30:00Z, 1705312200)"
 ).option("--tail <n>", "Show last N entries (default: 5)").option("--head <n>", "Show first N entries").option("--all", "Fetch all log entries").action(
@@ -13931,7 +14024,7 @@ async function showAgentEvents(runId, options, platformUrl) {
     order: options.order
   });
   if (firstResponse.events.length === 0) {
-    console.log(chalk36.yellow("No agent events found for this run"));
+    console.log(chalk37.yellow("No agent events found for this run"));
     return;
   }
   const framework = firstResponse.framework;
@@ -13964,7 +14057,7 @@ async function showAgentEvents(runId, options, platformUrl) {
   for (const event of events) {
     renderAgentEvent(event, framework, renderer);
   }
-  console.log(chalk36.dim(`View on platform: ${platformUrl}`));
+  console.log(chalk37.dim(`View on platform: ${platformUrl}`));
 }
 async function showSystemLog(runId, options) {
   const limit = options.targetCount === "all" ? PAGE_LIMIT : Math.min(options.targetCount, PAGE_LIMIT);
@@ -13974,7 +14067,7 @@ async function showSystemLog(runId, options) {
     order: options.order
   });
   if (!response.systemLog) {
-    console.log(chalk36.yellow("No system log found for this run"));
+    console.log(chalk37.yellow("No system log found for this run"));
     return;
   }
   console.log(response.systemLog);
@@ -13986,7 +14079,7 @@ async function showMetrics(runId, options) {
     order: options.order
   });
   if (firstResponse.metrics.length === 0) {
-    console.log(chalk36.yellow("No metrics found for this run"));
+    console.log(chalk37.yellow("No metrics found for this run"));
     return;
   }
   let allMetrics;
@@ -14026,7 +14119,7 @@ async function showNetworkLogs(runId, options) {
   });
   if (firstResponse.networkLogs.length === 0) {
     console.log(
-      chalk36.yellow(
+      chalk37.yellow(
         "No network logs found for this run. Network logs are only captured when using a runner with proxy enabled"
       )
     );
@@ -14063,17 +14156,17 @@ async function showNetworkLogs(runId, options) {
 }
 
 // src/commands/org/index.ts
-import { Command as Command48 } from "commander";
+import { Command as Command49 } from "commander";
 
 // src/commands/org/status.ts
-import { Command as Command40 } from "commander";
-import chalk37 from "chalk";
-var statusCommand5 = new Command40().name("status").description("View current organization status").action(
+import { Command as Command41 } from "commander";
+import chalk38 from "chalk";
+var statusCommand5 = new Command41().name("status").description("View current organization status").action(
   withErrorHandler(async () => {
     try {
       const org = await getOrg();
-      console.log(chalk37.bold("Organization Information:"));
-      console.log(`  Slug: ${chalk37.green(org.slug)}`);
+      console.log(chalk38.bold("Organization Information:"));
+      console.log(`  Slug: ${chalk38.green(org.slug)}`);
     } catch (error) {
       if (error instanceof Error && error.message.includes("No org configured")) {
         throw new Error("No organization configured", {
@@ -14086,9 +14179,9 @@ var statusCommand5 = new Command40().name("status").description("View current or
 );
 
 // src/commands/org/set.ts
-import { Command as Command41 } from "commander";
-import chalk38 from "chalk";
-var setCommand = new Command41().name("set").description("Rename your organization slug").argument("<slug>", "The new organization slug").option(
+import { Command as Command42 } from "commander";
+import chalk39 from "chalk";
+var setCommand = new Command42().name("set").description("Rename your organization slug").argument("<slug>", "The new organization slug").option(
   "--force",
   "Force change existing organization (may break references)"
 ).action(
@@ -14105,10 +14198,10 @@ var setCommand = new Command41().name("set").description("Rename your organizati
       }
       const org = await updateOrg({ slug, force: true });
       await saveConfig({ activeOrg: org.slug });
-      console.log(chalk38.green(`\u2713 Organization updated to ${org.slug}`));
+      console.log(chalk39.green(`\u2713 Organization updated to ${org.slug}`));
       console.log();
       console.log("Your agents will now be namespaced as:");
-      console.log(chalk38.cyan(`  ${org.slug}/<agent-name>`));
+      console.log(chalk39.cyan(`  ${org.slug}/<agent-name>`));
     } catch (error) {
       if (error instanceof Error && error.message.includes("already exists")) {
         throw new Error(
@@ -14121,32 +14214,32 @@ var setCommand = new Command41().name("set").description("Rename your organizati
 );
 
 // src/commands/org/list.ts
-import { Command as Command42 } from "commander";
-import chalk39 from "chalk";
-var listCommand5 = new Command42().name("list").description("List all accessible organizations").action(
+import { Command as Command43 } from "commander";
+import chalk40 from "chalk";
+var listCommand5 = new Command43().name("list").description("List all accessible organizations").action(
   withErrorHandler(async () => {
     const result = await listOrgs();
     const activeOrg = await getActiveOrg();
-    console.log(chalk39.bold("Available organizations:"));
+    console.log(chalk40.bold("Available organizations:"));
     for (const org of result.orgs) {
       const isCurrent = org.slug === activeOrg;
-      const marker = isCurrent ? chalk39.green("* ") : "  ";
+      const marker = isCurrent ? chalk40.green("* ") : "  ";
       const roleLabel = org.role ? ` (${org.role})` : "";
-      const currentLabel = isCurrent ? chalk39.dim(" \u2190 current") : "";
+      const currentLabel = isCurrent ? chalk40.dim(" \u2190 current") : "";
       console.log(`${marker}${org.slug}${roleLabel}${currentLabel}`);
     }
   })
 );
 
 // src/commands/org/use.ts
-import { Command as Command43 } from "commander";
-import chalk40 from "chalk";
-var useCommand = new Command43().name("use").description("Switch to a different organization").argument("[slug]", "Organization slug to switch to").option("--personal", "Switch to personal org").action(
+import { Command as Command44 } from "commander";
+import chalk41 from "chalk";
+var useCommand = new Command44().name("use").description("Switch to a different organization").argument("[slug]", "Organization slug to switch to").option("--personal", "Switch to personal org").action(
   withErrorHandler(
     async (slug, options) => {
       if (options.personal) {
         await saveConfig({ activeOrg: void 0 });
-        console.log(chalk40.green("\u2713 Switched to personal org."));
+        console.log(chalk41.green("\u2713 Switched to personal org."));
         return;
       }
       if (!slug) {
@@ -14162,27 +14255,27 @@ var useCommand = new Command43().name("use").description("Switch to a different
         );
       }
       await saveConfig({ activeOrg: slug });
-      console.log(chalk40.green(`\u2713 Switched to organization: ${slug}`));
+      console.log(chalk41.green(`\u2713 Switched to organization: ${slug}`));
     }
   )
 );
 
 // src/commands/org/members.ts
-import { Command as Command44 } from "commander";
-import chalk41 from "chalk";
-var membersCommand = new Command44().name("members").description("View organization members").action(
+import { Command as Command45 } from "commander";
+import chalk42 from "chalk";
+var membersCommand = new Command45().name("members").description("View organization members").action(
   withErrorHandler(async () => {
     try {
       const status = await getOrgMembers();
-      console.log(chalk41.bold(`Organization: ${status.slug}`));
+      console.log(chalk42.bold(`Organization: ${status.slug}`));
       console.log(`  Role: ${status.role}`);
       console.log(
         `  Created: ${new Date(status.createdAt).toLocaleDateString()}`
       );
       console.log();
-      console.log(chalk41.bold("Members:"));
+      console.log(chalk42.bold("Members:"));
       for (const member of status.members) {
-        const roleTag = member.role === "admin" ? chalk41.yellow(` (${member.role})`) : chalk41.dim(` (${member.role})`);
+        const roleTag = member.role === "admin" ? chalk42.yellow(` (${member.role})`) : chalk42.dim(` (${member.role})`);
         console.log(`  ${member.email}${roleTag}`);
       }
     } catch (error) {
@@ -14197,47 +14290,47 @@ var membersCommand = new Command44().name("members").description("View organizat
 );
 
 // src/commands/org/invite.ts
-import { Command as Command45 } from "commander";
-import chalk42 from "chalk";
-var inviteCommand = new Command45().name("invite").description("Invite a member to the current organization").requiredOption("--email <email>", "Email address of the member to invite").action(
+import { Command as Command46 } from "commander";
+import chalk43 from "chalk";
+var inviteCommand = new Command46().name("invite").description("Invite a member to the current organization").requiredOption("--email <email>", "Email address of the member to invite").action(
   withErrorHandler(async (options) => {
     await inviteOrgMember(options.email);
-    console.log(chalk42.green(`\u2713 Invitation sent to ${options.email}`));
+    console.log(chalk43.green(`\u2713 Invitation sent to ${options.email}`));
   })
 );
 
 // src/commands/org/remove.ts
-import { Command as Command46 } from "commander";
-import chalk43 from "chalk";
-var removeCommand = new Command46().name("remove").description("Remove a member from the current organization").argument("<email>", "Email address of the member to remove").action(
+import { Command as Command47 } from "commander";
+import chalk44 from "chalk";
+var removeCommand = new Command47().name("remove").description("Remove a member from the current organization").argument("<email>", "Email address of the member to remove").action(
   withErrorHandler(async (email) => {
     await removeOrgMember(email);
-    console.log(chalk43.green(`\u2713 Removed ${email} from organization`));
+    console.log(chalk44.green(`\u2713 Removed ${email} from organization`));
   })
 );
 
 // src/commands/org/leave.ts
-import { Command as Command47 } from "commander";
-import chalk44 from "chalk";
-var leaveCommand = new Command47().name("leave").description("Leave the current organization").action(
+import { Command as Command48 } from "commander";
+import chalk45 from "chalk";
+var leaveCommand = new Command48().name("leave").description("Leave the current organization").action(
   withErrorHandler(async () => {
     await leaveOrg();
     await saveConfig({ activeOrg: void 0 });
     console.log(
-      chalk44.green("\u2713 Left organization. Switched to personal org.")
+      chalk45.green("\u2713 Left organization. Switched to personal org.")
     );
   })
 );
 
 // src/commands/org/index.ts
-var orgCommand = new Command48().name("org").description("Manage your organization (namespace for agents)").addCommand(statusCommand5).addCommand(setCommand).addCommand(listCommand5).addCommand(useCommand).addCommand(membersCommand).addCommand(inviteCommand).addCommand(removeCommand).addCommand(leaveCommand);
+var orgCommand = new Command49().name("org").description("Manage your organization (namespace for agents)").addCommand(statusCommand5).addCommand(setCommand).addCommand(listCommand5).addCommand(useCommand).addCommand(membersCommand).addCommand(inviteCommand).addCommand(removeCommand).addCommand(leaveCommand);
 
 // src/commands/agent/index.ts
-import { Command as Command53 } from "commander";
+import { Command as Command54 } from "commander";
 
 // src/commands/agent/clone.ts
-import { Command as Command49 } from "commander";
-import chalk45 from "chalk";
+import { Command as Command50 } from "commander";
+import chalk46 from "chalk";
 import { mkdtempSync as mkdtempSync5 } from "fs";
 import { mkdir as mkdir7, writeFile as writeFile6, readdir as readdir2, copyFile, rm as rm4 } from "fs/promises";
 import { join as join10, dirname as dirname3, resolve, sep } from "path";
@@ -14268,13 +14361,13 @@ async function downloadInstructions(agentName, instructionsPath, destination) {
     throw new Error("Invalid instructions path: path traversal detected");
   }
   const volumeName = getInstructionsStorageName(agentName);
-  console.log(chalk45.dim("Downloading instructions..."));
+  console.log(chalk46.dim("Downloading instructions..."));
   const downloadInfo = await getStorageDownload({
     name: volumeName,
     type: "volume"
   });
   if ("empty" in downloadInfo) {
-    console.log(chalk45.yellow("\u26A0 Instructions volume is empty"));
+    console.log(chalk46.yellow("\u26A0 Instructions volume is empty"));
     return false;
   }
   const response = await fetch(downloadInfo.url);
@@ -14289,7 +14382,7 @@ async function downloadInstructions(agentName, instructionsPath, destination) {
   const files = await readdir2(tmpDir);
   const mdFile = files.find((f) => f === "CLAUDE.md" || f === "AGENTS.md");
   if (!mdFile) {
-    console.log(chalk45.yellow("\u26A0 No instructions file found in volume"));
+    console.log(chalk46.yellow("\u26A0 No instructions file found in volume"));
     await rm4(tmpDir, { recursive: true, force: true });
     return false;
   }
@@ -14298,7 +14391,7 @@ async function downloadInstructions(agentName, instructionsPath, destination) {
   await rm4(tmpDir, { recursive: true, force: true });
   return true;
 }
-var cloneCommand4 = new Command49().name("clone").description("Clone agent compose to local directory (latest version)").argument("<name>", "Agent compose name to clone").argument("[destination]", "Destination directory (default: agent name)").action(
+var cloneCommand4 = new Command50().name("clone").description("Clone agent compose to local directory (latest version)").argument("<name>", "Agent compose name to clone").argument("[destination]", "Destination directory (default: agent name)").action(
   withErrorHandler(async (name, destination) => {
     const targetDir = destination || name;
     const dirStatus = checkDirectoryStatus(targetDir);
@@ -14319,7 +14412,7 @@ var cloneCommand4 = new Command49().name("clone").description("Clone agent compo
     await mkdir7(targetDir, { recursive: true });
     const yamlPath = join10(targetDir, "vm0.yaml");
     await writeFile6(yamlPath, yamlContent, "utf8");
-    console.log(chalk45.green("\u2713 Created vm0.yaml"));
+    console.log(chalk46.green("\u2713 Created vm0.yaml"));
     const agentKey = Object.keys(content.agents)[0];
     const agent = agentKey ? content.agents[agentKey] : void 0;
     if (agent?.instructions) {
@@ -14330,27 +14423,27 @@ var cloneCommand4 = new Command49().name("clone").description("Clone agent compo
           targetDir
         );
         if (instructionsDownloaded) {
-          console.log(chalk45.green(`\u2713 Downloaded ${agent.instructions}`));
+          console.log(chalk46.green(`\u2713 Downloaded ${agent.instructions}`));
         }
       } catch (error) {
         console.log(
-          chalk45.yellow(
+          chalk46.yellow(
             `\u26A0 Could not download instructions: ${error instanceof Error ? error.message : "Unknown error"}`
           )
         );
       }
     }
     console.log();
-    console.log(chalk45.green(`\u2713 Successfully cloned agent: ${name}`));
-    console.log(chalk45.dim(`  Location: ${targetDir}/`));
-    console.log(chalk45.dim(`  Version: ${compose.headVersionId.slice(0, 8)}`));
+    console.log(chalk46.green(`\u2713 Successfully cloned agent: ${name}`));
+    console.log(chalk46.dim(`  Location: ${targetDir}/`));
+    console.log(chalk46.dim(`  Version: ${compose.headVersionId.slice(0, 8)}`));
   })
 );
 
 // src/commands/agent/delete.ts
-import { Command as Command50 } from "commander";
-import chalk46 from "chalk";
-var deleteCommand = new Command50().name("delete").alias("rm").description("Delete an agent").argument("<name>", "Agent name to delete").option("-y, --yes", "Skip confirmation prompt").action(
+import { Command as Command51 } from "commander";
+import chalk47 from "chalk";
+var deleteCommand = new Command51().name("delete").alias("rm").description("Delete an agent").argument("<name>", "Agent name to delete").option("-y, --yes", "Skip confirmation prompt").action(
   withErrorHandler(async (name, options) => {
     const compose = await getComposeByName(name);
     if (!compose) {
@@ -14364,7 +14457,7 @@ var deleteCommand = new Command50().name("delete").alias("rm").description("Dele
       }
       const confirmed = await promptConfirm(`Delete agent '${name}'?`, false);
       if (!confirmed) {
-        console.log(chalk46.dim("Cancelled"));
+        console.log(chalk47.dim("Cancelled"));
         return;
       }
     }
@@ -14378,14 +14471,14 @@ var deleteCommand = new Command50().name("delete").alias("rm").description("Dele
       }
       throw error;
     }
-    console.log(chalk46.green(`\u2713 Agent '${name}' deleted`));
+    console.log(chalk47.green(`\u2713 Agent '${name}' deleted`));
   })
 );
 
 // src/commands/agent/list.ts
-import { Command as Command51 } from "commander";
-import chalk47 from "chalk";
-var listCommand6 = new Command51().name("list").alias("ls").description("List all agent composes").action(
+import { Command as Command52 } from "commander";
+import chalk48 from "chalk";
+var listCommand6 = new Command52().name("list").alias("ls").description("List all agent composes").action(
   withErrorHandler(async () => {
     const response = await httpGet("/api/agent/composes/list");
     if (!response.ok) {
@@ -14394,9 +14487,9 @@ var listCommand6 = new Command51().name("list").alias("ls").description("List al
     }
     const data = await response.json();
     if (data.composes.length === 0) {
-      console.log(chalk47.dim("No agent composes found"));
+      console.log(chalk48.dim("No agent composes found"));
       console.log(
-        chalk47.dim("  Create one with: vm0 compose <agent-compose.yaml>")
+        chalk48.dim("  Create one with: vm0 compose <agent-compose.yaml>")
       );
       return;
     }
@@ -14404,9 +14497,9 @@ var listCommand6 = new Command51().name("list").alias("ls").description("List al
     const header = ["NAME".padEnd(nameWidth), "VERSION", "UPDATED"].join(
       "  "
     );
-    console.log(chalk47.dim(header));
+    console.log(chalk48.dim(header));
     for (const compose of data.composes) {
-      const versionShort = compose.headVersionId ? compose.headVersionId.slice(0, 8) : chalk47.dim("-");
+      const versionShort = compose.headVersionId ? compose.headVersionId.slice(0, 8) : chalk48.dim("-");
       const row = [
         compose.name.padEnd(nameWidth),
         versionShort,
@@ -14418,8 +14511,8 @@ var listCommand6 = new Command51().name("list").alias("ls").description("List al
 );
 
 // src/commands/agent/status.ts
-import { Command as Command52 } from "commander";
-import chalk48 from "chalk";
+import { Command as Command53 } from "commander";
+import chalk49 from "chalk";
 
 // src/lib/domain/source-derivation.ts
 import * as fs10 from "fs/promises";
@@ -14533,20 +14626,20 @@ function formatVariableSources(sources) {
   if (sources.secrets.length > 0) {
     console.log(`    Secrets:`);
     for (const secret of sources.secrets) {
-      const sourceInfo = chalk48.dim(`(${secret.source})`);
+      const sourceInfo = chalk49.dim(`(${secret.source})`);
       console.log(`      - ${secret.name.padEnd(20)} ${sourceInfo}`);
     }
   }
   if (sources.vars.length > 0) {
     console.log(`    Vars:`);
     for (const v of sources.vars) {
-      const sourceInfo = chalk48.dim(`(${v.source})`);
+      const sourceInfo = chalk49.dim(`(${v.source})`);
       console.log(`      - ${v.name.padEnd(20)} ${sourceInfo}`);
     }
   }
 }
 function formatAgentDetails(agentName, agent, agentSources, volumeConfigs) {
-  console.log(`  ${chalk48.cyan(agentName)}:`);
+  console.log(`  ${chalk49.cyan(agentName)}:`);
   console.log(`    Framework: ${agent.framework}`);
   if (agent.image) {
     console.log(`    Image:    ${agent.image}`);
@@ -14564,16 +14657,16 @@ function formatAgentDetails(agentName, agent, agentSources, volumeConfigs) {
   }
 }
 function formatComposeOutput(name, versionId, content, variableSources) {
-  console.log(chalk48.bold("Name:") + `    ${name}`);
-  console.log(chalk48.bold("Version:") + ` ${versionId}`);
+  console.log(chalk49.bold("Name:") + `    ${name}`);
+  console.log(chalk49.bold("Version:") + ` ${versionId}`);
   console.log();
-  console.log(chalk48.bold("Agents:"));
+  console.log(chalk49.bold("Agents:"));
   for (const [agentName, agent] of Object.entries(content.agents)) {
     const agentSources = variableSources?.get(agentName);
     formatAgentDetails(agentName, agent, agentSources, content.volumes);
   }
 }
-var statusCommand6 = new Command52().name("status").description("Show status of agent compose").argument(
+var statusCommand6 = new Command53().name("status").description("Show status of agent compose").argument(
   "<name[:version]>",
   "Agent name with optional version (e.g., my-agent:latest or my-agent:a1b2c3d4)"
 ).option("--no-sources", "Skip fetching skills to determine variable sources").action(
@@ -14626,7 +14719,7 @@ var statusCommand6 = new Command52().name("status").description("Show status of
         });
       } catch {
         console.error(
-          chalk48.yellow(
+          chalk49.yellow(
             "\u26A0 Warning: Failed to fetch skill sources, showing basic info"
           )
         );
@@ -14642,11 +14735,11 @@ var statusCommand6 = new Command52().name("status").description("Show status of
 );
 
 // src/commands/agent/index.ts
-var agentCommand = new Command53().name("agent").description("Manage agent composes").addCommand(cloneCommand4).addCommand(deleteCommand).addCommand(listCommand6).addCommand(statusCommand6);
+var agentCommand = new Command54().name("agent").description("Manage agent composes").addCommand(cloneCommand4).addCommand(deleteCommand).addCommand(listCommand6).addCommand(statusCommand6);
 
 // src/commands/init/index.ts
-import { Command as Command54 } from "commander";
-import chalk49 from "chalk";
+import { Command as Command55 } from "commander";
+import chalk50 from "chalk";
 import path17 from "path";
 import { existsSync as existsSync11 } from "fs";
 import { writeFile as writeFile7 } from "fs/promises";
@@ -14684,7 +14777,7 @@ function checkExistingFiles() {
   if (existsSync11(AGENTS_MD_FILE)) existingFiles.push(AGENTS_MD_FILE);
   return existingFiles;
 }
-var initCommand4 = new Command54().name("init").description("Initialize a new VM0 project in the current directory").option("-f, --force", "Overwrite existing files").option("-n, --name <name>", "Agent name (required in non-interactive mode)").action(
+var initCommand4 = new Command55().name("init").description("Initialize a new VM0 project in the current directory").option("-f, --force", "Overwrite existing files").option("-n, --name <name>", "Agent name (required in non-interactive mode)").action(
   withErrorHandler(async (options) => {
     const existingFiles = checkExistingFiles();
     if (existingFiles.length > 0 && !options.force) {
@@ -14713,7 +14806,7 @@ var initCommand4 = new Command54().name("init").description("Initialize a new VM
         }
       );
       if (name === void 0) {
-        console.log(chalk49.dim("Cancelled"));
+        console.log(chalk50.dim("Cancelled"));
         return;
       }
       agentName = name;
@@ -14727,33 +14820,33 @@ var initCommand4 = new Command54().name("init").description("Initialize a new VM
     }
     await writeFile7(VM0_YAML_FILE, generateVm0Yaml(agentName));
     const vm0Status = existingFiles.includes(VM0_YAML_FILE) ? " (overwritten)" : "";
-    console.log(chalk49.green(`\u2713 Created ${VM0_YAML_FILE}${vm0Status}`));
+    console.log(chalk50.green(`\u2713 Created ${VM0_YAML_FILE}${vm0Status}`));
     await writeFile7(AGENTS_MD_FILE, generateAgentsMd());
     const agentsStatus = existingFiles.includes(AGENTS_MD_FILE) ? " (overwritten)" : "";
-    console.log(chalk49.green(`\u2713 Created ${AGENTS_MD_FILE}${agentsStatus}`));
+    console.log(chalk50.green(`\u2713 Created ${AGENTS_MD_FILE}${agentsStatus}`));
     console.log();
     console.log("Next steps:");
     console.log(
-      `  1. Set up model provider (one-time): ${chalk49.cyan("vm0 model-provider setup")}`
+      `  1. Set up model provider (one-time): ${chalk50.cyan("vm0 model-provider setup")}`
     );
     console.log(
-      `  2. Edit ${chalk49.cyan("AGENTS.md")} to customize your agent's workflow`
+      `  2. Edit ${chalk50.cyan("AGENTS.md")} to customize your agent's workflow`
     );
     console.log(
-      `     Or install Claude plugin: ${chalk49.cyan(`vm0 setup-claude && claude "/vm0-agent let's build an agent"`)}`
+      `     Or install Claude plugin: ${chalk50.cyan(`vm0 setup-claude && claude "/vm0-agent let's build an agent"`)}`
     );
     console.log(
-      `  3. Run your agent: ${chalk49.cyan(`vm0 cook "let's start working"`)}`
+      `  3. Run your agent: ${chalk50.cyan(`vm0 cook "let's start working"`)}`
     );
   })
 );
 
 // src/commands/schedule/index.ts
-import { Command as Command61 } from "commander";
+import { Command as Command62 } from "commander";
 
 // src/commands/schedule/setup.ts
-import { Command as Command55 } from "commander";
-import chalk50 from "chalk";
+import { Command as Command56 } from "commander";
+import chalk51 from "chalk";
 
 // src/lib/domain/schedule-utils.ts
 import { parse as parseYaml5 } from "yaml";
@@ -15243,7 +15336,7 @@ async function buildAndDeploy(params) {
   }
   console.log(
     `
-Deploying schedule for agent ${chalk50.cyan(params.agentName)}...`
+Deploying schedule for agent ${chalk51.cyan(params.agentName)}...`
   );
   const deployResult = await deploySchedule({
     name: params.scheduleName,
@@ -15266,62 +15359,62 @@ Deploying schedule for agent ${chalk50.cyan(params.agentName)}...`
 function displayDeployResult(agentName, deployResult) {
   if (deployResult.created) {
     console.log(
-      chalk50.green(`\u2713 Created schedule for agent ${chalk50.cyan(agentName)}`)
+      chalk51.green(`\u2713 Created schedule for agent ${chalk51.cyan(agentName)}`)
     );
   } else {
     console.log(
-      chalk50.green(`\u2713 Updated schedule for agent ${chalk50.cyan(agentName)}`)
+      chalk51.green(`\u2713 Updated schedule for agent ${chalk51.cyan(agentName)}`)
     );
   }
-  console.log(chalk50.dim(`  Timezone: ${deployResult.schedule.timezone}`));
+  console.log(chalk51.dim(`  Timezone: ${deployResult.schedule.timezone}`));
   if (deployResult.schedule.triggerType === "loop" && deployResult.schedule.intervalSeconds != null) {
     console.log(
-      chalk50.dim(
+      chalk51.dim(
         `  Mode: Loop (interval ${deployResult.schedule.intervalSeconds}s)`
       )
     );
   } else if (deployResult.schedule.cronExpression) {
-    console.log(chalk50.dim(`  Cron: ${deployResult.schedule.cronExpression}`));
+    console.log(chalk51.dim(`  Cron: ${deployResult.schedule.cronExpression}`));
     if (deployResult.schedule.nextRunAt) {
       const nextRun = formatInTimezone(
         deployResult.schedule.nextRunAt,
         deployResult.schedule.timezone
       );
-      console.log(chalk50.dim(`  Next run: ${nextRun}`));
+      console.log(chalk51.dim(`  Next run: ${nextRun}`));
     }
   } else if (deployResult.schedule.atTime) {
     const atTimeFormatted = formatInTimezone(
       deployResult.schedule.atTime,
       deployResult.schedule.timezone
     );
-    console.log(chalk50.dim(`  At: ${atTimeFormatted}`));
+    console.log(chalk51.dim(`  At: ${atTimeFormatted}`));
   }
 }
 async function tryEnableSchedule(scheduleName, composeId, agentName) {
   try {
     await enableSchedule({ name: scheduleName, composeId });
     console.log(
-      chalk50.green(`\u2713 Enabled schedule for agent ${chalk50.cyan(agentName)}`)
+      chalk51.green(`\u2713 Enabled schedule for agent ${chalk51.cyan(agentName)}`)
     );
   } catch (error) {
-    console.error(chalk50.yellow("\u26A0 Failed to enable schedule"));
+    console.error(chalk51.yellow("\u26A0 Failed to enable schedule"));
     if (error instanceof ApiRequestError) {
       if (error.code === "SCHEDULE_PAST") {
-        console.error(chalk50.dim("  Scheduled time has already passed"));
+        console.error(chalk51.dim("  Scheduled time has already passed"));
       } else {
-        console.error(chalk50.dim(`  ${error.message}`));
+        console.error(chalk51.dim(`  ${error.message}`));
       }
     } else if (error instanceof Error) {
-      console.error(chalk50.dim(`  ${error.message}`));
+      console.error(chalk51.dim(`  ${error.message}`));
     }
     console.log(
-      `  To enable manually: ${chalk50.cyan(`vm0 schedule enable ${agentName}`)}`
+      `  To enable manually: ${chalk51.cyan(`vm0 schedule enable ${agentName}`)}`
     );
   }
 }
 function showEnableHint(agentName) {
   console.log();
-  console.log(`  To enable: ${chalk50.cyan(`vm0 schedule enable ${agentName}`)}`);
+  console.log(`  To enable: ${chalk51.cyan(`vm0 schedule enable ${agentName}`)}`);
 }
 async function handleScheduleEnabling(params) {
   const { scheduleName, composeId, agentName, enableFlag, shouldPromptEnable } = params;
@@ -15342,7 +15435,7 @@ async function handleScheduleEnabling(params) {
     showEnableHint(agentName);
   }
 }
-var setupCommand = new Command55().name("setup").description("Create or edit a schedule for an agent").argument("<agent-name>", "Agent name to configure schedule for").option("-n, --name <schedule-name>", 'Schedule name (default: "default")').option("-f, --frequency <type>", "Frequency: daily|weekly|monthly|once|loop").option("-t, --time <HH:MM>", "Time to run (24-hour format)").option("-d, --day <day>", "Day of week (mon-sun) or day of month (1-31)").option("-i, --interval <seconds>", "Interval in seconds for loop mode").option("-z, --timezone <tz>", "IANA timezone").option("-p, --prompt <text>", "Prompt to run").option("--artifact-name <name>", "Artifact name", "artifact").option("-e, --enable", "Enable schedule immediately after creation").option("--notify-email", "Enable email notifications (default: true)").option("--no-notify-email", "Disable email notifications").option("--notify-slack", "Enable Slack notifications (default: true)").option("--no-notify-slack", "Disable Slack notifications").action(
+var setupCommand = new Command56().name("setup").description("Create or edit a schedule for an agent").argument("<agent-name>", "Agent name to configure schedule for").option("-n, --name <schedule-name>", 'Schedule name (default: "default")').option("-f, --frequency <type>", "Frequency: daily|weekly|monthly|once|loop").option("-t, --time <HH:MM>", "Time to run (24-hour format)").option("-d, --day <day>", "Day of week (mon-sun) or day of month (1-31)").option("-i, --interval <seconds>", "Interval in seconds for loop mode").option("-z, --timezone <tz>", "IANA timezone").option("-p, --prompt <text>", "Prompt to run").option("--artifact-name <name>", "Artifact name", "artifact").option("-e, --enable", "Enable schedule immediately after creation").option("--notify-email", "Enable email notifications (default: true)").option("--no-notify-email", "Disable email notifications").option("--notify-slack", "Enable Slack notifications (default: true)").option("--no-notify-slack", "Disable Slack notifications").action(
   withErrorHandler(async (agentName, options) => {
     const { composeId, scheduleName } = await resolveAgent(
       agentName,
@@ -15353,7 +15446,7 @@ var setupCommand = new Command55().name("setup").description("Create or edit a s
       scheduleName
     );
     console.log(
-      chalk50.dim(
+      chalk51.dim(
         existingSchedule ? `Editing existing schedule for agent ${agentName}` : `Creating new schedule for agent ${agentName}`
       )
     );
@@ -15363,12 +15456,12 @@ var setupCommand = new Command55().name("setup").description("Create or edit a s
       defaults.frequency
     );
     if (!frequency) {
-      console.log(chalk50.dim("Cancelled"));
+      console.log(chalk51.dim("Cancelled"));
       return;
     }
     const timing = await gatherTiming(frequency, options, defaults);
     if (!timing) {
-      console.log(chalk50.dim("Cancelled"));
+      console.log(chalk51.dim("Cancelled"));
       return;
     }
     const { day, time, atTime, intervalSeconds } = timing;
@@ -15377,7 +15470,7 @@ var setupCommand = new Command55().name("setup").description("Create or edit a s
       existingSchedule?.timezone
     );
     if (!timezone) {
-      console.log(chalk50.dim("Cancelled"));
+      console.log(chalk51.dim("Cancelled"));
       return;
     }
     const promptText_ = await gatherPromptText(
@@ -15385,7 +15478,7 @@ var setupCommand = new Command55().name("setup").description("Create or edit a s
       existingSchedule?.prompt
     );
     if (!promptText_) {
-      console.log(chalk50.dim("Cancelled"));
+      console.log(chalk51.dim("Cancelled"));
       return;
     }
     const { notifyEmail, notifySlack } = await gatherNotificationPreferences(
@@ -15421,15 +15514,15 @@ var setupCommand = new Command55().name("setup").description("Create or edit a s
 );
 
 // src/commands/schedule/list.ts
-import { Command as Command56 } from "commander";
-import chalk51 from "chalk";
-var listCommand7 = new Command56().name("list").alias("ls").description("List all schedules").action(
+import { Command as Command57 } from "commander";
+import chalk52 from "chalk";
+var listCommand7 = new Command57().name("list").alias("ls").description("List all schedules").action(
   withErrorHandler(async () => {
     const result = await listSchedules();
     if (result.schedules.length === 0) {
-      console.log(chalk51.dim("No schedules found"));
+      console.log(chalk52.dim("No schedules found"));
       console.log(
-        chalk51.dim("  Create one with: vm0 schedule setup <agent-name>")
+        chalk52.dim("  Create one with: vm0 schedule setup <agent-name>")
       );
       return;
     }
@@ -15454,10 +15547,10 @@ var listCommand7 = new Command56().name("list").alias("ls").description("List al
       "STATUS".padEnd(8),
       "NEXT RUN"
     ].join("  ");
-    console.log(chalk51.dim(header));
+    console.log(chalk52.dim(header));
     for (const schedule of result.schedules) {
       const trigger = schedule.cronExpression ? `${schedule.cronExpression} (${schedule.timezone})` : schedule.atTime || "-";
-      const status = schedule.enabled ? chalk51.green("enabled") : chalk51.yellow("disabled");
+      const status = schedule.enabled ? chalk52.green("enabled") : chalk52.yellow("disabled");
       const nextRun = schedule.enabled ? formatRelativeTime2(schedule.nextRunAt) : "-";
       const row = [
         schedule.composeName.padEnd(agentWidth),
@@ -15473,48 +15566,48 @@ var listCommand7 = new Command56().name("list").alias("ls").description("List al
 );
 
 // src/commands/schedule/status.ts
-import { Command as Command57 } from "commander";
-import chalk52 from "chalk";
+import { Command as Command58 } from "commander";
+import chalk53 from "chalk";
 function formatDateTimeStyled(dateStr) {
-  if (!dateStr) return chalk52.dim("-");
+  if (!dateStr) return chalk53.dim("-");
   const formatted = formatDateTime(dateStr);
-  return formatted.replace(/\(([^)]+)\)$/, chalk52.dim("($1)"));
+  return formatted.replace(/\(([^)]+)\)$/, chalk53.dim("($1)"));
 }
 function formatTrigger(schedule) {
   if (schedule.triggerType === "loop" && schedule.intervalSeconds !== null) {
-    return `interval ${schedule.intervalSeconds}s ${chalk52.dim("(loop)")}`;
+    return `interval ${schedule.intervalSeconds}s ${chalk53.dim("(loop)")}`;
   }
   if (schedule.cronExpression) {
     return schedule.cronExpression;
   }
   if (schedule.atTime) {
-    return `${schedule.atTime} ${chalk52.dim("(one-time)")}`;
+    return `${schedule.atTime} ${chalk53.dim("(one-time)")}`;
   }
-  return chalk52.dim("-");
+  return chalk53.dim("-");
 }
 function formatRunStatus2(status) {
   switch (status) {
     case "completed":
-      return chalk52.green(status);
+      return chalk53.green(status);
     case "failed":
     case "timeout":
-      return chalk52.red(status);
+      return chalk53.red(status);
     case "running":
-      return chalk52.cyan(status);
+      return chalk53.cyan(status);
     case "pending":
-      return chalk52.yellow(status);
+      return chalk53.yellow(status);
     default:
       return status;
   }
 }
 function printRunConfiguration(schedule) {
-  const statusText = schedule.enabled ? chalk52.green("enabled") : chalk52.yellow("disabled");
+  const statusText = schedule.enabled ? chalk53.green("enabled") : chalk53.yellow("disabled");
   console.log(`${"Status:".padEnd(16)}${statusText}`);
   console.log(
-    `${"Agent:".padEnd(16)}${schedule.composeName} ${chalk52.dim(`(${schedule.orgSlug})`)}`
+    `${"Agent:".padEnd(16)}${schedule.composeName} ${chalk53.dim(`(${schedule.orgSlug})`)}`
   );
   const promptPreview = schedule.prompt.length > 60 ? schedule.prompt.slice(0, 57) + "..." : schedule.prompt;
-  console.log(`${"Prompt:".padEnd(16)}${chalk52.dim(promptPreview)}`);
+  console.log(`${"Prompt:".padEnd(16)}${chalk53.dim(promptPreview)}`);
   if (schedule.vars && Object.keys(schedule.vars).length > 0) {
     console.log(
       `${"Variables:".padEnd(16)}${Object.keys(schedule.vars).join(", ")}`
@@ -15543,7 +15636,7 @@ function printTimeSchedule(schedule) {
     );
   }
   if (schedule.triggerType === "loop") {
-    const failureText = schedule.consecutiveFailures > 0 ? chalk52.yellow(`${schedule.consecutiveFailures}/3`) : chalk52.dim("0/3");
+    const failureText = schedule.consecutiveFailures > 0 ? chalk53.yellow(`${schedule.consecutiveFailures}/3`) : chalk53.dim("0/3");
     console.log(`${"Failures:".padEnd(16)}${failureText}`);
   }
 }
@@ -15559,7 +15652,7 @@ async function printRecentRuns(name, composeId, limit) {
       console.log();
       console.log("Recent Runs:");
       console.log(
-        chalk52.dim("RUN ID                                STATUS     CREATED")
+        chalk53.dim("RUN ID                                STATUS     CREATED")
       );
       for (const run of runs) {
         const id = run.id;
@@ -15570,10 +15663,10 @@ async function printRecentRuns(name, composeId, limit) {
     }
   } catch {
     console.log();
-    console.log(chalk52.dim("Recent Runs: (unable to fetch)"));
+    console.log(chalk53.dim("Recent Runs: (unable to fetch)"));
   }
 }
-var statusCommand7 = new Command57().name("status").description("Show detailed status of a schedule").argument("<agent-name>", "Agent name").option(
+var statusCommand7 = new Command58().name("status").description("Show detailed status of a schedule").argument("<agent-name>", "Agent name").option(
   "-n, --name <schedule-name>",
   "Schedule name (required when agent has multiple schedules)"
 ).option(
@@ -15587,8 +15680,8 @@ var statusCommand7 = new Command57().name("status").description("Show detailed s
       const { name, composeId } = resolved;
       const schedule = await getScheduleByName({ name, composeId });
       console.log();
-      console.log(`Schedule for agent: ${chalk52.cyan(agentName)}`);
-      console.log(chalk52.dim("\u2501".repeat(50)));
+      console.log(`Schedule for agent: ${chalk53.cyan(agentName)}`);
+      console.log(chalk53.dim("\u2501".repeat(50)));
       printRunConfiguration(schedule);
       printTimeSchedule(schedule);
       const parsed = parseInt(options.limit, 10);
@@ -15603,9 +15696,9 @@ var statusCommand7 = new Command57().name("status").description("Show detailed s
 );
 
 // src/commands/schedule/delete.ts
-import { Command as Command58 } from "commander";
-import chalk53 from "chalk";
-var deleteCommand2 = new Command58().name("delete").alias("rm").description("Delete a schedule").argument("<agent-name>", "Agent name").option(
+import { Command as Command59 } from "commander";
+import chalk54 from "chalk";
+var deleteCommand2 = new Command59().name("delete").alias("rm").description("Delete a schedule").argument("<agent-name>", "Agent name").option(
   "-n, --name <schedule-name>",
   "Schedule name (required when agent has multiple schedules)"
 ).option("-y, --yes", "Skip confirmation prompt").action(
@@ -15617,11 +15710,11 @@ var deleteCommand2 = new Command58().name("delete").alias("rm").description("Del
           throw new Error("--yes flag is required in non-interactive mode");
         }
         const confirmed = await promptConfirm(
-          `Delete schedule for agent ${chalk53.cyan(agentName)}?`,
+          `Delete schedule for agent ${chalk54.cyan(agentName)}?`,
           false
         );
         if (!confirmed) {
-          console.log(chalk53.dim("Cancelled"));
+          console.log(chalk54.dim("Cancelled"));
           return;
         }
       }
@@ -15630,16 +15723,16 @@ var deleteCommand2 = new Command58().name("delete").alias("rm").description("Del
         composeId: resolved.composeId
       });
       console.log(
-        chalk53.green(`\u2713 Deleted schedule for agent ${chalk53.cyan(agentName)}`)
+        chalk54.green(`\u2713 Deleted schedule for agent ${chalk54.cyan(agentName)}`)
       );
     }
   )
 );
 
 // src/commands/schedule/enable.ts
-import { Command as Command59 } from "commander";
-import chalk54 from "chalk";
-var enableCommand = new Command59().name("enable").description("Enable a schedule").argument("<agent-name>", "Agent name").option(
+import { Command as Command60 } from "commander";
+import chalk55 from "chalk";
+var enableCommand = new Command60().name("enable").description("Enable a schedule").argument("<agent-name>", "Agent name").option(
   "-n, --name <schedule-name>",
   "Schedule name (required when agent has multiple schedules)"
 ).action(
@@ -15650,15 +15743,15 @@ var enableCommand = new Command59().name("enable").description("Enable a schedul
       composeId: resolved.composeId
     });
     console.log(
-      chalk54.green(`\u2713 Enabled schedule for agent ${chalk54.cyan(agentName)}`)
+      chalk55.green(`\u2713 Enabled schedule for agent ${chalk55.cyan(agentName)}`)
     );
   })
 );
 
 // src/commands/schedule/disable.ts
-import { Command as Command60 } from "commander";
-import chalk55 from "chalk";
-var disableCommand = new Command60().name("disable").description("Disable a schedule").argument("<agent-name>", "Agent name").option(
+import { Command as Command61 } from "commander";
+import chalk56 from "chalk";
+var disableCommand = new Command61().name("disable").description("Disable a schedule").argument("<agent-name>", "Agent name").option(
   "-n, --name <schedule-name>",
   "Schedule name (required when agent has multiple schedules)"
 ).action(
@@ -15669,17 +15762,17 @@ var disableCommand = new Command60().name("disable").description("Disable a sche
       composeId: resolved.composeId
     });
     console.log(
-      chalk55.green(`\u2713 Disabled schedule for agent ${chalk55.cyan(agentName)}`)
+      chalk56.green(`\u2713 Disabled schedule for agent ${chalk56.cyan(agentName)}`)
     );
   })
 );
 
 // src/commands/schedule/index.ts
-var scheduleCommand = new Command61().name("schedule").description("Manage agent schedules").addCommand(setupCommand).addCommand(listCommand7).addCommand(statusCommand7).addCommand(deleteCommand2).addCommand(enableCommand).addCommand(disableCommand);
+var scheduleCommand = new Command62().name("schedule").description("Manage agent schedules").addCommand(setupCommand).addCommand(listCommand7).addCommand(statusCommand7).addCommand(deleteCommand2).addCommand(enableCommand).addCommand(disableCommand);
 
 // src/commands/usage/index.ts
-import { Command as Command62 } from "commander";
-import chalk56 from "chalk";
+import { Command as Command63 } from "commander";
+import chalk57 from "chalk";
 
 // src/lib/utils/duration-formatter.ts
 function formatDuration(ms) {
@@ -15752,7 +15845,7 @@ function fillMissingDates(daily, startDate, endDate) {
   result.sort((a, b) => b.date.localeCompare(a.date));
   return result;
 }
-var usageCommand = new Command62().name("usage").description("View usage statistics").option("--since <date>", "Start date (ISO format or relative: 7d, 30d)").option(
+var usageCommand = new Command63().name("usage").description("View usage statistics").option("--since <date>", "Start date (ISO format or relative: 7d, 30d)").option(
   "--until <date>",
   "End date (ISO format or relative, defaults to now)"
 ).action(
@@ -15804,19 +15897,19 @@ var usageCommand = new Command62().name("usage").description("View usage statist
     );
     console.log();
     console.log(
-      chalk56.bold(
+      chalk57.bold(
         `Usage Summary (${formatDateRange(usage.period.start, usage.period.end)})`
       )
     );
     console.log();
-    console.log(chalk56.dim("DATE        RUNS    RUN TIME"));
+    console.log(chalk57.dim("DATE        RUNS    RUN TIME"));
     for (const day of filledDaily) {
       const dateDisplay = formatDateDisplay(day.date).padEnd(10);
       const runsDisplay = String(day.run_count).padStart(6);
       const timeDisplay = formatDuration(day.run_time_ms);
       console.log(`${dateDisplay}${runsDisplay}    ${timeDisplay}`);
     }
-    console.log(chalk56.dim("\u2500".repeat(29)));
+    console.log(chalk57.dim("\u2500".repeat(29)));
     const totalRunsDisplay = String(usage.summary.total_runs).padStart(6);
     const totalTimeDisplay = formatDuration(usage.summary.total_run_time_ms);
     console.log(
@@ -15827,67 +15920,67 @@ var usageCommand = new Command62().name("usage").description("View usage statist
 );
 
 // src/commands/secret/index.ts
-import { Command as Command66 } from "commander";
+import { Command as Command67 } from "commander";
 
 // src/commands/secret/list.ts
-import { Command as Command63 } from "commander";
-import chalk57 from "chalk";
-var listCommand8 = new Command63().name("list").alias("ls").description("List all secrets").action(
+import { Command as Command64 } from "commander";
+import chalk58 from "chalk";
+var listCommand8 = new Command64().name("list").alias("ls").description("List all secrets").action(
   withErrorHandler(async () => {
     const result = await listSecrets();
     if (result.secrets.length === 0) {
-      console.log(chalk57.dim("No secrets found"));
+      console.log(chalk58.dim("No secrets found"));
       console.log();
       console.log("To add a secret:");
-      console.log(chalk57.cyan("  vm0 secret set MY_API_KEY --body <value>"));
+      console.log(chalk58.cyan("  vm0 secret set MY_API_KEY --body <value>"));
       return;
     }
-    console.log(chalk57.bold("Secrets:"));
+    console.log(chalk58.bold("Secrets:"));
     console.log();
     for (const secret of result.secrets) {
       let typeIndicator = "";
       let derivedLine = null;
       if (secret.type === "model-provider") {
-        typeIndicator = chalk57.dim(" [model-provider]");
+        typeIndicator = chalk58.dim(" [model-provider]");
       } else if (secret.type === "connector") {
         const derived = getConnectorDerivedNames(secret.name);
         if (derived) {
-          typeIndicator = chalk57.dim(` [${derived.connectorLabel} connector]`);
-          derivedLine = chalk57.dim(
+          typeIndicator = chalk58.dim(` [${derived.connectorLabel} connector]`);
+          derivedLine = chalk58.dim(
             `Available as: ${derived.envVarNames.join(", ")}`
           );
         } else {
-          typeIndicator = chalk57.dim(" [connector]");
+          typeIndicator = chalk58.dim(" [connector]");
         }
       } else if (secret.type === "user") {
         const derived = getConnectorDerivedNames(secret.name);
         if (derived) {
-          typeIndicator = chalk57.dim(` [${derived.connectorLabel} connector]`);
-          derivedLine = chalk57.dim(
+          typeIndicator = chalk58.dim(` [${derived.connectorLabel} connector]`);
+          derivedLine = chalk58.dim(
             `Available as: ${derived.envVarNames.join(", ")}`
           );
         }
       }
-      console.log(`  ${chalk57.cyan(secret.name)}${typeIndicator}`);
+      console.log(`  ${chalk58.cyan(secret.name)}${typeIndicator}`);
       if (derivedLine) {
         console.log(`    ${derivedLine}`);
       }
       if (secret.description) {
-        console.log(`    ${chalk57.dim(secret.description)}`);
+        console.log(`    ${chalk58.dim(secret.description)}`);
       }
       console.log(
-        `    ${chalk57.dim(`Updated: ${new Date(secret.updatedAt).toLocaleString()}`)}`
+        `    ${chalk58.dim(`Updated: ${new Date(secret.updatedAt).toLocaleString()}`)}`
       );
       console.log();
     }
-    console.log(chalk57.dim(`Total: ${result.secrets.length} secret(s)`));
+    console.log(chalk58.dim(`Total: ${result.secrets.length} secret(s)`));
   })
 );
 
 // src/commands/secret/set.ts
-import { Command as Command64 } from "commander";
-import chalk58 from "chalk";
-var setCommand2 = new Command64().name("set").description("Create or update a secret").argument("<name>", "Secret name (uppercase, e.g., MY_API_KEY)").option(
+import { Command as Command65 } from "commander";
+import chalk59 from "chalk";
+var setCommand2 = new Command65().name("set").description("Create or update a secret").argument("<name>", "Secret name (uppercase, e.g., MY_API_KEY)").option(
   "-b, --body <value>",
   "Secret value (required in non-interactive mode)"
 ).option("-d, --description <description>", "Optional description").action(
@@ -15926,19 +16019,19 @@ var setCommand2 = new Command64().name("set").description("Create or update a se
         }
         throw error;
       }
-      console.log(chalk58.green(`\u2713 Secret "${secret.name}" saved`));
+      console.log(chalk59.green(`\u2713 Secret "${secret.name}" saved`));
       console.log();
       console.log("Use in vm0.yaml:");
-      console.log(chalk58.cyan(`  environment:`));
-      console.log(chalk58.cyan(`    ${name}: \${{ secrets.${name} }}`));
+      console.log(chalk59.cyan(`  environment:`));
+      console.log(chalk59.cyan(`    ${name}: \${{ secrets.${name} }}`));
     }
   )
 );
 
 // src/commands/secret/delete.ts
-import { Command as Command65 } from "commander";
-import chalk59 from "chalk";
-var deleteCommand3 = new Command65().name("delete").description("Delete a secret").argument("<name>", "Secret name to delete").option("-y, --yes", "Skip confirmation prompt").action(
+import { Command as Command66 } from "commander";
+import chalk60 from "chalk";
+var deleteCommand3 = new Command66().name("delete").description("Delete a secret").argument("<name>", "Secret name to delete").option("-y, --yes", "Skip confirmation prompt").action(
   withErrorHandler(async (name, options) => {
     try {
       await getSecret(name);
@@ -15957,61 +16050,61 @@ var deleteCommand3 = new Command65().name("delete").description("Delete a secret
         false
       );
       if (!confirmed) {
-        console.log(chalk59.dim("Cancelled"));
+        console.log(chalk60.dim("Cancelled"));
         return;
       }
     }
     await deleteSecret(name);
-    console.log(chalk59.green(`\u2713 Secret "${name}" deleted`));
+    console.log(chalk60.green(`\u2713 Secret "${name}" deleted`));
   })
 );
 
 // src/commands/secret/index.ts
-var secretCommand = new Command66().name("secret").description("Manage stored secrets for agent runs").addCommand(listCommand8).addCommand(setCommand2).addCommand(deleteCommand3);
+var secretCommand = new Command67().name("secret").description("Manage stored secrets for agent runs").addCommand(listCommand8).addCommand(setCommand2).addCommand(deleteCommand3);
 
 // src/commands/variable/index.ts
-import { Command as Command70 } from "commander";
+import { Command as Command71 } from "commander";
 
 // src/commands/variable/list.ts
-import { Command as Command67 } from "commander";
-import chalk60 from "chalk";
+import { Command as Command68 } from "commander";
+import chalk61 from "chalk";
 function truncateValue(value, maxLength = 60) {
   if (value.length <= maxLength) {
     return value;
   }
   return value.slice(0, maxLength - 15) + "... [truncated]";
 }
-var listCommand9 = new Command67().name("list").alias("ls").description("List all variables").action(
+var listCommand9 = new Command68().name("list").alias("ls").description("List all variables").action(
   withErrorHandler(async () => {
     const result = await listVariables();
     if (result.variables.length === 0) {
-      console.log(chalk60.dim("No variables found"));
+      console.log(chalk61.dim("No variables found"));
       console.log();
       console.log("To add a variable:");
-      console.log(chalk60.cyan("  vm0 variable set MY_VAR <value>"));
+      console.log(chalk61.cyan("  vm0 variable set MY_VAR <value>"));
       return;
     }
-    console.log(chalk60.bold("Variables:"));
+    console.log(chalk61.bold("Variables:"));
     console.log();
     for (const variable of result.variables) {
       const displayValue = truncateValue(variable.value);
-      console.log(`  ${chalk60.cyan(variable.name)} = ${displayValue}`);
+      console.log(`  ${chalk61.cyan(variable.name)} = ${displayValue}`);
       if (variable.description) {
-        console.log(`    ${chalk60.dim(variable.description)}`);
+        console.log(`    ${chalk61.dim(variable.description)}`);
       }
       console.log(
-        `    ${chalk60.dim(`Updated: ${new Date(variable.updatedAt).toLocaleString()}`)}`
+        `    ${chalk61.dim(`Updated: ${new Date(variable.updatedAt).toLocaleString()}`)}`
       );
       console.log();
     }
-    console.log(chalk60.dim(`Total: ${result.variables.length} variable(s)`));
+    console.log(chalk61.dim(`Total: ${result.variables.length} variable(s)`));
   })
 );
 
 // src/commands/variable/set.ts
-import { Command as Command68 } from "commander";
-import chalk61 from "chalk";
-var setCommand3 = new Command68().name("set").description("Create or update a variable").argument("<name>", "Variable name (uppercase, e.g., MY_VAR)").argument("<value>", "Variable value").option("-d, --description <description>", "Optional description").action(
+import { Command as Command69 } from "commander";
+import chalk62 from "chalk";
+var setCommand3 = new Command69().name("set").description("Create or update a variable").argument("<name>", "Variable name (uppercase, e.g., MY_VAR)").argument("<value>", "Variable value").option("-d, --description <description>", "Optional description").action(
   withErrorHandler(
     async (name, value, options) => {
       let variable;
@@ -16031,19 +16124,19 @@ var setCommand3 = new Command68().name("set").description("Create or update a va
         }
         throw error;
       }
-      console.log(chalk61.green(`\u2713 Variable "${variable.name}" saved`));
+      console.log(chalk62.green(`\u2713 Variable "${variable.name}" saved`));
       console.log();
       console.log("Use in vm0.yaml:");
-      console.log(chalk61.cyan(`  environment:`));
-      console.log(chalk61.cyan(`    ${name}: \${{ vars.${name} }}`));
+      console.log(chalk62.cyan(`  environment:`));
+      console.log(chalk62.cyan(`    ${name}: \${{ vars.${name} }}`));
     }
   )
 );
 
 // src/commands/variable/delete.ts
-import { Command as Command69 } from "commander";
-import chalk62 from "chalk";
-var deleteCommand4 = new Command69().name("delete").description("Delete a variable").argument("<name>", "Variable name to delete").option("-y, --yes", "Skip confirmation prompt").action(
+import { Command as Command70 } from "commander";
+import chalk63 from "chalk";
+var deleteCommand4 = new Command70().name("delete").description("Delete a variable").argument("<name>", "Variable name to delete").option("-y, --yes", "Skip confirmation prompt").action(
   withErrorHandler(async (name, options) => {
     try {
       await getVariable(name);
@@ -16062,32 +16155,32 @@ var deleteCommand4 = new Command69().name("delete").description("Delete a variab
         false
       );
       if (!confirmed) {
-        console.log(chalk62.dim("Cancelled"));
+        console.log(chalk63.dim("Cancelled"));
         return;
       }
     }
     await deleteVariable(name);
-    console.log(chalk62.green(`\u2713 Variable "${name}" deleted`));
+    console.log(chalk63.green(`\u2713 Variable "${name}" deleted`));
   })
 );
 
 // src/commands/variable/index.ts
-var variableCommand = new Command70().name("variable").description("Manage stored variables for agent runs").addCommand(listCommand9).addCommand(setCommand3).addCommand(deleteCommand4);
+var variableCommand = new Command71().name("variable").description("Manage stored variables for agent runs").addCommand(listCommand9).addCommand(setCommand3).addCommand(deleteCommand4);
 
 // src/commands/model-provider/index.ts
-import { Command as Command75 } from "commander";
+import { Command as Command76 } from "commander";
 
 // src/commands/model-provider/list.ts
-import { Command as Command71 } from "commander";
-import chalk63 from "chalk";
-var listCommand10 = new Command71().name("list").alias("ls").description("List all model providers").action(
+import { Command as Command72 } from "commander";
+import chalk64 from "chalk";
+var listCommand10 = new Command72().name("list").alias("ls").description("List all model providers").action(
   withErrorHandler(async () => {
     const result = await listModelProviders();
     if (result.modelProviders.length === 0) {
-      console.log(chalk63.dim("No model providers configured"));
+      console.log(chalk64.dim("No model providers configured"));
       console.log();
       console.log("To add a model provider:");
-      console.log(chalk63.cyan("  vm0 model-provider setup"));
+      console.log(chalk64.cyan("  vm0 model-provider setup"));
       return;
     }
     const byFramework = result.modelProviders.reduce(
@@ -16101,16 +16194,16 @@ var listCommand10 = new Command71().name("list").alias("ls").description("List a
       },
       {}
     );
-    console.log(chalk63.bold("Model Providers:"));
+    console.log(chalk64.bold("Model Providers:"));
     console.log();
     for (const [framework, providers] of Object.entries(byFramework)) {
-      console.log(`  ${chalk63.cyan(framework)}:`);
+      console.log(`  ${chalk64.cyan(framework)}:`);
       for (const provider of providers) {
-        const defaultTag = provider.isDefault ? chalk63.green(" (default)") : "";
-        const modelTag = provider.selectedModel ? chalk63.dim(` [${provider.selectedModel}]`) : "";
+        const defaultTag = provider.isDefault ? chalk64.green(" (default)") : "";
+        const modelTag = provider.selectedModel ? chalk64.dim(` [${provider.selectedModel}]`) : "";
         console.log(`    ${provider.type}${defaultTag}${modelTag}`);
         console.log(
-          chalk63.dim(
+          chalk64.dim(
             `      Updated: ${new Date(provider.updatedAt).toLocaleString()}`
           )
         );
@@ -16118,14 +16211,14 @@ var listCommand10 = new Command71().name("list").alias("ls").description("List a
       console.log();
     }
     console.log(
-      chalk63.dim(`Total: ${result.modelProviders.length} provider(s)`)
+      chalk64.dim(`Total: ${result.modelProviders.length} provider(s)`)
     );
   })
 );
 
 // src/commands/model-provider/setup.ts
-import { Command as Command72 } from "commander";
-import chalk64 from "chalk";
+import { Command as Command73 } from "commander";
+import chalk65 from "chalk";
 import prompts2 from "prompts";
 function validateProviderType(typeStr) {
   if (!Object.keys(MODEL_PROVIDER_TYPES).includes(typeStr)) {
@@ -16309,7 +16402,7 @@ async function promptForModelSelection(type2) {
   if (selected === "__custom__") {
     const placeholder = getCustomModelPlaceholder(type2);
     if (placeholder) {
-      console.log(chalk64.dim(`Example: ${placeholder}`));
+      console.log(chalk65.dim(`Example: ${placeholder}`));
     }
     const customResponse = await prompts2(
       {
@@ -16359,7 +16452,7 @@ async function promptForSecrets(type2, authMethod) {
   const secrets = {};
   for (const [name, fieldConfig] of Object.entries(secretsConfig)) {
     if (fieldConfig.helpText) {
-      console.log(chalk64.dim(fieldConfig.helpText));
+      console.log(chalk65.dim(fieldConfig.helpText));
     }
     const isSensitive = isSensitiveSecret(name);
     const placeholder = "placeholder" in fieldConfig ? fieldConfig.placeholder : "";
@@ -16411,7 +16504,7 @@ async function handleInteractiveMode() {
         title = `${title} \u2713`;
       }
       if (isExperimental) {
-        title = `${title} ${chalk64.dim("(experimental)")}`;
+        title = `${title} ${chalk65.dim("(experimental)")}`;
       }
       return {
         title,
@@ -16458,7 +16551,7 @@ async function handleInteractiveMode() {
   }
   const config = MODEL_PROVIDER_TYPES[type2];
   console.log();
-  console.log(chalk64.dim(config.helpText));
+  console.log(chalk65.dim(config.helpText));
   console.log();
   if (hasAuthMethods(type2)) {
     const authMethod = await promptForAuthMethod(type2);
@@ -16499,13 +16592,13 @@ async function promptSetAsDefault(type2, framework, isDefault) {
   );
   if (response.setDefault) {
     await setModelProviderDefault(type2);
-    console.log(chalk64.green(`\u2713 Default for ${framework} set to "${type2}"`));
+    console.log(chalk65.green(`\u2713 Default for ${framework} set to "${type2}"`));
   }
 }
 function collectSecrets(value, previous) {
   return previous.concat([value]);
 }
-var setupCommand2 = new Command72().name("setup").description("Configure a model provider").option("-t, --type <type>", "Provider type (for non-interactive mode)").option(
+var setupCommand2 = new Command73().name("setup").description("Configure a model provider").option("-t, --type <type>", "Provider type (for non-interactive mode)").option(
   "-s, --secret <value>",
   "Secret value (can be used multiple times, supports VALUE or KEY=VALUE format)",
   collectSecrets,
@@ -16543,11 +16636,11 @@ var setupCommand2 = new Command72().name("setup").description("Configure a model
         const modelNote2 = provider2.selectedModel ? ` with model: ${provider2.selectedModel}` : "";
         if (!hasModelSelection(input.type)) {
           console.log(
-            chalk64.green(`\u2713 Model provider "${input.type}" unchanged`)
+            chalk65.green(`\u2713 Model provider "${input.type}" unchanged`)
           );
         } else {
           console.log(
-            chalk64.green(
+            chalk65.green(
               `\u2713 Model provider "${input.type}" updated${defaultNote2}${modelNote2}`
             )
           );
@@ -16572,7 +16665,7 @@ var setupCommand2 = new Command72().name("setup").description("Configure a model
       const defaultNote = provider.isDefault ? ` (default for ${provider.framework})` : "";
       const modelNote = provider.selectedModel ? ` with model: ${provider.selectedModel}` : "";
       console.log(
-        chalk64.green(
+        chalk65.green(
           `\u2713 Model provider "${input.type}" ${action}${defaultNote}${modelNote}`
         )
       );
@@ -16588,9 +16681,9 @@ var setupCommand2 = new Command72().name("setup").description("Configure a model
 );
 
 // src/commands/model-provider/delete.ts
-import { Command as Command73 } from "commander";
-import chalk65 from "chalk";
-var deleteCommand5 = new Command73().name("delete").description("Delete a model provider").argument("<type>", "Model provider type to delete").action(
+import { Command as Command74 } from "commander";
+import chalk66 from "chalk";
+var deleteCommand5 = new Command74().name("delete").description("Delete a model provider").argument("<type>", "Model provider type to delete").action(
   withErrorHandler(async (type2) => {
     if (!Object.keys(MODEL_PROVIDER_TYPES).includes(type2)) {
       const validTypes = Object.keys(MODEL_PROVIDER_TYPES).join(", ");
@@ -16599,14 +16692,14 @@ var deleteCommand5 = new Command73().name("delete").description("Delete a model
       });
     }
     await deleteModelProvider(type2);
-    console.log(chalk65.green(`\u2713 Model provider "${type2}" deleted`));
+    console.log(chalk66.green(`\u2713 Model provider "${type2}" deleted`));
   })
 );
 
 // src/commands/model-provider/set-default.ts
-import { Command as Command74 } from "commander";
-import chalk66 from "chalk";
-var setDefaultCommand = new Command74().name("set-default").description("Set a model provider as default for its framework").argument("<type>", "Model provider type to set as default").action(
+import { Command as Command75 } from "commander";
+import chalk67 from "chalk";
+var setDefaultCommand = new Command75().name("set-default").description("Set a model provider as default for its framework").argument("<type>", "Model provider type to set as default").action(
   withErrorHandler(async (type2) => {
     if (!Object.keys(MODEL_PROVIDER_TYPES).includes(type2)) {
       const validTypes = Object.keys(MODEL_PROVIDER_TYPES).join(", ");
@@ -16616,7 +16709,7 @@ var setDefaultCommand = new Command74().name("set-default").description("Set a m
     }
     const provider = await setModelProviderDefault(type2);
     console.log(
-      chalk66.green(
+      chalk67.green(
         `\u2713 Default for ${provider.framework} set to "${provider.type}"`
       )
     );
@@ -16624,14 +16717,14 @@ var setDefaultCommand = new Command74().name("set-default").description("Set a m
 );
 
 // src/commands/model-provider/index.ts
-var modelProviderCommand = new Command75().name("model-provider").description("Manage model providers for agent runs").addCommand(listCommand10).addCommand(setupCommand2).addCommand(deleteCommand5).addCommand(setDefaultCommand);
+var modelProviderCommand = new Command76().name("model-provider").description("Manage model providers for agent runs").addCommand(listCommand10).addCommand(setupCommand2).addCommand(deleteCommand5).addCommand(setDefaultCommand);
 
 // src/commands/connector/index.ts
-import { Command as Command80 } from "commander";
+import { Command as Command81 } from "commander";
 
 // src/commands/connector/connect.ts
-import { Command as Command76 } from "commander";
-import chalk68 from "chalk";
+import { Command as Command77 } from "commander";
+import chalk69 from "chalk";
 import { initClient as initClient13 } from "@ts-rest/core";
 
 // src/commands/connector/lib/computer/start-services.ts
@@ -16640,7 +16733,7 @@ import { access as access2, constants } from "fs/promises";
 import { createServer } from "net";
 import { homedir as homedir4 } from "os";
 import { join as join12 } from "path";
-import chalk67 from "chalk";
+import chalk68 from "chalk";
 
 // src/commands/connector/lib/computer/ngrok.ts
 import ngrok from "@ngrok/ngrok";
@@ -16714,7 +16807,7 @@ async function checkComputerDependencies() {
   }
 }
 async function startComputerServices(credentials) {
-  console.log(chalk67.cyan("Starting computer connector services..."));
+  console.log(chalk68.cyan("Starting computer connector services..."));
   const wsgidavBinary = await findBinary("wsgidav");
   if (!wsgidavBinary) {
     throw new Error(
@@ -16741,7 +16834,7 @@ async function startComputerServices(credentials) {
   );
   wsgidav.stdout?.on("data", (data) => process.stdout.write(data));
   wsgidav.stderr?.on("data", (data) => process.stderr.write(data));
-  console.log(chalk67.green("\u2713 WebDAV server started"));
+  console.log(chalk68.green("\u2713 WebDAV server started"));
   const chrome = spawn2(
     chromeBinary,
     [
@@ -16755,7 +16848,7 @@ async function startComputerServices(credentials) {
   );
   chrome.stdout?.on("data", (data) => process.stdout.write(data));
   chrome.stderr?.on("data", (data) => process.stderr.write(data));
-  console.log(chalk67.green("\u2713 Chrome started"));
+  console.log(chalk68.green("\u2713 Chrome started"));
   try {
     await startNgrokTunnels(
       credentials.ngrokToken,
@@ -16764,18 +16857,18 @@ async function startComputerServices(credentials) {
       cdpPort
     );
     console.log(
-      chalk67.green(
+      chalk68.green(
         `\u2713 ngrok tunnels: webdav.${credentials.domain}, chrome.${credentials.domain}`
       )
     );
     console.log();
-    console.log(chalk67.green("\u2713 Computer connector active"));
+    console.log(chalk68.green("\u2713 Computer connector active"));
     console.log(`  WebDAV:     ~/Downloads \u2192 webdav.${credentials.domain}`);
     console.log(
       `  Chrome CDP: port ${cdpPort}   \u2192 chrome.${credentials.domain}`
     );
     console.log();
-    console.log(chalk67.dim("Press ^C twice to disconnect"));
+    console.log(chalk68.dim("Press ^C twice to disconnect"));
     console.log();
     let sigintCount = 0;
     await new Promise((resolve2) => {
@@ -16789,7 +16882,7 @@ async function startComputerServices(credentials) {
       const onSigint = () => {
         sigintCount++;
         if (sigintCount === 1) {
-          console.log(chalk67.dim("\nPress ^C again to disconnect and exit..."));
+          console.log(chalk68.dim("\nPress ^C again to disconnect and exit..."));
         } else {
           done();
         }
@@ -16799,11 +16892,11 @@ async function startComputerServices(credentials) {
     });
   } finally {
     console.log();
-    console.log(chalk67.cyan("Stopping services..."));
+    console.log(chalk68.cyan("Stopping services..."));
     wsgidav.kill("SIGTERM");
     chrome.kill("SIGTERM");
     await stopNgrokTunnels();
-    console.log(chalk67.green("\u2713 Services stopped"));
+    console.log(chalk68.green("\u2713 Services stopped"));
   }
 }
 
@@ -16828,10 +16921,10 @@ async function getHeaders2() {
 function renderHelpText(text) {
   return text.replace(
     /\[([^\]]+)\]\(([^)]+)\)/g,
-    (_m, label, url) => `${label} (${chalk68.cyan(url)})`
-  ).replace(/\*\*([^*]+)\*\*/g, (_m, content) => chalk68.bold(content)).replace(
+    (_m, label, url) => `${label} (${chalk69.cyan(url)})`
+  ).replace(/\*\*([^*]+)\*\*/g, (_m, content) => chalk69.bold(content)).replace(
     /^> (.+)$/gm,
-    (_m, content) => chalk68.yellow(`  ${content}`)
+    (_m, content) => chalk69.yellow(`  ${content}`)
   );
 }
 async function connectViaApiToken(connectorType, tokenValue) {
@@ -16856,7 +16949,7 @@ async function connectViaApiToken(connectorType, tokenValue) {
     for (const [secretName, secretConfig] of secretEntries) {
       if (!secretConfig.required) continue;
       const value = await promptPassword(
-        `${secretConfig.label}${secretConfig.placeholder ? chalk68.dim(` (${secretConfig.placeholder})`) : ""}:`
+        `${secretConfig.label}${secretConfig.placeholder ? chalk69.dim(` (${secretConfig.placeholder})`) : ""}:`
       );
       if (!value) {
         throw new Error("Cancelled");
@@ -16872,13 +16965,13 @@ async function connectViaApiToken(connectorType, tokenValue) {
     });
   }
   console.log(
-    chalk68.green(`
+    chalk69.green(`
 \u2713 ${config.label} connected successfully via API token!`)
   );
 }
 async function connectComputer(apiUrl, headers) {
   await checkComputerDependencies();
-  console.log(chalk68.cyan("Setting up computer connector..."));
+  console.log(chalk69.cyan("Setting up computer connector..."));
   const computerClient = initClient13(computerConnectorContract, {
     baseUrl: apiUrl,
     baseHeaders: headers,
@@ -16893,9 +16986,9 @@ async function connectComputer(apiUrl, headers) {
   }
   const credentials = createResult.body;
   await startComputerServices(credentials);
-  console.log(chalk68.cyan("Disconnecting computer connector..."));
+  console.log(chalk69.cyan("Disconnecting computer connector..."));
   await deleteConnector("computer");
-  console.log(chalk68.green("\u2713 Disconnected computer"));
+  console.log(chalk69.green("\u2713 Disconnected computer"));
   process.exit(0);
 }
 async function resolveAuthMethod(connectorType, tokenFlag) {
@@ -16934,7 +17027,7 @@ async function resolveAuthMethod(connectorType, tokenFlag) {
   );
 }
 async function connectViaOAuth(connectorType, apiUrl, headers) {
-  console.log(`Connecting ${chalk68.cyan(connectorType)}...`);
+  console.log(`Connecting ${chalk69.cyan(connectorType)}...`);
   const sessionsClient = initClient13(connectorSessionsContract, {
     baseUrl: apiUrl,
     baseHeaders: headers,
@@ -16950,8 +17043,8 @@ async function connectViaOAuth(connectorType, apiUrl, headers) {
   }
   const session = createResult.body;
   const verificationUrl = `${apiUrl}${session.verificationUrl}`;
-  console.log(chalk68.green("\nSession created"));
-  console.log(chalk68.cyan(`
+  console.log(chalk69.green("\nSession created"));
+  console.log(chalk69.cyan(`
 To connect, visit: ${verificationUrl}`));
   console.log(
     `
@@ -16983,7 +17076,7 @@ The session expires in ${Math.floor(session.expiresIn / 60)} minutes.`
     switch (status.status) {
       case "complete":
         console.log(
-          chalk68.green(`
+          chalk69.green(`
 
 ${connectorType} connected successfully!`)
         );
@@ -16995,13 +17088,13 @@ ${connectorType} connected successfully!`)
           `Connection failed: ${status.errorMessage || "Unknown error"}`
         );
       case "pending":
-        process.stdout.write(chalk68.dim("."));
+        process.stdout.write(chalk69.dim("."));
         break;
     }
   }
   throw new Error("Session timed out, please try again");
 }
-var connectCommand = new Command76().name("connect").description("Connect a third-party service (e.g., GitHub)").argument("<type>", "Connector type (e.g., github)").option("--token <value>", "API token value (skip interactive prompt)").action(
+var connectCommand = new Command77().name("connect").description("Connect a third-party service (e.g., GitHub)").argument("<type>", "Connector type (e.g., github)").option("--token <value>", "API token value (skip interactive prompt)").action(
   withErrorHandler(async (type2, options) => {
     const parseResult = connectorTypeSchema.safeParse(type2);
     if (!parseResult.success) {
@@ -17026,9 +17119,9 @@ var connectCommand = new Command76().name("connect").description("Connect a thir
 );
 
 // src/commands/connector/list.ts
-import { Command as Command77 } from "commander";
-import chalk69 from "chalk";
-var listCommand11 = new Command77().name("list").alias("ls").description("List all connectors and their status").action(
+import { Command as Command78 } from "commander";
+import chalk70 from "chalk";
+var listCommand11 = new Command78().name("list").alias("ls").description("List all connectors and their status").action(
   withErrorHandler(async () => {
     const result = await listConnectors();
     const connectedMap = new Map(result.connectors.map((c24) => [c24.type, c24]));
@@ -17050,25 +17143,25 @@ var listCommand11 = new Command77().name("list").alias("ls").description("List a
       statusText.padEnd(statusWidth),
       "ACCOUNT"
     ].join("  ");
-    console.log(chalk69.dim(header));
+    console.log(chalk70.dim(header));
     for (const type2 of allTypes) {
       const connector = connectedMap.get(type2);
-      const status = connector ? chalk69.green("\u2713".padEnd(statusWidth)) : chalk69.dim("-".padEnd(statusWidth));
-      const account = connector?.externalUsername ? `@${connector.externalUsername}` : chalk69.dim("-");
+      const status = connector ? chalk70.green("\u2713".padEnd(statusWidth)) : chalk70.dim("-".padEnd(statusWidth));
+      const account = connector?.externalUsername ? `@${connector.externalUsername}` : chalk70.dim("-");
       const row = [type2.padEnd(typeWidth), status, account].join("  ");
       console.log(row);
     }
     console.log();
-    console.log(chalk69.dim("To connect a service:"));
-    console.log(chalk69.dim("  vm0 connector connect <type>"));
+    console.log(chalk70.dim("To connect a service:"));
+    console.log(chalk70.dim("  vm0 connector connect <type>"));
   })
 );
 
 // src/commands/connector/status.ts
-import { Command as Command78 } from "commander";
-import chalk70 from "chalk";
+import { Command as Command79 } from "commander";
+import chalk71 from "chalk";
 var LABEL_WIDTH = 16;
-var statusCommand8 = new Command78().name("status").description("Show detailed status of a connector").argument("<type>", "Connector type (e.g., github)").action(
+var statusCommand8 = new Command79().name("status").description("Show detailed status of a connector").argument("<type>", "Connector type (e.g., github)").action(
   withErrorHandler(async (type2) => {
     const parseResult = connectorTypeSchema.safeParse(type2);
     if (!parseResult.success) {
@@ -17078,11 +17171,11 @@ var statusCommand8 = new Command78().name("status").description("Show detailed s
       });
     }
     const connector = await getConnector(parseResult.data);
-    console.log(`Connector: ${chalk70.cyan(type2)}`);
+    console.log(`Connector: ${chalk71.cyan(type2)}`);
     console.log();
     if (connector) {
       console.log(
-        `${"Status:".padEnd(LABEL_WIDTH)}${chalk70.green("connected")}`
+        `${"Status:".padEnd(LABEL_WIDTH)}${chalk71.green("connected")}`
       );
       console.log(
         `${"Account:".padEnd(LABEL_WIDTH)}@${connector.externalUsername}`
@@ -17104,23 +17197,23 @@ var statusCommand8 = new Command78().name("status").description("Show detailed s
         );
       }
       console.log();
-      console.log(chalk70.dim("To disconnect:"));
-      console.log(chalk70.dim(`  vm0 connector disconnect ${type2}`));
+      console.log(chalk71.dim("To disconnect:"));
+      console.log(chalk71.dim(`  vm0 connector disconnect ${type2}`));
     } else {
       console.log(
-        `${"Status:".padEnd(LABEL_WIDTH)}${chalk70.dim("not connected")}`
+        `${"Status:".padEnd(LABEL_WIDTH)}${chalk71.dim("not connected")}`
       );
       console.log();
-      console.log(chalk70.dim("To connect:"));
-      console.log(chalk70.dim(`  vm0 connector connect ${type2}`));
+      console.log(chalk71.dim("To connect:"));
+      console.log(chalk71.dim(`  vm0 connector connect ${type2}`));
     }
   })
 );
 
 // src/commands/connector/disconnect.ts
-import { Command as Command79 } from "commander";
-import chalk71 from "chalk";
-var disconnectCommand = new Command79().name("disconnect").description("Disconnect a third-party service").argument("<type>", "Connector type to disconnect (e.g., github)").action(
+import { Command as Command80 } from "commander";
+import chalk72 from "chalk";
+var disconnectCommand = new Command80().name("disconnect").description("Disconnect a third-party service").argument("<type>", "Connector type to disconnect (e.g., github)").action(
   withErrorHandler(async (type2) => {
     const parseResult = connectorTypeSchema.safeParse(type2);
     if (!parseResult.success) {
@@ -17131,33 +17224,33 @@ var disconnectCommand = new Command79().name("disconnect").description("Disconne
     }
     const connectorType = parseResult.data;
     await deleteConnector(connectorType);
-    console.log(chalk71.green(`\u2713 Disconnected ${type2}`));
+    console.log(chalk72.green(`\u2713 Disconnected ${type2}`));
   })
 );
 
 // src/commands/connector/index.ts
-var connectorCommand = new Command80().name("connector").description("Manage third-party service connections").addCommand(listCommand11).addCommand(statusCommand8).addCommand(connectCommand).addCommand(disconnectCommand);
+var connectorCommand = new Command81().name("connector").description("Manage third-party service connections").addCommand(listCommand11).addCommand(statusCommand8).addCommand(connectCommand).addCommand(disconnectCommand);
 
 // src/commands/onboard/index.ts
-import { Command as Command81 } from "commander";
-import chalk75 from "chalk";
+import { Command as Command82 } from "commander";
+import chalk76 from "chalk";
 import { mkdir as mkdir8 } from "fs/promises";
 import { existsSync as existsSync12 } from "fs";
 
 // src/lib/ui/welcome-box.ts
-import chalk72 from "chalk";
+import chalk73 from "chalk";
 var gradientColors = [
-  chalk72.hex("#FFAB5E"),
+  chalk73.hex("#FFAB5E"),
   // Line 1 - lightest
-  chalk72.hex("#FF9642"),
+  chalk73.hex("#FF9642"),
   // Line 2
-  chalk72.hex("#FF8228"),
+  chalk73.hex("#FF8228"),
   // Line 3
-  chalk72.hex("#FF6D0A"),
+  chalk73.hex("#FF6D0A"),
   // Line 4
-  chalk72.hex("#E85D00"),
+  chalk73.hex("#E85D00"),
   // Line 5
-  chalk72.hex("#CC4E00")
+  chalk73.hex("#CC4E00")
   // Line 6 - darkest
 ];
 var vm0LogoLines = [
@@ -17179,15 +17272,15 @@ function renderVm0Banner() {
 function renderOnboardWelcome() {
   renderVm0Banner();
   console.log(`  Build agentic workflows using natural language.`);
-  console.log(`  ${chalk72.dim("Currently in beta, enjoy it free")}`);
+  console.log(`  ${chalk73.dim("Currently in beta, enjoy it free")}`);
   console.log(
-    `  ${chalk72.dim("Star us on GitHub: https://github.com/vm0-ai/vm0")}`
+    `  ${chalk73.dim("Star us on GitHub: https://github.com/vm0-ai/vm0")}`
   );
   console.log();
 }
 
 // src/lib/ui/step-runner.ts
-import chalk73 from "chalk";
+import chalk74 from "chalk";
 function createStepRunner(options = true) {
   const opts = typeof options === "boolean" ? { interactive: options } : options;
   const interactive = opts.interactive ?? true;
@@ -17202,25 +17295,25 @@ function createStepRunner(options = true) {
     }
     for (const [i, step] of completedSteps.entries()) {
       if (step.failed) {
-        console.log(chalk73.red(`\u2717 ${step.label}`));
+        console.log(chalk74.red(`\u2717 ${step.label}`));
       } else {
-        console.log(chalk73.green(`\u25CF ${step.label}`));
+        console.log(chalk74.green(`\u25CF ${step.label}`));
       }
       const isLastStep = i === completedSteps.length - 1;
       if (!isLastStep || !isFinal) {
-        console.log(chalk73.dim("\u2502"));
+        console.log(chalk74.dim("\u2502"));
       }
     }
   }
   async function executeStep(label, fn, isFinal) {
     let stepFailed = false;
-    console.log(chalk73.yellow(`\u25CB ${label}`));
+    console.log(chalk74.yellow(`\u25CB ${label}`));
     const ctx = {
       connector() {
-        console.log(chalk73.dim("\u2502"));
+        console.log(chalk74.dim("\u2502"));
       },
       detail(message) {
-        console.log(`${chalk73.dim("\u2502")} ${message}`);
+        console.log(`${chalk74.dim("\u2502")} ${message}`);
       },
       async prompt(promptFn) {
         return await promptFn();
@@ -17237,12 +17330,12 @@ function createStepRunner(options = true) {
         redrawCompletedSteps(isFinal);
       } else {
         if (stepFailed) {
-          console.log(chalk73.red(`\u2717 ${label}`));
+          console.log(chalk74.red(`\u2717 ${label}`));
         } else {
-          console.log(chalk73.green(`\u25CF ${label}`));
+          console.log(chalk74.green(`\u25CF ${label}`));
         }
         if (!isFinal) {
-          console.log(chalk73.dim("\u2502"));
+          console.log(chalk74.dim("\u2502"));
         }
       }
     }
@@ -17402,7 +17495,7 @@ async function setupModelProvider(type2, secret, options) {
 
 // src/lib/domain/onboard/claude-setup.ts
 import { spawn as spawn3 } from "child_process";
-import chalk74 from "chalk";
+import chalk75 from "chalk";
 var MARKETPLACE_NAME = "vm0-skills";
 var MARKETPLACE_REPO = "vm0-ai/vm0-skills";
 var PLUGIN_ID = "vm0@vm0-skills";
@@ -17439,12 +17532,12 @@ async function runClaudeCommand(args, cwd) {
 }
 function handlePluginError(error, context) {
   const displayContext = context ?? "Claude plugin";
-  console.error(chalk74.red(`\u2717 Failed to install ${displayContext}`));
+  console.error(chalk75.red(`\u2717 Failed to install ${displayContext}`));
   if (error instanceof Error) {
-    console.error(chalk74.red(`\u2717 ${error.message}`));
+    console.error(chalk75.red(`\u2717 ${error.message}`));
   }
   console.error(
-    chalk74.dim("Please ensure Claude CLI is installed and accessible.")
+    chalk75.dim("Please ensure Claude CLI is installed and accessible.")
   );
   process.exit(1);
 }
@@ -17487,7 +17580,7 @@ async function updateMarketplace() {
   ]);
   if (!result.success) {
     console.warn(
-      chalk74.yellow(
+      chalk75.yellow(
         `Warning: Could not update marketplace: ${result.error ?? "unknown error"}`
       )
     );
@@ -17533,9 +17626,9 @@ async function handleAuthentication(ctx) {
       onInitiating: () => {
       },
       onDeviceCodeReady: (url, code, expiresIn) => {
-        step.detail(`Copy code: ${chalk75.cyan.bold(code)}`);
-        step.detail(`Open: ${chalk75.cyan(url)}`);
-        step.detail(chalk75.dim(`Expires in ${expiresIn} minutes`));
+        step.detail(`Copy code: ${chalk76.cyan.bold(code)}`);
+        step.detail(`Open: ${chalk76.cyan(url)}`);
+        step.detail(chalk76.dim(`Expires in ${expiresIn} minutes`));
       },
       onPolling: () => {
       },
@@ -17575,14 +17668,14 @@ async function handleModelProvider(ctx) {
     const selectedChoice = choices.find((c24) => c24.type === providerType);
     if (selectedChoice?.helpText) {
       for (const line of selectedChoice.helpText.split("\n")) {
-        step.detail(chalk75.dim(line));
+        step.detail(chalk76.dim(line));
       }
     }
     const secret = await step.prompt(
       () => promptPassword(`Enter your ${selectedChoice?.secretLabel ?? "secret"}:`)
     );
     if (!secret) {
-      console.log(chalk75.dim("Cancelled"));
+      console.log(chalk76.dim("Cancelled"));
       process.exit(0);
     }
     let selectedModel;
@@ -17601,7 +17694,7 @@ async function handleModelProvider(ctx) {
         () => promptSelect("Select model:", modelChoices)
       );
       if (modelSelection === void 0) {
-        console.log(chalk75.dim("Cancelled"));
+        console.log(chalk76.dim("Cancelled"));
         process.exit(0);
       }
       selectedModel = modelSelection === "" ? void 0 : modelSelection;
@@ -17611,7 +17704,7 @@ async function handleModelProvider(ctx) {
     });
     const modelNote = result.provider.selectedModel ? ` with model: ${result.provider.selectedModel}` : "";
     step.detail(
-      chalk75.green(
+      chalk76.green(
         `${providerType} ${result.created ? "created" : "updated"}${result.isDefault ? ` (default for ${result.framework})` : ""}${modelNote}`
       )
     );
@@ -17642,7 +17735,7 @@ async function handleAgentCreation(ctx) {
         agentName = inputName;
         if (existsSync12(agentName)) {
           step.detail(
-            chalk75.yellow(`${agentName}/ already exists, choose another name`)
+            chalk76.yellow(`${agentName}/ already exists, choose another name`)
           );
         } else {
           folderExists = false;
@@ -17663,7 +17756,7 @@ async function handleAgentCreation(ctx) {
       }
     }
     await mkdir8(agentName, { recursive: true });
-    step.detail(chalk75.green(`Created ${agentName}/`));
+    step.detail(chalk76.green(`Created ${agentName}/`));
   });
   return agentName;
 }
@@ -17679,7 +17772,7 @@ async function handlePluginInstallation(ctx, agentName) {
       shouldInstall = confirmed ?? true;
     }
     if (!shouldInstall) {
-      step.detail(chalk75.dim("Skipped"));
+      step.detail(chalk76.dim("Skipped"));
       return;
     }
     const scope = "project";
@@ -17687,7 +17780,7 @@ async function handlePluginInstallation(ctx, agentName) {
       const agentDir = `${process.cwd()}/${agentName}`;
       const result = await installVm0Plugin(scope, agentDir);
       step.detail(
-        chalk75.green(`Installed ${result.pluginId} (scope: ${result.scope})`)
+        chalk76.green(`Installed ${result.pluginId} (scope: ${result.scope})`)
       );
       pluginInstalled = true;
     } catch (error) {
@@ -17698,18 +17791,18 @@ async function handlePluginInstallation(ctx, agentName) {
 }
 function printNextSteps(agentName, pluginInstalled) {
   console.log();
-  console.log(chalk75.bold("Next step:"));
+  console.log(chalk76.bold("Next step:"));
   console.log();
   if (pluginInstalled) {
     console.log(
-      `  ${chalk75.cyan(`cd ${agentName} && claude "/${PRIMARY_SKILL_NAME} let's build an agent"`)}`
+      `  ${chalk76.cyan(`cd ${agentName} && claude "/${PRIMARY_SKILL_NAME} let's build an agent"`)}`
     );
   } else {
-    console.log(`  ${chalk75.cyan(`cd ${agentName} && vm0 init`)}`);
+    console.log(`  ${chalk76.cyan(`cd ${agentName} && vm0 init`)}`);
   }
   console.log();
 }
-var onboardCommand = new Command81().name("onboard").description("Guided setup for new VM0 users").option("-y, --yes", "Skip confirmation prompts").option("--name <name>", `Agent name (default: ${DEFAULT_AGENT_NAME})`).action(
+var onboardCommand = new Command82().name("onboard").description("Guided setup for new VM0 users").option("-y, --yes", "Skip confirmation prompts").option("--name <name>", `Agent name (default: ${DEFAULT_AGENT_NAME})`).action(
   withErrorHandler(async (options) => {
     const interactive = isInteractive();
     if (interactive) {
@@ -17734,21 +17827,21 @@ var onboardCommand = new Command81().name("onboard").description("Guided setup f
 );
 
 // src/commands/setup-claude/index.ts
-import { Command as Command82 } from "commander";
-import chalk76 from "chalk";
-var setupClaudeCommand = new Command82().name("setup-claude").description("Install VM0 Claude Plugin").option("--agent-dir <dir>", "Agent directory to run install in").option("--scope <scope>", "Installation scope (user or project)", "project").action(
+import { Command as Command83 } from "commander";
+import chalk77 from "chalk";
+var setupClaudeCommand = new Command83().name("setup-claude").description("Install VM0 Claude Plugin").option("--agent-dir <dir>", "Agent directory to run install in").option("--scope <scope>", "Installation scope (user or project)", "project").action(
   withErrorHandler(async (options) => {
-    console.log(chalk76.dim("Installing VM0 Claude Plugin..."));
+    console.log(chalk77.dim("Installing VM0 Claude Plugin..."));
     const scope = options.scope === "user" ? "user" : "project";
     const result = await installVm0Plugin(scope, options.agentDir);
     console.log(
-      chalk76.green(`\u2713 Installed ${result.pluginId} (scope: ${result.scope})`)
+      chalk77.green(`\u2713 Installed ${result.pluginId} (scope: ${result.scope})`)
     );
     console.log();
     console.log("Next step:");
     const cdPrefix = options.agentDir ? `cd ${options.agentDir} && ` : "";
     console.log(
-      chalk76.cyan(
+      chalk77.cyan(
         `  ${cdPrefix}claude "/${PRIMARY_SKILL_NAME} let's build a workflow"`
       )
     );
@@ -17756,36 +17849,36 @@ var setupClaudeCommand = new Command82().name("setup-claude").description("Insta
 );
 
 // src/commands/dashboard/index.ts
-import { Command as Command83 } from "commander";
-import chalk77 from "chalk";
-var dashboardCommand = new Command83().name("dashboard").description("Quick reference for common query commands").action(() => {
+import { Command as Command84 } from "commander";
+import chalk78 from "chalk";
+var dashboardCommand = new Command84().name("dashboard").description("Quick reference for common query commands").action(() => {
   console.log();
-  console.log(chalk77.bold("VM0 Dashboard"));
+  console.log(chalk78.bold("VM0 Dashboard"));
   console.log();
-  console.log(chalk77.bold("Agents"));
-  console.log(chalk77.dim("  List agents:      ") + "vm0 agent list");
+  console.log(chalk78.bold("Agents"));
+  console.log(chalk78.dim("  List agents:      ") + "vm0 agent list");
   console.log();
-  console.log(chalk77.bold("Runs"));
-  console.log(chalk77.dim("  Recent runs:      ") + "vm0 run list");
-  console.log(chalk77.dim("  View run logs:    ") + "vm0 logs <run-id>");
+  console.log(chalk78.bold("Runs"));
+  console.log(chalk78.dim("  Recent runs:      ") + "vm0 run list");
+  console.log(chalk78.dim("  View run logs:    ") + "vm0 logs <run-id>");
   console.log();
-  console.log(chalk77.bold("Schedules"));
-  console.log(chalk77.dim("  List schedules:   ") + "vm0 schedule list");
+  console.log(chalk78.bold("Schedules"));
+  console.log(chalk78.dim("  List schedules:   ") + "vm0 schedule list");
   console.log();
-  console.log(chalk77.bold("Account"));
-  console.log(chalk77.dim("  Usage stats:      ") + "vm0 usage");
-  console.log(chalk77.dim("  List secrets:     ") + "vm0 secret list");
-  console.log(chalk77.dim("  List variables:   ") + "vm0 variable list");
+  console.log(chalk78.bold("Account"));
+  console.log(chalk78.dim("  Usage stats:      ") + "vm0 usage");
+  console.log(chalk78.dim("  List secrets:     ") + "vm0 secret list");
+  console.log(chalk78.dim("  List variables:   ") + "vm0 variable list");
   console.log();
   console.log(
-    chalk77.dim("Not logged in? Run: ") + chalk77.cyan("vm0 auth login")
+    chalk78.dim("Not logged in? Run: ") + chalk78.cyan("vm0 auth login")
   );
   console.log();
 });
 
 // src/commands/preference/index.ts
-import { Command as Command84 } from "commander";
-import chalk78 from "chalk";
+import { Command as Command85 } from "commander";
+import chalk79 from "chalk";
 function detectTimezone2() {
   return Intl.DateTimeFormat().resolvedOptions().timeZone;
 }
@@ -17806,15 +17899,15 @@ function parseOnOff(flag, value) {
   );
 }
 function displayPreferences(prefs) {
-  console.log(chalk78.bold("Current preferences:"));
+  console.log(chalk79.bold("Current preferences:"));
   console.log(
-    `  Timezone:      ${prefs.timezone ? chalk78.cyan(prefs.timezone) : chalk78.dim("not set")}`
+    `  Timezone:      ${prefs.timezone ? chalk79.cyan(prefs.timezone) : chalk79.dim("not set")}`
   );
   console.log(
-    `  Email notify:  ${prefs.notifyEmail ? chalk78.green("on") : chalk78.dim("off")}`
+    `  Email notify:  ${prefs.notifyEmail ? chalk79.green("on") : chalk79.dim("off")}`
   );
   console.log(
-    `  Slack notify:  ${prefs.notifySlack ? chalk78.green("on") : chalk78.dim("off")}`
+    `  Slack notify:  ${prefs.notifySlack ? chalk79.green("on") : chalk79.dim("off")}`
   );
 }
 function buildUpdates(opts) {
@@ -17844,21 +17937,21 @@ function buildUpdates(opts) {
 function printUpdateResult(updates, result) {
   if (updates.timezone !== void 0) {
     console.log(
-      chalk78.green(
-        `Timezone set to ${chalk78.cyan(result.timezone ?? updates.timezone)}`
+      chalk79.green(
+        `Timezone set to ${chalk79.cyan(result.timezone ?? updates.timezone)}`
       )
     );
   }
   if (updates.notifyEmail !== void 0) {
     console.log(
-      chalk78.green(
+      chalk79.green(
         `Email notifications ${result.notifyEmail ? "enabled" : "disabled"}`
       )
     );
   }
   if (updates.notifySlack !== void 0) {
     console.log(
-      chalk78.green(
+      chalk79.green(
         `Slack notifications ${result.notifySlack ? "enabled" : "disabled"}`
       )
     );
@@ -17867,7 +17960,7 @@ function printUpdateResult(updates, result) {
 async function interactiveSetup(prefs) {
   if (!prefs.timezone) {
     const detectedTz = detectTimezone2();
-    console.log(chalk78.dim(`
+    console.log(chalk79.dim(`
 System timezone detected: ${detectedTz}`));
     const tz = await promptText(
       "Set timezone? (enter timezone or leave empty to skip)",
@@ -17878,7 +17971,7 @@ System timezone detected: ${detectedTz}`));
         throw new Error(`Invalid timezone: ${tz.trim()}`);
       }
       await updateUserPreferences({ timezone: tz.trim() });
-      console.log(chalk78.green(`Timezone set to ${chalk78.cyan(tz.trim())}`));
+      console.log(chalk79.green(`Timezone set to ${chalk79.cyan(tz.trim())}`));
     }
   }
   if (!prefs.notifyEmail) {
@@ -17888,11 +17981,11 @@ System timezone detected: ${detectedTz}`));
     );
     if (enable) {
       await updateUserPreferences({ notifyEmail: true });
-      console.log(chalk78.green("Email notifications enabled"));
+      console.log(chalk79.green("Email notifications enabled"));
     }
   }
 }
-var preferenceCommand = new Command84().name("preference").description("View or update your preferences").option("--timezone <timezone>", "IANA timezone (e.g., America/New_York)").option("--notify-email <on|off>", "Enable or disable email notifications").option("--notify-slack <on|off>", "Enable or disable Slack notifications").action(
+var preferenceCommand = new Command85().name("preference").description("View or update your preferences").option("--timezone <timezone>", "IANA timezone (e.g., America/New_York)").option("--notify-email <on|off>", "Enable or disable email notifications").option("--notify-slack <on|off>", "Enable or disable Slack notifications").action(
   withErrorHandler(async (opts) => {
     const updates = buildUpdates(opts);
     if (updates) {
@@ -17907,32 +18000,32 @@ var preferenceCommand = new Command84().name("preference").description("View or
     } else if (!prefs.timezone) {
       console.log();
       console.log(
-        `To set timezone: ${chalk78.cyan("vm0 preference --timezone <timezone>")}`
+        `To set timezone: ${chalk79.cyan("vm0 preference --timezone <timezone>")}`
       );
       console.log(
-        chalk78.dim("Example: vm0 preference --timezone America/New_York")
+        chalk79.dim("Example: vm0 preference --timezone America/New_York")
       );
     }
   })
 );
 
 // src/commands/upgrade/index.ts
-import { Command as Command85 } from "commander";
-import chalk79 from "chalk";
-var upgradeCommand = new Command85().name("upgrade").description("Upgrade vm0 CLI to the latest version").action(
+import { Command as Command86 } from "commander";
+import chalk80 from "chalk";
+var upgradeCommand = new Command86().name("upgrade").description("Upgrade vm0 CLI to the latest version").action(
   withErrorHandler(async () => {
     console.log("Checking for updates...");
     const latestVersion = await getLatestVersion();
     if (latestVersion === null) {
       throw new Error("Could not check for updates. Please try again later.");
     }
-    if (latestVersion === "9.60.1") {
-      console.log(chalk79.green(`\u2713 Already up to date (${"9.60.1"})`));
+    if (latestVersion === "9.61.0") {
+      console.log(chalk80.green(`\u2713 Already up to date (${"9.61.0"})`));
       return;
     }
     console.log(
-      chalk79.yellow(
-        `Current version: ${"9.60.1"} -> Latest version: ${latestVersion}`
+      chalk80.yellow(
+        `Current version: ${"9.61.0"} -> Latest version: ${latestVersion}`
       )
     );
     console.log();
@@ -17940,26 +18033,26 @@ var upgradeCommand = new Command85().name("upgrade").description("Upgrade vm0 CL
     if (!isAutoUpgradeSupported(packageManager)) {
       if (packageManager === "unknown") {
         console.log(
-          chalk79.yellow(
+          chalk80.yellow(
             "Could not detect your package manager for auto-upgrade."
           )
         );
       } else {
         console.log(
-          chalk79.yellow(
+          chalk80.yellow(
             `Auto-upgrade is not supported for ${packageManager}.`
           )
         );
       }
-      console.log(chalk79.yellow("Please upgrade manually:"));
-      console.log(chalk79.cyan(`  ${getManualUpgradeCommand(packageManager)}`));
+      console.log(chalk80.yellow("Please upgrade manually:"));
+      console.log(chalk80.cyan(`  ${getManualUpgradeCommand(packageManager)}`));
       return;
     }
     console.log(`Upgrading via ${packageManager}...`);
     const success = await performUpgrade(packageManager);
     if (success) {
       console.log(
-        chalk79.green(`\u2713 Upgraded from ${"9.60.1"} to ${latestVersion}`)
+        chalk80.green(`\u2713 Upgraded from ${"9.61.0"} to ${latestVersion}`)
       );
       return;
     }
@@ -17972,8 +18065,8 @@ var upgradeCommand = new Command85().name("upgrade").description("Upgrade vm0 CL
 );
 
 // src/index.ts
-var program = new Command86();
-program.name("vm0").description("VM0 CLI - Build and run agents with natural language").version("9.60.1");
+var program = new Command87();
+program.name("vm0").description("VM0 CLI - Build and run agents with natural language").version("9.61.0");
 program.addCommand(authCommand);
 program.addCommand(infoCommand);
 program.addCommand(composeCommand);