svamp-cli 0.1.56 → 0.1.58

package/dist/{run-sALUrMgm.mjs → run-CtrH9ayy.mjs}

@@ -1,7 +1,7 @@
-import os__default from 'os';
-import fs from 'fs/promises';
+import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import os__default from 'os';
+import fs, { mkdir as mkdir$1, readdir, readFile, writeFile, unlink } from 'fs/promises';
 import { readFileSync as readFileSync$1, mkdirSync, writeFileSync, existsSync as existsSync$1, copyFileSync, unlinkSync, watch, rmdirSync } from 'fs';
-import { join, dirname, resolve, basename } from 'path';
+import path, { join, dirname, resolve, basename } from 'path';
 import { fileURLToPath } from 'url';
 import { spawn as spawn$1 } from 'child_process';
 import { randomUUID as randomUUID$1 } from 'crypto';
@@ -632,6 +632,96 @@ async function registerMachineService(server, machineId, metadata, daemonState,
           return { success: false, entries: [], path: targetPath, error: err.message };
         }
       },
+      // ── Process supervisor RPC ────────────────────────────────────────
+      /** List all supervised processes. */
+      processList: async (params = {}, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "view");
+        if (!handlers.supervisor) return [];
+        return handlers.supervisor.list();
+      },
+      /** Add and start a new supervised process. */
+      processAdd: async (params, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "interact");
+        if (!handlers.supervisor) throw new Error("Process supervisor not available");
+        return handlers.supervisor.add(params.spec);
+      },
+      /**
+       * Apply a spec declaratively (idempotent, like kubectl apply).
+       * Returns { action: 'created'|'updated'|'no-change', info: ProcessInfo }
+       */
+      processApply: async (params, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "interact");
+        if (!handlers.supervisor) throw new Error("Process supervisor not available");
+        return handlers.supervisor.apply(params.spec);
+      },
+      /**
+       * Partially update a process spec and restart it.
+       * Returns updated ProcessInfo.
+       */
+      processUpdate: async (params, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "interact");
+        if (!handlers.supervisor) throw new Error("Process supervisor not available");
+        return handlers.supervisor.update(params.idOrName, params.spec);
+      },
+      /** Get a single process by id or name. */
+      processGet: async (params, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "view");
+        if (!handlers.supervisor) return void 0;
+        return handlers.supervisor.get(params.idOrName);
+      },
+      /** Start a stopped/failed process. */
+      processStart: async (params, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "interact");
+        if (!handlers.supervisor) throw new Error("Process supervisor not available");
+        await handlers.supervisor.start(params.idOrName);
+      },
+      /** Stop a running process (keeps it in supervision). */
+      processStop: async (params, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "interact");
+        if (!handlers.supervisor) throw new Error("Process supervisor not available");
+        await handlers.supervisor.stop(params.idOrName);
+      },
+      /** Restart a process. */
+      processRestart: async (params, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "interact");
+        if (!handlers.supervisor) throw new Error("Process supervisor not available");
+        await handlers.supervisor.restart(params.idOrName);
+      },
+      /** Stop and permanently remove a process from supervision. */
+      processRemove: async (params, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "admin");
+        if (!handlers.supervisor) throw new Error("Process supervisor not available");
+        await handlers.supervisor.remove(params.idOrName);
+      },
+      /** Get recent log lines for a process. */
+      processLogs: async (params, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "view");
+        if (!handlers.supervisor) return [];
+        return handlers.supervisor.getLogs(params.idOrName, params.last ?? 50);
+      },
+      // ── Service group management (proxies to agent-sandbox API) ──────────
+      /** List all exposed service groups for this machine's namespace. */
+      serviceList: async (context) => {
+        authorizeRequest(context, currentMetadata.sharing, "view");
+        try {
+          const { listServiceGroups } = await import('./api-Cegey1dh.mjs');
+          return await listServiceGroups();
+        } catch (err) {
+          return [];
+        }
+      },
+      /** Get full details of a single service group (includes backends + health). */
+      serviceGet: async (params, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "view");
+        const { getServiceGroup } = await import('./api-Cegey1dh.mjs');
+        return getServiceGroup(params.name);
+      },
+      /** Delete a service group. */
+      serviceDelete: async (params, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "admin");
+        const { deleteServiceGroup } = await import('./api-Cegey1dh.mjs');
+        return deleteServiceGroup(params.name);
+      },
       // WISE voice — create ephemeral token for OpenAI Realtime API
       wiseCreateEphemeralToken: async (params, context) => {
         authorizeRequest(context, currentMetadata.sharing, "interact");
@@ -3694,6 +3784,442 @@ function sanitizeEnvForSharing(env) {
   return sanitized;
 }
 
+const DEFAULT_PROBE_INTERVAL_S = 10;
+const DEFAULT_PROBE_TIMEOUT_S = 5;
+const DEFAULT_PROBE_FAILURE_THRESHOLD = 3;
+const MAX_LOG_LINES = 300;
+class ProcessSupervisor {
+  entries = /* @__PURE__ */ new Map();
+  persistDir;
+  constructor(persistDir) {
+    this.persistDir = persistDir;
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────────────────
+  /** Must be called once after construction to load persisted specs. */
+  async init() {
+    await mkdir$1(this.persistDir, { recursive: true });
+    await this.loadAll();
+  }
+  /** Stop all managed processes (called on daemon shutdown). */
+  async stopAll() {
+    const ids = Array.from(this.entries.keys());
+    await Promise.all(ids.map((id) => this.stop(id).catch(() => {
+    })));
+  }
+  // ── Public API ────────────────────────────────────────────────────────────
+  /**
+   * Add a new supervised process and start it immediately.
+   * Throws if a process with the same name already exists.
+   */
+  async add(spec) {
+    for (const entry2 of this.entries.values()) {
+      if (entry2.spec.name === spec.name) {
+        throw new Error(`Process '${spec.name}' already exists (id: ${entry2.spec.id}). Use restart or remove first.`);
+      }
+    }
+    const fullSpec = {
+      ...spec,
+      id: randomUUID$1(),
+      createdAt: Date.now()
+    };
+    const entry = this.makeEntry(fullSpec);
+    this.entries.set(fullSpec.id, entry);
+    await this.persistSpec(fullSpec);
+    await this.startEntry(
+      entry,
+      false
+      /* onRestore */
+    );
+    return this.toInfo(entry);
+  }
+  /** Start a stopped/failed process by id or name. */
+  async start(idOrName) {
+    const entry = this.require(idOrName);
+    if (entry.child && !entry.stopping) throw new Error(`Process '${entry.spec.name}' is already running`);
+    entry.stopping = false;
+    await this.startEntry(entry, false);
+  }
+  /** Stop a running process. Does NOT remove it from supervision. */
+  async stop(idOrName) {
+    const entry = this.require(idOrName);
+    entry.stopping = true;
+    this.clearTimers(entry);
+    if (entry.child) {
+      await this.killChild(entry.child);
+      entry.child = void 0;
+    }
+    entry.state.status = "stopped";
+    entry.state.stoppedAt = Date.now();
+    entry.state.pid = void 0;
+  }
+  /** Restart a process (stop if running, then start again). */
+  async restart(idOrName) {
+    const entry = this.require(idOrName);
+    if (entry.child) {
+      entry.stopping = true;
+      this.clearTimers(entry);
+      await this.killChild(entry.child);
+      entry.child = void 0;
+    }
+    entry.stopping = false;
+    entry.state.restartCount++;
+    await this.startEntry(entry, false);
+  }
+  /** Stop the process and remove it from supervision (deletes persisted spec). */
+  async remove(idOrName) {
+    const entry = this.require(idOrName);
+    const id = entry.spec.id;
+    await this.stop(entry.spec.name);
+    this.entries.delete(id);
+    await this.deleteSpec(id);
+  }
+  /** List all supervised processes. */
+  list() {
+    return Array.from(this.entries.values()).map((e) => this.toInfo(e));
+  }
+  /** Get a single process by id or name. Returns undefined if not found. */
+  get(idOrName) {
+    const entry = this.findByIdOrName(idOrName);
+    return entry ? this.toInfo(entry) : void 0;
+  }
+  /** Return the last N log lines for a process. */
+  getLogs(idOrName, last = 50) {
+    const entry = this.findByIdOrName(idOrName);
+    if (!entry) return [];
+    const buf = entry.logBuffer;
+    return last <= 0 ? [...buf] : buf.slice(-last);
+  }
+  /**
+   * Apply a spec declaratively (idempotent, like `kubectl apply`).
+   *
+   * - If no process with spec.name exists → create and start (action: 'created')
+   * - If exists and spec is unchanged → no-op (action: 'no-change')
+   * - If exists and spec changed → update config + restart (action: 'updated')
+   */
+  async apply(spec) {
+    const existing = Array.from(this.entries.values()).find((e) => e.spec.name === spec.name);
+    if (!existing) {
+      const info = await this.add(spec);
+      return { action: "created", info };
+    }
+    if (this.specsEqual(existing.spec, spec)) {
+      return { action: "no-change", info: this.toInfo(existing) };
+    }
+    const updatedSpec = {
+      ...spec,
+      id: existing.spec.id,
+      createdAt: existing.spec.createdAt
+      // preserve original creation time
+    };
+    existing.spec = updatedSpec;
+    await this.persistSpec(updatedSpec);
+    existing.stopping = true;
+    this.clearTimers(existing);
+    if (existing.child) {
+      await this.killChild(existing.child);
+      existing.child = void 0;
+    }
+    existing.stopping = false;
+    existing.state.status = "starting";
+    this.spawnProcess(existing);
+    return { action: "updated", info: this.toInfo(existing) };
+  }
+  /**
+   * Update a running process's spec and restart it.
+   * Merges the provided partial spec over the existing spec.
+   */
+  async update(idOrName, partialSpec) {
+    const entry = this.require(idOrName);
+    const updatedSpec = { ...entry.spec, ...partialSpec };
+    entry.spec = updatedSpec;
+    await this.persistSpec(updatedSpec);
+    entry.stopping = true;
+    this.clearTimers(entry);
+    if (entry.child) {
+      await this.killChild(entry.child);
+      entry.child = void 0;
+    }
+    entry.stopping = false;
+    entry.state.status = "starting";
+    this.spawnProcess(entry);
+    return this.toInfo(entry);
+  }
+  // ── Spec equality ─────────────────────────────────────────────────────────
+  /** Compare two specs for equality (ignoring id, createdAt, and runtime state). */
+  specsEqual(a, b) {
+    const pick = (s) => ({
+      name: s.name,
+      command: s.command,
+      args: JSON.stringify(s.args),
+      workdir: s.workdir,
+      env: JSON.stringify(s.env ?? {}),
+      keepAlive: s.keepAlive,
+      maxRestarts: s.maxRestarts,
+      restartDelay: s.restartDelay,
+      ttl: s.ttl,
+      probe: JSON.stringify(s.probe ?? null),
+      serviceGroup: s.serviceGroup,
+      ports: JSON.stringify(s.ports ?? [])
+    });
+    return JSON.stringify(pick(a)) === JSON.stringify(pick(b));
+  }
+  // ── Persistence ───────────────────────────────────────────────────────────
+  async loadAll() {
+    let files;
+    try {
+      files = await readdir(this.persistDir);
+    } catch {
+      return;
+    }
+    let loaded = 0;
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const raw = await readFile(path.join(this.persistDir, file), "utf-8");
+        const spec = JSON.parse(raw);
+        const entry = this.makeEntry(spec);
+        this.entries.set(spec.id, entry);
+        if (spec.keepAlive) {
+          await this.startEntry(
+            entry,
+            true
+            /* onRestore */
+          );
+        }
+        loaded++;
+      } catch (err) {
+        console.error(`[SUPERVISOR] Failed to load process spec ${file}: ${err.message}`);
+      }
+    }
+    if (loaded > 0) {
+      console.log(`[SUPERVISOR] Restored ${loaded} supervised process(es)`);
+    }
+  }
+  async persistSpec(spec) {
+    const filePath = path.join(this.persistDir, `${spec.id}.json`);
+    await writeFile(filePath, JSON.stringify(spec, null, 2), "utf-8");
+  }
+  async deleteSpec(id) {
+    try {
+      await unlink(path.join(this.persistDir, `${id}.json`));
+    } catch {
+    }
+  }
+  // ── Internal helpers ──────────────────────────────────────────────────────
+  makeEntry(spec) {
+    return {
+      spec,
+      state: {
+        id: spec.id,
+        status: "pending",
+        restartCount: 0,
+        consecutiveProbeFailures: 0
+      },
+      logBuffer: [],
+      stopping: false
+    };
+  }
+  require(idOrName) {
+    const entry = this.findByIdOrName(idOrName);
+    if (!entry) throw new Error(`Process '${idOrName}' not found`);
+    return entry;
+  }
+  findByIdOrName(idOrName) {
+    return this.entries.get(idOrName) ?? Array.from(this.entries.values()).find((e) => e.spec.name === idOrName);
+  }
+  toInfo(entry) {
+    return { spec: entry.spec, state: { ...entry.state } };
+  }
+  // ── Process spawning ──────────────────────────────────────────────────────
+  async startEntry(entry, onRestore) {
+    const { spec } = entry;
+    if (spec.ttl !== void 0 && onRestore) {
+      const elapsedS = (Date.now() - spec.createdAt) / 1e3;
+      if (elapsedS >= spec.ttl) {
+        console.log(`[SUPERVISOR] Process '${spec.name}' TTL expired on restore, removing`);
+        entry.state.status = "expired";
+        this.entries.delete(spec.id);
+        await this.deleteSpec(spec.id);
+        return;
+      }
+    }
+    entry.state.status = "starting";
+    entry.state.pid = void 0;
+    entry.state.startedAt = void 0;
+    entry.state.consecutiveProbeFailures = 0;
+    this.spawnProcess(entry);
+  }
+  spawnProcess(entry) {
+    const { spec, state } = entry;
+    try {
+      const env = { ...process.env, ...spec.env ?? {} };
+      const child = spawn$1(spec.command, spec.args, {
+        cwd: spec.workdir,
+        env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      entry.child = child;
+      state.status = "running";
+      state.pid = child.pid;
+      state.startedAt = Date.now();
+      const appendLog = (chunk) => {
+        for (const line of chunk.toString().split("\n")) {
+          if (!line) continue;
+          entry.logBuffer.push(line);
+          if (entry.logBuffer.length > MAX_LOG_LINES) entry.logBuffer.shift();
+        }
+      };
+      child.stdout?.on("data", appendLog);
+      child.stderr?.on("data", appendLog);
+      child.on("exit", (code, signal) => this.onProcessExit(entry, code, signal));
+      if (spec.probe) this.setupProbe(entry);
+      if (spec.ttl !== void 0) this.setupTTL(entry);
+      console.log(`[SUPERVISOR] Started '${spec.name}' pid=${child.pid}`);
+    } catch (err) {
+      state.status = "failed";
+      state.stoppedAt = Date.now();
+      console.error(`[SUPERVISOR] Failed to spawn '${spec.name}': ${err.message}`);
+    }
+  }
+  onProcessExit(entry, code, signal) {
+    const { spec, state } = entry;
+    entry.child = void 0;
+    state.pid = void 0;
+    state.stoppedAt = Date.now();
+    this.clearTimers(entry);
+    if (entry.stopping) {
+      state.status = "stopped";
+      console.log(`[SUPERVISOR] Process '${spec.name}' stopped (code=${code})`);
+      return;
+    }
+    const crashed = code !== 0 || signal !== null;
+    state.status = crashed ? "failed" : "stopped";
+    console.log(`[SUPERVISOR] Process '${spec.name}' exited (code=${code}, signal=${signal})`);
+    if (!spec.keepAlive) return;
+    if (spec.maxRestarts > 0 && state.restartCount >= spec.maxRestarts) {
+      console.warn(`[SUPERVISOR] Process '${spec.name}' reached max restarts (${spec.maxRestarts}), not restarting`);
+      state.status = "failed";
+      return;
+    }
+    const delayMs = spec.restartDelay * 1e3;
+    console.log(`[SUPERVISOR] Scheduling restart of '${spec.name}' in ${delayMs}ms (restart #${state.restartCount + 1})`);
+    entry.restartTimer = setTimeout(() => {
+      if (entry.stopping) return;
+      state.restartCount++;
+      state.status = "starting";
+      this.spawnProcess(entry);
+    }, delayMs);
+  }
+  // ── Health probes ─────────────────────────────────────────────────────────
+  setupProbe(entry) {
+    const intervalMs = (entry.spec.probe.interval ?? DEFAULT_PROBE_INTERVAL_S) * 1e3;
+    entry.probeTimer = setInterval(() => {
+      this.runHealthCheck(entry).catch(() => {
+      });
+    }, intervalMs);
+  }
+  async runHealthCheck(entry) {
+    if (!entry.child || entry.state.status !== "running") return;
+    const probe = entry.spec.probe;
+    const urlPath = probe.path ?? "/";
+    const timeoutMs = (probe.timeout ?? DEFAULT_PROBE_TIMEOUT_S) * 1e3;
+    const threshold = probe.failureThreshold ?? DEFAULT_PROBE_FAILURE_THRESHOLD;
+    const url = `http://localhost:${probe.port}${urlPath}`;
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
+      let resp;
+      try {
+        resp = await fetch(url, { signal: controller.signal });
+      } finally {
+        clearTimeout(timer);
+      }
+      const ok = resp.ok;
+      entry.state.lastProbe = { ok, timestamp: Date.now(), statusCode: resp.status };
+      if (ok) {
+        entry.state.consecutiveProbeFailures = 0;
+      } else {
+        entry.state.consecutiveProbeFailures++;
+        console.warn(
+          `[SUPERVISOR] Probe FAIL '${entry.spec.name}' HTTP ${resp.status} (${entry.state.consecutiveProbeFailures}/${threshold})`
+        );
+        if (entry.state.consecutiveProbeFailures >= threshold) {
+          await this.triggerProbeRestart(entry);
+        }
+      }
+    } catch (err) {
+      entry.state.lastProbe = { ok: false, timestamp: Date.now(), error: err.message };
+      entry.state.consecutiveProbeFailures++;
+      console.warn(
+        `[SUPERVISOR] Probe ERROR '${entry.spec.name}' ${err.message} (${entry.state.consecutiveProbeFailures}/${threshold})`
+      );
+      if (entry.state.consecutiveProbeFailures >= threshold) {
+        await this.triggerProbeRestart(entry);
+      }
+    }
+  }
+  async triggerProbeRestart(entry) {
+    console.warn(`[SUPERVISOR] Restarting '${entry.spec.name}' due to probe failures`);
+    entry.state.consecutiveProbeFailures = 0;
+    this.clearTimers(entry);
+    try {
+      await this.restart(entry.spec.id);
+    } catch (err) {
+      console.error(`[SUPERVISOR] Probe-triggered restart failed for '${entry.spec.name}': ${err.message}`);
+    }
+  }
+  // ── TTL ───────────────────────────────────────────────────────────────────
+  setupTTL(entry) {
+    const elapsedS = (Date.now() - entry.spec.createdAt) / 1e3;
+    const remainingS = entry.spec.ttl - elapsedS;
+    if (remainingS <= 0) {
+      this.expireProcess(entry);
+      return;
+    }
+    console.log(`[SUPERVISOR] Process '${entry.spec.name}' TTL: expires in ${remainingS.toFixed(0)}s`);
+    entry.ttlTimer = setTimeout(() => this.expireProcess(entry), remainingS * 1e3);
+  }
+  expireProcess(entry) {
+    console.log(`[SUPERVISOR] Process '${entry.spec.name}' TTL expired`);
+    entry.state.status = "expired";
+    entry.stopping = true;
+    const cleanup = async () => {
+      if (entry.child) await this.killChild(entry.child);
+      this.entries.delete(entry.spec.id);
+      await this.deleteSpec(entry.spec.id).catch(() => {
+      });
+    };
+    cleanup().catch((err) => console.error("[SUPERVISOR] TTL cleanup error:", err));
+  }
+  // ── Process kill helper ───────────────────────────────────────────────────
+  killChild(child) {
+    return new Promise((resolve) => {
+      const done = () => resolve();
+      child.once("exit", done);
+      child.kill("SIGTERM");
+      const forceKill = setTimeout(() => {
+        child.kill("SIGKILL");
+      }, 5e3);
+      child.once("exit", () => clearTimeout(forceKill));
+    });
+  }
+  // ── Timer cleanup ─────────────────────────────────────────────────────────
+  clearTimers(entry) {
+    if (entry.probeTimer) {
+      clearInterval(entry.probeTimer);
+      entry.probeTimer = void 0;
+    }
+    if (entry.ttlTimer) {
+      clearTimeout(entry.ttlTimer);
+      entry.ttlTimer = void 0;
+    }
+    if (entry.restartTimer) {
+      clearTimeout(entry.restartTimer);
+      entry.restartTimer = void 0;
+    }
+  }
+}
+
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = dirname(__filename$1);
 function loadEnvFile(path) {
@@ -4444,6 +4970,8 @@ async function startDaemon(options) {
   logger.log(`  Workspace: ${hyphaWorkspace || "(default)"}`);
   logger.log(`  Machine ID: ${machineId}`);
   let server = null;
+  const supervisor = new ProcessSupervisor(join(SVAMP_HOME, "processes"));
+  await supervisor.init();
   try {
     logger.log("Connecting to Hypha server...");
     server = await connectToHypha({
@@ -4461,6 +4989,7 @@ async function startDaemon(options) {
       if (consecutiveHeartbeatFailures > 0) {
         logger.log(`Hypha reconnection successful \u2014 services re-registered (resetting ${consecutiveHeartbeatFailures} failures)`);
         consecutiveHeartbeatFailures = 0;
+        lastReconnectAt = Date.now();
       }
     });
     const pidToTrackedSession = /* @__PURE__ */ new Map();
@@ -6025,7 +6554,8 @@ The automated loop has finished. Review the progress above and let me know if yo
         stopSession,
         restartSession,
         requestShutdown: () => requestShutdown("hypha-app"),
-        getTrackedSessions: getCurrentChildren
+        getTrackedSessions: getCurrentChildren,
+        supervisor
       }
     );
     logger.log(`Machine service registered: svamp-machine-${machineId}`);
@@ -6206,7 +6736,9 @@ The automated loop has finished. Review the progress above and let me know if yo
     const HEARTBEAT_INTERVAL_MS = 1e4;
     const PING_TIMEOUT_MS = 5e3;
     const MAX_FAILURES = 60;
+    const POST_RECONNECT_GRACE_MS = 2e4;
     let heartbeatRunning = false;
+    let lastReconnectAt = 0;
     const heartbeatInterval = setInterval(async () => {
       if (heartbeatRunning) return;
       heartbeatRunning = true;
@@ -6222,20 +6754,14 @@ The automated loop has finished. Review the progress above and let me know if yo
         try {
           const installedVersion = readPackageVersion();
           if (installedVersion !== "unknown" && installedVersion !== DAEMON_VERSION) {
-            logger.log(`svamp-cli version changed on disk: ${DAEMON_VERSION} \u2192 ${installedVersion}. Self-restarting...`);
             const supervised2 = process.env.SVAMP_SUPERVISED === "1";
-            if (!supervised2) {
-              cleanupDaemonStateFile();
-              const { spawn: spawnSelf } = await import('child_process');
-              spawnSelf(process.argv[0], process.argv.slice(1), {
-                detached: true,
-                stdio: "ignore",
-                env: process.env
-              }).unref();
-              await new Promise((r) => setTimeout(r, 500));
+            if (supervised2) {
+              logger.log(`svamp-cli version changed on disk: ${DAEMON_VERSION} \u2192 ${installedVersion}. Exiting for launchd restart...`);
+              requestShutdown("version-update", `Updated ${DAEMON_VERSION} \u2192 ${installedVersion}`);
+              return;
+            } else {
+              logger.log(`svamp-cli version changed on disk: ${DAEMON_VERSION} \u2192 ${installedVersion}. Run 'svamp daemon stop && svamp daemon start' to apply the update.`);
             }
-            requestShutdown("version-update", `Updated ${DAEMON_VERSION} \u2192 ${installedVersion}`);
-            return;
           }
         } catch {
         }
@@ -6252,36 +6778,65 @@ The automated loop has finished. Review the progress above and let me know if yo
             }
           }
         }
-        try {
-          await Promise.race([
-            server.echo("ping"),
-            new Promise((_, reject) => setTimeout(() => reject(new Error("Ping timed out")), PING_TIMEOUT_MS))
-          ]);
-          if (consecutiveHeartbeatFailures > 0) {
-            logger.log(`Heartbeat recovered after ${consecutiveHeartbeatFailures} failures`);
-            consecutiveHeartbeatFailures = 0;
-          }
-        } catch (err) {
-          consecutiveHeartbeatFailures++;
-          if (consecutiveHeartbeatFailures === 1) {
-            logger.log(`Ping failed: ${err.message}`);
-          } else if (consecutiveHeartbeatFailures % 6 === 0) {
-            logger.log(`Connection down for ${consecutiveHeartbeatFailures * HEARTBEAT_INTERVAL_MS / 1e3}s (${consecutiveHeartbeatFailures}/${MAX_FAILURES})`);
-          }
-          if (consecutiveHeartbeatFailures === 1 || consecutiveHeartbeatFailures % 3 === 0) {
-            const conn = server.rpc?._connection;
-            const ws = conn?._websocket;
-            if (ws?.readyState === 1) {
-              logger.log("Force-closing stale WebSocket to trigger reconnection");
-              try {
-                ws.close(4e3, "Stale connection");
-              } catch {
+        const inGrace = lastReconnectAt > 0 && Date.now() - lastReconnectAt < POST_RECONNECT_GRACE_MS;
+        if (!inGrace) {
+          try {
+            const pingStart = Date.now();
+            await new Promise((resolve2, reject) => {
+              const conn = server.rpc?._connection;
+              const ws = conn?._websocket;
+              if (!ws || ws.readyState !== 1) {
+                reject(new Error("WebSocket not open"));
+                return;
               }
+              const timer = setTimeout(() => {
+                ws.removeEventListener("message", onMsg);
+                reject(new Error("Ping timed out"));
+              }, PING_TIMEOUT_MS);
+              const onMsg = (event) => {
+                try {
+                  const d = typeof event.data === "string" ? JSON.parse(event.data) : null;
+                  if (d?.type === "pong") {
+                    clearTimeout(timer);
+                    ws.removeEventListener("message", onMsg);
+                    resolve2();
+                  }
+                } catch {
+                }
+              };
+              ws.addEventListener("message", onMsg);
+              ws.send(JSON.stringify({ type: "ping" }));
+            });
+            const pingMs = Date.now() - pingStart;
+            if (pingMs > 1e3) {
+              logger.log(`Slow ping: ${pingMs}ms`);
+            }
+            if (consecutiveHeartbeatFailures > 0) {
+              logger.log(`Heartbeat recovered after ${consecutiveHeartbeatFailures} failures`);
+              consecutiveHeartbeatFailures = 0;
+            }
+          } catch (err) {
+            consecutiveHeartbeatFailures++;
+            if (consecutiveHeartbeatFailures === 1) {
+              logger.log(`Ping failed: ${err.message}`);
+            } else if (consecutiveHeartbeatFailures % 6 === 0) {
+              logger.log(`Connection down for ${consecutiveHeartbeatFailures * HEARTBEAT_INTERVAL_MS / 1e3}s (${consecutiveHeartbeatFailures}/${MAX_FAILURES})`);
+            }
+            if (consecutiveHeartbeatFailures === 1 || consecutiveHeartbeatFailures % 3 === 0) {
+              const conn = server.rpc?._connection;
+              const ws = conn?._websocket;
+              if (ws?.readyState === 1) {
+                logger.log("Force-closing stale WebSocket to trigger reconnection");
+                try {
+                  ws.close(4e3, "Stale connection");
+                } catch {
+                }
+              }
+            }
+            if (consecutiveHeartbeatFailures >= MAX_FAILURES) {
+              logger.log(`Heartbeat failed ${MAX_FAILURES} times. Shutting down.`);
+              requestShutdown("heartbeat-timeout", err.message);
             }
-          }
-          if (consecutiveHeartbeatFailures >= MAX_FAILURES) {
-            logger.log(`Heartbeat failed ${MAX_FAILURES} times. Shutting down.`);
-            requestShutdown("heartbeat-timeout", err.message);
           }
         }
       } finally {
@@ -6353,6 +6908,8 @@ The automated loop has finished. Review the progress above and let me know if yo
         await debugService.disconnect();
       } catch {
       }
+      await supervisor.stopAll().catch(() => {
+      });
       artifactSync.destroy();
       try {
         await server.disconnect();