@vellumai/cli 0.8.3 → 0.8.5

package/src/commands/client.ts

@@ -4,9 +4,12 @@ import path from "node:path";
 
 import {
   findAssistantByName,
+  formatAssistantLookupError,
   getActiveAssistant,
+  lookupAssistantByIdentifier,
   resolveAssistant,
   saveAssistantEntry,
+  type AssistantEntry,
 } from "../lib/assistant-config";
 import {
   DAEMON_INTERNAL_ASSISTANT_ID,
@@ -20,6 +23,7 @@ import {
   WEB_INTERFACE_ID,
   getClientRegistrationHeaders,
 } from "../lib/client-identity";
+import { parseAssistantTargetArg } from "../lib/assistant-target-args.js";
 import {
   fetchOrganizationId,
   fetchPlatformAssistants,
@@ -51,13 +55,9 @@ interface ParsedArgs {
   bearerToken?: string;
   /** Interface identifier sent as X-Vellum-Interface-Id on all requests. */
   interfaceId: SupportedInterface;
-  project?: string;
-  zone?: string;
 }
 
-function readAssistantName(
-  entry: ReturnType<typeof findAssistantByName>,
-): string | undefined {
+function readAssistantName(entry: AssistantEntry | null): string | undefined {
   const rawName = entry?.name ?? entry?.assistantName;
   return typeof rawName === "string" && rawName.trim()
     ? rawName.trim()
@@ -67,7 +67,14 @@ function readAssistantName(
 function parseArgs(): ParsedArgs {
   const args = process.argv.slice(3);
 
-  let positionalName: string | undefined;
+  const positionalName = parseAssistantTargetArg(args, [
+    "--url",
+    "-u",
+    "--assistant-id",
+    "-a",
+    "--interface",
+    "-i",
+  ]);
   const flagArgs: string[] = [];
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -84,29 +91,29 @@ function parseArgs(): ParsedArgs {
       args[i + 1]
     ) {
       flagArgs.push(arg, args[++i]);
-    } else if (!arg.startsWith("-") && positionalName === undefined) {
-      positionalName = arg;
     }
   }
 
-  let entry: ReturnType<typeof findAssistantByName> = null;
+  let entry: AssistantEntry | null = null;
   if (positionalName) {
-    entry = findAssistantByName(positionalName);
-    if (!entry) {
-      console.error(
-        `No assistant instance found with name '${positionalName}'.`,
-      );
+    const result = lookupAssistantByIdentifier(positionalName);
+    if (result.status !== "found") {
+      console.error(formatAssistantLookupError(positionalName, result));
       process.exit(1);
     }
+    entry = result.entry;
   } else {
     const hasExplicitUrl =
       flagArgs.includes("--url") || flagArgs.includes("-u");
     const active = getActiveAssistant();
     if (active) {
-      entry = findAssistantByName(active);
+      const result = lookupAssistantByIdentifier(active);
+      if (result.status === "found") {
+        entry = result.entry;
+      }
       if (!entry && !hasExplicitUrl) {
         console.error(
-          `Active assistant '${active}' not found in lockfile. Set an active assistant with 'vellum use <name>'.`,
+          `Active assistant '${active}' not found in lockfile. Set an active assistant with 'vellum use <name-or-id>'.`,
         );
         process.exit(1);
       }
@@ -116,7 +123,7 @@ function parseArgs(): ParsedArgs {
       entry = resolveAssistant();
     } else if (!entry) {
       console.error(
-        "No active assistant set. Set one with 'vellum use <name>' or specify a name: 'vellum client <name>'.",
+        "No active assistant set. Set one with 'vellum use <name-or-id>' or specify one: 'vellum client <name-or-id>'.",
       );
       process.exit(1);
     }
@@ -169,8 +176,6 @@ function parseArgs(): ParsedArgs {
     platformToken,
     bearerToken,
     interfaceId,
-    project: entry?.project,
-    zone: entry?.zone,
   };
 }
 
@@ -217,10 +222,10 @@ function printUsage(): void {
   console.log(`${ANSI.bold}vellum client${ANSI.reset} - Connect to a hatched assistant
 
 ${ANSI.bold}USAGE:${ANSI.reset}
-    vellum client [name] [options]
+    vellum client [name-or-id] [options]
 
 ${ANSI.bold}ARGUMENTS:${ANSI.reset}
-    [name]                     Instance name (default: active)
+    [name-or-id]               Assistant display name or ID (default: active)
 
 ${ANSI.bold}OPTIONS:${ANSI.reset}
     -u, --url <url>            Runtime URL
@@ -343,8 +348,6 @@ export async function client(): Promise<void> {
     platformToken,
     bearerToken,
     interfaceId,
-    project,
-    zone,
   } = parseArgs();
 
   if (interfaceId === WEB_INTERFACE_ID) {
@@ -404,6 +407,6 @@ export async function client(): Promise<void> {
       console.log(`${ANSI.dim}Disconnected.${ANSI.reset}`);
       process.exit(0);
     },
-    { auth, project, zone, assistantName },
+    { auth, assistantName },
   );
 }

package/src/commands/ps.ts

@@ -2,11 +2,16 @@ import { join } from "path";
 
 import {
   findAssistantByName,
+  formatAssistantLookupError,
+  formatAssistantReference,
   getActiveAssistant,
+  getAssistantDisplayName,
   getDaemonPidPath,
   loadAllAssistants,
+  lookupAssistantByIdentifier,
   type AssistantEntry,
 } from "../lib/assistant-config";
+import { parseAssistantTargetArg } from "../lib/assistant-target-args.js";
 import { resolveEnvironmentSource } from "../lib/environments/resolve";
 import { loadGuardianToken } from "../lib/guardian-token";
 import {
@@ -52,8 +57,10 @@ function pad(s: string, w: number): string {
   return s + " ".repeat(Math.max(0, w - s.length));
 }
 
-function computeColWidths(rows: TableRow[]): ColWidths {
-  const headers: TableRow = { name: "NAME", status: "STATUS", info: "INFO" };
+function computeColWidths(
+  rows: TableRow[],
+  headers: TableRow = { name: "NAME", status: "STATUS", info: "INFO" },
+): ColWidths {
   const all = [headers, ...rows];
   return {
     name: Math.max(...all.map((r) => r.name.length)),
@@ -66,9 +73,11 @@ function formatRow(r: TableRow, colWidths: ColWidths): string {
   return `  ${pad(r.name, colWidths.name)}  ${pad(r.status, colWidths.status)}  ${r.info}`;
 }
 
-function printTable(rows: TableRow[]): void {
-  const colWidths = computeColWidths(rows);
-  const headers: TableRow = { name: "PROCESS", status: "STATUS", info: "INFO" };
+function printTable(
+  rows: TableRow[],
+  headers: TableRow = { name: "PROCESS", status: "STATUS", info: "INFO" },
+): void {
+  const colWidths = computeColWidths(rows, headers);
   console.log(formatRow(headers, colWidths));
   const sep = `  ${"-".repeat(colWidths.name)}  ${"-".repeat(colWidths.status)}  ${"-".repeat(colWidths.info)}`;
   console.log(sep);
@@ -377,7 +386,7 @@ async function getDockerProcesses(entry: AssistantEntry): Promise<TableRow[]> {
 async function showAssistantProcesses(entry: AssistantEntry): Promise<void> {
   const cloud = resolveCloud(entry);
 
-  console.log(`Processes for ${entry.assistantId} (${cloud}):\n`);
+  console.log(`Processes for ${formatAssistantReference(entry)} (${cloud}):\n`);
 
   if (cloud === "local") {
     const rows = await getLocalProcesses(entry);
@@ -473,6 +482,75 @@ async function showAssistantProcesses(entry: AssistantEntry): Promise<void> {
 
 // ── List all assistants (no arg) ────────────────────────────────
 
+type AssistantHealth = {
+  status: string;
+  detail: string | null;
+  version?: string;
+};
+
+async function getAssistantListHealth(
+  entry: AssistantEntry,
+): Promise<AssistantHealth> {
+  const resources = entry.resources;
+  if (entry.cloud === "local" && resources) {
+    // TODO(ATL-306): Remove readPidFile/getDaemonPidPath in favor of
+    // fetching daemon PIDs via the health API (Gateway Security Migration).
+    const pid = readPidFile(getDaemonPidPath(resources));
+    const alive = pid !== null && isProcessAlive(pid);
+    if (!alive) {
+      return { status: "sleeping", detail: null };
+    }
+    const token = loadGuardianToken(entry.assistantId)?.accessToken;
+    return checkHealth(entry.localUrl ?? entry.runtimeUrl, token);
+  }
+
+  if (entry.cloud === "docker") {
+    const res = dockerResourceNames(entry.assistantId);
+    const state = await getDockerContainerState(res.assistantContainer);
+    if (!state || state !== "running") {
+      return { status: "sleeping", detail: null };
+    }
+    const token = loadGuardianToken(entry.assistantId)?.accessToken;
+    return checkHealth(entry.localUrl ?? entry.runtimeUrl, token);
+  }
+
+  if (entry.cloud === "apple-container") {
+    // Apple containers are managed by the macOS app. Probe the gateway
+    // (runtimeUrl is always written to the lockfile during hatch).
+    const token = loadGuardianToken(entry.assistantId)?.accessToken;
+    return entry.runtimeUrl
+      ? checkHealth(entry.runtimeUrl, token)
+      : { status: "unknown", detail: "no runtime URL" };
+  }
+
+  if (entry.cloud === "vellum") {
+    return checkManagedHealth(entry.runtimeUrl, entry.assistantId);
+  }
+
+  const token = loadGuardianToken(entry.assistantId)?.accessToken;
+  return checkHealth(entry.localUrl ?? entry.runtimeUrl, token);
+}
+
+function formatAssistantListRow(
+  entry: AssistantEntry,
+  activeAssistantId: string | null,
+  health: AssistantHealth,
+): TableRow {
+  const infoParts: string[] = [];
+  infoParts.push(`id: ${entry.assistantId}`);
+  if (entry.runtimeUrl) infoParts.push(entry.runtimeUrl);
+  if (entry.cloud) infoParts.push(`cloud: ${entry.cloud}`);
+  if (entry.species) infoParts.push(`species: ${entry.species}`);
+  if (health.detail) infoParts.push(health.detail);
+
+  const prefix = entry.assistantId === activeAssistantId ? "* " : "  ";
+  return {
+    name: prefix + getAssistantDisplayName(entry),
+    status: withStatusEmoji(health.status),
+    info: infoParts.join(" | "),
+  };
+}
+
 export async function listAllAssistants(verbose: boolean): Promise<void> {
   const { name: envName, source: envSource } = resolveEnvironmentSource();
   const sourceLabels: Record<typeof envSource, string> = {
@@ -519,6 +597,9 @@ export async function listAllAssistants(verbose: boolean): Promise<void> {
 
   const assistants = loadAllAssistants();
   const activeId = getActiveAssistant();
+  const activeAssistantId = activeId
+    ? (findAssistantByName(activeId)?.assistantId ?? activeId)
+    : null;
 
   if (assistants.length === 0) {
     console.log("No assistants found.");
@@ -540,97 +621,17 @@ export async function listAllAssistants(verbose: boolean): Promise<void> {
     return;
   }
 
-  const rows: TableRow[] = assistants.map((a) => {
-    const infoParts: string[] = [];
-    if (a.runtimeUrl) infoParts.push(a.runtimeUrl);
-    if (a.cloud) infoParts.push(`cloud: ${a.cloud}`);
-    if (a.species) infoParts.push(`species: ${a.species}`);
-    const prefix = a.assistantId === activeId ? "* " : "  ";
-
-    return {
-      name: prefix + a.assistantId,
-      status: withStatusEmoji("checking..."),
-      info: infoParts.join(" | "),
-    };
-  });
-
-  const colWidths = computeColWidths(rows);
-
-  const headers: TableRow = { name: "NAME", status: "STATUS", info: "INFO" };
-  console.log(formatRow(headers, colWidths));
-  const sep = `  ${"-".repeat(colWidths.name)}  ${"-".repeat(colWidths.status)}  ${"-".repeat(colWidths.info)}`;
-  console.log(sep);
-  for (const row of rows) {
-    console.log(formatRow(row, colWidths));
-  }
-
-  const totalDataRows = rows.length;
-
-  await Promise.all(
-    assistants.map(async (a, rowIndex) => {
-      // For local assistants, check if the daemon process is alive before
-      // hitting the health endpoint. If the PID file is missing or the
-      // process isn't running, the assistant is sleeping — skip the
-      // network health check to avoid a misleading "unreachable" status.
-      let health: { status: string; detail: string | null; version?: string };
-      const resources = a.resources;
-      if (a.cloud === "local" && resources) {
-        // TODO(ATL-306): Remove readPidFile/getDaemonPidPath in favor of
-        // fetching daemon PIDs via the health API (Gateway Security Migration).
-        const pid = readPidFile(getDaemonPidPath(resources));
-        const alive = pid !== null && isProcessAlive(pid);
-        if (!alive) {
-          health = { status: "sleeping", detail: null };
-        } else {
-          const token = loadGuardianToken(a.assistantId)?.accessToken;
-          health = await checkHealth(a.localUrl ?? a.runtimeUrl, token);
-        }
-      } else if (a.cloud === "docker") {
-        const res = dockerResourceNames(a.assistantId);
-        const state = await getDockerContainerState(res.assistantContainer);
-        if (!state || state !== "running") {
-          health = { status: "sleeping", detail: null };
-        } else {
-          const token = loadGuardianToken(a.assistantId)?.accessToken;
-          health = await checkHealth(a.localUrl ?? a.runtimeUrl, token);
-        }
-      } else if (a.cloud === "apple-container") {
-        // Apple containers are managed by the macOS app. Probe the gateway
-        // (runtimeUrl is always written to the lockfile during hatch).
-        const token = loadGuardianToken(a.assistantId)?.accessToken;
-        health = a.runtimeUrl
-          ? await checkHealth(a.runtimeUrl, token)
-          : { status: "unknown" as const, detail: "no runtime URL" };
-      } else if (a.cloud === "vellum") {
-        health = await checkManagedHealth(a.runtimeUrl, a.assistantId);
-      } else {
-        const token = loadGuardianToken(a.assistantId)?.accessToken;
-        health = await checkHealth(a.localUrl ?? a.runtimeUrl, token);
-      }
-
-      const infoParts: string[] = [];
-      if (a.runtimeUrl) infoParts.push(a.runtimeUrl);
-      if (a.cloud) infoParts.push(`cloud: ${a.cloud}`);
-      if (a.species) infoParts.push(`species: ${a.species}`);
-      if (health.detail) infoParts.push(health.detail);
-
-      const prefix = a.assistantId === activeId ? "* " : "  ";
-      const updatedRow: TableRow = {
-        name: prefix + a.assistantId,
-        status: withStatusEmoji(health.status),
-        info: infoParts.join(" | "),
-      };
-
-      const linesUp = totalDataRows - rowIndex;
-      process.stdout.write(
-        `\x1b[${linesUp}A` +
-          `\r\x1b[K` +
-          formatRow(updatedRow, colWidths) +
-          `\n` +
-          (linesUp > 1 ? `\x1b[${linesUp - 1}B` : ""),
-      );
-    }),
+  const rows = await Promise.all(
+    assistants.map(async (entry) =>
+      formatAssistantListRow(
+        entry,
+        activeAssistantId,
+        await getAssistantListHealth(entry),
+      ),
+    ),
   );
+
+  printTable(rows, { name: "NAME", status: "STATUS", info: "INFO" });
 }
 
 // ── Entry point ─────────────────────────────────────────────────
@@ -638,14 +639,16 @@ export async function listAllAssistants(verbose: boolean): Promise<void> {
 export async function ps(): Promise<void> {
   const args = process.argv.slice(3);
   if (args.includes("--help") || args.includes("-h")) {
-    console.log("Usage: vellum ps [<name>] [--verbose]");
+    console.log("Usage: vellum ps [<name-or-id>] [--verbose]");
     console.log("");
     console.log(
       "List all assistants, or show processes for a specific assistant.",
     );
     console.log("");
     console.log("Arguments:");
-    console.log("  <name>       Show processes for the named assistant");
+    console.log(
+      "  <name-or-id> Show processes for the assistant display name or ID",
+    );
     console.log("");
     console.log("Options:");
     console.log(
@@ -655,19 +658,18 @@ export async function ps(): Promise<void> {
   }
 
   const verbose = args.includes("--verbose");
-  const positional = args.filter((a) => !a.startsWith("--"));
-  const assistantId = positional[0];
+  const assistantIdentifier = parseAssistantTargetArg(args);
 
-  if (!assistantId) {
+  if (!assistantIdentifier) {
     await listAllAssistants(verbose);
     return;
   }
 
-  const entry = findAssistantByName(assistantId);
-  if (!entry) {
-    console.error(`No assistant found with name '${assistantId}'.`);
+  const result = lookupAssistantByIdentifier(assistantIdentifier);
+  if (result.status !== "found") {
+    console.error(formatAssistantLookupError(assistantIdentifier, result));
     process.exit(1);
   }
 
-  await showAssistantProcesses(entry);
+  await showAssistantProcesses(result.entry);
 }

package/src/commands/retire.ts

@@ -2,30 +2,34 @@ import { existsSync, unlinkSync } from "fs";
 import { join } from "path";
 
 import {
-  findAssistantByName,
+  formatAssistantLookupError,
+  formatAssistantReference,
+  getAssistantDisplayName,
   loadAllAssistants,
+  lookupAssistantByIdentifier,
   removeAssistantEntry,
-} from "../lib/assistant-config";
-import type { AssistantEntry } from "../lib/assistant-config";
-import { getConfigDir } from "../lib/environments/paths";
-import { getCurrentEnvironment } from "../lib/environments/resolve";
+} from "../lib/assistant-config.js";
+import type { AssistantEntry } from "../lib/assistant-config.js";
+import { parseAssistantTargetArg } from "../lib/assistant-target-args.js";
+import { getConfigDir } from "../lib/environments/paths.js";
+import { getCurrentEnvironment } from "../lib/environments/resolve.js";
 import {
   authHeaders,
   getPlatformUrl,
   readPlatformToken,
-} from "../lib/platform-client";
-import { retireInstance as retireAwsInstance } from "../lib/aws";
-import { retireDocker } from "../lib/docker";
-import { retireInstance as retireGcpInstance } from "../lib/gcp";
-import { retireLocal } from "../lib/retire-local";
-import { retireAppleContainer } from "../lib/retire-apple-container";
-import { exec } from "../lib/step-runner";
+} from "../lib/platform-client.js";
+import { retireInstance as retireAwsInstance } from "../lib/aws.js";
+import { retireDocker } from "../lib/docker.js";
+import { retireInstance as retireGcpInstance } from "../lib/gcp.js";
+import { retireLocal } from "../lib/retire-local.js";
+import { retireAppleContainer } from "../lib/retire-apple-container.js";
+import { exec } from "../lib/step-runner.js";
 import {
   openLogFile,
   closeLogFile,
   resetLogFile,
   writeToLogFile,
-} from "../lib/xdg-log";
+} from "../lib/xdg-log.js";
 
 function resolveCloud(entry: AssistantEntry): string {
   if (entry.cloud) {
@@ -51,6 +55,12 @@ function extractHostFromUrl(url: string): string {
 
 export { retireLocal };
 
+interface RetireArgs {
+  name?: string;
+  source?: string;
+  yes: boolean;
+}
+
 async function retireCustom(entry: AssistantEntry): Promise<void> {
   const host = extractHostFromUrl(entry.runtimeUrl);
   const sshUser = entry.sshUser ?? "root";
@@ -129,14 +139,82 @@ async function retireVellum(
   }
 }
 
-function parseSource(): string | undefined {
-  const args = process.argv.slice(4);
+function parseRetireArgs(args: string[]): RetireArgs {
+  let source: string | undefined;
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--source" && args[i + 1]) {
-      return args[i + 1];
+      source = args[i + 1];
+      i++;
     }
   }
-  return undefined;
+
+  return {
+    name: parseAssistantTargetArg(args, ["--source"]),
+    source,
+    yes: args.includes("--yes"),
+  };
+}
+
+function formatRuntimeUrl(entry: AssistantEntry): string {
+  return entry.localUrl ?? entry.runtimeUrl;
+}
+
+function printRetireTarget(entry: AssistantEntry, cloud: string): void {
+  const displayName = getAssistantDisplayName(entry);
+
+  console.log("Assistant to retire:");
+  if (displayName !== entry.assistantId) {
+    console.log(`  Name: ${displayName}`);
+  }
+  console.log(`  ID: ${entry.assistantId}`);
+  console.log(`  Cloud: ${cloud}`);
+  console.log(`  Runtime: ${formatRuntimeUrl(entry)}`);
+  console.log("");
+}
+
+function canPromptForRetireConfirmation(): boolean {
+  return (
+    process.stdin.isTTY === true &&
+    process.stdout.isTTY === true &&
+    typeof process.stdin.setRawMode === "function"
+  );
+}
+
+async function confirmRetireInteractive(): Promise<boolean> {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  const wasRaw = stdin.isRaw === true;
+  const wasPaused = stdin.isPaused();
+
+  stdout.write("Press Enter to retire, or Esc/q to cancel: ");
+  stdin.setRawMode(true);
+  stdin.resume();
+
+  return await new Promise<boolean>((resolve) => {
+    const cleanup = () => {
+      stdin.off("data", onData);
+      stdin.setRawMode(wasRaw);
+      if (wasPaused) {
+        stdin.pause();
+      }
+      stdout.write("\n");
+    };
+
+    const onData = (chunk: Buffer) => {
+      const byte = chunk[0];
+      if (byte === 13 || byte === 10) {
+        cleanup();
+        resolve(true);
+        return;
+      }
+      if (byte === 27 || byte === 3 || byte === 113 || byte === 81) {
+        cleanup();
+        resolve(false);
+      }
+    };
+
+    stdin.on("data", onData);
+  });
 }
 
 /** Patch console methods to also append output to the given log file descriptor. */
@@ -188,38 +266,70 @@ export async function retire(): Promise<void> {
 async function retireInner(): Promise<void> {
   const args = process.argv.slice(3);
   if (args.includes("--help") || args.includes("-h")) {
-    console.log("Usage: vellum retire <name> [--source <source>]");
+    console.log(
+      "Usage: vellum retire <name-or-id> [--source <source>] [--yes]",
+    );
     console.log("");
     console.log("Delete an assistant instance and archive its data.");
+    console.log(
+      "By default, retire prints the assistant name, ID, cloud, and runtime before asking for confirmation.",
+    );
     console.log("");
     console.log("Arguments:");
-    console.log("  <name>               Name of the assistant to retire");
+    console.log(
+      "  <name-or-id>         Assistant display name or ID to retire",
+    );
     console.log("");
     console.log("Options:");
     console.log("  --source <source>    Source identifier for the retirement");
+    console.log(
+      "  --yes                Skip the interactive confirmation prompt",
+    );
     process.exit(0);
   }
 
-  const name = process.argv[3];
+  const parsed = parseRetireArgs(args);
+  const name = parsed.name;
 
   if (!name) {
-    console.error("Error: Instance name is required.");
-    console.error("Usage: vellum retire <name> [--source <source>]");
+    console.error("Error: Assistant name or ID is required.");
+    console.error(
+      "Usage: vellum retire <name-or-id> [--source <source>] [--yes]",
+    );
     process.exit(1);
   }
 
-  const entry = findAssistantByName(name);
-  if (!entry) {
-    console.error(`No assistant found with name '${name}'.`);
+  const lookup = lookupAssistantByIdentifier(name);
+  if (lookup.status !== "found") {
+    console.error(formatAssistantLookupError(name, lookup));
     console.error("Run 'vellum hatch' first, or check the instance name.");
     process.exit(1);
   }
 
-  const source = parseSource();
+  const entry = lookup.entry;
+  const assistantId = entry.assistantId;
+  const source = parsed.source;
   const cloud = resolveCloud(entry);
+  printRetireTarget(entry, cloud);
+
+  if (!parsed.yes) {
+    if (!canPromptForRetireConfirmation()) {
+      console.error(
+        "Error: Refusing to retire without confirmation in a non-interactive terminal.",
+      );
+      console.error("Re-run with --yes to confirm from automation.");
+      process.exit(1);
+    }
+
+    const confirmed = await confirmRetireInteractive();
+    if (!confirmed) {
+      console.log("Retire cancelled.");
+      process.exit(1);
+    }
+  }
 
   if (cloud === "apple-container") {
-    await retireAppleContainer(name, entry);
+    await retireAppleContainer(assistantId, entry);
   } else if (cloud === "gcp") {
     const project = entry.project;
     const zone = entry.zone;
@@ -229,29 +339,29 @@ async function retireInner(): Promise<void> {
       );
       process.exit(1);
     }
-    await retireGcpInstance(name, project, zone, source);
+    await retireGcpInstance(assistantId, project, zone, source);
   } else if (cloud === "aws") {
     const region = entry.region;
     if (!region) {
       console.error("Error: AWS region not found in assistant config.");
       process.exit(1);
     }
-    await retireAwsInstance(name, region, source);
+    await retireAwsInstance(assistantId, region, source);
   } else if (cloud === "docker") {
-    await retireDocker(name);
+    await retireDocker(assistantId);
   } else if (cloud === "local") {
-    await retireLocal(name, entry);
+    await retireLocal(assistantId, entry);
   } else if (cloud === "custom") {
     await retireCustom(entry);
   } else if (cloud === "vellum") {
-    await retireVellum(entry.assistantId, entry.runtimeUrl);
+    await retireVellum(assistantId, entry.runtimeUrl);
   } else {
     console.error(`Error: Unknown cloud type '${cloud}'.`);
     process.exit(1);
   }
 
-  removeAssistantEntry(name);
-  console.log(`Removed ${name} from config.`);
+  removeAssistantEntry(assistantId);
+  console.log(`Removed ${formatAssistantReference(entry)} from config.`);
 
   // When no assistants remain, remove the dock-display-name sentinel so
   // the next build.sh run falls back to "Vellum" instead of using the