@vm0/cli 9.77.1 → 9.78.0

package/index.js

@@ -47,7 +47,7 @@ if (DSN) {
   Sentry.init({
     dsn: DSN,
     environment: process.env.SENTRY_ENVIRONMENT ?? "production",
-    release: "9.77.1",
+    release: "9.78.0",
     sendDefaultPii: false,
     tracesSampleRate: 0,
     shutdownTimeout: 500,
@@ -66,7 +66,7 @@ if (DSN) {
     }
   });
   Sentry.setContext("cli", {
-    version: "9.77.1",
+    version: "9.78.0",
     command: process.argv.slice(2).join(" ")
   });
   Sentry.setContext("runtime", {
@@ -248,7 +248,7 @@ async function exchangeToken(apiUrl, deviceCode) {
   return response.json();
 }
 function delay(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function authenticate(apiUrl) {
   const targetApiUrl = apiUrl ?? await getApiUrl();
@@ -12544,23 +12544,23 @@ function validateRule(rule, permName, serviceName) {
       `Invalid rule "${rule}" in permission "${permName}" of firewall "${serviceName}": must be "METHOD /path"`
     );
   }
-  const [method, path18] = parts;
+  const [method, path17] = parts;
   if (!VALID_RULE_METHODS.has(method)) {
     throw new Error(
       `Invalid rule "${rule}" in permission "${permName}" of firewall "${serviceName}": unknown method "${method}" (must be uppercase)`
     );
   }
-  if (!path18.startsWith("/")) {
+  if (!path17.startsWith("/")) {
     throw new Error(
       `Invalid rule "${rule}" in permission "${permName}" of firewall "${serviceName}": path must start with "/"`
     );
   }
-  if (path18.includes("?") || path18.includes("#")) {
+  if (path17.includes("?") || path17.includes("#")) {
     throw new Error(
       `Invalid rule "${rule}" in permission "${permName}" of firewall "${serviceName}": path must not contain query string or fragment`
     );
   }
-  const segments = path18.split("/").filter(Boolean);
+  const segments = path17.split("/").filter(Boolean);
   const paramNames = /* @__PURE__ */ new Set();
   for (let i = 0; i < segments.length; i++) {
     const seg = segments[i];
@@ -12835,63 +12835,37 @@ var skillsResolveContract = c17.router({
   }
 });
 
-// ../../packages/core/src/contracts/required-env.ts
+// ../../packages/core/src/contracts/zero-agents.ts
 import { z as z26 } from "zod";
 var c18 = initContract();
-var agentRequiredEnvSchema = z26.object({
-  composeId: z26.string(),
-  agentName: z26.string(),
-  requiredSecrets: z26.array(z26.string()),
-  requiredVariables: z26.array(z26.string())
-});
-var requiredEnvContract = c18.router({
-  /**
-   * GET /api/agent/required-env
-   * Get required environment variables for user agents
-   */
-  getRequiredEnv: {
-    method: "GET",
-    path: "/api/agent/required-env",
-    headers: authHeadersSchema,
-    responses: {
-      200: z26.object({ agents: z26.array(agentRequiredEnvSchema) }),
-      401: apiErrorSchema
-    },
-    summary: "Get required environment variables for user agents"
-  }
-});
-
-// ../../packages/core/src/contracts/zero-agents.ts
-import { z as z27 } from "zod";
-var c19 = initContract();
-var zeroAgentResponseSchema = z27.object({
-  name: z27.string(),
-  agentComposeId: z27.string(),
-  description: z27.string().nullable(),
-  displayName: z27.string().nullable(),
-  sound: z27.string().nullable(),
-  connectors: z27.array(z27.string()),
+var zeroAgentResponseSchema = z26.object({
+  name: z26.string(),
+  agentComposeId: z26.string(),
+  description: z26.string().nullable(),
+  displayName: z26.string().nullable(),
+  sound: z26.string().nullable(),
+  connectors: z26.array(z26.string()),
   firewallPolicies: firewallPoliciesSchema.nullable()
 });
-var zeroAgentRequestSchema = z27.object({
-  description: z27.string().optional(),
-  displayName: z27.string().optional(),
-  sound: z27.string().optional(),
-  connectors: z27.array(z27.string())
+var zeroAgentRequestSchema = z26.object({
+  description: z26.string().optional(),
+  displayName: z26.string().optional(),
+  sound: z26.string().optional(),
+  connectors: z26.array(z26.string())
 });
-var zeroAgentMetadataRequestSchema = z27.object({
-  displayName: z27.string().optional(),
-  description: z27.string().optional(),
-  sound: z27.string().optional()
+var zeroAgentMetadataRequestSchema = z26.object({
+  displayName: z26.string().optional(),
+  description: z26.string().optional(),
+  sound: z26.string().optional()
 });
-var zeroAgentInstructionsResponseSchema = z27.object({
-  content: z27.string().nullable(),
-  filename: z27.string().nullable()
+var zeroAgentInstructionsResponseSchema = z26.object({
+  content: z26.string().nullable(),
+  filename: z26.string().nullable()
 });
-var zeroAgentInstructionsRequestSchema = z27.object({
-  content: z27.string()
+var zeroAgentInstructionsRequestSchema = z26.object({
+  content: z26.string()
 });
-var zeroAgentsMainContract = c19.router({
+var zeroAgentsMainContract = c18.router({
   create: {
     method: "POST",
     path: "/api/zero/agents",
@@ -12910,18 +12884,18 @@ var zeroAgentsMainContract = c19.router({
     path: "/api/zero/agents",
     headers: authHeadersSchema,
     responses: {
-      200: z27.array(zeroAgentResponseSchema),
+      200: z26.array(zeroAgentResponseSchema),
       401: apiErrorSchema
     },
     summary: "List zero agents"
   }
 });
-var zeroAgentsByNameContract = c19.router({
+var zeroAgentsByNameContract = c18.router({
   get: {
     method: "GET",
     path: "/api/zero/agents/:name",
     headers: authHeadersSchema,
-    pathParams: z27.object({ name: z27.string() }),
+    pathParams: z26.object({ name: z26.string() }),
     responses: {
       200: zeroAgentResponseSchema,
       401: apiErrorSchema,
@@ -12933,7 +12907,7 @@ var zeroAgentsByNameContract = c19.router({
     method: "PUT",
     path: "/api/zero/agents/:name",
     headers: authHeadersSchema,
-    pathParams: z27.object({ name: z27.string() }),
+    pathParams: z26.object({ name: z26.string() }),
     body: zeroAgentRequestSchema,
     responses: {
       200: zeroAgentResponseSchema,
@@ -12948,7 +12922,7 @@ var zeroAgentsByNameContract = c19.router({
     method: "PATCH",
     path: "/api/zero/agents/:name",
     headers: authHeadersSchema,
-    pathParams: z27.object({ name: z27.string() }),
+    pathParams: z26.object({ name: z26.string() }),
     body: zeroAgentMetadataRequestSchema,
     responses: {
       200: zeroAgentResponseSchema,
@@ -12961,21 +12935,21 @@ var zeroAgentsByNameContract = c19.router({
     method: "DELETE",
     path: "/api/zero/agents/:name",
     headers: authHeadersSchema,
-    pathParams: z27.object({ name: z27.string() }),
-    body: c19.noBody(),
+    pathParams: z26.object({ name: z26.string() }),
+    body: c18.noBody(),
     responses: {
-      204: c19.noBody(),
+      204: c18.noBody(),
       401: apiErrorSchema,
       404: apiErrorSchema
     },
     summary: "Delete zero agent by name"
   }
 });
-var zeroAgentFirewallPoliciesRequestSchema = z27.object({
-  name: z27.string(),
+var zeroAgentFirewallPoliciesRequestSchema = z26.object({
+  name: z26.string(),
   policies: firewallPoliciesSchema
 });
-var zeroAgentFirewallPoliciesContract = c19.router({
+var zeroAgentFirewallPoliciesContract = c18.router({
   update: {
     method: "PUT",
     path: "/api/zero/firewall-policies",
@@ -12991,12 +12965,12 @@ var zeroAgentFirewallPoliciesContract = c19.router({
     summary: "Update zero agent firewall policies (admin only)"
   }
 });
-var zeroAgentInstructionsContract = c19.router({
+var zeroAgentInstructionsContract = c18.router({
   get: {
     method: "GET",
     path: "/api/zero/agents/:name/instructions",
     headers: authHeadersSchema,
-    pathParams: z27.object({ name: z27.string() }),
+    pathParams: z26.object({ name: z26.string() }),
     responses: {
       200: zeroAgentInstructionsResponseSchema,
       401: apiErrorSchema,
@@ -13008,7 +12982,7 @@ var zeroAgentInstructionsContract = c19.router({
     method: "PUT",
     path: "/api/zero/agents/:name/instructions",
     headers: authHeadersSchema,
-    pathParams: z27.object({ name: z27.string() }),
+    pathParams: z26.object({ name: z26.string() }),
     body: zeroAgentInstructionsRequestSchema,
     responses: {
       200: zeroAgentResponseSchema,
@@ -13021,9 +12995,9 @@ var zeroAgentInstructionsContract = c19.router({
 });
 
 // ../../packages/core/src/contracts/zero-connectors.ts
-import { z as z28 } from "zod";
-var c20 = initContract();
-var zeroConnectorsMainContract = c20.router({
+import { z as z27 } from "zod";
+var c19 = initContract();
+var zeroConnectorsMainContract = c19.router({
   list: {
     method: "GET",
     path: "/api/zero/connectors",
@@ -13036,26 +13010,38 @@ var zeroConnectorsMainContract = c20.router({
     summary: "List all connectors (zero proxy)"
   }
 });
-var zeroConnectorsByTypeContract = c20.router({
+var zeroConnectorsByTypeContract = c19.router({
+  get: {
+    method: "GET",
+    path: "/api/zero/connectors/:type",
+    headers: authHeadersSchema,
+    pathParams: z27.object({ type: connectorTypeSchema }),
+    responses: {
+      200: connectorResponseSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Get connector by type (zero proxy)"
+  },
   delete: {
     method: "DELETE",
     path: "/api/zero/connectors/:type",
     headers: authHeadersSchema,
-    pathParams: z28.object({ type: connectorTypeSchema }),
+    pathParams: z27.object({ type: connectorTypeSchema }),
     responses: {
-      204: c20.noBody(),
+      204: c19.noBody(),
       401: apiErrorSchema,
       404: apiErrorSchema
     },
     summary: "Disconnect a connector (zero proxy)"
   }
 });
-var zeroConnectorScopeDiffContract = c20.router({
+var zeroConnectorScopeDiffContract = c19.router({
   getScopeDiff: {
     method: "GET",
     path: "/api/zero/connectors/:type/scope-diff",
     headers: authHeadersSchema,
-    pathParams: z28.object({ type: connectorTypeSchema }),
+    pathParams: z27.object({ type: connectorTypeSchema }),
     responses: {
       200: scopeDiffResponseSchema,
       401: apiErrorSchema,
@@ -13064,22 +13050,22 @@ var zeroConnectorScopeDiffContract = c20.router({
     summary: "Get scope diff for a connector"
   }
 });
-var connectorSearchAuthMethodSchema = z28.enum(["oauth", "api-token"]);
-var connectorSearchItemSchema = z28.object({
-  id: z28.string(),
-  label: z28.string(),
-  description: z28.string(),
-  authMethods: z28.array(connectorSearchAuthMethodSchema)
+var connectorSearchAuthMethodSchema = z27.enum(["oauth", "api-token"]);
+var connectorSearchItemSchema = z27.object({
+  id: z27.string(),
+  label: z27.string(),
+  description: z27.string(),
+  authMethods: z27.array(connectorSearchAuthMethodSchema)
 });
-var connectorSearchResponseSchema = z28.object({
-  connectors: z28.array(connectorSearchItemSchema)
+var connectorSearchResponseSchema = z27.object({
+  connectors: z27.array(connectorSearchItemSchema)
 });
-var zeroConnectorsSearchContract = c20.router({
+var zeroConnectorsSearchContract = c19.router({
   search: {
     method: "GET",
     path: "/api/zero/connectors/search",
     headers: authHeadersSchema,
-    query: z28.object({ keyword: z28.string().optional() }),
+    query: z27.object({ keyword: z27.string().optional() }),
     responses: {
       200: connectorSearchResponseSchema,
       401: apiErrorSchema
@@ -13087,11 +13073,81 @@ var zeroConnectorsSearchContract = c20.router({
     summary: "Search available connector types"
   }
 });
+var zeroConnectorSessionsContract = c19.router({
+  create: {
+    method: "POST",
+    path: "/api/zero/connectors/:type/sessions",
+    headers: authHeadersSchema,
+    pathParams: z27.object({ type: connectorTypeSchema }),
+    body: z27.object({}).optional(),
+    responses: {
+      200: connectorSessionResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema
+    },
+    summary: "Create connector session for device flow (zero proxy)"
+  }
+});
+var zeroConnectorSessionByIdContract = c19.router({
+  get: {
+    method: "GET",
+    path: "/api/zero/connectors/:type/sessions/:sessionId",
+    headers: authHeadersSchema,
+    pathParams: z27.object({
+      type: connectorTypeSchema,
+      sessionId: z27.uuid()
+    }),
+    responses: {
+      200: connectorSessionStatusResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Get connector session status (zero proxy)"
+  }
+});
+var zeroComputerConnectorContract = c19.router({
+  create: {
+    method: "POST",
+    path: "/api/zero/connectors/computer",
+    headers: authHeadersSchema,
+    body: z27.object({}).optional(),
+    responses: {
+      200: computerConnectorCreateResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      409: apiErrorSchema
+    },
+    summary: "Create computer connector (zero proxy)"
+  },
+  get: {
+    method: "GET",
+    path: "/api/zero/connectors/computer",
+    headers: authHeadersSchema,
+    responses: {
+      200: connectorResponseSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Get computer connector status (zero proxy)"
+  },
+  delete: {
+    method: "DELETE",
+    path: "/api/zero/connectors/computer",
+    headers: authHeadersSchema,
+    responses: {
+      204: c19.noBody(),
+      401: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Delete computer connector (zero proxy)"
+  }
+});
 
 // ../../packages/core/src/contracts/zero-org.ts
-import { z as z29 } from "zod";
-var c21 = initContract();
-var zeroOrgContract = c21.router({
+import { z as z28 } from "zod";
+var c20 = initContract();
+var zeroOrgContract = c20.router({
   get: {
     method: "GET",
     path: "/api/zero/org",
@@ -13120,12 +13176,12 @@ var zeroOrgContract = c21.router({
     summary: "Update org slug (zero proxy)"
   }
 });
-var zeroOrgLeaveContract = c21.router({
+var zeroOrgLeaveContract = c20.router({
   leave: {
     method: "POST",
     path: "/api/zero/org/leave",
     headers: authHeadersSchema,
-    body: z29.object({}),
+    body: z28.object({}),
     responses: {
       200: orgMessageResponseSchema,
       401: apiErrorSchema,
@@ -13135,12 +13191,12 @@ var zeroOrgLeaveContract = c21.router({
     summary: "Leave the current org (zero proxy)"
   }
 });
-var zeroOrgDeleteContract = c21.router({
+var zeroOrgDeleteContract = c20.router({
   delete: {
     method: "POST",
     path: "/api/zero/org/delete",
     headers: authHeadersSchema,
-    body: z29.object({ slug: z29.string() }),
+    body: z28.object({ slug: z28.string() }),
     responses: {
       200: orgMessageResponseSchema,
       400: apiErrorSchema,
@@ -13153,8 +13209,8 @@ var zeroOrgDeleteContract = c21.router({
 });
 
 // ../../packages/core/src/contracts/zero-org-list.ts
-var c22 = initContract();
-var zeroOrgListContract = c22.router({
+var c21 = initContract();
+var zeroOrgListContract = c21.router({
   list: {
     method: "GET",
     path: "/api/zero/org/list",
@@ -13169,8 +13225,8 @@ var zeroOrgListContract = c22.router({
 });
 
 // ../../packages/core/src/contracts/zero-org-members.ts
-var c23 = initContract();
-var zeroOrgMembersContract = c23.router({
+var c22 = initContract();
+var zeroOrgMembersContract = c22.router({
   members: {
     method: "GET",
     path: "/api/zero/org/members",
@@ -13214,7 +13270,7 @@ var zeroOrgMembersContract = c23.router({
     summary: "Remove a member from the org (zero proxy)"
   }
 });
-var zeroOrgInviteContract = c23.router({
+var zeroOrgInviteContract = c22.router({
   invite: {
     method: "POST",
     path: "/api/zero/org/invite",
@@ -13232,16 +13288,16 @@ var zeroOrgInviteContract = c23.router({
 });
 
 // ../../packages/core/src/contracts/zero-composes.ts
-import { z as z30 } from "zod";
-var c24 = initContract();
-var zeroComposesMainContract = c24.router({
+import { z as z29 } from "zod";
+var c23 = initContract();
+var zeroComposesMainContract = c23.router({
   getByName: {
     method: "GET",
     path: "/api/zero/composes",
     headers: authHeadersSchema,
-    query: z30.object({
-      name: z30.string().min(1, "Missing name query parameter"),
-      org: z30.string().optional()
+    query: z29.object({
+      name: z29.string().min(1, "Missing name query parameter"),
+      org: z29.string().optional()
     }),
     responses: {
       200: composeResponseSchema,
@@ -13252,13 +13308,13 @@ var zeroComposesMainContract = c24.router({
     summary: "Get agent compose by name (zero proxy)"
   }
 });
-var zeroComposesByIdContract = c24.router({
+var zeroComposesByIdContract = c23.router({
   getById: {
     method: "GET",
     path: "/api/zero/composes/:id",
     headers: authHeadersSchema,
-    pathParams: z30.object({
-      id: z30.string().min(1, "Compose ID is required")
+    pathParams: z29.object({
+      id: z29.string().min(1, "Compose ID is required")
     }),
     responses: {
       200: composeResponseSchema,
@@ -13272,12 +13328,12 @@ var zeroComposesByIdContract = c24.router({
     method: "DELETE",
     path: "/api/zero/composes/:id",
     headers: authHeadersSchema,
-    pathParams: z30.object({
-      id: z30.string().uuid("Compose ID is required")
+    pathParams: z29.object({
+      id: z29.string().uuid("Compose ID is required")
     }),
-    body: c24.noBody(),
+    body: c23.noBody(),
     responses: {
-      204: c24.noBody(),
+      204: c23.noBody(),
       401: apiErrorSchema,
       403: apiErrorSchema,
       404: apiErrorSchema,
@@ -13286,17 +13342,17 @@ var zeroComposesByIdContract = c24.router({
     summary: "Delete agent compose (zero proxy)"
   }
 });
-var zeroComposesListContract = c24.router({
+var zeroComposesListContract = c23.router({
   list: {
     method: "GET",
     path: "/api/zero/composes/list",
     headers: authHeadersSchema,
-    query: z30.object({
-      org: z30.string().optional()
+    query: z29.object({
+      org: z29.string().optional()
     }),
     responses: {
-      200: z30.object({
-        composes: z30.array(composeListItemSchema)
+      200: z29.object({
+        composes: z29.array(composeListItemSchema)
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -13307,7 +13363,7 @@ var zeroComposesListContract = c24.router({
 });
 
 // ../../packages/core/src/contracts/zero-runs.ts
-import { z as z31 } from "zod";
+import { z as z30 } from "zod";
 var zeroRunRequestSchema = unifiedRunRequestSchema.omit({
   triggerSource: true,
   memoryName: true,
@@ -13318,8 +13374,8 @@ var zeroRunRequestSchema = unifiedRunRequestSchema.omit({
   vars: true,
   secrets: true
 });
-var c25 = initContract();
-var zeroRunsMainContract = c25.router({
+var c24 = initContract();
+var zeroRunsMainContract = c24.router({
   create: {
     method: "POST",
     path: "/api/zero/runs",
@@ -13335,13 +13391,13 @@ var zeroRunsMainContract = c25.router({
     summary: "Create and execute agent run (zero proxy)"
   }
 });
-var zeroRunsByIdContract = c25.router({
+var zeroRunsByIdContract = c24.router({
   getById: {
     method: "GET",
     path: "/api/zero/runs/:id",
     headers: authHeadersSchema,
-    pathParams: z31.object({
-      id: z31.string().min(1, "Run ID is required")
+    pathParams: z30.object({
+      id: z30.string().min(1, "Run ID is required")
     }),
     responses: {
       200: getRunResponseSchema,
@@ -13352,15 +13408,15 @@ var zeroRunsByIdContract = c25.router({
     summary: "Get agent run by ID (zero proxy)"
   }
 });
-var zeroRunsCancelContract = c25.router({
+var zeroRunsCancelContract = c24.router({
   cancel: {
     method: "POST",
     path: "/api/zero/runs/:id/cancel",
     headers: authHeadersSchema,
-    pathParams: z31.object({
-      id: z31.string().min(1, "Run ID is required")
+    pathParams: z30.object({
+      id: z30.string().min(1, "Run ID is required")
     }),
-    body: z31.undefined(),
+    body: z30.undefined(),
     responses: {
       200: cancelRunResponseSchema,
       400: apiErrorSchema,
@@ -13371,7 +13427,7 @@ var zeroRunsCancelContract = c25.router({
     summary: "Cancel a pending or running run (zero proxy)"
   }
 });
-var zeroRunsQueueContract = c25.router({
+var zeroRunsQueueContract = c24.router({
   getQueue: {
     method: "GET",
     path: "/api/zero/runs/queue",
@@ -13384,18 +13440,18 @@ var zeroRunsQueueContract = c25.router({
     summary: "Get org run queue status (zero proxy)"
   }
 });
-var zeroRunAgentEventsContract = c25.router({
+var zeroRunAgentEventsContract = c24.router({
   getAgentEvents: {
     method: "GET",
     path: "/api/zero/runs/:id/telemetry/agent",
     headers: authHeadersSchema,
-    pathParams: z31.object({
-      id: z31.string().min(1, "Run ID is required")
+    pathParams: z30.object({
+      id: z30.string().min(1, "Run ID is required")
     }),
-    query: z31.object({
-      since: z31.coerce.number().optional(),
-      limit: z31.coerce.number().min(1).max(100).default(5),
-      order: z31.enum(["asc", "desc"]).default("desc")
+    query: z30.object({
+      since: z30.coerce.number().optional(),
+      limit: z30.coerce.number().min(1).max(100).default(5),
+      order: z30.enum(["asc", "desc"]).default("desc")
     }),
     responses: {
       200: agentEventsResponseSchema,
@@ -13407,62 +13463,62 @@ var zeroRunAgentEventsContract = c25.router({
 });
 
 // ../../packages/core/src/contracts/zero-schedules.ts
-import { z as z32 } from "zod";
-var c26 = initContract();
-var scheduleResponseSchema = z32.object({
-  id: z32.string().uuid(),
-  zeroAgentId: z32.string().uuid(),
-  agentName: z32.string(),
-  orgSlug: z32.string(),
-  userId: z32.string(),
-  name: z32.string(),
-  triggerType: z32.enum(["cron", "once", "loop"]),
-  cronExpression: z32.string().nullable(),
-  atTime: z32.string().nullable(),
-  intervalSeconds: z32.number().nullable(),
-  timezone: z32.string(),
-  prompt: z32.string(),
-  description: z32.string().nullable(),
-  appendSystemPrompt: z32.string().nullable(),
-  vars: z32.record(z32.string(), z32.string()).nullable(),
-  secretNames: z32.array(z32.string()).nullable(),
-  artifactName: z32.string().nullable(),
-  artifactVersion: z32.string().nullable(),
-  volumeVersions: z32.record(z32.string(), z32.string()).nullable(),
-  enabled: z32.boolean(),
-  notifyEmail: z32.boolean(),
-  notifySlack: z32.boolean(),
-  nextRunAt: z32.string().nullable(),
-  lastRunAt: z32.string().nullable(),
-  retryStartedAt: z32.string().nullable(),
-  consecutiveFailures: z32.number(),
-  createdAt: z32.string(),
-  updatedAt: z32.string()
+import { z as z31 } from "zod";
+var c25 = initContract();
+var scheduleResponseSchema = z31.object({
+  id: z31.string().uuid(),
+  zeroAgentId: z31.string().uuid(),
+  agentName: z31.string(),
+  orgSlug: z31.string(),
+  userId: z31.string(),
+  name: z31.string(),
+  triggerType: z31.enum(["cron", "once", "loop"]),
+  cronExpression: z31.string().nullable(),
+  atTime: z31.string().nullable(),
+  intervalSeconds: z31.number().nullable(),
+  timezone: z31.string(),
+  prompt: z31.string(),
+  description: z31.string().nullable(),
+  appendSystemPrompt: z31.string().nullable(),
+  vars: z31.record(z31.string(), z31.string()).nullable(),
+  secretNames: z31.array(z31.string()).nullable(),
+  artifactName: z31.string().nullable(),
+  artifactVersion: z31.string().nullable(),
+  volumeVersions: z31.record(z31.string(), z31.string()).nullable(),
+  enabled: z31.boolean(),
+  notifyEmail: z31.boolean(),
+  notifySlack: z31.boolean(),
+  nextRunAt: z31.string().nullable(),
+  lastRunAt: z31.string().nullable(),
+  retryStartedAt: z31.string().nullable(),
+  consecutiveFailures: z31.number(),
+  createdAt: z31.string(),
+  updatedAt: z31.string()
 });
-var scheduleListResponseSchema = z32.object({
-  schedules: z32.array(scheduleResponseSchema)
+var scheduleListResponseSchema = z31.object({
+  schedules: z31.array(scheduleResponseSchema)
 });
-var deployScheduleResponseSchema = z32.object({
+var deployScheduleResponseSchema = z31.object({
   schedule: scheduleResponseSchema,
-  created: z32.boolean()
+  created: z31.boolean()
 });
-var zeroDeployScheduleRequestSchema = z32.object({
-  name: z32.string().min(1).max(64, "Schedule name max 64 chars"),
-  cronExpression: z32.string().optional(),
-  atTime: z32.string().optional(),
-  intervalSeconds: z32.number().int().min(0).optional(),
-  timezone: z32.string().default("UTC"),
-  prompt: z32.string().min(1, "Prompt required"),
-  description: z32.string().optional(),
-  appendSystemPrompt: z32.string().optional(),
-  artifactName: z32.string().optional(),
-  artifactVersion: z32.string().optional(),
-  volumeVersions: z32.record(z32.string(), z32.string()).optional(),
-  zeroAgentId: z32.string().uuid("Invalid agent ID").optional(),
-  composeId: z32.string().uuid("Invalid compose ID").optional(),
-  enabled: z32.boolean().optional(),
-  notifyEmail: z32.boolean().optional(),
-  notifySlack: z32.boolean().optional()
+var zeroDeployScheduleRequestSchema = z31.object({
+  name: z31.string().min(1).max(64, "Schedule name max 64 chars"),
+  cronExpression: z31.string().optional(),
+  atTime: z31.string().optional(),
+  intervalSeconds: z31.number().int().min(0).optional(),
+  timezone: z31.string().default("UTC"),
+  prompt: z31.string().min(1, "Prompt required"),
+  description: z31.string().optional(),
+  appendSystemPrompt: z31.string().optional(),
+  artifactName: z31.string().optional(),
+  artifactVersion: z31.string().optional(),
+  volumeVersions: z31.record(z31.string(), z31.string()).optional(),
+  zeroAgentId: z31.string().uuid("Invalid agent ID").optional(),
+  composeId: z31.string().uuid("Invalid compose ID").optional(),
+  enabled: z31.boolean().optional(),
+  notifyEmail: z31.boolean().optional(),
+  notifySlack: z31.boolean().optional()
 }).refine((data) => Boolean(data.zeroAgentId ?? data.composeId), {
   message: "Either 'zeroAgentId' or 'composeId' must be provided"
 }).refine(
@@ -13478,7 +13534,7 @@ var zeroDeployScheduleRequestSchema = z32.object({
     message: "Exactly one of 'cronExpression', 'atTime', or 'intervalSeconds' must be specified"
   }
 );
-var zeroSchedulesMainContract = c26.router({
+var zeroSchedulesMainContract = c25.router({
   deploy: {
     method: "POST",
     path: "/api/zero/schedules",
@@ -13506,22 +13562,22 @@ var zeroSchedulesMainContract = c26.router({
     summary: "List all schedules (zero proxy)"
   }
 });
-var zeroSchedulesByNameContract = c26.router({
+var zeroSchedulesByNameContract = c25.router({
   delete: {
     method: "DELETE",
     path: "/api/zero/schedules/:name",
     headers: authHeadersSchema,
-    pathParams: z32.object({
-      name: z32.string().min(1, "Schedule name required")
+    pathParams: z31.object({
+      name: z31.string().min(1, "Schedule name required")
     }),
-    query: z32.object({
-      zeroAgentId: z32.string().uuid("Invalid agent ID").optional(),
-      composeId: z32.string().uuid("Invalid compose ID").optional()
+    query: z31.object({
+      zeroAgentId: z31.string().uuid("Invalid agent ID").optional(),
+      composeId: z31.string().uuid("Invalid compose ID").optional()
     }).refine((data) => Boolean(data.zeroAgentId ?? data.composeId), {
       message: "Either 'zeroAgentId' or 'composeId' must be provided"
     }),
     responses: {
-      204: c26.noBody(),
+      204: c25.noBody(),
       401: apiErrorSchema,
       403: apiErrorSchema,
       404: apiErrorSchema
@@ -13529,17 +13585,17 @@ var zeroSchedulesByNameContract = c26.router({
     summary: "Delete schedule (zero proxy)"
   }
 });
-var zeroSchedulesEnableContract = c26.router({
+var zeroSchedulesEnableContract = c25.router({
   enable: {
     method: "POST",
     path: "/api/zero/schedules/:name/enable",
     headers: authHeadersSchema,
-    pathParams: z32.object({
-      name: z32.string().min(1, "Schedule name required")
+    pathParams: z31.object({
+      name: z31.string().min(1, "Schedule name required")
     }),
-    body: z32.object({
-      zeroAgentId: z32.string().uuid("Invalid agent ID").optional(),
-      composeId: z32.string().uuid("Invalid compose ID").optional()
+    body: z31.object({
+      zeroAgentId: z31.string().uuid("Invalid agent ID").optional(),
+      composeId: z31.string().uuid("Invalid compose ID").optional()
     }).refine((data) => Boolean(data.zeroAgentId ?? data.composeId), {
       message: "Either 'zeroAgentId' or 'composeId' must be provided"
     }),
@@ -13556,12 +13612,12 @@ var zeroSchedulesEnableContract = c26.router({
     method: "POST",
     path: "/api/zero/schedules/:name/disable",
     headers: authHeadersSchema,
-    pathParams: z32.object({
-      name: z32.string().min(1, "Schedule name required")
+    pathParams: z31.object({
+      name: z31.string().min(1, "Schedule name required")
     }),
-    body: z32.object({
-      zeroAgentId: z32.string().uuid("Invalid agent ID").optional(),
-      composeId: z32.string().uuid("Invalid compose ID").optional()
+    body: z31.object({
+      zeroAgentId: z31.string().uuid("Invalid agent ID").optional(),
+      composeId: z31.string().uuid("Invalid compose ID").optional()
     }).refine((data) => Boolean(data.zeroAgentId ?? data.composeId), {
       message: "Either 'zeroAgentId' or 'composeId' must be provided"
     }),
@@ -13577,9 +13633,9 @@ var zeroSchedulesEnableContract = c26.router({
 });
 
 // ../../packages/core/src/contracts/zero-model-providers.ts
-import { z as z33 } from "zod";
-var c27 = initContract();
-var zeroModelProvidersMainContract = c27.router({
+import { z as z32 } from "zod";
+var c26 = initContract();
+var zeroModelProvidersMainContract = c26.router({
   list: {
     method: "GET",
     path: "/api/zero/model-providers",
@@ -13607,16 +13663,16 @@ var zeroModelProvidersMainContract = c27.router({
     summary: "Create or update an org-level model provider (admin only)"
   }
 });
-var zeroModelProvidersByTypeContract = c27.router({
+var zeroModelProvidersByTypeContract = c26.router({
   delete: {
     method: "DELETE",
     path: "/api/zero/model-providers/:type",
     headers: authHeadersSchema,
-    pathParams: z33.object({
+    pathParams: z32.object({
       type: modelProviderTypeSchema
     }),
     responses: {
-      204: c27.noBody(),
+      204: c26.noBody(),
       401: apiErrorSchema,
       403: apiErrorSchema,
       404: apiErrorSchema,
@@ -13625,15 +13681,15 @@ var zeroModelProvidersByTypeContract = c27.router({
     summary: "Delete an org-level model provider (admin only)"
   }
 });
-var zeroModelProvidersDefaultContract = c27.router({
+var zeroModelProvidersDefaultContract = c26.router({
   setDefault: {
     method: "POST",
     path: "/api/zero/model-providers/:type/default",
     headers: authHeadersSchema,
-    pathParams: z33.object({
+    pathParams: z32.object({
       type: modelProviderTypeSchema
     }),
-    body: z33.undefined(),
+    body: z32.undefined(),
     responses: {
       200: modelProviderResponseSchema,
       401: apiErrorSchema,
@@ -13644,12 +13700,12 @@ var zeroModelProvidersDefaultContract = c27.router({
     summary: "Set org-level model provider as default (admin only)"
   }
 });
-var zeroModelProvidersUpdateModelContract = c27.router({
+var zeroModelProvidersUpdateModelContract = c26.router({
   updateModel: {
     method: "PATCH",
     path: "/api/zero/model-providers/:type/model",
     headers: authHeadersSchema,
-    pathParams: z33.object({
+    pathParams: z32.object({
       type: modelProviderTypeSchema
     }),
     body: updateModelRequestSchema,
@@ -13665,8 +13721,8 @@ var zeroModelProvidersUpdateModelContract = c27.router({
 });
 
 // ../../packages/core/src/contracts/zero-user-preferences.ts
-var c28 = initContract();
-var zeroUserPreferencesContract = c28.router({
+var c27 = initContract();
+var zeroUserPreferencesContract = c27.router({
   get: {
     method: "GET",
     path: "/api/zero/user-preferences",
@@ -13694,9 +13750,9 @@ var zeroUserPreferencesContract = c28.router({
 });
 
 // ../../packages/core/src/contracts/zero-secrets.ts
-import { z as z34 } from "zod";
-var c29 = initContract();
-var zeroSecretsContract = c29.router({
+import { z as z33 } from "zod";
+var c28 = initContract();
+var zeroSecretsContract = c28.router({
   list: {
     method: "GET",
     path: "/api/zero/secrets",
@@ -13723,16 +13779,16 @@ var zeroSecretsContract = c29.router({
     summary: "Create or update a secret"
   }
 });
-var zeroSecretsByNameContract = c29.router({
+var zeroSecretsByNameContract = c28.router({
   delete: {
     method: "DELETE",
     path: "/api/zero/secrets/:name",
     headers: authHeadersSchema,
-    pathParams: z34.object({
+    pathParams: z33.object({
       name: secretNameSchema
     }),
     responses: {
-      204: c29.noBody(),
+      204: c28.noBody(),
       401: apiErrorSchema,
       404: apiErrorSchema,
       500: apiErrorSchema
@@ -13740,7 +13796,7 @@ var zeroSecretsByNameContract = c29.router({
     summary: "Delete a secret by name"
   }
 });
-var zeroVariablesContract = c29.router({
+var zeroVariablesContract = c28.router({
   list: {
     method: "GET",
     path: "/api/zero/variables",
@@ -13767,16 +13823,16 @@ var zeroVariablesContract = c29.router({
     summary: "Create or update a variable"
   }
 });
-var zeroVariablesByNameContract = c29.router({
+var zeroVariablesByNameContract = c28.router({
   delete: {
     method: "DELETE",
     path: "/api/zero/variables/:name",
     headers: authHeadersSchema,
-    pathParams: z34.object({
+    pathParams: z33.object({
       name: variableNameSchema
     }),
     responses: {
-      204: c29.noBody(),
+      204: c28.noBody(),
       401: apiErrorSchema,
       404: apiErrorSchema,
       500: apiErrorSchema
@@ -13786,15 +13842,15 @@ var zeroVariablesByNameContract = c29.router({
 });
 
 // ../../packages/core/src/contracts/zero-sessions.ts
-import { z as z35 } from "zod";
-var c30 = initContract();
-var zeroSessionsByIdContract = c30.router({
+import { z as z34 } from "zod";
+var c29 = initContract();
+var zeroSessionsByIdContract = c29.router({
   getById: {
     method: "GET",
     path: "/api/zero/sessions/:id",
     headers: authHeadersSchema,
-    pathParams: z35.object({
-      id: z35.string().min(1, "Session ID is required")
+    pathParams: z34.object({
+      id: z34.string().min(1, "Session ID is required")
     }),
     responses: {
       200: sessionResponseSchema,
@@ -13807,24 +13863,24 @@ var zeroSessionsByIdContract = c30.router({
 });
 
 // ../../packages/core/src/contracts/integrations.ts
-import { z as z36 } from "zod";
-var c31 = initContract();
-var integrationsSlackMessageContract = c31.router({
+import { z as z35 } from "zod";
+var c30 = initContract();
+var integrationsSlackMessageContract = c30.router({
   sendMessage: {
     method: "POST",
-    path: "/api/agent/integrations/slack/message",
+    path: "/api/zero/integrations/slack/message",
     headers: authHeadersSchema,
-    body: z36.object({
-      channel: z36.string().min(1, "Channel ID is required"),
-      text: z36.string().optional(),
-      threadTs: z36.string().optional(),
-      blocks: z36.array(z36.object({ type: z36.string() }).passthrough()).optional()
+    body: z35.object({
+      channel: z35.string().min(1, "Channel ID is required"),
+      text: z35.string().optional(),
+      threadTs: z35.string().optional(),
+      blocks: z35.array(z35.object({ type: z35.string() }).passthrough()).optional()
     }),
     responses: {
-      200: z36.object({
-        ok: z36.literal(true),
-        ts: z36.string().optional(),
-        channel: z36.string().optional()
+      200: z35.object({
+        ok: z35.literal(true),
+        ts: z35.string().optional(),
+        channel: z35.string().optional()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -13836,41 +13892,41 @@ var integrationsSlackMessageContract = c31.router({
 });
 
 // ../../packages/core/src/contracts/zero-billing.ts
-import { z as z37 } from "zod";
-var c32 = initContract();
-var autoRechargeSchema = z37.object({
-  enabled: z37.boolean(),
-  threshold: z37.number().nullable(),
-  amount: z37.number().nullable()
+import { z as z36 } from "zod";
+var c31 = initContract();
+var autoRechargeSchema = z36.object({
+  enabled: z36.boolean(),
+  threshold: z36.number().nullable(),
+  amount: z36.number().nullable()
 });
-var billingStatusResponseSchema = z37.object({
-  tier: z37.string(),
-  credits: z37.number(),
-  subscriptionStatus: z37.string().nullable(),
-  currentPeriodEnd: z37.string().nullable(),
-  hasSubscription: z37.boolean(),
+var billingStatusResponseSchema = z36.object({
+  tier: z36.string(),
+  credits: z36.number(),
+  subscriptionStatus: z36.string().nullable(),
+  currentPeriodEnd: z36.string().nullable(),
+  hasSubscription: z36.boolean(),
   autoRecharge: autoRechargeSchema
 });
-var checkoutResponseSchema = z37.object({
-  url: z37.string()
+var checkoutResponseSchema = z36.object({
+  url: z36.string()
 });
-var portalResponseSchema = z37.object({
-  url: z37.string()
+var portalResponseSchema = z36.object({
+  url: z36.string()
 });
-var checkoutRequestSchema = z37.object({
-  tier: z37.enum(["pro", "team"]),
-  successUrl: z37.string().url(),
-  cancelUrl: z37.string().url()
+var checkoutRequestSchema = z36.object({
+  tier: z36.enum(["pro", "team"]),
+  successUrl: z36.string().url(),
+  cancelUrl: z36.string().url()
 });
-var portalRequestSchema = z37.object({
-  returnUrl: z37.string().min(1)
+var portalRequestSchema = z36.object({
+  returnUrl: z36.string().min(1)
 });
-var autoRechargeUpdateRequestSchema = z37.object({
-  enabled: z37.boolean(),
-  threshold: z37.number().int().positive().optional(),
-  amount: z37.number().int().min(1e3).optional()
+var autoRechargeUpdateRequestSchema = z36.object({
+  enabled: z36.boolean(),
+  threshold: z36.number().int().positive().optional(),
+  amount: z36.number().int().min(1e3).optional()
 });
-var zeroBillingStatusContract = c32.router({
+var zeroBillingStatusContract = c31.router({
   get: {
     method: "GET",
     path: "/api/zero/billing/status",
@@ -13883,7 +13939,7 @@ var zeroBillingStatusContract = c32.router({
     summary: "Get billing status for current org"
   }
 });
-var zeroBillingCheckoutContract = c32.router({
+var zeroBillingCheckoutContract = c31.router({
   create: {
     method: "POST",
     path: "/api/zero/billing/checkout",
@@ -13899,7 +13955,7 @@ var zeroBillingCheckoutContract = c32.router({
     summary: "Create Stripe checkout session"
   }
 });
-var zeroBillingPortalContract = c32.router({
+var zeroBillingPortalContract = c31.router({
   create: {
     method: "POST",
     path: "/api/zero/billing/portal",
@@ -13915,7 +13971,7 @@ var zeroBillingPortalContract = c32.router({
     summary: "Create Stripe billing portal session"
   }
 });
-var zeroBillingAutoRechargeContract = c32.router({
+var zeroBillingAutoRechargeContract = c31.router({
   get: {
     method: "GET",
     path: "/api/zero/billing/auto-recharge",
@@ -13944,25 +14000,25 @@ var zeroBillingAutoRechargeContract = c32.router({
 });
 
 // ../../packages/core/src/contracts/zero-usage.ts
-import { z as z38 } from "zod";
-var c33 = initContract();
-var memberUsageSchema = z38.object({
-  userId: z38.string(),
-  email: z38.string(),
-  inputTokens: z38.number(),
-  outputTokens: z38.number(),
-  cacheReadInputTokens: z38.number(),
-  cacheCreationInputTokens: z38.number(),
-  creditsCharged: z38.number()
+import { z as z37 } from "zod";
+var c32 = initContract();
+var memberUsageSchema = z37.object({
+  userId: z37.string(),
+  email: z37.string(),
+  inputTokens: z37.number(),
+  outputTokens: z37.number(),
+  cacheReadInputTokens: z37.number(),
+  cacheCreationInputTokens: z37.number(),
+  creditsCharged: z37.number()
 });
-var usageMembersResponseSchema = z38.object({
-  period: z38.object({
-    start: z38.string(),
-    end: z38.string()
+var usageMembersResponseSchema = z37.object({
+  period: z37.object({
+    start: z37.string(),
+    end: z37.string()
   }).nullable(),
-  members: z38.array(memberUsageSchema)
+  members: z37.array(memberUsageSchema)
 });
-var zeroUsageMembersContract = c33.router({
+var zeroUsageMembersContract = c32.router({
   get: {
     method: "GET",
     path: "/api/zero/usage/members",
@@ -14460,16 +14516,16 @@ async function getLatestVersion() {
   }
 }
 function performUpgrade(packageManager) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     const args = packageManager === "pnpm" ? ["add", "-g", `${PACKAGE_NAME}@latest`] : ["install", "-g", `${PACKAGE_NAME}@latest`];
     const child = safeSpawn(packageManager, args, {
       stdio: "inherit"
     });
     child.on("close", (code) => {
-      resolve2(code === 0);
+      resolve(code === 0);
     });
     child.on("error", () => {
-      resolve2(false);
+      resolve(false);
     });
   });
 }
@@ -14545,9 +14601,9 @@ async function startSilentUpgrade(currentVersion) {
     detached: !isWindows,
     windowsHide: true
   });
-  const promise = new Promise((resolve2) => {
-    child.on("close", (code) => resolve2(code === 0));
-    child.on("error", () => resolve2(false));
+  const promise = new Promise((resolve) => {
+    child.on("close", (code) => resolve(code === 0));
+    child.on("error", () => resolve(false));
   });
   pendingUpgrade = { promise, child, packageManager };
 }
@@ -14559,10 +14615,10 @@ async function waitForSilentUpgrade(timeout = TIMEOUT_MS) {
   pendingUpgrade = null;
   const result = await Promise.race([
     promise,
-    new Promise((resolve2) => {
+    new Promise((resolve) => {
       setTimeout(() => {
         child.kill();
-        resolve2(false);
+        resolve(false);
       }, timeout);
     })
   ]);
@@ -14581,7 +14637,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.77.1"}`));
+  console.log(chalk4.bold(`VM0 CLI v${"9.78.0"}`));
   console.log();
   const config = await loadConfig();
   const hasEnvToken = !!process.env.VM0_TOKEN;
@@ -14618,61 +14674,6 @@ import { existsSync as existsSync5 } from "fs";
 import { dirname as dirname2, join as join8 } from "path";
 import { parse as parseYaml3 } from "yaml";
 
-// src/lib/api/core/http.ts
-async function appendOrgParam(path18) {
-  const activeOrg = await getActiveOrg();
-  if (!activeOrg) {
-    throw new Error(
-      "No active organization configured. Run: vm0 org use <slug>"
-    );
-  }
-  const queryStart = path18.indexOf("?");
-  if (queryStart !== -1) {
-    const params = new URLSearchParams(path18.slice(queryStart));
-    if (params.has("org")) {
-      return path18;
-    }
-    return `${path18}&org=${encodeURIComponent(activeOrg)}`;
-  }
-  return `${path18}?org=${encodeURIComponent(activeOrg)}`;
-}
-async function getRawHeaders() {
-  const token = await getActiveToken();
-  if (!token) {
-    throw new Error("Not authenticated. Run: vm0 auth login");
-  }
-  const headers = {
-    Authorization: `Bearer ${token}`
-  };
-  const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
-  if (bypassSecret) {
-    headers["x-vercel-protection-bypass"] = bypassSecret;
-  }
-  return headers;
-}
-async function httpGet(path18) {
-  const baseUrl = await getBaseUrl();
-  const headers = await getRawHeaders();
-  const orgPath = await appendOrgParam(path18);
-  return fetch(`${baseUrl}${orgPath}`, {
-    method: "GET",
-    headers
-  });
-}
-async function httpPost(path18, body) {
-  const baseUrl = await getBaseUrl();
-  const headers = await getRawHeaders();
-  const orgPath = await appendOrgParam(path18);
-  return fetch(`${baseUrl}${orgPath}`, {
-    method: "POST",
-    headers: {
-      ...headers,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(body)
-  });
-}
-
 // src/lib/api/domains/composes.ts
 import { initClient } from "@ts-rest/core";
 async function getComposeByName(name, org) {
@@ -14722,17 +14723,6 @@ async function createOrUpdateCompose(body) {
   }
   handleError(result, "Failed to create compose");
 }
-async function deleteCompose(id) {
-  const config = await getClientConfig();
-  const client = initClient(composesByIdContract, config);
-  const result = await client.delete({
-    params: { id }
-  });
-  if (result.status === 204) {
-    return;
-  }
-  handleError(result, "Failed to delete agent");
-}
 
 // src/lib/api/domains/runs.ts
 import { initClient as initClient2 } from "@ts-rest/core";
@@ -14928,6 +14918,52 @@ async function updateUserPreferences(body) {
   handleError(result, "Failed to update user preferences");
 }
 
+// src/lib/api/core/http.ts
+async function appendOrgParam(path17) {
+  const activeOrg = await getActiveOrg();
+  if (!activeOrg) {
+    throw new Error(
+      "No active organization configured. Run: vm0 org use <slug>"
+    );
+  }
+  const queryStart = path17.indexOf("?");
+  if (queryStart !== -1) {
+    const params = new URLSearchParams(path17.slice(queryStart));
+    if (params.has("org")) {
+      return path17;
+    }
+    return `${path17}&org=${encodeURIComponent(activeOrg)}`;
+  }
+  return `${path17}?org=${encodeURIComponent(activeOrg)}`;
+}
+async function getRawHeaders() {
+  const token = await getActiveToken();
+  if (!token) {
+    throw new Error("Not authenticated. Run: vm0 auth login");
+  }
+  const headers = {
+    Authorization: `Bearer ${token}`
+  };
+  const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
+  if (bypassSecret) {
+    headers["x-vercel-protection-bypass"] = bypassSecret;
+  }
+  return headers;
+}
+async function httpPost(path17, body) {
+  const baseUrl = await getBaseUrl();
+  const headers = await getRawHeaders();
+  const orgPath = await appendOrgParam(path17);
+  return fetch(`${baseUrl}${orgPath}`, {
+    method: "POST",
+    headers: {
+      ...headers,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+}
+
 // src/lib/api/domains/skills.ts
 import chalk5 from "chalk";
 function isResolveSkillsResponse(value) {
@@ -15300,20 +15336,100 @@ async function updateZeroAgentInstructions(name, content) {
   handleError(result, `Failed to update instructions for zero agent "${name}"`);
 }
 
-// src/lib/api/domains/zero-schedules.ts
+// src/lib/api/domains/zero-connectors.ts
 import { initClient as initClient14 } from "@ts-rest/core";
-async function deployZeroSchedule(body) {
+async function listZeroConnectors() {
   const config = await getClientConfig();
-  const client = initClient14(zeroSchedulesMainContract, config);
-  const result = await client.deploy({ body });
-  if (result.status === 200 || result.status === 201) {
-    return result.body;
+  const client = initClient14(zeroConnectorsMainContract, config);
+  const result = await client.list({ headers: {} });
+  if (result.status === 200) {
+    return result.body;
+  }
+  handleError(result, "Failed to list connectors");
+}
+async function getZeroConnector(type2) {
+  const config = await getClientConfig();
+  const client = initClient14(zeroConnectorsByTypeContract, config);
+  const result = await client.get({
+    params: { type: type2 }
+  });
+  if (result.status === 200) {
+    return result.body;
+  }
+  if (result.status === 404) {
+    return null;
+  }
+  handleError(result, `Failed to get connector "${type2}"`);
+}
+async function deleteZeroConnector(type2) {
+  const config = await getClientConfig();
+  const client = initClient14(zeroConnectorsByTypeContract, config);
+  const result = await client.delete({
+    params: { type: type2 }
+  });
+  if (result.status === 204) {
+    return;
+  }
+  handleError(result, `Connector "${type2}" not found`);
+}
+async function createZeroConnectorSession(type2) {
+  const config = await getClientConfig();
+  const client = initClient14(zeroConnectorSessionsContract, config);
+  const result = await client.create({
+    params: { type: type2 },
+    body: {}
+  });
+  if (result.status === 200) {
+    return result.body;
+  }
+  handleError(result, "Failed to create connector session");
+}
+async function getZeroConnectorSession(type2, sessionId) {
+  const config = await getClientConfig();
+  const client = initClient14(zeroConnectorSessionByIdContract, config);
+  const result = await client.get({
+    params: { type: type2, sessionId }
+  });
+  if (result.status === 200) {
+    return result.body;
+  }
+  handleError(result, "Failed to get connector session status");
+}
+async function createZeroComputerConnector() {
+  const config = await getClientConfig();
+  const client = initClient14(zeroComputerConnectorContract, config);
+  const result = await client.create({
+    body: {}
+  });
+  if (result.status === 200) {
+    return result.body;
+  }
+  handleError(result, "Failed to create computer connector");
+}
+async function deleteZeroComputerConnector() {
+  const config = await getClientConfig();
+  const client = initClient14(zeroComputerConnectorContract, config);
+  const result = await client.delete({});
+  if (result.status === 204) {
+    return;
+  }
+  handleError(result, "Computer connector not found");
+}
+
+// src/lib/api/domains/zero-schedules.ts
+import { initClient as initClient15 } from "@ts-rest/core";
+async function deployZeroSchedule(body) {
+  const config = await getClientConfig();
+  const client = initClient15(zeroSchedulesMainContract, config);
+  const result = await client.deploy({ body });
+  if (result.status === 200 || result.status === 201) {
+    return result.body;
   }
   handleError(result, "Failed to deploy schedule");
 }
 async function listZeroSchedules() {
   const config = await getClientConfig();
-  const client = initClient14(zeroSchedulesMainContract, config);
+  const client = initClient15(zeroSchedulesMainContract, config);
   const result = await client.list({ headers: {} });
   if (result.status === 200) {
     return result.body;
@@ -15322,7 +15438,7 @@ async function listZeroSchedules() {
 }
 async function deleteZeroSchedule(params) {
   const config = await getClientConfig();
-  const client = initClient14(zeroSchedulesByNameContract, config);
+  const client = initClient15(zeroSchedulesByNameContract, config);
   const result = await client.delete({
     params: { name: params.name },
     query: { zeroAgentId: params.zeroAgentId }
@@ -15334,7 +15450,7 @@ async function deleteZeroSchedule(params) {
 }
 async function enableZeroSchedule(params) {
   const config = await getClientConfig();
-  const client = initClient14(zeroSchedulesEnableContract, config);
+  const client = initClient15(zeroSchedulesEnableContract, config);
   const result = await client.enable({
     params: { name: params.name },
     body: { zeroAgentId: params.zeroAgentId }
@@ -15346,7 +15462,7 @@ async function enableZeroSchedule(params) {
 }
 async function disableZeroSchedule(params) {
   const config = await getClientConfig();
-  const client = initClient14(zeroSchedulesEnableContract, config);
+  const client = initClient15(zeroSchedulesEnableContract, config);
   const result = await client.disable({
     params: { name: params.name },
     body: { zeroAgentId: params.zeroAgentId }
@@ -15382,8 +15498,8 @@ async function resolveZeroScheduleByAgent(agentName, scheduleName) {
 }
 
 // src/lib/domain/yaml-validator.ts
-import { z as z39 } from "zod";
-var cliAgentNameSchema = z39.string().min(3, "Agent name must be at least 3 characters").max(64, "Agent name must be 64 characters or less").regex(
+import { z as z38 } from "zod";
+var cliAgentNameSchema = z38.string().min(3, "Agent name must be at least 3 characters").max(64, "Agent name must be 64 characters or less").regex(
   /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,62}[a-zA-Z0-9])?$/,
   "Agent name must start and end with letter or number, and contain only letters, numbers, and hyphens"
 );
@@ -15397,7 +15513,7 @@ var cliAgentDefinitionSchema = agentDefinitionSchema.superRefine(
             resolveSkillRef(skillRef);
           } catch (error) {
             ctx.addIssue({
-              code: z39.ZodIssueCode.custom,
+              code: z38.ZodIssueCode.custom,
               message: error instanceof Error ? error.message : `Invalid skill reference: ${skillRef}`,
               path: ["skills", i]
             });
@@ -15407,15 +15523,15 @@ var cliAgentDefinitionSchema = agentDefinitionSchema.superRefine(
     }
   }
 );
-var cliComposeSchema = z39.object({
-  version: z39.string().min(1, "Missing config.version"),
-  agents: z39.record(cliAgentNameSchema, cliAgentDefinitionSchema),
-  volumes: z39.record(z39.string(), volumeConfigSchema).optional()
+var cliComposeSchema = z38.object({
+  version: z38.string().min(1, "Missing config.version"),
+  agents: z38.record(cliAgentNameSchema, cliAgentDefinitionSchema),
+  volumes: z38.record(z38.string(), volumeConfigSchema).optional()
 }).superRefine((config, ctx) => {
   const agentKeys = Object.keys(config.agents);
   if (agentKeys.length === 0) {
     ctx.addIssue({
-      code: z39.ZodIssueCode.custom,
+      code: z38.ZodIssueCode.custom,
       message: "agents must have at least one agent defined",
       path: ["agents"]
     });
@@ -15423,7 +15539,7 @@ var cliComposeSchema = z39.object({
   }
   if (agentKeys.length > 1) {
     ctx.addIssue({
-      code: z39.ZodIssueCode.custom,
+      code: z38.ZodIssueCode.custom,
       message: "Multiple agents not supported yet. Only one agent allowed.",
       path: ["agents"]
     });
@@ -15435,7 +15551,7 @@ var cliComposeSchema = z39.object({
   if (agentVolumes && agentVolumes.length > 0) {
     if (!config.volumes) {
       ctx.addIssue({
-        code: z39.ZodIssueCode.custom,
+        code: z38.ZodIssueCode.custom,
         message: "Agent references volumes but no volumes section defined. Each volume must have explicit name and version.",
         path: ["volumes"]
       });
@@ -15445,7 +15561,7 @@ var cliComposeSchema = z39.object({
       const parts = volDeclaration.split(":");
       if (parts.length !== 2) {
         ctx.addIssue({
-          code: z39.ZodIssueCode.custom,
+          code: z38.ZodIssueCode.custom,
           message: `Invalid volume declaration: ${volDeclaration}. Expected format: volume-key:/mount/path`,
           path: ["agents", agentName, "volumes"]
         });
@@ -15454,7 +15570,7 @@ var cliComposeSchema = z39.object({
       const volumeKey = parts[0].trim();
       if (!config.volumes[volumeKey]) {
         ctx.addIssue({
-          code: z39.ZodIssueCode.custom,
+          code: z38.ZodIssueCode.custom,
           message: `Volume "${volumeKey}" is not defined in volumes section. Each volume must have explicit name and version.`,
           path: ["volumes", volumeKey]
         });
@@ -15462,29 +15578,29 @@ var cliComposeSchema = z39.object({
     }
   }
 });
-function formatInvalidTypeIssue(path18, issue) {
+function formatInvalidTypeIssue(path17, issue) {
   const received = issue.received;
   const isMissing = received === "undefined" || issue.message.includes("received undefined") || issue.message === "Required";
-  if (path18 === "version" && isMissing) {
+  if (path17 === "version" && isMissing) {
     return "Missing config.version";
   }
-  if (path18 === "agents" && isMissing) {
+  if (path17 === "agents" && isMissing) {
     return "Missing agents object in config";
   }
-  if (path18.startsWith("volumes.") && path18.endsWith(".name")) {
-    const volumeKey = path18.split(".")[1];
+  if (path17.startsWith("volumes.") && path17.endsWith(".name")) {
+    const volumeKey = path17.split(".")[1];
     return `Volume "${volumeKey}" must have a 'name' field (string)`;
   }
-  if (path18.startsWith("volumes.") && path18.endsWith(".version")) {
-    const volumeKey = path18.split(".")[1];
+  if (path17.startsWith("volumes.") && path17.endsWith(".version")) {
+    const volumeKey = path17.split(".")[1];
     return `Volume "${volumeKey}" must have a 'version' field (string)`;
   }
   if (issue.expected === "array") {
-    const fieldName = path18.replace(/^agents\.[^.]+\./, "agent.");
+    const fieldName = path17.replace(/^agents\.[^.]+\./, "agent.");
     return `${fieldName} must be an array`;
   }
   if (issue.expected === "string" && received === "number") {
-    const fieldName = path18.replace(/^agents\.[^.]+\./, "agent.");
+    const fieldName = path17.replace(/^agents\.[^.]+\./, "agent.");
     const match = fieldName.match(/^(agent\.[^.]+)\.\d+$/);
     if (match) {
       return `Each entry in ${match[1]?.replace("agent.", "")} must be a string`;
@@ -15495,24 +15611,24 @@ function formatInvalidTypeIssue(path18, issue) {
 function formatZodError(error) {
   const issue = error.issues[0];
   if (!issue) return "Validation failed";
-  const path18 = issue.path.join(".");
+  const path17 = issue.path.join(".");
   const message = issue.message;
-  if (!path18) return message;
+  if (!path17) return message;
   if (issue.code === "invalid_type") {
-    const formatted = formatInvalidTypeIssue(path18, issue);
+    const formatted = formatInvalidTypeIssue(path17, issue);
     if (formatted) return formatted;
   }
-  if (issue.code === "invalid_key" && path18.startsWith("agents.")) {
+  if (issue.code === "invalid_key" && path17.startsWith("agents.")) {
     return "Invalid agent name format. Must be 3-64 characters, letters, numbers, and hyphens only. Must start and end with letter or number.";
   }
-  if (message === "Invalid key in record" && path18.startsWith("agents.")) {
+  if (message === "Invalid key in record" && path17.startsWith("agents.")) {
     return "Invalid agent name format. Must be 3-64 characters, letters, numbers, and hyphens only. Must start and end with letter or number.";
   }
   if (issue.code === "custom") {
     return message;
   }
-  if (path18.startsWith("agents.")) {
-    const cleanPath = path18.replace(/^agents\.[^.]+\./, "agent.");
+  if (path17.startsWith("agents.")) {
+    const cleanPath = path17.replace(/^agents\.[^.]+\./, "agent.");
     if (message.startsWith("Invalid input:")) {
       const match = message.match(/expected (\w+), received (\w+)/);
       if (match && match[1] === "string" && match[2] === "number") {
@@ -15524,7 +15640,7 @@ function formatZodError(error) {
     }
     return `${cleanPath}: ${message}`;
   }
-  return `${path18}: ${message}`;
+  return `${path17}: ${message}`;
 }
 function validateAgentName(name) {
   return cliAgentNameSchema.safeParse(name).success;
@@ -15873,7 +15989,7 @@ function excludeVm0Filter(filePath) {
   return !shouldExclude;
 }
 function listTarFiles(tarPath) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const files = [];
     tar.list({
       file: tarPath,
@@ -15882,7 +15998,7 @@ function listTarFiles(tarPath) {
           files.push(entry.path);
         }
       }
-    }).then(() => resolve2(files)).catch(reject);
+    }).then(() => resolve(files)).catch(reject);
   });
 }
 async function listLocalFiles(dir, excludeDirs = [".vm0"]) {
@@ -15944,11 +16060,11 @@ async function removeEmptyDirs(dir, excludeDirs = [".vm0"]) {
 
 // src/lib/storage/direct-upload.ts
 async function hashFileStream(filePath) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
     const stream = fs4.createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
-    stream.on("end", () => resolve2(hash.digest("hex")));
+    stream.on("end", () => resolve(hash.digest("hex")));
     stream.on("error", reject);
   });
 }
@@ -16033,7 +16149,7 @@ function createManifest(files) {
   return Buffer.from(JSON.stringify(manifest, null, 2));
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function uploadToPresignedUrl(presignedUrl, data, contentType, maxRetries = 3) {
   let lastError = null;
@@ -16653,7 +16769,7 @@ var composeCommand = new Command7().name("compose").description("Create or updat
         options.autoUpdate = false;
       }
       if (options.autoUpdate !== false) {
-        await startSilentUpgrade("9.77.1");
+        await startSilentUpgrade("9.78.0");
       }
       try {
         let result;
@@ -17415,7 +17531,7 @@ async function pollEvents(runId, options) {
       result = { succeeded: false, runId };
     }
     if (!complete) {
-      await new Promise((resolve2) => setTimeout(resolve2, pollIntervalMs));
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
     }
   }
   return result;
@@ -17488,7 +17604,7 @@ var mainRunCommand = new Command8().name("run").description("Run an agent").argu
   withErrorHandler(
     async (identifier, prompt, options) => {
       if (options.autoUpdate !== false) {
-        await startSilentUpgrade("9.77.1");
+        await startSilentUpgrade("9.78.0");
       }
       const { org, name, version } = parseIdentifier(identifier);
       let composeId;
@@ -18984,7 +19100,7 @@ function printCommand(cmd) {
   console.log(chalk33.dim(`> ${cmd}`));
 }
 function execVm0Command(args, options = {}) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const stdio = options.silent ? "pipe" : "inherit";
     const proc = safeSpawn("vm0", args, {
       cwd: options.cwd,
@@ -19002,7 +19118,7 @@ function execVm0Command(args, options = {}) {
     }
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve2(stdout);
+        resolve(stdout);
       } else {
         reject(new Error(stderr || `Command failed with exit code ${code}`));
       }
@@ -19013,7 +19129,7 @@ function execVm0Command(args, options = {}) {
   });
 }
 function execVm0RunWithCapture(args, options = {}) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const env = process.stdout.isTTY ? { ...process.env, FORCE_COLOR: "1" } : process.env;
     const proc = safeSpawn("vm0", args, {
       cwd: options.cwd,
@@ -19034,7 +19150,7 @@ function execVm0RunWithCapture(args, options = {}) {
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve2(stdout);
+        resolve(stdout);
       } else {
         reject(new Error(stderr || `Command failed with exit code ${code}`));
       }
@@ -19244,7 +19360,7 @@ var cookAction = new Command35().name("cook").description("Quick start: prepare,
   withErrorHandler(
     async (prompt, options) => {
       if (options.autoUpdate !== false) {
-        const shouldExit = await checkAndUpgrade("9.77.1", prompt);
+        const shouldExit = await checkAndUpgrade("9.78.0", prompt);
         if (shouldExit) {
           process.exit(0);
         }
@@ -19430,7 +19546,7 @@ import { Command as Command40 } from "commander";
 import chalk36 from "chalk";
 
 // src/lib/api/api-client.ts
-import { initClient as initClient15 } from "@ts-rest/core";
+import { initClient as initClient16 } from "@ts-rest/core";
 var ApiClient = class {
   async getHeaders() {
     const token = await getActiveToken();
@@ -19456,7 +19572,7 @@ var ApiClient = class {
   async getComposeByName(name, org) {
     const baseUrl = await this.getBaseUrl();
     const headers = await this.getHeaders();
-    const client = initClient15(composesMainContract, {
+    const client = initClient16(composesMainContract, {
       baseUrl,
       baseHeaders: headers,
       jsonQuery: false
@@ -19477,7 +19593,7 @@ var ApiClient = class {
   async getComposeById(id) {
     const baseUrl = await this.getBaseUrl();
     const headers = await this.getHeaders();
-    const client = initClient15(composesByIdContract, {
+    const client = initClient16(composesByIdContract, {
       baseUrl,
       baseHeaders: headers,
       jsonQuery: false
@@ -19499,7 +19615,7 @@ var ApiClient = class {
   async getComposeVersion(composeId, version) {
     const baseUrl = await this.getBaseUrl();
     const headers = await this.getHeaders();
-    const client = initClient15(composesVersionsContract, {
+    const client = initClient16(composesVersionsContract, {
       baseUrl,
       baseHeaders: headers,
       jsonQuery: false
@@ -19520,7 +19636,7 @@ var ApiClient = class {
   async createOrUpdateCompose(body) {
     const baseUrl = await this.getBaseUrl();
     const headers = await this.getHeaders();
-    const client = initClient15(composesMainContract, {
+    const client = initClient16(composesMainContract, {
       baseUrl,
       baseHeaders: headers,
       jsonQuery: false
@@ -19543,7 +19659,7 @@ var ApiClient = class {
   async createRun(body) {
     const baseUrl = await this.getBaseUrl();
     const headers = await this.getHeaders();
-    const client = initClient15(runsMainContract, {
+    const client = initClient16(runsMainContract, {
       baseUrl,
       baseHeaders: headers,
       jsonQuery: false
@@ -19558,7 +19674,7 @@ var ApiClient = class {
   }
   async getEvents(runId, options) {
     const config = await getClientConfig();
-    const client = initClient15(runEventsContract, config);
+    const client = initClient16(runEventsContract, config);
     const result = await client.getEvents({
       params: { id: runId },
       query: {
@@ -19575,7 +19691,7 @@ var ApiClient = class {
   }
   async getSystemLog(runId, options) {
     const config = await getClientConfig();
-    const client = initClient15(runSystemLogContract, config);
+    const client = initClient16(runSystemLogContract, config);
     const result = await client.getSystemLog({
       params: { id: runId },
       query: {
@@ -19593,7 +19709,7 @@ var ApiClient = class {
   }
   async getMetrics(runId, options) {
     const config = await getClientConfig();
-    const client = initClient15(runMetricsContract, config);
+    const client = initClient16(runMetricsContract, config);
     const result = await client.getMetrics({
       params: { id: runId },
       query: {
@@ -19611,7 +19727,7 @@ var ApiClient = class {
   }
   async getAgentEvents(runId, options) {
     const config = await getClientConfig();
-    const client = initClient15(runAgentEventsContract, config);
+    const client = initClient16(runAgentEventsContract, config);
     const result = await client.getAgentEvents({
       params: { id: runId },
       query: {
@@ -19629,7 +19745,7 @@ var ApiClient = class {
   }
   async getNetworkLogs(runId, options) {
     const config = await getClientConfig();
-    const client = initClient15(runNetworkLogsContract, config);
+    const client = initClient16(runNetworkLogsContract, config);
     const result = await client.getNetworkLogs({
       params: { id: runId },
       query: {
@@ -19652,7 +19768,7 @@ var ApiClient = class {
   async getSession(sessionId) {
     const baseUrl = await this.getBaseUrl();
     const headers = await this.getHeaders();
-    const client = initClient15(sessionsByIdContract, {
+    const client = initClient16(sessionsByIdContract, {
       baseUrl,
       baseHeaders: headers,
       jsonQuery: false
@@ -19673,7 +19789,7 @@ var ApiClient = class {
    */
   async getCheckpoint(checkpointId) {
     const config = await getClientConfig();
-    const client = initClient15(checkpointsByIdContract, config);
+    const client = initClient16(checkpointsByIdContract, config);
     const result = await client.getById({
       params: { id: checkpointId }
     });
@@ -19690,7 +19806,7 @@ var ApiClient = class {
   async prepareStorage(body) {
     const baseUrl = await this.getBaseUrl();
     const headers = await this.getHeaders();
-    const client = initClient15(storagesPrepareContract, {
+    const client = initClient16(storagesPrepareContract, {
       baseUrl,
       baseHeaders: headers,
       jsonQuery: false
@@ -19709,7 +19825,7 @@ var ApiClient = class {
   async commitStorage(body) {
     const baseUrl = await this.getBaseUrl();
     const headers = await this.getHeaders();
-    const client = initClient15(storagesCommitContract, {
+    const client = initClient16(storagesCommitContract, {
       baseUrl,
       baseHeaders: headers,
       jsonQuery: false
@@ -19728,7 +19844,7 @@ var ApiClient = class {
   async getStorageDownload(query) {
     const baseUrl = await this.getBaseUrl();
     const headers = await this.getHeaders();
-    const client = initClient15(storagesDownloadContract, {
+    const client = initClient16(storagesDownloadContract, {
       baseUrl,
       baseHeaders: headers,
       jsonQuery: false
@@ -19753,7 +19869,7 @@ var ApiClient = class {
   async listStorages(query) {
     const baseUrl = await this.getBaseUrl();
     const headers = await this.getHeaders();
-    const client = initClient15(storagesListContract, {
+    const client = initClient16(storagesListContract, {
       baseUrl,
       baseHeaders: headers,
       jsonQuery: false
@@ -19769,7 +19885,7 @@ var ApiClient = class {
   /**
    * Generic GET request
    */
-  async get(path18) {
+  async get(path17) {
     const baseUrl = await this.getBaseUrl();
     const token = await getActiveToken();
     if (!token) {
@@ -19782,7 +19898,7 @@ var ApiClient = class {
     if (bypassSecret) {
       headers["x-vercel-protection-bypass"] = bypassSecret;
     }
-    return fetch(`${baseUrl}${path18}`, {
+    return fetch(`${baseUrl}${path17}`, {
       method: "GET",
       headers
     });
@@ -19790,7 +19906,7 @@ var ApiClient = class {
   /**
    * Generic POST request
    */
-  async post(path18, options) {
+  async post(path17, options) {
     const baseUrl = await this.getBaseUrl();
     const token = await getActiveToken();
     if (!token) {
@@ -19806,7 +19922,7 @@ var ApiClient = class {
     if (bypassSecret) {
       headers["x-vercel-protection-bypass"] = bypassSecret;
     }
-    return fetch(`${baseUrl}${path18}`, {
+    return fetch(`${baseUrl}${path17}`, {
       method: "POST",
       headers,
       body: options?.body
@@ -19815,7 +19931,7 @@ var ApiClient = class {
   /**
    * Generic DELETE request
    */
-  async delete(path18) {
+  async delete(path17) {
     const baseUrl = await this.getBaseUrl();
     const token = await getActiveToken();
     if (!token) {
@@ -19828,14 +19944,14 @@ var ApiClient = class {
     if (bypassSecret) {
       headers["x-vercel-protection-bypass"] = bypassSecret;
     }
-    return fetch(`${baseUrl}${path18}`, {
+    return fetch(`${baseUrl}${path17}`, {
       method: "DELETE",
       headers
     });
   }
   async searchLogs(options) {
     const config = await getClientConfig();
-    const client = initClient15(logsSearchContract, config);
+    const client = initClient16(logsSearchContract, config);
     const result = await client.searchLogs({
       query: {
         keyword: options.keyword,
@@ -20299,432 +20415,12 @@ async function showNetworkLogs(runId, options) {
   }
 }
 
-// src/commands/agent/index.ts
-import { Command as Command45 } from "commander";
-
-// src/commands/agent/clone.ts
+// src/commands/init/index.ts
 import { Command as Command41 } from "commander";
 import chalk37 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";
-import { tmpdir as tmpdir7 } from "os";
-import * as tar6 from "tar";
-import { stringify as yamlStringify } from "yaml";
-function cleanComposeContent(content) {
-  const agents = {};
-  for (const [name, agent] of Object.entries(content.agents)) {
-    const cleaned = {
-      framework: agent.framework
-    };
-    if (agent.description) cleaned.description = agent.description;
-    if (agent.volumes) cleaned.volumes = agent.volumes;
-    if (agent.environment) cleaned.environment = agent.environment;
-    if (agent.instructions) cleaned.instructions = agent.instructions;
-    if (agent.skills) cleaned.skills = agent.skills;
-    if (agent.experimental_runner)
-      cleaned.experimental_runner = agent.experimental_runner;
-    if (agent.experimental_profile)
-      cleaned.experimental_profile = agent.experimental_profile;
-    if (agent.experimental_capabilities)
-      cleaned.experimental_capabilities = agent.experimental_capabilities;
-    if (agent.experimental_firewalls)
-      cleaned.experimental_firewalls = agent.experimental_firewalls;
-    agents[name] = cleaned;
-  }
-  const result = {
-    version: content.version,
-    agents
-  };
-  if (content.volumes) {
-    result.volumes = content.volumes;
-  }
-  return result;
-}
-async function downloadInstructions(agentName, instructionsPath, destination) {
-  const destPath = join10(destination, instructionsPath);
-  const resolvedDest = resolve(destPath);
-  const resolvedBase = resolve(destination);
-  if (resolvedDest !== resolvedBase && !resolvedDest.startsWith(resolvedBase + sep)) {
-    throw new Error("Invalid instructions path: path traversal detected");
-  }
-  const volumeName = getInstructionsStorageName(agentName);
-  console.log(chalk37.dim("Downloading instructions..."));
-  const downloadInfo = await getStorageDownload({
-    name: volumeName,
-    type: "volume"
-  });
-  if ("empty" in downloadInfo) {
-    console.log(chalk37.yellow("\u26A0 Instructions volume is empty"));
-    return false;
-  }
-  const response = await fetch(downloadInfo.url);
-  if (!response.ok) {
-    throw new Error(`Failed to download instructions: ${response.status}`);
-  }
-  const buffer = Buffer.from(await response.arrayBuffer());
-  const tmpDir = mkdtempSync5(join10(tmpdir7(), "vm0-clone-"));
-  const tarPath = join10(tmpDir, "archive.tar.gz");
-  await writeFile6(tarPath, buffer);
-  await tar6.extract({ file: tarPath, cwd: tmpDir, gzip: true });
-  const files = await readdir2(tmpDir);
-  const mdFile = files.find((f) => f === "CLAUDE.md" || f === "AGENTS.md");
-  if (!mdFile) {
-    console.log(chalk37.yellow("\u26A0 No instructions file found in volume"));
-    await rm4(tmpDir, { recursive: true, force: true });
-    return false;
-  }
-  await mkdir7(dirname3(destPath), { recursive: true });
-  await copyFile(join10(tmpDir, mdFile), destPath);
-  await rm4(tmpDir, { recursive: true, force: true });
-  return true;
-}
-var cloneCommand4 = new Command41().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);
-    if (dirStatus.exists && !dirStatus.empty) {
-      throw new Error(`Directory "${targetDir}" is not empty`);
-    }
-    console.log(`Cloning agent compose: ${name}`);
-    const compose = await getComposeByName(name);
-    if (!compose) {
-      throw new Error(`Agent compose not found: ${name}`);
-    }
-    if (!compose.content || !compose.headVersionId) {
-      throw new Error(`Agent compose has no content: ${name}`);
-    }
-    const content = compose.content;
-    const cleanedContent = cleanComposeContent(content);
-    const yamlContent = yamlStringify(cleanedContent);
-    await mkdir7(targetDir, { recursive: true });
-    const yamlPath = join10(targetDir, "vm0.yaml");
-    await writeFile6(yamlPath, yamlContent, "utf8");
-    console.log(chalk37.green("\u2713 Created vm0.yaml"));
-    const agentKey = Object.keys(content.agents)[0];
-    const agent = agentKey ? content.agents[agentKey] : void 0;
-    if (agent?.instructions) {
-      try {
-        const instructionsDownloaded = await downloadInstructions(
-          name,
-          agent.instructions,
-          targetDir
-        );
-        if (instructionsDownloaded) {
-          console.log(chalk37.green(`\u2713 Downloaded ${agent.instructions}`));
-        }
-      } catch (error) {
-        console.log(
-          chalk37.yellow(
-            `\u26A0 Could not download instructions: ${error instanceof Error ? error.message : "Unknown error"}`
-          )
-        );
-      }
-    }
-    console.log();
-    console.log(chalk37.green(`\u2713 Successfully cloned agent: ${name}`));
-    console.log(chalk37.dim(`  Location: ${targetDir}/`));
-    console.log(chalk37.dim(`  Version: ${compose.headVersionId.slice(0, 8)}`));
-  })
-);
-
-// src/commands/agent/delete.ts
-import { Command as Command42 } from "commander";
-import chalk38 from "chalk";
-var deleteCommand = new Command42().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) {
-      throw new Error(`Agent '${name}' not found`, {
-        cause: new Error("Run: vm0 agent list")
-      });
-    }
-    if (!options.yes) {
-      if (!isInteractive()) {
-        throw new Error("--yes flag is required in non-interactive mode");
-      }
-      const confirmed = await promptConfirm(`Delete agent '${name}'?`, false);
-      if (!confirmed) {
-        console.log(chalk38.dim("Cancelled"));
-        return;
-      }
-    }
-    try {
-      await deleteCompose(compose.id);
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("currently running")) {
-        throw new Error("Cannot delete agent: agent is currently running", {
-          cause: new Error("Run: vm0 run list")
-        });
-      }
-      throw error;
-    }
-    console.log(chalk38.green(`\u2713 Agent '${name}' deleted`));
-  })
-);
-
-// src/commands/agent/list.ts
-import { Command as Command43 } from "commander";
-import chalk39 from "chalk";
-var listCommand5 = new Command43().name("list").alias("ls").description("List all agent composes").action(
-  withErrorHandler(async () => {
-    const response = await httpGet("/api/agent/composes/list");
-    if (!response.ok) {
-      const error = await response.json();
-      throw new Error(error.error?.message || "List failed");
-    }
-    const data = await response.json();
-    if (data.composes.length === 0) {
-      console.log(chalk39.dim("No agent composes found"));
-      console.log(
-        chalk39.dim("  Create one with: vm0 compose <agent-compose.yaml>")
-      );
-      return;
-    }
-    const nameWidth = Math.max(4, ...data.composes.map((c34) => c34.name.length));
-    const header = ["NAME".padEnd(nameWidth), "VERSION", "UPDATED"].join(
-      "  "
-    );
-    console.log(chalk39.dim(header));
-    for (const compose of data.composes) {
-      const versionShort = compose.headVersionId ? compose.headVersionId.slice(0, 8) : chalk39.dim("-");
-      const row = [
-        compose.name.padEnd(nameWidth),
-        versionShort,
-        formatRelativeTime(compose.updatedAt)
-      ].join("  ");
-      console.log(row);
-    }
-  })
-);
-
-// src/commands/agent/status.ts
-import { Command as Command44 } from "commander";
-import chalk40 from "chalk";
-
-// src/lib/domain/source-derivation.ts
-import * as fs10 from "fs/promises";
-import * as path16 from "path";
-import * as os8 from "os";
-async function fetchSkillFrontmatter(skillUrl, tempDir) {
-  try {
-    const parsed = parseGitHubTreeUrl2(skillUrl);
-    const skillDir = await downloadGitHubSkill(parsed, tempDir);
-    const frontmatter = await readSkillFrontmatter(skillDir);
-    return { skillName: parsed.skillName, frontmatter };
-  } catch {
-    return null;
-  }
-}
-async function deriveAgentVariableSources(agent, options) {
-  const grouped = extractAndGroupVariables(agent.environment ?? {});
-  const secretSources = /* @__PURE__ */ new Map();
-  const varSources = /* @__PURE__ */ new Map();
-  for (const ref of grouped.secrets) {
-    secretSources.set(ref.name, {
-      name: ref.name,
-      source: "agent environment"
-    });
-  }
-  for (const ref of grouped.vars) {
-    varSources.set(ref.name, { name: ref.name, source: "agent environment" });
-  }
-  if (options?.skipNetwork || !agent.skills || agent.skills.length === 0) {
-    return {
-      secrets: Array.from(secretSources.values()),
-      vars: Array.from(varSources.values())
-    };
-  }
-  const tempDir = await fs10.mkdtemp(
-    path16.join(os8.tmpdir(), "vm0-source-derivation-")
-  );
-  try {
-    const skillResults = await Promise.all(
-      agent.skills.map((url) => fetchSkillFrontmatter(url, tempDir))
-    );
-    for (const result of skillResults) {
-      if (!result) continue;
-      const { skillName, frontmatter } = result;
-      if (frontmatter.vm0_secrets) {
-        for (const secretName of frontmatter.vm0_secrets) {
-          if (secretSources.has(secretName)) {
-            secretSources.set(secretName, {
-              name: secretName,
-              source: `skill: ${skillName}`,
-              skillName
-            });
-          }
-        }
-      }
-      if (frontmatter.vm0_vars) {
-        for (const varName of frontmatter.vm0_vars) {
-          if (varSources.has(varName)) {
-            varSources.set(varName, {
-              name: varName,
-              source: `skill: ${skillName}`,
-              skillName
-            });
-          }
-        }
-      }
-    }
-  } finally {
-    await fs10.rm(tempDir, { recursive: true, force: true });
-  }
-  return {
-    secrets: Array.from(secretSources.values()),
-    vars: Array.from(varSources.values())
-  };
-}
-async function deriveComposeVariableSources(content, options) {
-  const results = /* @__PURE__ */ new Map();
-  const entries = Object.entries(content.agents);
-  const sourcesPromises = entries.map(async ([agentName, agent]) => {
-    const sources = await deriveAgentVariableSources(agent, options);
-    return { agentName, sources };
-  });
-  const sourcesResults = await Promise.all(sourcesPromises);
-  for (const { agentName, sources } of sourcesResults) {
-    results.set(agentName, sources);
-  }
-  return results;
-}
-
-// src/commands/agent/status.ts
-function formatListSection(label, items) {
-  if (items.length === 0) return;
-  console.log(`    ${label}:`);
-  for (const item of items) {
-    console.log(`      - ${item}`);
-  }
-}
-function formatVolumes(volumes, volumeConfigs) {
-  if (volumes.length === 0) return;
-  console.log(`    Volumes:`);
-  for (const vol of volumes) {
-    const volumeDef = volumeConfigs?.[vol];
-    if (volumeDef) {
-      console.log(`      - ${vol}:${volumeDef.version.slice(0, 8)}`);
-    } else {
-      console.log(`      - ${vol}`);
-    }
-  }
-}
-function formatVariableSources(sources) {
-  if (sources.secrets.length > 0) {
-    console.log(`    Secrets:`);
-    for (const secret of sources.secrets) {
-      const sourceInfo = chalk40.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 = chalk40.dim(`(${v.source})`);
-      console.log(`      - ${v.name.padEnd(20)} ${sourceInfo}`);
-    }
-  }
-}
-function formatAgentDetails(agentName, agent, agentSources, volumeConfigs) {
-  console.log(`  ${chalk40.cyan(agentName)}:`);
-  console.log(`    Framework: ${agent.framework}`);
-  formatVolumes(agent.volumes ?? [], volumeConfigs);
-  formatListSection("Skills", agent.skills ?? []);
-  if (agentSources) {
-    formatVariableSources(agentSources);
-  }
-  if (agent.experimental_runner) {
-    console.log(`    Runner: ${agent.experimental_runner.group}`);
-  }
-}
-function formatComposeOutput(name, versionId, content, variableSources) {
-  console.log(chalk40.bold("Name:") + `    ${name}`);
-  console.log(chalk40.bold("Version:") + ` ${versionId}`);
-  console.log();
-  console.log(chalk40.bold("Agents:"));
-  for (const [agentName, agent] of Object.entries(content.agents)) {
-    const agentSources = variableSources?.get(agentName);
-    formatAgentDetails(agentName, agent, agentSources, content.volumes);
-  }
-}
-var statusCommand5 = new Command44().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(
-  withErrorHandler(
-    async (argument, options) => {
-      const colonIndex = argument.lastIndexOf(":");
-      let name;
-      let version;
-      if (colonIndex === -1) {
-        name = argument;
-        version = "latest";
-      } else {
-        name = argument.slice(0, colonIndex);
-        version = argument.slice(colonIndex + 1) || "latest";
-      }
-      const compose = await getComposeByName(name);
-      if (!compose) {
-        throw new Error(`Agent compose not found: ${name}`, {
-          cause: new Error("Run: vm0 agent list")
-        });
-      }
-      let resolvedVersionId = compose.headVersionId;
-      if (version !== "latest" && compose.headVersionId) {
-        if (version.length < 64) {
-          try {
-            const versionInfo = await getComposeVersion(compose.id, version);
-            resolvedVersionId = versionInfo.versionId;
-          } catch (error) {
-            if (error instanceof Error && error.message.includes("not found")) {
-              throw new Error(`Version not found: ${version}`, {
-                cause: new Error(
-                  `HEAD version: ${compose.headVersionId?.slice(0, 8)}`
-                )
-              });
-            }
-            throw error;
-          }
-        } else {
-          resolvedVersionId = version;
-        }
-      }
-      if (!resolvedVersionId || !compose.content) {
-        throw new Error(`No version found for: ${name}`);
-      }
-      const content = compose.content;
-      let variableSources;
-      try {
-        variableSources = await deriveComposeVariableSources(content, {
-          skipNetwork: options.sources === false
-        });
-      } catch {
-        console.error(
-          chalk40.yellow(
-            "\u26A0 Warning: Failed to fetch skill sources, showing basic info"
-          )
-        );
-      }
-      formatComposeOutput(
-        compose.name,
-        resolvedVersionId,
-        content,
-        variableSources
-      );
-    }
-  )
-);
-
-// src/commands/agent/index.ts
-var agentCommand = new Command45().name("agent").description("Manage agent composes").addCommand(cloneCommand4).addCommand(deleteCommand).addCommand(listCommand5).addCommand(statusCommand5);
-
-// src/commands/init/index.ts
-import { Command as Command46 } from "commander";
-import chalk41 from "chalk";
-import path17 from "path";
+import path16 from "path";
 import { existsSync as existsSync11 } from "fs";
-import { writeFile as writeFile7 } from "fs/promises";
+import { writeFile as writeFile6 } from "fs/promises";
 var VM0_YAML_FILE = "vm0.yaml";
 var AGENTS_MD_FILE = "AGENTS.md";
 function generateVm0Yaml(agentName) {
@@ -20759,7 +20455,7 @@ function checkExistingFiles() {
   if (existsSync11(AGENTS_MD_FILE)) existingFiles.push(AGENTS_MD_FILE);
   return existingFiles;
 }
-var initCommand4 = new Command46().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 Command41().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) {
@@ -20775,7 +20471,7 @@ var initCommand4 = new Command46().name("init").description("Initialize a new VM
         cause: new Error("Usage: vm0 init --name <agent-name>")
       });
     } else {
-      const dirName = path17.basename(process.cwd());
+      const dirName = path16.basename(process.cwd());
       const defaultName = validateAgentName(dirName) ? dirName : void 0;
       const name = await promptText(
         "Enter agent name",
@@ -20788,7 +20484,7 @@ var initCommand4 = new Command46().name("init").description("Initialize a new VM
         }
       );
       if (name === void 0) {
-        console.log(chalk41.dim("Cancelled"));
+        console.log(chalk37.dim("Cancelled"));
         return;
       }
       agentName = name;
@@ -20800,41 +20496,41 @@ var initCommand4 = new Command46().name("init").description("Initialize a new VM
         )
       });
     }
-    await writeFile7(VM0_YAML_FILE, generateVm0Yaml(agentName));
+    await writeFile6(VM0_YAML_FILE, generateVm0Yaml(agentName));
     const vm0Status = existingFiles.includes(VM0_YAML_FILE) ? " (overwritten)" : "";
-    console.log(chalk41.green(`\u2713 Created ${VM0_YAML_FILE}${vm0Status}`));
-    await writeFile7(AGENTS_MD_FILE, generateAgentsMd());
+    console.log(chalk37.green(`\u2713 Created ${VM0_YAML_FILE}${vm0Status}`));
+    await writeFile6(AGENTS_MD_FILE, generateAgentsMd());
     const agentsStatus = existingFiles.includes(AGENTS_MD_FILE) ? " (overwritten)" : "";
-    console.log(chalk41.green(`\u2713 Created ${AGENTS_MD_FILE}${agentsStatus}`));
+    console.log(chalk37.green(`\u2713 Created ${AGENTS_MD_FILE}${agentsStatus}`));
     console.log();
     console.log("Next steps:");
     console.log(
-      `  1. Set up model provider (one-time): ${chalk41.cyan("vm0 org model-provider setup")}`
+      `  1. Set up model provider (one-time): ${chalk37.cyan("vm0 org model-provider setup")}`
     );
     console.log(
-      `  2. Edit ${chalk41.cyan("AGENTS.md")} to customize your agent's workflow`
+      `  2. Edit ${chalk37.cyan("AGENTS.md")} to customize your agent's workflow`
     );
     console.log(
-      `  3. Run your agent: ${chalk41.cyan(`vm0 cook "let's start working"`)}`
+      `  3. Run your agent: ${chalk37.cyan(`vm0 cook "let's start working"`)}`
     );
   })
 );
 
 // src/commands/connector/index.ts
-import { Command as Command51 } from "commander";
+import { Command as Command46 } from "commander";
 
 // src/commands/connector/connect.ts
-import { Command as Command47 } from "commander";
-import chalk43 from "chalk";
-import { initClient as initClient16 } from "@ts-rest/core";
+import { Command as Command42 } from "commander";
+import chalk39 from "chalk";
+import { initClient as initClient17 } from "@ts-rest/core";
 
 // src/commands/connector/lib/computer/start-services.ts
 import { spawn as spawn2 } from "child_process";
 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 chalk42 from "chalk";
+import { join as join10 } from "path";
+import chalk38 from "chalk";
 
 // src/commands/connector/lib/computer/ngrok.ts
 import ngrok from "@ngrok/ngrok";
@@ -20868,11 +20564,11 @@ var CHROME_CANDIDATES = [
   "chrome"
 ];
 async function getRandomPort() {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const server = createServer();
     server.listen(0, "127.0.0.1", () => {
       const { port } = server.address();
-      server.close(() => resolve2(port));
+      server.close(() => resolve(port));
     });
     server.on("error", reject);
   });
@@ -20886,9 +20582,9 @@ async function findBinary(...candidates) {
       } catch {
       }
     } else {
-      const found = await new Promise((resolve2) => {
+      const found = await new Promise((resolve) => {
         const child = spawn2("which", [candidate]);
-        child.on("close", (code) => resolve2(code === 0));
+        child.on("close", (code) => resolve(code === 0));
       });
       if (found) return candidate;
     }
@@ -20908,7 +20604,7 @@ async function checkComputerDependencies() {
   }
 }
 async function startComputerServices(credentials) {
-  console.log(chalk42.cyan("Starting computer connector services..."));
+  console.log(chalk38.cyan("Starting computer connector services..."));
   const wsgidavBinary = await findBinary("wsgidav");
   if (!wsgidavBinary) {
     throw new Error(
@@ -20921,7 +20617,7 @@ async function startComputerServices(credentials) {
   }
   const webdavPort = await getRandomPort();
   const cdpPort = await getRandomPort();
-  const downloadsPath = join12(homedir4(), "Downloads");
+  const downloadsPath = join10(homedir4(), "Downloads");
   const wsgidav = spawn2(
     wsgidavBinary,
     [
@@ -20935,7 +20631,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(chalk42.green("\u2713 WebDAV server started"));
+  console.log(chalk38.green("\u2713 WebDAV server started"));
   const chrome = spawn2(
     chromeBinary,
     [
@@ -20949,7 +20645,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(chalk42.green("\u2713 Chrome started"));
+  console.log(chalk38.green("\u2713 Chrome started"));
   try {
     await startNgrokTunnels(
       credentials.ngrokToken,
@@ -20958,32 +20654,32 @@ async function startComputerServices(credentials) {
       cdpPort
     );
     console.log(
-      chalk42.green(
+      chalk38.green(
         `\u2713 ngrok tunnels: webdav.${credentials.domain}, chrome.${credentials.domain}`
       )
     );
     console.log();
-    console.log(chalk42.green("\u2713 Computer connector active"));
+    console.log(chalk38.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(chalk42.dim("Press ^C twice to disconnect"));
+    console.log(chalk38.dim("Press ^C twice to disconnect"));
     console.log();
     let sigintCount = 0;
-    await new Promise((resolve2) => {
+    await new Promise((resolve) => {
       const keepAlive = setInterval(() => {
       }, 6e4);
       const done = () => {
         clearInterval(keepAlive);
         process.removeListener("SIGINT", onSigint);
-        resolve2();
+        resolve();
       };
       const onSigint = () => {
         sigintCount++;
         if (sigintCount === 1) {
-          console.log(chalk42.dim("\nPress ^C again to disconnect and exit..."));
+          console.log(chalk38.dim("\nPress ^C again to disconnect and exit..."));
         } else {
           done();
         }
@@ -20993,17 +20689,17 @@ async function startComputerServices(credentials) {
     });
   } finally {
     console.log();
-    console.log(chalk42.cyan("Stopping services..."));
+    console.log(chalk38.cyan("Stopping services..."));
     wsgidav.kill("SIGTERM");
     chrome.kill("SIGTERM");
     await stopNgrokTunnels();
-    console.log(chalk42.green("\u2713 Services stopped"));
+    console.log(chalk38.green("\u2713 Services stopped"));
   }
 }
 
 // src/commands/connector/connect.ts
 function delay2(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function getHeaders2() {
   const token = await getActiveToken();
@@ -21022,10 +20718,10 @@ async function getHeaders2() {
 function renderHelpText(text) {
   return text.replace(
     /\[([^\]]+)\]\(([^)]+)\)/g,
-    (_m, label, url) => `${label} (${chalk43.cyan(url)})`
-  ).replace(/\*\*([^*]+)\*\*/g, (_m, content) => chalk43.bold(content)).replace(
+    (_m, label, url) => `${label} (${chalk39.cyan(url)})`
+  ).replace(/\*\*([^*]+)\*\*/g, (_m, content) => chalk39.bold(content)).replace(
     /^> (.+)$/gm,
-    (_m, content) => chalk43.yellow(`  ${content}`)
+    (_m, content) => chalk39.yellow(`  ${content}`)
   );
 }
 async function connectViaApiToken(connectorType, tokenValue) {
@@ -21050,7 +20746,7 @@ async function connectViaApiToken(connectorType, tokenValue) {
     for (const [secretName, secretConfig] of secretEntries) {
       if (!secretConfig.required) continue;
       const value = await promptPassword(
-        `${secretConfig.label}${secretConfig.placeholder ? chalk43.dim(` (${secretConfig.placeholder})`) : ""}:`
+        `${secretConfig.label}${secretConfig.placeholder ? chalk39.dim(` (${secretConfig.placeholder})`) : ""}:`
       );
       if (!value) {
         throw new Error("Cancelled");
@@ -21066,14 +20762,14 @@ async function connectViaApiToken(connectorType, tokenValue) {
     });
   }
   console.log(
-    chalk43.green(`
+    chalk39.green(`
 \u2713 ${config.label} connected successfully via API token!`)
   );
 }
 async function connectComputer(apiUrl, headers) {
   await checkComputerDependencies();
-  console.log(chalk43.cyan("Setting up computer connector..."));
-  const computerClient = initClient16(computerConnectorContract, {
+  console.log(chalk39.cyan("Setting up computer connector..."));
+  const computerClient = initClient17(computerConnectorContract, {
     baseUrl: apiUrl,
     baseHeaders: headers,
     jsonQuery: false
@@ -21087,9 +20783,9 @@ async function connectComputer(apiUrl, headers) {
   }
   const credentials = createResult.body;
   await startComputerServices(credentials);
-  console.log(chalk43.cyan("Disconnecting computer connector..."));
+  console.log(chalk39.cyan("Disconnecting computer connector..."));
   await deleteConnector("computer");
-  console.log(chalk43.green("\u2713 Disconnected computer"));
+  console.log(chalk39.green("\u2713 Disconnected computer"));
   process.exit(0);
 }
 async function resolveAuthMethod(connectorType, tokenFlag) {
@@ -21128,8 +20824,8 @@ async function resolveAuthMethod(connectorType, tokenFlag) {
   );
 }
 async function connectViaOAuth(connectorType, apiUrl, headers) {
-  console.log(`Connecting ${chalk43.cyan(connectorType)}...`);
-  const sessionsClient = initClient16(connectorSessionsContract, {
+  console.log(`Connecting ${chalk39.cyan(connectorType)}...`);
+  const sessionsClient = initClient17(connectorSessionsContract, {
     baseUrl: apiUrl,
     baseHeaders: headers,
     jsonQuery: false
@@ -21144,15 +20840,15 @@ async function connectViaOAuth(connectorType, apiUrl, headers) {
   }
   const session = createResult.body;
   const verificationUrl = `${apiUrl}${session.verificationUrl}`;
-  console.log(chalk43.green("\nSession created"));
-  console.log(chalk43.cyan(`
+  console.log(chalk39.green("\nSession created"));
+  console.log(chalk39.cyan(`
 To connect, visit: ${verificationUrl}`));
   console.log(
     `
 The session expires in ${Math.floor(session.expiresIn / 60)} minutes.`
   );
   console.log("\nWaiting for authorization...");
-  const sessionClient = initClient16(connectorSessionByIdContract, {
+  const sessionClient = initClient17(connectorSessionByIdContract, {
     baseUrl: apiUrl,
     baseHeaders: headers,
     jsonQuery: false
@@ -21177,7 +20873,7 @@ The session expires in ${Math.floor(session.expiresIn / 60)} minutes.`
     switch (status.status) {
       case "complete":
         console.log(
-          chalk43.green(`
+          chalk39.green(`
 
 ${connectorType} connected successfully!`)
         );
@@ -21189,13 +20885,13 @@ ${connectorType} connected successfully!`)
           `Connection failed: ${status.errorMessage || "Unknown error"}`
         );
       case "pending":
-        process.stdout.write(chalk43.dim("."));
+        process.stdout.write(chalk39.dim("."));
         break;
     }
   }
   throw new Error("Session timed out, please try again");
 }
-var connectCommand = new Command47().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 Command42().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) {
@@ -21220,12 +20916,12 @@ var connectCommand = new Command47().name("connect").description("Connect a thir
 );
 
 // src/commands/connector/list.ts
-import { Command as Command48 } from "commander";
-import chalk44 from "chalk";
-var listCommand6 = new Command48().name("list").alias("ls").description("List all connectors and their status").action(
+import { Command as Command43 } from "commander";
+import chalk40 from "chalk";
+var listCommand5 = new Command43().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((c34) => [c34.type, c34]));
+    const connectedMap = new Map(result.connectors.map((c33) => [c33.type, c33]));
     const allTypesRaw = Object.keys(CONNECTOR_TYPES);
     const allTypes = [];
     for (const type2 of allTypesRaw) {
@@ -21244,24 +20940,24 @@ var listCommand6 = new Command48().name("list").alias("ls").description("List al
       statusText.padEnd(statusWidth),
       "ACCOUNT"
     ].join("  ");
-    console.log(chalk44.dim(header));
+    console.log(chalk40.dim(header));
     for (const type2 of allTypes) {
       const connector = connectedMap.get(type2);
       const scopeMismatch = connector !== void 0 && connector.authMethod === "oauth" && !hasRequiredScopes(type2, connector.oauthScopes);
-      const status = connector ? connector.needsReconnect ? chalk44.yellow("!".padEnd(statusWidth)) : scopeMismatch ? chalk44.yellow("!".padEnd(statusWidth)) : chalk44.green("\u2713".padEnd(statusWidth)) : chalk44.dim("-".padEnd(statusWidth));
-      const account = connector?.needsReconnect ? chalk44.yellow("(reconnect needed)") : scopeMismatch ? chalk44.yellow("(permissions update available)") : connector?.externalUsername ? `@${connector.externalUsername}` : chalk44.dim("-");
+      const status = connector ? connector.needsReconnect ? chalk40.yellow("!".padEnd(statusWidth)) : scopeMismatch ? chalk40.yellow("!".padEnd(statusWidth)) : chalk40.green("\u2713".padEnd(statusWidth)) : chalk40.dim("-".padEnd(statusWidth));
+      const account = connector?.needsReconnect ? chalk40.yellow("(reconnect needed)") : scopeMismatch ? chalk40.yellow("(permissions update available)") : connector?.externalUsername ? `@${connector.externalUsername}` : chalk40.dim("-");
       const row = [type2.padEnd(typeWidth), status, account].join("  ");
       console.log(row);
     }
     console.log();
-    console.log(chalk44.dim("To connect a service:"));
-    console.log(chalk44.dim("  vm0 connector connect <type>"));
+    console.log(chalk40.dim("To connect a service:"));
+    console.log(chalk40.dim("  vm0 connector connect <type>"));
   })
 );
 
 // src/commands/connector/status.ts
-import { Command as Command49 } from "commander";
-import chalk45 from "chalk";
+import { Command as Command44 } from "commander";
+import chalk41 from "chalk";
 
 // src/lib/domain/schedule-utils.ts
 function formatRelativeTime2(dateStr) {
@@ -21378,7 +21074,7 @@ function toISODateTime(dateTimeStr) {
 
 // src/commands/connector/status.ts
 var LABEL_WIDTH = 16;
-var statusCommand6 = new Command49().name("status").description("Show detailed status of a connector").argument("<type>", "Connector type (e.g., github)").action(
+var statusCommand5 = new Command44().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) {
@@ -21388,11 +21084,11 @@ var statusCommand6 = new Command49().name("status").description("Show detailed s
       });
     }
     const connector = await getConnector(parseResult.data);
-    console.log(`Connector: ${chalk45.cyan(type2)}`);
+    console.log(`Connector: ${chalk41.cyan(type2)}`);
     console.log();
     if (connector) {
       console.log(
-        `${"Status:".padEnd(LABEL_WIDTH)}${chalk45.green("connected")}`
+        `${"Status:".padEnd(LABEL_WIDTH)}${chalk41.green("connected")}`
       );
       console.log(
         `${"Account:".padEnd(LABEL_WIDTH)}@${connector.externalUsername}`
@@ -21408,7 +21104,7 @@ var statusCommand6 = new Command49().name("status").description("Show detailed s
       if (connector.authMethod === "oauth" && !hasRequiredScopes(parseResult.data, connector.oauthScopes)) {
         const diff = getScopeDiff(parseResult.data, connector.oauthScopes);
         console.log(
-          `${"Permissions:".padEnd(LABEL_WIDTH)}${chalk45.yellow("update available")}`
+          `${"Permissions:".padEnd(LABEL_WIDTH)}${chalk41.yellow("update available")}`
         );
         if (diff.addedScopes.length > 0) {
           console.log(
@@ -21430,23 +21126,23 @@ var statusCommand6 = new Command49().name("status").description("Show detailed s
         );
       }
       console.log();
-      console.log(chalk45.dim("To disconnect:"));
-      console.log(chalk45.dim(`  vm0 connector disconnect ${type2}`));
+      console.log(chalk41.dim("To disconnect:"));
+      console.log(chalk41.dim(`  vm0 connector disconnect ${type2}`));
     } else {
       console.log(
-        `${"Status:".padEnd(LABEL_WIDTH)}${chalk45.dim("not connected")}`
+        `${"Status:".padEnd(LABEL_WIDTH)}${chalk41.dim("not connected")}`
       );
       console.log();
-      console.log(chalk45.dim("To connect:"));
-      console.log(chalk45.dim(`  vm0 connector connect ${type2}`));
+      console.log(chalk41.dim("To connect:"));
+      console.log(chalk41.dim(`  vm0 connector connect ${type2}`));
     }
   })
 );
 
 // src/commands/connector/disconnect.ts
-import { Command as Command50 } from "commander";
-import chalk46 from "chalk";
-var disconnectCommand = new Command50().name("disconnect").description("Disconnect a third-party service").argument("<type>", "Connector type to disconnect (e.g., github)").action(
+import { Command as Command45 } from "commander";
+import chalk42 from "chalk";
+var disconnectCommand = new Command45().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) {
@@ -21457,16 +21153,16 @@ var disconnectCommand = new Command50().name("disconnect").description("Disconne
     }
     const connectorType = parseResult.data;
     await deleteConnector(connectorType);
-    console.log(chalk46.green(`\u2713 Disconnected ${type2}`));
+    console.log(chalk42.green(`\u2713 Disconnected ${type2}`));
   })
 );
 
 // src/commands/connector/index.ts
-var connectorCommand = new Command51().name("connector").description("Manage third-party service connections").addCommand(listCommand6).addCommand(statusCommand6).addCommand(connectCommand).addCommand(disconnectCommand);
+var connectorCommand = new Command46().name("connector").description("Manage third-party service connections").addCommand(listCommand5).addCommand(statusCommand5).addCommand(connectCommand).addCommand(disconnectCommand);
 
 // src/commands/preference/index.ts
-import { Command as Command52 } from "commander";
-import chalk47 from "chalk";
+import { Command as Command47 } from "commander";
+import chalk43 from "chalk";
 function detectTimezone2() {
   return Intl.DateTimeFormat().resolvedOptions().timeZone;
 }
@@ -21487,15 +21183,15 @@ function parseOnOff(flag, value) {
   );
 }
 function displayPreferences(prefs) {
-  console.log(chalk47.bold("Current preferences:"));
+  console.log(chalk43.bold("Current preferences:"));
   console.log(
-    `  Timezone:      ${prefs.timezone ? chalk47.cyan(prefs.timezone) : chalk47.dim("not set")}`
+    `  Timezone:      ${prefs.timezone ? chalk43.cyan(prefs.timezone) : chalk43.dim("not set")}`
   );
   console.log(
-    `  Email notify:  ${prefs.notifyEmail ? chalk47.green("on") : chalk47.dim("off")}`
+    `  Email notify:  ${prefs.notifyEmail ? chalk43.green("on") : chalk43.dim("off")}`
   );
   console.log(
-    `  Slack notify:  ${prefs.notifySlack ? chalk47.green("on") : chalk47.dim("off")}`
+    `  Slack notify:  ${prefs.notifySlack ? chalk43.green("on") : chalk43.dim("off")}`
   );
 }
 function buildUpdates(opts) {
@@ -21525,21 +21221,21 @@ function buildUpdates(opts) {
 function printUpdateResult(updates, result) {
   if (updates.timezone !== void 0) {
     console.log(
-      chalk47.green(
-        `Timezone set to ${chalk47.cyan(result.timezone ?? updates.timezone)}`
+      chalk43.green(
+        `Timezone set to ${chalk43.cyan(result.timezone ?? updates.timezone)}`
       )
     );
   }
   if (updates.notifyEmail !== void 0) {
     console.log(
-      chalk47.green(
+      chalk43.green(
         `Email notifications ${result.notifyEmail ? "enabled" : "disabled"}`
       )
     );
   }
   if (updates.notifySlack !== void 0) {
     console.log(
-      chalk47.green(
+      chalk43.green(
         `Slack notifications ${result.notifySlack ? "enabled" : "disabled"}`
       )
     );
@@ -21548,7 +21244,7 @@ function printUpdateResult(updates, result) {
 async function interactiveSetup(prefs) {
   if (!prefs.timezone) {
     const detectedTz = detectTimezone2();
-    console.log(chalk47.dim(`
+    console.log(chalk43.dim(`
 System timezone detected: ${detectedTz}`));
     const tz = await promptText(
       "Set timezone? (enter timezone or leave empty to skip)",
@@ -21559,7 +21255,7 @@ System timezone detected: ${detectedTz}`));
         throw new Error(`Invalid timezone: ${tz.trim()}`);
       }
       await updateUserPreferences({ timezone: tz.trim() });
-      console.log(chalk47.green(`Timezone set to ${chalk47.cyan(tz.trim())}`));
+      console.log(chalk43.green(`Timezone set to ${chalk43.cyan(tz.trim())}`));
     }
   }
   if (!prefs.notifyEmail) {
@@ -21569,11 +21265,11 @@ System timezone detected: ${detectedTz}`));
     );
     if (enable) {
       await updateUserPreferences({ notifyEmail: true });
-      console.log(chalk47.green("Email notifications enabled"));
+      console.log(chalk43.green("Email notifications enabled"));
     }
   }
 }
-var preferenceCommand = new Command52().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 Command47().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) {
@@ -21588,32 +21284,32 @@ var preferenceCommand = new Command52().name("preference").description("View or
     } else if (!prefs.timezone) {
       console.log();
       console.log(
-        `To set timezone: ${chalk47.cyan("vm0 preference --timezone <timezone>")}`
+        `To set timezone: ${chalk43.cyan("vm0 preference --timezone <timezone>")}`
       );
       console.log(
-        chalk47.dim("Example: vm0 preference --timezone America/New_York")
+        chalk43.dim("Example: vm0 preference --timezone America/New_York")
       );
     }
   })
 );
 
 // src/commands/upgrade/index.ts
-import { Command as Command53 } from "commander";
-import chalk48 from "chalk";
-var upgradeCommand = new Command53().name("upgrade").description("Upgrade vm0 CLI to the latest version").action(
+import { Command as Command48 } from "commander";
+import chalk44 from "chalk";
+var upgradeCommand = new Command48().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.77.1") {
-      console.log(chalk48.green(`\u2713 Already up to date (${"9.77.1"})`));
+    if (latestVersion === "9.78.0") {
+      console.log(chalk44.green(`\u2713 Already up to date (${"9.78.0"})`));
       return;
     }
     console.log(
-      chalk48.yellow(
-        `Current version: ${"9.77.1"} -> Latest version: ${latestVersion}`
+      chalk44.yellow(
+        `Current version: ${"9.78.0"} -> Latest version: ${latestVersion}`
       )
     );
     console.log();
@@ -21621,26 +21317,26 @@ var upgradeCommand = new Command53().name("upgrade").description("Upgrade vm0 CL
     if (!isAutoUpgradeSupported(packageManager)) {
       if (packageManager === "unknown") {
         console.log(
-          chalk48.yellow(
+          chalk44.yellow(
             "Could not detect your package manager for auto-upgrade."
           )
         );
       } else {
         console.log(
-          chalk48.yellow(
+          chalk44.yellow(
             `Auto-upgrade is not supported for ${packageManager}.`
           )
         );
       }
-      console.log(chalk48.yellow("Please upgrade manually:"));
-      console.log(chalk48.cyan(`  ${getManualUpgradeCommand(packageManager)}`));
+      console.log(chalk44.yellow("Please upgrade manually:"));
+      console.log(chalk44.cyan(`  ${getManualUpgradeCommand(packageManager)}`));
       return;
     }
     console.log(`Upgrading via ${packageManager}...`);
     const success = await performUpgrade(packageManager);
     if (success) {
       console.log(
-        chalk48.green(`\u2713 Upgraded from ${"9.77.1"} to ${latestVersion}`)
+        chalk44.green(`\u2713 Upgraded from ${"9.78.0"} to ${latestVersion}`)
       );
       return;
     }
@@ -21653,8 +21349,8 @@ var upgradeCommand = new Command53().name("upgrade").description("Upgrade vm0 CL
 );
 
 // src/commands/whoami.ts
-import { Command as Command54 } from "commander";
-import chalk49 from "chalk";
+import { Command as Command49 } from "commander";
+import chalk45 from "chalk";
 function isInsideSandbox() {
   return !!process.env.VM0_RUN_ID;
 }
@@ -21669,7 +21365,7 @@ async function showSandboxInfo() {
   const apiUrl = process.env.VM0_API_URL;
   const hasAgentInfo = agentName || agentVersion || agentComposeId || agentOrgSlug || cliAgentType;
   if (hasAgentInfo) {
-    console.log(chalk49.bold("Agent:"));
+    console.log(chalk45.bold("Agent:"));
     if (agentName) console.log(`  Name:       ${agentName}`);
     if (agentVersion) console.log(`  Version:    ${agentVersion}`);
     if (agentComposeId) console.log(`  Compose ID: ${agentComposeId}`);
@@ -21677,7 +21373,7 @@ async function showSandboxInfo() {
     if (cliAgentType) console.log(`  Framework:  ${cliAgentType}`);
     console.log();
   }
-  console.log(chalk49.bold("Run:"));
+  console.log(chalk45.bold("Run:"));
   if (runId) console.log(`  ID:         ${runId}`);
   if (activeOrg) console.log(`  Org:        ${activeOrg}`);
   if (apiUrl) console.log(`  API:        ${apiUrl}`);
@@ -21686,23 +21382,23 @@ async function showLocalInfo() {
   const token = await getToken();
   const apiUrl = await getApiUrl();
   const activeOrg = await getActiveOrg();
-  console.log(chalk49.bold("Auth:"));
+  console.log(chalk45.bold("Auth:"));
   if (token) {
     const tokenSource = process.env.VM0_TOKEN ? "VM0_TOKEN env var" : "config file";
     console.log(
-      `  Status:     ${chalk49.green("Authenticated")} (via ${tokenSource})`
+      `  Status:     ${chalk45.green("Authenticated")} (via ${tokenSource})`
     );
   } else {
-    console.log(`  Status:     ${chalk49.dim("Not authenticated")}`);
+    console.log(`  Status:     ${chalk45.dim("Not authenticated")}`);
   }
   console.log(`  API:        ${apiUrl}`);
   console.log();
   if (activeOrg) {
-    console.log(chalk49.bold("Org:"));
+    console.log(chalk45.bold("Org:"));
     console.log(`  Active:     ${activeOrg}`);
   }
 }
-var whoamiCommand = new Command54().name("whoami").description("Show current identity and environment information").action(
+var whoamiCommand = new Command49().name("whoami").description("Show current identity and environment information").action(
   withErrorHandler(async () => {
     if (isInsideSandbox()) {
       await showSandboxInfo();
@@ -21716,17 +21412,17 @@ var whoamiCommand = new Command54().name("whoami").description("Show current ide
 import { Command as Command99 } from "commander";
 
 // src/commands/zero/org/index.ts
-import { Command as Command77 } from "commander";
+import { Command as Command72 } from "commander";
 
 // src/commands/zero/org/status.ts
-import { Command as Command55 } from "commander";
-import chalk50 from "chalk";
-var statusCommand7 = new Command55().name("status").description("View current organization status").action(
+import { Command as Command50 } from "commander";
+import chalk46 from "chalk";
+var statusCommand6 = new Command50().name("status").description("View current organization status").action(
   withErrorHandler(async () => {
     try {
       const org = await getZeroOrg();
-      console.log(chalk50.bold("Organization Information:"));
-      console.log(`  Slug: ${chalk50.green(org.slug)}`);
+      console.log(chalk46.bold("Organization Information:"));
+      console.log(`  Slug: ${chalk46.green(org.slug)}`);
     } catch (error) {
       if (error instanceof ApiRequestError && error.status === 404) {
         throw new Error("No organization configured", {
@@ -21741,9 +21437,9 @@ var statusCommand7 = new Command55().name("status").description("View current or
 );
 
 // src/commands/zero/org/set.ts
-import { Command as Command56 } from "commander";
-import chalk51 from "chalk";
-var setCommand = new Command56().name("set").description("Rename your organization slug").argument("<slug>", "The new organization slug").option(
+import { Command as Command51 } from "commander";
+import chalk47 from "chalk";
+var setCommand = new Command51().name("set").description("Rename your organization slug").argument("<slug>", "The new organization slug").option(
   "--force",
   "Force change existing organization (may break references)"
 ).action(
@@ -21762,10 +21458,10 @@ var setCommand = new Command56().name("set").description("Rename your organizati
       }
       const org = await updateZeroOrg({ slug, force: true });
       await saveConfig({ activeOrg: org.slug });
-      console.log(chalk51.green(`\u2713 Organization updated to ${org.slug}`));
+      console.log(chalk47.green(`\u2713 Organization updated to ${org.slug}`));
       console.log();
       console.log("Your agents will now be namespaced as:");
-      console.log(chalk51.cyan(`  ${org.slug}/<agent-name>`));
+      console.log(chalk47.cyan(`  ${org.slug}/<agent-name>`));
     } catch (error) {
       if (error instanceof Error && error.message.includes("already exists")) {
         throw new Error(
@@ -21778,27 +21474,27 @@ var setCommand = new Command56().name("set").description("Rename your organizati
 );
 
 // src/commands/zero/org/list.ts
-import { Command as Command57 } from "commander";
-import chalk52 from "chalk";
-var listCommand7 = new Command57().name("list").description("List all accessible organizations").action(
+import { Command as Command52 } from "commander";
+import chalk48 from "chalk";
+var listCommand6 = new Command52().name("list").description("List all accessible organizations").action(
   withErrorHandler(async () => {
     const result = await listZeroOrgs();
     const activeOrg = await getActiveOrg();
-    console.log(chalk52.bold("Available organizations:"));
+    console.log(chalk48.bold("Available organizations:"));
     for (const org of result.orgs) {
       const isCurrent = org.slug === activeOrg;
-      const marker = isCurrent ? chalk52.green("* ") : "  ";
+      const marker = isCurrent ? chalk48.green("* ") : "  ";
       const roleLabel = org.role ? ` (${org.role})` : "";
-      const currentLabel = isCurrent ? chalk52.dim(" \u2190 current") : "";
+      const currentLabel = isCurrent ? chalk48.dim(" \u2190 current") : "";
       console.log(`${marker}${org.slug}${roleLabel}${currentLabel}`);
     }
   })
 );
 
 // src/commands/zero/org/use.ts
-import { Command as Command58 } from "commander";
-import chalk53 from "chalk";
-var useCommand = new Command58().name("use").description("Switch to a different organization").argument("<slug>", "Organization slug to switch to").action(
+import { Command as Command53 } from "commander";
+import chalk49 from "chalk";
+var useCommand = new Command53().name("use").description("Switch to a different organization").argument("<slug>", "Organization slug to switch to").action(
   withErrorHandler(async (slug) => {
     const orgList = await listZeroOrgs();
     const target = orgList.orgs.find((s) => s.slug === slug);
@@ -21806,119 +21502,119 @@ var useCommand = new Command58().name("use").description("Switch to a different
       throw new Error(`Organization '${slug}' not found or not accessible.`);
     }
     await saveConfig({ activeOrg: slug });
-    console.log(chalk53.green(`\u2713 Switched to organization: ${slug}`));
+    console.log(chalk49.green(`\u2713 Switched to organization: ${slug}`));
   })
 );
 
 // src/commands/zero/org/members.ts
-import { Command as Command59 } from "commander";
-import chalk54 from "chalk";
-var membersCommand = new Command59().name("members").description("View organization members").action(
+import { Command as Command54 } from "commander";
+import chalk50 from "chalk";
+var membersCommand = new Command54().name("members").description("View organization members").action(
   withErrorHandler(async () => {
     const status = await getZeroOrgMembers();
-    console.log(chalk54.bold(`Organization: ${status.slug}`));
+    console.log(chalk50.bold(`Organization: ${status.slug}`));
     console.log(`  Role: ${status.role}`);
     console.log(
       `  Created: ${new Date(status.createdAt).toLocaleDateString()}`
     );
     console.log();
-    console.log(chalk54.bold("Members:"));
+    console.log(chalk50.bold("Members:"));
     for (const member of status.members) {
-      const roleTag = member.role === "admin" ? chalk54.yellow(` (${member.role})`) : chalk54.dim(` (${member.role})`);
+      const roleTag = member.role === "admin" ? chalk50.yellow(` (${member.role})`) : chalk50.dim(` (${member.role})`);
       console.log(`  ${member.email}${roleTag}`);
     }
   })
 );
 
 // src/commands/zero/org/invite.ts
-import { Command as Command60 } from "commander";
-import chalk55 from "chalk";
-var inviteCommand = new Command60().name("invite").description("Invite a member to the current organization").requiredOption("--email <email>", "Email address of the member to invite").action(
+import { Command as Command55 } from "commander";
+import chalk51 from "chalk";
+var inviteCommand = new Command55().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 inviteZeroOrgMember(options.email);
-    console.log(chalk55.green(`\u2713 Invitation sent to ${options.email}`));
+    console.log(chalk51.green(`\u2713 Invitation sent to ${options.email}`));
   })
 );
 
 // src/commands/zero/org/remove.ts
-import { Command as Command61 } from "commander";
-import chalk56 from "chalk";
-var removeCommand = new Command61().name("remove").description("Remove a member from the current organization").argument("<email>", "Email address of the member to remove").action(
+import { Command as Command56 } from "commander";
+import chalk52 from "chalk";
+var removeCommand = new Command56().name("remove").description("Remove a member from the current organization").argument("<email>", "Email address of the member to remove").action(
   withErrorHandler(async (email) => {
     await removeZeroOrgMember(email);
-    console.log(chalk56.green(`\u2713 Removed ${email} from organization`));
+    console.log(chalk52.green(`\u2713 Removed ${email} from organization`));
   })
 );
 
 // src/commands/zero/org/leave.ts
-import { Command as Command62 } from "commander";
-import chalk57 from "chalk";
-var leaveCommand = new Command62().name("leave").description("Leave the current organization").action(
+import { Command as Command57 } from "commander";
+import chalk53 from "chalk";
+var leaveCommand = new Command57().name("leave").description("Leave the current organization").action(
   withErrorHandler(async () => {
     await leaveZeroOrg();
     const { orgs } = await listZeroOrgs();
     if (orgs.length === 0) {
       await saveConfig({ activeOrg: void 0 });
-      console.log(chalk57.green("\u2713 Left organization."));
+      console.log(chalk53.green("\u2713 Left organization."));
       console.log(
-        chalk57.yellow("No remaining organizations. Run: vm0 auth login")
+        chalk53.yellow("No remaining organizations. Run: vm0 auth login")
       );
       return;
     }
     const nextOrg = orgs[0].slug;
     await saveConfig({ activeOrg: nextOrg });
-    console.log(chalk57.green(`\u2713 Left organization. Switched to: ${nextOrg}`));
+    console.log(chalk53.green(`\u2713 Left organization. Switched to: ${nextOrg}`));
   })
 );
 
 // src/commands/zero/org/delete.ts
-import { Command as Command63 } from "commander";
-import chalk58 from "chalk";
-var deleteCommand2 = new Command63().name("delete").description("Delete the current organization (admin only)").argument("<slug>", "Organization slug to confirm deletion").action(
+import { Command as Command58 } from "commander";
+import chalk54 from "chalk";
+var deleteCommand = new Command58().name("delete").description("Delete the current organization (admin only)").argument("<slug>", "Organization slug to confirm deletion").action(
   withErrorHandler(async (slug) => {
     await deleteZeroOrg(slug);
-    console.log(chalk58.green(`\u2713 Organization '${slug}' has been deleted.`));
+    console.log(chalk54.green(`\u2713 Organization '${slug}' has been deleted.`));
   })
 );
 
 // src/commands/zero/org/secret/index.ts
-import { Command as Command67 } from "commander";
+import { Command as Command62 } from "commander";
 
 // src/commands/zero/org/secret/list.ts
-import { Command as Command64 } from "commander";
-import chalk59 from "chalk";
-var listCommand8 = new Command64().name("list").alias("ls").description("List all org-level secrets").action(
+import { Command as Command59 } from "commander";
+import chalk55 from "chalk";
+var listCommand7 = new Command59().name("list").alias("ls").description("List all org-level secrets").action(
   withErrorHandler(async () => {
     const result = await listZeroOrgSecrets();
     if (result.secrets.length === 0) {
-      console.log(chalk59.dim("No org secrets found"));
+      console.log(chalk55.dim("No org secrets found"));
       console.log();
       console.log("To add an org secret:");
       console.log(
-        chalk59.cyan("  vm0 zero org secret set MY_API_KEY --body <value>")
+        chalk55.cyan("  vm0 zero org secret set MY_API_KEY --body <value>")
       );
       return;
     }
-    console.log(chalk59.bold("Org Secrets:"));
+    console.log(chalk55.bold("Org Secrets:"));
     console.log();
     for (const secret of result.secrets) {
-      console.log(`  ${chalk59.cyan(secret.name)}`);
+      console.log(`  ${chalk55.cyan(secret.name)}`);
       if (secret.description) {
-        console.log(`    ${chalk59.dim(secret.description)}`);
+        console.log(`    ${chalk55.dim(secret.description)}`);
       }
       console.log(
-        `    ${chalk59.dim(`Updated: ${new Date(secret.updatedAt).toLocaleString()}`)}`
+        `    ${chalk55.dim(`Updated: ${new Date(secret.updatedAt).toLocaleString()}`)}`
       );
       console.log();
     }
-    console.log(chalk59.dim(`Total: ${result.secrets.length} secret(s)`));
+    console.log(chalk55.dim(`Total: ${result.secrets.length} secret(s)`));
   })
 );
 
 // src/commands/zero/org/secret/set.ts
-import { Command as Command65 } from "commander";
-import chalk60 from "chalk";
-var setCommand2 = new Command65().name("set").description("Create or update an org-level secret (admin only)").argument("<name>", "Secret name (uppercase, e.g., MY_API_KEY)").option(
+import { Command as Command60 } from "commander";
+import chalk56 from "chalk";
+var setCommand2 = new Command60().name("set").description("Create or update an org-level secret (admin only)").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(
@@ -21957,19 +21653,19 @@ var setCommand2 = new Command65().name("set").description("Create or update an o
         }
         throw error;
       }
-      console.log(chalk60.green(`\u2713 Org secret "${secret.name}" saved`));
+      console.log(chalk56.green(`\u2713 Org secret "${secret.name}" saved`));
       console.log();
       console.log("Use in vm0.yaml:");
-      console.log(chalk60.cyan(`  environment:`));
-      console.log(chalk60.cyan(`    ${name}: \${{ secrets.${name} }}`));
+      console.log(chalk56.cyan(`  environment:`));
+      console.log(chalk56.cyan(`    ${name}: \${{ secrets.${name} }}`));
     }
   )
 );
 
 // src/commands/zero/org/secret/remove.ts
-import { Command as Command66 } from "commander";
-import chalk61 from "chalk";
-var removeCommand2 = new Command66().name("remove").description("Delete an org-level secret (admin only)").argument("<name>", "Secret name to delete").option("-y, --yes", "Skip confirmation prompt").action(
+import { Command as Command61 } from "commander";
+import chalk57 from "chalk";
+var removeCommand2 = new Command61().name("remove").description("Delete an org-level secret (admin only)").argument("<name>", "Secret name to delete").option("-y, --yes", "Skip confirmation prompt").action(
   withErrorHandler(async (name, options) => {
     if (!options.yes) {
       if (!isInteractive()) {
@@ -21980,61 +21676,61 @@ var removeCommand2 = new Command66().name("remove").description("Delete an org-l
         false
       );
       if (!confirmed) {
-        console.log(chalk61.dim("Cancelled"));
+        console.log(chalk57.dim("Cancelled"));
         return;
       }
     }
     await deleteZeroOrgSecret(name);
-    console.log(chalk61.green(`\u2713 Org secret "${name}" deleted`));
+    console.log(chalk57.green(`\u2713 Org secret "${name}" deleted`));
   })
 );
 
 // src/commands/zero/org/secret/index.ts
-var zeroOrgSecretCommand = new Command67().name("secret").description("Manage org-level secrets (admin)").addCommand(listCommand8).addCommand(setCommand2).addCommand(removeCommand2);
+var zeroOrgSecretCommand = new Command62().name("secret").description("Manage org-level secrets (admin)").addCommand(listCommand7).addCommand(setCommand2).addCommand(removeCommand2);
 
 // src/commands/zero/org/variable/index.ts
-import { Command as Command71 } from "commander";
+import { Command as Command66 } from "commander";
 
 // src/commands/zero/org/variable/list.ts
-import { Command as Command68 } from "commander";
-import chalk62 from "chalk";
+import { Command as Command63 } from "commander";
+import chalk58 from "chalk";
 function truncateValue(value, maxLength = 60) {
   if (value.length <= maxLength) {
     return value;
   }
   return value.slice(0, maxLength - 15) + "... [truncated]";
 }
-var listCommand9 = new Command68().name("list").alias("ls").description("List all org-level variables").action(
+var listCommand8 = new Command63().name("list").alias("ls").description("List all org-level variables").action(
   withErrorHandler(async () => {
     const result = await listZeroOrgVariables();
     if (result.variables.length === 0) {
-      console.log(chalk62.dim("No org variables found"));
+      console.log(chalk58.dim("No org variables found"));
       console.log();
       console.log("To add an org variable:");
-      console.log(chalk62.cyan("  vm0 zero org variable set MY_VAR <value>"));
+      console.log(chalk58.cyan("  vm0 zero org variable set MY_VAR <value>"));
       return;
     }
-    console.log(chalk62.bold("Org Variables:"));
+    console.log(chalk58.bold("Org Variables:"));
     console.log();
     for (const variable of result.variables) {
       const displayValue = truncateValue(variable.value);
-      console.log(`  ${chalk62.cyan(variable.name)} = ${displayValue}`);
+      console.log(`  ${chalk58.cyan(variable.name)} = ${displayValue}`);
       if (variable.description) {
-        console.log(`    ${chalk62.dim(variable.description)}`);
+        console.log(`    ${chalk58.dim(variable.description)}`);
       }
       console.log(
-        `    ${chalk62.dim(`Updated: ${new Date(variable.updatedAt).toLocaleString()}`)}`
+        `    ${chalk58.dim(`Updated: ${new Date(variable.updatedAt).toLocaleString()}`)}`
       );
       console.log();
     }
-    console.log(chalk62.dim(`Total: ${result.variables.length} variable(s)`));
+    console.log(chalk58.dim(`Total: ${result.variables.length} variable(s)`));
   })
 );
 
 // src/commands/zero/org/variable/set.ts
-import { Command as Command69 } from "commander";
-import chalk63 from "chalk";
-var setCommand3 = new Command69().name("set").description("Create or update an org-level variable (admin only)").argument("<name>", "Variable name (uppercase, e.g., MY_VAR)").argument("<value>", "Variable value").option("-d, --description <description>", "Optional description").action(
+import { Command as Command64 } from "commander";
+import chalk59 from "chalk";
+var setCommand3 = new Command64().name("set").description("Create or update an org-level variable (admin only)").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;
@@ -22054,19 +21750,19 @@ var setCommand3 = new Command69().name("set").description("Create or update an o
         }
         throw error;
       }
-      console.log(chalk63.green(`\u2713 Org variable "${variable.name}" saved`));
+      console.log(chalk59.green(`\u2713 Org variable "${variable.name}" saved`));
       console.log();
       console.log("Use in vm0.yaml:");
-      console.log(chalk63.cyan(`  environment:`));
-      console.log(chalk63.cyan(`    ${name}: \${{ vars.${name} }}`));
+      console.log(chalk59.cyan(`  environment:`));
+      console.log(chalk59.cyan(`    ${name}: \${{ vars.${name} }}`));
     }
   )
 );
 
 // src/commands/zero/org/variable/remove.ts
-import { Command as Command70 } from "commander";
-import chalk64 from "chalk";
-var removeCommand3 = new Command70().name("remove").description("Delete an org-level variable (admin only)").argument("<name>", "Variable name to delete").option("-y, --yes", "Skip confirmation prompt").action(
+import { Command as Command65 } from "commander";
+import chalk60 from "chalk";
+var removeCommand3 = new Command65().name("remove").description("Delete an org-level variable (admin only)").argument("<name>", "Variable name to delete").option("-y, --yes", "Skip confirmation prompt").action(
   withErrorHandler(async (name, options) => {
     if (!options.yes) {
       if (!isInteractive()) {
@@ -22077,32 +21773,32 @@ var removeCommand3 = new Command70().name("remove").description("Delete an org-l
         false
       );
       if (!confirmed) {
-        console.log(chalk64.dim("Cancelled"));
+        console.log(chalk60.dim("Cancelled"));
         return;
       }
     }
     await deleteZeroOrgVariable(name);
-    console.log(chalk64.green(`\u2713 Org variable "${name}" deleted`));
+    console.log(chalk60.green(`\u2713 Org variable "${name}" deleted`));
   })
 );
 
 // src/commands/zero/org/variable/index.ts
-var zeroOrgVariableCommand = new Command71().name("variable").description("Manage org-level variables (admin)").addCommand(listCommand9).addCommand(setCommand3).addCommand(removeCommand3);
+var zeroOrgVariableCommand = new Command66().name("variable").description("Manage org-level variables (admin)").addCommand(listCommand8).addCommand(setCommand3).addCommand(removeCommand3);
 
 // src/commands/zero/org/model-provider/index.ts
-import { Command as Command76 } from "commander";
+import { Command as Command71 } from "commander";
 
 // src/commands/zero/org/model-provider/list.ts
-import { Command as Command72 } from "commander";
-import chalk65 from "chalk";
-var listCommand10 = new Command72().name("list").alias("ls").description("List all org-level model providers").action(
+import { Command as Command67 } from "commander";
+import chalk61 from "chalk";
+var listCommand9 = new Command67().name("list").alias("ls").description("List all org-level model providers").action(
   withErrorHandler(async () => {
     const result = await listZeroOrgModelProviders();
     if (result.modelProviders.length === 0) {
-      console.log(chalk65.dim("No org-level model providers configured"));
+      console.log(chalk61.dim("No org-level model providers configured"));
       console.log();
       console.log("To add an org-level model provider:");
-      console.log(chalk65.cyan("  vm0 zero org model-provider setup"));
+      console.log(chalk61.cyan("  vm0 zero org model-provider setup"));
       return;
     }
     const byFramework = result.modelProviders.reduce(
@@ -22116,16 +21812,16 @@ var listCommand10 = new Command72().name("list").alias("ls").description("List a
       },
       {}
     );
-    console.log(chalk65.bold("Org Model Providers:"));
+    console.log(chalk61.bold("Org Model Providers:"));
     console.log();
     for (const [framework, providers] of Object.entries(byFramework)) {
-      console.log(`  ${chalk65.cyan(framework)}:`);
+      console.log(`  ${chalk61.cyan(framework)}:`);
       for (const provider of providers) {
-        const defaultTag = provider.isDefault ? chalk65.green(" (default)") : "";
-        const modelTag = provider.selectedModel ? chalk65.dim(` [${provider.selectedModel}]`) : "";
+        const defaultTag = provider.isDefault ? chalk61.green(" (default)") : "";
+        const modelTag = provider.selectedModel ? chalk61.dim(` [${provider.selectedModel}]`) : "";
         console.log(`    ${provider.type}${defaultTag}${modelTag}`);
         console.log(
-          chalk65.dim(
+          chalk61.dim(
             `      Updated: ${new Date(provider.updatedAt).toLocaleString()}`
           )
         );
@@ -22133,18 +21829,18 @@ var listCommand10 = new Command72().name("list").alias("ls").description("List a
       console.log();
     }
     console.log(
-      chalk65.dim(`Total: ${result.modelProviders.length} provider(s)`)
+      chalk61.dim(`Total: ${result.modelProviders.length} provider(s)`)
     );
   })
 );
 
 // src/commands/zero/org/model-provider/setup.ts
-import { Command as Command73 } from "commander";
-import chalk67 from "chalk";
+import { Command as Command68 } from "commander";
+import chalk63 from "chalk";
 import prompts3 from "prompts";
 
 // src/lib/domain/model-provider/shared.ts
-import chalk66 from "chalk";
+import chalk62 from "chalk";
 import prompts2 from "prompts";
 function validateProviderType(typeStr) {
   if (!Object.keys(MODEL_PROVIDER_TYPES).includes(typeStr)) {
@@ -22329,7 +22025,7 @@ async function promptForModelSelection(type2) {
   if (selected === "__custom__") {
     const placeholder = getCustomModelPlaceholder(type2);
     if (placeholder) {
-      console.log(chalk66.dim(`Example: ${placeholder}`));
+      console.log(chalk62.dim(`Example: ${placeholder}`));
     }
     const customResponse = await prompts2(
       {
@@ -22379,7 +22075,7 @@ async function promptForSecrets(type2, authMethod) {
   const secrets = {};
   for (const [name, fieldConfig] of Object.entries(secretsConfig)) {
     if (fieldConfig.helpText) {
-      console.log(chalk66.dim(fieldConfig.helpText));
+      console.log(chalk62.dim(fieldConfig.helpText));
     }
     const isSensitive = isSensitiveSecret(name);
     const placeholder = "placeholder" in fieldConfig ? fieldConfig.placeholder : "";
@@ -22436,7 +22132,7 @@ async function handleInteractiveMode() {
       title = `${title} \u2713`;
     }
     if (isExperimental) {
-      title = `${title} ${chalk67.dim("(experimental)")}`;
+      title = `${title} ${chalk63.dim("(experimental)")}`;
     }
     return {
       title,
@@ -22483,7 +22179,7 @@ async function handleInteractiveMode() {
   const config = MODEL_PROVIDER_TYPES[type2];
   console.log();
   if ("helpText" in config) {
-    console.log(chalk67.dim(config.helpText));
+    console.log(chalk63.dim(config.helpText));
   }
   console.log();
   if (hasAuthMethods(type2)) {
@@ -22525,10 +22221,10 @@ async function promptSetAsDefault(type2, framework, isDefault) {
   );
   if (response.setDefault) {
     await setZeroOrgModelProviderDefault(type2);
-    console.log(chalk67.green(`\u2713 Default for ${framework} set to "${type2}"`));
+    console.log(chalk63.green(`\u2713 Default for ${framework} set to "${type2}"`));
   }
 }
-var setupCommand = new Command73().name("setup").description("Configure an org-level model provider").option("-t, --type <type>", "Provider type (for non-interactive mode)").option(
+var setupCommand = new Command68().name("setup").description("Configure an org-level 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,
@@ -22567,11 +22263,11 @@ var setupCommand = new Command73().name("setup").description("Configure an org-l
         const modelNote2 = provider2.selectedModel ? ` with model: ${provider2.selectedModel}` : "";
         if (!hasModelSelection(input.type)) {
           console.log(
-            chalk67.green(`\u2713 Org model provider "${input.type}" unchanged`)
+            chalk63.green(`\u2713 Org model provider "${input.type}" unchanged`)
           );
         } else {
           console.log(
-            chalk67.green(
+            chalk63.green(
               `\u2713 Org model provider "${input.type}" updated${defaultNote2}${modelNote2}`
             )
           );
@@ -22596,7 +22292,7 @@ var setupCommand = new Command73().name("setup").description("Configure an org-l
       const defaultNote = provider.isDefault ? ` (default for ${provider.framework})` : "";
       const modelNote = provider.selectedModel ? ` with model: ${provider.selectedModel}` : "";
       console.log(
-        chalk67.green(
+        chalk63.green(
           `\u2713 Org model provider "${input.type}" ${action}${defaultNote}${modelNote}`
         )
       );
@@ -22612,9 +22308,9 @@ var setupCommand = new Command73().name("setup").description("Configure an org-l
 );
 
 // src/commands/zero/org/model-provider/remove.ts
-import { Command as Command74 } from "commander";
-import chalk68 from "chalk";
-var removeCommand4 = new Command74().name("remove").description("Remove an org-level model provider").argument("<type>", "Model provider type to remove").action(
+import { Command as Command69 } from "commander";
+import chalk64 from "chalk";
+var removeCommand4 = new Command69().name("remove").description("Remove an org-level model provider").argument("<type>", "Model provider type to remove").action(
   withErrorHandler(async (type2) => {
     if (!Object.keys(MODEL_PROVIDER_TYPES).includes(type2)) {
       const validTypes = Object.keys(MODEL_PROVIDER_TYPES).join(", ");
@@ -22623,14 +22319,14 @@ var removeCommand4 = new Command74().name("remove").description("Remove an org-l
       });
     }
     await deleteZeroOrgModelProvider(type2);
-    console.log(chalk68.green(`\u2713 Org model provider "${type2}" removed`));
+    console.log(chalk64.green(`\u2713 Org model provider "${type2}" removed`));
   })
 );
 
 // src/commands/zero/org/model-provider/set-default.ts
-import { Command as Command75 } from "commander";
-import chalk69 from "chalk";
-var setDefaultCommand = new Command75().name("set-default").description("Set an org-level model provider as default for its framework").argument("<type>", "Model provider type to set as default").action(
+import { Command as Command70 } from "commander";
+import chalk65 from "chalk";
+var setDefaultCommand = new Command70().name("set-default").description("Set an org-level 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(", ");
@@ -22642,7 +22338,7 @@ var setDefaultCommand = new Command75().name("set-default").description("Set an
       type2
     );
     console.log(
-      chalk69.green(
+      chalk65.green(
         `\u2713 Default for ${provider.framework} set to "${provider.type}"`
       )
     );
@@ -22650,19 +22346,19 @@ var setDefaultCommand = new Command75().name("set-default").description("Set an
 );
 
 // src/commands/zero/org/model-provider/index.ts
-var zeroOrgModelProviderCommand = new Command76().name("model-provider").description("Manage org-level model providers").addCommand(listCommand10).addCommand(setupCommand).addCommand(removeCommand4).addCommand(setDefaultCommand);
+var zeroOrgModelProviderCommand = new Command71().name("model-provider").description("Manage org-level model providers").addCommand(listCommand9).addCommand(setupCommand).addCommand(removeCommand4).addCommand(setDefaultCommand);
 
 // src/commands/zero/org/index.ts
-var zeroOrgCommand = new Command77().name("org").description("Manage your organization").addCommand(statusCommand7).addCommand(setCommand).addCommand(listCommand7).addCommand(useCommand).addCommand(membersCommand).addCommand(inviteCommand).addCommand(removeCommand).addCommand(leaveCommand).addCommand(deleteCommand2).addCommand(zeroOrgSecretCommand).addCommand(zeroOrgVariableCommand).addCommand(zeroOrgModelProviderCommand);
+var zeroOrgCommand = new Command72().name("org").description("Manage your organization").addCommand(statusCommand6).addCommand(setCommand).addCommand(listCommand6).addCommand(useCommand).addCommand(membersCommand).addCommand(inviteCommand).addCommand(removeCommand).addCommand(leaveCommand).addCommand(deleteCommand).addCommand(zeroOrgSecretCommand).addCommand(zeroOrgVariableCommand).addCommand(zeroOrgModelProviderCommand);
 
 // src/commands/zero/agent/index.ts
-import { Command as Command83 } from "commander";
+import { Command as Command78 } from "commander";
 
 // src/commands/zero/agent/create.ts
-import { Command as Command78 } from "commander";
+import { Command as Command73 } from "commander";
 import { readFileSync } from "fs";
-import chalk70 from "chalk";
-var createCommand = new Command78().name("create").description("Create a new zero agent").requiredOption(
+import chalk66 from "chalk";
+var createCommand = new Command73().name("create").description("Create a new zero agent").requiredOption(
   "--connectors <items>",
   "Comma-separated connector short names (e.g. github,linear)"
 ).option("--display-name <name>", "Agent display name").option("--description <text>", "Agent description").option(
@@ -22682,7 +22378,7 @@ var createCommand = new Command78().name("create").description("Create a new zer
         const content = readFileSync(options.instructionsFile, "utf-8");
         await updateZeroAgentInstructions(agent.name, content);
       }
-      console.log(chalk70.green(`\u2713 Zero agent '${agent.name}' created`));
+      console.log(chalk66.green(`\u2713 Zero agent '${agent.name}' created`));
       console.log(`  Compose ID:   ${agent.agentComposeId}`);
       console.log(`  Connectors:   ${agent.connectors.join(", ")}`);
       if (agent.displayName) {
@@ -22693,10 +22389,10 @@ var createCommand = new Command78().name("create").description("Create a new zer
 );
 
 // src/commands/zero/agent/edit.ts
-import { Command as Command79 } from "commander";
+import { Command as Command74 } from "commander";
 import { readFileSync as readFileSync2 } from "fs";
-import chalk71 from "chalk";
-var editCommand = new Command79().name("edit").description("Edit a zero agent").argument("<name>", "Agent name").option(
+import chalk67 from "chalk";
+var editCommand = new Command74().name("edit").description("Edit a zero agent").argument("<name>", "Agent name").option(
   "--connectors <items>",
   "Comma-separated connector short names (e.g. github,linear)"
 ).option("--display-name <name>", "New display name").option("--description <text>", "New description").option(
@@ -22725,20 +22421,20 @@ var editCommand = new Command79().name("edit").description("Edit a zero agent").
         const content = readFileSync2(options.instructionsFile, "utf-8");
         await updateZeroAgentInstructions(name, content);
       }
-      console.log(chalk71.green(`\u2713 Zero agent '${name}' updated`));
+      console.log(chalk67.green(`\u2713 Zero agent '${name}' updated`));
     }
   )
 );
 
 // src/commands/zero/agent/view.ts
-import { Command as Command80 } from "commander";
-import chalk72 from "chalk";
-var viewCommand = new Command80().name("view").description("View a zero agent").argument("<name>", "Agent name").option("--instructions", "Also show instructions content").action(
+import { Command as Command75 } from "commander";
+import chalk68 from "chalk";
+var viewCommand = new Command75().name("view").description("View a zero agent").argument("<name>", "Agent name").option("--instructions", "Also show instructions content").action(
   withErrorHandler(
     async (name, options) => {
       const agent = await getZeroAgent(name);
-      console.log(chalk72.bold(agent.name));
-      if (agent.displayName) console.log(chalk72.dim(agent.displayName));
+      console.log(chalk68.bold(agent.name));
+      if (agent.displayName) console.log(chalk68.dim(agent.displayName));
       console.log();
       console.log(`Compose ID:   ${agent.agentComposeId}`);
       console.log(`Connectors:   ${agent.connectors.join(", ") || "-"}`);
@@ -22749,10 +22445,10 @@ var viewCommand = new Command80().name("view").description("View a zero agent").
         console.log();
         const result = await getZeroAgentInstructions(name);
         if (result.content) {
-          console.log(chalk72.dim("\u2500\u2500 Instructions \u2500\u2500"));
+          console.log(chalk68.dim("\u2500\u2500 Instructions \u2500\u2500"));
           console.log(result.content);
         } else {
-          console.log(chalk72.dim("No instructions set"));
+          console.log(chalk68.dim("No instructions set"));
         }
       }
     }
@@ -22760,15 +22456,15 @@ var viewCommand = new Command80().name("view").description("View a zero agent").
 );
 
 // src/commands/zero/agent/list.ts
-import { Command as Command81 } from "commander";
-import chalk73 from "chalk";
-var listCommand11 = new Command81().name("list").alias("ls").description("List all zero agents").action(
+import { Command as Command76 } from "commander";
+import chalk69 from "chalk";
+var listCommand10 = new Command76().name("list").alias("ls").description("List all zero agents").action(
   withErrorHandler(async () => {
     const agents = await listZeroAgents();
     if (agents.length === 0) {
-      console.log(chalk73.dim("No zero agents found"));
+      console.log(chalk69.dim("No zero agents found"));
       console.log(
-        chalk73.dim(
+        chalk69.dim(
           '  Create one with: vm0 zero agent create --connectors github --display-name "My Agent"'
         )
       );
@@ -22784,7 +22480,7 @@ var listCommand11 = new Command81().name("list").alias("ls").description("List a
       "DISPLAY NAME".padEnd(displayWidth),
       "CONNECTORS"
     ].join("  ");
-    console.log(chalk73.dim(header));
+    console.log(chalk69.dim(header));
     for (const agent of agents) {
       const row = [
         agent.name.padEnd(nameWidth),
@@ -22797,9 +22493,9 @@ var listCommand11 = new Command81().name("list").alias("ls").description("List a
 );
 
 // src/commands/zero/agent/delete.ts
-import { Command as Command82 } from "commander";
-import chalk74 from "chalk";
-var deleteCommand3 = new Command82().name("delete").alias("rm").description("Delete a zero agent").argument("<name>", "Agent name").option("-y, --yes", "Skip confirmation prompt").action(
+import { Command as Command77 } from "commander";
+import chalk70 from "chalk";
+var deleteCommand2 = new Command77().name("delete").alias("rm").description("Delete a zero agent").argument("<name>", "Agent name").option("-y, --yes", "Skip confirmation prompt").action(
   withErrorHandler(async (name, options) => {
     await getZeroAgent(name);
     if (!options.yes) {
@@ -22811,17 +22507,318 @@ var deleteCommand3 = new Command82().name("delete").alias("rm").description("Del
         false
       );
       if (!confirmed) {
-        console.log(chalk74.dim("Cancelled"));
+        console.log(chalk70.dim("Cancelled"));
         return;
       }
     }
     await deleteZeroAgent(name);
-    console.log(chalk74.green(`\u2713 Zero agent '${name}' deleted`));
+    console.log(chalk70.green(`\u2713 Zero agent '${name}' deleted`));
   })
 );
 
 // src/commands/zero/agent/index.ts
-var agentCommand2 = new Command83("agent").description("Manage zero agents").addCommand(createCommand).addCommand(editCommand).addCommand(viewCommand).addCommand(listCommand11).addCommand(deleteCommand3);
+var agentCommand = new Command78("agent").description("Manage zero agents").addCommand(createCommand).addCommand(editCommand).addCommand(viewCommand).addCommand(listCommand10).addCommand(deleteCommand2);
+
+// src/commands/zero/connector/index.ts
+import { Command as Command83 } from "commander";
+
+// src/commands/zero/connector/connect.ts
+import { Command as Command79 } from "commander";
+import chalk71 from "chalk";
+function delay3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function renderHelpText2(text) {
+  return text.replace(
+    /\[([^\]]+)\]\(([^)]+)\)/g,
+    (_m, label, url) => `${label} (${chalk71.cyan(url)})`
+  ).replace(/\*\*([^*]+)\*\*/g, (_m, content) => chalk71.bold(content)).replace(
+    /^> (.+)$/gm,
+    (_m, content) => chalk71.yellow(`  ${content}`)
+  );
+}
+async function connectViaApiToken2(connectorType, tokenValue) {
+  const config = CONNECTOR_TYPES[connectorType];
+  const apiTokenConfig = config.authMethods["api-token"];
+  if (!apiTokenConfig) {
+    throw new Error(
+      `${config.label} does not support API token authentication`
+    );
+  }
+  const secretEntries = Object.entries(apiTokenConfig.secrets);
+  const inputSecrets = {};
+  if (tokenValue && secretEntries.length === 1) {
+    const [secretName] = secretEntries[0];
+    inputSecrets[secretName] = tokenValue;
+  } else {
+    if (apiTokenConfig.helpText) {
+      console.log();
+      console.log(renderHelpText2(apiTokenConfig.helpText));
+      console.log();
+    }
+    for (const [secretName, secretConfig] of secretEntries) {
+      if (!secretConfig.required) continue;
+      const value = await promptPassword(
+        `${secretConfig.label}${secretConfig.placeholder ? chalk71.dim(` (${secretConfig.placeholder})`) : ""}:`
+      );
+      if (!value) {
+        throw new Error("Cancelled");
+      }
+      inputSecrets[secretName] = value;
+    }
+  }
+  for (const [name, value] of Object.entries(inputSecrets)) {
+    await setZeroSecret({
+      name,
+      value,
+      description: `API token for ${config.label} connector`
+    });
+  }
+  console.log(
+    chalk71.green(`
+\u2713 ${config.label} connected successfully via API token!`)
+  );
+}
+async function connectComputer2() {
+  await checkComputerDependencies();
+  console.log(chalk71.cyan("Setting up computer connector..."));
+  const credentials = await createZeroComputerConnector();
+  await startComputerServices(credentials);
+  console.log(chalk71.cyan("Disconnecting computer connector..."));
+  await deleteZeroComputerConnector();
+  console.log(chalk71.green("\u2713 Disconnected computer"));
+}
+async function resolveAuthMethod2(connectorType, tokenFlag) {
+  const config = CONNECTOR_TYPES[connectorType];
+  const oauthFlag = CONNECTOR_TYPES[connectorType].featureFlag;
+  const oauthAvailable = "oauth" in config.authMethods && (!oauthFlag || await isFeatureEnabled(oauthFlag));
+  const apiTokenAvailable = "api-token" in config.authMethods;
+  if (tokenFlag) {
+    if (!apiTokenAvailable) {
+      throw new Error(
+        `${config.label} does not support API token authentication`
+      );
+    }
+    return "api-token";
+  }
+  if (oauthAvailable && apiTokenAvailable) {
+    const selected = await promptSelect(
+      `How would you like to connect ${config.label}?`,
+      [
+        { title: "OAuth (Sign in with browser)", value: "oauth" },
+        {
+          title: `API Token (${config.authMethods["api-token"].label})`,
+          value: "api-token"
+        }
+      ]
+    );
+    if (!selected) {
+      throw new Error("Cancelled");
+    }
+    return selected;
+  }
+  if (apiTokenAvailable) return "api-token";
+  if (oauthAvailable) return "oauth";
+  throw new Error(
+    `${config.label} has no available auth methods. OAuth may not be enabled yet.`
+  );
+}
+async function connectViaOAuth2(connectorType) {
+  console.log(`Connecting ${chalk71.cyan(connectorType)}...`);
+  const session = await createZeroConnectorSession(connectorType);
+  const apiUrl = await getBaseUrl();
+  const verificationUrl = `${apiUrl}${session.verificationUrl}`;
+  console.log(chalk71.green("\nSession created"));
+  console.log(chalk71.cyan(`
+To connect, visit: ${verificationUrl}`));
+  console.log(
+    `
+The session expires in ${Math.floor(session.expiresIn / 60)} minutes.`
+  );
+  console.log("\nWaiting for authorization...");
+  const startTime = Date.now();
+  const maxWaitTime = session.expiresIn * 1e3;
+  const pollInterval = (session.interval || 5) * 1e3;
+  let isFirstPoll = true;
+  while (Date.now() - startTime < maxWaitTime) {
+    if (!isFirstPoll) {
+      await delay3(pollInterval);
+    }
+    isFirstPoll = false;
+    const status = await getZeroConnectorSession(connectorType, session.id);
+    switch (status.status) {
+      case "complete":
+        console.log(
+          chalk71.green(`
+
+${connectorType} connected successfully!`)
+        );
+        return;
+      case "expired":
+        throw new Error("Session expired, please try again");
+      case "error":
+        throw new Error(
+          `Connection failed: ${status.errorMessage || "Unknown error"}`
+        );
+      case "pending":
+        process.stdout.write(chalk71.dim("."));
+        break;
+    }
+  }
+  throw new Error("Session timed out, please try again");
+}
+var connectCommand2 = new Command79().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) {
+      const available = Object.keys(CONNECTOR_TYPES).join(", ");
+      throw new Error(`Unknown connector type: ${type2}`, {
+        cause: new Error(`Available connectors: ${available}`)
+      });
+    }
+    const connectorType = parseResult.data;
+    if (connectorType === "computer") {
+      await connectComputer2();
+      return;
+    }
+    const authMethod = await resolveAuthMethod2(connectorType, options.token);
+    if (authMethod === "api-token") {
+      await connectViaApiToken2(connectorType, options.token);
+      return;
+    }
+    await connectViaOAuth2(connectorType);
+  })
+);
+
+// src/commands/zero/connector/list.ts
+import { Command as Command80 } from "commander";
+import chalk72 from "chalk";
+var listCommand11 = new Command80().name("list").alias("ls").description("List all connectors and their status").action(
+  withErrorHandler(async () => {
+    const result = await listZeroConnectors();
+    const connectedMap = new Map(result.connectors.map((c33) => [c33.type, c33]));
+    const allTypesRaw = Object.keys(CONNECTOR_TYPES);
+    const allTypes = [];
+    for (const type2 of allTypesRaw) {
+      const flag = CONNECTOR_TYPES[type2].featureFlag;
+      const hasApiToken = "api-token" in CONNECTOR_TYPES[type2].authMethods;
+      if (flag && !await isFeatureEnabled(flag) && !hasApiToken) {
+        continue;
+      }
+      allTypes.push(type2);
+    }
+    const typeWidth = Math.max(4, ...allTypes.map((t) => t.length));
+    const statusText = "STATUS";
+    const statusWidth = statusText.length;
+    const header = [
+      "TYPE".padEnd(typeWidth),
+      statusText.padEnd(statusWidth),
+      "ACCOUNT"
+    ].join("  ");
+    console.log(chalk72.dim(header));
+    for (const type2 of allTypes) {
+      const connector = connectedMap.get(type2);
+      const scopeMismatch = connector !== void 0 && connector.authMethod === "oauth" && !hasRequiredScopes(type2, connector.oauthScopes);
+      const status = connector ? connector.needsReconnect ? chalk72.yellow("!".padEnd(statusWidth)) : scopeMismatch ? chalk72.yellow("!".padEnd(statusWidth)) : chalk72.green("\u2713".padEnd(statusWidth)) : chalk72.dim("-".padEnd(statusWidth));
+      const account = connector?.needsReconnect ? chalk72.yellow("(reconnect needed)") : scopeMismatch ? chalk72.yellow("(permissions update available)") : connector?.externalUsername ? `@${connector.externalUsername}` : chalk72.dim("-");
+      const row = [type2.padEnd(typeWidth), status, account].join("  ");
+      console.log(row);
+    }
+    console.log();
+    console.log(chalk72.dim("To connect a service:"));
+    console.log(chalk72.dim("  vm0 zero connector connect <type>"));
+  })
+);
+
+// src/commands/zero/connector/status.ts
+import { Command as Command81 } from "commander";
+import chalk73 from "chalk";
+var LABEL_WIDTH2 = 16;
+var statusCommand7 = new Command81().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) {
+      const available = Object.keys(CONNECTOR_TYPES).join(", ");
+      throw new Error(`Unknown connector type: ${type2}`, {
+        cause: new Error(`Available connectors: ${available}`)
+      });
+    }
+    const connector = await getZeroConnector(parseResult.data);
+    console.log(`Connector: ${chalk73.cyan(type2)}`);
+    console.log();
+    if (connector) {
+      console.log(
+        `${"Status:".padEnd(LABEL_WIDTH2)}${chalk73.green("connected")}`
+      );
+      console.log(
+        `${"Account:".padEnd(LABEL_WIDTH2)}@${connector.externalUsername}`
+      );
+      console.log(
+        `${"Auth Method:".padEnd(LABEL_WIDTH2)}${connector.authMethod}`
+      );
+      if (connector.oauthScopes && connector.oauthScopes.length > 0) {
+        console.log(
+          `${"OAuth Scopes:".padEnd(LABEL_WIDTH2)}${connector.oauthScopes.join(", ")}`
+        );
+      }
+      if (connector.authMethod === "oauth" && !hasRequiredScopes(parseResult.data, connector.oauthScopes)) {
+        const diff = getScopeDiff(parseResult.data, connector.oauthScopes);
+        console.log(
+          `${"Permissions:".padEnd(LABEL_WIDTH2)}${chalk73.yellow("update available")}`
+        );
+        if (diff.addedScopes.length > 0) {
+          console.log(
+            `${"  Added:".padEnd(LABEL_WIDTH2)}${diff.addedScopes.join(", ")}`
+          );
+        }
+        if (diff.removedScopes.length > 0) {
+          console.log(
+            `${"  Removed:".padEnd(LABEL_WIDTH2)}${diff.removedScopes.join(", ")}`
+          );
+        }
+      }
+      console.log(
+        `${"Connected:".padEnd(LABEL_WIDTH2)}${formatDateTime(connector.createdAt)}`
+      );
+      if (connector.updatedAt !== connector.createdAt) {
+        console.log(
+          `${"Last Updated:".padEnd(LABEL_WIDTH2)}${formatDateTime(connector.updatedAt)}`
+        );
+      }
+      console.log();
+      console.log(chalk73.dim("To disconnect:"));
+      console.log(chalk73.dim(`  vm0 zero connector disconnect ${type2}`));
+    } else {
+      console.log(
+        `${"Status:".padEnd(LABEL_WIDTH2)}${chalk73.dim("not connected")}`
+      );
+      console.log();
+      console.log(chalk73.dim("To connect:"));
+      console.log(chalk73.dim(`  vm0 zero connector connect ${type2}`));
+    }
+  })
+);
+
+// src/commands/zero/connector/disconnect.ts
+import { Command as Command82 } from "commander";
+import chalk74 from "chalk";
+var disconnectCommand2 = new Command82().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) {
+      const available = Object.keys(CONNECTOR_TYPES).join(", ");
+      throw new Error(`Unknown connector type: ${type2}`, {
+        cause: new Error(`Available connectors: ${available}`)
+      });
+    }
+    const connectorType = parseResult.data;
+    await deleteZeroConnector(connectorType);
+    console.log(chalk74.green(`\u2713 Disconnected ${type2}`));
+  })
+);
+
+// src/commands/zero/connector/index.ts
+var zeroConnectorCommand = new Command83().name("connector").description("Manage third-party service connections (zero)").addCommand(listCommand11).addCommand(statusCommand7).addCommand(connectCommand2).addCommand(disconnectCommand2);
 
 // src/commands/zero/schedule/index.ts
 import { Command as Command90 } from "commander";
@@ -22934,7 +22931,7 @@ async function gatherFrequency(optionFrequency, existingFrequency) {
   if (!isInteractive()) {
     throw new Error("--frequency is required (daily|weekly|monthly|once|loop)");
   }
-  const defaultIndex = existingFrequency ? FREQUENCY_CHOICES.findIndex((c34) => c34.value === existingFrequency) : 0;
+  const defaultIndex = existingFrequency ? FREQUENCY_CHOICES.findIndex((c33) => c33.value === existingFrequency) : 0;
   frequency = await promptSelect(
     "Schedule frequency",
     FREQUENCY_CHOICES,
@@ -22959,7 +22956,7 @@ async function gatherDay(frequency, optionDay, existingDay) {
     throw new Error("--day is required for weekly/monthly");
   }
   if (frequency === "weekly") {
-    const defaultDayIndex = existingDay !== void 0 ? DAY_OF_WEEK_CHOICES.findIndex((c34) => c34.value === existingDay) : 0;
+    const defaultDayIndex = existingDay !== void 0 ? DAY_OF_WEEK_CHOICES.findIndex((c33) => c33.value === existingDay) : 0;
     const day2 = await promptSelect(
       "Day of week",
       DAY_OF_WEEK_CHOICES,
@@ -23479,7 +23476,7 @@ var statusCommand8 = new Command86().name("status").description("Show detailed s
 // src/commands/zero/schedule/delete.ts
 import { Command as Command87 } from "commander";
 import chalk78 from "chalk";
-var deleteCommand4 = new Command87().name("delete").alias("rm").description("Delete a zero schedule").argument("<agent-name>", "Agent name").option(
+var deleteCommand3 = new Command87().name("delete").alias("rm").description("Delete a zero 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(
@@ -23558,7 +23555,7 @@ var disableCommand = new Command89().name("disable").description("Disable a zero
 );
 
 // src/commands/zero/schedule/index.ts
-var zeroScheduleCommand = new Command90().name("schedule").description("Manage zero agent schedules").addCommand(setupCommand2).addCommand(listCommand12).addCommand(statusCommand8).addCommand(deleteCommand4).addCommand(enableCommand).addCommand(disableCommand);
+var zeroScheduleCommand = new Command90().name("schedule").description("Manage zero agent schedules").addCommand(setupCommand2).addCommand(listCommand12).addCommand(statusCommand8).addCommand(deleteCommand3).addCommand(enableCommand).addCommand(disableCommand);
 
 // src/commands/zero/secret/index.ts
 import { Command as Command94 } from "commander";
@@ -23674,7 +23671,7 @@ var setCommand4 = new Command92().name("set").description("Create or update a se
 // src/commands/zero/secret/delete.ts
 import { Command as Command93 } from "commander";
 import chalk83 from "chalk";
-var deleteCommand5 = new Command93().name("delete").description("Delete a secret").argument("<name>", "Secret name to delete").option("-y, --yes", "Skip confirmation prompt").action(
+var deleteCommand4 = new Command93().name("delete").description("Delete a secret").argument("<name>", "Secret name to delete").option("-y, --yes", "Skip confirmation prompt").action(
   withErrorHandler(async (name, options) => {
     if (!options.yes) {
       if (!isInteractive()) {
@@ -23695,7 +23692,7 @@ var deleteCommand5 = new Command93().name("delete").description("Delete a secret
 );
 
 // src/commands/zero/secret/index.ts
-var zeroSecretCommand = new Command94().name("secret").description("Manage secrets").addCommand(listCommand13).addCommand(setCommand4).addCommand(deleteCommand5);
+var zeroSecretCommand = new Command94().name("secret").description("Manage secrets").addCommand(listCommand13).addCommand(setCommand4).addCommand(deleteCommand4);
 
 // src/commands/zero/variable/index.ts
 import { Command as Command98 } from "commander";
@@ -23771,7 +23768,7 @@ var setCommand5 = new Command96().name("set").description("Create or update a va
 // src/commands/zero/variable/delete.ts
 import { Command as Command97 } from "commander";
 import chalk86 from "chalk";
-var deleteCommand6 = new Command97().name("delete").description("Delete a variable").argument("<name>", "Variable name to delete").option("-y, --yes", "Skip confirmation prompt").action(
+var deleteCommand5 = new Command97().name("delete").description("Delete a variable").argument("<name>", "Variable name to delete").option("-y, --yes", "Skip confirmation prompt").action(
   withErrorHandler(async (name, options) => {
     if (!options.yes) {
       if (!isInteractive()) {
@@ -23792,14 +23789,14 @@ var deleteCommand6 = new Command97().name("delete").description("Delete a variab
 );
 
 // src/commands/zero/variable/index.ts
-var zeroVariableCommand = new Command98().name("variable").description("Manage variables").addCommand(listCommand14).addCommand(setCommand5).addCommand(deleteCommand6);
+var zeroVariableCommand = new Command98().name("variable").description("Manage variables").addCommand(listCommand14).addCommand(setCommand5).addCommand(deleteCommand5);
 
 // src/commands/zero/index.ts
-var zeroCommand = new Command99("zero").description("Zero platform commands").addCommand(zeroOrgCommand).addCommand(agentCommand2).addCommand(zeroScheduleCommand).addCommand(zeroSecretCommand).addCommand(zeroVariableCommand);
+var zeroCommand = new Command99("zero").description("Zero platform commands").addCommand(zeroOrgCommand).addCommand(agentCommand).addCommand(zeroConnectorCommand).addCommand(zeroScheduleCommand).addCommand(zeroSecretCommand).addCommand(zeroVariableCommand);
 
 // src/index.ts
 var program = new Command100();
-program.name("vm0").description("VM0 CLI - Build and run agents with natural language").version("9.77.1");
+program.name("vm0").description("VM0 CLI - Build and run agents with natural language").version("9.78.0");
 program.addCommand(authCommand);
 program.addCommand(infoCommand);
 program.addCommand(composeCommand);
@@ -23809,7 +23806,6 @@ program.addCommand(artifactCommand);
 program.addCommand(memoryCommand);
 program.addCommand(cookCommand);
 program.addCommand(logsCommand2);
-program.addCommand(agentCommand);
 program.addCommand(initCommand4);
 program.addCommand(connectorCommand);
 program.addCommand(preferenceCommand);