@vellumai/assistant 0.4.26 → 0.4.30

package/src/cli/core-commands.ts

@@ -1,39 +1,50 @@
-import { spawn } from 'node:child_process';
-import { execSync } from 'node:child_process';
-import { existsSync, readFileSync,statSync } from 'node:fs';
-import * as net from 'node:net';
-import { join } from 'node:path';
-
-import type { Command } from 'commander';
-
-import { startCli } from '../cli.js';
-import { getQdrantUrlEnv } from '../config/env.js';
-import { loadRawConfig } from '../config/loader.js';
-import { getConfig } from '../config/loader.js';
-import { hasSocketOverride,shouldAutoStartDaemon } from '../daemon/connection-policy.js';
+import { spawn } from "node:child_process";
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import * as net from "node:net";
+import { join } from "node:path";
+
+import type { Command } from "commander";
+
+import { startCli } from "../cli.js";
+import { getQdrantUrlEnv } from "../config/env.js";
+import { loadRawConfig } from "../config/loader.js";
+import { getConfig } from "../config/loader.js";
+import {
+  hasSocketOverride,
+  shouldAutoStartDaemon,
+} from "../daemon/connection-policy.js";
 import {
   ensureDaemonRunning,
   getDaemonStatus,
-  startDaemon,
   stopDaemon,
-} from '../daemon/lifecycle.js';
-import { formatJson,formatMarkdown } from '../export/formatter.js';
+} from "../daemon/lifecycle.js";
+import { formatJson, formatMarkdown } from "../export/formatter.js";
 import {
   clearAll as clearAllConversations,
   getConversation,
   getMessages,
   listConversations,
-} from '../memory/conversation-store.js';
-import { initializeDb } from '../memory/db.js';
-import { initQdrantClient } from '../memory/qdrant-client.js';
-import { getRecentInvocations } from '../memory/tool-usage-store.js';
-import { IpcError } from '../util/errors.js';
-import { getCliLogger } from '../util/logger.js';
-import { getDataDir, getDbPath, getLogPath, getRootDir, getSocketPath, getWorkspaceDir, getWorkspaceHooksDir,getWorkspaceSkillsDir } from '../util/platform.js';
-import { timeAgo } from '../util/time.js';
-import { sendOneMessage } from './ipc-client.js';
-
-const log = getCliLogger('cli');
+} from "../memory/conversation-store.js";
+import { initializeDb } from "../memory/db.js";
+import { initQdrantClient } from "../memory/qdrant-client.js";
+import { getRecentInvocations } from "../memory/tool-usage-store.js";
+import { IpcError } from "../util/errors.js";
+import { getCliLogger } from "../util/logger.js";
+import {
+  getDataDir,
+  getDbPath,
+  getLogPath,
+  getRootDir,
+  getSocketPath,
+  getWorkspaceDir,
+  getWorkspaceHooksDir,
+  getWorkspaceSkillsDir,
+} from "../util/platform.js";
+import { timeAgo } from "../util/time.js";
+import { sendOneMessage } from "./ipc-client.js";
+
+const log = getCliLogger("cli");
 
 export function registerDefaultAction(program: Command): void {
   program.action(async () => {
@@ -44,85 +55,32 @@ export function registerDefaultAction(program: Command): void {
   });
 }
 
-export function registerDaemonCommand(program: Command): void {
-  const daemon = program.command('daemon').description('Manage the daemon process');
-
-  daemon
-    .command('start')
-    .description('Start the daemon')
-    .action(async () => {
-      const result = await startDaemon();
-      if (result.alreadyRunning) {
-        log.info(`Daemon already running (pid ${result.pid})`);
-      } else {
-        log.info(`Daemon started (pid ${result.pid})`);
-      }
-    });
-
-  daemon
-    .command('stop')
-    .description('Stop the daemon')
-    .action(async () => {
-      const result = await stopDaemon();
-      if (result.stopped) {
-        log.info('Daemon stopped');
-      } else if (result.reason === 'stop_failed') {
-        log.error('Failed to stop daemon — process survived SIGKILL');
-        process.exit(1);
-      } else {
-        log.info('Daemon is not running');
-      }
-    });
-
-  daemon
-    .command('restart')
-    .description('Restart the daemon')
-    .action(async () => {
-      const stopResult = await stopDaemon();
-      if (stopResult.stopped) {
-        log.info('Daemon stopped');
-      } else if (stopResult.reason === 'stop_failed') {
-        log.error('Failed to stop daemon — process survived SIGKILL, cannot restart');
-        process.exit(1);
-      }
-      const startResult = await startDaemon();
-      log.info(`Daemon started (pid ${startResult.pid})`);
-    });
-
-  daemon
-    .command('status')
-    .description('Show daemon status')
-    .action(async () => {
-      const status = await getDaemonStatus();
-      if (status.running) {
-        log.info(`Daemon is running (pid ${status.pid})`);
-      } else {
-        log.info('Daemon is not running');
-      }
-      log.info(`Socket path: ${getSocketPath()}${hasSocketOverride() ? ' (override)' : ''}`);
-      log.info(`Autostart: ${shouldAutoStartDaemon() ? 'enabled' : 'disabled'}`);
-    });
-}
-
 export function registerDevCommand(program: Command): void {
   program
-    .command('dev')
-    .description('Run the daemon in dev mode')
-    .option('--watch', 'Auto-restart on source file changes (disruptive during Claude Code sessions)')
+    .command("dev")
+    .description("Run the daemon in dev mode")
+    .option(
+      "--watch",
+      "Auto-restart on source file changes (disruptive during Claude Code sessions)",
+    )
     .action(async (opts: { watch?: boolean }) => {
       let status = await getDaemonStatus();
       if (status.running) {
-        log.info('Stopping existing daemon...');
+        log.info("Stopping existing daemon...");
         const stopResult = await stopDaemon();
-        if (!stopResult.stopped && stopResult.reason === 'stop_failed') {
-          log.error('Failed to stop existing daemon — process survived SIGKILL');
+        if (!stopResult.stopped && stopResult.reason === "stop_failed") {
+          log.error(
+            "Failed to stop existing daemon — process survived SIGKILL",
+          );
           process.exit(1);
         }
       } else if (status.pid) {
         // PID file references a live process but the socket is unresponsive.
         // This can happen during the daemon startup window before the socket
         // is bound. Wait briefly for it to come up before replacing.
-        log.info('Daemon process alive but socket unresponsive — waiting for startup...');
+        log.info(
+          "Daemon process alive but socket unresponsive — waiting for startup...",
+        );
         const maxWait = 5000;
         const interval = 500;
         let waited = 0;
@@ -133,10 +91,12 @@ export function registerDevCommand(program: Command): void {
           status = await getDaemonStatus();
           if (status.running) {
             // Socket came up — stop the daemon normally.
-            log.info('Daemon became responsive, stopping it...');
+            log.info("Daemon became responsive, stopping it...");
             const stopResult = await stopDaemon();
-            if (!stopResult.stopped && stopResult.reason === 'stop_failed') {
-              log.error('Failed to stop existing daemon — process survived SIGKILL');
+            if (!stopResult.stopped && stopResult.reason === "stop_failed") {
+              log.error(
+                "Failed to stop existing daemon — process survived SIGKILL",
+              );
               process.exit(1);
             }
             resolved = true;
@@ -151,10 +111,12 @@ export function registerDevCommand(program: Command): void {
         if (!resolved) {
           // Still alive but unresponsive after waiting — stop it via stopDaemon()
           // which handles SIGTERM → SIGKILL escalation and PID file cleanup.
-          log.info('Daemon still unresponsive after wait — stopping it...');
+          log.info("Daemon still unresponsive after wait — stopping it...");
           const stopResult = await stopDaemon();
-          if (!stopResult.stopped && stopResult.reason === 'stop_failed') {
-            log.error('Failed to stop existing daemon — process survived SIGKILL');
+          if (!stopResult.stopped && stopResult.reason === "stop_failed") {
+            log.error(
+              "Failed to stop existing daemon — process survived SIGKILL",
+            );
             process.exit(1);
           }
         }
@@ -163,154 +125,173 @@ export function registerDevCommand(program: Command): void {
       const mainPath = `${import.meta.dirname}/../daemon/main.ts`;
 
       const useWatch = opts.watch === true;
-      log.info(`Starting daemon in dev mode${useWatch ? ' with file watching' : ''} (Ctrl+C to stop)`);
+      log.info(
+        `Starting daemon in dev mode${
+          useWatch ? " with file watching" : ""
+        } (Ctrl+C to stop)`,
+      );
 
-      const repoRoot = join(import.meta.dirname, '..', '..', '..');
-      const args = useWatch ? ['--watch', 'run', mainPath] : ['run', mainPath];
-      const child = spawn('bun', args, {
-        stdio: 'inherit',
+      const repoRoot = join(import.meta.dirname, "..", "..", "..");
+      const args = useWatch ? ["--watch", "run", mainPath] : ["run", mainPath];
+      const child = spawn("bun", args, {
+        stdio: "inherit",
         env: {
           ...process.env,
           BASE_DATA_DIR: repoRoot,
-          VELLUM_LOG_STDERR: '1',
-          VELLUM_DEBUG: '1',
+          VELLUM_LOG_STDERR: "1",
+          VELLUM_DEBUG: "1",
         },
       });
 
       const forward = (signal: NodeJS.Signals) => {
         child.kill(signal);
       };
-      process.on('SIGINT', () => forward('SIGINT'));
-      process.on('SIGTERM', () => forward('SIGTERM'));
+      process.on("SIGINT", () => forward("SIGINT"));
+      process.on("SIGTERM", () => forward("SIGTERM"));
 
-      child.on('exit', (code) => {
+      child.on("exit", (code) => {
         process.exit(code ?? 0);
       });
     });
 }
 
 export function registerSessionsCommand(program: Command): void {
-  const sessions = program.command('sessions').description('Manage sessions');
+  const sessions = program.command("sessions").description("Manage sessions");
 
   sessions
-    .command('list')
-    .description('List all sessions')
+    .command("list")
+    .description("List all sessions")
     .action(async () => {
       if (shouldAutoStartDaemon()) await ensureDaemonRunning();
-      const response = await sendOneMessage({ type: 'session_list' });
-      if (response.type === 'session_list_response') {
+      const response = await sendOneMessage({ type: "session_list" });
+      if (response.type === "session_list_response") {
         if (response.sessions.length === 0) {
-          log.info('No sessions');
+          log.info("No sessions");
         } else {
           for (const s of response.sessions) {
             log.info(`  ${s.id}  ${s.title}  ${timeAgo(s.updatedAt)}`);
           }
         }
-      } else if (response.type === 'error') {
+      } else if (response.type === "error") {
         log.error(`Error: ${response.message}`);
       }
     });
 
   sessions
-    .command('new [title]')
-    .description('Create a new session')
+    .command("new [title]")
+    .description("Create a new session")
     .action(async (title?: string) => {
       if (shouldAutoStartDaemon()) await ensureDaemonRunning();
       const response = await sendOneMessage({
-        type: 'session_create',
+        type: "session_create",
         title,
       });
-      if (response.type === 'session_info') {
+      if (response.type === "session_info") {
         log.info(`Created session: ${response.title} (${response.sessionId})`);
-      } else if (response.type === 'error') {
+      } else if (response.type === "error") {
         log.error(`Error: ${response.message}`);
       }
     });
 
   sessions
-    .command('export [sessionId]')
-    .description('Export a conversation as markdown or JSON')
-    .option('-f, --format <format>', 'Output format: md or json', 'md')
-    .option('-o, --output <file>', 'Write to file instead of stdout')
-    .action(async (sessionId?: string, opts?: { format: string; output?: string }) => {
-      initializeDb();
-      const format = opts?.format ?? 'md';
-      if (format !== 'md' && format !== 'json') {
-        log.error('Error: format must be "md" or "json"');
-        process.exit(1);
-      }
-
-      let id = sessionId;
-      if (!id) {
-        const all = listConversations(1);
-        if (all.length === 0) {
-          log.error('No sessions found');
+    .command("export [sessionId]")
+    .description("Export a conversation as markdown or JSON")
+    .option("-f, --format <format>", "Output format: md or json", "md")
+    .option("-o, --output <file>", "Write to file instead of stdout")
+    .action(
+      async (
+        sessionId?: string,
+        opts?: { format: string; output?: string },
+      ) => {
+        initializeDb();
+        const format = opts?.format ?? "md";
+        if (format !== "md" && format !== "json") {
+          log.error('Error: format must be "md" or "json"');
           process.exit(1);
         }
-        id = all[0].id;
-      }
 
-      // Support prefix matching for session IDs
-      let conversation = getConversation(id);
-      if (!conversation) {
-        const all = listConversations(Number.MAX_SAFE_INTEGER);
-        const match = all.find((c) => c.id.startsWith(id!));
-        if (match) {
-          conversation = match;
-        } else {
-          log.error(`Session not found: ${id}`);
-          process.exit(1);
+        let id = sessionId;
+        if (!id) {
+          const all = listConversations(1);
+          if (all.length === 0) {
+            log.error("No sessions found");
+            process.exit(1);
+          }
+          id = all[0].id;
         }
-      }
-
-      const msgs = getMessages(conversation.id);
-      const exportData = {
-        ...conversation,
-        messages: msgs.map((m) => ({
-          role: m.role,
-          content: JSON.parse(m.content),
-          createdAt: m.createdAt,
-        })),
-      };
 
-      const output = format === 'json'
-        ? formatJson(exportData)
-        : formatMarkdown(exportData);
+        // Support prefix matching for session IDs
+        let conversation = getConversation(id);
+        if (!conversation) {
+          const all = listConversations(Number.MAX_SAFE_INTEGER);
+          const match = all.find((c) => c.id.startsWith(id!));
+          if (match) {
+            conversation = match;
+          } else {
+            log.error(`Session not found: ${id}`);
+            process.exit(1);
+          }
+        }
 
-      if (opts?.output) {
-        const { writeFileSync } = await import('node:fs');
-        writeFileSync(opts.output, output);
-        log.info(`Exported to ${opts.output}`);
-      } else {
-        process.stdout.write(output);
-      }
-    });
+        const msgs = getMessages(conversation.id);
+        const exportData = {
+          ...conversation,
+          messages: msgs.map((m) => ({
+            role: m.role,
+            content: JSON.parse(m.content),
+            createdAt: m.createdAt,
+          })),
+        };
+
+        const output =
+          format === "json"
+            ? formatJson(exportData)
+            : formatMarkdown(exportData);
+
+        if (opts?.output) {
+          const { writeFileSync } = await import("node:fs");
+          writeFileSync(opts.output, output);
+          log.info(`Exported to ${opts.output}`);
+        } else {
+          process.stdout.write(output);
+        }
+      },
+    );
 
   sessions
-    .command('clear')
-    .description('Clear all conversations, messages, and vector data (dev only)')
+    .command("clear")
+    .description(
+      "Clear all conversations, messages, and vector data (dev only)",
+    )
     .action(async () => {
-      log.info('This will permanently delete all conversations, messages, and vector data.');
+      log.info(
+        "This will permanently delete all conversations, messages, and vector data.",
+      );
 
-      const readline = await import('node:readline');
-      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const readline = await import("node:readline");
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
       const answer = await new Promise<string>((resolve) => {
-        rl.question('Are you sure? (y/N) ', resolve);
+        rl.question("Are you sure? (y/N) ", resolve);
       });
       rl.close();
-      if (answer.toLowerCase() !== 'y') {
-        log.info('Cancelled');
+      if (answer.toLowerCase() !== "y") {
+        log.info("Cancelled");
         return;
       }
 
       initializeDb();
       const result = clearAllConversations();
-      log.info(`Cleared ${result.conversations} conversations, ${result.messages} messages`);
+      log.info(
+        `Cleared ${result.conversations} conversations, ${result.messages} messages`,
+      );
 
       // Notify a running daemon to drop its in-memory sessions so it
       // doesn't keep serving stale history from deleted conversation rows.
       try {
-        await sendOneMessage({ type: 'sessions_clear' });
+        await sendOneMessage({ type: "sessions_clear" });
       } catch {
         // Daemon may not be running — that's fine, no sessions to invalidate.
       }
@@ -326,25 +307,27 @@ export function registerSessionsCommand(program: Command): void {
       });
       const deleted = await qdrant.deleteCollection();
       if (deleted) {
-        log.info(`Deleted Qdrant collection "${config.memory.qdrant.collection}"`);
+        log.info(
+          `Deleted Qdrant collection "${config.memory.qdrant.collection}"`,
+        );
       } else {
-        log.info('Qdrant collection not found or not reachable (skipped)');
+        log.info("Qdrant collection not found or not reachable (skipped)");
       }
 
-      log.info('Done.');
+      log.info("Done.");
     });
 }
 
 export function registerAuditCommand(program: Command): void {
   program
-    .command('audit')
-    .description('Show recent tool invocations')
-    .option('-l, --limit <n>', 'Number of entries to show', '20')
+    .command("audit")
+    .description("Show recent tool invocations")
+    .option("-l, --limit <n>", "Number of entries to show", "20")
     .action((opts: { limit: string }) => {
       const limit = parseInt(opts.limit, 10) || 20;
       const rows = getRecentInvocations(limit);
       if (rows.length === 0) {
-        log.info('No tool invocations recorded');
+        log.info("No tool invocations recorded");
         return;
       }
       const tsW = 20;
@@ -354,17 +337,20 @@ export function registerAuditCommand(program: Command): void {
       const riskW = 8;
       const durW = 8;
       log.info(
-        'Timestamp'.padEnd(tsW) +
-        'Tool'.padEnd(toolW) +
-        'Input'.padEnd(inputW) +
-        'Decision'.padEnd(decW) +
-        'Risk'.padEnd(riskW) +
-        'Duration',
+        "Timestamp".padEnd(tsW) +
+          "Tool".padEnd(toolW) +
+          "Input".padEnd(inputW) +
+          "Decision".padEnd(decW) +
+          "Risk".padEnd(riskW) +
+          "Duration",
       );
-      log.info('-'.repeat(tsW + toolW + inputW + decW + riskW + durW));
+      log.info("-".repeat(tsW + toolW + inputW + decW + riskW + durW));
       for (const r of rows) {
-        const ts = new Date(r.createdAt).toISOString().slice(0, 19).replace('T', ' ');
-        let inputSummary = '';
+        const ts = new Date(r.createdAt)
+          .toISOString()
+          .slice(0, 19)
+          .replace("T", " ");
+        let inputSummary = "";
         try {
           const parsed = JSON.parse(r.input);
           if (parsed.command) inputSummary = parsed.command;
@@ -374,16 +360,19 @@ export function registerAuditCommand(program: Command): void {
           inputSummary = r.input;
         }
         if (inputSummary.length > inputW - 2) {
-          inputSummary = inputSummary.slice(0, inputW - 4) + '..';
+          inputSummary = inputSummary.slice(0, inputW - 4) + "..";
         }
-        const dur = r.durationMs < 1000 ? `${r.durationMs}ms` : `${(r.durationMs / 1000).toFixed(1)}s`;
+        const dur =
+          r.durationMs < 1000
+            ? `${r.durationMs}ms`
+            : `${(r.durationMs / 1000).toFixed(1)}s`;
         log.info(
           ts.padEnd(tsW) +
-          r.toolName.padEnd(toolW) +
-          inputSummary.padEnd(inputW) +
-          r.decision.padEnd(decW) +
-          r.riskLevel.padEnd(riskW) +
-          dur,
+            r.toolName.padEnd(toolW) +
+            inputSummary.padEnd(inputW) +
+            r.decision.padEnd(decW) +
+            r.riskLevel.padEnd(riskW) +
+            dur,
         );
       }
     });
@@ -391,52 +380,59 @@ export function registerAuditCommand(program: Command): void {
 
 export function registerDoctorCommand(program: Command): void {
   program
-    .command('doctor')
-    .description('Run diagnostic checks')
+    .command("doctor")
+    .description("Run diagnostic checks")
     .action(async () => {
       const pass = (label: string) => log.info(`  \u2713 ${label}`);
       const fail = (label: string, detail?: string) =>
-        log.info(`  \u2717 ${label}${detail ? ` — ${detail}` : ''}`);
+        log.info(`  \u2717 ${label}${detail ? ` — ${detail}` : ""}`);
 
-      log.info('Vellum Doctor\n');
+      log.info("Vellum Doctor\n");
 
       // 0. Connection policy info
       const socketPath = getSocketPath();
       const isOverride = hasSocketOverride();
       const autostart = shouldAutoStartDaemon();
-      log.info(`  Socket:    ${socketPath}${isOverride ? ' (override via VELLUM_DAEMON_SOCKET)' : ''}`);
-      log.info(`  Autostart: ${autostart ? 'enabled' : 'disabled'}\n`);
+      log.info(
+        `  Socket:    ${socketPath}${
+          isOverride ? " (override via VELLUM_DAEMON_SOCKET)" : ""
+        }`,
+      );
+      log.info(`  Autostart: ${autostart ? "enabled" : "disabled"}\n`);
 
       // 1. Bun installed
       try {
-        execSync('bun --version', { stdio: 'pipe' });
-        pass('Bun is installed');
+        execSync("bun --version", { stdio: "pipe" });
+        pass("Bun is installed");
       } catch {
-        fail('Bun is installed', 'bun not found in PATH');
+        fail("Bun is installed", "bun not found in PATH");
       }
 
       // 2. Provider/API key configured
       const raw = loadRawConfig();
-      const provider = typeof raw.provider === 'string' ? raw.provider : 'anthropic';
+      const provider =
+        typeof raw.provider === "string" ? raw.provider : "anthropic";
       const providerEnvVar: Record<string, string> = {
-        anthropic: 'ANTHROPIC_API_KEY',
-        openai: 'OPENAI_API_KEY',
-        gemini: 'GEMINI_API_KEY',
-        ollama: 'OLLAMA_API_KEY',
-        fireworks: 'FIREWORKS_API_KEY',
-        openrouter: 'OPENROUTER_API_KEY',
+        anthropic: "ANTHROPIC_API_KEY",
+        openai: "OPENAI_API_KEY",
+        gemini: "GEMINI_API_KEY",
+        ollama: "OLLAMA_API_KEY",
+        fireworks: "FIREWORKS_API_KEY",
+        openrouter: "OPENROUTER_API_KEY",
       };
-      const configKey = (raw.apiKeys as Record<string, string> | undefined)?.[provider];
+      const configKey = (raw.apiKeys as Record<string, string> | undefined)?.[
+        provider
+      ];
       const envVar = providerEnvVar[provider];
       const envKey = envVar ? process.env[envVar] : undefined;
 
-      if (provider === 'ollama') {
-        pass('Provider configured (Ollama; API key optional)');
+      if (provider === "ollama") {
+        pass("Provider configured (Ollama; API key optional)");
       } else if (envKey || configKey) {
-        pass('API key configured');
+        pass("API key configured");
       } else {
         fail(
-          'API key configured',
+          "API key configured",
           envVar
             ? `set ${envVar} or run: vellum config set apiKeys.${provider} <key>`
             : `set API key for provider "${provider}"`,
@@ -447,67 +443,95 @@ export function registerDoctorCommand(program: Command): void {
       try {
         const sock = getSocketPath();
         if (!existsSync(sock)) {
-          fail('Daemon reachable', 'socket not found (is the daemon running?)');
+          fail("Daemon reachable", "socket not found (is the daemon running?)");
         } else {
           await new Promise<void>((resolve, reject) => {
             const s = net.createConnection(sock);
-            const timer = setTimeout(() => { s.destroy(); reject(new IpcError('timeout')); }, 2000);
-            s.on('connect', () => { clearTimeout(timer); s.end(); resolve(); });
-            s.on('error', (err) => { clearTimeout(timer); reject(err); });
+            const timer = setTimeout(() => {
+              s.destroy();
+              reject(new IpcError("timeout"));
+            }, 2000);
+            s.on("connect", () => {
+              clearTimeout(timer);
+              s.end();
+              resolve();
+            });
+            s.on("error", (err) => {
+              clearTimeout(timer);
+              reject(err);
+            });
           });
-          pass('Daemon reachable');
+          pass("Daemon reachable");
         }
       } catch {
-        fail('Daemon reachable', 'could not connect to daemon socket');
+        fail("Daemon reachable", "could not connect to daemon socket");
       }
 
       // 4. DB exists and readable
       const dbPath = getDbPath();
       if (existsSync(dbPath)) {
         try {
-          const { Database } = await import('bun:sqlite');
+          const { Database } = await import("bun:sqlite");
           const db = new Database(dbPath, { readonly: true });
-          db.query('SELECT 1').get();
+          db.query("SELECT 1").get();
           db.close();
-          pass('Database exists and readable');
+          pass("Database exists and readable");
         } catch {
-          fail('Database exists and readable', 'file exists but cannot be read');
+          fail(
+            "Database exists and readable",
+            "file exists but cannot be read",
+          );
         }
       } else {
-        fail('Database exists and readable', `not found at ${dbPath}`);
+        fail("Database exists and readable", `not found at ${dbPath}`);
       }
 
       // 5. ~/.vellum/ directory structure (workspace layout)
       const rootDir = getRootDir();
       const dataDir = getDataDir();
       const workspaceDir = getWorkspaceDir();
-      const requiredDirs = [rootDir, workspaceDir, dataDir, `${dataDir}/db`, `${dataDir}/logs`, getWorkspaceSkillsDir(), getWorkspaceHooksDir(), `${rootDir}/protected`];
+      const requiredDirs = [
+        rootDir,
+        workspaceDir,
+        dataDir,
+        `${dataDir}/db`,
+        `${dataDir}/logs`,
+        getWorkspaceSkillsDir(),
+        getWorkspaceHooksDir(),
+        `${rootDir}/protected`,
+      ];
       const missing = requiredDirs.filter((d) => !existsSync(d));
       if (missing.length === 0) {
-        pass('Directory structure exists');
+        pass("Directory structure exists");
       } else {
-        fail('Directory structure exists', `missing: ${missing.join(', ')}`);
+        fail("Directory structure exists", `missing: ${missing.join(", ")}`);
       }
 
       // 6. Disk space
       try {
-        const output = execSync(`df -k "${rootDir}"`, { stdio: 'pipe', encoding: 'utf-8' });
-        const lines = output.trim().split('\n');
+        const output = execSync(`df -k "${rootDir}"`, {
+          stdio: "pipe",
+          encoding: "utf-8",
+        });
+        const lines = output.trim().split("\n");
         if (lines.length >= 2) {
           const cols = lines[1].trim().split(/\s+/);
           const availKB = parseInt(cols[3], 10);
           if (isNaN(availKB)) {
-            fail('Disk space', 'could not parse available space');
+            fail("Disk space", "could not parse available space");
           } else if (availKB < 100 * 1024) {
-            fail('Disk space', `only ${Math.round(availKB / 1024)}MB free (< 100MB)`);
+            fail(
+              "Disk space",
+              `only ${Math.round(availKB / 1024)}MB free (< 100MB)`,
+            );
           } else {
             pass(`Disk space (${Math.round(availKB / 1024)}MB free)`);
           }
         } else {
-          fail('Disk space', 'unexpected df output');
+          fail("Disk space", "unexpected df output");
         }
       } catch {
-        fail('Disk space', 'could not check disk space');
+        fail("Disk space", "could not check disk space");
       }
 
       // 7. Log file size
@@ -517,34 +541,42 @@ export function registerDoctorCommand(program: Command): void {
           const logStat = statSync(logPath);
           const logSizeMB = logStat.size / (1024 * 1024);
           if (logSizeMB > 50) {
-            fail('Log file size', `${logSizeMB.toFixed(1)}MB (> 50MB)`);
+            fail("Log file size", `${logSizeMB.toFixed(1)}MB (> 50MB)`);
           } else {
             pass(`Log file size (${logSizeMB.toFixed(1)}MB)`);
           }
         } catch {
-          fail('Log file size', 'could not stat log file');
+          fail("Log file size", "could not stat log file");
         }
       } else {
-        pass('Log file size (no log file yet)');
+        pass("Log file size (no log file yet)");
       }
 
       // 8. DB integrity check
       if (existsSync(dbPath)) {
         try {
-          const { Database } = await import('bun:sqlite');
+          const { Database } = await import("bun:sqlite");
           const db = new Database(dbPath, { readonly: true });
-          const result = db.query('PRAGMA integrity_check').get() as { integrity_check: string } | null;
+          const result = db.query("PRAGMA integrity_check").get() as {
+            integrity_check: string;
+          } | null;
           db.close();
-          if (result?.integrity_check === 'ok') {
-            pass('Database integrity check');
+          if (result?.integrity_check === "ok") {
+            pass("Database integrity check");
           } else {
-            fail('Database integrity check', result?.integrity_check ?? 'unknown result');
+            fail(
+              "Database integrity check",
+              result?.integrity_check ?? "unknown result",
+            );
           }
         } catch (err) {
-          fail('Database integrity check', err instanceof Error ? err.message : 'unknown error');
+          fail(
+            "Database integrity check",
+            err instanceof Error ? err.message : "unknown error",
+          );
         }
       } else {
-        fail('Database integrity check', 'database file not found');
+        fail("Database integrity check", "database file not found");
       }
 
       // 9. Socket permissions
@@ -554,54 +586,64 @@ export function registerDoctorCommand(program: Command): void {
           const sockStat = statSync(sockPath);
           const mode = sockStat.mode & 0o777;
           if (mode === 0o600 || mode === 0o700) {
-            pass(`Socket permissions (${mode.toString(8).padStart(4, '0')})`);
+            pass(`Socket permissions (${mode.toString(8).padStart(4, "0")})`);
           } else {
-            fail('Socket permissions', `expected 0600 or 0700, got 0${mode.toString(8)}`);
+            fail(
+              "Socket permissions",
+              `expected 0600 or 0700, got 0${mode.toString(8)}`,
+            );
           }
         } catch {
-          fail('Socket permissions', 'could not stat socket');
+          fail("Socket permissions", "could not stat socket");
         }
       } else {
-        pass('Socket permissions (socket not present — daemon not running)');
+        pass("Socket permissions (socket not present — daemon not running)");
       }
 
       // 10. Trust rule syntax
       const trustPath = `${rootDir}/protected/trust.json`;
       if (existsSync(trustPath)) {
         try {
-          const rawTrust = readFileSync(trustPath, 'utf-8');
+          const rawTrust = readFileSync(trustPath, "utf-8");
           const data = JSON.parse(rawTrust);
-          if (typeof data !== 'object' || data == null) {
-            fail('Trust rule syntax', 'trust.json is not a JSON object');
-          } else if (typeof data.version !== 'number') {
-            fail('Trust rule syntax', 'missing or invalid "version" field');
+          if (typeof data !== "object" || data == null) {
+            fail("Trust rule syntax", "trust.json is not a JSON object");
+          } else if (typeof data.version !== "number") {
+            fail("Trust rule syntax", 'missing or invalid "version" field');
           } else if (!Array.isArray(data.rules)) {
-            fail('Trust rule syntax', 'missing or invalid "rules" array');
+            fail("Trust rule syntax", 'missing or invalid "rules" array');
           } else {
             const invalid = data.rules.filter(
               (r: unknown) =>
-                typeof r !== 'object' || r == null ||
-                typeof (r as Record<string, unknown>).tool !== 'string' ||
-                typeof (r as Record<string, unknown>).pattern !== 'string' ||
-                typeof (r as Record<string, unknown>).scope !== 'string',
+                typeof r !== "object" ||
+                r == null ||
+                typeof (r as Record<string, unknown>).tool !== "string" ||
+                typeof (r as Record<string, unknown>).pattern !== "string" ||
+                typeof (r as Record<string, unknown>).scope !== "string",
             );
             if (invalid.length > 0) {
-              fail('Trust rule syntax', `${invalid.length} rule(s) have invalid structure`);
+              fail(
+                "Trust rule syntax",
+                `${invalid.length} rule(s) have invalid structure`,
+              );
             } else {
               pass(`Trust rule syntax (${data.rules.length} rule(s))`);
             }
           }
         } catch (err) {
-          fail('Trust rule syntax', err instanceof Error ? err.message : 'could not parse');
+          fail(
+            "Trust rule syntax",
+            err instanceof Error ? err.message : "could not parse",
+          );
         }
       } else {
-        pass('Trust rule syntax (no trust.json yet)');
+        pass("Trust rule syntax (no trust.json yet)");
       }
 
       // 11. WASM files
       const wasmFiles = [
-        { pkg: 'web-tree-sitter', file: 'web-tree-sitter.wasm' },
-        { pkg: 'tree-sitter-bash', file: 'tree-sitter-bash.wasm' },
+        { pkg: "web-tree-sitter", file: "web-tree-sitter.wasm" },
+        { pkg: "tree-sitter-bash", file: "tree-sitter-bash.wasm" },
       ];
       let wasmOk = true;
       const missingWasm: string[] = [];
@@ -609,11 +651,14 @@ export function registerDoctorCommand(program: Command): void {
         const dir = import.meta.dirname ?? __dirname;
         let fullPath = `${dir}/../../node_modules/${wasm.pkg}/${wasm.file}`;
         // In compiled binaries, fall back to Resources/ or next to the binary
-        if (!existsSync(fullPath) && dir.startsWith('/$bunfs/')) {
-          const { dirname: pathDirname, join: pathJoin } = await import('node:path');
+        if (!existsSync(fullPath) && dir.startsWith("/$bunfs/")) {
+          const { dirname: pathDirname, join: pathJoin } =
+            await import("node:path");
           const execDir = pathDirname(process.execPath);
-          const resourcesPath = pathJoin(execDir, '..', 'Resources', wasm.file);
-          fullPath = existsSync(resourcesPath) ? resourcesPath : pathJoin(execDir, wasm.file);
+          const resourcesPath = pathJoin(execDir, "..", "Resources", wasm.file);
+          fullPath = existsSync(resourcesPath)
+            ? resourcesPath
+            : pathJoin(execDir, wasm.file);
         }
         if (!existsSync(fullPath)) {
           missingWasm.push(wasm.file);
@@ -632,28 +677,38 @@ export function registerDoctorCommand(program: Command): void {
         }
       }
       if (wasmOk) {
-        pass('WASM files present and non-empty');
+        pass("WASM files present and non-empty");
       } else {
-        fail('WASM files', missingWasm.join(', '));
+        fail("WASM files", missingWasm.join(", "));
       }
 
       // 12. Browser runtime (Playwright + Chromium)
-      const { checkBrowserRuntime } = await import('../tools/browser/runtime-check.js');
+      const { checkBrowserRuntime } =
+        await import("../tools/browser/runtime-check.js");
       const browserStatus = await checkBrowserRuntime();
-      if (browserStatus.playwrightAvailable && browserStatus.chromiumInstalled) {
-        pass('Browser runtime (Playwright + Chromium)');
+      if (
+        browserStatus.playwrightAvailable &&
+        browserStatus.chromiumInstalled
+      ) {
+        pass("Browser runtime (Playwright + Chromium)");
       } else if (!browserStatus.playwrightAvailable) {
-        fail('Browser runtime', 'playwright not available');
+        fail("Browser runtime", "playwright not available");
       } else {
-        fail('Browser runtime', browserStatus.error ?? 'Chromium not installed');
+        fail(
+          "Browser runtime",
+          browserStatus.error ?? "Chromium not installed",
+        );
       }
 
       // 13. Sandbox backend diagnostics
-      const { runSandboxDiagnostics } = await import('../tools/terminal/sandbox-diagnostics.js');
+      const { runSandboxDiagnostics } =
+        await import("../tools/terminal/sandbox-diagnostics.js");
       const sandbox = runSandboxDiagnostics();
-      log.info(`\n  Sandbox:   ${sandbox.config.enabled ? 'enabled' : 'disabled'}`);
+      log.info(
+        `\n  Sandbox:   ${sandbox.config.enabled ? "enabled" : "disabled"}`,
+      );
       log.info(`  Reason:    ${sandbox.activeBackendReason}`);
-      log.info('');
+      log.info("");
       for (const check of sandbox.checks) {
         if (check.ok) {
           pass(check.label);
@@ -666,38 +721,52 @@ export function registerDoctorCommand(program: Command): void {
 
 export function registerCompletionsCommand(program: Command): void {
   program
-    .command('completions')
-    .argument('<shell>', 'Shell type: bash, zsh, or fish')
-    .description('Generate shell completion script (e.g. vellum completions bash >> ~/.bashrc)')
+    .command("completions")
+    .argument("<shell>", "Shell type: bash, zsh, or fish")
+    .description(
+      "Generate shell completion script (e.g. vellum completions bash >> ~/.bashrc)",
+    )
     .action((shell: string) => {
       const subcommands: Record<string, string[]> = {
-        daemon: ['start', 'stop', 'restart', 'status'],
-        sessions: ['list', 'new', 'export', 'clear'],
-        config: ['set', 'get', 'list', 'validate-allowlist'],
-        keys: ['list', 'set', 'delete'],
-        trust: ['list', 'remove', 'clear'],
-        memory: ['status', 'backfill', 'cleanup', 'query', 'rebuild-index'],
-        hooks: ['list', 'enable', 'disable', 'install', 'remove'],
-        contacts: ['list', 'get', 'merge'],
-        autonomy: ['get', 'set'],
+        sessions: ["list", "new", "export", "clear"],
+        config: ["set", "get", "list", "validate-allowlist"],
+        keys: ["list", "set", "delete"],
+        trust: ["list", "remove", "clear"],
+        memory: ["status", "backfill", "cleanup", "query", "rebuild-index"],
+        hooks: ["list", "enable", "disable", "install", "remove"],
+        contacts: ["list", "invites", "get", "merge"],
+        autonomy: ["get", "set"],
       };
       const topLevel = [
-        'daemon', 'dev', 'sessions', 'config', 'keys', 'trust', 'memory',
-        'hooks', 'contacts', 'autonomy', 'audit', 'doctor', 'completions', 'help',
+        "dev",
+        "sessions",
+        "config",
+        "keys",
+        "trust",
+        "memory",
+        "hooks",
+        "contacts",
+        "autonomy",
+        "audit",
+        "doctor",
+        "completions",
+        "help",
       ];
 
       switch (shell) {
-        case 'bash':
+        case "bash":
           process.stdout.write(generateBashCompletion(topLevel, subcommands));
           break;
-        case 'zsh':
+        case "zsh":
           process.stdout.write(generateZshCompletion(topLevel, subcommands));
           break;
-        case 'fish':
+        case "fish":
           process.stdout.write(generateFishCompletion(topLevel, subcommands));
           break;
         default:
-          log.error(`Unknown shell: ${shell}. Supported shells: bash, zsh, fish`);
+          log.error(
+            `Unknown shell: ${shell}. Supported shells: bash, zsh, fish`,
+          );
           process.exit(1);
       }
     });
@@ -708,8 +777,13 @@ function generateBashCompletion(
   subcommands: Record<string, string[]>,
 ): string {
   const subcmdCases = Object.entries(subcommands)
-    .map(([cmd, subs]) => `        ${cmd}) COMPREPLY=( $(compgen -W "${subs.join(' ')}" -- "$cur") ) ;;`)
-    .join('\n');
+    .map(
+      ([cmd, subs]) =>
+        `        ${cmd}) COMPREPLY=( $(compgen -W "${subs.join(
+          " ",
+        )}" -- "$cur") ) ;;`,
+    )
+    .join("\n");
 
   return `# vellum bash completion
 # Add to ~/.bashrc: eval "$(vellum completions bash)"
@@ -718,7 +792,9 @@ _vellum_completions() {
     _init_completion || return
 
     if [[ $cword -eq 1 ]]; then
-        COMPREPLY=( $(compgen -W "${topLevel.join(' ')} --help --version" -- "$cur") )
+        COMPREPLY=( $(compgen -W "${topLevel.join(
+          " ",
+        )} --help --version" -- "$cur") )
         return
     fi
 
@@ -737,8 +813,8 @@ function generateZshCompletion(
   subcommands: Record<string, string[]>,
 ): string {
   const subcmdCases = Object.entries(subcommands)
-    .map(([cmd, subs]) => `        ${cmd}) compadd ${subs.join(' ')} ;;`)
-    .join('\n');
+    .map(([cmd, subs]) => `        ${cmd}) compadd ${subs.join(" ")} ;;`)
+    .join("\n");
 
   return `#compdef vellum
 # vellum zsh completion
@@ -746,7 +822,6 @@ function generateZshCompletion(
 _vellum() {
     local -a commands
     commands=(
-        'daemon:Manage the daemon process'
         'dev:Run daemon in dev mode with auto-restart'
         'sessions:Manage sessions'
         'config:Manage configuration'
@@ -789,24 +864,23 @@ function generateFishCompletion(
   script += `complete -c vellum -f\n`;
 
   const descriptions: Record<string, string> = {
-    daemon: 'Manage the daemon process',
-    dev: 'Run daemon in dev mode with auto-restart',
-    sessions: 'Manage sessions',
-    config: 'Manage configuration',
-    keys: 'Manage API keys in secure storage',
-    trust: 'Manage trust rules',
-    memory: 'Manage long-term memory',
-    hooks: 'Manage hooks',
-    contacts: 'Manage the contact graph',
-    autonomy: 'View and configure autonomy tiers',
-    audit: 'Show recent tool invocations',
-    doctor: 'Run diagnostic checks',
-    completions: 'Generate shell completion script',
-    help: 'Display help',
+    dev: "Run daemon in dev mode with auto-restart",
+    sessions: "Manage sessions",
+    config: "Manage configuration",
+    keys: "Manage API keys in secure storage",
+    trust: "Manage trust rules",
+    memory: "Manage long-term memory",
+    hooks: "Manage hooks",
+    contacts: "Manage the contact graph",
+    autonomy: "View and configure autonomy tiers",
+    audit: "Show recent tool invocations",
+    doctor: "Run diagnostic checks",
+    completions: "Generate shell completion script",
+    help: "Display help",
   };
 
   for (const cmd of topLevel) {
-    const desc = descriptions[cmd] ?? '';
+    const desc = descriptions[cmd] ?? "";
     script += `complete -c vellum -n '__fish_use_subcommand' -a '${cmd}' -d '${desc}'\n`;
   }
   script += `complete -c vellum -n '__fish_use_subcommand' -l help -d 'Show help'\n`;