@moxt-ai/mobius 0.0.292 → 0.0.294

package/dist/cli.js

@@ -5398,7 +5398,7 @@ var program = new Command();
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.292",
+  version: "0.0.294",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -70684,6 +70684,7 @@ var queuePageSchema = external_exports.object({
   nextCursor: external_exports.string().nullish()
 });
 var CodexBorrowedAcpAgent = class {
+  steeringSupported = false;
   #client;
   #threadId;
   #emit;
@@ -70905,7 +70906,7 @@ var CodexBorrowedAcpAgent = class {
   nativeTurnId = () => null;
   steer = async (_params, signal) => {
     signal.throwIfAborted();
-    return { outcome: "promptRequired", reason: "noRunningTurn" };
+    throw new AcpExecutionError("This Codex session only supports queued input", {}, "steering_unsupported");
   };
   // The reader connection cannot receive or control the owner's live turn.
   onNotification = async (_method, _params) => {
@@ -71045,6 +71046,7 @@ function userInputSchema(questions) {
   return { properties, required: required2, type: "object" };
 }
 var CodexOwnedAcpAgent = class {
+  steeringSupported = true;
   #context;
   #appServer;
   #settings;
@@ -73967,7 +73969,10 @@ var CodexAcpAgent = class {
       await this.#resume(context.params.sessionId, context.params.cwd, context.signal);
       await this.#replaySavedHistory(context.signal);
       this.#advertiseCompactCommand();
-      return { configOptions: this.#settings.configOptions() };
+      return {
+        _meta: { steering: { supported: this.#sessionAgent.steeringSupported } },
+        configOptions: this.#settings.configOptions()
+      };
     }).onRequest(methods3.agent.session.fork, async (context) => {
       const forked = threadForkResponseSchema.parse(
         await this.#appServer.request(
@@ -73990,7 +73995,10 @@ var CodexAcpAgent = class {
     }).onRequest(methods3.agent.session.resume, async (context) => {
       await this.#resume(context.params.sessionId, context.params.cwd, context.signal);
       this.#advertiseCompactCommand();
-      return { configOptions: this.#settings.configOptions() };
+      return {
+        _meta: { steering: { supported: this.#sessionAgent.steeringSupported } },
+        configOptions: this.#settings.configOptions()
+      };
     }).onRequest(methods3.agent.session.prompt, async (context) => {
       if (isCompactCommand(context.params.prompt)) {
         return await this.#sessionAgent.compact(context.signal);
@@ -78310,6 +78318,16 @@ function normalizeAcpCapabilities(initialized) {
     unstableForkSession: session?.fork != null
   });
 }
+function restrictAcpSessionCapabilities(capabilities, response) {
+  if (!isRecord3(response) || !isRecord3(response["_meta"])) {
+    return capabilities;
+  }
+  const steering = response["_meta"]["steering"];
+  if (!isRecord3(steering) || steering["supported"] !== false) {
+    return capabilities;
+  }
+  return Object.freeze({ ...capabilities, steering: false });
+}
 
 // src/acp/agent/agent-definition.ts
 var AgentDefinition = class {
@@ -90333,6 +90351,7 @@ async function restoreSession(session, signal, recovery, origin) {
     session.setNativeHistoryOwnership({ kind: "fresh-session" });
     lifecycleResponse2 = created;
   }
+  session.restrictSessionCapabilities(lifecycleResponse2);
   session.setConfigOptions(session.sessionConfigProtocol.normalizeLifecycle(lifecycleResponse2));
   if (stored instanceof FoundStoredSession && session.restored) {
     await session.restoreStoredConfigurations(stored.session, signal);
@@ -90585,6 +90604,9 @@ var AgentSession = class _AgentSession {
       signal
     );
   };
+  restrictSessionCapabilities = (response) => {
+    this.#capabilities = restrictAcpSessionCapabilities(this.#capabilities, response);
+  };
   prepared = () => new PreparedSession(
     this.#agentName,
     this.#agentVersion,
@@ -90658,6 +90680,7 @@ var AgentSession = class _AgentSession {
         );
         await this.#updates.drained();
         signal.throwIfAborted();
+        this.restrictSessionCapabilities(response);
         const loaded = { history, kind: "loaded", response };
         this.#sessionLoad = loaded;
         return loaded;
@@ -93239,6 +93262,50 @@ var ExecutionReceipts = class {
   };
 };
 
+// src/session/turn/runtime-turn-activity.ts
+var RuntimeTurnActivity = class {
+  #turns = /* @__PURE__ */ new Set();
+  #admission = { kind: "open" };
+  acceptsPrompts = () => this.#admission.kind !== "reserved";
+  count = () => this.#turns.size;
+  start = (turn) => {
+    this.#turns.add(turn);
+  };
+  finish = (turn) => {
+    this.#turns.delete(turn);
+    if (this.#turns.size === 0 && this.#admission.kind === "waiting") {
+      this.#admission.reserve();
+    }
+  };
+  reserveWhenIdle = (signal) => {
+    signal.throwIfAborted();
+    if (this.#admission.kind !== "open") {
+      throw new Error("A daemon upgrade already owns admission");
+    }
+    return new Promise((resolve20, reject2) => {
+      const abort = () => {
+        this.#admission = { kind: "open" };
+        signal.removeEventListener("abort", abort);
+        reject2(signal.reason);
+      };
+      const reserve = () => {
+        this.#admission = { kind: "reserved" };
+        signal.removeEventListener("abort", abort);
+        resolve20({
+          [Symbol.dispose]: () => {
+            this.#admission = { kind: "open" };
+          }
+        });
+      };
+      this.#admission = { kind: "waiting", reserve };
+      signal.addEventListener("abort", abort, { once: true });
+      if (this.#turns.size === 0) {
+        reserve();
+      }
+    });
+  };
+};
+
 // src/session/turn/active-turn.ts
 import { randomUUID as randomUUID15 } from "node:crypto";
 var ActiveRuntimeTurn = class {
@@ -93455,9 +93522,12 @@ var SessionExecutionState = class {
 var SessionTurns = class {
   #bySessionId = /* @__PURE__ */ new Map();
   #operations;
-  constructor(operations) {
+  #activity;
+  constructor(operations, activity2 = new RuntimeTurnActivity()) {
     this.#operations = operations;
+    this.#activity = activity2;
   }
+  acceptsPrompts = () => this.#activity.acceptsPrompts();
   session = (sessionId) => {
     let session = this.#bySessionId.get(sessionId);
     if (session === void 0) {
@@ -93467,10 +93537,15 @@ var SessionTurns = class {
     return session;
   };
   get = (commandId, sessionId) => this.#bySessionId.get(sessionId)?.get(commandId);
-  start = (command, attemptId) => this.session(command.sessionId).start(command, attemptId);
+  start = (command, attemptId) => {
+    const turn = this.session(command.sessionId).start(command, attemptId);
+    this.#activity.start(turn);
+    return turn;
+  };
   finish = (turn) => {
     this.#bySessionId.get(turn.command.sessionId)?.finish(turn);
     this.sweep();
+    this.#activity.finish(turn);
   };
   recordEvent = (event) => "sessionId" in event ? this.#bySessionId.get(event.sessionId)?.recordEvent(event) ?? event : event;
   recordSessionEvent = (event) => {
@@ -93712,7 +93787,7 @@ function buildSessionLayer(options) {
   const sessionStore = new SqliteSessionStore(new AcpSessionTable(sessionDatabase), events);
   const externalContent = new LocalExternalContentStore(stateDirectory);
   const operations = new ExecutionReceipts();
-  const activeSessions = new SessionTurns(operations);
+  const activeSessions = new SessionTurns(operations, options.turnActivity);
   const directories = new WorkspaceDirectoryService(bindingId, defaultWorkspace);
   const manager = new SessionManager2({
     observer: new SessionLayerObserver((event) => eventProjection.record(event), sink.publishInfo),
@@ -95685,6 +95760,16 @@ var sessionPromptCommand = {
     if (message.kind !== SESSION_PROMPT_KIND) {
       throw new Error("Command kind mismatch");
     }
+    if (!context.sessionTurns.acceptsPrompts()) {
+      send(context.socket, {
+        code: "runtime_upgrading",
+        requestId: message.commandId,
+        kind: "session.operation.failed",
+        message: "The Runtime is upgrading. Retry after it reconnects.",
+        sessionId: message.sessionId
+      });
+      return;
+    }
     const receipt = context.operations.claimExecution(
       message.commandId,
       message.sessionId,
@@ -96490,6 +96575,7 @@ async function runRelayConnection({
         reject2(failure2);
       };
       const stop = () => {
+        publisher.flush();
         diagnostics.connectionClosed(connectionEpoch, 1e3, "Daemon stopped", "daemon_stop");
         closeRelaySocket(socket, 1e3, "Daemon stopped");
         resolveConnection();
@@ -96645,6 +96731,11 @@ var RuntimeSessionEventPublisher = class {
     this.#socket = null;
     this.dropPendingEvents();
   };
+  flush = () => {
+    if (this.#socket !== null) {
+      this.flushEvents(this.#socket);
+    }
+  };
   publishOperationFailure = (sessionId, requestId, code, message) => {
     this.#send({ kind: "session.operation.failed", sessionId, requestId, code, message });
   };
@@ -96778,6 +96869,7 @@ async function runRuntime(config2, parentSignal, timer = systemTimer, options =
   );
   const publisher = new RuntimeSessionEventPublisher(timer);
   const layer = buildSessionLayer({
+    ...options.turnActivity === void 0 ? {} : { turnActivity: options.turnActivity },
     bindingId: config2.bindingId,
     channelId: config2.channelId,
     defaultWorkspace: config2.defaultWorkspace,
@@ -96947,6 +97039,7 @@ var MobiusRuntimeEngine = class {
     this.#state = new RunningMobiusRuntimeState();
     try {
       await runRuntime(this.#config, signal, void 0, {
+        ...this.#options.turnActivity === void 0 ? {} : { turnActivity: this.#options.turnActivity },
         ...this.#options.onConnectionStatus === void 0 ? {} : { onConnectionStatus: this.#options.onConnectionStatus },
         ...this.#options.reportUpgradeAvailability === void 0 ? {} : { reportUpgradeAvailability: this.#options.reportUpgradeAvailability },
         ...this.#options.processLogsDirectory === void 0 ? {} : { processLogsDirectory: this.#options.processLogsDirectory }
@@ -97095,11 +97188,11 @@ async function reportDaemonUpgradeAvailability(send2, signal) {
     send2({ ...base, kind: "runtime.upgrade.result", outcome: { status: "succeeded" } });
   }
 }
-async function runDaemonReleaseUpgrades(signal) {
+async function runDaemonReleaseUpgrades(signal, activity2) {
   try {
     for await (const _tick of setInterval2(36e5, void 0, { signal })) {
       try {
-        await checkDaemonReleaseUpgrade(signal);
+        await checkDaemonReleaseUpgrade(signal, activity2);
       } catch (cause) {
         signal.throwIfAborted();
         console.error("Daemon npm upgrade check failed", cause);
@@ -97117,6 +97210,9 @@ async function requestDaemonReleaseUpgrade(stateDirectory, currentVersion, signa
     return { kind: "current" };
   }
   const launch = await installDaemonReleaseVersion(version2, signal);
+  return await requestInstalledDaemonReleaseSwitch(stateDirectory, launch, signal);
+}
+async function requestInstalledDaemonReleaseSwitch(stateDirectory, launch, signal) {
   const id = randomUUID17();
   const response = lifecycleResponse.parse(
     await sendLocalRequest(stateDirectory, "manager", { kind: "switch", id, context: "npm", launch }, signal)
@@ -97127,7 +97223,7 @@ async function requestDaemonReleaseUpgrade(stateDirectory, currentVersion, signa
   if (response.kind !== "switching") {
     throw new DaemonReleaseUpgradeError("manager_incompatible", "The manager does not support daemon switching");
   }
-  return { kind: "requested", id, version: version2 };
+  return { kind: "requested", id, version: launch.version };
 }
 async function awaitDaemonReleaseSwitch(stateDirectory, id, signal) {
   const deadline = AbortSignal.any([signal, AbortSignal.timeout(SWITCH_COMPLETION_MILLISECONDS)]);
@@ -97158,13 +97254,37 @@ async function awaitDaemonReleaseSwitch(stateDirectory, id, signal) {
   }
   return outcome;
 }
-async function checkDaemonReleaseUpgrade(signal) {
+async function checkDaemonReleaseUpgrade(signal, activity2) {
   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;
   }
-  await requestDaemonReleaseUpgrade(control.stateDirectory, package_default.version, signal);
+  const version2 = await findNewDaemonReleaseVersion(package_default.version, signal);
+  if (version2 === null) {
+    return;
+  }
+  const launch = await installDaemonReleaseVersion(version2, signal);
+  if (activity2.count() > 0) {
+    new RuntimeDiagnosticLog(control.stateDirectory).record(
+      `Mobius daemon diagnostic ${JSON.stringify({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        event: "daemon_upgrade_deferred",
+        version: version2,
+        activeTurns: activity2.count()
+      })}`
+    );
+  }
+  using _reservation = await activity2.reserveWhenIdle(signal);
+  signal.throwIfAborted();
+  await requestInstalledDaemonReleaseSwitch(control.stateDirectory, launch, signal);
+  await new Promise((resolve20) => {
+    if (signal.aborted) {
+      resolve20();
+    } else {
+      signal.addEventListener("abort", () => resolve20(), { once: true });
+    }
+  });
 }
 
 // src/daemon/lifecycle/worker.ts
@@ -97220,6 +97340,7 @@ async function runWorkerRuntime(version2, combined, shutdown, rejectionGuard) {
     }
   }
   rejectionGuard.bindStateDirectory(control.stateDirectory);
+  const turnActivity = new RuntimeTurnActivity();
   const active = /* @__PURE__ */ new Map();
   const fail = (connectionId2, cause) => {
     console.error(`Runtime ${connectionId2} failed; stopping the daemon`, cause);
@@ -97247,6 +97368,7 @@ async function runWorkerRuntime(version2, combined, shutdown, rejectionGuard) {
         const controller = new AbortController();
         const engine = new MobiusRuntimeEngine(paired.config, {
           processLogsDirectory: control.stateDirectory,
+          turnActivity,
           reportUpgradeAvailability: reportDaemonUpgradeAvailability
         });
         const completion = engine.run(AbortSignal.any([combined, controller.signal])).then(
@@ -97289,7 +97411,7 @@ async function runWorkerRuntime(version2, combined, shutdown, rejectionGuard) {
       async () => {
         combined.throwIfAborted();
         await recordCurrentData(version2, combined);
-        upgrades = runDaemonReleaseUpgrades(combined);
+        upgrades = runDaemonReleaseUpgrades(combined, turnActivity);
         if (process.connected) {
           process.send?.({ kind: "worker-ready", version: version2 }, () => void 0);
         }