@mycadet/cli 0.12.7 → 0.12.9

package/src/commands/upgrade.ts

@@ -1,7 +1,6 @@
 import { resolveExistingLocalSigningKey } from "@mycadet/local-mode";
-import { isManagedCloud } from "../lib/managed-cloud.js";
+import { isCloudHome } from "../lib/cloud-values.js";
 import { spawnSync } from "child_process";
-import { writeFileSync } from "fs";
 import { join } from "path";
 
 import cliPkg from "../../package.json";
@@ -20,6 +19,7 @@ import {
   GATEWAY_INTERNAL_PORT,
   ASSISTANT_INTERNAL_PORT,
   dockerResourceNames,
+  pullImage,
   startContainers,
   stopContainers,
 } from "../lib/docker";
@@ -27,14 +27,14 @@ import {
   fetchLatestStableVersion,
   fetchReleases,
   resolveImageRefs,
-} from "../lib/platform-releases";
+} from "../lib/cloud-releases";
 import {
   authHeaders,
   fetchAssistantDetail,
   fetchUpgradeInProgress,
-  getPlatformUrl,
-  readPlatformToken,
-} from "../lib/platform-client";
+  getCloudUrl,
+  readCloudToken,
+} from "../lib/cloud-client";
 import { checkManagedHealth } from "../lib/health-check.js";
 import {
   evaluateUpgradePoll,
@@ -47,7 +47,6 @@ import {
 } from "../lib/backup-ops.js";
 import { emitCliError, categorizeUpgradeError } from "../lib/cli-error.js";
 import { parseAssistantTargetArg } from "../lib/assistant-target-args.js";
-import { exec } from "../lib/step-runner.js";
 import {
   broadcastUpgradeEvent,
   attemptFailedStateRestore,
@@ -77,7 +76,7 @@ import {
   startLocalDaemon,
   stopLocalProcesses,
 } from "../lib/local.js";
-import { restoreTunnelEdgeAndAutoTunnel } from "../lib/tunnel-edge.js";
+import { restoreTunnelEdgeAndAutoTunnel } from "../lib/tunnel.js";
 import {
   leaseGuardianToken,
   resetGuardianBootstrap,
@@ -119,12 +118,12 @@ function parseArgs(): UpgradeArgs {
       console.log("");
       console.log("Arguments:");
       console.log(
-        "  <name>               Name of the assistant to upgrade (default: active or only assistant)",
+        "  <name>               Name of the assistant to upgrade, defaults to active or only assistant",
       );
       console.log("");
       console.log("Options:");
       console.log(
-        "  --version <version>  Target version to upgrade to (default: CLI version)",
+        "  --version <version>  Target version to upgrade to, defaults to the CLI version",
       );
       console.log(
         "  --latest             Upgrade to the latest stable release, updating the CLI first if needed",
@@ -317,7 +316,7 @@ async function upgradeDocker(
       );
       return;
     }
-    console.log(`🔁 Reinstalling ${versionTag} (--force)...\n`);
+    console.log(`🔁 Reinstalling ${versionTag} with --force...\n`);
   }
 
   console.log("🔍 Resolving image references...");
@@ -407,7 +406,7 @@ async function upgradeDocker(
   try {
     for (const [service, image] of pullImages) {
       console.log(`   Pulling ${service}: ${image}`);
-      await exec("docker", ["pull", image]);
+      await pullImage(image);
     }
   } catch (pullErr) {
     const detail = pullErr instanceof Error ? pullErr.message : String(pullErr);
@@ -454,7 +453,7 @@ async function upgradeDocker(
     // Clean up old pre-upgrade backups, keep last 3
     pruneOldBackups(entry.assistantId, 3);
   } else {
-    console.warn("⚠️  Pre-upgrade backup failed (continuing with upgrade)\n");
+    console.warn("⚠️  Pre-upgrade backup failed, continuing with upgrade\n");
   }
 
   // Persist the backup path so `cadet rollback` can restore the exact backup
@@ -502,17 +501,12 @@ async function upgradeDocker(
   const ready = await waitForReady(entry.runtimeUrl);
   if (ready) {
     // Update lockfile with new service group topology
-    const newDigests = await captureImageRefs(res);
     const updatedEntry: AssistantEntry = {
       ...entry,
       containerInfo: {
         assistantImage: imageTags.assistant,
         gatewayImage: imageTags.gateway,
         cesImage: imageTags["credential-executor"],
-        assistantDigest: newDigests?.assistant,
-        gatewayDigest: newDigests?.gateway,
-        cesDigest: newDigests?.["credential-executor"],
-        networkName: res.network,
         assistantPort,
       },
       previousContainerInfo: entry.containerInfo,
@@ -668,13 +662,9 @@ async function upgradeDocker(
             );
           }
 
-          // Capture fresh digests from the now-running rolled-back containers.
-          const rollbackDigests = await captureImageRefs(res);
-
           // Restore previous container info in lockfile after rollback.
-          // The *Image fields hold human-readable image:tag names from the
-          // pre-upgrade containerInfo; *Digest fields get fresh values from
-          // the running containers (or fall back to previousImageRefs).
+          // The recorded image refs are the rollback record now (digests are
+          // gone from the contract).
           const rolledBackEntry: AssistantEntry = {
             ...entry,
             containerInfo: {
@@ -686,14 +676,6 @@ async function upgradeDocker(
               cesImage:
                 entry.containerInfo?.cesImage ??
                 previousImageRefs["credential-executor"],
-              assistantDigest:
-                rollbackDigests?.assistant ?? previousImageRefs.assistant,
-              gatewayDigest:
-                rollbackDigests?.gateway ?? previousImageRefs.gateway,
-              cesDigest:
-                rollbackDigests?.["credential-executor"] ??
-                previousImageRefs["credential-executor"],
-              networkName: res.network,
               assistantPort,
             },
             previousContainerInfo: undefined,
@@ -909,7 +891,7 @@ async function upgradeLocal(
       );
       return;
     }
-    console.log(`🔁 Reinstalling ${targetVersion} (--force)...\n`);
+    console.log(`🔁 Reinstalling ${targetVersion} with --force...\n`);
   }
 
   console.log(
@@ -951,7 +933,7 @@ async function upgradeLocal(
     console.log(`   Backup saved: ${backupPath}\n`);
     pruneOldBackups(entry.assistantId, 3);
   } else {
-    console.warn("⚠️  Pre-upgrade backup failed (continuing with upgrade)\n");
+    console.warn("⚠️  Pre-upgrade backup failed, continuing with upgrade\n");
   }
 
   let bootstrapSecret = entry.guardianBootstrapSecret;
@@ -1035,17 +1017,11 @@ async function upgradeLocal(
   console.log("✅ Local assistant processes started\n");
 
   const workspaceDir = join(entry.resources.instanceDir, "workspace");
-  const ngrokChild = await restoreTunnelEdgeAndAutoTunnel(
+  await restoreTunnelEdgeAndAutoTunnel(
     entry.assistantId,
     entry.resources.gatewayPort,
     workspaceDir,
   );
-  if (ngrokChild?.pid) {
-    writeFileSync(
-      join(entry.resources.instanceDir, "ngrok.pid"),
-      String(ngrokChild.pid),
-    );
-  }
 
   console.log("Waiting for assistant to become ready...");
   const ready = await waitForReady(adminUrl);
@@ -1113,7 +1089,7 @@ function sleep(ms: number): Promise<void> {
 }
 
 /**
- * Poll the platform until the upgrade completes, then confirm health.
+ * Poll the cloud until the upgrade completes, then confirm health.
  * Mirrors the web UI's Software Updates flow (poll the DB-backed
  * `current_release_version` rather than the gateway, which bounces while
  * the service group restarts).
@@ -1163,7 +1139,7 @@ async function waitForPlatformUpgrade(
       const healthDeadline = Date.now() + PLATFORM_HEALTH_CONFIRM_TIMEOUT_MS;
       while (Date.now() < healthDeadline) {
         const health = await checkManagedHealth(
-          entry.runtimeUrl || getPlatformUrl(),
+          entry.runtimeUrl || getCloudUrl(),
           entry.assistantId,
         );
         if (health.status === "healthy") {
@@ -1187,7 +1163,7 @@ async function waitForPlatformUpgrade(
 
   const timeoutMin = Math.round(timeoutMs / 60_000);
   console.warn(
-    `⚠️  Upgrade request was accepted but completion was not confirmed within ${timeoutMin} minutes. The platform may still be working — check \`cadet ps\` or the web settings page.`,
+    `⚠️  Upgrade request was accepted but completion was not confirmed within ${timeoutMin} minutes. The cloud may still be working — check \`cadet ps\` or the web settings page.`,
   );
 }
 
@@ -1197,10 +1173,10 @@ async function upgradePlatform(
   wait: boolean,
 ): Promise<void> {
   console.log(
-    `🔄 Upgrading platform-hosted assistant '${entry.assistantId}'...\n`,
+    `🔄 Upgrading cloud-hosted assistant '${entry.assistantId}'...\n`,
   );
 
-  const token = readPlatformToken();
+  const token = readCloudToken();
   if (!token) {
     const msg =
       "Error: Not logged in. Run `cadet login --token <token>` first.";
@@ -1214,7 +1190,7 @@ async function upgradePlatform(
   // downgrades before POSTing, and bail if an upgrade is already running.
   const [assistantDetail, health] = await Promise.all([
     fetchAssistantDetail(token, entry.assistantId, entry.runtimeUrl),
-    checkManagedHealth(entry.runtimeUrl || getPlatformUrl(), entry.assistantId),
+    checkManagedHealth(entry.runtimeUrl || getCloudUrl(), entry.assistantId),
   ]);
   // Health probe first, DB-backed field as the sleeping-assistant fallback.
   const currentVersion =
@@ -1225,7 +1201,7 @@ async function upgradePlatform(
   // platform may differ from the active lockfile default.
   const releases = await fetchReleases({
     channel: releaseChannel,
-    platformUrl: entry.runtimeUrl,
+    cloudUrl: entry.runtimeUrl,
   });
 
   const resolution = resolveUpgradeTarget({
@@ -1276,7 +1252,7 @@ async function upgradePlatform(
 
   const headers = await authHeaders(token, entry.runtimeUrl);
 
-  const url = `${entry.runtimeUrl || getPlatformUrl()}/v1/assistants/${encodeURIComponent(entry.assistantId)}/upgrade/`;
+  const url = `${entry.runtimeUrl || getCloudUrl()}/v1/assistants/${encodeURIComponent(entry.assistantId)}/upgrade/`;
   const body: { version?: string } = {};
   if (version) {
     body.version = version;
@@ -1345,11 +1321,11 @@ async function upgradePlatform(
   }
 
   // NOTE: We intentionally do NOT broadcast a "complete" event here.
-  // The platform API returning 200 only means "upgrade request accepted" —
+  // The cloud API returning 200 only means "upgrade request accepted" —
   // the service group has not yet restarted with the new version.  The
   // completion signal will come from the client's health-check
   // version-change detection (DaemonConnection.swift) once the new
-  // version actually appears after the platform restarts the service group.
+  // version actually appears after the cloud restarts the service group.
 
   console.log(`✅ ${result.detail}`);
   if (result.version) {
@@ -1483,7 +1459,7 @@ async function resolveLatestStableTag(): Promise<string> {
     );
     emitCliError(
       "UNKNOWN",
-      "Could not determine the latest stable release from the platform API",
+      "Could not determine the latest stable release from the cloud API",
     );
     process.exit(1);
   }
@@ -1560,7 +1536,7 @@ export const upgrade = Object.assign(
     return;
   }
 
-  // When --latest is passed, resolve the target from the platform API and
+  // When --latest is passed, resolve the target from the cloud API and
   // self-update the CLI if it's behind.  The resolved version is then used
   // as the explicit target for the rest of the upgrade flow.
   let effectiveVersion = version;
@@ -1586,7 +1562,7 @@ export const upgrade = Object.assign(
       return;
     }
 
-    if (isManagedCloud(cloud)) {
+    if (isCloudHome(cloud)) {
       await upgradePlatform(entry, effectiveVersion, !noWait);
       return;
     }

package/src/commands/use.ts

@@ -38,7 +38,7 @@ export const use = Object.assign(
           `Active assistant: ${formatAssistantReference(result.entry)}`,
         );
       } else {
-        console.log(`Active assistant: ${active} (not found in lockfile)`);
+        console.log(`Active assistant: ${active} — not found in lockfile`);
       }
     } else {
       console.log("No active assistant set.");

package/src/commands/wake.ts

@@ -2,16 +2,23 @@ import {
   SigningKeyContinuityError,
   resolveExistingLocalSigningKey,
 } from "@mycadet/local-mode";
-import { writeFileSync } from "fs";
 import { join } from "path";
 
 import {
   getDaemonPidPath,
+  loadAllAssistants,
   resolveTargetAssistant,
   saveAssistantEntry,
 } from "../lib/assistant-config.js";
-import { dockerResourceNames, wakeContainers } from "../lib/docker.js";
+import type { AssistantEntry } from "../lib/assistant-config.js";
 import {
+  dockerResourceNames,
+  isNoSuchContainerError,
+  recreateDockerContainers,
+  wakeContainers,
+} from "../lib/docker.js";
+import {
+  GuardianLeasePermanentError,
   leaseGuardianToken,
   resetGuardianBootstrap,
   seedGuardianTokenFromSiblingEnv,
@@ -39,22 +46,25 @@ import {
   DOCKER_GATEWAY_READY_TIMEOUT_MS,
   restoreContainerTunnelEdge,
   restoreTunnelEdgeAndAutoTunnel,
-} from "../lib/tunnel-edge.js";
+} from "../lib/tunnel.js";
 
 export const wake = Object.assign(
   async function wake(): Promise<void> {
   const args = process.argv.slice(3);
   if (args.includes("--help") || args.includes("-h")) {
-    console.log("Usage: cadet wake [<name>] [options]");
+    console.log("Usage: cadet wake [<name> | --all] [options]");
     console.log("");
     console.log("Start the assistant and gateway processes.");
     console.log("");
     console.log("Arguments:");
     console.log(
-      "  <name>    Name of the assistant to start (default: active or only local)",
+      "  <name>    Name of the assistant to start, defaults to active or only local",
     );
     console.log("");
     console.log("Options:");
+    console.log(
+      "  --all          Start every assistant across all remotes instead of one",
+    );
     console.log(
       "  --watch        Run assistant and gateway in watch mode (hot reload on source changes)",
     );
@@ -80,7 +90,122 @@ export const wake = Object.assign(
   // recovered deliberately via `cadet wake <id> --repair-guardian`.
   const repairGuardian = args.includes("--repair-guardian");
   const nameArg = args.find((a) => !a.startsWith("-"));
+  const all = args.includes("--all");
+
+  if (all && nameArg) {
+    console.error("Error: --all cannot be combined with an assistant name.");
+    process.exit(1);
+  }
+  if (all && (foreground || repairGuardian)) {
+    console.error(
+      "Error: --all cannot be combined with --foreground or --repair-guardian.",
+    );
+    process.exit(1);
+  }
+
+  if (all) {
+    await wakeAll({ watch });
+    return;
+  }
+
   const entry = resolveTargetAssistant(nameArg);
+  try {
+    await wakeAssistant(entry, { watch, foreground, repairGuardian });
+  } catch (err) {
+    if (err instanceof WakeExit) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+    throw err;
+  }
+
+  // Foreground blocking is a single-assistant concern (--all refuses the
+  // flag), and the docker path already warned that foreground is ignored.
+  if (foreground && entry.cloud !== "docker") {
+    console.log("Running in the foreground, Ctrl+C to stop...\n");
+    // Block forever — the daemon is running with inherited stdio so its
+    // output streams to this terminal. When the user hits Ctrl+C, SIGINT
+    // propagates to the daemon child and both exit.
+    await new Promise<void>((resolve) => {
+      process.on("SIGINT", () => {
+        console.log("\nShutting down...");
+        resolve();
+      });
+      process.on("SIGTERM", () => resolve());
+    });
+  }
+},
+  { description: "Start the assistant and gateway" },
+);
+
+/**
+ * Start every assistant this CLI's environment knows about — `--all`. The
+ * CLI only ever reaches one environment, so this is the current env's
+ * lockfile. Same per-assistant wake as the single path, but one assistant's
+ * failure never blocks the others; failures only decide the exit code.
+ */
+async function wakeAll(opts: { watch: boolean }): Promise<void> {
+  const entries = loadAllAssistants();
+  if (entries.length === 0) {
+    console.error("Error: no assistants found. Run 'cadet hatch' first.");
+    process.exit(1);
+  }
+
+  let failures = 0;
+  const seen = new Set<string>();
+  for (const entry of entries) {
+    if (seen.has(entry.assistantId)) continue;
+    seen.add(entry.assistantId);
+    if (entry.cloud === "apple-container" || entry.cloud === "paired") {
+      console.log(
+        `Skipping '${entry.assistantId}' (${entry.cloud}) — its lifecycle is managed elsewhere.`,
+      );
+      continue;
+    }
+    try {
+      await wakeAssistant(entry, {
+        watch: opts.watch,
+        foreground: false,
+        repairGuardian: false,
+      });
+    } catch (err) {
+      failures++;
+      console.error(
+        `Error: failed to wake '${entry.assistantId}': ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    }
+  }
+  if (failures > 0) {
+    process.exit(1);
+  }
+}
+
+type WakeAssistantOptions = {
+  watch: boolean;
+  foreground: boolean;
+  repairGuardian: boolean;
+};
+
+/**
+ * Marks a deliberate per-assistant refusal (an unmanageable runtime, missing
+ * resources, a daemon that died during startup). The single-assistant path
+ * renders it as the same "Error: …" + exit 1 the command always printed;
+ * `--all` treats it as one entry's failure and keeps waking the rest.
+ */
+class WakeExit extends Error {}
+
+/**
+ * Start one assistant and its gateway. Throws WakeExit on deliberate
+ * refusals so the caller decides between exiting (single path) and
+ * continuing to the next entry (`--all`).
+ */
+async function wakeAssistant(
+  entry: AssistantEntry,
+  opts: WakeAssistantOptions,
+): Promise<void> {
+  const { watch, foreground, repairGuardian } = opts;
 
   if (entry.cloud === "docker") {
     if (watch || foreground) {
@@ -88,11 +213,23 @@ export const wake = Object.assign(
         .filter(Boolean)
         .join(" and ");
       console.warn(
-        `Warning: ${ignored} ignored for Docker instances (not supported).`,
+        `Warning: ${ignored} ignored for Docker instances.`,
       );
     }
     const res = dockerResourceNames(entry.assistantId);
-    await wakeContainers(res);
+    try {
+      await wakeContainers(res);
+    } catch (err) {
+      // A migrated install has data in the volumes but containers that were
+      // never created (v0.0.10 run feedback: "No such container"). Recreate
+      // the service group from the entry's recorded images; anything else
+      // is a real wake failure.
+      if (!isNoSuchContainerError(err)) throw err;
+      console.log(
+        `Containers for '${entry.assistantId}' don't exist yet — recreating from the recorded images...`,
+      );
+      await recreateDockerContainers(entry);
+    }
     console.log("Docker containers started.");
     await restoreContainerTunnelEdge(entry, DOCKER_GATEWAY_READY_TIMEOUT_MS);
     console.log("Wake complete.");
@@ -100,31 +237,27 @@ export const wake = Object.assign(
   }
 
   if (entry.cloud === "apple-container") {
-    console.error(
-      `Error: '${entry.assistantId}' uses the Apple Containers runtime. Its lifecycle is managed by the macOS app — use the app to start it.`,
+    throw new WakeExit(
+      `'${entry.assistantId}' uses the Apple Containers runtime. Its lifecycle is managed by the macOS app — use the app to start it.`,
     );
-    process.exit(1);
   }
 
   if (entry.cloud === "paired") {
-    console.error(
-      `Error: '${entry.assistantId}' is a remote assistant paired from another machine — its lifecycle is managed on its host machine, not here. Use \`cadet client ${entry.assistantId}\` to chat with it.`,
+    throw new WakeExit(
+      `'${entry.assistantId}' is a remote assistant paired from another machine — its lifecycle is managed on its host machine, not here. Use \`cadet client ${entry.assistantId}\` to chat with it.`,
     );
-    process.exit(1);
   }
 
   if (entry.cloud && entry.cloud !== "local") {
-    console.error(
-      `Error: 'cadet wake' only works with local and docker assistants. '${entry.assistantId}' is a ${entry.cloud} instance.`,
+    throw new WakeExit(
+      `'cadet wake' only works with local and docker assistants. '${entry.assistantId}' is a ${entry.cloud} instance.`,
     );
-    process.exit(1);
   }
 
   if (!entry.resources) {
-    console.error(
-      `Error: Local assistant '${entry.assistantId}' is missing resource configuration. Re-hatch to fix.`,
+    throw new WakeExit(
+      `Local assistant '${entry.assistantId}' is missing resource configuration. Re-hatch to fix.`,
     );
-    process.exit(1);
   }
   const resources = entry.resources;
   let signingKey: string;
@@ -231,7 +364,7 @@ export const wake = Object.assign(
       daemonMigrationsFailed = daemonState.status === "migration_failed";
       if (watch) {
         console.log(
-          `Assistant running (pid ${daemonState.pid}) — watch mode not available (no source files). Keeping existing process.`,
+          `Assistant running (pid ${daemonState.pid}) — watch mode not available, no source files. Keeping existing process.`,
         );
       } else if (daemonMigrationsFailed) {
         console.log(
@@ -275,10 +408,9 @@ export const wake = Object.assign(
     // first and fail the command instead of reporting a successful wake for
     // an assistant that is not running.
     if (!isProcessAlive(pidFile).alive) {
-      console.error(
-        `Error: the assistant exited during startup and is not running. Its runtime HTTP port ${resources.daemonPort} may be held by another process (check \`lsof -i :${resources.daemonPort}\`); the daemon log records the startup error it reported.`,
+      throw new WakeExit(
+        `the assistant exited during startup and is not running. Its runtime HTTP port ${resources.daemonPort} may be held by another process (check \`lsof -i :${resources.daemonPort}\`); the daemon log records the startup error it reported.`,
       );
-      process.exit(1);
     }
     // startLocalDaemon's post-spawn wait is bounded (60s), and a longer
     // migration outlives it. Classify the fresh spawn the same way the
@@ -356,7 +488,7 @@ export const wake = Object.assign(
       } else {
         if (watch) {
           console.log(
-            `Gateway running (pid ${gatewayState.pid}) — watch mode not available (no source files). Keeping existing process.`,
+            `Gateway running (pid ${gatewayState.pid}) — watch mode not available, no source files. Keeping existing process.`,
           );
         } else {
           console.log(`Gateway already running (pid ${gatewayState.pid}).`);
@@ -430,11 +562,14 @@ export const wake = Object.assign(
         console.log("   Re-provisioned guardian token.");
         break;
       } catch (err) {
-        if (attempt < maxAttempts) {
+        if (
+          attempt < maxAttempts &&
+          !(err instanceof GuardianLeasePermanentError)
+        ) {
           await new Promise((r) => setTimeout(r, 2000 * 2 ** (attempt - 1)));
         } else {
           console.warn(
-            `   Guardian token re-provision failed after ${maxAttempts} attempts: ${err}`,
+            `   Guardian token re-provision failed${err instanceof GuardianLeasePermanentError ?", not retrying — a malformed 200 will not fix itself" : ` after ${maxAttempts} attempts`}: ${err}`,
           );
           // The user explicitly confirmed this destructive repair — a
           // success exit here would make callers (the web recovery flow)
@@ -446,18 +581,15 @@ export const wake = Object.assign(
     }
   }
 
-  // Restore the nginx edge and point the webhook auto-tunnel at it. Non-fatal:
-  // a down edge is a degraded remote-web/webhook path, not a broken assistant.
+  // Restore the nginx edge and point the auto-tunnel at it. The spawned agent
+  // records itself in the root lockfile under `tunnel`. Non-fatal: a down
+  // edge is a degraded remote-web/webhook path, not a broken assistant.
   const workspaceDir = join(resources.instanceDir, "workspace");
-  const ngrokChild = await restoreTunnelEdgeAndAutoTunnel(
+  await restoreTunnelEdgeAndAutoTunnel(
     entry.assistantId,
     resources.gatewayPort,
     workspaceDir,
   );
-  if (ngrokChild?.pid) {
-    const ngrokPidFile = join(resources.instanceDir, "ngrok.pid");
-    writeFileSync(ngrokPidFile, String(ngrokChild.pid));
-  }
 
   if (daemonMigrationsFailed) {
     console.log(
@@ -469,21 +601,5 @@ export const wake = Object.assign(
     );
   }
   console.log("Wake complete.");
-
-  if (foreground) {
-    console.log("Running in foreground (Ctrl+C to stop)...\n");
-    // Block forever — the daemon is running with inherited stdio so its
-    // output streams to this terminal. When the user hits Ctrl+C, SIGINT
-    // propagates to the daemon child and both exit.
-    await new Promise<void>((resolve) => {
-      process.on("SIGINT", () => {
-        console.log("\nShutting down...");
-        resolve();
-      });
-      process.on("SIGTERM", () => resolve());
-    });
-  }
-},
-  { description: "Start the assistant and gateway" },
-);
+}