@vellumai/cli 0.8.10-staging.1 → 0.8.11-staging.1

package/src/commands/confirm.ts

@@ -0,0 +1,144 @@
+/**
+ * `vellum confirm <assistant> --request-id <id> --decision allow|deny`
+ *
+ * Resolve a pending tool confirmation on a running assistant via its
+ * runtime HTTP API. The assistant raises a `confirmation_request` event
+ * (with a `requestId`) when a tool exceeds the auto-approve risk
+ * threshold; this command answers it so the turn can proceed. Headless
+ * automation (e.g. the evals harness) uses it to approve requests that
+ * would otherwise hang waiting for an interactive user.
+ */
+
+import { extractFlag } from "../lib/arg-utils.js";
+import { AssistantClient } from "../lib/assistant-client.js";
+
+function printUsage(): void {
+  console.log(`vellum confirm - Resolve a pending tool confirmation
+
+USAGE:
+    vellum confirm [assistant] --request-id <id> [--decision allow|deny]
+
+ARGUMENTS:
+    [assistant]    Instance name (default: active assistant)
+
+OPTIONS:
+    --request-id <id>     The requestId from the confirmation_request event (required)
+    --decision <value>    allow or deny (default: allow)
+    --json                Output raw JSON response
+
+EXAMPLES:
+    vellum confirm --request-id ede263d9-cc45-4d63-86f8-a656d17b3a3a
+    vellum confirm my-assistant --request-id req-1 --decision deny
+    vellum confirm --json --request-id req-1
+`);
+}
+
+interface ParsedConfirmArgs {
+  assistantId?: string;
+  requestId: string;
+  decision: "allow" | "deny";
+  jsonOutput: boolean;
+}
+
+type ParseResult =
+  | { ok: true; value: ParsedConfirmArgs }
+  | { ok: false; error: string };
+
+/**
+ * Parse `vellum confirm` arguments. Pure: does no I/O and never exits, so the
+ * positional/flag rules can be unit-tested. Defaults the decision to `allow`,
+ * which is the common automation case (approve and continue).
+ */
+export function parseConfirmArgs(rawArgs: string[]): ParseResult {
+  const jsonOutput = rawArgs.includes("--json");
+  let args = rawArgs.filter((a) => a !== "--json");
+
+  const requestIdFlagPresent = args.includes("--request-id");
+  const [requestId, afterRequestId] = extractFlag(args, "--request-id");
+  args = afterRequestId;
+
+  const decisionFlagPresent = args.includes("--decision");
+  const [decisionRaw, afterDecision] = extractFlag(args, "--decision");
+  args = afterDecision;
+
+  // `extractFlag` strips a trailing value-less flag, which would otherwise let
+  // the next positional masquerade as the flag's value (or, for --decision,
+  // silently fall back to "allow" and approve a tool call the caller never
+  // meant to approve). Treat a flag supplied without a value as an error.
+  if (requestIdFlagPresent && requestId === undefined) {
+    return { ok: false, error: "--request-id requires a value." };
+  }
+  if (!requestId) {
+    return { ok: false, error: "--request-id is required." };
+  }
+
+  if (decisionFlagPresent && decisionRaw === undefined) {
+    return {
+      ok: false,
+      error: '--decision requires a value ("allow" or "deny").',
+    };
+  }
+  const decision = decisionRaw ?? "allow";
+  if (decision !== "allow" && decision !== "deny") {
+    return {
+      ok: false,
+      error: `--decision must be "allow" or "deny" (got "${decision}").`,
+    };
+  }
+
+  if (args.length >= 2) {
+    return { ok: false, error: "unexpected extra arguments." };
+  }
+
+  return {
+    ok: true,
+    value: { assistantId: args[0], requestId, decision, jsonOutput },
+  };
+}
+
+function exitWithUsage(error: string): never {
+  console.error(`Error: ${error}`);
+  console.error("");
+  printUsage();
+  process.exit(1);
+}
+
+export async function confirm(): Promise<void> {
+  const rawArgs = process.argv.slice(3);
+
+  if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+    printUsage();
+    return;
+  }
+
+  const parsed = parseConfirmArgs(rawArgs);
+  if (!parsed.ok) {
+    exitWithUsage(parsed.error);
+  }
+
+  const { assistantId, requestId, decision, jsonOutput } = parsed.value;
+
+  const client = new AssistantClient({ assistantId });
+
+  const response = await client.post("/confirm", { requestId, decision });
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    console.error(
+      `Error: HTTP ${response.status}: ${body || response.statusText}`,
+    );
+    process.exit(1);
+  }
+
+  const result = (await response.json()) as { accepted: boolean };
+
+  if (jsonOutput) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(
+      result.accepted
+        ? `Confirmation resolved (${decision})`
+        : `Confirmation not accepted`,
+    );
+  }
+}

package/src/commands/connect.ts

@@ -1,7 +1,7 @@
 import { connectImport } from "./connect/import.js";
 
 function printUsage(): void {
-  console.log("Usage: vellum connect <subcommand>");
+  console.log("Usage: vellum connect [beta] <subcommand>");
   console.log("");
   console.log("Connect to an assistant paired from another machine.");
   console.log("");

package/src/commands/devices.ts

@@ -28,6 +28,7 @@ import {
   canPromptForConfirmation,
   confirmAction,
 } from "../lib/confirm-action.js";
+import { loopbackSafeFetch } from "../lib/loopback-fetch.js";
 
 interface DeviceRecord {
   hashedDeviceId: string;
@@ -38,7 +39,7 @@ interface DeviceRecord {
 }
 
 function printUsage(): void {
-  console.log(`vellum devices - List and revoke devices paired to a local assistant
+  console.log(`vellum devices [beta] - List and revoke devices paired to a local assistant
 
 USAGE:
     vellum devices [name]
@@ -108,7 +109,7 @@ async function listDevices(entry: AssistantEntry, base: string): Promise<void> {
 
   let response: Response;
   try {
-    response = await fetch(`${base}/v1/devices`, {
+    response = await loopbackSafeFetch(`${base}/v1/devices`, {
       method: "GET",
       headers: getClientRegistrationHeaders(CLI_INTERFACE_ID),
     });
@@ -186,7 +187,7 @@ async function revokeDevice(
 
   let response: Response;
   try {
-    response = await fetch(`${base}/v1/devices/revoke`, {
+    response = await loopbackSafeFetch(`${base}/v1/devices/revoke`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",

package/src/commands/hatch.ts

@@ -181,6 +181,7 @@ interface HatchArgs {
   configValues: Record<string, string>;
   flagEnvVars: Record<string, string>;
   analyze: boolean;
+  disablePlatform: boolean;
 }
 
 function parseArgs(): HatchArgs {
@@ -188,6 +189,8 @@ function parseArgs(): HatchArgs {
     process.argv.slice(3),
   );
   const flagEnvVars = { ...readAmbientFlagEnvVars(), ...cliFlagVars };
+  const disablePlatformAmbient = process.env.VELLUM_DISABLE_PLATFORM?.trim().toLowerCase();
+  let disablePlatform = disablePlatformAmbient === "true" || disablePlatformAmbient === "1";
   let species: Species = DEFAULT_SPECIES;
   let detached = false;
   let keepAlive = false;
@@ -233,6 +236,9 @@ function parseArgs(): HatchArgs {
       console.log(
         "  --analyze                 Emit a structured hatch-timing log line on stdout",
       );
+      console.log(
+        "  --disable-platform        Suppress all outbound platform API calls",
+      );
       process.exit(0);
     } else if (arg === "-d") {
       detached = true;
@@ -293,11 +299,13 @@ function parseArgs(): HatchArgs {
       const value = next.slice(eqIndex + 1);
       configValues[key] = value;
       i++;
+    } else if (arg === "--disable-platform") {
+      disablePlatform = true;
     } else if (VALID_SPECIES.includes(arg as Species)) {
       species = arg as Species;
     } else {
       console.error(
-        `Error: Unknown argument '${arg}'. Valid options: ${VALID_SPECIES.join(", ")}, -d, --watch, --source <path>, --keep-alive, --name <name>, --remote <${VALID_REMOTE_HOSTS.join("|")}>, --config <key=value>, --flag <key=value>, --analyze`,
+        `Error: Unknown argument '${arg}'. Valid options: ${VALID_SPECIES.join(", ")}, -d, --watch, --source <path>, --keep-alive, --name <name>, --remote <${VALID_REMOTE_HOSTS.join("|")}>, --config <key=value>, --flag <key=value>, --analyze, --disable-platform`,
       );
       process.exit(1);
     }
@@ -314,6 +322,7 @@ function parseArgs(): HatchArgs {
     configValues,
     flagEnvVars,
     analyze,
+    disablePlatform,
   };
 }
 
@@ -549,8 +558,14 @@ export async function hatch(): Promise<void> {
     configValues,
     flagEnvVars,
     analyze,
+    disablePlatform,
   } = parseArgs();
 
+  if (disablePlatform) {
+    process.env.VELLUM_DISABLE_PLATFORM = "true";
+    flagEnvVars.VELLUM_DISABLE_PLATFORM = "true";
+  }
+
   if (watch && remote !== "local" && remote !== "docker") {
     console.error(
       "Error: --watch is only supported for local and docker hatch targets.",

package/src/commands/pair.ts

@@ -26,6 +26,7 @@ import {
 } from "../lib/client-identity.js";
 import { GATEWAY_PORT } from "../lib/constants.js";
 import { getLocalLanIPv4 } from "../lib/local.js";
+import { loopbackSafeFetch } from "../lib/loopback-fetch.js";
 
 function isLoopbackHost(url: string): boolean {
   try {
@@ -37,7 +38,7 @@ function isLoopbackHost(url: string): boolean {
 }
 
 function printUsage(): void {
-  console.log(`vellum pair - Mint a device-scoped token for another machine
+  console.log(`vellum pair [beta] - Mint a device-scoped token for another machine
 
 USAGE:
     vellum pair [assistant] [options]
@@ -154,7 +155,7 @@ export async function pair(): Promise<void> {
 
   let response: Response;
   try {
-    response = await fetch(`${mintUrl}/v1/pair`, {
+    response = await loopbackSafeFetch(`${mintUrl}/v1/pair`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",

package/src/commands/restore.ts

@@ -16,6 +16,7 @@ import {
   platformPollJobStatus,
 } from "../lib/platform-client.js";
 import { performDockerRollback } from "../lib/upgrade-lifecycle.js";
+import { loopbackSafeFetch } from "../lib/loopback-fetch.js";
 
 function printUsage(): void {
   console.log(
@@ -588,7 +589,7 @@ export async function restore(): Promise<void> {
 
     let response: Response;
     try {
-      response = await fetch(
+      response = await loopbackSafeFetch(
         `${entry.runtimeUrl}/v1/migrations/import-preflight`,
         {
           method: "POST",
@@ -694,7 +695,7 @@ export async function restore(): Promise<void> {
 
     let response: Response;
     try {
-      response = await fetch(`${entry.runtimeUrl}/v1/migrations/import`, {
+      response = await loopbackSafeFetch(`${entry.runtimeUrl}/v1/migrations/import`, {
         method: "POST",
         headers: {
           Authorization: `Bearer ${accessToken}`,

package/src/commands/retire.ts

@@ -36,6 +36,7 @@ import {
   resetLogFile,
   writeToLogFile,
 } from "../lib/xdg-log.js";
+import { loopbackSafeFetch } from "../lib/loopback-fetch.js";
 
 export { retireLocal };
 
@@ -96,7 +97,7 @@ async function retireVellum(
 
   const platformUrl = runtimeUrl || getPlatformUrl();
   const url = `${platformUrl}/v1/assistants/${encodeURIComponent(assistantId)}/retire/`;
-  const response = await fetch(url, {
+  const response = await loopbackSafeFetch(url, {
     method: "DELETE",
     headers: await authHeaders(token, runtimeUrl),
   });

package/src/commands/roadmap.ts

@@ -1,4 +1,5 @@
 import { readPlatformToken, getWebUrl } from "../lib/platform-client.js";
+import { loopbackSafeFetch } from "../lib/loopback-fetch.js";
 
 function printUsage(): void {
   console.log("Usage: vellum roadmap <subcommand>");
@@ -88,7 +89,7 @@ async function apiFetch(
   if (options.token) headers["X-Session-Token"] = options.token;
   if (options.body) headers["Content-Type"] = "application/json";
 
-  return fetch(url, {
+  return loopbackSafeFetch(url, {
     method: options.method ?? "GET",
     headers,
     body: options.body ? JSON.stringify(options.body) : undefined,

package/src/commands/rollback.ts

@@ -1,5 +1,3 @@
-import { randomBytes } from "crypto";
-
 import {
   findAssistantByName,
   getActiveAssistant,
@@ -27,9 +25,8 @@ import {
   buildProgressEvent,
   buildStartingEvent,
   buildUpgradeCommitMessage,
-  captureContainerEnv,
+  captureReplayState,
   commitWorkspaceViaGateway,
-  CONTAINER_ENV_EXCLUDE_KEYS,
   fetchCurrentVersion,
   fetchPreviousVersion,
   performDockerRollback,
@@ -308,39 +305,13 @@ export async function rollback(): Promise<void> {
       `🔄 Rolling back Docker assistant '${instanceName}' to ${previousVersion}...\n`,
     );
 
-    // Capture current container env
-    console.log("💾 Capturing existing container environment...");
-    const capturedEnv = await captureContainerEnv(res.assistantContainer);
-    console.log(
-      `   Captured ${Object.keys(capturedEnv).length} env var(s) from ${res.assistantContainer}\n`,
-    );
-
-    // Capture GUARDIAN_BOOTSTRAP_SECRET from the gateway container (it is only
-    // set on gateway, not assistant) so it persists across container restarts.
-    const gatewayEnv = await captureContainerEnv(res.gatewayContainer);
-    const bootstrapSecret = gatewayEnv["GUARDIAN_BOOTSTRAP_SECRET"];
-
-    // Extract CES_SERVICE_TOKEN from captured env, or generate fresh one
-    const cesServiceToken =
-      capturedEnv["CES_SERVICE_TOKEN"] || randomBytes(32).toString("hex");
-
-    // Extract or generate the shared JWT signing key.
-    const signingKey =
-      capturedEnv["ACTOR_TOKEN_SIGNING_KEY"] || randomBytes(32).toString("hex");
-
-    // Build extra env vars, excluding keys managed by buildServiceRunArgs
-    const envKeysSetByRunArgs = new Set(CONTAINER_ENV_EXCLUDE_KEYS);
-    for (const envVar of ["ANTHROPIC_API_KEY", "VELLUM_PLATFORM_URL"]) {
-      if (process.env[envVar]) {
-        envKeysSetByRunArgs.add(envVar);
-      }
-    }
-    const extraAssistantEnv: Record<string, string> = {};
-    for (const [key, value] of Object.entries(capturedEnv)) {
-      if (!envKeysSetByRunArgs.has(key)) {
-        extraAssistantEnv[key] = value;
-      }
-    }
+    const {
+      bootstrapSecret,
+      cesServiceToken,
+      signingKey,
+      extraAssistantEnv,
+      extraGatewayEnv,
+    } = await captureReplayState(res);
 
     // Parse gateway port from entry's runtimeUrl, fall back to default
     let gatewayPort = GATEWAY_INTERNAL_PORT;
@@ -401,6 +372,7 @@ export async function rollback(): Promise<void> {
         bootstrapSecret,
         cesServiceToken,
         extraAssistantEnv,
+        extraGatewayEnv,
         gatewayPort,
         imageTags: previousImageRefs,
         instanceName,

package/src/commands/unpair.ts

@@ -24,7 +24,7 @@ import {
 import { deleteGuardianToken } from "../lib/guardian-token";
 
 function printUsage(): void {
-  console.log(`vellum unpair - Forget a paired assistant imported from another machine
+  console.log(`vellum unpair [beta] - Forget a paired assistant imported from another machine
 
 USAGE:
     vellum unpair <name> [--yes]

package/src/commands/upgrade.ts

@@ -1,4 +1,3 @@
-import { randomBytes } from "crypto";
 import { spawnSync } from "child_process";
 
 import cliPkg from "../../package.json";
@@ -40,15 +39,15 @@ import {
   buildProgressEvent,
   buildStartingEvent,
   buildUpgradeCommitMessage,
-  captureContainerEnv,
+  captureReplayState,
   captureUpgradeFailureLogs,
   commitWorkspaceViaGateway,
-  CONTAINER_ENV_EXCLUDE_KEYS,
   rollbackMigrations,
   UPGRADE_PROGRESS,
   waitForReady,
 } from "../lib/upgrade-lifecycle.js";
 import { compareVersions } from "../lib/version-compat.js";
+import { loopbackSafeFetch } from "../lib/loopback-fetch.js";
 
 interface UpgradeArgs {
   name: string | null;
@@ -232,7 +231,7 @@ async function upgradeDocker(
     lastWorkspaceMigrationId?: string;
   } = {};
   try {
-    const healthResp = await fetch(
+    const healthResp = await loopbackSafeFetch(
       `${entry.runtimeUrl}/healthz?include=migrations`,
       {
         signal: AbortSignal.timeout(5000),
@@ -297,16 +296,13 @@ async function upgradeDocker(
     }),
   );
 
-  console.log("💾 Capturing existing container environment...");
-  const capturedEnv = await captureContainerEnv(res.assistantContainer);
-  console.log(
-    `   Captured ${Object.keys(capturedEnv).length} env var(s) from ${res.assistantContainer}\n`,
-  );
-
-  // Capture GUARDIAN_BOOTSTRAP_SECRET from the gateway container (it is only
-  // set on gateway, not assistant) so it persists across container restarts.
-  const gatewayEnv = await captureContainerEnv(res.gatewayContainer);
-  const bootstrapSecret = gatewayEnv["GUARDIAN_BOOTSTRAP_SECRET"];
+  const {
+    bootstrapSecret,
+    cesServiceToken,
+    signingKey,
+    extraAssistantEnv,
+    extraGatewayEnv,
+  } = await captureReplayState(res);
 
   // Notify connected clients that an upgrade is about to begin.
   // This must fire BEFORE any progress broadcasts so the UI sets
@@ -361,18 +357,6 @@ async function upgradeDocker(
     // use default
   }
 
-  // Extract CES_SERVICE_TOKEN from the captured env so it can be passed via
-  // the dedicated cesServiceToken parameter (which propagates it to all three
-  // containers). If the old instance predates CES_SERVICE_TOKEN, generate a
-  // fresh one so gateway and CES can authenticate.
-  const cesServiceToken =
-    capturedEnv["CES_SERVICE_TOKEN"] || randomBytes(32).toString("hex");
-
-  // Extract or generate the shared JWT signing key. Pre-env-var instances
-  // won't have it in capturedEnv, so generate fresh in that case.
-  const signingKey =
-    capturedEnv["ACTOR_TOKEN_SIGNING_KEY"] || randomBytes(32).toString("hex");
-
   // Create pre-upgrade backup (best-effort, daemon must be running)
   await broadcastUpgradeEvent(
     entry.runtimeUrl,
@@ -415,23 +399,6 @@ async function upgradeDocker(
   await stopContainers(res);
   console.log("✅ Containers stopped\n");
 
-  // Build the set of extra env vars to replay on the new assistant container.
-  // Captured env vars serve as the base; keys already managed by
-  // buildServiceRunArgs are excluded to avoid duplicates.
-  const envKeysSetByRunArgs = new Set(CONTAINER_ENV_EXCLUDE_KEYS);
-  // Only exclude keys that buildServiceRunArgs will actually set
-  for (const envVar of ["ANTHROPIC_API_KEY", "VELLUM_PLATFORM_URL"]) {
-    if (process.env[envVar]) {
-      envKeysSetByRunArgs.add(envVar);
-    }
-  }
-  const extraAssistantEnv: Record<string, string> = {};
-  for (const [key, value] of Object.entries(capturedEnv)) {
-    if (!envKeysSetByRunArgs.has(key)) {
-      extraAssistantEnv[key] = value;
-    }
-  }
-
   console.log("🚀 Starting upgraded containers...");
   await startContainers(
     {
@@ -439,6 +406,7 @@ async function upgradeDocker(
       bootstrapSecret,
       cesServiceToken,
       extraAssistantEnv,
+      extraGatewayEnv,
       gatewayPort,
       imageTags,
       instanceName,
@@ -544,6 +512,7 @@ async function upgradeDocker(
             bootstrapSecret,
             cesServiceToken,
             extraAssistantEnv,
+            extraGatewayEnv,
             gatewayPort,
             imageTags: previousImageRefs,
             instanceName,
@@ -727,7 +696,7 @@ async function upgradePlatform(
     body.version = version;
   }
 
-  const response = await fetch(url, {
+  const response = await loopbackSafeFetch(url, {
     method: "POST",
     headers,
     body: JSON.stringify(body),

package/src/commands/wake.ts

@@ -7,7 +7,12 @@ import {
   saveAssistantEntry,
 } from "../lib/assistant-config.js";
 import { dockerResourceNames, wakeContainers } from "../lib/docker.js";
-import { seedGuardianTokenFromSiblingEnv } from "../lib/guardian-token.js";
+import {
+  leaseGuardianToken,
+  loadGuardianToken,
+  resetGuardianBootstrap,
+  seedGuardianTokenFromSiblingEnv,
+} from "../lib/guardian-token.js";
 import { resolveProcessState, stopProcessByPidFile } from "../lib/process";
 import {
   generateLocalSigningKey,
@@ -37,11 +42,23 @@ export async function wake(): Promise<void> {
     console.log(
       "  --foreground   Run assistant in foreground with logs printed to terminal",
     );
+    console.log(
+      "  --repair-guardian  Re-provision the guardian token if missing (resets the\n" +
+        "                     gateway bootstrap and re-leases — REVOKES other device-bound\n" +
+        "                     tokens, so only use deliberately, never from auto-repair)",
+    );
     process.exit(0);
   }
 
   const watch = args.includes("--watch");
   const foreground = args.includes("--foreground");
+  // Re-leasing the guardian token calls guardian/init, which revokes every
+  // other device-bound token (other tabs, other local clients on this machine).
+  // Gate it behind an explicit flag so the automatic connect-repair path
+  // (`runWake` spawns `wake <id>` with no flags) can never revoke a live session
+  // — it only ever restarts + sibling-seeds. A genuine spent-bootstrap brick is
+  // recovered deliberately via `vellum wake <id> --repair-guardian`.
+  const repairGuardian = args.includes("--repair-guardian");
   const nameArg = args.find((a) => !a.startsWith("-"));
   const entry = resolveTargetAssistant(nameArg);
 
@@ -221,6 +238,37 @@ export async function wake(): Promise<void> {
     console.log("   Seeded guardian token from sibling environment.");
   }
 
+  // Last-resort recovery (explicit `--repair-guardian` only): if no guardian
+  // token exists for this env even after sibling seeding, re-provision one. The
+  // single-use bootstrap secret may already be spent — a prior connect can
+  // lease a token that's then lost, or the gateway marks the secret consumed
+  // before the client persists it — which otherwise bricks connect into a
+  // 401 → auth-rate-limit → 429 cascade with no path back short of retire+hatch.
+  // Reset the gateway's bootstrap lock+consumed state (loopback-only, authorized
+  // by the lockfile secret — mirrors the macOS client's forceReBootstrap), then
+  // re-lease. Gated behind the flag because the re-lease revokes other
+  // device-bound tokens; it must never run from the automatic repair path.
+  if (repairGuardian && !loadGuardianToken(entry.assistantId)) {
+    const loopbackUrl = `http://127.0.0.1:${resources.gatewayPort}`;
+    const maxAttempts = 3;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        await resetGuardianBootstrap(loopbackUrl, bootstrapSecret);
+        await leaseGuardianToken(loopbackUrl, entry.assistantId, bootstrapSecret);
+        console.log("   Re-provisioned guardian token.");
+        break;
+      } catch (err) {
+        if (attempt < maxAttempts) {
+          await new Promise((r) => setTimeout(r, 2000 * 2 ** (attempt - 1)));
+        } else {
+          console.warn(
+            `   Guardian token re-provision failed after ${maxAttempts} attempts: ${err}`,
+          );
+        }
+      }
+    }
+  }
+
   // Auto-start ngrok if webhook integrations (e.g. Telegram) are configured.
   const workspaceDir = join(resources.instanceDir, ".vellum", "workspace");
   const ngrokChild = await maybeStartNgrokTunnel(

package/src/index.ts

@@ -4,6 +4,7 @@ import cliPkg from "../package.json";
 import { backup } from "./commands/backup";
 import { clean } from "./commands/clean";
 import { client } from "./commands/client";
+import { confirm } from "./commands/confirm";
 import { connect } from "./commands/connect";
 import { devices } from "./commands/devices";
 import { env } from "./commands/env";
@@ -40,6 +41,7 @@ const commands = {
   backup,
   clean,
   client,
+  confirm,
   connect,
   devices,
   env,
@@ -81,8 +83,13 @@ function printHelp(): void {
   console.log("  backup   Export a backup of a running assistant");
   console.log("  clean    Kill orphaned vellum processes");
   console.log("  client   Connect to a hatched assistant");
-  console.log("  connect  Import an assistant paired from another machine");
-  console.log("  devices  List or revoke devices paired to a local assistant");
+  console.log("  confirm  Resolve a pending tool confirmation on an assistant");
+  console.log(
+    "  connect  Import an assistant paired from another machine [beta]",
+  );
+  console.log(
+    "  devices  List or revoke devices paired to a local assistant [beta]",
+  );
   console.log("  env      Manage the default CLI environment");
   console.log("  events   Stream events from a running assistant");
   console.log("  exec     Execute a command inside an assistant's container");
@@ -94,7 +101,7 @@ function printHelp(): void {
   console.log("  logout   Log out of the Vellum platform");
   console.log("  message  Send a message to a running assistant");
   console.log(
-    "  pair     Mint a device-scoped token to connect another machine",
+    "  pair     Mint a device-scoped token to connect another machine [beta]",
   );
   console.log(
     "  ps       List assistants (or processes for a specific assistant)",
@@ -113,7 +120,7 @@ function printHelp(): void {
   console.log("  terminal Open a terminal into a managed assistant container");
   console.log("  tunnel   Create a tunnel for a locally hosted assistant");
   console.log(
-    "  unpair   Forget a paired assistant imported from another machine",
+    "  unpair   Forget a paired assistant imported from another machine [beta]",
   );
   console.log("  upgrade  Upgrade an assistant to a newer version");
   console.log("  use      Set the active assistant for commands");