@moxt-ai/mobius 0.0.386 → 0.0.388

package/dist/{cli-NLIGRBEL.js → cli-O57WJIFN.js}

@@ -1,12 +1,8 @@
-import {
-  require_semver
-} from "./chunk-T2GPD4RK.js";
 import {
   BoundedLineLog,
   MissingAdapter,
   MobiusRuntimeEngine,
   PairingClientError,
-  RuntimeDiagnosticLog,
   RuntimeInstallationStore,
   RuntimeInstallationStoreError,
   RuntimeLocalContext,
@@ -14,35 +10,26 @@ import {
   RuntimeTurnActivity,
   UnsupportedAgentVersion,
   WORKER_LIFECYCLE_LOG_FILENAME,
-  canonicalPath,
-  decodeIdentifier,
   decodeRuntimeUpgradeVersion,
   describeRelayFailure,
   discoverLocalAgentInventory,
   ensurePrivateDirectory,
   external_exports,
-  findExecutableOnPath,
   installationPointerPath,
   isNodeError,
-  isRecord,
   logDirectory,
   parsePairingCode,
   parseRelayOrigin,
   platformSupportFor,
   prepareRuntimeConnection,
   refreshAgentCatalog,
-  resolveLaunchFiles,
-  runBoundedProcess,
   unhandledRejectionLogFilename,
   validateLocalPath,
   validatePairingId
-} from "./chunk-FVYSQLQL.js";
+} from "./chunk-7BSIM5AK.js";
 import {
-  __callDispose,
-  __toESM,
-  __using,
   package_default
-} from "./chunk-Z6JG65YI.js";
+} from "./chunk-Z4WUPVBL.js";
 
 // ../../node_modules/.pnpm/commander@15.0.0/node_modules/commander/lib/error.js
 var CommanderError = class extends Error {
@@ -3433,8 +3420,6 @@ var STATE_ROOT_LAYOUT = Object.freeze({
   currentData: "current-data.txt",
   /** Applications' installations: `installations/<application>/<installation>`. */
   installations: "installations",
-  /** Managed CLI releases: `npm/<version>`. */
-  releases: "npm",
   /** Each CLI version's data: `versions/<version>`. */
   versions: "versions"
 });
@@ -3882,14 +3867,29 @@ function registerAgentsHandler(program2, context) {
   });
 }
 
-// src/daemon/lifecycle/manager.ts
-import { setTimeout as setTimeout2 } from "node:timers/promises";
+// src/daemon/lifecycle/daemon.ts
+import { setTimeout as delay } from "node:timers/promises";
+
+// src/engine/session/process/runtime-agent-processes.ts
+var RuntimeAgentProcesses = class {
+  #pools = /* @__PURE__ */ new Set();
+  /** Tracks a Runtime's pool until the returned function removes it. */
+  add = (pool) => {
+    this.#pools.add(pool);
+    return () => {
+      this.#pools.delete(pool);
+    };
+  };
+  retireIdleProcesses = async () => {
+    await Promise.all([...this.#pools].map(async (pool) => await pool.retireIdleProcesses()));
+  };
+};
 
-// src/storage/daemon/manager-lock.ts
+// src/storage/daemon/daemon-lock.ts
 import { readFile as readFile3, unlink, writeFile as writeFile2 } from "node:fs/promises";
 import { join as join7 } from "node:path";
-async function acquireManagerLock(stateDirectory, name = "manager.lock") {
-  const path2 = join7(stateDirectory, name);
+async function acquireDaemonLock(stateDirectory, filename = "manager.lock") {
+  const path2 = join7(stateDirectory, filename);
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
       await writeFile2(path2, `${process.pid.toString()}
@@ -3916,9 +3916,22 @@ async function acquireManagerLock(stateDirectory, name = "manager.lock") {
   }
   return null;
 }
-async function managerLockExists(stateDirectory) {
+async function daemonLockExists(stateDirectory, filename = "manager.lock") {
   try {
-    await readFile3(join7(stateDirectory, "manager.lock"), "utf8");
+    const pid = Number((await readFile3(join7(stateDirectory, filename), "utf8")).trim());
+    if (!Number.isSafeInteger(pid) || pid <= 1) {
+      return true;
+    }
+    try {
+      process.kill(pid, 0);
+    } catch (cause) {
+      if (isNodeError(cause, "ESRCH")) {
+        return false;
+      }
+      if (!isNodeError(cause, "EPERM")) {
+        throw cause;
+      }
+    }
     return true;
   } catch (cause) {
     if (isNodeError(cause, "ENOENT")) {
@@ -3928,8 +3941,9 @@ async function managerLockExists(stateDirectory) {
   }
 }
 
-// src/daemon/control/local-server.ts
-import { createServer } from "node:net";
+// src/daemon/control/local-client.ts
+import { createHash } from "node:crypto";
+import { createConnection } from "node:net";
 
 // src/storage/daemon/control-token.ts
 import { randomBytes } from "node:crypto";
@@ -3961,8 +3975,6 @@ async function readOrCreateControlToken(stateDirectory) {
 }
 
 // src/daemon/control/local-client.ts
-import { createHash } from "node:crypto";
-import { createConnection } from "node:net";
 var CONTROL_TIMEOUT_MILLISECONDS = 13e4;
 var MAXIMUM_MESSAGE_BYTES = 64 * 1024;
 var managerPlatform = platformSupportFor(process.platform);
@@ -4037,6 +4049,7 @@ async function sendLocalRequest(stateDirectory, endpoint, command, signal) {
 }
 
 // src/daemon/control/local-server.ts
+import { createServer } from "node:net";
 async function serveLocalControl(stateDirectory, endpoint, signal, handle, onListening = () => void 0, onResponse = () => void 0) {
   signal.throwIfAborted();
   const token = await readOrCreateControlToken(stateDirectory);
@@ -4097,71 +4110,6 @@ async function serveLocalControl(stateDirectory, endpoint, signal, handle, onLis
   }
 }
 
-// src/daemon/control/protocol.ts
-var workerLaunch = external_exports.object({
-  executable: external_exports.string().min(1),
-  entry: external_exports.string().min(1),
-  version: external_exports.string().min(1).max(128)
-}).readonly();
-var transition = {
-  id: external_exports.string().min(1).max(256),
-  context: external_exports.string().max(256),
-  previous: workerLaunch,
-  next: workerLaunch
-};
-var daemonSwitchState = external_exports.discriminatedUnion("kind", [
-  external_exports.object({ ...transition, kind: external_exports.literal("switching") }),
-  external_exports.object({ ...transition, kind: external_exports.literal("switched") }),
-  external_exports.object({
-    ...transition,
-    kind: external_exports.literal("rolled-back"),
-    code: external_exports.string(),
-    message: external_exports.string(),
-    stdout: external_exports.string().max(4096),
-    stderr: external_exports.string().max(4096),
-    retryAfter: external_exports.number().int().nonnegative()
-  })
-]).readonly();
-var lifecycleCommand = external_exports.discriminatedUnion("kind", [
-  external_exports.object({ kind: external_exports.literal("status") }),
-  external_exports.object({ kind: external_exports.literal("ensure"), launch: workerLaunch }),
-  external_exports.object({ kind: external_exports.literal("stop") }),
-  external_exports.object({
-    kind: external_exports.literal("switch"),
-    id: external_exports.string().min(1).max(256),
-    context: external_exports.string().max(256),
-    launch: workerLaunch
-  }),
-  external_exports.object({ kind: external_exports.literal("switch-status"), wait: external_exports.boolean() })
-]).readonly();
-var lifecycleResponse = external_exports.discriminatedUnion("kind", [
-  external_exports.object({
-    kind: external_exports.literal("status"),
-    protocolVersion: external_exports.literal(2),
-    worker: external_exports.object({ pid: external_exports.number().int().positive(), version: external_exports.string() }).readonly().nullable()
-  }),
-  external_exports.object({ kind: external_exports.literal("switch-status"), state: daemonSwitchState.nullable() }),
-  external_exports.object({ kind: external_exports.literal("stopped") }),
-  external_exports.object({ kind: external_exports.literal("switching") }),
-  external_exports.object({ kind: external_exports.literal("error"), code: external_exports.string(), message: external_exports.string() })
-]).readonly();
-var lifecycleCommandKinds = /* @__PURE__ */ new Set(["ensure", "status", "stop", "switch", "switch-status"]);
-var lifecycleResponseKinds = /* @__PURE__ */ new Set(["error", "status", "stopped", "switching", "switch-status"]);
-var daemonSwitchStateKinds = /* @__PURE__ */ new Set(["rolled-back", "switched", "switching"]);
-function hasUnknownKind(value, known) {
-  return typeof value === "object" && value !== null && "kind" in value && typeof value.kind === "string" && !known.has(value.kind);
-}
-var decodeKnownLifecycleCommand = (value) => hasUnknownKind(value, lifecycleCommandKinds) ? null : lifecycleCommand.parse(value);
-var decodeKnownLifecycleResponse = (value) => {
-  if (hasUnknownKind(value, lifecycleResponseKinds)) {
-    return null;
-  }
-  if (typeof value === "object" && value !== null && "kind" in value && value.kind === "switch-status" && "state" in value && hasUnknownKind(value.state, daemonSwitchStateKinds)) {
-    return lifecycleResponse.parse({ ...value, state: null });
-  }
-  return lifecycleResponse.parse(value);
-};
-
 // src/daemon/upgrades/data.ts
 async function prepareVersionData(version, signal) {
   signal.throwIfAborted();
@@ -4174,9 +4122,6 @@ async function prepareVersionData(version, signal) {
   await discardVersionData(root, targetVersion, signal);
   await copyVersionData(root, current, targetVersion, signal);
 }
-async function discardRolledBackData(version, signal) {
-  await discardVersionData(readStateDirectory(), decodeRuntimeUpgradeVersion(version), signal);
-}
 async function recordCurrentData(version, signal) {
   await writeCurrentDataVersion(readStateDirectory(), decodeRuntimeUpgradeVersion(version), signal);
 }
@@ -4200,7 +4145,7 @@ function describeRejection(reason) {
   }).join("");
   return printable.slice(0, MAXIMUM_REJECTION_TEXT_BYTES);
 }
-function surviveUnhandledRejections(role) {
+function surviveUnhandledRejections() {
   let log = null;
   const pending = [];
   const record = (reason) => {
@@ -4231,7 +4176,7 @@ function surviveUnhandledRejections(role) {
       }
       log = new BoundedLineLog(
         logDirectory(stateDirectory),
-        unhandledRejectionLogFilename(role),
+        unhandledRejectionLogFilename("worker"),
         MAXIMUM_REJECTION_LOG_BYTES,
         (cause) => {
           process.stderr.write(`The unhandled rejection log could not be written: ${String(cause)}
@@ -4248,606 +4193,309 @@ function surviveUnhandledRejections(role) {
   };
 }
 
-// src/daemon/lifecycle/worker-lifecycle-log.ts
-var MAXIMUM_LIFECYCLE_LOG_BYTES = 512 * 1024;
-var MAXIMUM_TEXT_BYTES = 2048;
-function toLogText(value) {
-  const singleLine = Array.from(value, (character) => {
-    const code = character.charCodeAt(0);
-    return code < 32 || code === 127 ? " " : character;
-  }).join("");
-  return singleLine.slice(-MAXIMUM_TEXT_BYTES);
-}
-var WorkerLifecycleLog = class {
-  #log;
-  constructor(stateDirectory) {
-    this.#log = new BoundedLineLog(
-      logDirectory(stateDirectory),
-      WORKER_LIFECYCLE_LOG_FILENAME,
-      MAXIMUM_LIFECYCLE_LOG_BYTES,
-      (cause) => {
-        process.stderr.write(`The worker lifecycle log could not be written: ${String(cause)}
-`);
-      }
-    );
+// src/daemon/lifecycle/daemon.ts
+var DaemonRuntimeError = class extends Error {
+  code = "worker_runtime_failed";
+  constructor(connectionId, cause) {
+    super(`Runtime ${connectionId} failed`, { cause });
   }
-  started = (pid, version) => {
-    this.#append({ kind: "worker_started", pid, version });
-  };
-  ready = (pid, version) => {
-    this.#append({ kind: "worker_ready", pid, version });
-  };
-  exited = (pid, version, exit, stderr) => {
-    this.#append({
-      kind: "worker_exited",
-      pid,
-      version,
-      exitCode: exit.code,
-      signal: exit.signal,
-      stderr: toLogText(stderr)
-    });
-  };
-  startFailed = (version, pid, code, message, stderr) => {
-    this.#append({
-      kind: "worker_start_failed",
-      pid,
-      version,
-      code,
-      message: toLogText(message),
-      stderr: toLogText(stderr)
-    });
-  };
-  restartFailed = (version, message) => {
-    this.#append({ kind: "worker_restart_failed", version, message: toLogText(message) });
-  };
-  #append = (entry) => {
-    this.#log.record(
-      `Mobius worker lifecycle ${JSON.stringify({ ...entry, timestamp: (/* @__PURE__ */ new Date()).toISOString() })}`
-    );
-  };
 };
-
-// src/daemon/lifecycle/worker-process.ts
-import { spawn } from "node:child_process";
-import { isAbsolute } from "node:path";
-async function decodeWorkerLaunch(value) {
-  const { entry, executable, version } = workerLaunch.parse(value);
-  if (!isAbsolute(entry) || !isAbsolute(executable)) {
-    throw new Error("Worker launch paths must be absolute");
-  }
-  const resolved = await resolveLaunchFiles(entry, executable);
-  if (resolved === null) {
-    throw new Error("Worker launch paths must be files");
-  }
-  return { entry: resolved.entry, executable: resolved.executable, version };
+async function sendDaemonCommand(directory, kind, signal) {
+  const response = await sendLocalRequest(directory, "manager", { kind }, signal);
+  return response === null ? await sendLocalRequest(directory, "worker", { kind }, signal) : response;
 }
-var WorkerStartupError = class extends Error {
-  code;
-  stdout;
-  stderr;
-  constructor(code, message, options, stdout = "", stderr = "") {
-    super(message, options);
-    this.code = code;
-    this.stdout = stdout;
-    this.stderr = stderr;
-  }
-};
-var WorkerProcess = class {
-  #child;
-  #stdout = "";
-  #stderr = "";
-  #started = Promise.withResolvers();
-  #closed = Promise.withResolvers();
-  #drained = Promise.withResolvers();
-  #exit = null;
-  exited = this.#closed.promise;
-  // Resolves once the child's stdio streams are closed, so the captured stderr
-  // tail is final. Bounded: if an orphaned grandchild inherits the pipes and
-  // keeps them open, the fallback timer still resolves it.
-  streamsSettled = this.#drained.promise;
-  launch;
-  ready;
-  constructor(launch, signal, environment) {
-    signal.throwIfAborted();
-    this.launch = launch;
-    this.#child = spawn(launch.executable, [launch.entry, "__worker"], {
-      env: environment,
-      windowsHide: true,
-      stdio: ["ignore", "pipe", "pipe", "ipc"]
-    });
-    this.#child.stdout?.setEncoding("utf8").on("data", (chunk) => {
-      this.#stdout = (this.#stdout + chunk).slice(-4096);
-      process.stdout.write(chunk);
-    });
-    this.#child.stderr?.setEncoding("utf8").on("data", (chunk) => {
-      this.#stderr = (this.#stderr + chunk).slice(-4096);
-      process.stderr.write(chunk);
-    });
-    this.#child.once("close", () => {
-      this.#drained.resolve();
-    });
-    this.#child.on("message", (value) => {
-      if (isRecord(value) && value["kind"] === "worker-ready") {
-        if (value["version"] !== launch.version) {
-          this.#started.reject(
-            new WorkerStartupError(
-              "worker_version_mismatch",
-              "The new daemon reported a different version"
-            )
-          );
-        } else {
-          this.#started.resolve(value);
-        }
-        return;
-      }
-    });
-    this.#child.once("error", (cause) => {
-      this.#started.reject(
-        new WorkerStartupError("worker_spawn_failed", "The new daemon process could not be launched", {
-          cause
-        })
-      );
-      if (this.#child.pid === void 0) {
-        this.#exit = { code: null, signal: null };
-        this.#boundStreamsSettled();
-        this.#closed.resolve();
-      }
-    });
-    this.#child.once("exit", (code, signal2) => {
-      this.#exit = { code, signal: signal2 };
-      this.#boundStreamsSettled();
-      this.#started.reject(
-        new WorkerStartupError(
-          "worker_exited",
-          "The new daemon exited before becoming ready",
-          void 0,
-          this.#stdout,
-          this.#stderr
-        )
-      );
-      this.#closed.resolve();
-    });
-    this.ready = this.#waitForStart(signal);
-  }
-  #boundStreamsSettled() {
-    const giveUp = setTimeout(() => this.#drained.resolve(), 2e3);
-    void this.#drained.promise.then(() => clearTimeout(giveUp));
-  }
-  get running() {
-    return this.#child.exitCode === null && this.#child.signalCode === null && this.#child.connected;
-  }
-  get pid() {
-    const pid = this.#child.pid;
-    if (pid === void 0) {
-      throw new Error("The working process did not start");
+async function reloadDaemon(stateDirectory, signal) {
+  try {
+    const response = await sendDaemonCommand(stateDirectory, "reload", signal);
+    if (typeof response !== "object" || response === null || !("kind" in response) || response.kind !== "reloaded") {
+      throw new Error("Saved configuration could not be applied to the running daemon");
     }
-    return pid;
-  }
-  // How the child terminated, available once `exited` settles. `code` and `signal`
-  // are null when the process could not be launched at all.
-  get exit() {
-    if (this.#exit === null) {
-      throw new Error("The working process has not exited");
+  } catch (cause) {
+    if (!isNodeError(cause, "ENOENT") && !isNodeError(cause, "ECONNREFUSED")) {
+      throw cause;
     }
-    return this.#exit;
   }
-  get stderr() {
-    return this.#stderr;
-  }
-  close = async () => {
-    if (this.#child.connected) {
-      this.#child.disconnect();
-    }
-    const timeout = setTimeout(() => this.#child.kill("SIGKILL"), 1e4);
-    try {
-      await this.#closed.promise;
-    } finally {
-      clearTimeout(timeout);
+}
+async function releaseIdleAgentProcesses(stateDirectory, signal) {
+  try {
+    const response = await sendDaemonCommand(stateDirectory, "release", signal);
+    if (typeof response === "object" && response !== null && "kind" in response && response.kind === "released") {
+      return;
     }
-  };
-  async #waitForStart(signal) {
-    const deadline = AbortSignal.any([signal, AbortSignal.timeout(12e4)]);
-    const abort = () => this.#started.reject(
-      signal.aborted ? signal.reason : new WorkerStartupError(
-        "worker_start_timeout",
-        "The new daemon did not become ready within 120 seconds",
-        { cause: deadline.reason },
-        this.#stdout,
-        this.#stderr
-      )
+    throw new Error(
+      "The running daemon cannot release Agent sessions. Run `npx --yes @moxt-ai/mobius@latest restart` to update it first."
     );
-    deadline.addEventListener("abort", abort, { once: true });
-    if (deadline.aborted) {
-      abort();
-    }
-    try {
-      return await this.#started.promise;
-    } finally {
-      deadline.removeEventListener("abort", abort);
+  } catch (cause) {
+    if (!isNodeError(cause, "ENOENT") && !isNodeError(cause, "ECONNREFUSED")) {
+      throw cause;
     }
   }
-};
-
-// src/daemon/lifecycle/manager.ts
-async function runManager(stateDirectory, signal) {
-  const release = await acquireManagerLock(stateDirectory);
-  if (release === null) {
-    return;
+}
+async function runDaemon(version, signal, owner = "standalone") {
+  if (owner === "legacy-manager" && !process.connected) {
+    throw new Error("The legacy worker entrypoint requires a manager IPC connection");
   }
-  const rejectionGuard = surviveUnhandledRejections("manager");
-  rejectionGuard.bindStateDirectory(stateDirectory);
+  const rejectionGuard = surviveUnhandledRejections();
   const shutdown = new AbortController();
   const combined = AbortSignal.any([signal, shutdown.signal]);
-  const lifecycle = new WorkerLifecycleLog(stateDirectory);
-  const workerExits = /* @__PURE__ */ new Set();
-  let worker;
-  let switchState = null;
-  let queue = Promise.resolve();
-  const status = () => ({
-    kind: "status",
-    protocolVersion: 2,
-    worker: worker?.running ? { pid: worker.pid, version: worker.launch.version } : null
-  });
-  const start = async (launch) => {
-    combined.throwIfAborted();
-    await worker?.close();
-    const replacement = new WorkerProcess(launch, combined, process.env);
-    worker = replacement;
-    let pid = null;
-    try {
-      pid = replacement.pid;
-    } catch {
-    }
-    if (pid !== null) {
-      lifecycle.started(pid, launch.version);
-    }
-    try {
-      await replacement.ready;
-    } catch (cause) {
-      await replacement.close();
-      await replacement.streamsSettled;
-      const code = cause instanceof WorkerStartupError ? cause.code : "worker_start_failed";
-      const message = cause instanceof WorkerStartupError ? cause.message : "The new daemon could not start";
-      lifecycle.startFailed(launch.version, pid, code, message, replacement.stderr);
-      throw cause;
+  const disconnect = () => shutdown.abort();
+  if (owner === "legacy-manager") {
+    process.once("disconnect", disconnect);
+  }
+  try {
+    await runDaemonRuntime(version, combined, shutdown, rejectionGuard, owner);
+  } catch (cause) {
+    const control = await openMobiusControlInstallation(AbortSignal.timeout(5e3), process.env);
+    new BoundedLineLog(logDirectory(control.stateDirectory), WORKER_LIFECYCLE_LOG_FILENAME, 512 * 1024).record(
+      JSON.stringify({
+        kind: "daemon_failed",
+        message: cause instanceof Error ? cause.message : "Daemon failed"
+      })
+    );
+    throw cause;
+  } finally {
+    shutdown.abort();
+    rejectionGuard.release();
+    if (owner === "legacy-manager") {
+      process.off("disconnect", disconnect);
+      if (process.connected) {
+        process.disconnect();
+      }
     }
-    if (pid !== null) {
-      lifecycle.ready(pid, launch.version);
+  }
+}
+async function runDaemonRuntime(version, combined, shutdown, rejectionGuard, owner) {
+  const control = await openMobiusControlInstallation(combined, process.env);
+  const releaseDaemon = await acquireDaemonLock(
+    control.stateDirectory,
+    owner === "legacy-manager" ? "worker.lock" : "manager.lock"
+  );
+  if (releaseDaemon === null) {
+    return;
+  }
+  const lifecycleLog = new BoundedLineLog(
+    logDirectory(control.stateDirectory),
+    WORKER_LIFECYCLE_LOG_FILENAME,
+    512 * 1024
+  );
+  lifecycleLog.record(
+    JSON.stringify({ kind: "daemon_started", pid: process.pid, version, timestamp: (/* @__PURE__ */ new Date()).toISOString() })
+  );
+  try {
+    if (owner === "standalone") {
+      const deadline = AbortSignal.any([combined, AbortSignal.timeout(3e4)]);
+      while (await daemonLockExists(control.stateDirectory, "worker.lock")) {
+        await delay(50, void 0, { signal: deadline });
+      }
+      deadline.throwIfAborted();
     }
-    const exited = replacement.exited.then(async () => {
-      await replacement.streamsSettled;
-      if (pid !== null) {
-        lifecycle.exited(pid, launch.version, replacement.exit, replacement.stderr);
+    await prepareVersionData(version, combined);
+    const engineDataDir = await prepareMobiusEngineDataDir(version, combined, process.env);
+    const installation = await RuntimeInstallationStore.open(engineDataDir, combined);
+    rejectionGuard.bindStateDirectory(control.stateDirectory);
+    const turnActivity = new RuntimeTurnActivity();
+    const agentProcesses = new RuntimeAgentProcesses();
+    const active = /* @__PURE__ */ new Map();
+    const fail = (connectionId, cause) => {
+      console.error(`Runtime ${connectionId} failed; stopping the daemon`, cause);
+      shutdown.abort(new DaemonRuntimeError(connectionId, cause));
+    };
+    const reconcile = async () => {
+      const connections = await installation.listConnections(combined);
+      const enabled = new Set(
+        connections.filter((connection) => connection.activation === "active").map((connection) => connection.connectionId)
+      );
+      for (const [id, running] of active) {
+        if (enabled.has(id)) {
+          continue;
+        }
+        running.controller.abort();
+        await running.completion;
+        active.delete(id);
       }
-      try {
-        await setTimeout2(1e3, void 0, { signal: combined });
-        const restart = queue.then(async () => {
-          if (worker === replacement && !combined.aborted) {
-            await start(replacement.launch);
-          }
-        });
-        queue = restart.catch(() => void 0);
-        await restart;
-      } catch {
-        if (!combined.aborted) {
-          const message = "The working daemon could not be restarted; run mobius start to retry";
-          process.stderr.write(`${message}
-`);
-          lifecycle.restartFailed(launch.version, message);
+      for (const connection of connections) {
+        if (!enabled.has(connection.connectionId) || active.has(connection.connectionId)) {
+          continue;
+        }
+        try {
+          const config = await prepareRuntimeConnection(
+            installation,
+            connection,
+            combined,
+            process.env,
+            resolveMaxAcpProcesses(process.env)
+          );
+          const controller = new AbortController();
+          const loop = new RuntimeLoop(async () => config, {
+            processLogsDirectory: control.stateDirectory,
+            turnActivity,
+            agentProcesses
+          });
+          const completion = loop.run(AbortSignal.any([combined, controller.signal])).then(
+            () => {
+              if (!combined.aborted && !controller.signal.aborted) {
+                fail(connection.connectionId, new Error("The Runtime stopped unexpectedly"));
+              }
+            },
+            (cause) => {
+              if (!combined.aborted && !controller.signal.aborted) {
+                fail(connection.connectionId, cause);
+              }
+            }
+          ).finally(() => active.delete(connection.connectionId));
+          active.set(connection.connectionId, { config, controller, completion });
+        } catch (cause) {
+          combined.throwIfAborted();
+          fail(connection.connectionId, cause);
+          throw cause;
         }
       }
-    });
-    workerExits.add(exited);
-    void exited.finally(() => workerExits.delete(exited));
-  };
-  const switchWorker = async (transition2) => {
-    try {
-      await start(transition2.next);
-      switchState = { ...transition2, kind: "switched" };
-    } catch (cause) {
-      combined.throwIfAborted();
-      const code = cause instanceof WorkerStartupError ? cause.code : "worker_start_failed";
-      const message = cause instanceof WorkerStartupError ? cause.message : "The new daemon could not start";
-      switchState = {
-        ...transition2,
-        kind: "rolled-back",
-        code,
-        message,
-        stdout: cause instanceof WorkerStartupError ? cause.stdout : "",
-        stderr: cause instanceof WorkerStartupError ? cause.stderr : "",
-        retryAfter: Date.now() + 8 * 36e5
-      };
-      await start(transition2.previous);
-      await discardRolledBackData(transition2.next.version, combined);
-    }
-  };
-  const handle = async (value, requestSignal) => {
-    const command = decodeKnownLifecycleCommand(value);
-    if (command === null) {
-      return null;
-    }
-    if (command.kind === "switch-status" && !command.wait) {
-      return { kind: "switch-status", state: switchState };
-    }
-    const result = queue.then(async () => {
-      requestSignal.throwIfAborted();
-      switch (command.kind) {
-        case "switch-status":
-          return { kind: "switch-status", state: switchState };
-        case "status":
-          return status();
-        case "stop":
-          return { kind: "stopped" };
-        case "switch": {
-          const state = switchState;
-          if (state?.kind === "switching" || state?.kind === "rolled-back" && state.retryAfter > Date.now()) {
-            return {
-              kind: "error",
-              code: "switch_blocked",
-              message: "A switch is in progress or cooling down"
-            };
-          }
-          if (!worker?.running) {
-            return {
-              kind: "error",
-              code: "worker_unavailable",
-              message: "There is no working daemon to replace"
-            };
+    };
+    const refreshRunningCatalogs = async (connectionIds) => {
+      await Promise.all(
+        [...connectionIds].map(async (connectionId) => {
+          const config = active.get(connectionId)?.config;
+          if (config?.rediscoverAgents === void 0) {
+            return;
           }
-          const next = await decodeWorkerLaunch(command.launch);
-          if (next.version === worker.launch.version) {
-            return {
-              kind: "error",
-              code: "already_current",
-              message: "The requested version is already running"
-            };
+          try {
+            await refreshAgentCatalog(
+              config,
+              config.rediscoverAgents,
+              AbortSignal.any([combined, AbortSignal.timeout(9e4)])
+            );
+          } catch (cause) {
+            combined.throwIfAborted();
+            console.error(`Runtime ${connectionId} could not refresh its Agent catalog`, cause);
           }
-          switchState = {
-            kind: "switching",
-            id: command.id,
-            context: command.context,
-            previous: worker.launch,
-            next
-          };
-          return { kind: "switching" };
+        })
+      );
+    };
+    let reload = Promise.resolve();
+    const handle = async (request) => {
+      if (typeof request === "object" && request !== null && "kind" in request) {
+        if (request.kind === "status" || request.kind === "ensure") {
+          return { kind: "status", protocolVersion: 2, worker: { pid: process.pid, version } };
         }
-        case "ensure": {
-          const launch = await decodeWorkerLaunch(command.launch);
-          if (!worker?.running || worker.launch.version !== launch.version || worker.launch.entry !== launch.entry || worker.launch.executable !== launch.executable) {
-            await start(launch);
-          }
-          await worker?.ready;
-          return status();
+        if (request.kind === "stop") {
+          return { kind: "stopped" };
         }
       }
-    });
-    queue = result.catch(() => void 0);
-    return await result;
-  };
-  try {
-    await serveLocalControl(stateDirectory, "manager", combined, handle, void 0, (response) => {
-      if (typeof response === "object" && response !== null && "kind" in response && response.kind === "switching") {
-        const pending = queue.then(async () => {
-          const state = switchState;
-          if (state?.kind === "switching") {
-            await switchWorker(state);
-          }
-        });
-        queue = pending.catch(() => {
-          if (!combined.aborted) {
-            process.stderr.write("Daemon switch or rollback failed; run mobius start to retry.\n");
+      if (typeof request === "object" && request !== null && "kind" in request && request.kind === "release") {
+        await agentProcesses.retireIdleProcesses();
+        return { kind: "released" };
+      }
+      if (typeof request !== "object" || request === null || !("kind" in request) || request.kind !== "reload") {
+        return { kind: "error", code: "invalid_reload", message: "Expected a configuration reload" };
+      }
+      const running = new Set(active.keys());
+      const pending = reload.then(reconcile).then(async () => await refreshRunningCatalogs(running));
+      reload = pending.catch(() => void 0);
+      await pending;
+      return { kind: "reloaded" };
+    };
+    try {
+      await reconcile();
+      await recordCurrentData(version, combined);
+      lifecycleLog.record(
+        JSON.stringify({
+          kind: "daemon_ready",
+          pid: process.pid,
+          version,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+      const servers = owner === "legacy-manager" ? ["worker"] : ["manager", "worker"];
+      const results = await Promise.allSettled(
+        servers.map(async (endpoint) => {
+          try {
+            await serveLocalControl(
+              control.stateDirectory,
+              endpoint,
+              combined,
+              handle,
+              () => {
+                if (owner === "legacy-manager") {
+                  combined.throwIfAborted();
+                  process.send?.({ kind: "worker-ready", version }, () => void 0);
+                }
+              },
+              (response) => {
+                if (typeof response === "object" && response !== null && "kind" in response && response.kind === "stopped") {
+                  shutdown.abort();
+                }
+              }
+            );
+          } finally {
+            shutdown.abort();
           }
-        });
+        })
+      );
+      for (const result of results) {
+        if (result.status === "rejected") {
+          throw result.reason;
+        }
       }
-      if (typeof response === "object" && response !== null && "kind" in response && response.kind === "stopped") {
-        shutdown.abort();
+      if (shutdown.signal.reason instanceof DaemonRuntimeError) {
+        throw shutdown.signal.reason;
       }
-    });
+    } finally {
+      shutdown.abort();
+      await reload;
+      await Promise.all([...active.values()].map((running) => running.completion));
+    }
   } finally {
-    shutdown.abort();
-    await queue;
-    await worker?.close();
-    await Promise.all(workerExits);
-    rejectionGuard.release();
-    await release();
+    await releaseDaemon();
   }
 }
 
-// src/cli/handler/daemon/manager.ts
-function registerManagerCommand(program2, context) {
-  program2.command("__manager", { hidden: true }).action(async () => {
-    const installation = await openMobiusControlInstallation(context.shutdownSignal, process.env);
-    await runManager(installation.stateDirectory, context.shutdownSignal);
-  });
-}
-
-// src/daemon/lifecycle/manager-client.ts
-var import_semver2 = __toESM(require_semver(), 1);
-import { spawn as spawn2 } from "node:child_process";
-
-// src/daemon/upgrades/package.ts
-import { isAbsolute as isAbsolute2, join as join10, relative } from "node:path";
-var import_semver = __toESM(require_semver(), 1);
+// src/daemon/lifecycle/daemon-client.ts
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { setTimeout as delay2 } from "node:timers/promises";
 
-// src/storage/daemon/release-files.ts
-import { readFile as readFile5, realpath } from "node:fs/promises";
-import { join as join9 } from "node:path";
-function releasePrefix(version) {
-  return join9(readStateDirectory(), STATE_ROOT_LAYOUT.releases, version);
-}
-async function readInstalledRelease(prefix) {
-  const packageRoot = await realpath(join9(prefix, "node_modules", "@moxt-ai", "mobius"));
-  return { manifest: await readFile5(join9(packageRoot, "package.json"), "utf8"), packageRoot };
+// src/daemon/control/protocol.ts
+var lifecycleResponse = external_exports.discriminatedUnion("kind", [
+  external_exports.object({
+    kind: external_exports.literal("status"),
+    protocolVersion: external_exports.literal(2),
+    worker: external_exports.object({ pid: external_exports.number().int().positive(), version: external_exports.string() }).readonly().nullable()
+  }),
+  external_exports.object({ kind: external_exports.literal("stopped") }),
+  external_exports.object({ kind: external_exports.literal("error"), code: external_exports.string(), message: external_exports.string() })
+]).readonly();
+function decodeKnownLifecycleResponse(value) {
+  if (typeof value === "object" && value !== null && "kind" in value && typeof value.kind === "string" && !["status", "stopped", "error"].includes(value.kind)) {
+    return null;
+  }
+  return lifecycleResponse.parse(value);
 }
 
-// src/daemon/upgrades/package.ts
-var DaemonReleaseUpgradeError = class extends Error {
-  code;
-  constructor(code, message, options) {
-    super(message, options);
-    this.code = code;
+// src/daemon/lifecycle/daemon-client.ts
+async function spawnDaemon() {
+  const entry = process.argv[1];
+  if (entry === void 0) {
+    throw new Error("The CLI entrypoint is missing");
   }
-};
-async function prepareDaemonReleaseVersion(version, signal) {
-  decodeRuntimeUpgradeVersion(version);
-  signal.throwIfAborted();
-  const prefix = releasePrefix(version);
-  let installed;
-  try {
-    installed = await readInstalledRelease(prefix);
-  } catch (cause) {
-    signal.throwIfAborted();
-    if (!isNodeError(cause, "ENOENT")) {
-      throw new DaemonReleaseUpgradeError(
-        "release_read_failed",
-        "The installed Mobius release could not be read",
-        { cause }
-      );
-    }
-    return await installDaemonReleaseVersion(version, signal);
-  }
-  try {
-    return await verifyInstalledDaemonRelease(installed, prefix, version, signal);
-  } catch (cause) {
-    signal.throwIfAborted();
-    if (cause instanceof DaemonReleaseUpgradeError) {
-      throw cause;
-    }
-    throw new DaemonReleaseUpgradeError("release_invalid", "The installed Mobius release could not be verified", {
-      cause
-    });
-  }
-}
-async function installDaemonReleaseVersion(version, signal) {
-  decodeRuntimeUpgradeVersion(version);
-  const npm = await findExecutableOnPath("npm", process.env);
-  if (npm === null) {
-    throw new DaemonReleaseUpgradeError("npm_unavailable", "npm is required to download the new daemon");
-  }
-  const prefix = releasePrefix(version);
-  await ensurePrivateDirectory(prefix);
-  try {
-    await validateLocalPath(prefix, true, true, signal);
-    await runBoundedProcess({
-      command: npm.path,
-      arguments: [
-        "install",
-        "--prefix",
-        prefix,
-        "--ignore-scripts",
-        "--no-audit",
-        "--no-fund",
-        "--save-exact",
-        "--",
-        `@moxt-ai/mobius@${version}`
-      ],
-      cwd: prefix,
-      environment: process.env,
-      signal,
-      timeoutMilliseconds: 3e5,
-      outputLimitBytes: 64 * 1024
-    });
-    return await verifyInstalledDaemonRelease(await readInstalledRelease(prefix), prefix, version, signal);
-  } catch (cause) {
-    signal.throwIfAborted();
-    if (cause instanceof DaemonReleaseUpgradeError) {
-      throw cause;
-    }
-    throw new DaemonReleaseUpgradeError(
-      "npm_install_failed",
-      "npm could not install and verify the requested Mobius version",
-      { cause }
-    );
-  }
-}
-async function verifyInstalledDaemonRelease(installed, prefix, version, signal) {
-  await validateLocalPath(prefix, true, true, signal);
-  const metadata = external_exports.object({
-    name: external_exports.literal("@moxt-ai/mobius"),
-    version: external_exports.literal(version),
-    bin: external_exports.object({ mobius: external_exports.literal("dist/cli.js") }),
-    engines: external_exports.object({ node: external_exports.string().refine((value) => (0, import_semver.validRange)(value) !== null) })
-  }).parse(JSON.parse(installed.manifest));
-  const entry = await canonicalPath(join10(installed.packageRoot, metadata.bin.mobius));
-  const resolved = relative(await canonicalPath(prefix), entry);
-  if (resolved.startsWith("..") || isAbsolute2(resolved)) {
-    throw new Error("Installed entry escaped npm prefix");
-  }
-  if (!(0, import_semver.satisfies)(process.versions.node, metadata.engines.node)) {
-    throw new DaemonReleaseUpgradeError(
-      "node_incompatible",
-      `Mobius ${version} requires Node.js ${metadata.engines.node}; the running daemon uses ${process.versions.node} at ${process.execPath}. Update Node.js before retrying.`
-    );
-  }
-  try {
-    const result = await runBoundedProcess({
-      command: process.execPath,
-      arguments: [entry, "--version"],
-      cwd: prefix,
-      environment: process.env,
-      signal,
-      timeoutMilliseconds: 3e4,
-      outputLimitBytes: 16 * 1024
-    });
-    if (!result.stdout.split(/\r?\n/u).includes(`CLI: ${version}`)) {
-      throw new Error("Candidate did not report the requested CLI version");
-    }
-  } catch (cause) {
-    signal.throwIfAborted();
-    throw new DaemonReleaseUpgradeError(
-      "release_startup_failed",
-      `Mobius ${version} startup check failed; the current daemon is unchanged.`,
-      { cause }
-    );
-  }
-  return await decodeWorkerLaunch({ executable: process.execPath, entry, version });
-}
-var npmViewVersionSchema = external_exports.union([external_exports.string(), external_exports.tuple([external_exports.string()])]).transform((value) => typeof value === "string" ? value : value[0]);
-async function findNewDaemonReleaseVersion(currentVersion, signal) {
-  const npm = await findExecutableOnPath("npm", process.env);
-  if (npm === null) {
-    throw new DaemonReleaseUpgradeError("npm_unavailable", "npm is required to check for a new daemon");
-  }
-  try {
-    const result = await runBoundedProcess({
-      command: npm.path,
-      arguments: ["view", "@moxt-ai/mobius", "dist-tags.latest", "--json", "--prefer-online"],
-      cwd: process.cwd(),
-      environment: process.env,
-      signal,
-      timeoutMilliseconds: 3e4,
-      outputLimitBytes: 4096
-    });
-    const version = decodeRuntimeUpgradeVersion(npmViewVersionSchema.parse(JSON.parse(result.stdout)));
-    return (0, import_semver.gt)(version, currentVersion) ? version : null;
-  } catch (cause) {
-    signal.throwIfAborted();
-    throw new DaemonReleaseUpgradeError("npm_check_failed", "npm could not return a valid latest Mobius version", {
-      cause
-    });
-  }
-}
-
-// src/daemon/lifecycle/manager-client.ts
-async function spawnManager(launch) {
-  const child = spawn2(launch.executable, [launch.entry, "__manager"], {
+  const child = spawn(process.execPath, [entry, "__daemon"], {
     detached: true,
     windowsHide: true,
     env: process.env,
     stdio: "ignore"
   });
+  await once(child, "spawn");
   child.unref();
   return child;
 }
-async function launchManager(launch) {
-  process.stdout.write(`Starting mobius daemon ${launch.version}
+async function launchDaemon(version) {
+  process.stdout.write(`Starting mobius daemon ${version}
 `);
-  await spawnManager(launch);
+  return await spawnDaemon();
 }
-async function waitForManagerExit(stateDirectory, signal) {
+async function waitForDaemonExit(stateDirectory, signal) {
   const deadline = AbortSignal.any([signal, AbortSignal.timeout(3e4)]);
   while (!deadline.aborted) {
-    if (!await managerLockExists(stateDirectory)) {
+    if (!await daemonLockExists(stateDirectory)) {
       return;
     }
     await new Promise((resolve6, reject) => {
@@ -4863,24 +4511,15 @@ async function waitForManagerExit(stateDirectory, signal) {
   }
   throw deadline.reason;
 }
-async function ensureWorkingProcess(stateDirectory, cliVersion, signal) {
-  const current = await readCurrentDataVersion(readStateDirectory(), signal);
-  const version = current !== null && (0, import_semver2.gt)(current, cliVersion) ? current : cliVersion;
-  const launch = await prepareDaemonReleaseVersion(version, signal);
-  const deadline = AbortSignal.any([signal, AbortSignal.timeout(CONTROL_TIMEOUT_MILLISECONDS)]);
-  await ensureManager(stateDirectory, launch, deadline);
-  const response = decodeKnownLifecycleResponse(
-    await sendLocalRequest(stateDirectory, "manager", { kind: "ensure", launch }, deadline)
-  );
-  if (response?.kind === "error") {
-    throw new Error(response.message);
+async function ensureDaemon(stateDirectory, version, signal) {
+  const running = await readDaemonVersion(stateDirectory, signal);
+  if (running !== null) {
+    return running;
   }
-  if (response?.kind !== "status" || response.worker?.version !== version) {
-    throw new Error("The working daemon did not start");
-  }
-  return version;
+  const deadline = AbortSignal.any([signal, AbortSignal.timeout(CONTROL_TIMEOUT_MILLISECONDS)]);
+  return await waitForDaemon(stateDirectory, version, deadline);
 }
-async function readWorkingProcessVersion(stateDirectory, signal) {
+async function readDaemonVersion(stateDirectory, signal) {
   try {
     const response = decodeKnownLifecycleResponse(
       await sendLocalRequest(stateDirectory, "manager", { kind: "status" }, signal)
@@ -4895,28 +4534,49 @@ async function readWorkingProcessVersion(stateDirectory, signal) {
   }
   return null;
 }
-async function ensureManager(stateDirectory, launch, signal) {
-  let managerStarted = false;
+async function waitForDaemon(stateDirectory, version, signal) {
+  let daemonStarted = false;
+  let child;
   while (!signal.aborted) {
     try {
-      const response = decodeKnownLifecycleResponse(
+      let response = decodeKnownLifecycleResponse(
         await sendLocalRequest(stateDirectory, "manager", { kind: "status" }, signal)
       );
-      if (response?.kind === "status") {
-        if (managerStarted) {
-          process.stdout.write(`Mobius daemon ${launch.version} started
+      if (response?.kind === "status" && response.worker === null) {
+        const entry = process.argv[1];
+        if (entry === void 0) {
+          throw new Error("The CLI entrypoint is missing");
+        }
+        response = decodeKnownLifecycleResponse(
+          await sendLocalRequest(
+            stateDirectory,
+            "manager",
+            { kind: "ensure", launch: { entry, executable: process.execPath, version } },
+            signal
+          )
+        );
+      }
+      if (response?.kind === "error") {
+        throw new Error(response.message);
+      }
+      if (response?.kind === "status" && response.worker !== null) {
+        if (daemonStarted) {
+          process.stdout.write(`Mobius daemon ${version} started
 `);
         }
-        return;
+        return response.worker.version;
       }
-      throw new Error("The manager could not return its status");
+      throw new Error("The daemon could not return its status");
     } catch (cause) {
       if (!isNodeError(cause, "ENOENT") && !isNodeError(cause, "ECONNREFUSED")) {
         throw cause;
       }
-      if (!managerStarted) {
-        await launchManager(launch);
-        managerStarted = true;
+      if (child !== void 0 && (child.signalCode !== null || child.exitCode !== null && (child.exitCode !== 0 || !await daemonLockExists(stateDirectory)))) {
+        throw new Error("The daemon exited before becoming ready");
+      }
+      if (!daemonStarted) {
+        child = await launchDaemon(version);
+        daemonStarted = true;
       }
       await new Promise((resolve6, reject) => {
         const timeout = setTimeout(finish, 50);
@@ -4932,414 +4592,42 @@ async function ensureManager(stateDirectory, launch, signal) {
   }
   throw signal.reason;
 }
-async function stopManager(stateDirectory, signal) {
-  try {
-    const response = decodeKnownLifecycleResponse(
-      await sendLocalRequest(stateDirectory, "manager", { kind: "stop" }, signal)
-    );
-    if (response?.kind === "error") {
-      throw new Error(response.message);
-    }
-    if (response?.kind !== "stopped") {
-      throw new Error("The Mobius manager returned an unexpected response");
-    }
-    await waitForManagerExit(stateDirectory, signal);
-    return response;
-  } catch (cause) {
-    if (isNodeError(cause, "ENOENT") || isNodeError(cause, "ECONNREFUSED")) {
-      return { kind: "stopped" };
-    }
-    throw cause;
-  }
-}
-
-// src/cli/handler/daemon/quit.ts
-function registerQuitCommand(program2, context) {
-  program2.command("quit").description("stop the manager and every active Runtime").action(async () => {
-    const installation = await openMobiusControlInstallation(context.shutdownSignal, process.env);
-    await stopManager(installation.stateDirectory, context.shutdownSignal);
-    process.stdout.write("Mobius daemon stopped.\n");
-  });
-}
-
-// src/daemon/lifecycle/worker.ts
-import { setTimeout as setTimeout4 } from "node:timers/promises";
-
-// src/engine/session/process/runtime-agent-processes.ts
-var RuntimeAgentProcesses = class {
-  #pools = /* @__PURE__ */ new Set();
-  /** Tracks a Runtime's pool until the returned function removes it. */
-  add = (pool) => {
-    this.#pools.add(pool);
-    return () => {
-      this.#pools.delete(pool);
-    };
-  };
-  retireIdleProcesses = async () => {
-    await Promise.all([...this.#pools].map(async (pool) => await pool.retireIdleProcesses()));
-  };
-};
-
-// src/daemon/upgrades/upgrade.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { setInterval, setTimeout as setTimeout3 } from "node:timers/promises";
-
-// src/daemon/control/switch-status.ts
-async function readSwitchStatus(directory, signal, wait = false) {
-  const response = decodeKnownLifecycleResponse(
-    await sendLocalRequest(directory, "manager", { kind: "switch-status", wait }, signal)
-  );
-  if (response?.kind !== "switch-status") {
-    throw new Error("The manager could not return the switch status");
-  }
-  return response.state;
-}
-
-// src/daemon/upgrades/upgrade.ts
-var SWITCH_COMPLETION_MILLISECONDS = 3e5;
-var SWITCH_POLL_MILLISECONDS = 200;
-var UPGRADE_QUIET_MILLISECONDS = 30 * 6e4;
-var UPGRADE_QUIET_CHECK_MILLISECONDS = 6e4;
-async function reportDaemonUpgradeAvailability(send, signal) {
-  if (!process.connected) {
-    return;
-  }
-  const control = await openMobiusControlInstallation(signal, process.env);
-  const transition2 = await readSwitchStatus(control.stateDirectory, signal, true);
-  if (transition2 === null) {
-    return;
-  }
-  const base = {
-    kind: "runtime.upgrade.result",
-    requestId: decodeIdentifier(transition2.id),
-    version: package_default.version,
-    targetVersion: transition2.next.version
-  };
-  if (transition2.kind === "rolled-back" && transition2.previous.version === package_default.version) {
-    send({
-      ...base,
-      kind: "runtime.upgrade.result",
-      outcome: {
-        status: "failed",
-        code: transition2.code,
-        message: transition2.message,
-        retryAfter: transition2.retryAfter,
-        stdout: transition2.stdout,
-        stderr: transition2.stderr
+async function stopDaemon(stateDirectory, signal) {
+  const deadline = AbortSignal.any([signal, AbortSignal.timeout(CONTROL_TIMEOUT_MILLISECONDS)]);
+  while (true) {
+    deadline.throwIfAborted();
+    try {
+      const response = decodeKnownLifecycleResponse(
+        await sendLocalRequest(stateDirectory, "manager", { kind: "stop" }, deadline)
+      );
+      if (response?.kind === "error") {
+        throw new Error(response.message);
       }
-    });
-  } else if (transition2.next.version === package_default.version) {
-    send({ ...base, kind: "runtime.upgrade.result", outcome: { status: "succeeded" } });
-  }
-}
-async function runDaemonReleaseUpgrades(signal, activity) {
-  try {
-    for await (const _tick of setInterval(36e5, void 0, { signal })) {
-      try {
-        await checkDaemonReleaseUpgrade(signal, activity);
-      } catch (cause) {
-        signal.throwIfAborted();
-        console.error("Daemon npm upgrade check failed", cause);
+      if (response?.kind !== "stopped") {
+        throw new Error("The Mobius daemon returned an unexpected response");
       }
-    }
-  } catch (cause) {
-    if (!signal.aborted) {
-      throw cause;
-    }
-  }
-}
-async function requestDaemonReleaseUpgrade(stateDirectory, currentVersion, signal) {
-  const version = await findNewDaemonReleaseVersion(currentVersion, signal);
-  if (version === null) {
-    return { kind: "current" };
-  }
-  const launch = await installDaemonReleaseVersion(version, signal);
-  return await requestInstalledDaemonReleaseSwitch(stateDirectory, launch, signal);
-}
-async function requestInstalledDaemonReleaseSwitch(stateDirectory, launch, signal) {
-  const id = randomUUID2();
-  const response = decodeKnownLifecycleResponse(
-    await sendLocalRequest(stateDirectory, "manager", { kind: "switch", id, context: "npm", launch }, signal)
-  );
-  if (response?.kind === "error") {
-    throw new DaemonReleaseUpgradeError(response.code, response.message);
-  }
-  if (response?.kind !== "switching") {
-    throw new DaemonReleaseUpgradeError("manager_incompatible", "The manager does not support daemon switching");
-  }
-  return { kind: "requested", id, version: launch.version };
-}
-async function awaitDaemonReleaseSwitch(stateDirectory, id, signal) {
-  const deadline = AbortSignal.any([signal, AbortSignal.timeout(SWITCH_COMPLETION_MILLISECONDS)]);
-  let outcome;
-  while (!deadline.aborted) {
-    let state;
-    try {
-      state = await readSwitchStatus(stateDirectory, deadline);
+      await waitForDaemonExit(stateDirectory, deadline);
+      return response;
     } catch (cause) {
-      if (isNodeError(cause, "ENOENT") || isNodeError(cause, "ECONNREFUSED")) {
-        throw cause;
-      }
       deadline.throwIfAborted();
-      state = null;
-    }
-    if (state !== null && state.id === id && state.kind !== "switching") {
-      outcome = state;
-      break;
-    }
-    await setTimeout3(SWITCH_POLL_MILLISECONDS, void 0, { signal: deadline });
-  }
-  if (outcome === void 0) {
-    throw deadline.reason;
-  }
-  if (outcome.kind === "rolled-back") {
-    deadline.throwIfAborted();
-    await readSwitchStatus(stateDirectory, deadline, true).catch(() => void 0);
-  }
-  return outcome;
-}
-async function reserveWhenQuiet(activity, signal) {
-  for (; ; ) {
-    await activity.whenIdle(signal);
-    for await (const _tick of setInterval(UPGRADE_QUIET_CHECK_MILLISECONDS, void 0, { signal })) {
-      const reservation = activity.reserveIfQuiet(UPGRADE_QUIET_MILLISECONDS);
-      if (reservation !== null) {
-        return reservation;
+      if (!isNodeError(cause, "ENOENT") && !isNodeError(cause, "ECONNREFUSED")) {
+        throw cause;
       }
-      if (activity.count() > 0) {
-        break;
+      if (!await daemonLockExists(stateDirectory)) {
+        return { kind: "stopped" };
       }
+      await delay2(50, void 0, { signal: deadline });
     }
-    signal.throwIfAborted();
-  }
-}
-async function checkDaemonReleaseUpgrade(signal, activity) {
-  var _stack = [];
-  try {
-    const control = await openMobiusControlInstallation(signal, process.env);
-    const transition2 = await readSwitchStatus(control.stateDirectory, signal);
-    if (transition2?.kind === "switching" || transition2?.kind === "rolled-back" && transition2.retryAfter > Date.now()) {
-      return;
-    }
-    const version = await findNewDaemonReleaseVersion(package_default.version, signal);
-    if (version === null) {
-      return;
-    }
-    const launch = await installDaemonReleaseVersion(version, signal);
-    let reservation = activity.reserveIfQuiet(UPGRADE_QUIET_MILLISECONDS);
-    if (reservation === null) {
-      const diagnostics = new RuntimeDiagnosticLog(control.stateDirectory);
-      const record = (event, details = {}) => diagnostics.record(
-        `Mobius daemon diagnostic ${JSON.stringify({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), event, version, ...details })}`
-      );
-      record("daemon_upgrade_deferred", { activeWork: activity.count(), ...activity.describe() });
-      reservation = await reserveWhenQuiet(activity, signal);
-      record("daemon_upgrade_released");
-    }
-    const _reservation = __using(_stack, reservation);
-    signal.throwIfAborted();
-    await requestInstalledDaemonReleaseSwitch(control.stateDirectory, launch, signal);
-    await new Promise((resolve6) => {
-      if (signal.aborted) {
-        resolve6();
-      } else {
-        signal.addEventListener("abort", () => resolve6(), { once: true });
-      }
-    });
-  } catch (_) {
-    var _error = _, _hasError = true;
-  } finally {
-    __callDispose(_stack, _error, _hasError);
   }
 }
 
-// src/daemon/lifecycle/worker.ts
-var WorkerRuntimeError = class extends Error {
-  code = "worker_runtime_failed";
-  constructor(connectionId, cause) {
-    super(`Runtime ${connectionId} failed`, { cause });
-  }
-};
-async function reloadDaemon(stateDirectory, signal) {
-  try {
-    const response = await sendLocalRequest(stateDirectory, "worker", { kind: "reload" }, signal);
-    if (typeof response !== "object" || response === null || !("kind" in response) || response.kind !== "reloaded") {
-      throw new Error("Saved configuration could not be applied to the running daemon");
-    }
-  } catch (cause) {
-    if (!isNodeError(cause, "ENOENT") && !isNodeError(cause, "ECONNREFUSED")) {
-      throw cause;
-    }
-  }
-}
-async function releaseIdleAgentProcesses(stateDirectory, signal) {
-  try {
-    const response = await sendLocalRequest(stateDirectory, "worker", { kind: "release" }, signal);
-    if (typeof response === "object" && response !== null && "kind" in response && response.kind === "released") {
-      return;
-    }
-    throw new Error("The running daemon cannot release Agent sessions. Run `mobius start` to update it first.");
-  } catch (cause) {
-    if (!isNodeError(cause, "ENOENT") && !isNodeError(cause, "ECONNREFUSED")) {
-      throw cause;
-    }
-  }
-}
-async function runWorker(version, signal) {
-  if (!process.connected) {
-    throw new Error("The daemon must be started by its manager");
-  }
-  const rejectionGuard = surviveUnhandledRejections("worker");
-  const shutdown = new AbortController();
-  const combined = AbortSignal.any([signal, shutdown.signal]);
-  const disconnect = () => shutdown.abort();
-  process.once("disconnect", disconnect);
-  try {
-    await runWorkerRuntime(version, combined, shutdown, rejectionGuard);
-  } finally {
-    shutdown.abort();
-    process.off("disconnect", disconnect);
-    rejectionGuard.release();
-    if (process.connected) {
-      process.disconnect();
-    }
-  }
-}
-async function runWorkerRuntime(version, combined, shutdown, rejectionGuard) {
-  const control = await openMobiusControlInstallation(combined, process.env);
-  await prepareVersionData(version, combined);
-  const engineDataDir = await prepareMobiusEngineDataDir(version, combined, process.env);
-  const installation = await RuntimeInstallationStore.open(engineDataDir, combined);
-  const deadline = AbortSignal.any([combined, AbortSignal.timeout(15e3)]);
-  let release = null;
-  while (release === null) {
-    deadline.throwIfAborted();
-    release = await acquireManagerLock(control.stateDirectory, "worker.lock");
-    if (release === null) {
-      await setTimeout4(25, void 0, { signal: deadline });
-    }
-  }
-  rejectionGuard.bindStateDirectory(control.stateDirectory);
-  const turnActivity = new RuntimeTurnActivity();
-  const agentProcesses = new RuntimeAgentProcesses();
-  const active = /* @__PURE__ */ new Map();
-  const fail = (connectionId, cause) => {
-    console.error(`Runtime ${connectionId} failed; stopping the daemon`, cause);
-    shutdown.abort(new WorkerRuntimeError(connectionId, cause));
-  };
-  const reconcile = async () => {
-    const connections = await installation.listConnections(combined);
-    const enabled = new Set(
-      connections.filter((connection) => connection.activation === "active").map((connection) => connection.connectionId)
-    );
-    for (const [id, running] of active) {
-      if (enabled.has(id)) {
-        continue;
-      }
-      running.controller.abort();
-      await running.completion;
-      active.delete(id);
-    }
-    for (const connection of connections) {
-      if (!enabled.has(connection.connectionId) || active.has(connection.connectionId)) {
-        continue;
-      }
-      try {
-        const config = await prepareRuntimeConnection(
-          installation,
-          connection,
-          combined,
-          process.env,
-          resolveMaxAcpProcesses(process.env)
-        );
-        const controller = new AbortController();
-        const loop = new RuntimeLoop(async () => config, {
-          processLogsDirectory: control.stateDirectory,
-          turnActivity,
-          agentProcesses,
-          reportUpgradeAvailability: reportDaemonUpgradeAvailability
-        });
-        const completion = loop.run(AbortSignal.any([combined, controller.signal])).then(
-          () => {
-            if (!combined.aborted && !controller.signal.aborted) {
-              fail(connection.connectionId, new Error("The Runtime stopped unexpectedly"));
-            }
-          },
-          (cause) => {
-            if (!combined.aborted && !controller.signal.aborted) {
-              fail(connection.connectionId, cause);
-            }
-          }
-        ).finally(() => active.delete(connection.connectionId));
-        active.set(connection.connectionId, { config, controller, completion });
-      } catch (cause) {
-        combined.throwIfAborted();
-        fail(connection.connectionId, cause);
-        throw cause;
-      }
-    }
-  };
-  const refreshRunningCatalogs = async (connectionIds) => {
-    await Promise.all(
-      [...connectionIds].map(async (connectionId) => {
-        const config = active.get(connectionId)?.config;
-        if (config?.rediscoverAgents === void 0) {
-          return;
-        }
-        try {
-          await refreshAgentCatalog(
-            config,
-            config.rediscoverAgents,
-            AbortSignal.any([combined, AbortSignal.timeout(9e4)])
-          );
-        } catch (cause) {
-          combined.throwIfAborted();
-          console.error(`Runtime ${connectionId} could not refresh its Agent catalog`, cause);
-        }
-      })
-    );
-  };
-  let reload = Promise.resolve();
-  let upgrades = Promise.resolve();
-  try {
-    await reconcile();
-    await serveLocalControl(
-      control.stateDirectory,
-      "worker",
-      combined,
-      async (request) => {
-        if (typeof request === "object" && request !== null && "kind" in request && request.kind === "release") {
-          await agentProcesses.retireIdleProcesses();
-          return { kind: "released" };
-        }
-        if (typeof request !== "object" || request === null || !("kind" in request) || request.kind !== "reload") {
-          return { kind: "error", code: "invalid_reload", message: "Expected a configuration reload" };
-        }
-        const running = new Set(active.keys());
-        const pending = reload.then(reconcile).then(async () => await refreshRunningCatalogs(running));
-        reload = pending.catch(() => void 0);
-        await pending;
-        return { kind: "reloaded" };
-      },
-      async () => {
-        combined.throwIfAborted();
-        await recordCurrentData(version, combined);
-        upgrades = runDaemonReleaseUpgrades(combined, turnActivity);
-        if (process.connected) {
-          process.send?.({ kind: "worker-ready", version }, () => void 0);
-        }
-      }
-    );
-    if (shutdown.signal.reason instanceof WorkerRuntimeError) {
-      throw shutdown.signal.reason;
-    }
-  } finally {
-    shutdown.abort();
-    await upgrades;
-    await reload;
-    await Promise.all([...active.values()].map((running) => running.completion));
-    await release();
-  }
+// src/cli/handler/daemon/quit.ts
+function registerQuitCommand(program2, context) {
+  program2.command("stop").alias("quit").description("stop the daemon and every active Runtime").action(async () => {
+    const installation = await openMobiusControlInstallation(context.shutdownSignal, process.env);
+    await stopDaemon(installation.stateDirectory, context.shutdownSignal);
+    process.stdout.write("Mobius daemon stopped.\n");
+  });
 }
 
 // src/cli/handler/daemon/release.ts
@@ -5355,7 +4643,7 @@ function registerReleaseCommand(program2, context) {
 function registerStartCommand(program2, context) {
   program2.command("start").description("ensure the daemon is running and optionally activate a saved connection").addOption(valueOption("--connection <connection-id>", "saved Runtime connection identifier")).action(async (options) => {
     const control = await openMobiusControlInstallation(context.shutdownSignal, process.env);
-    await ensureWorkingProcess(control.stateDirectory, context.version, context.shutdownSignal);
+    await ensureDaemon(control.stateDirectory, context.version, context.shutdownSignal);
     const installation = await openMobiusCliInstallation(context.shutdownSignal, process.env);
     if (options.connection !== void 0) {
       await installation.setConnectionActivation(options.connection, "active", context.shutdownSignal);
@@ -5367,43 +4655,23 @@ function registerStartCommand(program2, context) {
 
 // src/cli/handler/daemon/upgrade.ts
 function registerUpgradeCommand(program2, context) {
-  program2.command("upgrade").description("start the daemon if needed and upgrade it to the newest npm release").action(async () => {
-    const signal = context.shutdownSignal;
-    const control = await openMobiusControlInstallation(signal, process.env);
-    const current = await readWorkingProcessVersion(control.stateDirectory, signal) ?? await ensureWorkingProcess(control.stateDirectory, context.version, signal);
-    await reloadDaemon(control.stateDirectory, signal);
-    const attempt = await requestDaemonReleaseUpgrade(control.stateDirectory, current, signal);
-    if (attempt.kind === "current") {
-      process.stdout.write(`Mobius daemon ${current} is already the newest release.
-`);
-      return;
-    }
-    process.stdout.write(`Upgrading Mobius daemon to ${attempt.version}...
-`);
-    const outcome = await awaitDaemonReleaseSwitch(control.stateDirectory, attempt.id, signal);
-    if (outcome.kind === "switched") {
-      process.stdout.write(`Mobius daemon upgraded to ${attempt.version}.
+  program2.command("restart").alias("upgrade").description("restart the daemon using the latest release").action(async () => {
+    const control = await openMobiusControlInstallation(context.shutdownSignal, process.env);
+    await stopDaemon(control.stateDirectory, context.shutdownSignal);
+    const version = await ensureDaemon(control.stateDirectory, context.version, context.shutdownSignal);
+    process.stdout.write(`Mobius daemon ${version} restarted.
 `);
-      return;
-    }
-    throw new DaemonReleaseUpgradeError(
-      outcome.code,
-      `The upgrade to ${attempt.version} failed and ${outcome.previous.version} was restored: ${outcome.message}`
-    );
-  });
-}
-
-// src/cli/handler/daemon/worker.ts
-function registerWorkerCommand(program2, context) {
-  program2.command("__worker", { hidden: true }).action(async () => {
-    await runWorker(context.version, context.shutdownSignal);
   });
 }
 
 // src/cli/handler/daemon/index.ts
 function registerInternalRuntimeHandlers(program2, context) {
-  registerManagerCommand(program2, context);
-  registerWorkerCommand(program2, context);
+  program2.command("__daemon", { hidden: true }).action(async () => {
+    await runDaemon(context.version, context.shutdownSignal);
+  });
+  program2.command("__worker", { hidden: true }).action(async () => {
+    await runDaemon(context.version, context.shutdownSignal, "legacy-manager");
+  });
 }
 function registerDaemonProcessLifecycleHandlers(program2, context) {
   registerStartCommand(program2, context);
@@ -5414,11 +4682,11 @@ function registerDaemonProcessLifecycleHandlers(program2, context) {
 
 // src/cli/handler/diagnose/index.ts
 import { fork } from "node:child_process";
-import { join as join13, resolve as resolve3 } from "node:path";
+import { join as join11, resolve as resolve3 } from "node:path";
 
 // src/storage/diagnostics/relay-probe-files.ts
-import { mkdir, readFile as readFile6, rm as rm2, stat as stat2, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join11 } from "node:path";
+import { mkdir, readFile as readFile5, rm as rm2, stat as stat2, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join9 } from "node:path";
 var ProbeConfigurationFileError = class extends Error {
   code = "probe_config_invalid";
 };
@@ -5431,7 +4699,7 @@ async function readPrivateProbeConfiguration(path2, signal) {
     );
   }
   try {
-    return JSON.parse(await readFile6(path2, { encoding: "utf8", signal }));
+    return JSON.parse(await readFile5(path2, { encoding: "utf8", signal }));
   } catch {
     signal.throwIfAborted();
     throw new ProbeConfigurationFileError("The pairing configuration is not valid JSON");
@@ -5444,16 +4712,16 @@ async function ensureProbeDirectory(directory) {
   await mkdir(directory, { recursive: true, mode: 448 });
 }
 async function writeProbeReport(directory, report) {
-  await writeFile4(join11(directory, "report.json"), `${JSON.stringify(report, null, 2)}
+  await writeFile4(join9(directory, "report.json"), `${JSON.stringify(report, null, 2)}
 `, { mode: 384 });
 }
 async function writeProbeEvents(directory, events) {
-  await writeFile4(join11(directory, "transport.jsonl"), events.map((event) => JSON.stringify(event)).join("\n"), {
+  await writeFile4(join9(directory, "transport.jsonl"), events.map((event) => JSON.stringify(event)).join("\n"), {
     mode: 384
   });
 }
 async function removeProbeState(directory) {
-  await rm2(join11(directory, "state"), { recursive: true, force: true });
+  await rm2(join9(directory, "state"), { recursive: true, force: true });
 }
 
 // src/cli/handler/diagnose/config.ts
@@ -5599,7 +4867,7 @@ async function collectRouteEvidence(hostname, cancellation) {
 }
 
 // src/cli/handler/diagnose/worker.ts
-import { join as join12 } from "node:path";
+import { join as join10 } from "node:path";
 async function runRelayProbeWorker(configPath, role, directory, signal) {
   if (!process.send) {
     throw new Error("The relay probe worker requires its coordinator");
@@ -5643,11 +4911,11 @@ async function runRelayProbeWorker(configPath, role, directory, signal) {
       collectRouteEvidence(origin.hostname, stopped),
       ...proxy === null ? [] : [collectRouteEvidence(proxy.hostname, stopped)]
     ]);
-    const workspace = join12(directory, "workspace");
+    const workspace = join10(directory, "workspace");
     await ensureProbeDirectory(workspace);
     const engine = new MobiusRuntimeEngine({
-      engineDataDir: join12(directory, "state"),
-      agentLaunchEnvironment: { HOME: join12(directory, "home"), PATH: "" }
+      engineDataDir: join10(directory, "state"),
+      agentLaunchEnvironment: { HOME: join10(directory, "home"), PATH: "" }
     });
     const pairing2 = config[role];
     const connection = await engine.pair(
@@ -5739,9 +5007,9 @@ var ProbeLeg = class {
       throw new RelayProbeError("probe_entrypoint_missing", "Cannot locate the Mobius CLI entrypoint");
     }
     const environment = {
-      HOME: join13(directory, "home"),
+      HOME: join11(directory, "home"),
       PATH: process.env["PATH"] ?? "",
-      MOBIUS_STATE_DIRECTORY: join13(directory, "state")
+      MOBIUS_STATE_DIRECTORY: join11(directory, "state")
     };
     for (const name of [
       "SystemRoot",
@@ -5884,8 +5152,8 @@ async function compare(configPath, output, duration, context) {
   try {
     for (const role of ["direct", "proxy"]) {
       context.shutdownSignal.throwIfAborted();
-      const legDirectory = join13(directory, role);
-      await ensureProbeDirectory(join13(legDirectory, "home"));
+      const legDirectory = join11(directory, role);
+      await ensureProbeDirectory(join11(legDirectory, "home"));
       legs.push(new ProbeLeg(role, resolve3(configPath), legDirectory, proxy));
     }
     const cancelled = Promise.withResolvers();
@@ -5969,11 +5237,11 @@ async function compare(configPath, output, duration, context) {
         legs: reports
       };
       await writeProbeReport(directory, report);
-      process.stdout.write(`${join13(directory, "report.json")}
+      process.stdout.write(`${join11(directory, "report.json")}
 `);
     } finally {
       clearTimeout(force);
-      await Promise.all(legs.map((leg) => removeProbeState(join13(directory, leg.role))));
+      await Promise.all(legs.map((leg) => removeProbeState(join11(directory, leg.role))));
     }
   }
 }
@@ -5998,11 +5266,11 @@ function registerDiagnoseCommand(program2, context) {
 }
 
 // src/cli/handler/logs/logic/collect-local-logs.ts
-import { join as join15, relative as relative3, resolve as resolve4 } from "node:path";
+import { join as join13, relative as relative2, resolve as resolve4 } from "node:path";
 
 // src/storage/logs/log-files.ts
-import { lstat as lstat2, readdir, readFile as readFile7 } from "node:fs/promises";
-import { join as join14, relative as relative2 } from "node:path";
+import { lstat as lstat2, readdir, readFile as readFile6 } from "node:fs/promises";
+import { join as join12, relative } from "node:path";
 var LOG_FILE_NAME_PATTERN = /^[\w.-]{1,128}\.log$/u;
 var INSTALLATIONS_DIRECTORY = "installations";
 var VERSIONS_DIRECTORY = "versions";
@@ -6010,22 +5278,22 @@ function isAbsent(cause) {
   return typeof cause === "object" && cause !== null && Reflect.get(cause, "code") === "ENOENT";
 }
 async function findLogDirectories(root, unreadable, signal) {
-  const versions = join14(root, VERSIONS_DIRECTORY);
-  const installationsRoots = [join14(root, INSTALLATIONS_DIRECTORY)];
+  const versions = join12(root, VERSIONS_DIRECTORY);
+  const installationsRoots = [join12(root, INSTALLATIONS_DIRECTORY)];
   for (const version of await listDirectories(versions, root, unreadable, signal)) {
-    installationsRoots.push(join14(versions, version, INSTALLATIONS_DIRECTORY));
+    installationsRoots.push(join12(versions, version, INSTALLATIONS_DIRECTORY));
   }
   const found = [];
   for (const installations of installationsRoots) {
     for (const dataDirectory of await listDirectories(installations, root, unreadable, signal)) {
-      const application = join14(installations, dataDirectory);
+      const application = join12(installations, dataDirectory);
       for (const installationId of await listDirectories(application, root, unreadable, signal)) {
-        const logs = join14(application, installationId, "logs");
+        const logs = join12(application, installationId, "logs");
         const status = await directoryStatus(logs);
         if (status === "listed") {
           found.push(logs);
         } else if (status === "unreadable") {
-          unreadable.push(relative2(root, logs));
+          unreadable.push(relative(root, logs));
         }
       }
     }
@@ -6039,7 +5307,7 @@ async function listDirectories(path2, root, unreadable, signal) {
     return entries.filter((entry) => entry.isDirectory() && !entry.isSymbolicLink()).map((entry) => entry.name);
   } catch (cause) {
     if (!isAbsent(cause)) {
-      unreadable.push(relative2(root, path2));
+      unreadable.push(relative(root, path2));
     }
     return [];
   }
@@ -6050,7 +5318,7 @@ async function listLogFiles(directory, root, unreadable) {
     return entries.filter((entry) => entry.isFile() && !entry.isSymbolicLink() && LOG_FILE_NAME_PATTERN.test(entry.name)).map((entry) => entry.name).sort();
   } catch (cause) {
     if (!isAbsent(cause)) {
-      unreadable.push(relative2(root, directory));
+      unreadable.push(relative(root, directory));
     }
     return [];
   }
@@ -6078,7 +5346,7 @@ async function readOwnedLogFile(path2, signal) {
     return { kind: "skipped" };
   }
   try {
-    return { kind: "read", content: await readFile7(path2, { encoding: "utf8", signal }) };
+    return { kind: "read", content: await readFile6(path2, { encoding: "utf8", signal }) };
   } catch (cause) {
     if (signal.aborted) {
       throw cause;
@@ -6100,8 +5368,8 @@ async function collectLocalDaemonLogs(stateDirectory, tailLines, signal) {
   for (const directory of directories) {
     const names = await listLogFiles(directory, root, unreadable);
     for (const name of names) {
-      const path2 = join15(directory, name);
-      const reported = relative3(root, path2);
+      const path2 = join13(directory, name);
+      const reported = relative2(root, path2);
       const read = await readOwnedLogFile(path2, signal);
       if (read.kind === "unreadable") {
         unreadable.push(reported);
@@ -6282,7 +5550,7 @@ function registerPairAction(command, context) {
   command.addOption(valueOption("--url <relay-url>", "relay HTTP or HTTPS URL")).addOption(valueOption("--code <pairing-code>", "pairing code shown in the browser")).addOption(valueOption("--pairing <runtime-pairing-id>", "Runtime pairing identifier")).addOption(valueOption("--workspace <directory>", "default workspace directory")).action(async (options) => {
     const requested = requirePairOptions(options, command);
     const control = await openMobiusControlInstallation(context.shutdownSignal, process.env);
-    await ensureWorkingProcess(control.stateDirectory, context.version, context.shutdownSignal);
+    await ensureDaemon(control.stateDirectory, context.version, context.shutdownSignal);
     const installation = await openMobiusCliInstallation(context.shutdownSignal, process.env);
     process.stdout.write(`mobius version: ${context.version}
 `);
@@ -6340,13 +5608,14 @@ function registerPairHandlers(program2, context) {
 // src/cli/handler/version/index.ts
 async function reportInstallationVersion(context) {
   const control = await openMobiusControlInstallation(context.shutdownSignal, process.env);
-  const daemonVersion = await readWorkingProcessVersion(control.stateDirectory, context.shutdownSignal);
+  const daemonVersion = await readDaemonVersion(control.stateDirectory, context.shutdownSignal);
   process.stdout.write(`CLI: ${context.version}
 `);
   process.stdout.write(`Daemon: ${daemonVersion ?? "not running"}
 `);
 }
 function registerVersionHandler(program2, context) {
+  program2.command("status").description("show CLI and daemon versions").action(async () => await reportInstallationVersion(context));
   program2.option("-v, --version", "print the CLI and running daemon versions");
   program2.action(() => {
     if (program2.opts()["version"]) {
@@ -6406,4 +5675,4 @@ async function runCLI() {
 export {
   runCLI
 };
-//# sourceMappingURL=cli-NLIGRBEL.js.map
+//# sourceMappingURL=cli-O57WJIFN.js.map