@botiverse/raft-computer 0.0.58 → 0.0.59

package/dist/index.js

@@ -5874,7 +5874,7 @@ var require_connect = __commonJS({
       const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions);
       timeout = timeout == null ? 1e4 : timeout;
       allowH2 = allowH2 != null ? allowH2 : false;
-      return function connect2({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) {
+      return function connect3({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) {
         let socket;
         if (protocol === "https:") {
           if (!tls) {
@@ -11552,7 +11552,7 @@ var require_client = __commonJS({
         tls,
         strictContentLength,
         maxCachedSessions,
-        connect: connect3,
+        connect: connect4,
         maxRequestsPerClient,
         localAddress,
         maxResponseSize,
@@ -11609,7 +11609,7 @@ var require_client = __commonJS({
         if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) {
           throw new InvalidArgumentError2("bodyTimeout must be a positive integer or zero");
         }
-        if (connect3 != null && typeof connect3 !== "function" && typeof connect3 !== "object") {
+        if (connect4 != null && typeof connect4 !== "function" && typeof connect4 !== "object") {
           throw new InvalidArgumentError2("connect must be a function or an object");
         }
         if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) {
@@ -11643,8 +11643,8 @@ var require_client = __commonJS({
           throw new InvalidArgumentError2("pingInterval must be a positive integer, greater or equal to 0");
         }
         super();
-        if (typeof connect3 !== "function") {
-          connect3 = buildConnector({
+        if (typeof connect4 !== "function") {
+          connect4 = buildConnector({
             ...tls,
             maxCachedSessions,
             allowH2,
@@ -11652,14 +11652,14 @@ var require_client = __commonJS({
             socketPath,
             timeout: connectTimeout,
             ...typeof autoSelectFamily === "boolean" ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
-            ...connect3
+            ...connect4
           });
         } else if (socketPath != null) {
-          const customConnect = connect3;
-          connect3 = (opts, callback) => customConnect({ ...opts, socketPath }, callback);
+          const customConnect = connect4;
+          connect4 = (opts, callback) => customConnect({ ...opts, socketPath }, callback);
         }
         this[kUrl] = util.parseOrigin(url);
-        this[kConnector] = connect3;
+        this[kConnector] = connect4;
         this[kPipelining] = pipelining != null ? pipelining : 1;
         this[kMaxHeadersSize] = maxHeaderSize;
         this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout;
@@ -11717,7 +11717,7 @@ var require_client = __commonJS({
         );
       }
       [kConnect](cb) {
-        connect2(this);
+        connect3(this);
         this.once("connect", cb);
       }
       [kDispatch](opts, handler) {
@@ -11779,7 +11779,7 @@ var require_client = __commonJS({
         assert(client[kSize] === 0);
       }
     }
-    function connect2(client) {
+    function connect3(client) {
       assert(!client[kConnecting]);
       assert(!client[kHTTPContext]);
       let { host, hostname, protocol, port } = client[kUrl];
@@ -11958,7 +11958,7 @@ var require_client = __commonJS({
           return;
         }
         if (!client[kHTTPContext]) {
-          connect2(client);
+          connect3(client);
           return;
         }
         if (client[kHTTPContext].destroyed) {
@@ -12257,7 +12257,7 @@ var require_pool = __commonJS({
       constructor(origin, {
         connections,
         factory = defaultFactory,
-        connect: connect2,
+        connect: connect3,
         connectTimeout,
         tls,
         maxCachedSessions,
@@ -12274,24 +12274,24 @@ var require_pool = __commonJS({
         if (typeof factory !== "function") {
           throw new InvalidArgumentError2("factory must be a function.");
         }
-        if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
+        if (connect3 != null && typeof connect3 !== "function" && typeof connect3 !== "object") {
           throw new InvalidArgumentError2("connect must be a function or an object");
         }
-        if (typeof connect2 !== "function") {
-          connect2 = buildConnector({
+        if (typeof connect3 !== "function") {
+          connect3 = buildConnector({
             ...tls,
             maxCachedSessions,
             allowH2,
             socketPath,
             timeout: connectTimeout,
             ...typeof autoSelectFamily === "boolean" ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
-            ...connect2
+            ...connect3
           });
         }
         super();
         this[kConnections] = connections || null;
         this[kUrl] = util.parseOrigin(origin);
-        this[kOptions] = { ...util.deepClone(options), connect: connect2, allowH2, clientTtl, socketPath };
+        this[kOptions] = { ...util.deepClone(options), connect: connect3, allowH2, clientTtl, socketPath };
         this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
         this[kFactory] = factory;
         this.on("connect", (origin2, targets) => {
@@ -12510,7 +12510,7 @@ var require_round_robin_pool = __commonJS({
       constructor(origin, {
         connections,
         factory = defaultFactory,
-        connect: connect2,
+        connect: connect3,
         connectTimeout,
         tls,
         maxCachedSessions,
@@ -12527,24 +12527,24 @@ var require_round_robin_pool = __commonJS({
         if (typeof factory !== "function") {
           throw new InvalidArgumentError2("factory must be a function.");
         }
-        if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
+        if (connect3 != null && typeof connect3 !== "function" && typeof connect3 !== "object") {
           throw new InvalidArgumentError2("connect must be a function or an object");
         }
-        if (typeof connect2 !== "function") {
-          connect2 = buildConnector({
+        if (typeof connect3 !== "function") {
+          connect3 = buildConnector({
             ...tls,
             maxCachedSessions,
             allowH2,
             socketPath,
             timeout: connectTimeout,
             ...typeof autoSelectFamily === "boolean" ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
-            ...connect2
+            ...connect3
           });
         }
         super();
         this[kConnections] = connections || null;
         this[kUrl] = util.parseOrigin(origin);
-        this[kOptions] = { ...util.deepClone(options), connect: connect2, allowH2, clientTtl, socketPath };
+        this[kOptions] = { ...util.deepClone(options), connect: connect3, allowH2, clientTtl, socketPath };
         this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
         this[kFactory] = factory;
         this[kIndex] = -1;
@@ -12619,21 +12619,21 @@ var require_agent = __commonJS({
       return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts);
     }
     var Agent = class extends DispatcherBase {
-      constructor({ factory = defaultFactory, maxOrigins = Infinity, connect: connect2, ...options } = {}) {
+      constructor({ factory = defaultFactory, maxOrigins = Infinity, connect: connect3, ...options } = {}) {
         if (typeof factory !== "function") {
           throw new InvalidArgumentError2("factory must be a function.");
         }
-        if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
+        if (connect3 != null && typeof connect3 !== "function" && typeof connect3 !== "object") {
           throw new InvalidArgumentError2("connect must be a function or an object");
         }
         if (typeof maxOrigins !== "number" || Number.isNaN(maxOrigins) || maxOrigins <= 0) {
           throw new InvalidArgumentError2("maxOrigins must be a number greater than 0");
         }
         super();
-        if (connect2 && typeof connect2 !== "function") {
-          connect2 = { ...connect2 };
+        if (connect3 && typeof connect3 !== "function") {
+          connect3 = { ...connect3 };
         }
-        this[kOptions] = { ...util.deepClone(options), maxOrigins, connect: connect2 };
+        this[kOptions] = { ...util.deepClone(options), maxOrigins, connect: connect3 };
         this[kFactory] = factory;
         this[kClients] = /* @__PURE__ */ new Map();
         this[kOrigins] = /* @__PURE__ */ new Set();
@@ -13432,16 +13432,16 @@ var require_proxy_agent = __commonJS({
     }
     var Http1ProxyWrapper = class extends DispatcherBase {
       #client;
-      constructor(proxyUrl, { headers = {}, connect: connect2, factory }) {
+      constructor(proxyUrl, { headers = {}, connect: connect3, factory }) {
         if (!proxyUrl) {
           throw new InvalidArgumentError2("Proxy URL is mandatory");
         }
         super();
         this[kProxyHeaders] = headers;
         if (factory) {
-          this.#client = factory(proxyUrl, { connect: connect2 });
+          this.#client = factory(proxyUrl, { connect: connect3 });
         } else {
-          this.#client = new Client(proxyUrl, { connect: connect2 });
+          this.#client = new Client(proxyUrl, { connect: connect3 });
         }
       }
       [kDispatch](opts, handler) {
@@ -13502,7 +13502,7 @@ var require_proxy_agent = __commonJS({
         } else if (username && password) {
           this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString("base64")}`;
         }
-        const connect2 = buildConnector({ ...opts.proxyTls });
+        const connect3 = buildConnector({ ...opts.proxyTls });
         this[kConnectEndpoint] = buildConnector({ ...opts.requestTls });
         const agentFactory = opts.factory || defaultAgentFactory;
         const factory = (origin2, options) => {
@@ -13510,7 +13510,7 @@ var require_proxy_agent = __commonJS({
           if (this[kProxy].protocol === "socks5:" || this[kProxy].protocol === "socks:") {
             return new Socks5ProxyAgent(this[kProxy].uri, {
               headers: this[kProxyHeaders],
-              connect: connect2,
+              connect: connect3,
               factory: agentFactory,
               username: opts.username || username,
               password: opts.password || password,
@@ -13520,7 +13520,7 @@ var require_proxy_agent = __commonJS({
           if (!this[kTunnelProxy] && protocol2 === "http:" && this[kProxy].protocol === "http:") {
             return new Http1ProxyWrapper(this[kProxy].uri, {
               headers: this[kProxyHeaders],
-              connect: connect2,
+              connect: connect3,
               factory: agentFactory
             });
           }
@@ -13529,7 +13529,7 @@ var require_proxy_agent = __commonJS({
         if (protocol === "socks5:" || protocol === "socks:") {
           this[kClient] = null;
         } else {
-          this[kClient] = clientFactory(url, { connect: connect2 });
+          this[kClient] = clientFactory(url, { connect: connect3 });
         }
         this[kAgent] = new Agent({
           ...opts,
@@ -14139,7 +14139,7 @@ var require_h2c_client = __commonJS({
             "h2c-client: Only h2c protocol is supported"
           );
         }
-        const { connect: connect2, maxConcurrentStreams, pipelining, ...opts } = clientOpts ?? {};
+        const { connect: connect3, maxConcurrentStreams, pipelining, ...opts } = clientOpts ?? {};
         let defaultMaxConcurrentStreams = 100;
         let defaultPipelining = 100;
         if (maxConcurrentStreams != null && Number.isInteger(maxConcurrentStreams) && maxConcurrentStreams > 0) {
@@ -15328,10 +15328,10 @@ var require_api_connect = __commonJS({
         }
       }
     };
-    function connect2(opts, callback) {
+    function connect3(opts, callback) {
       if (callback === void 0) {
         return new Promise((resolve2, reject) => {
-          connect2.call(this, opts, (err, data) => {
+          connect3.call(this, opts, (err, data) => {
             return err ? reject(err) : resolve2(data);
           });
         });
@@ -15348,7 +15348,7 @@ var require_api_connect = __commonJS({
         queueMicrotask(() => callback(err, { opaque }));
       }
     }
-    module.exports = connect2;
+    module.exports = connect3;
   }
 });
 
@@ -29971,9 +29971,6 @@ function serverDir(slockHome, serverId) {
 function serverAttachmentPath(slockHome, serverId) {
   return path2.join(serverDir(slockHome, serverId), "runner.state.json");
 }
-function legacyServerAttachmentPath(slockHome, serverId) {
-  return path2.join(serverDir(slockHome, serverId), "attachment.json");
-}
 function serverRunnerPidPath(slockHome, serverId) {
   return path2.join(serverDir(slockHome, serverId), "server-runner.pid");
 }
@@ -29995,18 +29992,8 @@ function serviceStatePath(slockHome) {
 function servicePidPath(slockHome) {
   return path2.join(serviceRunDir(slockHome), "service.pid");
 }
-function legacyServicePidPath(slockHome) {
-  return path2.join(computerDir(slockHome), "service.pid");
-}
-function legacySupervisorPidPath(slockHome) {
-  return path2.join(computerDir(slockHome), "supervisor.pid");
-}
 function servicePidReadFallback(slockHome) {
-  return [
-    servicePidPath(slockHome),
-    legacyServicePidPath(slockHome),
-    legacySupervisorPidPath(slockHome)
-  ];
+  return [servicePidPath(slockHome)];
 }
 function serviceLogPath(slockHome) {
   return path2.join(serviceRunDir(slockHome), "service.log");
@@ -30244,14 +30231,7 @@ async function readAttachmentAt(path3) {
 }
 async function readServerAttachment(slockHome, serverId) {
   if (!isValidServerId(serverId)) return null;
-  const current = await readAttachmentAt(serverAttachmentPath(slockHome, serverId));
-  const legacy = await readAttachmentAt(legacyServerAttachmentPath(slockHome, serverId));
-  if (!current) return legacy;
-  if (!legacy) return current;
-  if (legacy.adoptedFromLegacy === true && current.adoptedFromLegacy !== true && legacy.serverMachineId !== current.serverMachineId) {
-    return legacy;
-  }
-  return current;
+  return readAttachmentAt(serverAttachmentPath(slockHome, serverId));
 }
 async function writeServerAttachment(slockHome, attachment) {
   if (!isValidServerId(attachment.serverId)) return;
@@ -30512,8 +30492,8 @@ async function runAttach(opts) {
 // src/setup.ts
 init_esm_shims();
 var import_undici3 = __toESM(require_undici(), 1);
-import { chmod as chmod6, mkdir as mkdir12, readFile as readFile11, rename as rename4, rm as rm3, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname11 } from "path";
+import { chmod as chmod6, mkdir as mkdir13, readFile as readFile12, rename as rename4, rm as rm3, writeFile as writeFile11 } from "fs/promises";
+import { dirname as dirname12 } from "path";
 
 // src/lib/migration.ts
 init_esm_shims();
@@ -31039,8 +31019,8 @@ function readComputerVersion(moduleUrl = import.meta.url) {
 var COMPUTER_VERSION = readComputerVersion();
 
 // src/service.ts
-import { mkdir as mkdir11, readFile as readFile10, writeFile as writeFile9, open, rename as rename3 } from "fs/promises";
-import { dirname as dirname10, join as joinPath } from "path";
+import { mkdir as mkdir12, readFile as readFile11, writeFile as writeFile10, open, rename as rename3 } from "fs/promises";
+import { dirname as dirname11, join as joinPath } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/cleanup.ts
@@ -31400,6 +31380,53 @@ async function emitRunnerStateTransition(slockHome, serverId, fromState, toState
   }
 }
 
+// src/lib/runnerStateMachine.ts
+init_esm_shims();
+var RUNNER_TRIGGER = {
+  spawn: "spawn",
+  spawnFailed: "spawn-failed",
+  ready: "ready",
+  exitGraceful: "exit-graceful",
+  exitCrash: "exit-crash",
+  exitCrashDegraded: "exit-crash-degraded",
+  exitConfigError: "exit-config-error",
+  detachStop: "detach-stop",
+  shutdownStop: "shutdown-stop",
+  reset: "reset"
+};
+function nextRunnerStateOnExit(exitClass, budgetBreached) {
+  if (exitClass === "config-error") return "degraded";
+  if (exitClass === "crash") return budgetBreached ? "degraded" : "crashed";
+  return "stopped";
+}
+function exitTrigger(exitClass, budgetBreached) {
+  if (exitClass === "config-error") return RUNNER_TRIGGER.exitConfigError;
+  if (exitClass === "crash") {
+    return budgetBreached ? RUNNER_TRIGGER.exitCrashDegraded : RUNNER_TRIGGER.exitCrash;
+  }
+  return RUNNER_TRIGGER.exitGraceful;
+}
+function canSpawn(rec, wanted, now) {
+  if (!wanted) return false;
+  if (!rec) return true;
+  if (rec.child) return false;
+  if (rec.lifecycle !== "crashed" && rec.lifecycle !== "stopped") return false;
+  return now >= (rec.backoffUntil ?? 0);
+}
+function rehydrateRunnerRecord(serverId, degraded) {
+  return {
+    serverId,
+    lifecycle: degraded ? "degraded" : "stopped",
+    stopping: false
+  };
+}
+function applyRunnerReset(rec) {
+  if (rec.lifecycle !== "degraded") return false;
+  rec.lifecycle = "stopped";
+  rec.backoffUntil = void 0;
+  return true;
+}
+
 // src/services/start.ts
 init_esm_shims();
 
@@ -32575,120 +32602,569 @@ async function listRunners(installRoot, opts = {}) {
   return { servers };
 }
 
-// src/service.ts
-var seaRequire = createRequire2(import.meta.url);
-var cachedIsSea;
-function isSeaBinary() {
-  if (cachedIsSea !== void 0) return cachedIsSea;
+// src/reset.ts
+init_esm_shims();
+
+// src/serviceState.ts
+init_esm_shims();
+import { mkdir as mkdir11, readFile as readFile10, writeFile as writeFile9, appendFile as appendFile3 } from "fs/promises";
+import { dirname as dirname10 } from "path";
+
+// src/lib/state.ts
+init_esm_shims();
+var SERVICE_STATE_VALUES = [
+  "starting",
+  "running",
+  "degraded",
+  "stopping",
+  "stopped"
+];
+function isServiceState(value) {
+  return typeof value === "string" && SERVICE_STATE_VALUES.includes(value);
+}
+
+// src/serviceState.ts
+var DEFAULT_STATE = {
+  state: "running",
+  crashHistory: []
+};
+async function readServiceState(slockHome) {
   try {
-    cachedIsSea = seaRequire("node:sea").isSea();
+    const raw = await readFile10(serviceStatePath(slockHome), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return { ...DEFAULT_STATE };
+    const obj = parsed;
+    const state = isServiceState(obj.state) ? obj.state : "running";
+    const crashHistory = Array.isArray(obj.crashHistory) ? obj.crashHistory.filter(isCrashEntry) : [];
+    return { state, crashHistory };
   } catch {
-    cachedIsSea = false;
+    return { ...DEFAULT_STATE };
   }
-  return cachedIsSea;
 }
-function buildResidentSpawn(mode, serverId, selfEntry = process.argv[1] ?? "", execArgv = process.execArgv, isSea = isSeaBinary()) {
-  const tail = serverId ? [mode, serverId] : [mode];
-  if (isSea) {
-    return { command: process.execPath, args: [...execArgv, ...tail] };
-  }
-  return { command: process.execPath, args: [...execArgv, selfEntry, ...tail] };
+async function writeServiceState(slockHome, file) {
+  const path3 = serviceStatePath(slockHome);
+  await mkdir11(dirname10(path3), { recursive: true });
+  await writeFile9(path3, JSON.stringify(file), { mode: 384 });
 }
-var PARENT_LOCK_HELD_ENV_VAR = "SLOCK_COMPUTER_PARENT_MUTATION_LOCK_HELD";
-async function spawnDetachedService(slockHome) {
-  await mkdir11(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],
-    windowsHide: true,
-    env: { ...process.env, [PARENT_LOCK_HELD_ENV_VAR]: "1" }
-  });
-  child.on("error", (err) => {
-    process.stderr.write(
-      `${JSON.stringify({ ok: false, code: "SUPERVISOR_SPAWN_FAILED", message: err.message })}
-`
-    );
-  });
-  const pid = child.pid;
-  child.unref();
-  await supLogFd.close();
-  if (!pid) {
-    throw new Error("SUPERVISOR_SPAWN_FAILED: could not spawn the service process");
-  }
-  await writePidfileAt(servicePidPath(slockHome), pid);
-  return pid;
+function isCrashEntry(value) {
+  if (!value || typeof value !== "object") return false;
+  const obj = value;
+  return typeof obj.at === "string";
 }
-var EX_CONFIG_EXIT_CODE = 78;
-async function ensureSeaRuntimePackageDir() {
-  if (!isSeaBinary() || process.env.PI_PACKAGE_DIR) return;
+async function emitServiceStateTransition(slockHome, fromState, toState, trigger) {
+  const entry = {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    kind: "service-state-changed",
+    fromState,
+    toState,
+    trigger
+  };
   try {
-    const dir = joinPath(resolveSlockHome(), "runtime-pkg");
-    await mkdir11(dir, { recursive: true });
-    await writeFile9(
-      joinPath(dir, "package.json"),
-      `${JSON.stringify({ name: "slock-computer-sea-runtime", version: COMPUTER_VERSION })}
-`
-    );
-    process.env.PI_PACKAGE_DIR = dir;
+    const path3 = serviceLogPath(slockHome);
+    await mkdir11(dirname10(path3), { recursive: true });
+    await appendFile3(path3, JSON.stringify(entry) + "\n");
   } catch {
   }
 }
-var defaultCoreFactory = async (creds) => {
-  await ensureSeaRuntimePackageDir();
-  let coreMod;
+async function clearServiceCrashHistory(slockHome) {
+  const current = await readServiceState(slockHome);
+  const previousState = current.state;
+  const clearedCrashCount = current.crashHistory.length;
+  const next = { state: "running", crashHistory: [] };
+  await writeServiceState(slockHome, next);
+  await emitServiceStateTransition(
+    slockHome,
+    previousState,
+    "running",
+    "reset-service"
+  );
+  return { previousState, clearedCrashCount };
+}
+
+// src/targetServer.ts
+init_esm_shims();
+function attachmentLabel(a) {
+  return formatServerSlugDisplay(a.serverSlug);
+}
+async function refreshAttachmentSlug(home, attachment) {
   try {
-    coreMod = await import("@botiverse/raft-daemon/core");
-  } catch (err) {
-    const code = err?.code;
-    const isModuleMissing = code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND" || err instanceof Error && /Cannot find (module|package)/i.test(err.message);
-    if (isModuleMissing) {
-      process.stderr.write(
-        `slock-computer: per-server daemon failed to load \`@botiverse/raft-daemon/core\`.
-  Reason: ${err instanceof Error ? err.message : String(err)}
-  This usually means a source-run workspace without a built daemon dist.
-  Fix: run \`pnpm --filter @botiverse/raft-daemon build\` once, then \`slock-computer doctor <server> --reset-health && slock-computer start\`.
-  (Packaged/npx installs ship the dist already \u2014 this only affects local source-run setups.)
-`
+    const client = new ComputerAttachClient(attachment.serverUrl, "");
+    const result = await client.preflight(attachment.apiKey);
+    if (!result.ok || !result.serverSlug || result.serverSlug === attachment.serverSlug) {
+      return attachment;
+    }
+    const updated = { ...attachment, serverSlug: result.serverSlug };
+    await writeServerAttachment(home, updated);
+    return updated;
+  } catch {
+    return attachment;
+  }
+}
+async function listAttachmentsWithFreshSlugs(home) {
+  const attachments = await listServerAttachments(home);
+  return await Promise.all(attachments.map((a) => refreshAttachmentSlug(home, a)));
+}
+async function resolveTargetServerId(opts) {
+  const home = resolveSlockHome();
+  let attachments = await listServerAttachments(home);
+  if (attachments.length === 0) {
+    fail("NO_ATTACHMENT", "No server attachments yet. Run `slock-computer attach /<serverSlug>` (e.g. `/myserver`) first.");
+  }
+  const requested = normalizeServerSlug(opts.server ?? "");
+  if (requested) {
+    let found = attachments.find((a) => a.serverSlug === requested);
+    if (!found) {
+      attachments = await listAttachmentsWithFreshSlugs(home);
+      found = attachments.find((a) => a.serverSlug === requested);
+    }
+    if (!found) {
+      fail(
+        "NOT_ATTACHED",
+        `Server slug ${formatServerSlugDisplay(requested)} is not attached. Attached server slugs: ${attachments.map(attachmentLabel).join(", ")}.`
       );
-      process.exit(EX_CONFIG_EXIT_CODE);
     }
-    throw err;
+    return found.serverId;
   }
-  process.env.SLOCK_COMPUTER_VERSION = COMPUTER_VERSION;
-  return new coreMod.DaemonCore({
-    serverUrl: creds.serverUrl,
-    apiKey: creds.apiKey,
-    localTrace: true,
-    // In a SEA single-binary there is no sidecar `slock` CLI script for the
-    // daemon to resolve, so inject the `__cli` sentinel: the agent CLI wrapper
-    // then execs `<exe> __cli "$@"`, re-execing this binary in CLI mode
-    // (runBundledSlockCli). Normal installs leave this unset → the daemon
-    // resolves the bundled CLI dist path as before.
-    slockCliPath: isSeaBinary() ? "__cli" : void 0,
-    // Managed-Computer remote control (server → WS → runner). This runner
-    // is the service's in-process `__run` child, so:
-    //   restart → SIGTERM ourselves → runResident's shutdown does
-    //     core.stop() + exit 0 → classifyRunnerExit = graceful → the
-    //     service supervisor respawns this runner (effective restart).
-    //   upgrade (SEA + requestId) → run the SEA upgrade IN-PROCESS so we can
-    //     stream `computer:upgrade:progress` over this live WS, then SIGTERM
-    //     ourselves; the supervisor respawns the swapped binary and the new
-    //     process reports `done` via onComputerUpgradeReconcile on reconnect.
-    //   upgrade (non-SEA dev run, or no requestId) → SEA-only no-op. The
-    //     npm-install-root upgrade path is retired: a managed Computer is a
-    //     SEA single binary; a source/dev run has no binary to self-swap.
-    onComputerControl: (action, ctx) => {
-      if (action === "restart") {
-        process.kill(process.pid, "SIGTERM");
-        return;
+  if (attachments.length === 1) return attachments[0].serverId;
+  fail(
+    "AMBIGUOUS_SERVER",
+    `Multiple servers attached (${attachments.map(attachmentLabel).join(", ")}). Pass \`--server /<serverSlug>\` (e.g. \`--server ${attachmentLabel(attachments[0])}\`) to choose one.`
+  );
+}
+async function resolveTargetAttachment(opts) {
+  const serverId = await resolveTargetServerId(opts);
+  const a = await readServerAttachment(resolveSlockHome(), serverId);
+  if (!a) {
+    const label = opts.server ?? serverId;
+    fail("INVALID_ATTACHMENT", `Attachment for ${label} is missing/invalid. Re-run \`slock-computer attach ${label}\`.`);
+  }
+  return a;
+}
+
+// src/lib/ipc-client.ts
+init_esm_shims();
+import { connect as connect2 } from "net";
+import { randomUUID } from "crypto";
+var DEFAULT_PROTOCOL_VERSION = 1;
+var CLIENT_KIND = "lib";
+var CLIENT_VERSION = "0.0.0";
+function resolveTransportPath2(installRoot) {
+  return process.platform === "win32" ? serviceWindowsPipeName(installRoot) : serviceSocketPath(installRoot);
+}
+async function connectService(installRoot, options = {}) {
+  const protocolVersion = options.protocolVersion ?? DEFAULT_PROTOCOL_VERSION;
+  const transportPath = resolveTransportPath2(installRoot);
+  const socket = await new Promise((resolve2, reject) => {
+    const s = connect2({ path: transportPath });
+    s.once("connect", () => resolve2(s));
+    s.once("error", (err) => reject(
+      new ServiceClientError("IPC_PROTOCOL_HANDSHAKE_FAILED", `unable to connect to ${transportPath}: ${err.message}`, err)
+    ));
+  });
+  const decoder = new FrameDecoder();
+  const pendingRequests = /* @__PURE__ */ new Map();
+  const eventQueue = [];
+  const eventWaiters = [];
+  let closed = false;
+  let protocolError = null;
+  function terminate(error) {
+    if (closed) return;
+    closed = true;
+    if (error) protocolError = error;
+    socket.destroy();
+    for (const pending of pendingRequests.values()) {
+      pending.reject(error ?? new ServiceClientError("IPC_CLIENT_CLOSED", "service client closed before response"));
+    }
+    pendingRequests.clear();
+    for (const waiter of eventWaiters) waiter.resolve(null);
+    eventWaiters.length = 0;
+  }
+  function dispatchFrame(frame) {
+    if (!isRecord2(frame) || typeof frame.type !== "string") {
+      throw new ServiceClientError("IPC_MALFORMED_FRAME", "frame is missing required `type` field");
+    }
+    if (frame.type === "event") {
+      const event = { kind: String(frame.kind), payload: frame.payload };
+      if (eventWaiters.length > 0) {
+        const waiter = eventWaiters.shift();
+        waiter.resolve(event);
+      } else {
+        eventQueue.push(event);
       }
-      if (isSeaBinary() && ctx.requestId) {
-        return runManagedSeaUpgrade(ctx.requestId, ctx);
+      return;
+    }
+    if (frame.type === "response") {
+      const id = String(frame.id ?? "");
+      const pending = pendingRequests.get(id);
+      if (!pending) return;
+      pendingRequests.delete(id);
+      if ("error" in frame && isRecord2(frame.error)) {
+        const code = String(frame.error.code ?? "IPC_MALFORMED_FRAME");
+        const message = String(frame.error.message ?? "service request failed");
+        pending.reject(new ServiceClientError(code, message));
+      } else {
+        pending.resolve(frame.result);
       }
-      console.warn(
-        `[Computer] Ignoring upgrade request: in-process SEA upgrade unavailable (isSea=${isSeaBinary()}, requestId=${ctx.requestId ? "present" : "absent"}). Managed upgrade requires a SEA binary invoked with a requestId.`
+      return;
+    }
+    if (frame.type === "ping") {
+      socket.write(encodeFrame({ type: "pong" }));
+      return;
+    }
+    if (frame.type === "pong") {
+      return;
+    }
+  }
+  socket.on("data", (chunk) => {
+    try {
+      decoder.push(chunk);
+      const frames = decoder.drain();
+      for (const frame of frames) {
+        dispatchFrame(frame);
+      }
+    } catch (error) {
+      terminate(error instanceof ServiceClientError ? error : new ServiceClientError("IPC_MALFORMED_FRAME", "frame decode failed", error));
+    }
+  });
+  socket.on("close", () => terminate(null));
+  socket.on("error", (err) => terminate(
+    new ServiceClientError("IPC_MALFORMED_FRAME", `socket error: ${err.message}`, err)
+  ));
+  await new Promise((resolve2, reject) => {
+    let settled = false;
+    const settle = (action) => {
+      if (settled) return;
+      settled = true;
+      socket.removeListener("close", onHandshakeClose);
+      socket.removeListener("error", onHandshakeError);
+      action();
+    };
+    const onHandshakeClose = () => settle(() => {
+      reject(new ServiceClientError(
+        "IPC_PROTOCOL_HANDSHAKE_FAILED",
+        "service closed connection before sending hello-ack"
+      ));
+    });
+    const onHandshakeError = (err) => settle(() => {
+      reject(new ServiceClientError(
+        "IPC_PROTOCOL_HANDSHAKE_FAILED",
+        `handshake socket error: ${err.message}`,
+        err
+      ));
+    });
+    socket.once("close", onHandshakeClose);
+    socket.once("error", onHandshakeError);
+    const onFirstFrame = (chunk) => {
+      socket.removeListener("data", onFirstFrame);
+      try {
+        decoder.push(chunk);
+        const frames = decoder.drain();
+        if (frames.length === 0) {
+          socket.once("data", onFirstFrame);
+          return;
+        }
+        const [firstFrame, ...remaining] = frames;
+        if (!isRecord2(firstFrame) || typeof firstFrame.type !== "string") {
+          settle(() => reject(new ServiceClientError("IPC_PROTOCOL_HANDSHAKE_FAILED", "handshake response missing `type`")));
+          return;
+        }
+        if (firstFrame.type === "hello-reject") {
+          const reason = String(firstFrame.reason ?? "IPC_PROTOCOL_VERSION_UNSUPPORTED");
+          settle(() => reject(new ServiceClientError(
+            reason === "IPC_PROTOCOL_VERSION_UNSUPPORTED" ? "IPC_PROTOCOL_VERSION_UNSUPPORTED" : "IPC_PROTOCOL_HANDSHAKE_FAILED",
+            `service rejected handshake: ${String(firstFrame.reason ?? "unknown")}`
+          )));
+          return;
+        }
+        if (firstFrame.type !== "hello-ack") {
+          settle(() => reject(new ServiceClientError("IPC_PROTOCOL_HANDSHAKE_FAILED", `expected hello-ack, got \`${firstFrame.type}\``)));
+          return;
+        }
+        for (const frame of remaining) {
+          dispatchFrame(frame);
+        }
+        settle(resolve2);
+      } catch (error) {
+        settle(() => reject(error instanceof ServiceClientError ? error : new ServiceClientError("IPC_PROTOCOL_HANDSHAKE_FAILED", "handshake decode failed", error)));
+      }
+    };
+    socket.once("data", onFirstFrame);
+    socket.write(encodeFrame({
+      type: "hello",
+      protocolVersion,
+      clientKind: CLIENT_KIND,
+      clientVersion: CLIENT_VERSION
+    }));
+  });
+  const events = {
+    [Symbol.asyncIterator]() {
+      return {
+        async next() {
+          if (eventQueue.length > 0) {
+            return { value: eventQueue.shift(), done: false };
+          }
+          if (closed) {
+            if (protocolError) throw protocolError;
+            return { value: void 0, done: true };
+          }
+          return new Promise((resolve2, reject) => {
+            eventWaiters.push({
+              resolve: (event) => {
+                if (event === null) {
+                  if (protocolError) reject(protocolError);
+                  else resolve2({ value: void 0, done: true });
+                } else {
+                  resolve2({ value: event, done: false });
+                }
+              }
+            });
+          });
+        },
+        async return() {
+          terminate(null);
+          return { value: void 0, done: true };
+        }
+      };
+    }
+  };
+  const client = {
+    events,
+    async request(method, params, _options = {}) {
+      if (closed) {
+        throw protocolError ?? new ServiceClientError("IPC_CLIENT_CLOSED", "service client is closed");
+      }
+      const id = randomUUID();
+      return new Promise((resolve2, reject) => {
+        pendingRequests.set(id, {
+          resolve: (value) => resolve2(value),
+          reject
+        });
+        try {
+          socket.write(encodeFrame({ type: "request", id, method, params }));
+        } catch (error) {
+          pendingRequests.delete(id);
+          reject(error);
+        }
+      });
+    },
+    async close() {
+      terminate(null);
+    }
+  };
+  return client;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/reset.ts
+async function resetViaServiceOrDisk(slockHome, viaService, direct) {
+  let client = null;
+  try {
+    client = await connectService(slockHome);
+  } catch {
+    client = null;
+  }
+  if (!client) return direct();
+  try {
+    return await viaService(client);
+  } finally {
+    await client.close();
+  }
+}
+async function resetService(installRoot) {
+  const { previousState, clearedCrashCount } = await clearServiceCrashHistory(installRoot);
+  return {
+    status: "ok",
+    previousState,
+    clearedCrashCount
+  };
+}
+async function resetRunner(installRoot, serverId) {
+  const attachment = await readServerAttachment(installRoot, serverId);
+  if (!attachment) {
+    return { status: "not-found", serverId };
+  }
+  const outcome = await resetRunnerHealth(installRoot, serverId);
+  if (outcome.status === "not-found") {
+    return { status: "not-found", serverId };
+  }
+  return {
+    status: "ok",
+    serverId,
+    previousState: outcome.previousState ?? "running",
+    clearedCrashCount: outcome.clearedCrashCount ?? 0
+  };
+}
+async function runReset(opts) {
+  const wantsService = opts.service === true;
+  const wantsRunner = opts.runner === true;
+  if (wantsService && wantsRunner) {
+    fail(
+      "RESET_SCOPE_AMBIGUOUS",
+      "`--service` and `--runner` are mutually exclusive. Pass exactly one."
+    );
+  }
+  if (!wantsService && !wantsRunner) {
+    fail(
+      "RESET_SCOPE_MISSING",
+      "Pass `--service` to clear the service-level crash history, or `--runner` to clear a per-runner crash history."
+    );
+  }
+  const slockHome = resolveSlockHome();
+  if (wantsService) {
+    const result2 = await resetViaServiceOrDisk(
+      slockHome,
+      (client) => client.request("reset-service", void 0),
+      () => resetService(slockHome)
+    );
+    if (opts.json) {
+      info(JSON.stringify(result2));
+      return;
+    }
+    info(
+      `Reset service crash history (previous state: ${result2.previousState}; cleared ${result2.clearedCrashCount} entr${result2.clearedCrashCount === 1 ? "y" : "ies"}).`
+    );
+    info("Service state transitioned to `running`. Runners were not touched.");
+    return;
+  }
+  const serverId = await resolveTargetServerId({ server: opts.server });
+  const result = await resetViaServiceOrDisk(
+    slockHome,
+    (client) => client.request("reset-runner", { serverId }),
+    () => resetRunner(slockHome, serverId)
+  );
+  if (result.status === "not-found") {
+    fail(
+      "RESET_RUNNER_NOT_FOUND",
+      `Runner for server ${serverId} was not found.`
+    );
+  }
+  if (opts.json) {
+    info(JSON.stringify(result));
+    return;
+  }
+  info(
+    `Reset runner crash history for server ${result.serverId} (previous state: ${result.previousState}; cleared ${result.clearedCrashCount} entr${result.clearedCrashCount === 1 ? "y" : "ies"}).`
+  );
+  info("Runner state transitioned to `running`. Process was not respawned.");
+}
+
+// src/service.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var seaRequire = createRequire2(import.meta.url);
+var cachedIsSea;
+function isSeaBinary() {
+  if (cachedIsSea !== void 0) return cachedIsSea;
+  try {
+    cachedIsSea = seaRequire("node:sea").isSea();
+  } catch {
+    cachedIsSea = false;
+  }
+  return cachedIsSea;
+}
+function buildResidentSpawn(mode, serverId, selfEntry = process.argv[1] ?? "", execArgv = process.execArgv, isSea = isSeaBinary()) {
+  const tail = serverId ? [mode, serverId] : [mode];
+  if (isSea) {
+    return { command: process.execPath, args: [...execArgv, ...tail] };
+  }
+  return { command: process.execPath, args: [...execArgv, selfEntry, ...tail] };
+}
+var PARENT_LOCK_HELD_ENV_VAR = "SLOCK_COMPUTER_PARENT_MUTATION_LOCK_HELD";
+async function spawnDetachedService(slockHome) {
+  await mkdir12(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],
+    windowsHide: true,
+    env: { ...process.env, [PARENT_LOCK_HELD_ENV_VAR]: "1" }
+  });
+  child.on("error", (err) => {
+    process.stderr.write(
+      `${JSON.stringify({ ok: false, code: "SUPERVISOR_SPAWN_FAILED", message: err.message })}
+`
+    );
+  });
+  const pid = child.pid;
+  child.unref();
+  await supLogFd.close();
+  if (!pid) {
+    throw new Error("SUPERVISOR_SPAWN_FAILED: could not spawn the service process");
+  }
+  await writePidfileAt(servicePidPath(slockHome), pid);
+  return pid;
+}
+var EX_CONFIG_EXIT_CODE = 78;
+async function ensureSeaRuntimePackageDir() {
+  if (!isSeaBinary() || process.env.PI_PACKAGE_DIR) return;
+  try {
+    const dir = joinPath(resolveSlockHome(), "runtime-pkg");
+    await mkdir12(dir, { recursive: true });
+    await writeFile10(
+      joinPath(dir, "package.json"),
+      `${JSON.stringify({ name: "slock-computer-sea-runtime", version: COMPUTER_VERSION })}
+`
+    );
+    process.env.PI_PACKAGE_DIR = dir;
+  } catch {
+  }
+}
+var defaultCoreFactory = async (creds) => {
+  await ensureSeaRuntimePackageDir();
+  let coreMod;
+  try {
+    coreMod = await import("@botiverse/raft-daemon/core");
+  } catch (err) {
+    const code = err?.code;
+    const isModuleMissing = code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND" || err instanceof Error && /Cannot find (module|package)/i.test(err.message);
+    if (isModuleMissing) {
+      process.stderr.write(
+        `slock-computer: per-server daemon failed to load \`@botiverse/raft-daemon/core\`.
+  Reason: ${err instanceof Error ? err.message : String(err)}
+  This usually means a source-run workspace without a built daemon dist.
+  Fix: run \`pnpm --filter @botiverse/raft-daemon build\` once, then \`slock-computer doctor <server> --reset-health && slock-computer start\`.
+  (Packaged/npx installs ship the dist already \u2014 this only affects local source-run setups.)
+`
+      );
+      process.exit(EX_CONFIG_EXIT_CODE);
+    }
+    throw err;
+  }
+  process.env.SLOCK_COMPUTER_VERSION = COMPUTER_VERSION;
+  return new coreMod.DaemonCore({
+    serverUrl: creds.serverUrl,
+    apiKey: creds.apiKey,
+    localTrace: true,
+    // In a SEA single-binary there is no sidecar `slock` CLI script for the
+    // daemon to resolve, so inject the `__cli` sentinel: the agent CLI wrapper
+    // then execs `<exe> __cli "$@"`, re-execing this binary in CLI mode
+    // (runBundledSlockCli). Normal installs leave this unset → the daemon
+    // resolves the bundled CLI dist path as before.
+    slockCliPath: isSeaBinary() ? "__cli" : void 0,
+    // Managed-Computer remote control (server → WS → runner). This runner
+    // is the service's in-process `__run` child, so:
+    //   restart → SIGTERM ourselves → runResident's shutdown does
+    //     core.stop() + exit 0 → classifyRunnerExit = graceful → the
+    //     service supervisor respawns this runner (effective restart).
+    //   upgrade (SEA + requestId) → run the SEA upgrade IN-PROCESS so we can
+    //     stream `computer:upgrade:progress` over this live WS, then SIGTERM
+    //     ourselves; the supervisor respawns the swapped binary and the new
+    //     process reports `done` via onComputerUpgradeReconcile on reconnect.
+    //   upgrade (non-SEA dev run, or no requestId) → SEA-only no-op. The
+    //     npm-install-root upgrade path is retired: a managed Computer is a
+    //     SEA single binary; a source/dev run has no binary to self-swap.
+    onComputerControl: (action, ctx) => {
+      if (action === "restart") {
+        process.kill(process.pid, "SIGTERM");
+        return;
+      }
+      if (isSeaBinary() && ctx.requestId) {
+        return runManagedSeaUpgrade(ctx.requestId, ctx);
+      }
+      console.warn(
+        `[Computer] Ignoring upgrade request: in-process SEA upgrade unavailable (isSea=${isSeaBinary()}, requestId=${ctx.requestId ? "present" : "absent"}). Managed upgrade requires a SEA binary invoked with a requestId.`
       );
     },
     // Blip-stitch: on every (re)connect, if THIS process booted from a freshly
@@ -32778,9 +33254,6 @@ async function runResident(serverId, deps = {}) {
 }
 var RECONCILE_INTERVAL_MS = 5e3;
 var CHILD_RESTART_BACKOFF_MS = 2e3;
-function canSupervisorSpawnChild(serverId, running, restarting) {
-  return !running.has(serverId) && !restarting.has(serverId);
-}
 function formatReadySummary(ready, serverIds, opts) {
   if (opts.serverId && serverIds.length === 1) {
     const pid = ready.get(opts.serverId);
@@ -32821,10 +33294,10 @@ async function runServiceStartupRecovery(slockHome) {
 }
 async function resolveServiceIdentity() {
   const here = fileURLToPath2(import.meta.url);
-  const installRoot = dirname10(dirname10(here));
+  const installRoot = dirname11(dirname11(here));
   let version = null;
   try {
-    const raw = await readFile10(joinPath(installRoot, "package.json"), "utf8");
+    const raw = await readFile11(joinPath(installRoot, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.version === "string" && parsed.version.length > 0) {
       version = parsed.version;
@@ -32847,7 +33320,7 @@ async function writeServiceVersionEvidence(slockHome) {
     };
     const dest = serviceVersionPath(slockHome);
     const tmp = `${dest}.tmp`;
-    await writeFile9(tmp, JSON.stringify(payload) + "\n", { mode: 384 });
+    await writeFile10(tmp, JSON.stringify(payload) + "\n", { mode: 384 });
     await rename3(tmp, dest);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -32857,7 +33330,7 @@ async function writeServiceVersionEvidence(slockHome) {
     );
   }
 }
-async function startServiceIpcSeam(slockHome) {
+async function startServiceIpcSeam(slockHome, mutations) {
   const handlers = {
     "service-status": async () => readServiceStatus(slockHome),
     "runner-status": async ({ serverId }) => {
@@ -32870,7 +33343,18 @@ async function startServiceIpcSeam(slockHome) {
         throw err;
       }
     },
-    "list-runners": async () => listRunners(slockHome)
+    "list-runners": async () => listRunners(slockHome),
+    "reset-service": async () => mutations ? mutations.resetService() : resetService(slockHome),
+    "reset-runner": async ({ serverId }) => mutations ? mutations.resetRunner(serverId) : resetRunner(slockHome, serverId),
+    "upgrade-start": async (params) => {
+      if (!mutations) {
+        throw new ServiceClientError(
+          "IPC_MALFORMED_FRAME",
+          "upgrade-start requires a live supervisor mutation surface"
+        );
+      }
+      return mutations.upgradeStart(params);
+    }
   };
   const ipc = createIpcServer({ installRoot: slockHome, handlers });
   try {
@@ -32888,17 +33372,33 @@ async function startServiceIpcSeam(slockHome) {
 }
 async function runService() {
   const slockHome = resolveSlockHome();
-  await mkdir11(serviceRunDir(slockHome), { recursive: true });
+  await mkdir12(serviceRunDir(slockHome), { recursive: true });
   await runServiceStartupRecovery(slockHome);
   await writePidfileAt(servicePidPath(slockHome), process.pid);
   await writeServiceVersionEvidence(slockHome);
-  const children = /* @__PURE__ */ new Map();
-  const restarting = /* @__PURE__ */ new Set();
+  const runners2 = /* @__PURE__ */ new Map();
+  let shuttingDown = false;
+  let inFlightUpgrade = null;
   const { [PARENT_LOCK_HELD_ENV_VAR]: _parentLockMarker, ...childEnv } = process.env;
+  const emitTransition = (serverId, from, to, trigger) => {
+    void emitRunnerStateTransition(slockHome, serverId, from, to, trigger);
+  };
+  let scheduleReconcile = () => {
+  };
   const spawnChild = async (serverId) => {
-    if (children.has(serverId)) return;
+    if (shuttingDown) return;
+    const existing = runners2.get(serverId);
+    if (existing?.child) return;
+    const fromState = existing?.lifecycle ?? "stopped";
+    const record = existing ?? { serverId, lifecycle: "stopped", stopping: false };
+    record.lifecycle = "starting";
+    record.stopping = false;
+    record.backoffUntil = void 0;
+    record.child = void 0;
+    runners2.set(serverId, record);
+    emitTransition(serverId, fromState, "starting", RUNNER_TRIGGER.spawn);
     const logPath = serverRunnerLogPath(slockHome, serverId);
-    await mkdir11(dirname10(logPath), { recursive: true });
+    await mkdir12(dirname11(logPath), { recursive: true });
     const logFd = await open(logPath, "a");
     const { command, args } = buildResidentSpawn("__run", serverId);
     const child = spawn2(command, args, {
@@ -32907,89 +33407,159 @@ async function runService() {
       env: childEnv
     });
     await logFd.close();
-    if (!child.pid) return;
-    const handle = { serverId, child, stopping: false };
-    children.set(serverId, handle);
+    if (!child.pid) {
+      record.lifecycle = "crashed";
+      record.backoffUntil = Date.now() + CHILD_RESTART_BACKOFF_MS;
+      emitTransition(serverId, "starting", "crashed", RUNNER_TRIGGER.spawnFailed);
+      scheduleReconcile(CHILD_RESTART_BACKOFF_MS);
+      return;
+    }
+    record.child = child;
+    record.lifecycle = "running";
+    emitTransition(serverId, "starting", "running", RUNNER_TRIGGER.ready);
     await writePidfileAt(serverRunnerPidPath(slockHome, serverId), child.pid);
     child.on("exit", (code, signal) => {
       void (async () => {
-        children.delete(serverId);
+        const rec = runners2.get(serverId);
+        if (!rec) return;
+        rec.child = void 0;
         await clearPidfileAt(serverRunnerPidPath(slockHome, serverId));
-        if (handle.stopping) return;
-        const classification = classifyRunnerExit(code, signal);
-        if (classification === "config-error") {
+        if (rec.stopping) {
+          const trigger = shuttingDown ? RUNNER_TRIGGER.shutdownStop : RUNNER_TRIGGER.detachStop;
+          const prev2 = rec.lifecycle;
+          rec.lifecycle = "stopped";
+          emitTransition(serverId, prev2, "stopped", trigger);
+          return;
+        }
+        const exitClass = classifyRunnerExit(code, signal);
+        if (exitClass === "config-error") {
           try {
             await markFatalConfig(slockHome, serverId, code, signal);
           } catch {
           }
+          const prev2 = rec.lifecycle;
+          rec.lifecycle = "degraded";
+          emitTransition(serverId, prev2, "degraded", RUNNER_TRIGGER.exitConfigError);
           process.stderr.write(
             `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;
         }
-        if (classification === "graceful") {
-          restarting.add(serverId);
+        if (exitClass === "crash") {
           try {
-            await new Promise((r) => setTimeout(r, CHILD_RESTART_BACKOFF_MS));
-            if (await readServerAttachment(slockHome, serverId) && !shuttingDown) {
-              await spawnChild(serverId);
-            }
-          } finally {
-            restarting.delete(serverId);
+            await recordCrash(slockHome, serverId, code, signal);
+          } catch {
           }
-          return;
-        }
-        try {
-          await recordCrash(slockHome, serverId, code, signal);
-        } catch {
         }
-        if (await isDegraded(slockHome, serverId)) {
+        const budgetBreached = exitClass === "crash" ? await isDegraded(slockHome, serverId) : false;
+        const prev = rec.lifecycle;
+        const to = nextRunnerStateOnExit(exitClass, budgetBreached);
+        rec.lifecycle = to;
+        emitTransition(serverId, prev, to, exitTrigger(exitClass, budgetBreached));
+        if (to === "degraded") {
           process.stderr.write(
             `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;
         }
-        restarting.add(serverId);
-        try {
-          await new Promise((r) => setTimeout(r, CHILD_RESTART_BACKOFF_MS));
-          if (await readServerAttachment(slockHome, serverId) && !shuttingDown) {
-            await spawnChild(serverId);
-          }
-        } finally {
-          restarting.delete(serverId);
-        }
+        rec.backoffUntil = Date.now() + CHILD_RESTART_BACKOFF_MS;
+        scheduleReconcile(CHILD_RESTART_BACKOFF_MS);
       })();
     });
   };
-  const killChild = (handle) => {
-    handle.stopping = true;
+  const killChild = (rec) => {
+    rec.stopping = true;
     try {
-      handle.child.kill("SIGTERM");
+      rec.child?.kill("SIGTERM");
     } catch {
     }
   };
   const reconcile = async () => {
+    if (shuttingDown) return;
     const wanted = new Set(await listManagedServerIds(slockHome));
+    const now = Date.now();
     for (const id of wanted) {
-      if (canSupervisorSpawnChild(id, children, restarting)) await spawnChild(id);
+      if (canSpawn(runners2.get(id), true, now)) await spawnChild(id);
     }
-    for (const [id, handle] of children) {
-      if (!wanted.has(id)) killChild(handle);
+    for (const [id, rec] of runners2) {
+      if (!wanted.has(id) && rec.child) killChild(rec);
     }
   };
-  const ipc = await startServiceIpcSeam(slockHome);
-  let shuttingDown = false;
+  scheduleReconcile = (delayMs) => {
+    setTimeout(() => void reconcile(), Math.max(0, delayMs));
+  };
+  const ipc = await startServiceIpcSeam(slockHome, {
+    resetService: () => resetService(slockHome),
+    resetRunner: async (serverId) => {
+      const result = await resetRunner(slockHome, serverId);
+      if (result.status === "ok") {
+        const rec = runners2.get(serverId);
+        if (rec && applyRunnerReset(rec)) {
+          emitTransition(serverId, "degraded", "stopped", RUNNER_TRIGGER.reset);
+          scheduleReconcile(0);
+        }
+      }
+      return result;
+    },
+    // `upgrade-start` (phase ①b): the running service drives the SEA upgrade
+    // in-process (reusing the tested resolveAndRunSeaUpgrade) instead of the
+    // service spawning a `slock-computer upgrade` subprocess — single-writer
+    // initiation. Async: resolve the target version (so the `started` response
+    // carries it), then kick off download+verify+swap WITHOUT awaiting so the
+    // IPC response flushes first; the swap + self-restart use the EXISTING
+    // mechanism unchanged (path 1 — restart is orthogonal, evolving under XX).
+    // A second concurrent upgrade-start is reported `already-running`.
+    upgradeStart: async ({ targetVersion: explicit }) => {
+      if (!isSeaBinary()) {
+        throw new ServiceClientError(
+          "IPC_MALFORMED_FRAME",
+          "upgrade-start is SEA-only; this service is a non-SEA (dev/npm) run"
+        );
+      }
+      if (inFlightUpgrade) {
+        return { status: "already-running", ...inFlightUpgrade };
+      }
+      const channel2 = await readChannel(slockHome);
+      const baseUrl = resolveUpgradeBaseUrl();
+      const resolved = explicit ?? await resolveSeaTargetVersion(channel2, baseUrl) ?? COMPUTER_VERSION;
+      const upgradeId = randomUUID2();
+      inFlightUpgrade = { upgradeId, targetVersion: resolved };
+      void (async () => {
+        try {
+          await resolveAndRunSeaUpgrade({
+            slockHome,
+            requestId: upgradeId,
+            fromVersion: COMPUTER_VERSION,
+            currentBinaryPath: process.execPath,
+            nowIso: (/* @__PURE__ */ new Date()).toISOString(),
+            deps: explicit ? { resolveTargetVersion: async () => explicit } : void 0
+          });
+        } catch (err) {
+          process.stderr.write(
+            `Service: upgrade ${upgradeId} failed: ${err instanceof Error ? err.message : String(err)}
+`
+          );
+        } finally {
+          inFlightUpgrade = null;
+        }
+      })();
+      return { status: "started", upgradeId, targetVersion: resolved };
+    }
+  });
   const shutdown = () => {
     if (shuttingDown) return;
     shuttingDown = true;
-    for (const handle of children.values()) killChild(handle);
+    for (const rec of runners2.values()) if (rec.child) killChild(rec);
     void ipc.close();
     void clearPidfileAt(servicePidPath(slockHome)).then(() => process.exit(0));
   };
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
+  for (const id of await listManagedServerIds(slockHome)) {
+    runners2.set(id, rehydrateRunnerRecord(id, await isDegraded(slockHome, id)));
+  }
   await reconcile();
   const timer = setInterval(() => {
     void reconcile();
@@ -33111,7 +33681,7 @@ async function runDetach(serverId, serverLabel = serverId) {
 var USER_SESSION_EXPIRY_LEEWAY_MS = 3e4;
 async function readUserSessionAuth(slockHome) {
   try {
-    const parsed = JSON.parse(await readFile11(userSessionPath(slockHome), "utf8"));
+    const parsed = JSON.parse(await readFile12(userSessionPath(slockHome), "utf8"));
     return {
       accessToken: typeof parsed.accessToken === "string" ? parsed.accessToken : "",
       ...typeof parsed.serverUrl === "string" ? { serverUrl: parsed.serverUrl } : {}
@@ -33122,7 +33692,7 @@ async function readUserSessionAuth(slockHome) {
 }
 async function hasValidUserSession(slockHome) {
   try {
-    const parsed = JSON.parse(await readFile11(userSessionPath(slockHome), "utf8"));
+    const parsed = JSON.parse(await readFile12(userSessionPath(slockHome), "utf8"));
     return parsed.kind === "user-session" && typeof parsed.accessToken === "string" && parsed.accessToken.length > 0 && !isJwtExpired(parsed.accessToken);
   } catch {
     return false;
@@ -33142,7 +33712,7 @@ async function refreshUserSession(slockHome, serverUrl) {
   const file = userSessionPath(slockHome);
   let session;
   try {
-    session = JSON.parse(await readFile11(file, "utf8"));
+    session = JSON.parse(await readFile12(file, "utf8"));
   } catch {
     return false;
   }
@@ -33161,8 +33731,8 @@ async function refreshUserSession(slockHome, serverUrl) {
     if (res.status !== 200 || typeof body?.accessToken !== "string" || typeof body.refreshToken !== "string") {
       return false;
     }
-    await mkdir12(dirname11(file), { recursive: true });
-    await writeFile10(
+    await mkdir13(dirname12(file), { recursive: true });
+    await writeFile11(
       tmpFile,
       JSON.stringify(
         {
@@ -33491,68 +34061,6 @@ async function runSetup(opts, deps = {}) {
 
 // src/runners.ts
 init_esm_shims();
-
-// src/targetServer.ts
-init_esm_shims();
-function attachmentLabel(a) {
-  return formatServerSlugDisplay(a.serverSlug);
-}
-async function refreshAttachmentSlug(home, attachment) {
-  try {
-    const client = new ComputerAttachClient(attachment.serverUrl, "");
-    const result = await client.preflight(attachment.apiKey);
-    if (!result.ok || !result.serverSlug || result.serverSlug === attachment.serverSlug) {
-      return attachment;
-    }
-    const updated = { ...attachment, serverSlug: result.serverSlug };
-    await writeServerAttachment(home, updated);
-    return updated;
-  } catch {
-    return attachment;
-  }
-}
-async function listAttachmentsWithFreshSlugs(home) {
-  const attachments = await listServerAttachments(home);
-  return await Promise.all(attachments.map((a) => refreshAttachmentSlug(home, a)));
-}
-async function resolveTargetServerId(opts) {
-  const home = resolveSlockHome();
-  let attachments = await listServerAttachments(home);
-  if (attachments.length === 0) {
-    fail("NO_ATTACHMENT", "No server attachments yet. Run `slock-computer attach /<serverSlug>` (e.g. `/myserver`) first.");
-  }
-  const requested = normalizeServerSlug(opts.server ?? "");
-  if (requested) {
-    let found = attachments.find((a) => a.serverSlug === requested);
-    if (!found) {
-      attachments = await listAttachmentsWithFreshSlugs(home);
-      found = attachments.find((a) => a.serverSlug === requested);
-    }
-    if (!found) {
-      fail(
-        "NOT_ATTACHED",
-        `Server slug ${formatServerSlugDisplay(requested)} is not attached. Attached server slugs: ${attachments.map(attachmentLabel).join(", ")}.`
-      );
-    }
-    return found.serverId;
-  }
-  if (attachments.length === 1) return attachments[0].serverId;
-  fail(
-    "AMBIGUOUS_SERVER",
-    `Multiple servers attached (${attachments.map(attachmentLabel).join(", ")}). Pass \`--server /<serverSlug>\` (e.g. \`--server ${attachmentLabel(attachments[0])}\`) to choose one.`
-  );
-}
-async function resolveTargetAttachment(opts) {
-  const serverId = await resolveTargetServerId(opts);
-  const a = await readServerAttachment(resolveSlockHome(), serverId);
-  if (!a) {
-    const label = opts.server ?? serverId;
-    fail("INVALID_ATTACHMENT", `Attachment for ${label} is missing/invalid. Re-run \`slock-computer attach ${label}\`.`);
-  }
-  return a;
-}
-
-// src/runners.ts
 async function runRunnersList(opts) {
   const serverId = await resolveTargetServerId({ server: opts.server });
   const installRoot = resolveSlockHome();
@@ -33757,14 +34265,14 @@ async function runDoctor(opts) {
 
 // src/logs.ts
 init_esm_shims();
-import { readFile as readFile12 } from "fs/promises";
+import { readFile as readFile13 } from "fs/promises";
 var DEFAULT_LINES = 200;
 async function runLogs(opts) {
   const home = resolveSlockHome();
   const file = opts.service ? serviceLogPath(home) : serverRunnerLogPath(home, await resolveTargetServerId({ server: opts.server }));
   let content;
   try {
-    content = await readFile12(file, "utf8");
+    content = await readFile13(file, "utf8");
   } catch {
     fail(
       "NO_DAEMON_LOG",
@@ -33778,156 +34286,6 @@ async function runLogs(opts) {
   for (const line of tail) info(redactSecrets(line));
 }
 
-// src/reset.ts
-init_esm_shims();
-
-// src/serviceState.ts
-init_esm_shims();
-import { mkdir as mkdir13, readFile as readFile13, writeFile as writeFile11, appendFile as appendFile3 } from "fs/promises";
-import { dirname as dirname12 } from "path";
-
-// src/lib/state.ts
-init_esm_shims();
-var SERVICE_STATE_VALUES = [
-  "starting",
-  "running",
-  "degraded",
-  "stopping",
-  "stopped"
-];
-function isServiceState(value) {
-  return typeof value === "string" && SERVICE_STATE_VALUES.includes(value);
-}
-
-// src/serviceState.ts
-var DEFAULT_STATE = {
-  state: "running",
-  crashHistory: []
-};
-async function readServiceState(slockHome) {
-  try {
-    const raw = await readFile13(serviceStatePath(slockHome), "utf8");
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object") return { ...DEFAULT_STATE };
-    const obj = parsed;
-    const state = isServiceState(obj.state) ? obj.state : "running";
-    const crashHistory = Array.isArray(obj.crashHistory) ? obj.crashHistory.filter(isCrashEntry) : [];
-    return { state, crashHistory };
-  } catch {
-    return { ...DEFAULT_STATE };
-  }
-}
-async function writeServiceState(slockHome, file) {
-  const path3 = serviceStatePath(slockHome);
-  await mkdir13(dirname12(path3), { recursive: true });
-  await writeFile11(path3, JSON.stringify(file), { mode: 384 });
-}
-function isCrashEntry(value) {
-  if (!value || typeof value !== "object") return false;
-  const obj = value;
-  return typeof obj.at === "string";
-}
-async function emitServiceStateTransition(slockHome, fromState, toState, trigger) {
-  const entry = {
-    at: (/* @__PURE__ */ new Date()).toISOString(),
-    kind: "service-state-changed",
-    fromState,
-    toState,
-    trigger
-  };
-  try {
-    const path3 = serviceLogPath(slockHome);
-    await mkdir13(dirname12(path3), { recursive: true });
-    await appendFile3(path3, JSON.stringify(entry) + "\n");
-  } catch {
-  }
-}
-async function clearServiceCrashHistory(slockHome) {
-  const current = await readServiceState(slockHome);
-  const previousState = current.state;
-  const clearedCrashCount = current.crashHistory.length;
-  const next = { state: "running", crashHistory: [] };
-  await writeServiceState(slockHome, next);
-  await emitServiceStateTransition(
-    slockHome,
-    previousState,
-    "running",
-    "reset-service"
-  );
-  return { previousState, clearedCrashCount };
-}
-
-// src/reset.ts
-async function resetService(installRoot) {
-  const { previousState, clearedCrashCount } = await clearServiceCrashHistory(installRoot);
-  return {
-    status: "ok",
-    previousState,
-    clearedCrashCount
-  };
-}
-async function resetRunner(installRoot, serverId) {
-  const attachment = await readServerAttachment(installRoot, serverId);
-  if (!attachment) {
-    return { status: "not-found", serverId };
-  }
-  const outcome = await resetRunnerHealth(installRoot, serverId);
-  if (outcome.status === "not-found") {
-    return { status: "not-found", serverId };
-  }
-  return {
-    status: "ok",
-    serverId,
-    previousState: outcome.previousState ?? "running",
-    clearedCrashCount: outcome.clearedCrashCount ?? 0
-  };
-}
-async function runReset(opts) {
-  const wantsService = opts.service === true;
-  const wantsRunner = opts.runner === true;
-  if (wantsService && wantsRunner) {
-    fail(
-      "RESET_SCOPE_AMBIGUOUS",
-      "`--service` and `--runner` are mutually exclusive. Pass exactly one."
-    );
-  }
-  if (!wantsService && !wantsRunner) {
-    fail(
-      "RESET_SCOPE_MISSING",
-      "Pass `--service` to clear the service-level crash history, or `--runner` to clear a per-runner crash history."
-    );
-  }
-  const slockHome = resolveSlockHome();
-  if (wantsService) {
-    const result2 = await resetService(slockHome);
-    if (opts.json) {
-      info(JSON.stringify(result2));
-      return;
-    }
-    info(
-      `Reset service crash history (previous state: ${result2.previousState}; cleared ${result2.clearedCrashCount} entr${result2.clearedCrashCount === 1 ? "y" : "ies"}).`
-    );
-    info("Service state transitioned to `running`. Runners were not touched.");
-    return;
-  }
-  const serverId = await resolveTargetServerId({ server: opts.server });
-  const result = await resetRunner(slockHome, serverId);
-  if (result.status === "not-found") {
-    fail(
-      "RESET_RUNNER_NOT_FOUND",
-      `Runner for server ${serverId} was not found.`
-    );
-  }
-  if (opts.json) {
-    info(JSON.stringify(result));
-    return;
-  }
-  info(
-    `Reset runner crash history for server ${result.serverId} (previous state: ${result.previousState}; cleared ${result.clearedCrashCount} entr${result.clearedCrashCount === 1 ? "y" : "ies"}).`
-  );
-  info("Runner state transitioned to `running`. Process was not respawned.");
-}
-
 // src/concurrency.ts
 init_esm_shims();
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
@@ -33988,11 +34346,9 @@ function resolveUpgradeTrigger(raw) {
   return raw === "web" || raw === "tray" ? raw : "cli";
 }
 var UPGRADE_ERROR_CODES = [
-  "UPGRADE_DEPS_CHANGED",
   "UPGRADE_NETWORK_FAILED",
   "UPGRADE_INTEGRITY_FAILED",
   "UPGRADE_SWAP_FAILED",
-  "UPGRADE_RESTART_FAILED",
   "UPGRADE_NO_TARGET",
   "UPGRADE_ALREADY_RUNNING"
 ];
@@ -34345,6 +34701,31 @@ program2.command("upgrade").description(
     async (opts) => {
       const slockHome = resolveSlockHome();
       const trigger = resolveUpgradeTrigger(process.env.SLOCK_UPGRADE_TRIGGER);
+      if (!opts.dryRun && !opts.channel) {
+        let client = null;
+        try {
+          client = await connectService(slockHome);
+        } catch {
+          client = null;
+        }
+        if (client) {
+          try {
+            const r = await client.request("upgrade-start", {
+              targetVersion: opts.targetVersion
+            });
+            if (r.status === "already-running") {
+              info(`An upgrade to ${r.targetVersion} is already running (id ${r.upgradeId}).`);
+            } else {
+              info(
+                `Upgrade to ${r.targetVersion} started (id ${r.upgradeId}). The service downloads, verifies, swaps the binary, and restarts on it; run \`slock-computer status\` to confirm.`
+              );
+            }
+          } finally {
+            await client.close();
+          }
+          return;
+        }
+      }
       try {
         await withMutationLock(
           () => runUpgradeCli(slockHome, {