@moxt-ai/mobius 0.0.149 → 0.0.152

package/dist/runtime.js

@@ -20740,9 +20740,17 @@ function decodeSessionQueuedEvent(encoded) {
 }
 function decodeRuntimeLivenessReadyEvent(encoded) {
   const value = parseJson2(encoded);
-  assertExactKeys(value, ["kind"]);
   assertKind(value, RUNTIME_LIVENESS_READY_KIND);
-  return { kind: RUNTIME_LIVENESS_READY_KIND };
+  if (value["sessionEventDelivery"] === void 0) {
+    assertExactKeys(value, ["kind"]);
+    return { kind: RUNTIME_LIVENESS_READY_KIND };
+  }
+  assertExactKeys(value, ["kind", "sessionEventDelivery"]);
+  const sessionEventDelivery = readString(value, "sessionEventDelivery", 32);
+  if (sessionEventDelivery !== "reliable-v1") {
+    throw new ProtocolMessageError("Unsupported Session event delivery mode");
+  }
+  return { kind: RUNTIME_LIVENESS_READY_KIND, sessionEventDelivery };
 }
 function decodeRuntimeHeartbeatEvent(encoded) {
   const value = parseJson2(encoded);
@@ -21074,6 +21082,12 @@ var nativeSessionRequestSchema = external_exports.discriminatedUnion("action", [
     entryId: identifierStringSchema,
     targetSessionId: identifierStringSchema
   }).readonly(),
+  external_exports.strictObject({
+    ...identity,
+    action: external_exports.literal("fork-recorded"),
+    targetSessionId: identifierStringSchema,
+    throughCommandId: identifierStringSchema
+  }).readonly(),
   external_exports.strictObject({
     ...identity,
     action: external_exports.literal("delete"),
@@ -21097,6 +21111,12 @@ var nativeSessionCommandSchema = external_exports.discriminatedUnion("action", [
     entryId: identifierStringSchema,
     targetSessionId: identifierStringSchema
   }).readonly(),
+  external_exports.strictObject({
+    ...identity,
+    action: external_exports.literal("fork-recorded"),
+    targetSessionId: identifierStringSchema,
+    throughCommandId: identifierStringSchema
+  }).readonly(),
   external_exports.strictObject({
     ...identity,
     action: external_exports.literal("delete"),
@@ -21146,7 +21166,7 @@ var nativeSessionResultSchema = external_exports.discriminatedUnion("action", [
   }).readonly(),
   external_exports.strictObject({
     ...resultEnvelope,
-    action: external_exports.enum(["import", "fork"]),
+    action: external_exports.enum(["import", "fork", "fork-recorded"]),
     targetSessionId: identifierStringSchema,
     ready: sessionReadyEventSchema,
     title: external_exports.string().max(500)
@@ -21192,14 +21212,68 @@ var encodeNativeSessionCancel = (value) => JSON.stringify(nativeSessionCancelSch
 
 // ../protocol/src/session-events.ts
 var SESSION_EVENT_KIND = "session.event";
+var SESSION_EVENT_ACK_KIND = "session.event.ack";
+var SESSION_EVENT_DEFERRED_KIND = "session.event.deferred";
+var SESSION_EVENT_REJECTED_KIND = "session.event.rejected";
+var SESSION_FORKED_KIND = "session.forked";
+var SessionEventRejectionCode = {
+  IdempotencyConflict: "idempotency_conflict",
+  InvalidEvent: "invalid_event",
+  RecordingRejected: "recording_rejected"
+};
 var MAX_RECORDED_EVENT_LENGTH = 8 * 1024 * 1024;
-var eventEnvelopeSchema = external_exports.strictObject({
+var ephemeralEventEnvelopeSchema = external_exports.strictObject({
   kind: external_exports.literal(SESSION_EVENT_KIND),
   payload: external_exports.string().min(2).max(MAX_RECORDED_EVENT_LENGTH),
   sessionId: identifierStringSchema
 }).readonly();
+var reliableDeliverySchema = external_exports.strictObject({
+  eventId: identifierStringSchema,
+  kind: external_exports.literal("reliable"),
+  sourceSeq: external_exports.string().regex(/^(?:0|[1-9][0-9]*)$/u).max(40),
+  streamId: identifierStringSchema
+}).readonly();
+var reliableSessionEventEnvelopeSchema = external_exports.strictObject({
+  delivery: reliableDeliverySchema,
+  kind: external_exports.literal(SESSION_EVENT_KIND),
+  payload: external_exports.string().min(2).max(MAX_RECORDED_EVENT_LENGTH),
+  sessionId: identifierStringSchema
+}).readonly();
+var eventEnvelopeSchema = external_exports.union([ephemeralEventEnvelopeSchema, reliableSessionEventEnvelopeSchema]).readonly();
+var acknowledgementOutcomeSchema = external_exports.discriminatedUnion("kind", [
+  external_exports.strictObject({ kind: external_exports.literal("relayed") }).readonly(),
+  external_exports.strictObject({
+    kind: external_exports.literal("recorded"),
+    providerId: identifierStringSchema,
+    recordingEpoch: identifierStringSchema
+  }).readonly()
+]);
+var eventAcknowledgementSchema = external_exports.strictObject({
+  eventId: identifierStringSchema,
+  kind: external_exports.literal(SESSION_EVENT_ACK_KIND),
+  outcome: acknowledgementOutcomeSchema,
+  sessionId: identifierStringSchema
+}).readonly();
+var eventDeferredSchema = external_exports.strictObject({
+  eventId: identifierStringSchema,
+  kind: external_exports.literal(SESSION_EVENT_DEFERRED_KIND),
+  retryAfterMilliseconds: external_exports.number().int().min(100).max(6e4),
+  sessionId: identifierStringSchema
+}).readonly();
+var eventRejectedSchema = external_exports.strictObject({
+  code: external_exports.enum(SessionEventRejectionCode),
+  eventId: identifierStringSchema,
+  kind: external_exports.literal(SESSION_EVENT_REJECTED_KIND),
+  sessionId: identifierStringSchema
+}).readonly();
 var SESSION_QUEUE_CHANGED_KIND = "session.queue.changed";
 var sessionQueueChangedSchema = external_exports.strictObject({ kind: external_exports.literal(SESSION_QUEUE_CHANGED_KIND), sessionId: identifierStringSchema }).readonly();
+var sessionForkedSchema = external_exports.strictObject({
+  kind: external_exports.literal(SESSION_FORKED_KIND),
+  sessionId: identifierStringSchema,
+  sourceSessionId: identifierStringSchema,
+  throughCommandId: identifierStringSchema
+}).readonly();
 function decode5(encoded, schema) {
   let value;
   try {
@@ -21226,11 +21300,19 @@ var encode4 = (message, schema) => {
 };
 var decodeSessionEventEnvelope = (encoded) => decode5(encoded, eventEnvelopeSchema);
 var encodeSessionEventEnvelope = (message) => encode4(message, eventEnvelopeSchema);
+var decodeSessionEventAcknowledgement = (encoded) => decode5(encoded, eventAcknowledgementSchema);
+var encodeSessionEventAcknowledgement = (message) => encode4(message, eventAcknowledgementSchema);
+var decodeSessionEventDeferred = (encoded) => decode5(encoded, eventDeferredSchema);
+var encodeSessionEventDeferred = (message) => encode4(message, eventDeferredSchema);
+var decodeSessionEventRejected = (encoded) => decode5(encoded, eventRejectedSchema);
+var encodeSessionEventRejected = (message) => encode4(message, eventRejectedSchema);
 function decodeRecordedSessionEvent(encoded) {
   const kind = decodeMessageKind(encoded);
   switch (kind) {
     case SESSION_QUEUE_CHANGED_KIND:
       return decode5(encoded, sessionQueueChangedSchema);
+    case SESSION_FORKED_KIND:
+      return decode5(encoded, sessionForkedSchema);
     case AGENT_ACTIVITY_KIND:
       return decodeAgentActivityEvent(encoded);
     case AGENT_ACTIVITY_NARRATION_KIND:
@@ -21397,6 +21479,21 @@ var serviceToDaemonSignatures = {
     encodeSessionElicitationRespondCommand,
     decodeSessionElicitationRespondCommand
   ),
+  [SESSION_EVENT_ACK_KIND]: defineMessageSignature(
+    SESSION_EVENT_ACK_KIND,
+    encodeSessionEventAcknowledgement,
+    decodeSessionEventAcknowledgement
+  ),
+  [SESSION_EVENT_DEFERRED_KIND]: defineMessageSignature(
+    SESSION_EVENT_DEFERRED_KIND,
+    encodeSessionEventDeferred,
+    decodeSessionEventDeferred
+  ),
+  [SESSION_EVENT_REJECTED_KIND]: defineMessageSignature(
+    SESSION_EVENT_REJECTED_KIND,
+    encodeSessionEventRejected,
+    decodeSessionEventRejected
+  ),
   [SESSION_LIVE_HISTORY_LOAD_KIND]: defineMessageSignature(
     SESSION_LIVE_HISTORY_LOAD_KIND,
     encodeSessionLiveHistoryLoad,
@@ -26691,7 +26788,7 @@ function createDaemonConfig(connection, agents = [], installableAgents = [], loc
 }
 
 // src/run-daemon.ts
-import { createHash as createHash5, randomUUID as randomUUID6 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID7 } from "node:crypto";
 import { join as join17 } from "node:path";
 import { styleText } from "node:util";
 
@@ -28256,13 +28353,15 @@ var AcpPreparedSession = class {
   capabilities;
   commands;
   configOptions;
+  prompted;
   restored;
-  constructor(agentName, agentVersion, capabilities, commands, configOptions, restored) {
+  constructor(agentName, agentVersion, capabilities, commands, configOptions, prompted, restored) {
     this.agentName = agentName;
     this.agentVersion = agentVersion;
     this.capabilities = capabilities;
     this.commands = commands;
     this.configOptions = configOptions;
+    this.prompted = prompted;
     this.restored = restored;
   }
 };
@@ -34432,6 +34531,10 @@ var acpSessionStoreMigrations = [
   {
     "name": "0000_slimy_captain_midlands.sql",
     "sql": "CREATE TABLE `acp_session` (\n	`session_id` text PRIMARY KEY NOT NULL,\n	`agent_id` text NOT NULL,\n	`native_session_id` text NOT NULL,\n	`cwd` text NOT NULL,\n	`additional_directories` text NOT NULL,\n	`prompted` integer NOT NULL,\n	`title` text NOT NULL,\n	`updated_at` text NOT NULL\n);\n--> statement-breakpoint\nCREATE TABLE `deleted_acp_session` (\n	`session_id` text PRIMARY KEY NOT NULL\n);\n"
+  },
+  {
+    "name": "0001_regular_ultimates.sql",
+    "sql": "ALTER TABLE `acp_session` ADD `last_terminal_command_id` text;"
   }
 ];
 
@@ -34449,6 +34552,7 @@ var acpSession = sqliteTable("acp_session", {
   nativeSessionId: text("native_session_id").notNull(),
   cwd: text("cwd").notNull(),
   additionalDirectories: text("additional_directories").notNull(),
+  lastTerminalCommandId: text("last_terminal_command_id"),
   prompted: integer2("prompted", { mode: "boolean" }).notNull(),
   title: text("title").notNull(),
   updatedAt: text("updated_at").notNull()
@@ -34464,15 +34568,17 @@ var AcpStoredSession = class {
   additionalDirectories;
   agentId;
   cwd;
+  lastTerminalCommandId;
   nativeSessionId;
   prompted;
   sessionId;
   title;
   updatedAt;
-  constructor(sessionId, agentId, nativeSessionId, cwd, additionalDirectories, prompted, title2, updatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  constructor(sessionId, agentId, nativeSessionId, cwd, additionalDirectories, prompted, title2, updatedAt = (/* @__PURE__ */ new Date()).toISOString(), lastTerminalCommandId = null) {
     this.additionalDirectories = [...additionalDirectories];
     this.agentId = agentId;
     this.cwd = cwd;
+    this.lastTerminalCommandId = lastTerminalCommandId;
     this.nativeSessionId = nativeSessionId;
     this.prompted = prompted;
     this.sessionId = sessionId;
@@ -34533,6 +34639,7 @@ var storedSessionRowSchema = external_exports.object({
   additionalDirectories: external_exports.string(),
   agentId: external_exports.string(),
   cwd: external_exports.string(),
+  lastTerminalCommandId: external_exports.string().nullable(),
   nativeSessionId: external_exports.string(),
   prompted: external_exports.boolean(),
   sessionId: external_exports.string(),
@@ -34552,7 +34659,8 @@ function decodeStoredSession(value) {
     additionalDirectories,
     row.prompted,
     row.title,
-    row.updatedAt
+    row.updatedAt,
+    row.lastTerminalCommandId
   );
 }
 var SqliteAcpSessionStore = class {
@@ -34619,6 +34727,7 @@ var SqliteAcpSessionStore = class {
       additionalDirectories: JSON.stringify(session.additionalDirectories),
       agentId: session.agentId,
       cwd: session.cwd,
+      lastTerminalCommandId: session.lastTerminalCommandId,
       nativeSessionId: session.nativeSessionId,
       prompted: session.prompted,
       sessionId: session.sessionId,
@@ -34671,6 +34780,7 @@ var AgentSession = class _AgentSession {
   #commands = [];
   #configRevision = 0;
   #configOptions = [];
+  #lastTerminalCommandId = null;
   #prompted = false;
   #nativePrompt = null;
   #sessionLoad = { kind: "not-requested" };
@@ -34774,6 +34884,7 @@ var AgentSession = class _AgentSession {
     this.#capabilities,
     this.#commands,
     this.#configOptions,
+    this.#prompted,
     this.#restored
   );
   loadHistory = async (signal) => {
@@ -35007,6 +35118,7 @@ var AgentSession = class _AgentSession {
     } else if (stored instanceof FoundAcpStoredSession && stored.session.agentId === this.#agentId && stored.session.cwd === this.#cwd && arraysEqual(stored.session.additionalDirectories, this.#additionalDirectories)) {
       this.selectNativeSession(stored.session.nativeSessionId);
       this.#prompted = stored.session.prompted;
+      this.#lastTerminalCommandId = stored.session.lastTerminalCommandId;
       this.#sessionTitle = stored.session.title;
       this.#restored = true;
       if (this.#capabilities.resumeSession) {
@@ -35080,7 +35192,9 @@ var AgentSession = class _AgentSession {
         this.#cwd,
         this.#additionalDirectories,
         this.#prompted,
-        this.#sessionTitle ?? ""
+        this.#sessionTitle ?? "",
+        (/* @__PURE__ */ new Date()).toISOString(),
+        this.#lastTerminalCommandId
       )
     );
   };
@@ -35280,7 +35394,9 @@ var AgentSession = class _AgentSession {
         this.#cwd,
         this.#additionalDirectories,
         true,
-        this.#sessionTitle
+        this.#sessionTitle,
+        (/* @__PURE__ */ new Date()).toISOString(),
+        this.#lastTerminalCommandId
       )
     );
     this.#prompted = true;
@@ -35332,6 +35448,20 @@ var AgentSession = class _AgentSession {
           usage: result.usage ?? null
         });
       }
+      this.#lastTerminalCommandId = options.commandId;
+      this.#store.write(
+        new AcpStoredSession(
+          this.#mobiusSessionId,
+          this.#agentId,
+          this.#updates.sessionId(),
+          this.#cwd,
+          this.#additionalDirectories,
+          true,
+          this.#sessionTitle ?? "",
+          (/* @__PURE__ */ new Date()).toISOString(),
+          this.#lastTerminalCommandId
+        )
+      );
       return result;
     } catch (error62) {
       await running.activities.finish();
@@ -35524,7 +35654,9 @@ var AgentSession = class _AgentSession {
             this.#cwd,
             this.#additionalDirectories,
             this.#prompted,
-            this.#sessionTitle ?? ""
+            this.#sessionTitle ?? "",
+            (/* @__PURE__ */ new Date()).toISOString(),
+            this.#lastTerminalCommandId
           )
         );
       }
@@ -36570,9 +36702,17 @@ var AgentRuntimeManager = class {
         const openedKey = `${options2.agent.id}:${runtime.nativeSessionId()}`;
         this.#nativeOperations.add(openedKey);
         try {
+          const prepared = runtime.prepared();
+          if (origin.kind === "fork" && options2.agent.id === "claude") {
+            await this.#retireSessionProcess(
+              options2.sessionId,
+              runtime,
+              async () => await runtime.closeProcess()
+            );
+          }
           return {
             sessionId: options2.sessionId,
-            prepared: runtime.prepared()
+            prepared
           };
         } finally {
           this.#nativeOperations.delete(openedKey);
@@ -38983,6 +39123,7 @@ var readCodexFullHistory = async (agent, cwd, nativeSessionId, signal, nativeTur
 
 // src/native-sessions/service.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
+import { basename as basename4 } from "node:path";
 
 // src/native-sessions/acp-history.ts
 async function readAcpHistory(sessions, directories, bindingId, options, nativeSessionId) {
@@ -39123,6 +39264,64 @@ var NativeSessionService = class {
         sessionId: command.sessionId
       };
     }
+    if (command.action === "fork-recorded") {
+      const source = this.#sessions.findSessions([command.sessionId])[0];
+      if (source === void 0 || !source.prompted) {
+        throw new AcpExecutionError(
+          "The source conversation has no resumable native Agent session",
+          {},
+          "native_session_not_found"
+        );
+      }
+      if (source.agentId !== command.agentId || source.cwd !== cwd || source.additionalDirectories.length !== additionalDirectories.length || source.additionalDirectories.some((path2, index) => path2 !== additionalDirectories[index])) {
+        throw new AcpExecutionError(
+          "The source conversation execution target does not match the fork request",
+          {},
+          "native_session_target_changed"
+        );
+      }
+      if (source.lastTerminalCommandId !== command.throughCommandId) {
+        throw new AcpExecutionError(
+          "The selected Turn is no longer the source conversation head",
+          {},
+          "fork_point_stale"
+        );
+      }
+      const opened2 = await this.#sessions.openNativeSession(
+        { ...options, sessionId: command.targetSessionId },
+        { kind: "fork", nativeSessionId: source.nativeSessionId }
+      );
+      signal.throwIfAborted();
+      const directory = await this.#directories.list(this.#config.bindingId, command.directoryId, signal);
+      const ready2 = {
+        additionalDirectories: additionalDirectories.map((path2, index) => ({
+          directoryId: command.additionalDirectoryIds[index] ?? command.directoryId,
+          name: basename4(path2) || path2
+        })),
+        agentId: command.agentId,
+        agentName: opened2.prepared.agentName,
+        agentVersion: opened2.prepared.agentVersion,
+        capabilities: opened2.prepared.capabilities,
+        commands: opened2.prepared.commands,
+        configOptions: opened2.prepared.configOptions,
+        directoryId: command.directoryId,
+        directoryLabel: directory.directoryLabel,
+        kind: "session.ready",
+        requestId: command.requestId,
+        restored: true,
+        sessionId: opened2.sessionId
+      };
+      this.record(command, "native_recorded_session_forked");
+      return {
+        action: "fork-recorded",
+        kind: "native.session.result",
+        ready: ready2,
+        requestId: command.requestId,
+        sessionId: command.sessionId,
+        targetSessionId: command.targetSessionId,
+        title: source.title || "Untitled session"
+      };
+    }
     const prepared = await this.#sessions.prepareNativeSessionBrowser(options);
     if (!prepared.capabilities.listSessions) {
       throw new AcpExecutionError(
@@ -40444,7 +40643,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
 // src/artifacts/local-file-streamer.ts
 import { createReadStream as createReadStream2 } from "node:fs";
 import { realpath as realpath8, stat as stat7 } from "node:fs/promises";
-import { basename as basename4, isAbsolute as isAbsolute10, normalize as normalize4, resolve as resolve5 } from "node:path";
+import { basename as basename5, isAbsolute as isAbsolute10, normalize as normalize4, resolve as resolve5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var CHUNK_BYTES = 192 * 1024;
 function requestedPath(value) {
@@ -40495,7 +40694,7 @@ async function streamLocalFile(command, send2, signal, workingDirectory) {
     kind: FILE_BEGIN_KIND,
     mediaType: raster?.mimeType ?? "application/octet-stream",
     modifiedAt: before.mtime.toISOString(),
-    name: basename4(target) || "file",
+    name: basename5(target) || "file",
     requestId: command.requestId,
     sessionId: command.sessionId
   });
@@ -40525,7 +40724,7 @@ async function streamLocalFile(command, send2, signal, workingDirectory) {
 }
 
 // src/authorization/resolve-session-directories.ts
-import { basename as basename5 } from "node:path";
+import { basename as basename6 } from "node:path";
 var ResolvedSessionDirectories = class {
   additionalDirectories;
   additionalDirectoryEntries;
@@ -40550,7 +40749,7 @@ async function resolveSessionDirectories(directories, bindingId, directoryId2, a
     additionalDirectories.push(directory);
     additionalDirectoryEntries.push({
       directoryId: additionalDirectoryId,
-      name: basename5(directory)
+      name: basename6(directory)
     });
   }
   return new ResolvedSessionDirectories(cwd, additionalDirectories, additionalDirectoryEntries);
@@ -41287,14 +41486,15 @@ async function executePrompt({
     const appliedSettings = command.sessionConfigurations === void 0 ? void 0 : agentForSessionConfiguration(agent, command.sessionConfigurations);
     const executionAgent = appliedSettings?.agent ?? agent;
     const sessionConfigurations = appliedSettings?.sessionConfigurations;
+    const preparation = {
+      additionalDirectories: resolved.additionalDirectories,
+      agent: executionAgent,
+      cwd: resolved.cwd,
+      sessionId: command.sessionId,
+      signal
+    };
+    let prepared = await sessions.prepareExecutionSession(preparation);
     if (command.sessionConfigurations !== void 0) {
-      const prepared = await sessions.prepareExecutionSession({
-        additionalDirectories: resolved.additionalDirectories,
-        agent: executionAgent,
-        cwd: resolved.cwd,
-        sessionId: command.sessionId,
-        signal
-      });
       if (availability.disposition === SessionPromptDisposition.Steer) {
         assertAppliedSessionConfiguration(prepared.configOptions, sessionConfigurations ?? []);
       } else {
@@ -41310,6 +41510,7 @@ async function executePrompt({
           command.sessionId,
           signal
         );
+        prepared = await sessions.prepareExecutionSession(preparation);
       }
     }
     audit.record({
@@ -41328,6 +41529,24 @@ async function executePrompt({
       }
     }
     const stream = activateAttempt();
+    if (!prepared.prompted) {
+      const listing = await directories.list(config2.bindingId, command.directoryId, signal);
+      publisher.publish(command.sessionId, {
+        additionalDirectories: resolved.additionalDirectoryEntries,
+        agentId: command.agentId,
+        agentName: prepared.agentName,
+        agentVersion: prepared.agentVersion,
+        capabilities: prepared.capabilities,
+        commands: prepared.commands,
+        configOptions: prepared.configOptions,
+        directoryId: command.directoryId,
+        directoryLabel: listing.directoryLabel,
+        kind: SESSION_READY_KIND,
+        requestId: command.commandId,
+        restored: prepared.restored,
+        sessionId: command.sessionId
+      });
+    }
     publisher.publish(command.sessionId, {
       commandId: command.commandId,
       epoch: stream.epoch,
@@ -41581,7 +41800,7 @@ async function executeSessionConfigure(publisher, socket, command, config2, dire
 // src/native-sessions/handle-native-requests.ts
 import { WebSocket as WebSocket5 } from "undici";
 function createNativeSessionRequestHandler(dependencies) {
-  const { audit, diagnostics, nativeSessions, signal, socket, timer } = dependencies;
+  const { audit, diagnostics, nativeSessions, publisher, signal, socket, timer } = dependencies;
   const pending = /* @__PURE__ */ new Map();
   const cancel = (command) => {
     const request = pending.get(command.requestId);
@@ -41633,6 +41852,17 @@ function createNativeSessionRequestHandler(dependencies) {
         }
         operationSignal.throwIfAborted();
         const result = await nativeSessions.execute(command, operationSignal);
+        if (command.action === "fork-recorded" && result.action === "fork-recorded") {
+          publisher.publishBatch(result.ready.sessionId, [
+            result.ready,
+            {
+              kind: "session.forked",
+              sessionId: result.ready.sessionId,
+              sourceSessionId: command.sessionId,
+              throughCommandId: command.throughCommandId
+            }
+          ]);
+        }
         if (socket.readyState === WebSocket5.OPEN) {
           send(socket, result);
         }
@@ -41718,6 +41948,7 @@ function createDaemonCommandHandler({
     audit,
     diagnostics,
     nativeSessions,
+    publisher,
     signal,
     socket,
     timer
@@ -42240,6 +42471,7 @@ async function runRelayConnection({
 }) {
   const relayUrl = new URL(config2.relayUrl);
   relayUrl.searchParams.set("liveness", "1");
+  relayUrl.searchParams.set("sessionEventDelivery", "reliable-v1");
   const socket = await connectRelay(relayUrl, signal);
   diagnostics.connectionOpened(connectionEpoch);
   const connectionController = new AbortController();
@@ -42359,6 +42591,10 @@ async function runRelayConnection({
           const message = decodeServiceToDaemonMessage(encoded);
           const kind = message.kind;
           if (kind === RUNTIME_LIVENESS_READY_KIND) {
+            publisher.connect(
+              socket,
+              message.sessionEventDelivery === "reliable-v1" ? "reliable" : "ephemeral"
+            );
             connectionLiveness.start();
             return;
           }
@@ -42366,6 +42602,18 @@ async function runRelayConnection({
             connectionLiveness.acknowledge(message);
             return;
           }
+          if (kind === SESSION_EVENT_ACK_KIND) {
+            publisher.acknowledge(message);
+            return;
+          }
+          if (kind === SESSION_EVENT_DEFERRED_KIND) {
+            publisher.defer(message);
+            return;
+          }
+          if (kind === SESSION_EVENT_REJECTED_KIND) {
+            publisher.quarantine(message);
+            return;
+          }
           commands.handle(message);
         } catch (error62) {
           console.error("Mobius daemon rejected a message", error62);
@@ -42380,7 +42628,6 @@ async function runRelayConnection({
       socket.addEventListener("close", handleClose);
       socket.addEventListener("error", handleError);
       socket.addEventListener("message", handleMessage);
-      publisher.connect(socket);
       if (signal.aborted) {
         stop();
       }
@@ -42391,54 +42638,405 @@ async function runRelayConnection({
   }
 }
 
+// src/relay-connection/session-event-outbox.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
+import { mkdirSync as mkdirSync3 } from "node:fs";
+import { dirname as dirname5 } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+var DEFAULT_STANDARD_EVENT_BYTES = 96 * 1024 * 1024;
+var DEFAULT_CRITICAL_EVENT_BYTES = 128 * 1024 * 1024;
+var MAX_DEAD_LETTERS = 1024;
+var DEFAULT_LIMITS = {
+  criticalEventBytes: DEFAULT_CRITICAL_EVENT_BYTES,
+  standardEventBytes: DEFAULT_STANDARD_EVENT_BYTES
+};
+var SessionEventOutboxCapacityError = class extends Error {
+  code = "session_event_outbox_full";
+  constructor() {
+    super("The persistent Session event outbox is full");
+    this.name = "SessionEventOutboxCapacityError";
+  }
+};
+function rowNumber(row, field) {
+  const value = typeof row === "object" && row !== null ? Reflect.get(row, field) : void 0;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`SQLite returned an invalid ${field} value`);
+  }
+  return value;
+}
+function rowString(row, field) {
+  const value = typeof row === "object" && row !== null ? Reflect.get(row, field) : void 0;
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`SQLite returned an invalid ${field} value`);
+  }
+  return value;
+}
+function validateLimits(limits) {
+  if (!Number.isSafeInteger(limits.standardEventBytes) || limits.standardEventBytes < 1 || !Number.isSafeInteger(limits.criticalEventBytes) || limits.criticalEventBytes < limits.standardEventBytes) {
+    throw new Error("Session event outbox limits are invalid");
+  }
+}
+var SessionEventOutbox = class {
+  #database;
+  #limits;
+  constructor(path2, limits = DEFAULT_LIMITS) {
+    validateLimits(limits);
+    mkdirSync3(dirname5(path2), { mode: 448, recursive: true });
+    this.#limits = limits;
+    this.#database = new DatabaseSync(path2);
+    this.#database.exec("PRAGMA journal_mode = WAL; PRAGMA synchronous = FULL; PRAGMA busy_timeout = 5000;");
+    this.#database.exec(`
+            CREATE TABLE IF NOT EXISTS relay_session_event_outbox (
+                ordinal INTEGER PRIMARY KEY AUTOINCREMENT,
+                event_id TEXT NOT NULL UNIQUE,
+                session_id TEXT NOT NULL,
+                source_seq INTEGER NOT NULL UNIQUE,
+                byte_length INTEGER NOT NULL,
+                envelope_json TEXT NOT NULL
+            ) STRICT;
+            CREATE INDEX IF NOT EXISTS relay_session_event_outbox_order
+                ON relay_session_event_outbox(source_seq);
+            CREATE TABLE IF NOT EXISTS relay_session_event_outbox_state (
+                singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+                stream_id TEXT NOT NULL,
+                next_source_seq INTEGER NOT NULL,
+                total_bytes INTEGER NOT NULL
+            ) STRICT;
+            CREATE TABLE IF NOT EXISTS relay_session_event_dead_letters (
+                ordinal INTEGER PRIMARY KEY AUTOINCREMENT,
+                event_id TEXT NOT NULL UNIQUE,
+                session_id TEXT NOT NULL,
+                rejection_code TEXT NOT NULL,
+                envelope_json TEXT NOT NULL
+            ) STRICT;
+        `);
+    this.#database.prepare(
+      `INSERT OR IGNORE INTO relay_session_event_outbox_state (
+                    singleton, stream_id, next_source_seq, total_bytes
+                ) VALUES (1, ?, 1, 0)`
+    ).run(randomUUID6());
+  }
+  acknowledge = (acknowledgement) => this.#remove(acknowledgement.eventId, acknowledgement.sessionId);
+  close = () => {
+    this.#database.close();
+  };
+  enqueue = (sessionId, payload, critical) => {
+    const envelope2 = this.enqueueBatch(sessionId, [payload], critical)[0];
+    if (envelope2 === void 0) {
+      throw new Error("The Session event outbox did not enqueue the event");
+    }
+    return envelope2;
+  };
+  enqueueBatch = (sessionId, payloads, critical) => {
+    if (payloads.length < 1 || payloads.length > 32) {
+      throw new Error("A Session event batch must contain between 1 and 32 events");
+    }
+    this.#database.exec("BEGIN IMMEDIATE");
+    try {
+      const state = this.#database.prepare(
+        `SELECT stream_id, next_source_seq, total_bytes
+                     FROM relay_session_event_outbox_state
+                     WHERE singleton = 1`
+      ).get();
+      const sourceSeq = rowNumber(state, "next_source_seq");
+      if (sourceSeq < 1 || !Number.isSafeInteger(sourceSeq + payloads.length)) {
+        throw new Error("The Session event source sequence is exhausted");
+      }
+      const streamId = rowString(state, "stream_id");
+      const stored = payloads.map((payload, index) => {
+        const envelope2 = {
+          delivery: {
+            eventId: randomUUID6(),
+            kind: "reliable",
+            sourceSeq: (sourceSeq + index).toString(),
+            streamId
+          },
+          kind: SESSION_EVENT_KIND,
+          payload,
+          sessionId
+        };
+        const encoded = encodeSessionEventEnvelope(envelope2);
+        return { byteLength: Buffer.byteLength(encoded, "utf8"), encoded, envelope: envelope2 };
+      });
+      const byteLength = stored.reduce((total, entry) => total + entry.byteLength, 0);
+      const maximumBytes = critical ? this.#limits.criticalEventBytes : this.#limits.standardEventBytes;
+      if (rowNumber(state, "total_bytes") + byteLength > maximumBytes) {
+        throw new SessionEventOutboxCapacityError();
+      }
+      const insert = this.#database.prepare(
+        `INSERT INTO relay_session_event_outbox (
+                    event_id, session_id, source_seq, byte_length, envelope_json
+                ) VALUES (?, ?, ?, ?, ?)`
+      );
+      for (const entry of stored) {
+        insert.run(
+          entry.envelope.delivery.eventId,
+          sessionId,
+          Number(entry.envelope.delivery.sourceSeq),
+          entry.byteLength,
+          entry.encoded
+        );
+      }
+      this.#database.prepare(
+        `UPDATE relay_session_event_outbox_state
+                     SET next_source_seq = next_source_seq + ?,
+                         total_bytes = total_bytes + ?
+                     WHERE singleton = 1`
+      ).run(stored.length, byteLength);
+      this.#database.exec("COMMIT");
+      return stored.map((entry) => entry.envelope);
+    } catch (error62) {
+      this.#database.exec("ROLLBACK");
+      throw error62;
+    }
+  };
+  pending = (limit, excludedEventIds) => {
+    if (!Number.isSafeInteger(limit) || limit < 1) {
+      throw new Error("Session event replay limit must be a positive integer");
+    }
+    const exclusion = excludedEventIds.length === 0 ? "" : `WHERE event_id NOT IN (${excludedEventIds.map(() => "?").join(", ")})`;
+    return this.#database.prepare(
+      `SELECT envelope_json
+                 FROM relay_session_event_outbox
+                 ${exclusion}
+                 ORDER BY source_seq
+                 LIMIT ?`
+    ).all(...excludedEventIds, limit).map((row) => {
+      const envelope2 = decodeSessionEventEnvelope(rowString(row, "envelope_json"));
+      if (!("delivery" in envelope2)) {
+        throw new Error("SQLite returned an invalid reliable Session event envelope");
+      }
+      return envelope2;
+    });
+  };
+  quarantine = (rejection) => {
+    this.#database.exec("BEGIN IMMEDIATE");
+    try {
+      const stored = this.#database.prepare(
+        `SELECT byte_length, envelope_json
+                     FROM relay_session_event_outbox
+                     WHERE event_id = ? AND session_id = ?`
+      ).get(rejection.eventId, rejection.sessionId);
+      if (stored === void 0) {
+        this.#database.exec("COMMIT");
+        return false;
+      }
+      this.#database.prepare(
+        `INSERT INTO relay_session_event_dead_letters (
+                        event_id, session_id, rejection_code, envelope_json
+                    ) VALUES (?, ?, ?, ?)`
+      ).run(rejection.eventId, rejection.sessionId, rejection.code, rowString(stored, "envelope_json"));
+      this.#deleteStored(rejection.eventId, rejection.sessionId, rowNumber(stored, "byte_length"));
+      this.#database.prepare(
+        `DELETE FROM relay_session_event_dead_letters
+                     WHERE ordinal NOT IN (
+                         SELECT ordinal FROM relay_session_event_dead_letters
+                         ORDER BY ordinal DESC LIMIT ?
+                     )`
+      ).run(MAX_DEAD_LETTERS);
+      this.#database.exec("COMMIT");
+      return true;
+    } catch (error62) {
+      this.#database.exec("ROLLBACK");
+      throw error62;
+    }
+  };
+  #deleteStored = (eventId, sessionId, byteLength) => {
+    const deletion = this.#database.prepare(
+      `DELETE FROM relay_session_event_outbox
+                 WHERE event_id = ? AND session_id = ?`
+    ).run(eventId, sessionId);
+    if (deletion.changes !== 1) {
+      throw new Error("The Session event could not be removed from the outbox");
+    }
+    const state = this.#database.prepare(
+      `UPDATE relay_session_event_outbox_state
+                 SET total_bytes = total_bytes - ?
+                 WHERE singleton = 1 AND total_bytes >= ?`
+    ).run(byteLength, byteLength);
+    if (state.changes !== 1) {
+      throw new Error("The Session event outbox capacity state is inconsistent");
+    }
+  };
+  #remove = (eventId, sessionId) => {
+    this.#database.exec("BEGIN IMMEDIATE");
+    try {
+      const stored = this.#database.prepare(
+        `SELECT byte_length
+                     FROM relay_session_event_outbox
+                     WHERE event_id = ? AND session_id = ?`
+      ).get(eventId, sessionId);
+      if (stored === void 0) {
+        this.#database.exec("COMMIT");
+        return false;
+      }
+      this.#deleteStored(eventId, sessionId, rowNumber(stored, "byte_length"));
+      this.#database.exec("COMMIT");
+      return true;
+    } catch (error62) {
+      this.#database.exec("ROLLBACK");
+      throw error62;
+    }
+  };
+};
+
 // src/relay-connection/session-event-publisher.ts
 import { WebSocket as WebSocket9 } from "undici";
-var MAX_LIVE_EVENT_BUFFERED_BYTES = 16 * 1024 * 1024;
+var SESSION_EVENT_REPLAY_WINDOW = 16;
+var SESSION_EVENT_REPLAY_BYTE_LIMIT = 32 * 1024 * 1024;
+function reservesSessionEventCapacity(event) {
+  if (event.kind === SESSION_COMPLETED_KIND || event.kind === SESSION_FAILED_KIND || event.kind === SESSION_FORKED_KIND || event.kind === SESSION_READY_KIND) {
+    return true;
+  }
+  return event.kind === AGENT_ACTIVITY_KIND && (event.activityType === "progress" || event.activityType === "reasoning") && (event.status === "completed" || event.status === "failed");
+}
 var DaemonSessionEventPublisher = class {
-  #socket = null;
-  #reportedDrop = false;
-  connect = (socket) => {
-    this.#socket = socket;
-    this.#reportedDrop = false;
+  #inFlight = /* @__PURE__ */ new Map();
+  #outbox;
+  #reportedCapacityKinds = /* @__PURE__ */ new Set();
+  #timer;
+  #connection = { kind: "disconnected" };
+  #deferredReplay = null;
+  #inFlightBytes = 0;
+  constructor(outbox, timer) {
+    this.#outbox = outbox;
+    this.#timer = timer;
+  }
+  acknowledge = (acknowledgement) => {
+    if (!this.#outbox.acknowledge(acknowledgement)) {
+      return;
+    }
+    this.#removeInFlight(acknowledgement.eventId);
+    this.#publishNextBatch();
+  };
+  close = () => {
+    this.#deferredReplay?.cancel();
+    this.#deferredReplay = null;
+    this.#connection = { kind: "disconnected" };
+    this.#clearInFlight();
+    this.#outbox.close();
+  };
+  connect = (socket, delivery) => {
+    this.#connection = { delivery, kind: "connected", socket };
+    this.#clearInFlight();
+    this.#publishNextBatch();
+  };
+  defer = (deferred) => {
+    if (!this.#inFlight.has(deferred.eventId)) {
+      return;
+    }
+    this.#clearInFlight();
+    if (this.#deferredReplay !== null) {
+      return;
+    }
+    this.#deferredReplay = this.#timer.schedule(() => {
+      this.#deferredReplay = null;
+      this.#publishNextBatch();
+    }, deferred.retryAfterMilliseconds);
   };
   disconnect = (socket) => {
-    if (this.#socket === socket) {
-      this.#socket = null;
+    if (this.#connection.kind !== "connected" || this.#connection.socket !== socket) {
+      return;
     }
+    this.#connection = { kind: "disconnected" };
+    this.#clearInFlight();
   };
   publish = (sessionId, event) => {
-    const socket = this.#socket;
-    if (socket === null || socket.readyState !== WebSocket9.OPEN) {
-      this.#reportDrop();
+    try {
+      this.#outbox.enqueue(sessionId, encodeRecordedSessionEvent(event), reservesSessionEventCapacity(event));
+    } catch (error62) {
+      if (!(error62 instanceof SessionEventOutboxCapacityError)) {
+        throw error62;
+      }
+      if (!this.#reportedCapacityKinds.has(event.kind)) {
+        this.#reportedCapacityKinds.add(event.kind);
+        console.warn(
+          `Mobius daemon could not persist "${event.kind}" because the Session event outbox is full`
+        );
+      }
       return;
     }
-    if (socket.bufferedAmount >= MAX_LIVE_EVENT_BUFFERED_BYTES) {
-      this.#socket = null;
-      socket.close(1013, "Live event backpressure");
-      this.#reportDrop();
+    this.#publishNextBatch();
+  };
+  publishBatch = (sessionId, events) => {
+    const critical = events.some(reservesSessionEventCapacity);
+    this.#outbox.enqueueBatch(sessionId, events.map(encodeRecordedSessionEvent), critical);
+    this.#publishNextBatch();
+  };
+  quarantine = (rejection) => {
+    if (!this.#outbox.quarantine(rejection)) {
       return;
     }
-    try {
-      socket.send(
-        encodeDaemonToServiceMessage({
-          kind: SESSION_EVENT_KIND,
-          payload: encodeRecordedSessionEvent(event),
-          sessionId
-        })
-      );
-    } catch {
-      this.#reportDrop();
-    }
+    this.#removeInFlight(rejection.eventId);
+    console.error(`Mobius Relay rejected Session event ${rejection.eventId} with code ${rejection.code}`);
+    this.#publishNextBatch();
   };
-  close = () => {
-    this.#socket = null;
+  #clearInFlight = () => {
+    this.#inFlight.clear();
+    this.#inFlightBytes = 0;
+  };
+  #publishNextBatch = () => {
+    if (this.#deferredReplay !== null || this.#connection.kind !== "connected") {
+      return;
+    }
+    while (this.#inFlight.size < SESSION_EVENT_REPLAY_WINDOW) {
+      const batch = this.#outbox.pending(SESSION_EVENT_REPLAY_WINDOW - this.#inFlight.size, [
+        ...this.#inFlight.keys()
+      ]);
+      let sent = 0;
+      for (const envelope2 of batch) {
+        const encoded = encodeDaemonToServiceMessage(
+          this.#connection.delivery === "reliable" ? envelope2 : {
+            kind: envelope2.kind,
+            payload: envelope2.payload,
+            sessionId: envelope2.sessionId
+          }
+        );
+        const byteLength = Buffer.byteLength(encoded, "utf8");
+        if (this.#inFlightBytes + byteLength > SESSION_EVENT_REPLAY_BYTE_LIMIT) {
+          return;
+        }
+        if (!this.#send(encoded)) {
+          this.#clearInFlight();
+          return;
+        }
+        if (this.#connection.delivery === "ephemeral") {
+          this.#outbox.acknowledge({
+            eventId: envelope2.delivery.eventId,
+            kind: "session.event.ack",
+            outcome: { kind: "relayed" },
+            sessionId: envelope2.sessionId
+          });
+          sent += 1;
+          continue;
+        }
+        this.#inFlight.set(envelope2.delivery.eventId, { byteLength });
+        this.#inFlightBytes += byteLength;
+        sent += 1;
+      }
+      if (sent === 0) {
+        return;
+      }
+    }
   };
-  #reportDrop = () => {
-    if (this.#reportedDrop) {
+  #removeInFlight = (eventId) => {
+    const inFlight = this.#inFlight.get(eventId);
+    if (inFlight === void 0) {
       return;
     }
-    this.#reportedDrop = true;
-    console.warn("Mobius daemon dropped live Session events while the Relay was unavailable");
+    this.#inFlight.delete(eventId);
+    this.#inFlightBytes -= inFlight.byteLength;
+  };
+  #send = (encoded) => {
+    if (this.#connection.kind !== "connected" || this.#connection.socket.readyState !== WebSocket9.OPEN) {
+      return false;
+    }
+    try {
+      this.#connection.socket.send(encoded);
+      return true;
+    } catch {
+      return false;
+    }
   };
 };
 
@@ -42499,7 +43097,7 @@ async function installDetectedAgentIntegrations(config2, installations, signal)
       {
         agentId: agent.id,
         kind: AGENT_INSTALL_REQUEST_KIND,
-        requestId: `automatic-integration-${randomUUID6()}`
+        requestId: `automatic-integration-${randomUUID7()}`
       },
       signal
     );
@@ -42521,7 +43119,11 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
     join17(stateDirectory, "sessions", `${createHash5("sha256").update(config2.channelId).digest("hex")}.sqlite`)
   );
   const operations = new DaemonOperationState();
-  const publisher = new DaemonSessionEventPublisher();
+  const channelHash = createHash5("sha256").update(config2.channelId).digest("hex");
+  const publisher = new DaemonSessionEventPublisher(
+    new SessionEventOutbox(join17(stateDirectory, "events", `${channelHash}.sqlite`)),
+    timer
+  );
   const activeTurns = new DaemonTurnRegistry(operations);
   const recordSessionEvent = (sessionId, event) => {
     publisher.publish(sessionId, activeTurns.recordEvent(event));
@@ -42709,13 +43311,13 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
 // src/pairing/pair-local-machine.ts
 import { mkdir as mkdir5, realpath as realpath9, stat as stat8 } from "node:fs/promises";
 import { hostname as hostname3 } from "node:os";
-import { basename as basename6, resolve as resolve7 } from "node:path";
+import { basename as basename7, resolve as resolve7 } from "node:path";
 import { fetch as fetch4 } from "undici";
 
 // src/storage/runtime-installation-store.ts
-import { createHash as createHash6, randomUUID as randomUUID7 } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID8 } from "node:crypto";
 import { mkdir as mkdir4, open as open5, readdir as readdir3, rename as rename3, unlink, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname5, join as join18, resolve as resolve6 } from "node:path";
+import { dirname as dirname6, join as join18, resolve as resolve6 } from "node:path";
 var APPLICATION_ID_PATTERN = /^[a-z][a-z0-9]*(?:[.-][a-z0-9]+){1,31}$/;
 var CONNECTION_ID_PATTERN = /^mcn_[a-f0-9]{32}$/;
 var INSTALLATION_ID_PATTERN = /^min_[a-f0-9]{32}$/;
@@ -42843,10 +43445,10 @@ function parseRelayOrigin(value) {
   return origin;
 }
 function connectionId() {
-  return `mcn_${randomUUID7().replaceAll("-", "")}`;
+  return `mcn_${randomUUID8().replaceAll("-", "")}`;
 }
 function installationId() {
-  return `min_${randomUUID7().replaceAll("-", "")}`;
+  return `min_${randomUUID8().replaceAll("-", "")}`;
 }
 function channelIndexFileName(channelId) {
   return `mci_${createHash6("sha256").update(channelId).digest("hex")}.json`;
@@ -42957,8 +43559,8 @@ async function readJsonFile(path2, signal, missingCode) {
 }
 async function writeJsonAtomically(path2, value, signal) {
   signal.throwIfAborted();
-  const directory = dirname5(path2);
-  const temporaryPath = join18(directory, `.${randomUUID7()}.tmp`);
+  const directory = dirname6(path2);
+  const temporaryPath = join18(directory, `.${randomUUID8()}.tmp`);
   try {
     await mkdir4(directory, { mode: 448, recursive: true });
     signal.throwIfAborted();
@@ -43351,7 +43953,7 @@ async function claimPairing(options, defaultWorkspace, localAgents, installableA
         installableAgents,
         machineName: hostname3(),
         pairingCode: options.code,
-        workspaceName: basename6(defaultWorkspace) || "Local workspace"
+        workspaceName: basename7(defaultWorkspace) || "Local workspace"
       }),
       dispatcher: environmentProxyDispatcher,
       headers: { "content-type": "application/json" },