@slock-ai/computer 0.0.15 → 0.0.16-alpha.0

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,7 +29877,7 @@ 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");
@@ -29894,14 +29894,17 @@ function serverHealthPath(slockHome, serverId) {
 function serviceStatePath(slockHome) {
   return path2.join(computerDir(slockHome), "service.state.json");
 }
-function supervisorPidPath(slockHome) {
+function servicePidPath(slockHome) {
+  return path2.join(computerDir(slockHome), "service.pid");
+}
+function legacySupervisorPidPath(slockHome) {
   return path2.join(computerDir(slockHome), "supervisor.pid");
 }
-function supervisorLogPath(slockHome) {
-  return path2.join(computerDir(slockHome), "supervisor.log");
+function serviceLogPath(slockHome) {
+  return path2.join(computerDir(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 +30802,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,8 +30872,8 @@ 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) {
@@ -30919,7 +30922,7 @@ 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));
@@ -31156,7 +31159,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 {
@@ -31199,7 +31202,7 @@ 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.`;
+  return `Timed out waiting for ${target} to start. Run \`slock-computer status\` and inspect ${serviceLogPath(slockHome)} plus per-server daemon logs under ~/.slock/computer/servers/<serverId>/daemon.log.`;
 }
 async function start(input, options = {}) {
   options.signal?.throwIfAborted?.();
@@ -31227,11 +31230,11 @@ async function start(input, options = {}) {
   for (const id of managedTargets) {
     await setServerManaged(slockHome, id);
   }
-  const existing = await readPidfileAt(supervisorPidPath(slockHome));
+  const existing = await readPidfileAt(servicePidPath(slockHome));
   if (existing && isProcessAlive2(existing)) {
     emit4(options, {
       type: "already_running",
-      supervisorPid: existing,
+      servicePid: existing,
       managedTargets,
       attachedCount: attached.length
     });
@@ -31248,8 +31251,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 +31261,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 +31275,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 +31318,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) {
@@ -31348,14 +31351,22 @@ 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);
+  let pidfilePath = servicePidPath(slockHome);
+  let pid = await readPidfile(pidfilePath);
+  if (pid === null) {
+    const legacyPidfilePath = legacySupervisorPidPath(slockHome);
+    const legacyPid = await readPidfile(legacyPidfilePath);
+    if (legacyPid !== null) {
+      pidfilePath = legacyPidfilePath;
+      pid = legacyPid;
+    }
+  }
   emit5(options, { type: "stopping", pid });
   if (pid === null) {
     emit5(options, { type: "not_running" });
@@ -31373,7 +31384,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 +31403,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}`
   );
 }
 
@@ -31508,16 +31519,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) {
+async function spawnDetachedService(slockHome) {
   await mkdir8(computerDir(slockHome), { recursive: true });
-  const supLogFd = await open(supervisorLogPath(slockHome), "a");
-  const { command, args } = buildResidentSpawn("__supervise", null);
+  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 +31545,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 +31573,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 +31618,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 +31637,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 +31663,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,12 +31701,12 @@ 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 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) => {
@@ -31718,14 +31729,14 @@ async function runSupervise() {
         children.delete(serverId);
         await clearPidfileAt(serverDaemonPidPath(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 ${serverDaemonLogPath(slockHome, serverId)} for the actionable error.
 `
           );
           return;
@@ -31743,7 +31754,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 +31787,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 +31809,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 +31817,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));
@@ -31847,17 +31858,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 +31893,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.`
             );
           }
         }
@@ -32206,9 +32217,9 @@ 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 pidStatus(servicePidPath(installRoot)),
+    logPath: serviceLogPath(installRoot)
   };
   const servers = [];
   for (const a of attachments) {
@@ -32231,7 +32242,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 +32263,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`).");
@@ -32486,8 +32497,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 +32544,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 +32618,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) : serverDaemonLogPath(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 daemon log at ${file}. Start its daemon first (\`slock-computer start\`).`
     );
   }
   const n = Number.isInteger(opts.lines) && opts.lines > 0 ? opts.lines : DEFAULT_LINES;
@@ -32682,7 +32693,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 +32877,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 +33383,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 +33435,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 +33476,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 +33536,16 @@ async function restartPhase(slockHome, deps = {}) {
   }
   return { ok: false, reason: "health_check_timeout" };
 }
-async function defaultReadSupervisorPid(slockHome) {
+async function defaultReadServicePid(slockHome) {
   try {
-    const raw = (await readFile14(supervisorPidPath(slockHome), "utf8")).trim();
+    const raw = (await readFile14(servicePidPath(slockHome), "utf8")).trim();
     const pid = Number.parseInt(raw, 10);
     return Number.isInteger(pid) && pid > 0 ? pid : null;
   } catch {
     return null;
   }
 }
-async function defaultKillSupervisor(pid) {
+async function defaultKillService(pid) {
   try {
     process.kill(pid, "SIGTERM");
   } catch (err) {
@@ -33542,7 +33553,7 @@ async function defaultKillSupervisor(pid) {
     throw err;
   }
 }
-async function defaultForceKillSupervisor(pid) {
+async function defaultForceKillService(pid) {
   try {
     process.kill(pid, "SIGKILL");
   } catch (err) {
@@ -33566,7 +33577,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 +33753,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 +33765,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 +33785,7 @@ async function runUpgrade(slockHome, opts) {
       verify,
       swap,
       restart,
-      rolledBack: rb.binaryRestored && rb.supervisorHealthy,
+      rolledBack: rb.binaryRestored && rb.serviceHealthy,
       rollback: rb
     };
   }
@@ -33787,12 +33798,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 +33820,7 @@ async function runUpgrade(slockHome, opts) {
       swap,
       restart,
       rolling,
-      rolledBack: rb.binaryRestored && rb.supervisorHealthy,
+      rolledBack: rb.binaryRestored && rb.serviceHealthy,
       rollback: rb
     };
   }
@@ -33956,8 +33967,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;
@@ -34057,7 +34068,7 @@ async function runUpgradeCli(slockHome, opts, deps = {}) {
     info(`Drain mode: ${drainMode}${drainMode === "force" ? " (in-flight turns will be dropped)" : ""}.`);
   }
   const runUpgradeFn = deps.runUpgradeFn ?? runUpgrade;
-  const spawnFreshSupervisor = deps.spawnFreshSupervisor ?? defaultSpawnFreshSupervisor;
+  const spawnFreshService = deps.spawnFreshService ?? defaultSpawnFreshService;
   const outcome = await runUpgradeFn(slockHome, {
     targetVersion,
     fromVersion,
@@ -34065,12 +34076,12 @@ 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;
@@ -34100,7 +34111,7 @@ 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),
@@ -34273,8 +34284,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 +34377,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 +34456,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 +34485,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,7 +34496,7 @@ 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)) {
@@ -34556,12 +34567,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 +34589,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 daemons).").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 daemon is reconciled (default: ensure all attached)").description("Start/ensure the Computer service (manages all per-server daemons).").option("--foreground", "stay in this terminal instead of detaching").action(withCliExit(async (serverSlug, opts) => {
   await withMutationLock(
     async () => runStart({
       foreground: opts.foreground,
@@ -34590,10 +34601,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 daemons).").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 +34619,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 +34631,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 daemon 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 daemon 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 +34712,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);

package/dist/lib/index.d.ts

@@ -22,7 +22,7 @@ interface ComputerStatusReport {
     userId: string | null;
     loginServerUrl: string | null;
     userSessionError: string | null;
-    supervisor: DaemonState & {
+    service: DaemonState & {
         logPath: string;
     };
     servers: ServerStatusRow[];
@@ -45,13 +45,13 @@ interface RunnerListItem {
  *               budget near breach, see §1/§2)
  *   crashed   — observed exit / fatal signal
  *   stopped   — intentional stop (operator-driven via `runners stop` or
- *               supervisor shutdown)
+ *               service shutdown)
  */
 declare const RUNNER_STATE_VALUES: readonly ["starting", "running", "degraded", "crashed", "stopped"];
 type RunnerState = (typeof RUNNER_STATE_VALUES)[number];
 declare function isRunnerState(value: unknown): value is RunnerState;
 /**
- * Service (supervisor) lifecycle states (§3.2). Mirrors runner shape but
+ * Service (service) lifecycle states (§3.2). Mirrors runner shape but
  * narrower — the service is a singleton per install root.
  *
  *   starting  — pidfile written, socket not yet listening
@@ -465,7 +465,7 @@ declare function readServiceStatus(installRoot: string): Promise<ServiceStatusRe
  * Read a single attached server's daemon state row plus the runners
  * currently running on it. Throws `StateReaderError("NOT_ATTACHED")` if
  * `serverId` is not in the attached set, or `"INVALID_ATTACHMENT"` if
- * the attachment.json under that id is unreadable.
+ * the runner.state.json under that id is unreadable.
  */
 declare function readRunnerStatus(installRoot: string, serverId: string): Promise<RunnerStatusResult>;
 /**

package/dist/lib/index.js

@@ -126,7 +126,7 @@ function serverDir(slockHome, serverId) {
   return path.join(serversDir(slockHome), assertValidServerId(serverId));
 }
 function serverAttachmentPath(slockHome, serverId) {
-  return path.join(serverDir(slockHome, serverId), "attachment.json");
+  return path.join(serverDir(slockHome, serverId), "runner.state.json");
 }
 function serverDaemonPidPath(slockHome, serverId) {
   return path.join(serverDir(slockHome, serverId), "daemon.pid");
@@ -137,11 +137,11 @@ function serverDaemonLogPath(slockHome, serverId) {
 function serverHealthPath(slockHome, serverId) {
   return path.join(serverDir(slockHome, serverId), "health.json");
 }
-function supervisorPidPath(slockHome) {
-  return path.join(computerDir(slockHome), "supervisor.pid");
+function servicePidPath(slockHome) {
+  return path.join(computerDir(slockHome), "service.pid");
 }
-function supervisorLogPath(slockHome) {
-  return path.join(computerDir(slockHome), "supervisor.log");
+function serviceLogPath(slockHome) {
+  return path.join(computerDir(slockHome), "service.log");
 }
 
 // src/serverState.ts
@@ -283,9 +283,9 @@ 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 pidStatus(servicePidPath(installRoot)),
+    logPath: serviceLogPath(installRoot)
   };
   const servers = [];
   for (const a of attachments) {
@@ -308,7 +308,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
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/computer",
-  "version": "0.0.15",
+  "version": "0.0.16-alpha.0",
   "description": "Slock Computer — standalone human/local-machine control-plane CLI (login + attach). Distinct from the agent-facing @slock-ai/cli.",
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
     "commander": "^12.1.0",
     "proper-lockfile": "^4.1.2",
     "undici": "^7.24.7",
-    "@slock-ai/daemon": "0.55.1"
+    "@slock-ai/daemon": "0.55.2-alpha.0"
   },
   "devDependencies": {
     "@types/node": "^25.5.0",
@@ -44,6 +44,7 @@
     "build": "pnpm run build:deps && tsup",
     "test": "node --import tsx --test --test-force-exit 'src/**/*.test.ts'",
     "typecheck": "tsc --noEmit",
-    "lint:boundaries": "node scripts/check-boundaries.mjs"
+    "lint:boundaries": "node scripts/check-boundaries.mjs",
+    "lint:naming": "node scripts/check-naming.mjs"
   }
 }