@vellumai/cli 0.4.42 → 0.4.44

package/src/commands/client.ts

@@ -1,9 +1,12 @@
+import { hostname } from "os";
+
 import {
   findAssistantByName,
   getActiveAssistant,
   loadLatestAssistant,
 } from "../lib/assistant-config";
 import { GATEWAY_PORT, type Species } from "../lib/constants";
+import { getLocalLanIPv4, getMacLocalHostname } from "../lib/local";
 
 const ANSI = {
   reset: "\x1b[0m",
@@ -46,7 +49,7 @@ function parseArgs(): ParsedArgs {
     }
   }
 
-  let entry: ReturnType<typeof findAssistantByName>;
+  let entry: ReturnType<typeof findAssistantByName> = null;
   if (positionalName) {
     entry = findAssistantByName(positionalName);
     if (!entry) {
@@ -55,15 +58,30 @@ function parseArgs(): ParsedArgs {
       );
       process.exit(1);
     }
-  } else if (process.env.RUNTIME_URL) {
-    // Explicit env var — skip assistant resolution, will use env values below
-    entry = loadLatestAssistant();
   } else {
-    // Respect active assistant when set, otherwise fall back to latest
-    // for backward compatibility with remote-only setups.
+    const hasExplicitUrl =
+      process.env.RUNTIME_URL ||
+      flagArgs.includes("--url") ||
+      flagArgs.includes("-u");
     const active = getActiveAssistant();
-    const activeEntry = active ? findAssistantByName(active) : null;
-    entry = activeEntry ?? loadLatestAssistant();
+    if (active) {
+      entry = findAssistantByName(active);
+      if (!entry && !hasExplicitUrl) {
+        console.error(
+          `Active assistant '${active}' not found in lockfile. Set an active assistant with 'vellum use <name>'.`,
+        );
+        process.exit(1);
+      }
+    }
+    if (!entry && hasExplicitUrl) {
+      // URL provided but active assistant missing or unset — use latest for remaining defaults
+      entry = loadLatestAssistant();
+    } else if (!entry) {
+      console.error(
+        "No active assistant set. Set one with 'vellum use <name>' or specify a name: 'vellum client <name>'.",
+      );
+      process.exit(1);
+    }
   }
 
   let runtimeUrl =
@@ -90,7 +108,7 @@ function parseArgs(): ParsedArgs {
   }
 
   return {
-    runtimeUrl: runtimeUrl.replace(/\/+$/, ""),
+    runtimeUrl: maybeSwapToLocalhost(runtimeUrl.replace(/\/+$/, "")),
     assistantId,
     species,
     bearerToken,
@@ -99,6 +117,50 @@ function parseArgs(): ParsedArgs {
   };
 }
 
+/**
+ * If the hostname in `url` matches this machine's local DNS name, LAN IP, or
+ * raw hostname, replace it with 127.0.0.1 so the client avoids mDNS round-trips
+ * when talking to an assistant running on the same machine.
+ */
+function maybeSwapToLocalhost(url: string): string {
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return url;
+  }
+
+  const urlHost = parsed.hostname.toLowerCase();
+
+  const localNames: string[] = [];
+
+  const host = hostname();
+  if (host) {
+    localNames.push(host.toLowerCase());
+    // Also consider the bare name without .local suffix
+    if (host.toLowerCase().endsWith(".local")) {
+      localNames.push(host.toLowerCase().slice(0, -".local".length));
+    }
+  }
+
+  const macHost = getMacLocalHostname();
+  if (macHost) {
+    localNames.push(macHost.toLowerCase());
+  }
+
+  const lanIp = getLocalLanIPv4();
+  if (lanIp) {
+    localNames.push(lanIp);
+  }
+
+  if (localNames.includes(urlHost)) {
+    parsed.hostname = "127.0.0.1";
+    return parsed.toString().replace(/\/+$/, "");
+  }
+
+  return url;
+}
+
 function printUsage(): void {
   console.log(`${ANSI.bold}vellum client${ANSI.reset} - Connect to a hatched assistant
 
@@ -106,7 +168,7 @@ ${ANSI.bold}USAGE:${ANSI.reset}
     vellum client [name] [options]
 
 ${ANSI.bold}ARGUMENTS:${ANSI.reset}
-    [name]                     Instance name (default: latest)
+    [name]                     Instance name (default: active)
 
 ${ANSI.bold}OPTIONS:${ANSI.reset}
     -u, --url <url>            Runtime URL

package/src/commands/hatch.ts

@@ -22,10 +22,10 @@ import cliPkg from "../../package.json";
 import { buildOpenclawStartupScript } from "../adapters/openclaw";
 import {
   allocateLocalResources,
-  defaultLocalResources,
   findAssistantByName,
   loadAllAssistants,
   saveAssistantEntry,
+  setActiveAssistant,
   syncConfigToLockfile,
 } from "../lib/assistant-config";
 import type {
@@ -39,6 +39,7 @@ import {
   VALID_SPECIES,
 } from "../lib/constants";
 import type { RemoteHost, Species } from "../lib/constants";
+import { hatchDocker } from "../lib/docker";
 import { hatchGcp } from "../lib/gcp";
 import type { PollResult, WatchHatchingResult } from "../lib/gcp";
 import {
@@ -49,6 +50,7 @@ import {
 import { isProcessAlive } from "../lib/process";
 import { generateRandomSuffix } from "../lib/random-name";
 import { validateAssistantName } from "../lib/retire-archive";
+import { archiveLogFile, resetLogFile } from "../lib/xdg-log";
 
 export type { PollResult, WatchHatchingResult } from "../lib/gcp";
 
@@ -169,6 +171,7 @@ const DEFAULT_REMOTE: RemoteHost = "local";
 interface HatchArgs {
   species: Species;
   detached: boolean;
+  keepAlive: boolean;
   name: string | null;
   remote: RemoteHost;
   daemonOnly: boolean;
@@ -180,6 +183,7 @@ function parseArgs(): HatchArgs {
   const args = process.argv.slice(3);
   let species: Species = DEFAULT_SPECIES;
   let detached = false;
+  let keepAlive = false;
   let name: string | null = null;
   let remote: RemoteHost = DEFAULT_REMOTE;
   let daemonOnly = false;
@@ -212,6 +216,9 @@ function parseArgs(): HatchArgs {
       console.log(
         "  --watch                   Run assistant and gateway in watch mode (hot reload on source changes)",
       );
+      console.log(
+        "  --keep-alive              Stay alive after hatch, exit when gateway stops",
+      );
       process.exit(0);
     } else if (arg === "-d") {
       detached = true;
@@ -221,6 +228,8 @@ function parseArgs(): HatchArgs {
       restart = true;
     } else if (arg === "--watch") {
       watch = true;
+    } else if (arg === "--keep-alive") {
+      keepAlive = true;
     } else if (arg === "--name") {
       const next = args[i + 1];
       if (!next || next.startsWith("-")) {
@@ -251,13 +260,13 @@ function parseArgs(): HatchArgs {
       species = arg as Species;
     } else {
       console.error(
-        `Error: Unknown argument '${arg}'. Valid options: ${VALID_SPECIES.join(", ")}, -d, --daemon-only, --restart, --watch, --name <name>, --remote <${VALID_REMOTE_HOSTS.join("|")}>`,
+        `Error: Unknown argument '${arg}'. Valid options: ${VALID_SPECIES.join(", ")}, -d, --daemon-only, --restart, --watch, --keep-alive, --name <name>, --remote <${VALID_REMOTE_HOSTS.join("|")}>`,
       );
       process.exit(1);
     }
   }
 
-  return { species, detached, name, remote, daemonOnly, restart, watch };
+  return { species, detached, keepAlive, name, remote, daemonOnly, restart, watch };
 }
 
 function formatElapsed(ms: number): string {
@@ -682,6 +691,7 @@ async function hatchLocal(
   daemonOnly: boolean = false,
   restart: boolean = false,
   watch: boolean = false,
+  keepAlive: boolean = false,
 ): Promise<void> {
   if (restart && !name && !process.env.VELLUM_ASSISTANT_NAME) {
     console.error(
@@ -717,14 +727,13 @@ async function hatchLocal(
   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(resources.instanceDir, ".vellum");
+  const logsDir = join(resources.instanceDir, ".vellum", "workspace", "data", "logs");
+  archiveLogFile("hatch.log", logsDir);
+  resetLogFile("hatch.log");
 
   console.log(`🥚 Hatching local assistant: ${instanceName}`);
   console.log(`   Species: ${species}`);
@@ -761,7 +770,6 @@ async function hatchLocal(
     assistantId: instanceName,
     runtimeUrl,
     localUrl: `http://127.0.0.1:${resources.gatewayPort}`,
-    baseDataDir,
     bearerToken,
     cloud: "local",
     species,
@@ -770,6 +778,7 @@ async function hatchLocal(
   };
   if (!daemonOnly && !restart) {
     saveAssistantEntry(localEntry);
+    setActiveAssistant(instanceName);
     syncConfigToLockfile();
 
     if (process.env.VELLUM_DESKTOP_APP) {
@@ -790,6 +799,46 @@ async function hatchLocal(
     const localGatewayUrl = `http://127.0.0.1:${resources.gatewayPort}`;
     await displayPairingQRCode(localGatewayUrl, bearerToken, runtimeUrl);
   }
+
+  if (keepAlive) {
+    const gatewayHealthUrl = `http://127.0.0.1:${resources.gatewayPort}/healthz`;
+    const POLL_INTERVAL_MS = 5000;
+    const MAX_FAILURES = 3;
+    let consecutiveFailures = 0;
+
+    const shutdown = async (): Promise<void> => {
+      console.log("\nShutting down local processes...");
+      await stopLocalProcesses(resources);
+      process.exit(0);
+    };
+
+    process.on("SIGTERM", () => void shutdown());
+    process.on("SIGINT", () => void shutdown());
+
+    // Poll the gateway health endpoint until it stops responding.
+    while (true) {
+      await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+      try {
+        const res = await fetch(gatewayHealthUrl, {
+          signal: AbortSignal.timeout(3000),
+        });
+        if (res.ok) {
+          consecutiveFailures = 0;
+        } else {
+          consecutiveFailures++;
+        }
+      } catch {
+        consecutiveFailures++;
+      }
+      if (consecutiveFailures >= MAX_FAILURES) {
+        console.log(
+          "\n⚠️  Gateway stopped responding — shutting down.",
+        );
+        await stopLocalProcesses(resources);
+        process.exit(1);
+      }
+    }
+  }
 }
 
 function getCliVersion(): string {
@@ -800,7 +849,7 @@ export async function hatch(): Promise<void> {
   const cliVersion = getCliVersion();
   console.log(`@vellumai/cli v${cliVersion}`);
 
-  const { species, detached, name, remote, daemonOnly, restart, watch } =
+  const { species, detached, keepAlive, name, remote, daemonOnly, restart, watch } =
     parseArgs();
 
   if (restart && remote !== "local") {
@@ -810,13 +859,15 @@ export async function hatch(): Promise<void> {
     process.exit(1);
   }
 
-  if (watch && remote !== "local") {
-    console.error("Error: --watch is only supported for local hatch targets.");
+  if (watch && remote !== "local" && remote !== "docker") {
+    console.error(
+      "Error: --watch is only supported for local and docker hatch targets.",
+    );
     process.exit(1);
   }
 
   if (remote === "local") {
-    await hatchLocal(species, name, daemonOnly, restart, watch);
+    await hatchLocal(species, name, daemonOnly, restart, watch, keepAlive);
     return;
   }
 
@@ -831,8 +882,8 @@ export async function hatch(): Promise<void> {
   }
 
   if (remote === "docker") {
-    console.error("Error: Docker remote host is not yet implemented.");
-    process.exit(1);
+    await hatchDocker(species, detached, name, watch);
+    return;
   }
 
   console.error(`Error: Remote host '${remote}' is not yet supported.`);

package/src/commands/ps.ts

@@ -3,7 +3,6 @@ import { homedir } from "os";
 import { join } from "path";
 
 import {
-  defaultLocalResources,
   findAssistantByName,
   getActiveAssistant,
   loadAllAssistants,
@@ -178,45 +177,65 @@ interface DetectedProcess {
   pid: string | null;
   port: number;
   running: boolean;
+  watch: boolean;
+}
+
+async function isWatchMode(pid: string): Promise<boolean> {
+  try {
+    const args = await execOutput("ps", ["-p", pid, "-o", "args="]);
+    return args.includes("--watch");
+  } catch {
+    return false;
+  }
 }
 
 async function detectProcess(spec: ProcessSpec): Promise<DetectedProcess> {
   // Tier 1: pgrep by process title
   const pids = await pgrepExact(spec.pgrepName);
   if (pids.length > 0) {
-    return { name: spec.name, pid: pids[0], port: spec.port, running: true };
+    const watch = await isWatchMode(pids[0]);
+    return { name: spec.name, pid: pids[0], port: spec.port, running: true, watch };
   }
 
   // Tier 2: TCP port probe (skip for processes without a port)
   const listening = spec.port > 0 && (await probePort(spec.port));
   if (listening) {
     const filePid = readPidFile(spec.pidFile);
+    const watch = filePid ? await isWatchMode(filePid) : false;
     return {
       name: spec.name,
       pid: filePid,
       port: spec.port,
       running: true,
+      watch,
     };
   }
 
   // Tier 3: PID file fallback
   const filePid = readPidFile(spec.pidFile);
   if (filePid && isProcessAlive(filePid)) {
-    return { name: spec.name, pid: filePid, port: spec.port, running: true };
+    const watch = await isWatchMode(filePid);
+    return { name: spec.name, pid: filePid, port: spec.port, running: true, watch };
   }
 
-  return { name: spec.name, pid: null, port: spec.port, running: false };
+  return { name: spec.name, pid: null, port: spec.port, running: false, watch: false };
 }
 
 function formatDetectionInfo(proc: DetectedProcess): string {
   const parts: string[] = [];
   if (proc.pid) parts.push(`PID ${proc.pid}`);
   if (proc.port > 0) parts.push(`port ${proc.port}`);
+  if (proc.watch) parts.push("watch");
   return parts.join(" | ");
 }
 
 async function getLocalProcesses(entry: AssistantEntry): Promise<TableRow[]> {
-  const resources = entry.resources ?? defaultLocalResources();
+  if (!entry.resources) {
+    throw new Error(
+      `Local assistant '${entry.assistantId}' is missing resource configuration. Re-hatch to fix.`,
+    );
+  }
+  const resources = entry.resources;
   const vellumDir = join(resources.instanceDir, ".vellum");
 
   const specs: ProcessSpec[] = [
@@ -409,9 +428,7 @@ async function listAllAssistants(): Promise<void> {
       // 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);
+      const resources = a.resources;
       if (a.cloud === "local" && resources) {
         const pid = readPidFile(resources.pidFile);
         const alive = pid !== null && isProcessAlive(pid);

package/src/commands/recover.ts

@@ -37,7 +37,17 @@ export async function recover(): Promise<void> {
     process.exit(1);
   }
 
-  // 2. Check ~/.vellum doesn't already exist
+  // 2. Read and validate metadata before any side effects
+  const entry: AssistantEntry = JSON.parse(readFileSync(metadataPath, "utf-8"));
+  if (!entry.resources) {
+    throw new Error(
+      `Retired assistant '${name}' is missing resource configuration. ` +
+        `Fix the archive metadata at ${metadataPath} and retry, ` +
+        `or run 'vellum hatch' to re-provision with proper resource allocation.`,
+    );
+  }
+
+  // 3. Check ~/.vellum doesn't already exist
   const vellumDir = join(homedir(), ".vellum");
   if (existsSync(vellumDir)) {
     console.error(
@@ -46,21 +56,20 @@ export async function recover(): Promise<void> {
     process.exit(1);
   }
 
-  // 3. Extract archive
+  // 4. Extract archive
   await exec("tar", ["xzf", archivePath, "-C", homedir()]);
 
-  // 4. Restore lockfile entry
-  const entry: AssistantEntry = JSON.parse(readFileSync(metadataPath, "utf-8"));
+  // 5. Restore lockfile entry
   saveAssistantEntry(entry);
 
-  // 5. Clean up archive
+  // 6. Clean up archive
   unlinkSync(archivePath);
   unlinkSync(metadataPath);
 
-  // 6. Start daemon + gateway (same as wake)
-  await startLocalDaemon();
+  // 7. Start daemon + gateway (same as wake)
+  await startLocalDaemon(false, entry.resources);
   if (!process.env.VELLUM_DESKTOP_APP) {
-    await startGateway();
+    await startGateway(undefined, false, entry.resources);
   }
 
   console.log(`✅ Recovered assistant '${name}'.`);

package/src/commands/retire.ts

@@ -4,13 +4,13 @@ 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";
 import { retireInstance as retireAwsInstance } from "../lib/aws";
+import { retireDocker } from "../lib/docker";
 import { retireInstance as retireGcpInstance } from "../lib/gcp";
 import {
   stopOrphanedDaemonProcesses,
@@ -45,22 +45,20 @@ function extractHostFromUrl(url: string): string {
 async function retireLocal(name: string, entry: AssistantEntry): Promise<void> {
   console.log("\u{1F5D1}\ufe0f  Stopping local assistant...\n");
 
-  // 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");
+  if (!entry.resources) {
+    throw new Error(
+      `Local assistant '${name}' is missing resource configuration. Re-hatch to fix.`,
+    );
+  }
+  const resources = entry.resources;
+  const vellumDir = 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");
+    if (!other.resources) return false;
+    const otherVellumDir = join(other.resources.instanceDir, ".vellum");
     return otherVellumDir === vellumDir;
   });
 
@@ -72,17 +70,8 @@ async function retireLocal(name: string, entry: AssistantEntry): Promise<void> {
     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,
-  ]);
+  const daemonPidFile = resources.pidFile;
+  const daemonStopped = await stopProcessByPidFile(daemonPidFile, "daemon");
 
   // Stop gateway via PID file — use a longer timeout because the gateway has a
   // configurable drain window (GATEWAY_SHUTDOWN_DRAIN_MS, default 5s) before it exits.
@@ -286,6 +275,8 @@ async function retireInner(): Promise<void> {
       process.exit(1);
     }
     await retireAwsInstance(name, region, source);
+  } else if (cloud === "docker") {
+    await retireDocker(name);
   } else if (cloud === "local") {
     await retireLocal(name, entry);
   } else if (cloud === "custom") {

package/src/commands/sleep.ts

@@ -1,15 +1,50 @@
+import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 
-import {
-  defaultLocalResources,
-  resolveTargetAssistant,
-} from "../lib/assistant-config.js";
-import { stopProcessByPidFile } from "../lib/process";
+import { resolveTargetAssistant } from "../lib/assistant-config.js";
+import type { AssistantEntry } from "../lib/assistant-config.js";
+import { isProcessAlive, stopProcessByPidFile } from "../lib/process";
+
+const ACTIVE_CALL_LEASES_FILE = "active-call-leases.json";
+
+type ActiveCallLease = {
+  callSessionId: string;
+};
+
+function getAssistantRootDir(entry: AssistantEntry): string {
+  if (!entry.resources) {
+    throw new Error(
+      `Local assistant '${entry.assistantId}' is missing resource configuration. Re-hatch to fix.`,
+    );
+  }
+  return join(entry.resources.instanceDir, ".vellum");
+}
+
+function readActiveCallLeases(vellumDir: string): ActiveCallLease[] {
+  const path = join(vellumDir, ACTIVE_CALL_LEASES_FILE);
+  if (!existsSync(path)) {
+    return [];
+  }
+
+  const raw = JSON.parse(readFileSync(path, "utf-8")) as {
+    version?: number;
+    leases?: Array<{ callSessionId?: unknown }>;
+  };
+  if (raw.version !== 1 || !Array.isArray(raw.leases)) {
+    throw new Error(`Invalid active call lease file at ${path}`);
+  }
+
+  return raw.leases.filter(
+    (lease): lease is ActiveCallLease =>
+      typeof lease?.callSessionId === "string" &&
+      lease.callSessionId.length > 0,
+  );
+}
 
 export async function sleep(): Promise<void> {
   const args = process.argv.slice(3);
   if (args.includes("--help") || args.includes("-h")) {
-    console.log("Usage: vellum sleep [<name>]");
+    console.log("Usage: vellum sleep [<name>] [--force]");
     console.log("");
     console.log("Stop the assistant and gateway processes.");
     console.log("");
@@ -17,9 +52,15 @@ export async function sleep(): Promise<void> {
     console.log(
       "  <name>    Name of the assistant to stop (default: active or only local)",
     );
+    console.log("");
+    console.log("Options:");
+    console.log(
+      "  --force   Stop the assistant even if a phone call keepalive lease is active",
+    );
     process.exit(0);
   }
 
+  const force = args.includes("--force");
   const nameArg = args.find((a) => !a.startsWith("-"));
   const entry = resolveTargetAssistant(nameArg);
 
@@ -30,18 +71,49 @@ export async function sleep(): Promise<void> {
     process.exit(1);
   }
 
-  const resources = entry.resources ?? defaultLocalResources();
-
-  const daemonPidFile = resources.pidFile;
-  const socketFile = resources.socketPath;
-  const vellumDir = join(resources.instanceDir, ".vellum");
+  if (!entry.resources) {
+    console.error(
+      `Error: Local assistant '${entry.assistantId}' is missing resource configuration. Re-hatch to fix.`,
+    );
+    process.exit(1);
+  }
+  const resources = entry.resources;
+  const assistantPidFile = resources.pidFile;
+  const vellumDir = getAssistantRootDir(entry);
   const gatewayPidFile = join(vellumDir, "gateway.pid");
 
-  // Stop daemon
-  const daemonStopped = await stopProcessByPidFile(daemonPidFile, "daemon", [
-    socketFile,
-  ]);
-  if (!daemonStopped) {
+  if (!force) {
+    const assistantAlive = isProcessAlive(assistantPidFile).alive;
+    if (assistantAlive) {
+      try {
+        const activeCallLeases = readActiveCallLeases(vellumDir);
+        if (activeCallLeases.length > 0) {
+          const activeIds = activeCallLeases.map(
+            (lease) => lease.callSessionId,
+          );
+          console.error(
+            `Error: assistant is staying awake for active phone calls (${activeIds.join(
+              ", ",
+            )}). Use 'vellum sleep --force' to stop it anyway.`,
+          );
+          process.exit(1);
+        }
+      } catch (err) {
+        console.error(
+          `Error: ${
+            err instanceof Error ? err.message : String(err)
+          }. Use 'vellum sleep --force' to override if you want to stop the assistant anyway.`,
+        );
+        process.exit(1);
+      }
+    }
+  }
+
+  const assistantStopped = await stopProcessByPidFile(
+    assistantPidFile,
+    "assistant",
+  );
+  if (!assistantStopped) {
     console.log("Assistant is not running.");
   } else {
     console.log("Assistant stopped.");