@slock-ai/computer 0.0.15 → 0.0.16

package/dist/index.js

@@ -29737,7 +29737,7 @@ var ComputerAttachClient = class {
    * over the machine. On success the server marks the machine row migrated
    * and mints a fresh `sk_computer_*`. The raw legacy key MUST NOT be
    * persisted by the caller — only the freshly-minted sk_computer_* lands
-   * in attachment.json.
+   * in runner.state.json.
    */
   async adoptLegacy(legacyApiKey, name) {
     const res = await (0, import_undici.fetch)(this.url("/api/computer/adopt-legacy"), {
@@ -29877,13 +29877,13 @@ function serverDir(slockHome, serverId) {
   return path2.join(serversDir(slockHome), assertValidServerId(serverId));
 }
 function serverAttachmentPath(slockHome, serverId) {
-  return path2.join(serverDir(slockHome, serverId), "attachment.json");
+  return path2.join(serverDir(slockHome, serverId), "runner.state.json");
 }
-function serverDaemonPidPath(slockHome, serverId) {
-  return path2.join(serverDir(slockHome, serverId), "daemon.pid");
+function serverRunnerPidPath(slockHome, serverId) {
+  return path2.join(serverDir(slockHome, serverId), "server-runner.pid");
 }
-function serverDaemonLogPath(slockHome, serverId) {
-  return path2.join(serverDir(slockHome, serverId), "daemon.log");
+function serverRunnerLogPath(slockHome, serverId) {
+  return path2.join(serverDir(slockHome, serverId), "server-runner.log");
 }
 function serverManagedFlagPath(slockHome, serverId) {
   return path2.join(serverDir(slockHome, serverId), "managed.flag");
@@ -29891,17 +29891,33 @@ function serverManagedFlagPath(slockHome, serverId) {
 function serverHealthPath(slockHome, serverId) {
   return path2.join(serverDir(slockHome, serverId), "health.json");
 }
+function serviceRunDir(slockHome) {
+  return path2.join(computerDir(slockHome), "run");
+}
 function serviceStatePath(slockHome) {
-  return path2.join(computerDir(slockHome), "service.state.json");
+  return path2.join(serviceRunDir(slockHome), "service.state.json");
+}
+function servicePidPath(slockHome) {
+  return path2.join(serviceRunDir(slockHome), "service.pid");
+}
+function legacyServicePidPath(slockHome) {
+  return path2.join(computerDir(slockHome), "service.pid");
 }
-function supervisorPidPath(slockHome) {
+function legacySupervisorPidPath(slockHome) {
   return path2.join(computerDir(slockHome), "supervisor.pid");
 }
-function supervisorLogPath(slockHome) {
-  return path2.join(computerDir(slockHome), "supervisor.log");
+function servicePidReadFallback(slockHome) {
+  return [
+    servicePidPath(slockHome),
+    legacyServicePidPath(slockHome),
+    legacySupervisorPidPath(slockHome)
+  ];
+}
+function serviceLogPath(slockHome) {
+  return path2.join(serviceRunDir(slockHome), "service.log");
 }
-function supervisorVersionPath(slockHome) {
-  return path2.join(computerDir(slockHome), "supervisor-version.json");
+function serviceVersionPath(slockHome) {
+  return path2.join(computerDir(slockHome), "service-version.json");
 }
 var HOSTNAME_SUFFIXES = [
   ".fritz.box",
@@ -30799,7 +30815,7 @@ async function appendAdoptionLog(slockHome, line) {
   }
 }
 
-// src/supervisor.ts
+// src/service.ts
 init_esm_shims();
 import { spawn as spawn2 } from "child_process";
 import { mkdir as mkdir8, readFile as readFile7, writeFile as writeFile7, open, rename as rename2 } from "fs/promises";
@@ -30869,12 +30885,12 @@ async function cleanupStalePidfile(pidfilePath) {
 }
 async function cleanupAllStalePidfiles(slockHome) {
   const cleaned = [];
-  if (await cleanupStalePidfile(supervisorPidPath(slockHome))) {
-    cleaned.push(supervisorPidPath(slockHome));
+  if (await cleanupStalePidfile(servicePidPath(slockHome))) {
+    cleaned.push(servicePidPath(slockHome));
   }
   const attached = await listAttachedServerIds(slockHome);
   for (const sid of attached) {
-    const p = serverDaemonPidPath(slockHome, sid);
+    const p = serverRunnerPidPath(slockHome, sid);
     if (await cleanupStalePidfile(p)) cleaned.push(p);
   }
   return cleaned;
@@ -30919,10 +30935,10 @@ async function cleanupOrphanProcesses(slockHome, psSpawn) {
   const managed = new Set(await listManagedServerIds(slockHome));
   const signaled = [];
   const knownPids = /* @__PURE__ */ new Set();
-  const supPid = await readPidfileAt(supervisorPidPath(slockHome));
+  const supPid = await readPidfileAt(servicePidPath(slockHome));
   if (supPid !== null) knownPids.add(supPid);
   for (const sid of managed) {
-    const pid = await readPidfileAt(serverDaemonPidPath(slockHome, sid));
+    const pid = await readPidfileAt(serverRunnerPidPath(slockHome, sid));
     if (pid !== null) knownPids.add(pid);
   }
   if (supPid === null) return signaled;
@@ -31156,7 +31172,7 @@ async function emitRunnerStateTransition(slockHome, serverId, fromState, toState
     trigger
   };
   try {
-    const path3 = supervisorLogPath(slockHome);
+    const path3 = serviceLogPath(slockHome);
     await mkdir7(dirname7(path3), { recursive: true });
     await appendFile2(path3, JSON.stringify(entry) + "\n");
   } catch {
@@ -31165,6 +31181,50 @@ async function emitRunnerStateTransition(slockHome, serverId, fromState, toState
 
 // src/services/start.ts
 init_esm_shims();
+
+// src/internal/service-pid-fallback.ts
+init_esm_shims();
+async function findLiveServicePid(slockHome, deps = {}) {
+  const readPidfile = deps.readPidfile ?? readPidfileAt;
+  const isAlive = deps.isProcessAlive ?? isProcessAlive2;
+  const clearStale = deps.clearPidfile ?? clearPidfileAt;
+  return walkFallback(slockHome, readPidfile, isAlive, clearStale);
+}
+async function findLiveServicePidReadOnly(slockHome, deps = {}) {
+  const readPidfile = deps.readPidfile ?? readPidfileAt;
+  const isAlive = deps.isProcessAlive ?? isProcessAlive2;
+  return walkFallback(slockHome, readPidfile, isAlive, async () => void 0);
+}
+async function walkFallback(slockHome, readPidfile, isAlive, clearStale) {
+  const candidates = servicePidReadFallback(slockHome);
+  let firstStalePidfile = null;
+  let firstStalePid = null;
+  for (const candidate of candidates) {
+    const candidatePid = await readPidfile(candidate);
+    if (candidatePid === null) continue;
+    if (isAlive(candidatePid)) {
+      return {
+        pid: candidatePid,
+        pidfilePath: candidate,
+        firstStalePidfile,
+        firstStalePid
+      };
+    }
+    await clearStale(candidate);
+    if (firstStalePidfile === null) {
+      firstStalePidfile = candidate;
+      firstStalePid = candidatePid;
+    }
+  }
+  return {
+    pid: null,
+    pidfilePath: candidates[0],
+    firstStalePidfile,
+    firstStalePid
+  };
+}
+
+// src/services/start.ts
 var START_ENSURE_TIMEOUT_MS = 15e3;
 var START_ENSURE_POLL_INTERVAL_MS = 100;
 function emit4(opts, event) {
@@ -31186,7 +31246,7 @@ async function waitForManagedDaemonPids(slockHome, serverIds, opts) {
   while (ready.size < serverIds.length) {
     for (const serverId of serverIds) {
       if (ready.has(serverId)) continue;
-      const pid = await readPidfile(serverDaemonPidPath(slockHome, serverId));
+      const pid = await readPidfile(serverRunnerPidPath(slockHome, serverId));
       if (pid && isAlive(pid)) ready.set(serverId, pid);
     }
     if (ready.size === serverIds.length) return ready;
@@ -31198,8 +31258,8 @@ async function waitForManagedDaemonPids(slockHome, serverIds, opts) {
 }
 function buildTimeoutMessage(slockHome, serverIds, ready, input) {
   const missing = serverIds.filter((id) => !ready.has(id));
-  const target = input.serverId && missing.length === 1 ? `${input.serverLabel ?? input.serverId}` : `${missing.length} daemon(s): ${missing.join(", ")}`;
-  return `Timed out waiting for ${target} to start. Run \`slock-computer status\` and inspect ${supervisorLogPath(slockHome)} plus per-server daemon logs under ~/.slock/computer/servers/<serverId>/daemon.log.`;
+  const target = input.serverId && missing.length === 1 ? `${input.serverLabel ?? input.serverId}` : `${missing.length} server runner(s): ${missing.join(", ")}`;
+  return `Timed out waiting for ${target} to start. Run \`slock-computer status\` and inspect ${serviceLogPath(slockHome)} plus per-server server-runner logs under ~/.slock/computer/servers/<serverId>/server-runner.log.`;
 }
 async function start(input, options = {}) {
   options.signal?.throwIfAborted?.();
@@ -31227,11 +31287,14 @@ async function start(input, options = {}) {
   for (const id of managedTargets) {
     await setServerManaged(slockHome, id);
   }
-  const existing = await readPidfileAt(supervisorPidPath(slockHome));
-  if (existing && isProcessAlive2(existing)) {
+  const { pid: existing } = await findLiveServicePid(slockHome, {
+    readPidfile: options.readPidfile,
+    isProcessAlive: options.isProcessAlive
+  });
+  if (existing !== null) {
     emit4(options, {
       type: "already_running",
-      supervisorPid: existing,
+      servicePid: existing,
       managedTargets,
       attachedCount: attached.length
     });
@@ -31248,8 +31311,8 @@ async function start(input, options = {}) {
       managedTargets,
       attachedCount: attached.length,
       ready: ready2,
-      supervisorPid: existing,
-      supervisorLogPath: supervisorLogPath(slockHome)
+      servicePid: existing,
+      serviceLogPath: serviceLogPath(slockHome)
     };
   }
   if (input.foreground) {
@@ -31258,11 +31321,11 @@ async function start(input, options = {}) {
       managedTargets,
       attachedCount: attached.length
     });
-    const supervise = options.runSupervise ?? runSupervise;
+    const service = options.runService ?? runService;
     const previousParentLockMarker = process.env[PARENT_LOCK_HELD_ENV_VAR];
     process.env[PARENT_LOCK_HELD_ENV_VAR] = "1";
     try {
-      await supervise();
+      await service();
     } finally {
       if (previousParentLockMarker === void 0) delete process.env[PARENT_LOCK_HELD_ENV_VAR];
       else process.env[PARENT_LOCK_HELD_ENV_VAR] = previousParentLockMarker;
@@ -31272,34 +31335,34 @@ async function start(input, options = {}) {
       managedTargets,
       attachedCount: attached.length,
       ready: /* @__PURE__ */ new Map(),
-      supervisorPid: null,
-      supervisorLogPath: supervisorLogPath(slockHome)
+      servicePid: null,
+      serviceLogPath: serviceLogPath(slockHome)
     };
   }
   options.signal?.throwIfAborted?.();
   let pid;
   try {
-    pid = await (options.spawnDetachedSupervisor ?? spawnDetachedSupervisor)(slockHome);
+    pid = await (options.spawnDetachedService ?? spawnDetachedService)(slockHome);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     throw new ComputerServiceError("SUPERVISOR_SPAWN_FAILED", msg, err);
   }
   emit4(options, {
     type: "spawned",
-    supervisorPid: pid,
+    servicePid: pid,
     managedTargets,
     attachedCount: attached.length
   });
   if (options.signal?.aborted) {
     const ready2 = await pollReadyOnce(slockHome, managedTargets, options);
-    emit4(options, { type: "aborted", supervisorPid: pid, managedTargets, ready: ready2 });
+    emit4(options, { type: "aborted", servicePid: pid, managedTargets, ready: ready2 });
     return {
       status: "aborted",
       managedTargets,
       attachedCount: attached.length,
       ready: ready2,
-      supervisorPid: pid,
-      supervisorLogPath: supervisorLogPath(slockHome)
+      servicePid: pid,
+      serviceLogPath: serviceLogPath(slockHome)
     };
   }
   const ready = await waitForManagedDaemonPids(slockHome, managedTargets, options);
@@ -31315,8 +31378,8 @@ async function start(input, options = {}) {
     managedTargets,
     attachedCount: attached.length,
     ready,
-    supervisorPid: pid,
-    supervisorLogPath: supervisorLogPath(slockHome)
+    servicePid: pid,
+    serviceLogPath: serviceLogPath(slockHome)
   };
 }
 async function pollReadyOnce(slockHome, serverIds, opts) {
@@ -31324,7 +31387,7 @@ async function pollReadyOnce(slockHome, serverIds, opts) {
   const isAlive = opts.isProcessAlive ?? isProcessAlive2;
   const ready = /* @__PURE__ */ new Map();
   for (const serverId of serverIds) {
-    const pid = await readPidfile(serverDaemonPidPath(slockHome, serverId));
+    const pid = await readPidfile(serverRunnerPidPath(slockHome, serverId));
     if (pid && isAlive(pid)) ready.set(serverId, pid);
   }
   return ready;
@@ -31348,24 +31411,29 @@ async function stop(input = {}, options = {}) {
   const slockHome = resolveSlockHome();
   const readPidfile = options.readPidfile ?? readPidfileAt;
   const isAlive = options.isProcessAlive ?? isProcessAlive2;
-  const killer = options.killSupervisor ?? ((pid2) => {
+  const killer = options.killService ?? ((pid2) => {
     process.kill(pid2, "SIGTERM");
   });
   const sleep2 = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   const pollIntervalMs = options.pollIntervalMs ?? STOP_POLL_INTERVAL_MS;
   const timeoutMs = options.timeoutMs ?? STOP_TIMEOUT_MS;
-  const pidfilePath = supervisorPidPath(slockHome);
-  const pid = await readPidfile(pidfilePath);
+  const { pid, pidfilePath, firstStalePidfile, firstStalePid } = await findLiveServicePid(slockHome, {
+    readPidfile,
+    isProcessAlive: isAlive
+  });
   emit5(options, { type: "stopping", pid });
   if (pid === null) {
+    if (firstStalePidfile !== null && firstStalePid !== null) {
+      emit5(options, { type: "stale_pidfile_cleared", pid: firstStalePid });
+      return {
+        status: "stale_pidfile_cleared",
+        pid: firstStalePid,
+        pidfilePath: firstStalePidfile
+      };
+    }
     emit5(options, { type: "not_running" });
     return { status: "not_running", pid: null, pidfilePath };
   }
-  if (!isAlive(pid)) {
-    await clearPidfileAt(pidfilePath);
-    emit5(options, { type: "stale_pidfile_cleared", pid });
-    return { status: "stale_pidfile_cleared", pid, pidfilePath };
-  }
   options.signal?.throwIfAborted?.();
   try {
     killer(pid);
@@ -31373,7 +31441,7 @@ async function stop(input = {}, options = {}) {
     const cause = err instanceof Error ? err : new Error(String(err));
     throw new ComputerServiceError(
       "STOP_SIGNAL_FAILED",
-      `Failed to send SIGTERM to supervisor (pid ${pid}): ${cause.message}. Check process permissions or run: kill ${pid}`,
+      `Failed to send SIGTERM to service (pid ${pid}): ${cause.message}. Check process permissions or run: kill ${pid}`,
       err
     );
   }
@@ -31392,7 +31460,7 @@ async function stop(input = {}, options = {}) {
   }
   throw new ComputerServiceError(
     "STOP_TIMEOUT",
-    `Supervisor (pid ${pid}) did not exit within ${timeoutMs}ms after SIGTERM. Force-kill with: kill -9 ${pid}`
+    `Service (pid ${pid}) did not exit within ${timeoutMs}ms after SIGTERM. Force-kill with: kill -9 ${pid}`
   );
 }
 
@@ -31493,8 +31561,8 @@ async function detach(input, options = {}) {
   await clearServerManaged(slockHome, serverId);
   const subtree = [
     serverAttachmentPath(slockHome, serverId),
-    serverDaemonPidPath(slockHome, serverId),
-    serverDaemonLogPath(slockHome, serverId)
+    serverRunnerPidPath(slockHome, serverId),
+    serverRunnerLogPath(slockHome, serverId)
   ];
   for (const p of subtree) await clearPidfileAt(p);
   emit6(options, { type: "subtree_cleared", serverId, serverLabel });
@@ -31508,16 +31576,16 @@ async function detach(input, options = {}) {
   };
 }
 
-// src/supervisor.ts
+// src/service.ts
 function buildResidentSpawn(mode, serverId, selfEntry = process.argv[1] ?? "", execArgv = process.execArgv) {
   const tail = serverId ? [mode, serverId] : [mode];
   return { command: process.execPath, args: [...execArgv, selfEntry, ...tail] };
 }
 var PARENT_LOCK_HELD_ENV_VAR = "SLOCK_COMPUTER_PARENT_MUTATION_LOCK_HELD";
-async function spawnDetachedSupervisor(slockHome) {
-  await mkdir8(computerDir(slockHome), { recursive: true });
-  const supLogFd = await open(supervisorLogPath(slockHome), "a");
-  const { command, args } = buildResidentSpawn("__supervise", null);
+async function spawnDetachedService(slockHome) {
+  await mkdir8(serviceRunDir(slockHome), { recursive: true });
+  const supLogFd = await open(serviceLogPath(slockHome), "a");
+  const { command, args } = buildResidentSpawn("__service", null);
   const child = spawn2(command, args, {
     detached: true,
     stdio: ["ignore", supLogFd.fd, supLogFd.fd],
@@ -31534,9 +31602,9 @@ async function spawnDetachedSupervisor(slockHome) {
   child.unref();
   await supLogFd.close();
   if (!pid) {
-    throw new Error("SUPERVISOR_SPAWN_FAILED: could not spawn the supervisor process");
+    throw new Error("SUPERVISOR_SPAWN_FAILED: could not spawn the service process");
   }
-  await writePidfileAt(supervisorPidPath(slockHome), pid);
+  await writePidfileAt(servicePidPath(slockHome), pid);
   return pid;
 }
 var EX_CONFIG_EXIT_CODE = 78;
@@ -31562,7 +31630,7 @@ var defaultCoreFactory = async (creds) => {
   }
   return new coreMod.DaemonCore({ serverUrl: creds.serverUrl, apiKey: creds.apiKey, localTrace: true });
 };
-function classifyChildExit(code, signal) {
+function classifyRunnerExit(code, signal) {
   if (code === EX_CONFIG_EXIT_CODE) return "config-error";
   if (signal === "SIGTERM" || signal === "SIGINT") return "graceful";
   if (code === 0) return "graceful";
@@ -31607,18 +31675,18 @@ function formatReadySummary(ready, serverIds, opts) {
   }
   return `Daemons for ${serverIds.length} managed server(s) are running.`;
 }
-async function runSupervisorStartupRecovery(slockHome) {
+async function runServiceStartupRecovery(slockHome) {
   const parentHoldsLock = process.env[PARENT_LOCK_HELD_ENV_VAR] === "1";
   try {
     if (parentHoldsLock) {
       process.stderr.write(
-        "Supervisor startup: parent CLI holds mutation lock \u2014 skipping lock cleanup.\n"
+        "Service startup: parent CLI holds mutation lock \u2014 skipping lock cleanup.\n"
       );
     } else {
       const releasedLocks = await forceReleaseLock(slockHome);
       if (releasedLocks.length > 0) {
         process.stderr.write(
-          `Supervisor startup: force-released ${releasedLocks.length} stale lock(s).
+          `Service startup: force-released ${releasedLocks.length} stale lock(s).
 `
         );
       }
@@ -31626,19 +31694,19 @@ async function runSupervisorStartupRecovery(slockHome) {
     const report = await runFullCleanup(slockHome, { skipLockCleanup: parentHoldsLock });
     if (report.anyAction) {
       process.stderr.write(
-        `Supervisor startup recovery: cleaned ${report.stalePidfiles.length} pidfile(s), ${report.powerLossRecovered.length} quarantined, ${report.tmpFilesCleared.length} tmp file(s), ${report.staleLocks.length} stale lock(s).
+        `Service startup recovery: cleaned ${report.stalePidfiles.length} pidfile(s), ${report.powerLossRecovered.length} quarantined, ${report.tmpFilesCleared.length} tmp file(s), ${report.staleLocks.length} stale lock(s).
 `
       );
     }
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     process.stderr.write(
-      `Supervisor startup recovery pass failed: ${msg}. Continuing; cleanup will retry on next supervisor restart.
+      `Service startup recovery pass failed: ${msg}. Continuing; cleanup will retry on next service restart.
 `
     );
   }
 }
-async function resolveSupervisorIdentity() {
+async function resolveServiceIdentity() {
   const here = fileURLToPath2(import.meta.url);
   const installRoot = dirname8(dirname8(here));
   let version = null;
@@ -31652,30 +31720,30 @@ async function resolveSupervisorIdentity() {
   }
   return { installRoot, version };
 }
-async function writeSupervisorVersionEvidence(slockHome) {
+async function writeServiceVersionEvidence(slockHome) {
   try {
-    const ident = await resolveSupervisorIdentity();
+    const ident = await resolveServiceIdentity();
     const payload = {
       version: ident.version,
       installRoot: ident.installRoot,
       pid: process.pid,
       writtenAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    const dest = supervisorVersionPath(slockHome);
+    const dest = serviceVersionPath(slockHome);
     const tmp = `${dest}.tmp`;
     await writeFile7(tmp, JSON.stringify(payload) + "\n", { mode: 384 });
     await rename2(tmp, dest);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     process.stderr.write(
-      `Supervisor: failed to write version evidence: ${msg}. Continuing.
+      `Service: failed to write version evidence: ${msg}. Continuing.
 `
     );
   }
 }
-async function readSupervisorVersionEvidence(slockHome) {
+async function readServiceVersionEvidence(slockHome) {
   try {
-    const raw = await readFile7(supervisorVersionPath(slockHome), "utf8");
+    const raw = await readFile7(serviceVersionPath(slockHome), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.installRoot !== "string" || typeof parsed.pid !== "number" || typeof parsed.writtenAt !== "string" || parsed.version !== null && typeof parsed.version !== "string") {
       return null;
@@ -31690,16 +31758,16 @@ async function readSupervisorVersionEvidence(slockHome) {
     return null;
   }
 }
-async function runSupervise() {
+async function runService() {
   const slockHome = resolveSlockHome();
-  await mkdir8(computerDir(slockHome), { recursive: true });
-  await runSupervisorStartupRecovery(slockHome);
-  await writePidfileAt(supervisorPidPath(slockHome), process.pid);
-  await writeSupervisorVersionEvidence(slockHome);
+  await mkdir8(serviceRunDir(slockHome), { recursive: true });
+  await runServiceStartupRecovery(slockHome);
+  await writePidfileAt(servicePidPath(slockHome), process.pid);
+  await writeServiceVersionEvidence(slockHome);
   const children = /* @__PURE__ */ new Map();
   const { [PARENT_LOCK_HELD_ENV_VAR]: _parentLockMarker, ...childEnv } = process.env;
   const spawnChild = async (serverId) => {
-    const logPath = serverDaemonLogPath(slockHome, serverId);
+    const logPath = serverRunnerLogPath(slockHome, serverId);
     await mkdir8(dirname8(logPath), { recursive: true });
     const logFd = await open(logPath, "a");
     const { command, args } = buildResidentSpawn("__run", serverId);
@@ -31712,20 +31780,20 @@ async function runSupervise() {
     if (!child.pid) return;
     const handle = { serverId, child, stopping: false };
     children.set(serverId, handle);
-    await writePidfileAt(serverDaemonPidPath(slockHome, serverId), child.pid);
+    await writePidfileAt(serverRunnerPidPath(slockHome, serverId), child.pid);
     child.on("exit", (code, signal) => {
       void (async () => {
         children.delete(serverId);
-        await clearPidfileAt(serverDaemonPidPath(slockHome, serverId));
+        await clearPidfileAt(serverRunnerPidPath(slockHome, serverId));
         if (handle.stopping) return;
-        const classification = classifyChildExit(code, signal);
+        const classification = classifyRunnerExit(code, signal);
         if (classification === "config-error") {
           try {
             await markFatalConfig(slockHome, serverId, code, signal);
           } catch {
           }
           process.stderr.write(
-            `Supervisor: server ${serverId} child exited with EX_CONFIG (${EX_CONFIG_EXIT_CODE}); marked degraded, NOT auto-restarting. See ${serverDaemonLogPath(slockHome, serverId)} for the actionable error.
+            `Service: server ${serverId} child exited with EX_CONFIG (${EX_CONFIG_EXIT_CODE}); marked degraded, NOT auto-restarting. See ${serverRunnerLogPath(slockHome, serverId)} for the actionable error.
 `
           );
           return;
@@ -31743,7 +31811,7 @@ async function runSupervise() {
         }
         if (await isDegraded(slockHome, serverId)) {
           process.stderr.write(
-            `Supervisor: server ${serverId} marked degraded (>=3 crashes in 60s); skipping auto-restart. Run \`slock-computer doctor ${serverId} --reset-health\` after fixing the underlying issue.
+            `Service: server ${serverId} marked degraded (>=3 crashes in 60s); skipping auto-restart. Run \`slock-computer doctor ${serverId} --reset-health\` after fixing the underlying issue.
 `
           );
           return;
@@ -31776,7 +31844,7 @@ async function runSupervise() {
     if (shuttingDown) return;
     shuttingDown = true;
     for (const handle of children.values()) killChild(handle);
-    void clearPidfileAt(supervisorPidPath(slockHome)).then(() => process.exit(0));
+    void clearPidfileAt(servicePidPath(slockHome)).then(() => process.exit(0));
   };
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
@@ -31798,7 +31866,7 @@ async function runStart(opts = {}, deps = {}) {
         serverLabel: opts.serverLabel ?? null
       },
       {
-        spawnDetachedSupervisor: deps.spawnDetachedSupervisor,
+        spawnDetachedService: deps.spawnDetachedService,
         readPidfile: deps.readPidfile,
         isProcessAlive: deps.isProcessAlive,
         sleep: deps.sleep,
@@ -31806,17 +31874,17 @@ async function runStart(opts = {}, deps = {}) {
         ensurePollIntervalMs: deps.ensurePollIntervalMs,
         onEvent: (event) => {
           if (event.type === "already_running") {
-            info(`Supervisor already running (pid ${event.supervisorPid}).`);
+            info(`Service already running (pid ${event.servicePid}).`);
           } else if (event.type === "running") {
             info(
-              `Running supervisor in the foreground (managing ${event.managedTargets.length} of ${event.attachedCount} attached server(s)). Ctrl-C to stop.`
+              `Running service in the foreground (managing ${event.managedTargets.length} of ${event.attachedCount} attached server(s)). Ctrl-C to stop.`
             );
           } else if (event.type === "spawned") {
-            info(`Supervisor started (pid ${event.supervisorPid}); keeps running after this terminal closes.`);
+            info(`Service started (pid ${event.servicePid}); keeps running after this terminal closes.`);
             spawnedBackground = {
               managedCount: event.managedTargets.length,
               attachedCount: event.attachedCount,
-              logPath: supervisorLogPath(resolveSlockHome())
+              logPath: serviceLogPath(resolveSlockHome())
             };
           } else if (event.type === "ready") {
             info(formatReadySummary(event.ready, event.managedTargets, opts));
@@ -31836,7 +31904,7 @@ async function runStart(opts = {}, deps = {}) {
     info(
       `Managing ${sb.managedCount} of ${sb.attachedCount} attached server(s). Logs: ${sb.logPath}`
     );
-    info(`Per-server daemon logs: ~/.slock/computer/servers/<serverId>/daemon.log`);
+    info(`Per-server server-runner logs: ~/.slock/computer/servers/<serverId>/server-runner.log`);
     info(`Check state with \`slock-computer status\`.`);
   }
 }
@@ -31847,17 +31915,17 @@ async function runStop(deps = {}) {
       {
         readPidfile: deps.readPidfile,
         isProcessAlive: deps.isProcessAlive,
-        killSupervisor: deps.killSupervisor,
+        killService: deps.killService,
         sleep: deps.sleep,
         pollIntervalMs: deps.pollIntervalMs,
         timeoutMs: deps.timeoutMs,
         onEvent: (event) => {
           if (event.type === "not_running") {
-            info("Supervisor not running.");
+            info("Service not running.");
           } else if (event.type === "stale_pidfile_cleared") {
-            info(`Supervisor not running (cleared stale pidfile for pid ${event.pid}).`);
+            info(`Service not running (cleared stale pidfile for pid ${event.pid}).`);
           } else if (event.type === "stopped") {
-            info(`Stopped supervisor (pid ${event.pid}).`);
+            info(`Stopped service (pid ${event.pid}).`);
           }
         }
       }
@@ -31882,7 +31950,7 @@ async function runDetach(serverId, serverLabel = serverId) {
           } else if (event.type === "detached") {
             info(`Detached from server ${event.serverLabel}.`);
             info(
-              `The supervisor (if running) will stop that server's daemon on its next reconcile tick.`
+              `The service (if running) will stop that server's daemon on its next reconcile tick.`
             );
           }
         }
@@ -32197,6 +32265,10 @@ async function pidStatus(pidfile) {
   const pid = await readPidfileAt(pidfile);
   return pid !== null && isProcessAlive2(pid) ? { running: true, pid } : { running: false };
 }
+async function serviceState(slockHome) {
+  const { pid } = await findLiveServicePidReadOnly(slockHome);
+  return pid !== null ? { running: true, pid } : { running: false };
+}
 async function deriveHealth(slockHome, serverId, daemon) {
   if (!daemon.running) return "offline";
   if (await isDegraded(slockHome, serverId)) return "degraded";
@@ -32206,20 +32278,20 @@ async function buildStatusReport(installRoot) {
   const sessionRead = await readUserSession(userSessionPath(installRoot));
   const session = sessionRead.session;
   const attachments = await listServerAttachments(installRoot);
-  const supervisor = {
-    ...await pidStatus(supervisorPidPath(installRoot)),
-    logPath: supervisorLogPath(installRoot)
+  const service = {
+    ...await serviceState(installRoot),
+    logPath: serviceLogPath(installRoot)
   };
   const servers = [];
   for (const a of attachments) {
-    const daemon = await pidStatus(serverDaemonPidPath(installRoot, a.serverId));
+    const daemon = await pidStatus(serverRunnerPidPath(installRoot, a.serverId));
     servers.push({
       serverId: a.serverId,
       serverSlug: a.serverSlug ?? null,
       serverMachineId: a.serverMachineId,
       serverUrl: a.serverUrl,
       attachedAt: a.attachedAt ?? null,
-      daemonLogPath: serverDaemonLogPath(installRoot, a.serverId),
+      serverRunnerLogPath: serverRunnerLogPath(installRoot, a.serverId),
       daemon,
       health: await deriveHealth(installRoot, a.serverId, daemon)
     });
@@ -32231,7 +32303,7 @@ async function buildStatusReport(installRoot) {
     userId: session ? str(session.userId) : null,
     loginServerUrl: session ? str(session.serverUrl) : null,
     userSessionError: sessionRead.state === "invalid" ? sessionRead.error : null,
-    supervisor,
+    service,
     servers
   };
 }
@@ -32252,9 +32324,9 @@ async function runStatus(opts) {
   );
   if (report.loginServerUrl) info(`Login server: ${report.loginServerUrl}`);
   info(
-    `Supervisor:   ${report.supervisor.running ? `running (pid ${report.supervisor.pid})` : "stopped \u2014 run `slock-computer start`"}`
+    `Service:   ${report.service.running ? `running (pid ${report.service.pid})` : "stopped \u2014 run `slock-computer start`"}`
   );
-  info(`Supervisor log: ${report.supervisor.logPath}`);
+  info(`Service log: ${report.service.logPath}`);
   info("");
   if (report.servers.length === 0) {
     info("Attachments:  none \u2014 run `slock-computer attach /<serverSlug>` (e.g. `/myserver`).");
@@ -32266,7 +32338,7 @@ async function runStatus(opts) {
       info(
         `  ${pad(formatServerSlugDisplay(s.serverSlug), 24)}${pad(s.health, 12)}${pad(dcol, 24)}${pad(s.serverMachineId, 38)}${s.serverUrl}`
       );
-      info(`    Daemon log: ${s.daemonLogPath}`);
+      info(`    Server runner log: ${s.serverRunnerLogPath}`);
     }
     if (report.servers.some((s) => s.health === "degraded")) {
       info("");
@@ -32486,8 +32558,8 @@ async function runDoctorChecks() {
     report.userSessionError ? { name: "user session", ok: false, detail: "invalid user session file \u2014 re-run `slock-computer login`" } : report.loggedIn ? { name: "user session", ok: true, detail: `logged in (user ${report.userId ?? "?"})` } : { name: "user session", ok: false, detail: "not logged in \u2014 run `slock-computer login`" }
   );
   checks.push(
-    report.supervisor.running ? { name: "supervisor", ok: true, detail: `running (pid ${report.supervisor.pid})` } : {
-      name: "supervisor",
+    report.service.running ? { name: "service", ok: true, detail: `running (pid ${report.service.pid})` } : {
+      name: "service",
       ok: true,
       detail: "stopped (run `slock-computer start` when you want background)"
     }
@@ -32533,7 +32605,7 @@ async function runDoctor(opts) {
   if (opts.resetHealth && opts.serverId) {
     await resetHealth(slockHome, opts.serverId);
     info(`Reset health state for server ${opts.serverLabel ?? opts.serverId}.`);
-    info(`Supervisor will resume auto-restart on next daemon exit.`);
+    info(`Service will resume auto-restart on next daemon exit.`);
   }
   const checks = await runDoctorChecks();
   const allOk = checks.every((c) => c.ok);
@@ -32607,14 +32679,14 @@ import { readFile as readFile10 } from "fs/promises";
 var DEFAULT_LINES = 200;
 async function runLogs(opts) {
   const home = resolveSlockHome();
-  const file = opts.supervisor ? supervisorLogPath(home) : serverDaemonLogPath(home, await resolveTargetServerId({ server: opts.server }));
+  const file = opts.service ? serviceLogPath(home) : serverRunnerLogPath(home, await resolveTargetServerId({ server: opts.server }));
   let content;
   try {
     content = await readFile10(file, "utf8");
   } catch {
     fail(
       "NO_DAEMON_LOG",
-      opts.supervisor ? `No supervisor log at ${file}. Start the supervisor first (\`slock-computer start\`).` : `No daemon log at ${file}. Start its daemon first (\`slock-computer start\`).`
+      opts.service ? `No service log at ${file}. Start the service first (\`slock-computer start\`).` : `No server runner log at ${file}. Start its server runner first (\`slock-computer start\`).`
     );
   }
   const n = Number.isInteger(opts.lines) && opts.lines > 0 ? opts.lines : DEFAULT_LINES;
@@ -32682,7 +32754,7 @@ async function emitServiceStateTransition(slockHome, fromState, toState, trigger
     trigger
   };
   try {
-    const path3 = supervisorLogPath(slockHome);
+    const path3 = serviceLogPath(slockHome);
     await mkdir10(dirname10(path3), { recursive: true });
     await appendFile3(path3, JSON.stringify(entry) + "\n");
   } catch {
@@ -32866,7 +32938,7 @@ async function runChannelSet(slockHome, raw) {
   }
   await writeChannel(slockHome, parsed);
   info(`Channel set to ${parsed}.`);
-  info(`Note: supervisor reads channel at startup; restart \`slock-computer start\` to apply.`);
+  info(`Note: service reads channel at startup; restart \`slock-computer start\` to apply.`);
 }
 
 // src/upgradeCli.ts
@@ -33372,49 +33444,49 @@ async function rollbackSwap(currentBinaryDir, deps = {}) {
   }
 }
 async function rollbackRestart(slockHome, currentBinaryDir, deps = {}) {
-  const readSupervisorPid = deps.readSupervisorPid ?? (() => defaultReadSupervisorPid(slockHome));
+  const readServicePid = deps.readServicePid ?? (() => defaultReadServicePid(slockHome));
   const isProcessAlive4 = deps.isProcessAlive ?? defaultIsProcessAlive;
-  const killSupervisor = deps.killSupervisor ?? defaultKillSupervisor;
-  const forceKillSupervisor = deps.forceKillSupervisor ?? defaultForceKillSupervisor;
+  const killService = deps.killService ?? defaultKillService;
+  const forceKillService = deps.forceKillService ?? defaultForceKillService;
   const waitForExit = deps.waitForExit ?? defaultWaitForExit;
-  const spawnFreshSupervisor = deps.spawnFreshSupervisor;
+  const spawnFreshService = deps.spawnFreshService;
   const healthCheck = deps.healthCheck ?? (() => defaultHealthCheck(slockHome));
   const healthTimeoutMs = deps.healthTimeoutMs ?? 3e4;
   const healthPollIntervalMs = deps.healthPollIntervalMs ?? 500;
-  let supervisorStopped = false;
+  let serviceStopped = false;
   try {
-    const pid = await readSupervisorPid();
+    const pid = await readServicePid();
     if (pid === null || !isProcessAlive4(pid)) {
-      supervisorStopped = true;
+      serviceStopped = true;
     } else {
-      await killSupervisor(pid);
+      await killService(pid);
       const exited = await waitForExit(pid, 1e4);
       if (!exited) {
-        await forceKillSupervisor(pid);
+        await forceKillService(pid);
         const escalatedExit = await waitForExit(pid, 5e3);
-        supervisorStopped = escalatedExit;
+        serviceStopped = escalatedExit;
       } else {
-        supervisorStopped = true;
+        serviceStopped = true;
       }
     }
   } catch (e) {
     return {
       binaryRestored: false,
-      supervisorStopped: false,
-      supervisorRespawned: false,
-      supervisorHealthy: false,
+      serviceStopped: false,
+      serviceRespawned: false,
+      serviceHealthy: false,
       failedStep: "stop",
       reason: e instanceof Error ? e.message : String(e)
     };
   }
-  if (!supervisorStopped) {
+  if (!serviceStopped) {
     return {
       binaryRestored: false,
-      supervisorStopped: false,
-      supervisorRespawned: false,
-      supervisorHealthy: false,
+      serviceStopped: false,
+      serviceRespawned: false,
+      serviceHealthy: false,
       failedStep: "stop",
-      reason: "new-version supervisor did not exit (graceful + SIGKILL both timed out)"
+      reason: "new-version service did not exit (graceful + SIGKILL both timed out)"
     };
   }
   const swapRb = await rollbackSwap(currentBinaryDir, {
@@ -33424,31 +33496,31 @@ async function rollbackRestart(slockHome, currentBinaryDir, deps = {}) {
   if (!swapRb.rolledBack) {
     return {
       binaryRestored: false,
-      supervisorStopped: true,
-      supervisorRespawned: false,
-      supervisorHealthy: false,
+      serviceStopped: true,
+      serviceRespawned: false,
+      serviceHealthy: false,
       failedStep: "binary",
       reason: "could not restore .prev \u2192 currentBinaryDir"
     };
   }
-  if (!spawnFreshSupervisor) {
+  if (!spawnFreshService) {
     return {
       binaryRestored: true,
-      supervisorStopped: true,
-      supervisorRespawned: false,
-      supervisorHealthy: false,
+      serviceStopped: true,
+      serviceRespawned: false,
+      serviceHealthy: false,
       failedStep: "respawn",
-      reason: "no spawnFreshSupervisor callback wired; old supervisor not respawned"
+      reason: "no spawnFreshService callback wired; old service not respawned"
     };
   }
   try {
-    await spawnFreshSupervisor();
+    await spawnFreshService();
   } catch (e) {
     return {
       binaryRestored: true,
-      supervisorStopped: true,
-      supervisorRespawned: false,
-      supervisorHealthy: false,
+      serviceStopped: true,
+      serviceRespawned: false,
+      serviceHealthy: false,
       failedStep: "respawn",
       reason: e instanceof Error ? e.message : String(e)
     };
@@ -33465,53 +33537,53 @@ async function rollbackRestart(slockHome, currentBinaryDir, deps = {}) {
   if (!healthy) {
     return {
       binaryRestored: true,
-      supervisorStopped: true,
-      supervisorRespawned: true,
-      supervisorHealthy: false,
+      serviceStopped: true,
+      serviceRespawned: true,
+      serviceHealthy: false,
       failedStep: "health",
-      reason: "old supervisor failed health check after rollback respawn"
+      reason: "old service failed health check after rollback respawn"
     };
   }
   return {
     binaryRestored: true,
-    supervisorStopped: true,
-    supervisorRespawned: true,
-    supervisorHealthy: true
+    serviceStopped: true,
+    serviceRespawned: true,
+    serviceHealthy: true
   };
 }
 async function restartPhase(slockHome, deps = {}) {
-  const readSupervisorPid = deps.readSupervisorPid ?? (() => defaultReadSupervisorPid(slockHome));
-  const killSupervisor = deps.killSupervisor ?? defaultKillSupervisor;
-  const forceKillSupervisor = deps.forceKillSupervisor ?? defaultForceKillSupervisor;
+  const readServicePid = deps.readServicePid ?? (() => defaultReadServicePid(slockHome));
+  const killService = deps.killService ?? defaultKillService;
+  const forceKillService = deps.forceKillService ?? defaultForceKillService;
   const waitForExit = deps.waitForExit ?? defaultWaitForExit;
-  const spawnFreshSupervisor = deps.spawnFreshSupervisor;
+  const spawnFreshService = deps.spawnFreshService;
   const healthCheck = deps.healthCheck ?? (() => defaultHealthCheck(slockHome));
   const healthTimeoutMs = deps.healthTimeoutMs ?? 3e4;
   const healthPollIntervalMs = deps.healthPollIntervalMs ?? 500;
   const forceKill = deps.forceKill === true;
-  const oldPid = await readSupervisorPid();
+  const oldPid = await readServicePid();
   if (oldPid !== null) {
     try {
       if (forceKill) {
-        await forceKillSupervisor(oldPid);
+        await forceKillService(oldPid);
       } else {
-        await killSupervisor(oldPid);
+        await killService(oldPid);
         const exited = await waitForExit(oldPid, 1e4);
         if (!exited) {
-          await forceKillSupervisor(oldPid);
+          await forceKillService(oldPid);
           const escalatedExit = await waitForExit(oldPid, 5e3);
           if (!escalatedExit) {
-            return { ok: false, reason: "supervisor_kill_failed" };
+            return { ok: false, reason: "service_kill_failed" };
           }
         }
       }
     } catch {
-      return { ok: false, reason: "supervisor_kill_failed" };
+      return { ok: false, reason: "service_kill_failed" };
     }
   }
-  if (spawnFreshSupervisor) {
+  if (spawnFreshService) {
     try {
-      await spawnFreshSupervisor();
+      await spawnFreshService();
     } catch {
       return { ok: false, reason: "spawn_failed" };
     }
@@ -33525,16 +33597,11 @@ async function restartPhase(slockHome, deps = {}) {
   }
   return { ok: false, reason: "health_check_timeout" };
 }
-async function defaultReadSupervisorPid(slockHome) {
-  try {
-    const raw = (await readFile14(supervisorPidPath(slockHome), "utf8")).trim();
-    const pid = Number.parseInt(raw, 10);
-    return Number.isInteger(pid) && pid > 0 ? pid : null;
-  } catch {
-    return null;
-  }
+async function defaultReadServicePid(slockHome) {
+  const { pid } = await findLiveServicePid(slockHome);
+  return pid;
 }
-async function defaultKillSupervisor(pid) {
+async function defaultKillService(pid) {
   try {
     process.kill(pid, "SIGTERM");
   } catch (err) {
@@ -33542,7 +33609,7 @@ async function defaultKillSupervisor(pid) {
     throw err;
   }
 }
-async function defaultForceKillSupervisor(pid) {
+async function defaultForceKillService(pid) {
   try {
     process.kill(pid, "SIGKILL");
   } catch (err) {
@@ -33566,7 +33633,7 @@ async function defaultWaitForExit(pid, timeoutMs) {
   return false;
 }
 async function defaultHealthCheck(slockHome) {
-  const pid = await defaultReadSupervisorPid(slockHome);
+  const pid = await defaultReadServicePid(slockHome);
   if (pid === null) return false;
   try {
     process.kill(pid, 0);
@@ -33742,11 +33809,11 @@ async function runUpgrade(slockHome, opts) {
     };
   }
   const restart = await restartPhase(slockHome, {
-    readSupervisorPid: deps.readSupervisorPid,
-    killSupervisor: deps.killSupervisor,
-    forceKillSupervisor: deps.forceKillSupervisor,
+    readServicePid: deps.readServicePid,
+    killService: deps.killService,
+    forceKillService: deps.forceKillService,
     waitForExit: deps.waitForExit,
-    spawnFreshSupervisor: deps.spawnFreshSupervisor,
+    spawnFreshService: deps.spawnFreshService,
     healthCheck: deps.healthCheck,
     healthTimeoutMs: deps.healthTimeoutMs,
     healthPollIntervalMs: deps.healthPollIntervalMs,
@@ -33754,12 +33821,12 @@ async function runUpgrade(slockHome, opts) {
   });
   if (!restart.ok) {
     const rb = await rollbackRestart(slockHome, opts.currentBinaryDir, {
-      readSupervisorPid: deps.readSupervisorPid,
+      readServicePid: deps.readServicePid,
       isProcessAlive: deps.isProcessAlive,
-      killSupervisor: deps.killSupervisor,
-      forceKillSupervisor: deps.forceKillSupervisor,
+      killService: deps.killService,
+      forceKillService: deps.forceKillService,
       waitForExit: deps.waitForExit,
-      spawnFreshSupervisor: deps.spawnFreshSupervisor,
+      spawnFreshService: deps.spawnFreshService,
       healthCheck: deps.healthCheck,
       healthTimeoutMs: deps.healthTimeoutMs,
       healthPollIntervalMs: deps.healthPollIntervalMs,
@@ -33774,7 +33841,7 @@ async function runUpgrade(slockHome, opts) {
       verify,
       swap,
       restart,
-      rolledBack: rb.binaryRestored && rb.supervisorHealthy,
+      rolledBack: rb.binaryRestored && rb.serviceHealthy,
       rollback: rb
     };
   }
@@ -33787,12 +33854,12 @@ async function runUpgrade(slockHome, opts) {
   });
   if (!rolling.ok) {
     const rb = await rollbackRestart(slockHome, opts.currentBinaryDir, {
-      readSupervisorPid: deps.readSupervisorPid,
+      readServicePid: deps.readServicePid,
       isProcessAlive: deps.isProcessAlive,
-      killSupervisor: deps.killSupervisor,
-      forceKillSupervisor: deps.forceKillSupervisor,
+      killService: deps.killService,
+      forceKillService: deps.forceKillService,
       waitForExit: deps.waitForExit,
-      spawnFreshSupervisor: deps.spawnFreshSupervisor,
+      spawnFreshService: deps.spawnFreshService,
       healthCheck: deps.healthCheck,
       healthTimeoutMs: deps.healthTimeoutMs,
       healthPollIntervalMs: deps.healthPollIntervalMs,
@@ -33809,7 +33876,7 @@ async function runUpgrade(slockHome, opts) {
       swap,
       restart,
       rolling,
-      rolledBack: rb.binaryRestored && rb.supervisorHealthy,
+      rolledBack: rb.binaryRestored && rb.serviceHealthy,
       rollback: rb
     };
   }
@@ -33850,7 +33917,7 @@ async function rollingDaemonHealthCheck(slockHome, deps = {}) {
 }
 async function defaultReadDaemonPid(slockHome, serverId) {
   try {
-    const raw = (await readFile14(serverDaemonPidPath(slockHome, serverId), "utf8")).trim();
+    const raw = (await readFile14(serverRunnerPidPath(slockHome, serverId), "utf8")).trim();
     const pid = Number.parseInt(raw, 10);
     return Number.isInteger(pid) && pid > 0 ? pid : null;
   } catch {
@@ -33956,8 +34023,8 @@ async function readBundledDaemonVersion(binaryDir) {
     return null;
   }
 }
-async function defaultSpawnFreshSupervisor(slockHome) {
-  await spawnDetachedSupervisor(slockHome);
+async function defaultSpawnFreshService(slockHome) {
+  await spawnDetachedService(slockHome);
 }
 async function runUpgradeCli(slockHome, opts, deps = {}) {
   let channel2;
@@ -34056,8 +34123,10 @@ async function runUpgradeCli(slockHome, opts, deps = {}) {
   if (drainMode !== void 0 && drainMode !== "drain") {
     info(`Drain mode: ${drainMode}${drainMode === "force" ? " (in-flight turns will be dropped)" : ""}.`);
   }
+  const readBundledFn = deps.readBundledDaemonVersion ?? readBundledDaemonVersion;
+  const fromBundledDaemonVersion = await readBundledFn(currentBinaryDir);
   const runUpgradeFn = deps.runUpgradeFn ?? runUpgrade;
-  const spawnFreshSupervisor = deps.spawnFreshSupervisor ?? defaultSpawnFreshSupervisor;
+  const spawnFreshService = deps.spawnFreshService ?? defaultSpawnFreshService;
   const outcome = await runUpgradeFn(slockHome, {
     targetVersion,
     fromVersion,
@@ -34065,25 +34134,26 @@ async function runUpgradeCli(slockHome, opts, deps = {}) {
     currentBinaryDir,
     drainMode,
     deps: {
-      // Wire the production supervisor-spawn into BOTH phase 5 (happy)
+      // Wire the production service-spawn into BOTH phase 5 (happy)
       // and the operational-rollback respawn path inside `runUpgrade`.
       // Without this, phase 5 falls through to a no-spawn health-poll
       // and rollback later trips `failedStep="respawn"`. See Dayu
       // blocker (#wg-slock-computer:b43b36fb msg=911eb84e).
-      spawnFreshSupervisor: () => spawnFreshSupervisor(slockHome)
+      spawnFreshService: () => spawnFreshService(slockHome)
     }
   });
-  const readBundledFn = deps.readBundledDaemonVersion ?? readBundledDaemonVersion;
-  const bundledDaemonVersion = await readBundledFn(currentBinaryDir);
-  const bundle = (version) => bundledDaemonVersion !== null ? { computerVersion: version, bundledDaemonVersion } : { computerVersion: version };
+  const toBundledDaemonVersion = await readBundledFn(currentBinaryDir);
+  const bundle = (version, bundledDaemonVersion) => bundledDaemonVersion !== null ? { computerVersion: version, bundledDaemonVersion } : { computerVersion: version };
+  const fromBundle = bundle(fromVersion, fromBundledDaemonVersion);
+  const toBundle = bundle(targetVersion, toBundledDaemonVersion);
   const logTrigger = opts.trigger ?? "cli";
   if (outcome.ok) {
     info(
       `Upgrade ${fromVersion} \u2192 ${targetVersion} succeeded (health-OK in ${outcome.restart?.healthAfterMs ?? 0}ms).`
     );
     await appendUpgradeLogEntry(slockHome, {
-      fromBundle: bundle(fromVersion),
-      toBundle: bundle(targetVersion),
+      fromBundle,
+      toBundle,
       channel: channel2,
       trigger: logTrigger,
       outcome: "ok"
@@ -34100,11 +34170,11 @@ async function runUpgradeCli(slockHome, opts, deps = {}) {
   }
   if (outcome.phase === "cleanup") {
     info(
-      `Upgrade ${fromVersion} \u2192 ${targetVersion} succeeded; cleanup phase reported a non-fatal issue: ${outcome.reason ?? "unknown"}. Active layout + supervisor are healthy.`
+      `Upgrade ${fromVersion} \u2192 ${targetVersion} succeeded; cleanup phase reported a non-fatal issue: ${outcome.reason ?? "unknown"}. Active layout + service are healthy.`
     );
     await appendUpgradeLogEntry(slockHome, {
-      fromBundle: bundle(fromVersion),
-      toBundle: bundle(targetVersion),
+      fromBundle,
+      toBundle,
       channel: channel2,
       trigger: logTrigger,
       outcome: "ok"
@@ -34114,8 +34184,8 @@ async function runUpgradeCli(slockHome, opts, deps = {}) {
   }
   const code = mapFailurePhaseToCode(outcome);
   await appendUpgradeLogEntry(slockHome, {
-    fromBundle: bundle(fromVersion),
-    toBundle: bundle(targetVersion),
+    fromBundle,
+    toBundle,
     channel: channel2,
     trigger: logTrigger,
     outcome: "err",
@@ -34273,8 +34343,8 @@ function buildSimulatedDeps(slockHome, opts) {
         fsRename: opts.simulateFail === "swap" ? async () => {
           throw new Error("simulated swap failure: fsRename");
         } : void 0,
-        readSupervisorPid: async () => null,
-        spawnFreshSupervisor: async () => {
+        readServicePid: async () => null,
+        spawnFreshService: async () => {
           await maybeSleep();
           spawnCalls += 1;
           if (opts.simulateFail === "restart" && spawnCalls === 1) {
@@ -34366,7 +34436,7 @@ async function captureStateSnapshot(slockHome, version, currentBinaryDir) {
     upgradeSnapshot: await pathInfo(upgradeSnapshotPath(slockHome)),
     stagingDir: stagingExists,
     stagingEntries,
-    supervisorPid: await pathInfo(supervisorPidPath(slockHome)),
+    servicePid: await pathInfo(servicePidPath(slockHome)),
     channelFile: await pathInfo(join8(computerDir(slockHome), "channel")),
     computerDir: await pathInfo(computerDir(slockHome)),
     servers,
@@ -34445,8 +34515,8 @@ async function runUpgradeInstallSmoke(slockHome, opts, deps = {}) {
   const currentBinaryDir = opts.currentBinaryDir ?? (deps.currentBinaryDir ?? defaultCurrentBinaryDirLocal)();
   const fromVersion = opts.fromVersion ?? await (deps.currentVersion ?? defaultCurrentVersionLocal)();
   const channel2 = opts.channel ?? "latest";
-  const spawnFreshSupervisor = deps.spawnFreshSupervisor ?? (async (h) => {
-    await spawnDetachedSupervisor(h);
+  const spawnFreshService = deps.spawnFreshService ?? (async (h) => {
+    await spawnDetachedService(h);
   });
   await mkdir16(slockHome, { recursive: true });
   const outcome = await runUpgrade(slockHome, {
@@ -34474,7 +34544,7 @@ async function runUpgradeInstallSmoke(slockHome, opts, deps = {}) {
       // dependencies from the registry; this smoke isolates the swap /
       // restart mechanics and keeps dependency hydration out of scope.
       npmInstall: async () => ({ exitCode: 0, stderr: "" }),
-      spawnFreshSupervisor: () => spawnFreshSupervisor(slockHome),
+      spawnFreshService: () => spawnFreshService(slockHome),
       // PR-E 18/n: the workspace-built tarball still carries
       // `workspace:*` (or `file:` after pack-rewrite in some workflows)
       // for `@slock-ai/daemon`, which production preflight rejects as
@@ -34485,13 +34555,13 @@ async function runUpgradeInstallSmoke(slockHome, opts, deps = {}) {
       preflight: { allowUnsafeSpec: true }
     }
   });
-  const activeVersion = await readSupervisorVersionEvidence(slockHome);
+  const activeVersion = await readServiceVersionEvidence(slockHome);
   return { outcome, activeVersion };
 }
-async function runUpgradeInstallSmokeCli(slockHome, opts, writer = (s) => process.stdout.write(s)) {
+async function runUpgradeInstallSmokeCli(slockHome, opts, writer = (s) => process.stdout.write(s), deps = {}) {
   let report;
   try {
-    report = await runUpgradeInstallSmoke(slockHome, opts);
+    report = await runUpgradeInstallSmoke(slockHome, opts, deps);
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     writer(
@@ -34556,12 +34626,12 @@ program2.name("slock-computer").description("Slock Computer \u2014 local-machine
 program2.command("login").description("Log in via device-code (one user identity per Computer / SLOCK_HOME).").option("--server-url <url>", `Slock API base URL; defaults to SLOCK_SERVER_URL or ${DEFAULT_SLOCK_SERVER_URL}`).action(withCliExit(async (opts) => {
   await runLogin({ serverUrl: opts.serverUrl });
 }));
-program2.command("attach").argument("<serverSlug>", "target Slock server slug (canonical form `/myserver`; bare `myserver` accepted)").description("Attach this Computer to one Slock server (add-not-replace; multi-server OK).").option("--server-url <url>", `Slock API base URL; defaults to the saved user session, SLOCK_SERVER_URL, or ${DEFAULT_SLOCK_SERVER_URL}`).option("--name <name>", "Computer display name; defaults to a sanitized hostname").option("--no-run", "only authorize + write local state; do not start the supervisor").option("--foreground", "run the supervisor in this terminal instead of the background").action(withCliExit(async (serverSlug, opts) => {
+program2.command("attach").argument("<serverSlug>", "target Slock server slug (canonical form `/myserver`; bare `myserver` accepted)").description("Attach this Computer to one Slock server (add-not-replace; multi-server OK).").option("--server-url <url>", `Slock API base URL; defaults to the saved user session, SLOCK_SERVER_URL, or ${DEFAULT_SLOCK_SERVER_URL}`).option("--name <name>", "Computer display name; defaults to a sanitized hostname").option("--no-run", "only authorize + write local state; do not start the service").option("--foreground", "run the service in this terminal instead of the background").action(withCliExit(async (serverSlug, opts) => {
   await withMutationLock(
     () => runAttach({ serverSlug, serverUrl: opts.serverUrl, name: opts.name, run: opts.run, foreground: opts.foreground })
   );
 }));
-program2.command("setup").argument("<serverSlug>", "target Slock server slug (canonical form `/myserver`; bare `myserver` accepted)").description("Set up this Computer for one server: login if needed, attach (or \xA7X.1 migrate-prompt) if needed, then start.").option("--server-url <url>", `Slock API base URL; defaults to the saved user session, SLOCK_SERVER_URL, or ${DEFAULT_SLOCK_SERVER_URL}`).option("--name <name>", "Computer display name for a new attachment; defaults to a sanitized hostname").option("--no-start", "stop after login + attach; do not start the supervisor").option("--foreground", "run the supervisor in this terminal instead of the background").option("-y, --yes", "allow non-interactive setup after confirming the planned actions").action(
+program2.command("setup").argument("<serverSlug>", "target Slock server slug (canonical form `/myserver`; bare `myserver` accepted)").description("Set up this Computer for one server: login if needed, attach (or \xA7X.1 migrate-prompt) if needed, then start.").option("--server-url <url>", `Slock API base URL; defaults to the saved user session, SLOCK_SERVER_URL, or ${DEFAULT_SLOCK_SERVER_URL}`).option("--name <name>", "Computer display name for a new attachment; defaults to a sanitized hostname").option("--no-start", "stop after login + attach; do not start the service").option("--foreground", "run the service in this terminal instead of the background").option("-y, --yes", "allow non-interactive setup after confirming the planned actions").action(
   withCliExit(async (serverSlug, opts) => {
     await withMutationLock(
       () => runSetup({
@@ -34578,10 +34648,10 @@ program2.command("setup").argument("<serverSlug>", "target Slock server slug (ca
 program2.command("detach").argument("<serverSlug>", "server slug to detach from this Computer (canonical form `/myserver`)").description("Remove ONE server's local attachment; never touches user-session or other servers.").action(withCliExit(async (serverSlug) => {
   await withMutationLock(async () => runDetach(await resolveTargetServerId({ server: serverSlug }), serverSlug));
 }));
-program2.command("status").description("Show this Computer's aggregate state (login + supervisor + per-server daemons).").option("--json", "emit the machine-readable report").action(withCliExit(async (opts) => {
+program2.command("status").description("Show this Computer's aggregate state (login + service + per-server server-runners).").option("--json", "emit the machine-readable report").action(withCliExit(async (opts) => {
   await runStatus({ json: opts.json });
 }));
-program2.command("start").argument("[serverSlug]", "optional: verify this server is attached and ensure its daemon is reconciled (default: ensure all attached)").description("Start/ensure the Computer supervisor (manages all per-server daemons).").option("--foreground", "stay in this terminal instead of detaching").action(withCliExit(async (serverSlug, opts) => {
+program2.command("start").argument("[serverSlug]", "optional: verify this server is attached and ensure its server-runner is reconciled (default: ensure all attached)").description("Start/ensure the Computer service (manages all per-server server-runners).").option("--foreground", "stay in this terminal instead of detaching").action(withCliExit(async (serverSlug, opts) => {
   await withMutationLock(
     async () => runStart({
       foreground: opts.foreground,
@@ -34590,10 +34660,10 @@ program2.command("start").argument("[serverSlug]", "optional: verify this server
     })
   );
 }));
-program2.command("stop").description("Stop the Computer supervisor (and all managed per-server daemons).").action(withCliExit(async () => {
+program2.command("stop").description("Stop the Computer service (and all managed per-server server-runners).").action(withCliExit(async () => {
   await withMutationLock(() => runStop());
 }));
-program2.command("doctor").argument("[serverSlug]", "optional: scope detail (recent crashes) to one server").description("Diagnose login + per-server attachments + per-server preflight (no secrets).").option("--json", "emit the machine-readable report").option("--cleanup", "after diagnosis, run the local residue cleanup pass").option("--fix", "alias for --cleanup (same behavior)").option("--reset-health", "clear <serverSlug>'s crash history so supervisor resumes auto-restart").action(
+program2.command("doctor").argument("[serverSlug]", "optional: scope detail (recent crashes) to one server").description("Diagnose login + per-server attachments + per-server preflight (no secrets).").option("--json", "emit the machine-readable report").option("--cleanup", "after diagnosis, run the local residue cleanup pass").option("--fix", "alias for --cleanup (same behavior)").option("--reset-health", "clear <serverSlug>'s crash history so service resumes auto-restart").action(
   withCliExit(
     async (serverSlug, opts) => {
       const serverId = serverSlug ? await resolveTargetServerId({ server: serverSlug }) : void 0;
@@ -34608,7 +34678,7 @@ program2.command("doctor").argument("[serverSlug]", "optional: scope detail (rec
     }
   )
 );
-program2.command("reset").description("Clear a degraded state and resume the supervisor's auto-restart loop.").option("--service", "clear the service-level crash history (cascade record)").option("--runner", "clear a runner's crash history (selected by `--server`)").option("--server <slug>", "with `--runner`, select target server slug (required when \u22652 attached)").option("--json", "emit the machine-readable result").action(
+program2.command("reset").description("Clear a degraded state and resume the service's auto-restart loop.").option("--service", "clear the service-level crash history (cascade record)").option("--runner", "clear a runner's crash history (selected by `--server`)").option("--server <slug>", "with `--runner`, select target server slug (required when \u22652 attached)").option("--json", "emit the machine-readable result").action(
   withCliExit(async (opts) => {
     await withMutationLock(
       () => runReset({
@@ -34620,8 +34690,8 @@ program2.command("reset").description("Clear a degraded state and resume the sup
     );
   })
 );
-program2.command("logs").description("Tail one server's daemon log (or the supervisor log); secrets redacted.").option("--lines <n>", "trailing lines to show (default 200)", (v) => Number.parseInt(v, 10)).option("--server <slug>", "select target server slug (required when \u22652 attached)").option("--supervisor", "tail the global supervisor log instead of a per-server daemon log").action(withCliExit(async (opts) => {
-  await runLogs({ lines: opts.lines, server: opts.server ?? null, supervisor: !!opts.supervisor });
+program2.command("logs").description("Tail one server's server-runner log (or the service log); secrets redacted.").option("--lines <n>", "trailing lines to show (default 200)", (v) => Number.parseInt(v, 10)).option("--server <slug>", "select target server slug (required when \u22652 attached)").option("--service", "tail the global service log instead of a per-server server-runner log").action(withCliExit(async (opts) => {
+  await runLogs({ lines: opts.lines, server: opts.server ?? null, service: !!opts.service });
 }));
 var runners = program2.command("runners").description("Computer runner control plane (per-server scoped; \xA712 whitelist server-side).");
 runners.command("list").description("List runners on one attached server.").option("--json", "emit the machine-readable list").option("--server <slug>", "select target server slug (required when \u22652 attached)").action(withCliExit(async (opts) => {
@@ -34701,8 +34771,8 @@ program2.command("upgrade").description(
     }
   )
 );
-program2.command("__supervise", { hidden: true }).action(withCliExit(async () => {
-  await runSupervise();
+program2.command("__service", { hidden: true }).action(withCliExit(async () => {
+  await runService();
 }));
 program2.command("__run", { hidden: true }).argument("<serverId>", "server id this daemon child is bound to").action(withCliExit(async (serverId) => {
   await runResident(serverId);