@vellumai/cli 0.4.36 → 0.4.40

package/src/commands/hatch.ts

@@ -21,14 +21,19 @@ import cliPkg from "../../package.json";
 
 import { buildOpenclawStartupScript } from "../adapters/openclaw";
 import {
+  allocateLocalResources,
+  defaultLocalResources,
+  findAssistantByName,
   loadAllAssistants,
   saveAssistantEntry,
   syncConfigToLockfile,
 } from "../lib/assistant-config";
-import type { AssistantEntry } from "../lib/assistant-config";
+import type {
+  AssistantEntry,
+  LocalInstanceResources,
+} from "../lib/assistant-config";
 import { hatchAws } from "../lib/aws";
 import {
-  GATEWAY_PORT,
   SPECIES_CONFIG,
   VALID_REMOTE_HOSTS,
   VALID_SPECIES,
@@ -41,7 +46,6 @@ import {
   startGateway,
   stopLocalProcesses,
 } from "../lib/local";
-import { probePort } from "../lib/port-probe";
 import { isProcessAlive } from "../lib/process";
 import { generateRandomSuffix } from "../lib/random-name";
 import { validateAssistantName } from "../lib/retire-archive";
@@ -583,6 +587,8 @@ async function waitForDaemonReady(
 async function displayPairingQRCode(
   runtimeUrl: string,
   bearerToken: string | undefined,
+  /** External gateway URL for the QR payload. When omitted, runtimeUrl is used. */
+  externalGatewayUrl?: string,
 ): Promise<void> {
   try {
     const pairingRequestId = randomUUID();
@@ -609,7 +615,7 @@ async function displayPairingQRCode(
       body: JSON.stringify({
         pairingRequestId,
         pairingSecret,
-        gatewayUrl: runtimeUrl,
+        gatewayUrl: externalGatewayUrl ?? runtimeUrl,
       }),
     });
 
@@ -628,7 +634,7 @@ async function displayPairingQRCode(
       type: "vellum-daemon",
       v: 4,
       id: hostId,
-      g: runtimeUrl,
+      g: externalGatewayUrl ?? runtimeUrl,
       pairingRequestId,
       pairingSecret,
     });
@@ -703,64 +709,49 @@ async function hatchLocal(
       );
       await stopLocalProcesses();
     }
+  }
 
-    // Verify required ports are available before starting any services.
-    // Only check when no local assistants exist — if there are existing local
-    // assistants, their daemon/gateway/qdrant legitimately own these ports.
-    const RUNTIME_HTTP_PORT = Number(process.env.RUNTIME_HTTP_PORT) || 7821;
-    const QDRANT_PORT = 6333;
-    const requiredPorts = [
-      { name: "daemon", port: RUNTIME_HTTP_PORT },
-      { name: "gateway", port: GATEWAY_PORT },
-      { name: "qdrant", port: QDRANT_PORT },
-    ];
-    const conflicts: string[] = [];
-    await Promise.all(
-      requiredPorts.map(async ({ name, port }) => {
-        if (await probePort(port)) {
-          conflicts.push(`  - Port ${port} (${name}) is already in use`);
-        }
-      }),
-    );
-    if (conflicts.length > 0) {
-      throw new Error(
-        `Cannot hatch — required ports are already in use:\n${conflicts.join("\n")}\n\n` +
-          "Stop the conflicting processes or use environment variables to configure alternative ports " +
-          "(RUNTIME_HTTP_PORT, GATEWAY_PORT).",
-      );
-    }
+  // Reuse existing resources if re-hatching with --name that matches a known
+  // local assistant, otherwise allocate fresh per-instance ports and directories.
+  let resources: LocalInstanceResources;
+  const existingEntry = findAssistantByName(instanceName);
+  if (existingEntry?.cloud === "local" && existingEntry.resources) {
+    resources = existingEntry.resources;
+  } else if (restart && existingEntry?.cloud === "local") {
+    // Legacy entry without resources — use default paths to match existing layout
+    resources = defaultLocalResources();
+  } else {
+    resources = await allocateLocalResources(instanceName);
   }
 
-  const baseDataDir = join(
-    process.env.BASE_DATA_DIR?.trim() ||
-      (process.env.HOME ?? userInfo().homedir),
-    ".vellum",
-  );
+  const baseDataDir = join(resources.instanceDir, ".vellum");
 
   console.log(`🥚 Hatching local assistant: ${instanceName}`);
   console.log(`   Species: ${species}`);
   console.log("");
 
-  await startLocalDaemon(watch);
+  await startLocalDaemon(watch, resources);
 
   let runtimeUrl: string;
   try {
-    runtimeUrl = await startGateway(instanceName, watch);
+    runtimeUrl = await startGateway(instanceName, watch, resources);
   } catch (error) {
     // Gateway failed — stop the daemon we just started so we don't leave
     // orphaned processes with no lock file entry.
     console.error(
       `\n❌ Gateway startup failed — stopping assistant to avoid orphaned processes.`,
     );
-    await stopLocalProcesses();
+    await stopLocalProcesses(resources);
     throw error;
   }
 
   // Read the bearer token (JWT) written by the daemon so the CLI can
-  // authenticate with the gateway.
+  // with the gateway (which requires auth by default). The daemon writes under
+  // getRootDir() which resolves to <instanceDir>/.vellum/.
   let bearerToken: string | undefined;
   try {
-    const token = readFileSync(join(baseDataDir, "http-token"), "utf-8").trim();
+    const tokenPath = join(resources.instanceDir, ".vellum", "http-token");
+    const token = readFileSync(tokenPath, "utf-8").trim();
     if (token) bearerToken = token;
   } catch {
     // Token file may not exist if daemon started without HTTP server
@@ -769,11 +760,13 @@ async function hatchLocal(
   const localEntry: AssistantEntry = {
     assistantId: instanceName,
     runtimeUrl,
+    localUrl: `http://127.0.0.1:${resources.gatewayPort}`,
     baseDataDir,
     bearerToken,
     cloud: "local",
     species,
     hatchedAt: new Date().toISOString(),
+    resources,
   };
   if (!daemonOnly && !restart) {
     saveAssistantEntry(localEntry);
@@ -791,8 +784,11 @@ async function hatchLocal(
     console.log(`  Runtime: ${runtimeUrl}`);
     console.log("");
 
-    // Generate and display pairing QR code
-    await displayPairingQRCode(runtimeUrl, bearerToken);
+    // Use loopback for HTTP calls (health check + pairing register) since
+    // mDNS hostnames may not resolve on the local machine, but keep the
+    // external runtimeUrl in the QR payload so iOS devices can reach it.
+    const localGatewayUrl = `http://127.0.0.1:${resources.gatewayPort}`;
+    await displayPairingQRCode(localGatewayUrl, bearerToken, runtimeUrl);
   }
 }
 

package/src/commands/ps.ts

@@ -3,20 +3,18 @@ import { homedir } from "os";
 import { join } from "path";
 
 import {
+  defaultLocalResources,
   findAssistantByName,
+  getActiveAssistant,
   loadAllAssistants,
   type AssistantEntry,
 } from "../lib/assistant-config";
-import { GATEWAY_PORT } from "../lib/constants";
 import { checkHealth } from "../lib/health-check";
 import { pgrepExact } from "../lib/pgrep";
 import { probePort } from "../lib/port-probe";
 import { withStatusEmoji } from "../lib/status-emoji";
 import { execOutput } from "../lib/step-runner";
 
-const RUNTIME_HTTP_PORT = Number(process.env.RUNTIME_HTTP_PORT) || 7821;
-const QDRANT_PORT = 6333;
-
 // ── Table formatting helpers ────────────────────────────────────
 
 interface TableRow {
@@ -218,25 +216,26 @@ function formatDetectionInfo(proc: DetectedProcess): string {
 }
 
 async function getLocalProcesses(entry: AssistantEntry): Promise<TableRow[]> {
-  const vellumDir = entry.baseDataDir ?? join(homedir(), ".vellum");
+  const resources = entry.resources ?? defaultLocalResources();
+  const vellumDir = join(resources.instanceDir, ".vellum");
 
   const specs: ProcessSpec[] = [
     {
       name: "assistant",
       pgrepName: "vellum-daemon",
-      port: RUNTIME_HTTP_PORT,
-      pidFile: join(vellumDir, "vellum.pid"),
+      port: resources.daemonPort,
+      pidFile: resources.pidFile,
     },
     {
       name: "qdrant",
       pgrepName: "qdrant",
-      port: QDRANT_PORT,
+      port: resources.qdrantPort,
       pidFile: join(vellumDir, "workspace", "data", "qdrant", "qdrant.pid"),
     },
     {
       name: "gateway",
       pgrepName: "vellum-gateway",
-      port: GATEWAY_PORT,
+      port: resources.gatewayPort,
       pidFile: join(vellumDir, "gateway.pid"),
     },
     {
@@ -355,6 +354,7 @@ async function detectOrphanedProcesses(): Promise<OrphanedProcess[]> {
 
 async function listAllAssistants(): Promise<void> {
   const assistants = loadAllAssistants();
+  const activeId = getActiveAssistant();
 
   if (assistants.length === 0) {
     console.log("No assistants found.");
@@ -381,9 +381,10 @@ async function listAllAssistants(): Promise<void> {
     const infoParts = [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: a.assistantId,
+      name: prefix + a.assistantId,
       status: withStatusEmoji("checking..."),
       info: infoParts.join(" | "),
     };
@@ -403,15 +404,34 @@ async function listAllAssistants(): Promise<void> {
 
   await Promise.all(
     assistants.map(async (a, rowIndex) => {
-      const health = await checkHealth(a.runtimeUrl, a.bearerToken);
+      // 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 };
+      const resources =
+        a.resources ??
+        (a.cloud === "local" ? defaultLocalResources() : undefined);
+      if (a.cloud === "local" && resources) {
+        const pid = readPidFile(resources.pidFile);
+        const alive = pid !== null && isProcessAlive(pid);
+        if (!alive) {
+          health = { status: "sleeping", detail: null };
+        } else {
+          health = await checkHealth(a.localUrl ?? a.runtimeUrl, a.bearerToken);
+        }
+      } else {
+        health = await checkHealth(a.localUrl ?? a.runtimeUrl, a.bearerToken);
+      }
 
       const infoParts = [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: a.assistantId,
+        name: prefix + a.assistantId,
         status: withStatusEmoji(health.status),
         info: infoParts.join(" | "),
       };

package/src/commands/retire.ts

@@ -4,7 +4,9 @@ import { homedir } from "os";
 import { basename, dirname, join } from "path";
 
 import {
+  defaultLocalResources,
   findAssistantByName,
+  loadAllAssistants,
   removeAssistantEntry,
 } from "../lib/assistant-config";
 import type { AssistantEntry } from "../lib/assistant-config";
@@ -40,18 +42,44 @@ function extractHostFromUrl(url: string): string {
   }
 }
 
-function getBaseDir(): string {
-  return process.env.BASE_DATA_DIR?.trim() || homedir();
-}
-
 async function retireLocal(name: string, entry: AssistantEntry): Promise<void> {
   console.log("\u{1F5D1}\ufe0f  Stopping local assistant...\n");
 
-  const vellumDir = join(getBaseDir(), ".vellum");
+  // Use entry resources when available; for legacy entries, derive paths
+  // from baseDataDir (which may differ from homedir if BASE_DATA_DIR was set).
+  const resources = entry.resources ?? defaultLocalResources();
+  const legacyDir = entry.baseDataDir;
+  const vellumDir = legacyDir ?? join(resources.instanceDir, ".vellum");
+
+  // Check whether another local assistant shares the same data directory.
+  // Legacy entries without `resources` all resolve to ~/.vellum/ — if we
+  // blindly kill processes and archive the directory, we'd destroy the
+  // other assistant's running daemon and data.
+  const otherSharesDir = loadAllAssistants().some((other) => {
+    if (other.cloud !== "local") return false;
+    if (other.assistantId === name) return false;
+    const otherVellumDir =
+      other.baseDataDir ??
+      join((other.resources ?? defaultLocalResources()).instanceDir, ".vellum");
+    return otherVellumDir === vellumDir;
+  });
 
-  // Stop daemon via PID file
-  const daemonPidFile = join(vellumDir, "vellum.pid");
-  const socketFile = join(vellumDir, "vellum.sock");
+  if (otherSharesDir) {
+    console.log(
+      `   Skipping process stop and archive — another local assistant shares ${vellumDir}.`,
+    );
+    console.log("\u2705 Local instance retired (config entry removed only).");
+    return;
+  }
+
+  // Stop daemon via PID file — prefer resources paths, but for legacy entries
+  // with a custom baseDataDir, derive from that directory instead.
+  const daemonPidFile = legacyDir
+    ? join(legacyDir, "vellum.pid")
+    : resources.pidFile;
+  const socketFile = legacyDir
+    ? join(legacyDir, "vellum.sock")
+    : resources.socketPath;
   const daemonStopped = await stopProcessByPidFile(daemonPidFile, "daemon", [
     socketFile,
   ]);
@@ -67,14 +95,22 @@ async function retireLocal(name: string, entry: AssistantEntry): Promise<void> {
     await stopOrphanedDaemonProcesses();
   }
 
+  // For named instances (instanceDir differs from homedir), archive and
+  // remove the entire instance directory. For the default instance
+  // (instanceDir is homedir), archive only the .vellum subdirectory.
+  const isNamedInstance = resources.instanceDir !== homedir();
+  const dirToArchive = isNamedInstance ? resources.instanceDir : vellumDir;
+
   // Move the data directory out of the way so the path is immediately available
   // for the next hatch, then kick off the tar archive in the background.
   const archivePath = getArchivePath(name);
   const metadataPath = getMetadataPath(name);
   const stagingDir = `${archivePath}.staging`;
 
-  if (!existsSync(vellumDir)) {
-    console.log(`   No data directory at ${vellumDir} — nothing to archive.`);
+  if (!existsSync(dirToArchive)) {
+    console.log(
+      `   No data directory at ${dirToArchive} — nothing to archive.`,
+    );
     console.log("\u2705 Local instance retired.");
     return;
   }
@@ -83,10 +119,10 @@ async function retireLocal(name: string, entry: AssistantEntry): Promise<void> {
   mkdirSync(dirname(stagingDir), { recursive: true });
 
   try {
-    renameSync(vellumDir, stagingDir);
+    renameSync(dirToArchive, stagingDir);
   } catch (err) {
     console.warn(
-      `⚠️  Failed to move ${vellumDir}: ${err instanceof Error ? err.message : err}`,
+      `⚠️  Failed to move ${dirToArchive}: ${err instanceof Error ? err.message : err}`,
     );
     console.warn("Skipping archive.");
     console.log("\u2705 Local instance retired.");

package/src/commands/skills.ts

@@ -1,10 +1,12 @@
 import { execSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import {
+  cpSync,
   existsSync,
   mkdirSync,
   readFileSync,
   renameSync,
+  rmSync,
   writeFileSync,
 } from "node:fs";
 import { homedir } from "node:os";
@@ -27,6 +29,38 @@ function getSkillsIndexPath(): string {
   return join(getSkillsDir(), "SKILLS.md");
 }
 
+/**
+ * Resolve the repo-level skills/ directory when running in dev mode.
+ * Returns the path if VELLUM_DEV is set and the directory exists, or undefined.
+ */
+function getRepoSkillsDir(): string | undefined {
+  if (!process.env.VELLUM_DEV) return undefined;
+
+  // cli/src/commands/skills.ts -> ../../../skills/
+  const candidate = join(import.meta.dir, "..", "..", "..", "skills");
+  if (existsSync(join(candidate, "catalog.json"))) {
+    return candidate;
+  }
+  return undefined;
+}
+
+/**
+ * Read skills from the repo-local catalog.json.
+ */
+function readLocalCatalog(repoSkillsDir: string): CatalogSkill[] {
+  try {
+    const raw = readFileSync(
+      join(repoSkillsDir, "catalog.json"),
+      "utf-8",
+    );
+    const manifest = JSON.parse(raw) as CatalogManifest;
+    if (!Array.isArray(manifest.skills)) return [];
+    return manifest.skills;
+  } catch {
+    return [];
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Platform API client
 // ---------------------------------------------------------------------------
@@ -221,6 +255,33 @@ function upsertSkillsIndex(id: string): void {
   atomicWriteFile(indexPath, content.endsWith("\n") ? content : content + "\n");
 }
 
+function removeSkillsIndexEntry(id: string): void {
+  const indexPath = getSkillsIndexPath();
+  if (!existsSync(indexPath)) return;
+
+  const lines = readFileSync(indexPath, "utf-8").split("\n");
+  const escaped = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`^[-*]\\s+(?:\`)?${escaped}(?:\`)?\\s*$`);
+  const filtered = lines.filter((line) => !pattern.test(line));
+
+  // If nothing changed, skip the write
+  if (filtered.length === lines.length) return;
+
+  const content = filtered.join("\n");
+  atomicWriteFile(indexPath, content.endsWith("\n") ? content : content + "\n");
+}
+
+function uninstallSkillLocally(skillId: string): void {
+  const skillDir = join(getSkillsDir(), skillId);
+
+  if (!existsSync(skillDir)) {
+    throw new Error(`Skill "${skillId}" is not installed.`);
+  }
+
+  rmSync(skillDir, { recursive: true, force: true });
+  removeSkillsIndexEntry(skillId);
+}
+
 async function installSkillLocally(
   skillId: string,
   catalogEntry: CatalogSkill,
@@ -237,8 +298,17 @@ async function installSkillLocally(
 
   mkdirSync(skillDir, { recursive: true });
 
-  // Extract all files from the archive into the skill directory
-  await fetchAndExtractSkill(skillId, skillDir);
+  // In dev mode, install from the local repo skills directory if available
+  const repoSkillsDir = getRepoSkillsDir();
+  const repoSkillSource = repoSkillsDir
+    ? join(repoSkillsDir, skillId)
+    : undefined;
+
+  if (repoSkillSource && existsSync(join(repoSkillSource, "SKILL.md"))) {
+    cpSync(repoSkillSource, skillDir, { recursive: true });
+  } else {
+    await fetchAndExtractSkill(skillId, skillDir);
+  }
 
   // Write version metadata
   if (catalogEntry.version) {
@@ -288,6 +358,9 @@ function printUsage(): void {
   console.log(
     "  install <skill-id> [--overwrite]  Install a skill from the catalog",
   );
+  console.log(
+    "  uninstall <skill-id>              Uninstall a previously installed skill",
+  );
   console.log("");
   console.log("Options:");
   console.log("  --json    Machine-readable JSON output");
@@ -312,6 +385,18 @@ export async function skills(): Promise<void> {
       try {
         const catalog = await fetchCatalog();
 
+        // In dev mode, merge in skills from the repo-local skills/ directory
+        const repoSkillsDir = getRepoSkillsDir();
+        if (repoSkillsDir) {
+          const localSkills = readLocalCatalog(repoSkillsDir);
+          const remoteIds = new Set(catalog.map((s) => s.id));
+          for (const local of localSkills) {
+            if (!remoteIds.has(local.id)) {
+              catalog.push(local);
+            }
+          }
+        }
+
         if (json) {
           console.log(JSON.stringify({ ok: true, skills: catalog }));
           return;
@@ -353,9 +438,20 @@ export async function skills(): Promise<void> {
       const overwrite = hasFlag(args, "--overwrite");
 
       try {
-        // Verify skill exists in catalog
-        const catalog = await fetchCatalog();
-        const entry = catalog.find((s) => s.id === skillId);
+        // In dev mode, also check the repo-local skills/ directory
+        const repoSkillsDir = getRepoSkillsDir();
+        let localSkills: CatalogSkill[] = [];
+        if (repoSkillsDir) {
+          localSkills = readLocalCatalog(repoSkillsDir);
+        }
+
+        // Check local catalog first, then fall back to remote
+        let entry = localSkills.find((s) => s.id === skillId);
+        if (!entry) {
+          const catalog = await fetchCatalog();
+          entry = catalog.find((s) => s.id === skillId);
+        }
+
         if (!entry) {
           throw new Error(`Skill "${skillId}" not found in the Vellum catalog`);
         }
@@ -380,6 +476,35 @@ export async function skills(): Promise<void> {
       break;
     }
 
+    case "uninstall": {
+      const skillId = args.find(
+        (a) => !a.startsWith("--") && a !== "uninstall",
+      );
+      if (!skillId) {
+        console.error("Usage: vellum skills uninstall <skill-id>");
+        process.exit(1);
+      }
+
+      try {
+        uninstallSkillLocally(skillId);
+
+        if (json) {
+          console.log(JSON.stringify({ ok: true, skillId }));
+        } else {
+          console.log(`Uninstalled skill "${skillId}".`);
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (json) {
+          console.log(JSON.stringify({ ok: false, error: msg }));
+        } else {
+          console.error(`Error: ${msg}`);
+        }
+        process.exitCode = 1;
+      }
+      break;
+    }
+
     default: {
       console.error(`Unknown skills subcommand: ${subcommand}`);
       printUsage();

package/src/commands/sleep.ts

@@ -1,20 +1,40 @@
-import { homedir } from "os";
 import { join } from "path";
 
+import {
+  defaultLocalResources,
+  resolveTargetAssistant,
+} from "../lib/assistant-config.js";
 import { stopProcessByPidFile } from "../lib/process";
 
 export async function sleep(): Promise<void> {
   const args = process.argv.slice(3);
   if (args.includes("--help") || args.includes("-h")) {
-    console.log("Usage: vellum sleep");
+    console.log("Usage: vellum sleep [<name>]");
     console.log("");
     console.log("Stop the assistant and gateway processes.");
+    console.log("");
+    console.log("Arguments:");
+    console.log(
+      "  <name>    Name of the assistant to stop (default: active or only local)",
+    );
     process.exit(0);
   }
 
-  const vellumDir = join(homedir(), ".vellum");
-  const daemonPidFile = join(vellumDir, "vellum.pid");
-  const socketFile = join(vellumDir, "vellum.sock");
+  const nameArg = args.find((a) => !a.startsWith("-"));
+  const entry = resolveTargetAssistant(nameArg);
+
+  if (entry.cloud && entry.cloud !== "local") {
+    console.error(
+      `Error: 'vellum sleep' only works with local assistants. '${entry.assistantId}' is a ${entry.cloud} instance.`,
+    );
+    process.exit(1);
+  }
+
+  const resources = entry.resources ?? defaultLocalResources();
+
+  const daemonPidFile = resources.pidFile;
+  const socketFile = resources.socketPath;
+  const vellumDir = join(resources.instanceDir, ".vellum");
   const gatewayPidFile = join(vellumDir, "gateway.pid");
 
   // Stop daemon
@@ -40,5 +60,4 @@ export async function sleep(): Promise<void> {
   } else {
     console.log("Gateway stopped.");
   }
-
 }

package/src/commands/use.ts

@@ -0,0 +1,44 @@
+import {
+  findAssistantByName,
+  getActiveAssistant,
+  setActiveAssistant,
+} from "../lib/assistant-config.js";
+
+export async function use(): Promise<void> {
+  const args = process.argv.slice(3);
+
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log("Usage: vellum use [<name>]");
+    console.log("");
+    console.log("Set the active assistant for commands.");
+    console.log("");
+    console.log("Arguments:");
+    console.log("  <name>    Name of the assistant to make active");
+    console.log("");
+    console.log(
+      "When called without a name, prints the current active assistant.",
+    );
+    process.exit(0);
+  }
+
+  const name = args.find((a) => !a.startsWith("-"));
+
+  if (!name) {
+    const active = getActiveAssistant();
+    if (active) {
+      console.log(`Active assistant: ${active}`);
+    } else {
+      console.log("No active assistant set.");
+    }
+    return;
+  }
+
+  const entry = findAssistantByName(name);
+  if (!entry) {
+    console.error(`No assistant found with name '${name}'.`);
+    process.exit(1);
+  }
+
+  setActiveAssistant(name);
+  console.log(`Active assistant set to '${name}'.`);
+}