@vellumai/cli 0.10.6-dev.202607072040.fb971ce → 0.10.6-staging.1

package/src/lib/docker.ts

@@ -23,10 +23,7 @@ import { buildHatchConfigValues, writeInitialConfig } from "./config-utils";
 import { buildServiceRunArgs } from "./statefulset.js";
 import type { Species } from "./constants";
 import { getOrCreateHostDeviceId } from "./device-id.js";
-import {
-  ASSISTANT_INTERNAL_PORT,
-  getDefaultPorts,
-} from "./environments/paths.js";
+import { ASSISTANT_INTERNAL_PORT, getDefaultPorts } from "./environments/paths.js";
 import { getCurrentEnvironment } from "./environments/resolve.js";
 import { leaseGuardianToken } from "./guardian-token";
 import { logHatchNextSteps } from "./hatch-next-steps.js";
@@ -71,7 +68,6 @@ export {
   ASSISTANT_INTERNAL_PORT,
   GATEWAY_INTERNAL_PORT,
 } from "./environments/paths.js";
-import { classifyReadyzResponse } from "./http-client.js";
 import { loopbackSafeFetch } from "./loopback-fetch.js";
 
 /** Max time to wait for the assistant container to emit the readiness sentinel. */
@@ -957,8 +953,7 @@ function startFileWatcher(opts: {
   netnsContainer?: string;
   assistantCaCertPath?: string;
 }): () => void {
-  const { gatewayPort, assistantPort, imageTags, instanceName, repoRoot, res } =
-    opts;
+  const { gatewayPort, assistantPort, imageTags, instanceName, repoRoot, res } = opts;
 
   const { dirs: watchDirs, files: watchFiles } = collectWatchTargets(repoRoot);
 
@@ -1492,24 +1487,19 @@ export async function hatchDocker(params: HatchDockerParams): Promise<void> {
 
     emitProgress(6, 6, "Waiting for services...");
     const waitDetached = watch ? false : detached;
-    const { ready, guardianAccessToken, notReadyReason } =
-      await waitForGatewayAndLease({
-        bootstrapSecret: ownSecret,
-        containerName: res.assistantContainer,
-        detached: waitDetached,
-        instanceName,
-        logFd,
-        runtimeUrl,
-        containersUpAt,
-        analyze: params.analyze ?? false,
-      });
+    const { ready, guardianAccessToken } = await waitForGatewayAndLease({
+      bootstrapSecret: ownSecret,
+      containerName: res.assistantContainer,
+      detached: waitDetached,
+      instanceName,
+      logFd,
+      runtimeUrl,
+      containersUpAt,
+      analyze: params.analyze ?? false,
+    });
 
     if (!ready && !(watch && repoRoot)) {
-      throw new Error(
-        notReadyReason === "migrations_failed"
-          ? "Assistant database migrations failed — the container is running but DB-backed routes are unavailable; check its logs and restore a backup or retry the migration"
-          : "Timed out waiting for assistant to become ready",
-      );
+      throw new Error("Timed out waiting for assistant to become ready");
     }
 
     if (ready) {
@@ -1611,13 +1601,7 @@ async function waitForGatewayAndLease(opts: {
   runtimeUrl: string;
   containersUpAt: number;
   analyze: boolean;
-}): Promise<{
-  ready: boolean;
-  guardianAccessToken?: string;
-  /** Present when readiness was not reached because migrations terminally
-   * failed (returned in seconds, unlike an actual timeout). */
-  notReadyReason?: "migrations_failed";
-}> {
+}): Promise<{ ready: boolean; guardianAccessToken?: string }> {
   const {
     bootstrapSecret,
     containerName,
@@ -1691,34 +1675,24 @@ async function waitForGatewayAndLease(opts: {
   const readyUrl = `${runtimeUrl}/readyz`;
   const start = containersUpAt;
   let ready = false;
-  let migrationsFailed = false;
 
-  // Readiness is classified from the /readyz BODY: the assistant returns 200
-  // with `ready: false` while DB migrations run (the k8s keep-the-pod
-  // contract), so `resp.ok` alone would declare readiness mid-migration and
-  // the guardian token lease below would burn its shared budget against the
-  // gateway's still-closed traffic gate.
   while (Date.now() - start < DOCKER_READY_TIMEOUT_MS) {
     try {
       const resp = await loopbackSafeFetch(readyUrl, {
         signal: AbortSignal.timeout(5000),
       });
-      const body = (await resp.json().catch(() => null)) as {
-        status?: string;
-        upstream?: number;
-      } | null;
-      const readiness = classifyReadyzResponse(resp.ok, body);
-      if (readiness === "ready") {
+      if (resp.ok) {
         ready = true;
         break;
       }
-      if (readiness === "failed") {
-        migrationsFailed = true;
-        break;
-      }
-      const parts = [body?.status].filter(Boolean);
-      if (body?.upstream != null) parts.push(`upstream=${body.upstream}`);
-      const detail = parts.length > 0 ? ` — ${parts.join(", ")}` : "";
+      const body = await resp.text();
+      let detail = "";
+      try {
+        const json = JSON.parse(body);
+        const parts = [json.status];
+        if (json.upstream != null) parts.push(`upstream=${json.upstream}`);
+        detail = ` — ${parts.join(", ")}`;
+      } catch {}
       log(`Readiness check: ${resp.status}${detail} (retrying...)`);
     } catch {
       // Connection refused / timeout — not up yet
@@ -1728,20 +1702,11 @@ async function waitForGatewayAndLease(opts: {
 
   if (!ready) {
     log("");
-    if (migrationsFailed) {
-      log(`   \u26a0\ufe0f  Assistant database migrations FAILED.`);
-    } else {
-      log(`   \u26a0\ufe0f  Timed out waiting for assistant to become ready.`);
-    }
+    log(`   \u26a0\ufe0f  Timed out waiting for assistant to become ready.`);
     log(`   The container is still running.`);
     log(`   Check logs with: docker logs -f ${containerName}`);
     log("");
-    return {
-      ready: false,
-      ...(migrationsFailed
-        ? { notReadyReason: "migrations_failed" as const }
-        : {}),
-    };
+    return { ready: false };
   }
 
   const readyAt = Date.now();

package/src/lib/http-client.ts

@@ -1,7 +1,5 @@
 import { loopbackSafeFetch } from "./loopback-fetch.js";
 
-export type HttpProbeEndpoint = "healthz" | "readyz";
-
 /**
  * Build the base URL for the daemon HTTP server.
  */
@@ -9,13 +7,16 @@ export function buildDaemonUrl(port: number): string {
   return `http://127.0.0.1:${port}`;
 }
 
-async function httpProbe(
+/**
+ * Perform an HTTP health check against the daemon's `/healthz` endpoint.
+ * Returns true if the daemon responds with HTTP 200, false otherwise.
+ */
+export async function httpHealthCheck(
   port: number,
-  endpoint: HttpProbeEndpoint,
-  timeoutMs: number,
+  timeoutMs = 1500,
 ): Promise<boolean> {
   try {
-    const url = `${buildDaemonUrl(port)}/${endpoint}`;
+    const url = `${buildDaemonUrl(port)}/healthz`;
     const response = await loopbackSafeFetch(url, {
       signal: AbortSignal.timeout(timeoutMs),
     });
@@ -26,118 +27,21 @@ async function httpProbe(
 }
 
 /**
- * Perform an HTTP health check against the daemon's `/healthz` endpoint.
- * Returns true if the daemon responds with HTTP 200, false otherwise.
- */
-export async function httpHealthCheck(
-  port: number,
-  timeoutMs = 1500,
-): Promise<boolean> {
-  return httpProbe(port, "healthz", timeoutMs);
-}
-
-/**
- * Poll a daemon probe endpoint until it responds with 200 or the timeout is
- * reached.
+ * Poll the daemon's `/healthz` endpoint until it responds with 200 or the
+ * timeout is reached.
  *
- * Returns true if the daemon became ready within the timeout, false otherwise.
+ * Returns true if the daemon became healthy within the timeout, false otherwise.
  */
 export async function waitForDaemonReady(
   port: number,
   timeoutMs = 60000,
-  endpoint: HttpProbeEndpoint = "healthz",
 ): Promise<boolean> {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
-    if (await httpProbe(port, endpoint, 1500)) {
+    if (await httpHealthCheck(port)) {
       return true;
     }
     await new Promise((r) => setTimeout(r, 250));
   }
   return false;
 }
-
-/**
- * Migration-aware daemon readiness, derived from the `/readyz` BODY rather
- * than its status code. The status code is the k8s contract — 200 while
- * migrations run so the pod stays in service, 503 only on migration failure —
- * so `response.ok` alone cannot distinguish "ready" from "still migrating".
- */
-export type DaemonReadiness = "ready" | "migrating" | "failed" | "unreachable";
-
-/**
- * Classify a `/readyz` response (daemon-direct or proxied through the
- * gateway, which forwards the assistant's readiness body). Shared by the
- * local daemon probe and the docker upgrade/hatch readiness waits so there is
- * exactly one reader of the readiness wire shape.
- *
- * Any HTTP-answered response proves the daemon is alive, so a non-ready
- * answer without a failed-migrations body classifies as "migrating" — this
- * covers legacy daemons whose strict `/readyz` returns 503 with a `notReady`
- * body throughout startup. "unreachable" is reserved for the no-answer case
- * (the caller's fetch threw).
- */
-export function classifyReadyzResponse(
-  ok: boolean,
-  body: unknown,
-): Exclude<DaemonReadiness, "unreachable"> {
-  const readiness = body as {
-    ready?: boolean;
-    dbMigrations?: { state?: string };
-  } | null;
-  if (readiness?.dbMigrations?.state === "failed") return "failed";
-  // A 200 with no explicit `ready: false` counts as ready — this also
-  // covers daemons that predate the migration-state body.
-  if (ok && readiness?.ready !== false) return "ready";
-  return "migrating";
-}
-
-/** Single `/readyz` probe, classified from the response body. */
-export async function probeDaemonReadiness(
-  port: number,
-  timeoutMs = 1500,
-): Promise<DaemonReadiness> {
-  try {
-    const response = await loopbackSafeFetch(`${buildDaemonUrl(port)}/readyz`, {
-      signal: AbortSignal.timeout(timeoutMs),
-    });
-    const body = (await response.json().catch(() => null)) as unknown;
-    return classifyReadyzResponse(response.ok, body);
-  } catch {
-    return "unreachable";
-  }
-}
-
-/**
- * `probeDaemonReadiness` with one retry on a transient timeout: a single
- * probe's 1.5s budget can elapse while a synchronous migration step blocks
- * the daemon's event loop, misreporting a live daemon as unreachable.
- */
-export async function probeDaemonReadinessWithRetry(
-  port: number,
-): Promise<DaemonReadiness> {
-  const first = await probeDaemonReadiness(port);
-  if (first !== "unreachable") {
-    return first;
-  }
-  return probeDaemonReadiness(port);
-}
-
-/**
- * Poll `/readyz` until the daemon is ready, its migrations have terminally
- * FAILED (returned immediately — failed never recovers without a restart, so
- * waiting out the deadline would be pure delay), or `deadlineMs` passes.
- * Returns the last observed readiness.
- */
-export async function waitForDaemonMigrationsReady(
-  port: number,
-  deadlineMs: number,
-): Promise<DaemonReadiness> {
-  let last: DaemonReadiness = "unreachable";
-  for (;;) {
-    last = await probeDaemonReadiness(port);
-    if (last === "ready" || last === "failed") return last;
-    if (Date.now() >= deadlineMs) return last;
-    await new Promise((r) => setTimeout(r, 250));
-  }
-}

package/src/lib/local.ts

@@ -18,17 +18,9 @@ import {
   type LocalInstanceResources,
 } from "./assistant-config.js";
 import { GATEWAY_PORT } from "./constants.js";
-import {
-  type DaemonReadiness,
-  httpHealthCheck,
-  probeDaemonReadiness,
-  probeDaemonReadinessWithRetry,
-  waitForDaemonMigrationsReady,
-  waitForDaemonReady,
-} from "./http-client.js";
+import { httpHealthCheck, waitForDaemonReady } from "./http-client.js";
 import { stopIngressNginx } from "./nginx-ingress.js";
 import {
-  type ProcessState,
   resolveProcessState,
   stopProcess,
   stopProcessByPidFile,
@@ -573,55 +565,32 @@ function applyDaemonEnvOverrides(
     env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH =
       options.defaultWorkspaceConfigPath;
   }
-  // Pin the daemon to the exact socket the sibling binds so the two agree
-  // regardless of any stale CES_LOCAL_SOCKET inherited from the parent
-  // environment. The assistant connects to the sibling instead of spawning
-  // its own CES.
-  env.CES_STANDALONE = "1";
-  env.CES_LOCAL_SOCKET = resolveCesSocketPath(resources);
+  // When the CLI launches CES as a sibling (CES_STANDALONE), pin the daemon to
+  // the exact socket the sibling binds so the two agree regardless of any stale
+  // CES_LOCAL_SOCKET inherited from the parent environment. The assistant then
+  // connects to the sibling instead of spawning its own CES.
+  if (isCesSiblingOptIn()) {
+    env.CES_STANDALONE = "1";
+    env.CES_LOCAL_SOCKET = resolveCesSocketPath(resources);
+  }
   applyIpcSocketDirOverride(env);
 }
 
-function logDaemonReadiness(readiness: DaemonReadiness): void {
-  switch (readiness) {
-    case "ready":
-      console.log("   Assistant ready\n");
-      break;
-    case "migrating":
-      console.log(
-        "   Assistant is up — database migrations still running; DB-backed commands return 503 until they finish\n",
-      );
-      break;
-    case "failed":
-      console.log(
-        "   ⚠️  Assistant database migrations FAILED — DB-backed commands return 503 until the assistant is restarted\n",
-      );
-      break;
-    default:
-      console.log(
-        "   ⚠️  Assistant did not become ready within 60s — continuing anyway\n",
-      );
+function logDaemonReadiness(ready: boolean): void {
+  if (ready) {
+    console.log("   Assistant ready\n");
+  } else {
+    console.log(
+      "   ⚠️  Assistant did not become ready within 60s — continuing anyway\n",
+    );
   }
 }
 
-function logAssistantAlreadyRunning(
-  pid: number,
-  status: ProcessState["status"],
-): void {
-  const suffix =
-    status === "migration_failed"
-      ? " but its database migrations failed — restart to recover"
-      : status === "unready"
-        ? " — database migrations still running"
-        : "";
-  console.log(`   Assistant already running (pid ${pid})${suffix}\n`);
-}
-
 async function startDaemonFromSource(
   assistantIndex: string,
   resources: LocalInstanceResources,
   options?: DaemonStartOptions,
-): Promise<boolean> {
+): Promise<void> {
   const foreground = options?.foreground ?? false;
   const daemonMainPath = resolveDaemonMainPath(assistantIndex);
 
@@ -631,21 +600,19 @@ async function startDaemonFromSource(
   mkdirSync(dirname(pidFile), { recursive: true });
 
   // --- Lifecycle guard: prevent split-brain daemon state ---
-  if (await awaitStartingSentinel(pidFile, resources.daemonPort)) return false;
+  if (await awaitStartingSentinel(pidFile, resources.daemonPort)) return;
 
   const daemonState = await resolveProcessState(
     pidFile,
     resources.daemonPort,
     "Assistant",
-    60_000,
-    "readyz",
   );
-  if (daemonState.status !== "needs_start") {
-    logAssistantAlreadyRunning(daemonState.pid, daemonState.status);
-    return false;
+  if (daemonState.status === "healthy") {
+    console.log(`   Assistant already running (pid ${daemonState.pid})\n`);
+    return;
   }
 
-  if (await checkOrphanedDaemon(pidFile, resources.daemonPort)) return false;
+  if (await checkOrphanedDaemon(pidFile, resources.daemonPort)) return;
 
   const env: Record<string, string | undefined> = {
     ...process.env,
@@ -686,7 +653,6 @@ async function startDaemonFromSource(
       unlinkSync(pidFile);
     } catch {}
   }
-  return true;
 }
 
 // NOTE: startDaemonWatchFromSource() is the CLI-side watch-mode daemon
@@ -697,7 +663,7 @@ async function startDaemonWatchFromSource(
   assistantIndex: string,
   resources: LocalInstanceResources,
   options?: DaemonStartOptions,
-): Promise<boolean> {
+): Promise<void> {
   const mainPath = resolveDaemonMainPath(assistantIndex);
   if (!existsSync(mainPath)) {
     throw new Error(`Daemon main.ts not found at ${mainPath}`);
@@ -707,21 +673,19 @@ async function startDaemonWatchFromSource(
   mkdirSync(dirname(pidFile), { recursive: true });
 
   // --- Lifecycle guard: prevent split-brain daemon state ---
-  if (await awaitStartingSentinel(pidFile, resources.daemonPort)) return false;
+  if (await awaitStartingSentinel(pidFile, resources.daemonPort)) return;
 
   const daemonState = await resolveProcessState(
     pidFile,
     resources.daemonPort,
     "Assistant",
-    60_000,
-    "readyz",
   );
-  if (daemonState.status !== "needs_start") {
-    logAssistantAlreadyRunning(daemonState.pid, daemonState.status);
-    return false;
+  if (daemonState.status === "healthy") {
+    console.log(`   Assistant already running (pid ${daemonState.pid})\n`);
+    return;
   }
 
-  if (await checkOrphanedDaemon(pidFile, resources.daemonPort)) return false;
+  if (await checkOrphanedDaemon(pidFile, resources.daemonPort)) return;
 
   const env: Record<string, string | undefined> = {
     ...process.env,
@@ -755,7 +719,6 @@ async function startDaemonWatchFromSource(
   }
 
   console.log("   Assistant started in watch mode (bun --watch)");
-  return true;
 }
 
 function resolveGatewayDir(resources?: LocalInstanceResources): string {
@@ -848,9 +811,19 @@ function resolveCesSocketPath(resources?: LocalInstanceResources): string {
 }
 
 /**
- * Launch the local CES sibling over a Unix socket. The sibling model is now
- * the default topology for local (non-containerized) instances, matching how
- * containerized homes already run CES.
+ * Whether the CLI should launch CES as an independent sibling process instead
+ * of leaving the assistant to spawn it as an stdio child. Temporary opt-in
+ * (`CES_STANDALONE=1`) while local CES converges onto the sibling model that
+ * containerized homes already use.
+ */
+function isCesSiblingOptIn(): boolean {
+  return process.env.CES_STANDALONE === "1";
+}
+
+/**
+ * Launch the local CES sibling over a Unix socket (opted into via
+ * `CES_STANDALONE=1`). No-op unless the opt-in is set, in which case the
+ * assistant continues to spawn CES itself as today.
  *
  * The sibling runs with `CES_STANDALONE=1` so its lifecycle is anchored to
  * SIGTERM rather than stdin EOF, mirroring the gateway: a CLI-owned process
@@ -861,6 +834,8 @@ export async function startCes(
   watch: boolean = false,
   resources?: LocalInstanceResources,
 ): Promise<void> {
+  if (!isCesSiblingOptIn()) return;
+
   const vellumDir = resources
     ? join(resources.instanceDir, ".vellum")
     : join(homedir(), ".vellum");
@@ -1021,14 +996,8 @@ async function awaitStartingSentinel(
   }
 
   console.log("   Assistant is starting — waiting for it to become ready...");
-  const readiness = await waitForDaemonMigrationsReady(
-    daemonPort,
-    Date.now() + 60000,
-  );
-  if (readiness !== "unreachable") {
-    // The daemon exists and is answering — migrating and failed states must
-    // NOT fall through to a second spawn (split-brain). Report honestly.
-    logDaemonReadiness(readiness);
+  if (await waitForDaemonReady(daemonPort, 60000)) {
+    console.log("   Assistant is ready\n");
     return true;
   }
   try {
@@ -1295,20 +1264,8 @@ export async function startLocalDaemon(
     : undefined;
   if (runtimeAssistantIndex) {
     console.log("🔨 Starting local assistant runtime...");
-    // Wait for readiness only after an actual spawn — an attach to an
-    // already-running daemon was classified and logged inside
-    // startDaemonFromSource, and re-waiting would just block on a migration
-    // the user was already told about.
-    if (
-      await startDaemonFromSource(runtimeAssistantIndex, resources, options)
-    ) {
-      logDaemonReadiness(
-        await waitForDaemonMigrationsReady(
-          resources.daemonPort,
-          Date.now() + 60000,
-        ),
-      );
-    }
+    await startDaemonFromSource(runtimeAssistantIndex, resources, options);
+    logDaemonReadiness(await waitForDaemonReady(resources.daemonPort, 60000));
     return;
   }
 
@@ -1334,22 +1291,15 @@ export async function startLocalDaemon(
       pidFile,
       resources.daemonPort,
       "Assistant",
-      60_000,
-      "readyz",
     );
-    const daemonAlive = daemonState.status !== "needs_start";
+    const daemonAlive = daemonState.status === "healthy";
     if (daemonAlive) {
-      logAssistantAlreadyRunning(daemonState.pid, daemonState.status);
+      console.log(`   Assistant already running (pid ${daemonState.pid})\n`);
     }
 
     if (!daemonAlive) {
       if (await checkOrphanedDaemon(pidFile, resources.daemonPort)) {
         ensureBunInstalled();
-        // The orphan already answers health checks — a readiness probe
-        // classifies it without blocking on an in-flight migration.
-        logDaemonReadiness(
-          await probeDaemonReadinessWithRetry(resources.daemonPort),
-        );
         return;
       }
 
@@ -1450,56 +1400,29 @@ export async function startLocalDaemon(
     }
 
     // Wait for daemon to respond on HTTP (up to 60s — fresh installs
-    // may need 30-60s for Qdrant download, migrations, and first-time init).
-    // "migrating" and "failed" both mean the daemon is up and answering, so
-    // they don't trigger the source fallback (a restart against the same DB
-    // would reproduce the same migration state).
-    //
-    // Runs only after a fresh spawn: an attached daemon was already
-    // classified and logged by resolveProcessState above, and re-waiting on
-    // its in-flight migration would just double the reported diagnosis.
-    if (!daemonAlive) {
-      let readiness = await waitForDaemonMigrationsReady(
-        resources.daemonPort,
-        Date.now() + 60000,
-      );
-      const daemonHealthy =
-        readiness !== "unreachable" ||
-        (await httpHealthCheck(resources.daemonPort));
-
-      // Dev fallback: if the bundled daemon did not become healthy in time,
-      // fall back to source daemon startup so local source runs still work.
-      if (!daemonHealthy) {
-        const assistantIndex = resolveAssistantIndexPath(resources);
-        if (assistantIndex) {
-          console.log(
-            "   Bundled assistant not healthy after 60s — falling back to source assistant...",
-          );
-          // Kill the bundled daemon to avoid two processes competing for the same port
-          await stopProcessByPidFile(pidFile, "bundled daemon");
-          if (watch) {
-            await startDaemonWatchFromSource(
-              assistantIndex,
-              resources,
-              options,
-            );
-          } else {
-            await startDaemonFromSource(assistantIndex, resources, options);
-          }
-          readiness = await waitForDaemonMigrationsReady(
-            resources.daemonPort,
-            Date.now() + 60000,
-          );
+    // may need 30-60s for Qdrant download, migrations, and first-time init)
+    let daemonReady = await waitForDaemonReady(resources.daemonPort, 60000);
+
+    // Dev fallback: if the bundled daemon did not become ready in time,
+    // fall back to source daemon startup so local source runs still work.
+    if (!daemonReady) {
+      const assistantIndex = resolveAssistantIndexPath(resources);
+      if (assistantIndex) {
+        console.log(
+          "   Bundled assistant not ready after 60s — falling back to source assistant...",
+        );
+        // Kill the bundled daemon to avoid two processes competing for the same port
+        await stopProcessByPidFile(pidFile, "bundled daemon");
+        if (watch) {
+          await startDaemonWatchFromSource(assistantIndex, resources, options);
+        } else {
+          await startDaemonFromSource(assistantIndex, resources, options);
         }
-      } else if (readiness === "unreachable") {
-        // The health check just passed, so the readyz probes were the flaky
-        // part — re-probe once so the log reports the daemon's real state
-        // instead of "did not become ready".
-        readiness = await probeDaemonReadiness(resources.daemonPort);
+        daemonReady = await waitForDaemonReady(resources.daemonPort, 60000);
       }
-
-      logDaemonReadiness(readiness);
     }
+
+    logDaemonReadiness(daemonReady);
   } else {
     console.log("🔨 Starting local assistant...");
 
@@ -1510,18 +1433,12 @@ export async function startLocalDaemon(
           "  Ensure the daemon binary is bundled alongside the CLI, or run from the source tree.",
       );
     }
-    const spawned = watch
-      ? await startDaemonWatchFromSource(assistantIndex, resources, options)
-      : await startDaemonFromSource(assistantIndex, resources, options);
-    // Attach case was classified and logged inside the start function.
-    if (spawned) {
-      logDaemonReadiness(
-        await waitForDaemonMigrationsReady(
-          resources.daemonPort,
-          Date.now() + 60000,
-        ),
-      );
+    if (watch) {
+      await startDaemonWatchFromSource(assistantIndex, resources, options);
+    } else {
+      await startDaemonFromSource(assistantIndex, resources, options);
     }
+    logDaemonReadiness(await waitForDaemonReady(resources.daemonPort, 60000));
   }
 }