@moxt-ai/mobius 0.0.147 → 0.0.150

package/dist/index.js

@@ -20766,9 +20766,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);
@@ -21060,18 +21068,21 @@ var activeTurnMessageSchema = external_exports.discriminatedUnion("role", [
   activeTurnAssistantMessageSchema
 ]);
 var activeTurnSnapshotSchema = external_exports.strictObject({
-  activities: external_exports.array(activeTurnActivitySchema).readonly(),
   commandId: identifierStringSchema,
-  content: external_exports.array(displayContentSchema).readonly(),
-  prompt: external_exports.string().max(1e5),
-  text: external_exports.string(),
-  truncated: external_exports.boolean(),
   epoch: identifierStringSchema,
+  hasOlder: external_exports.boolean(),
   interaction: external_exports.discriminatedUnion("kind", [sessionPermissionRequestedEventSchema, sessionElicitationRequestedEventSchema]).nullable(),
   messages: external_exports.array(activeTurnMessageSchema).max(SESSION_HISTORY_MESSAGE_LIMIT).readonly(),
   sequence: external_exports.number().int().nonnegative(),
-  state: external_exports.literal("running")
-}).readonly();
+  state: external_exports.literal("running"),
+  truncated: external_exports.boolean()
+}).readonly().refine(
+  (snapshot) => snapshot.messages.reduce(
+    (total, message) => total + message.text.length + (message.role === "assistant" ? JSON.stringify(message.activities).length + JSON.stringify(message.content).length : 0),
+    0
+  ) <= SESSION_HISTORY_CHARACTER_LIMIT,
+  "Active Turn snapshot content is too large"
+);
 var identity = {
   ...envelope,
   kind: external_exports.literal(NATIVE_SESSION_REQUEST_KIND),
@@ -21215,27 +21226,61 @@ var encodeNativeSessionCancel = (value) => JSON.stringify(nativeSessionCancelSch
 
 // ../protocol/src/session-events.ts
 var SESSION_EVENT_KIND = "session.event";
-var SESSION_EVENT_COMMITTED_KIND = "session.event.committed";
+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 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 committedEventSchema = external_exports.strictObject({
-  kind: external_exports.literal(SESSION_EVENT_COMMITTED_KIND),
+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 reliableEventEnvelopeSchema = 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, reliableEventEnvelopeSchema]).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 SESSION_TURN_UPDATED_KIND = "session.turn.updated";
-var sessionTurnUpdatedSchema = external_exports.strictObject({
-  kind: external_exports.literal(SESSION_TURN_UPDATED_KIND),
-  sessionId: identifierStringSchema,
-  turn: activeTurnSnapshotSchema
-}).readonly();
-var decodeSessionTurnUpdatedEvent = (encoded) => decode5(encoded, sessionTurnUpdatedSchema);
 function decode5(encoded, schema) {
   let value;
   try {
@@ -21262,11 +21307,15 @@ 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_TURN_UPDATED_KIND:
-      return decodeSessionTurnUpdatedEvent(encoded);
     case SESSION_QUEUE_CHANGED_KIND:
       return decode5(encoded, sessionQueueChangedSchema);
     case AGENT_ACTIVITY_KIND:
@@ -21435,6 +21484,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,
@@ -37527,7 +37591,7 @@ function isRuntimeRelayRevocation(closeCode, closeReason) {
 }
 
 // src/run-daemon.ts
-import { createHash as createHash6, randomUUID as randomUUID7 } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID8 } from "node:crypto";
 import { join as join18 } from "node:path";
 import { styleText } from "node:util";
 
@@ -38731,6 +38795,28 @@ var DaemonInstallationObserver = class {
 
 // src/daemon-active-turn.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
+function activeMessageCharacters(message) {
+  return message.text.length + (message.role === "assistant" ? JSON.stringify(message.activities).length + JSON.stringify(message.content).length : 0);
+}
+var ACTIVE_TURN_TEXT_CHUNK_LIMIT = Math.floor(SESSION_HISTORY_CHARACTER_LIMIT / 2);
+function boundedRecoveryMessages(messages) {
+  const selected = [];
+  let remainingCharacters = SESSION_HISTORY_CHARACTER_LIMIT;
+  for (let index = messages.length - 1; index >= 0 && selected.length < SESSION_HISTORY_MESSAGE_LIMIT; index -= 1) {
+    const message = messages[index];
+    if (message === void 0) {
+      break;
+    }
+    const characters = activeMessageCharacters(message);
+    if (characters <= remainingCharacters) {
+      selected.unshift(message);
+      remainingCharacters -= characters;
+      continue;
+    }
+    break;
+  }
+  return { hasOlder: selected.length !== messages.length, messages: selected };
+}
 var ActiveDaemonTurn = class {
   attemptId;
   command;
@@ -38738,9 +38824,7 @@ var ActiveDaemonTurn = class {
   #finished = Promise.withResolvers();
   #cancellationRequested = false;
   #dispatch;
-  #text = "";
   #activities = /* @__PURE__ */ new Map();
-  #content = /* @__PURE__ */ new Map();
   #timeline;
   #sequence = 0;
   #interaction = null;
@@ -38787,9 +38871,17 @@ var ActiveDaemonTurn = class {
   effectiveDisposition = () => this.#dispatch.kind === "promoted" ? SessionPromptDisposition.Steer : this.command.disposition;
   recordEvent = (event) => {
     if (event.kind === AGENT_MESSAGE_DELTA_KIND) {
-      this.#text += event.text;
+      const sequence = this.advance();
       this.appendMessageText(event.messageId, event.text);
-      return this.updated();
+      return {
+        commandId: this.command.commandId,
+        epoch: this.#epoch,
+        kind: AGENT_MESSAGE_DELTA_KIND,
+        messageId: event.messageId,
+        sequence,
+        sessionId: this.command.sessionId,
+        text: event.text
+      };
     }
     if (event.sessionId !== this.command.sessionId || "commandId" in event && event.commandId !== this.command.commandId) {
       return event;
@@ -38836,7 +38928,6 @@ var ActiveDaemonTurn = class {
         toolKind: previous?.toolKind ?? ""
       });
     } else if (event.kind === AGENT_CONTENT_KIND) {
-      this.#content.set(event.contentId, event.content);
       const target = this.#timeline.findLastIndex(
         (entry) => entry.kind === "message" && entry.sourceMessageId === event.messageId
       );
@@ -38862,7 +38953,7 @@ var ActiveDaemonTurn = class {
       this.#interaction = null;
     }
     if (event.kind === AGENT_ACTIVITY_KIND || event.kind === AGENT_ACTIVITY_NARRATION_KIND || event.kind === AGENT_CONTENT_KIND) {
-      return this.updated();
+      this.advance();
     }
     return event;
   };
@@ -38871,7 +38962,7 @@ var ActiveDaemonTurn = class {
     while (remaining.length > 0) {
       const latest = this.#timeline.at(-1);
       if (latest?.kind === "message" && latest.sourceMessageId === messageId) {
-        const available = SESSION_HISTORY_CHARACTER_LIMIT - latest.text.length;
+        const available = ACTIVE_TURN_TEXT_CHUNK_LIMIT - latest.text.length;
         if (available > 0) {
           this.#timeline = [
             ...this.#timeline.slice(0, -1),
@@ -38888,21 +38979,22 @@ var ActiveDaemonTurn = class {
           id: decodeIdentifier(randomUUID2()),
           kind: "message",
           sourceMessageId: messageId,
-          text: remaining.slice(0, SESSION_HISTORY_CHARACTER_LIMIT)
+          text: remaining.slice(0, ACTIVE_TURN_TEXT_CHUNK_LIMIT)
         }
       ];
-      remaining = remaining.slice(SESSION_HISTORY_CHARACTER_LIMIT);
+      remaining = remaining.slice(ACTIVE_TURN_TEXT_CHUNK_LIMIT);
     }
   }
   recordSteeringPrompt = (command) => {
     if (this.#dispatch.kind !== "running" || command.sessionId !== this.command.sessionId || command.targetCommandId !== this.command.commandId) {
-      return null;
+      return false;
     }
     this.#timeline = [
       ...this.#timeline,
       { id: decodeIdentifier(command.commandId), images: command.images, kind: "user", text: command.prompt }
     ];
-    return this.updated();
+    this.advance();
+    return true;
   };
   timelineMessages() {
     return this.#timeline.flatMap((entry) => {
@@ -38924,32 +39016,39 @@ var ActiveDaemonTurn = class {
       return activity2 === void 0 ? [] : [{ activities: [activity2], content: [], id: entry.id, role: "assistant", text: "" }];
     });
   }
-  updated = () => {
-    this.#sequence += 1;
-    const turn = this.snapshot();
-    if (turn === null) {
-      throw new Error("Only a running turn can publish a snapshot");
+  advance = () => {
+    if (this.#dispatch.kind !== "running") {
+      throw new Error("Only a running turn can advance its snapshot");
     }
-    return { kind: "session.turn.updated", sessionId: this.command.sessionId, turn };
+    this.#sequence += 1;
+    return this.#sequence;
   };
   snapshot = () => {
     if (this.#dispatch.kind !== "running") {
       return null;
     }
-    const completeMessages = this.timelineMessages();
-    const messages = completeMessages.slice(-SESSION_HISTORY_MESSAGE_LIMIT);
+    const bounded2 = boundedRecoveryMessages(this.timelineMessages());
     return {
-      activities: [...this.#activities.values()].sort((left, right) => left.sequence - right.sequence),
       commandId: decodeIdentifier(this.command.commandId),
-      content: [...this.#content.values()],
-      prompt: this.command.prompt,
-      text: this.#text,
-      truncated: messages.length !== completeMessages.length,
       epoch: this.#epoch,
+      hasOlder: bounded2.hasOlder,
       interaction: this.#interaction,
-      messages,
+      messages: bounded2.messages,
       sequence: this.#sequence,
-      state: "running"
+      state: "running",
+      truncated: false
+    };
+  };
+  recovery = () => {
+    if (this.#dispatch.kind !== "running") {
+      return null;
+    }
+    return {
+      commandId: decodeIdentifier(this.command.commandId),
+      epoch: this.#epoch,
+      messages: this.timelineMessages(),
+      state: "running",
+      truncated: false
     };
   };
   matches = (cancellation) => cancellation.commandId === this.command.commandId && cancellation.sessionId === this.command.sessionId;
@@ -38975,6 +39074,7 @@ var ActiveDaemonTurn = class {
 };
 
 // src/daemon-turn-registry.ts
+var COMPLETED_TURN_RECOVERY_LIMIT = 32;
 var waitForTurnCompletion = (turn, waitSignal) => {
   waitSignal.throwIfAborted();
   return new Promise((resolve9, reject) => {
@@ -39001,6 +39101,7 @@ var waitForTurnCompletion = (turn, waitSignal) => {
 };
 var DaemonTurnRegistry = class {
   #turns = /* @__PURE__ */ new Map();
+  #completed = /* @__PURE__ */ new Map();
   #operations;
   constructor(operations) {
     this.#operations = operations;
@@ -39012,7 +39113,22 @@ var DaemonTurnRegistry = class {
   };
   get = (commandId) => this.#turns.get(commandId);
   finish = (turn) => {
+    const recovery = turn.recovery();
     this.#turns.delete(turn.command.commandId);
+    if (recovery !== null) {
+      this.#completed.delete(turn.command.sessionId);
+      this.#completed.set(turn.command.sessionId, {
+        command: turn.command,
+        recovery: { ...recovery, state: "completed" }
+      });
+      while (this.#completed.size > COMPLETED_TURN_RECOVERY_LIMIT) {
+        const oldestSessionId = this.#completed.keys().next().value;
+        if (oldestSessionId === void 0) {
+          break;
+        }
+        this.#completed.delete(oldestSessionId);
+      }
+    }
     turn.finish();
   };
   recordEvent = (event) => {
@@ -39033,7 +39149,7 @@ var DaemonTurnRegistry = class {
   };
   recordSteeringPrompt = (command) => {
     const target = this.#turns.get(command.targetCommandId);
-    return target?.recordSteeringPrompt(command) ?? null;
+    return target?.recordSteeringPrompt(command) ?? false;
   };
   executionSnapshot = async (matches) => {
     const matching = [];
@@ -39064,12 +39180,30 @@ var DaemonTurnRegistry = class {
     }
     return null;
   };
+  recovery = (matches) => {
+    for (const turn of this.#turns.values()) {
+      if (!matches(turn.command)) {
+        continue;
+      }
+      const recovery = turn.recovery();
+      if (recovery !== null) {
+        return recovery;
+      }
+    }
+    for (const completed of this.#completed.values()) {
+      if (matches(completed.command)) {
+        return completed.recovery;
+      }
+    }
+    return null;
+  };
   close = async () => {
     const turns = [...this.#turns.values()];
     for (const turn of turns) {
       turn.abortDaemon();
     }
     await Promise.all(turns.map((turn) => turn.completion));
+    this.#completed.clear();
   };
   admitAndWait = async (turn, waitSignal, onQueued) => {
     const command = turn.command;
@@ -41377,10 +41511,10 @@ async function resolveSessionDirectories(directories, bindingId, directoryId2, a
 }
 
 // src/native-sessions/live-history-page.ts
-function liveHistoryCursor(sessionId, endIndex) {
-  return Buffer.from(JSON.stringify({ endIndex, sessionId }), "utf8").toString("base64url");
+function encodeLiveHistoryCursor(cursor) {
+  return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
 }
-function liveHistoryEndIndex(cursor, sessionId) {
+function decodeLiveHistoryCursor(cursor, sessionId) {
   try {
     if (!/^[A-Za-z0-9_-]{1,512}$/u.test(cursor)) {
       throw new Error("Invalid cursor alphabet");
@@ -41390,14 +41524,32 @@ function liveHistoryEndIndex(cursor, sessionId) {
       throw new Error("Invalid cursor shape");
     }
     const record2 = Object.fromEntries(Object.entries(value));
-    if (Object.keys(record2).sort().join(",") !== "endIndex,sessionId" || record2["sessionId"] !== sessionId || typeof record2["endIndex"] !== "number" || !Number.isSafeInteger(record2["endIndex"]) || record2["endIndex"] < 0) {
+    const keys = Object.keys(record2).sort().join(",");
+    const legacyNative = keys === "endIndex,sessionId";
+    const kind = legacyNative ? "native" : record2["kind"];
+    if (keys !== "endIndex,kind,sessionId" && keys !== "endIndex,epoch,kind,sessionId" && !legacyNative || record2["sessionId"] !== sessionId || kind !== "active" && kind !== "native" || typeof record2["endIndex"] !== "number" || !Number.isSafeInteger(record2["endIndex"]) || record2["endIndex"] < 0) {
       throw new Error("Invalid cursor target");
     }
-    return record2["endIndex"];
+    if (kind === "active") {
+      if (keys !== "endIndex,epoch,kind,sessionId" || typeof record2["epoch"] !== "string") {
+        throw new Error("Invalid active cursor target");
+      }
+      return { endIndex: record2["endIndex"], epoch: record2["epoch"], kind, sessionId };
+    }
+    if (keys !== "endIndex,kind,sessionId" && !legacyNative) {
+      throw new Error("Invalid native cursor target");
+    }
+    return { endIndex: record2["endIndex"], kind, sessionId };
   } catch (cause) {
     throw new AcpExecutionError("The native Session history cursor is invalid", { cause }, "invalid_cursor");
   }
 }
+function activeHistoryCursor(sessionId, epoch, endIndex) {
+  return encodeLiveHistoryCursor({ endIndex, epoch, kind: "active", sessionId });
+}
+function nativeHistoryCursor(sessionId, endIndex) {
+  return encodeLiveHistoryCursor({ endIndex, kind: "native", sessionId });
+}
 function liveHistoryCoveredTurnRanges(history) {
   const ranges = [];
   let historyIndex = history.messages.length;
@@ -41418,139 +41570,180 @@ function liveHistoryCoveredTurnRanges(history) {
 function historyMessageCharacters(message) {
   return message.text.length + (message.role === "assistant" ? JSON.stringify(message.activities).length + JSON.stringify(message.content).length : 0);
 }
-function boundedActiveMessages(messages, messageLimit, characterLimit) {
+function isNativeHistoryImageMimeType(mimeType) {
+  return mimeType === "image/png" || mimeType === "image/jpeg" || mimeType === "image/gif" || mimeType === "image/webp";
+}
+function selectMessagesBefore(messages, endIndex, messageLimit, characterLimit) {
   const selected = [];
   let remainingCharacters = characterLimit;
-  for (let index = messages.length - 1; index >= 0 && selected.length < messageLimit; index -= 1) {
+  let startIndex = endIndex;
+  for (let index = endIndex - 1; index >= 0 && selected.length < messageLimit; index -= 1) {
     const message = messages[index];
     if (message === void 0) {
       break;
     }
     const characters = historyMessageCharacters(message);
-    if (characters <= remainingCharacters) {
-      selected.unshift(message);
-      remainingCharacters -= characters;
-      continue;
-    }
-    const structuredCharacters = characters - message.text.length;
-    if (selected.length === 0 && structuredCharacters <= remainingCharacters) {
-      const textCharacters = remainingCharacters - structuredCharacters;
-      selected.unshift({ ...message, text: textCharacters === 0 ? "" : message.text.slice(-textCharacters) });
-      remainingCharacters = 0;
+    if (characters > remainingCharacters) {
+      break;
     }
-    break;
+    selected.unshift(message);
+    remainingCharacters -= characters;
+    startIndex = index;
   }
-  return {
-    characters: characterLimit - remainingCharacters,
-    messages: selected,
-    truncated: selected.length !== messages.length
-  };
+  if (selected.length === 0 && endIndex > 0) {
+    throw new AcpExecutionError(
+      "A native Session history item exceeds the page budget",
+      {},
+      "history_item_too_large"
+    );
+  }
+  return { characters: characterLimit - remainingCharacters, messages: selected, startIndex };
 }
 function nativeActiveMessage(message) {
-  return message.role === "user" ? { role: "user", text: message.text } : {
-    activities: message.activities,
-    content: message.content,
-    role: "assistant",
-    text: message.text
-  };
+  if (message.role === "assistant") {
+    return {
+      activities: message.activities,
+      content: message.content,
+      role: "assistant",
+      text: message.text
+    };
+  }
+  const images = (message.images ?? []).flatMap((image) => {
+    if (image.data.length < 4 || image.data.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(image.data) || !isNativeHistoryImageMimeType(image.mimeType)) {
+      return [];
+    }
+    return [{ data: image.data, mimeType: image.mimeType, name: image.name }];
+  });
+  return { ...images.length === 0 ? {} : { images }, role: "user", text: message.text };
+}
+function nativeHistoryCoversCompletedRecovery(history, recovery) {
+  const root = recovery.messages.find((message) => message.role === "user" && message.id === recovery.commandId);
+  if (root === void 0) {
+    return false;
+  }
+  const rootIndex = history.messages.findLastIndex(
+    (message) => message.role === "user" && message.text === root.text
+  );
+  if (rootIndex < 0) {
+    return false;
+  }
+  const nativeAssistant = history.messages.slice(rootIndex + 1).filter((message) => message.role === "assistant");
+  if (nativeAssistant.length === 0) {
+    return false;
+  }
+  const recoveryAssistant = recovery.messages.filter((message) => message.role === "assistant");
+  const recoveryText = recoveryAssistant.map((message) => message.text).join("");
+  const nativeText = nativeAssistant.map((message) => message.text).join("");
+  if (recoveryText.length > 0 && !nativeText.includes(recoveryText)) {
+    return false;
+  }
+  const nativeContent = new Set(
+    nativeAssistant.flatMap((message) => message.content).map((content) => JSON.stringify(content))
+  );
+  return recoveryAssistant.flatMap((message) => message.content).every((content) => nativeContent.has(JSON.stringify(content)));
 }
-function paginateAcpSessionHistory(history, sessionId, cursor, limit) {
+function historyBeforeActiveTurn(history, activeTurn) {
   if (history.status === "unavailable") {
-    if (cursor !== null) {
-      throw new AcpExecutionError("Unavailable native Session history has no cursor", {}, "invalid_cursor");
-    }
-    return { cause: history.cause, nextCursor: null, status: "unavailable" };
+    return history;
   }
-  const endIndex = cursor === null ? history.messages.length : liveHistoryEndIndex(cursor, sessionId);
+  const activeRoot = activeTurn.messages.find(
+    (message) => message.role === "user" && message.id === activeTurn.commandId
+  );
+  const matchingActiveUserIndex = activeRoot === void 0 ? -1 : activeTurn.state === "completed" || history.messages.at(-1)?.role === "user" && history.messages.at(-1)?.text === activeRoot.text || history.coveredCommandIds.includes(activeTurn.commandId) ? history.messages.findLastIndex((message) => message.role === "user" && message.text === activeRoot.text) : -1;
+  const activeUserIndex = matchingActiveUserIndex >= 0 ? matchingActiveUserIndex : liveHistoryCoveredTurnRanges(history).find((range) => range.commandId === activeTurn.commandId)?.userIndex ?? -1;
+  if (activeUserIndex < 0) {
+    return history;
+  }
+  return {
+    ...history,
+    coveredCommandIds: history.coveredCommandIds.filter((id) => id !== activeTurn.commandId),
+    coveredMessageIds: history.coveredMessageIds.filter(
+      (id) => id !== `${activeTurn.commandId}:user` && id !== `${activeTurn.commandId}:agent`
+    ),
+    messages: history.messages.slice(0, activeUserIndex)
+  };
+}
+function paginateAvailableNativeHistory(history, sessionId, endIndex, limit, characterLimit) {
   if (endIndex > history.messages.length) {
     throw new AcpExecutionError("The native Session history cursor is invalid", {}, "invalid_cursor");
   }
-  const startIndex = Math.max(0, endIndex - limit);
+  const selected = selectMessagesBefore(history.messages, endIndex, limit, characterLimit);
   const coveredMessageIds = new Set(history.coveredMessageIds);
   const ranges = liveHistoryCoveredTurnRanges(history);
   return {
-    coveredCommandIds: ranges.filter((range) => range.userIndex >= startIndex && range.assistantEndIndex <= endIndex).map((range) => range.commandId),
+    coveredCommandIds: ranges.filter((range) => range.userIndex >= selected.startIndex && range.assistantEndIndex <= endIndex).map((range) => range.commandId),
     coveredMessageIds: ranges.flatMap((range) => [
-      ...range.userIndex >= startIndex && range.userIndex < endIndex && coveredMessageIds.has(`${range.commandId}:user`) ? [`${range.commandId}:user`] : [],
-      ...range.assistantStartIndex >= startIndex && range.assistantEndIndex <= endIndex && coveredMessageIds.has(`${range.commandId}:agent`) ? [`${range.commandId}:agent`] : []
+      ...range.userIndex >= selected.startIndex && range.userIndex < endIndex && coveredMessageIds.has(`${range.commandId}:user`) ? [`${range.commandId}:user`] : [],
+      ...range.assistantStartIndex >= selected.startIndex && range.assistantEndIndex <= endIndex && coveredMessageIds.has(`${range.commandId}:agent`) ? [`${range.commandId}:agent`] : []
     ]),
-    messages: history.messages.slice(startIndex, endIndex),
-    nextCursor: startIndex > 0 ? liveHistoryCursor(sessionId, startIndex) : null,
+    messages: selected.messages,
+    nextCursor: selected.startIndex > 0 ? nativeHistoryCursor(sessionId, selected.startIndex) : null,
     status: "available",
     truncated: history.truncated
   };
 }
-function paginateLiveSessionHistory(history, activeTurn, sessionId, cursor, limit) {
-  if (activeTurn === null || cursor !== null) {
-    return paginateAcpSessionHistory(history, sessionId, cursor, limit);
+function paginateNativeHistory(history, sessionId, cursor, limit) {
+  if (cursor?.kind === "active") {
+    throw new AcpExecutionError("The native Session history cursor is invalid", {}, "invalid_cursor");
   }
   if (history.status === "unavailable") {
-    const bounded3 = boundedActiveMessages(
-      activeTurn.messages.map(nativeActiveMessage),
-      limit,
-      SESSION_HISTORY_CHARACTER_LIMIT
-    );
-    return {
-      coveredCommandIds: [],
-      coveredMessageIds: [],
-      messages: bounded3.messages,
-      nextCursor: null,
-      status: "available",
-      truncated: activeTurn.truncated || bounded3.truncated
-    };
+    if (cursor !== null) {
+      throw new AcpExecutionError("Unavailable native Session history has no cursor", {}, "invalid_cursor");
+    }
+    return { cause: history.cause, nextCursor: null, status: "unavailable" };
   }
-  const activeRoot = activeTurn.messages.find(
-    (message) => message.role === "user" && message.id === activeTurn.commandId
+  return paginateAvailableNativeHistory(
+    history,
+    sessionId,
+    cursor?.endIndex ?? history.messages.length,
+    limit,
+    SESSION_HISTORY_CHARACTER_LIMIT
   );
-  const coveredActiveRoot = history.coveredCommandIds.includes(activeTurn.commandId);
-  const matchingActiveUserIndex = coveredActiveRoot ? history.messages.findLastIndex(
-    (message) => message.role === "user" && message.text === (activeRoot?.text ?? activeTurn.prompt)
-  ) : -1;
-  const activeUserIndex = matchingActiveUserIndex >= 0 ? matchingActiveUserIndex : liveHistoryCoveredTurnRanges(history).find((range) => range.commandId === activeTurn.commandId)?.userIndex ?? -1;
-  if (activeUserIndex >= 0) {
-    history = {
-      ...history,
-      coveredCommandIds: history.coveredCommandIds.filter((id) => id !== activeTurn.commandId),
-      coveredMessageIds: history.coveredMessageIds.filter(
-        (id) => id !== `${activeTurn.commandId}:user` && id !== `${activeTurn.commandId}:agent`
-      ),
-      messages: history.messages.slice(0, activeUserIndex + 1)
-    };
-  }
-  const latestNativeMessage = history.messages.at(-1);
-  const firstActiveMessage = activeTurn.messages[0];
-  const preserveNativeRoot = activeUserIndex >= 0 || firstActiveMessage?.role === "user" && latestNativeMessage?.role === "user" && latestNativeMessage.text === firstActiveMessage.text;
-  const activeMessages = activeTurn.messages.slice(preserveNativeRoot ? 1 : 0).map(nativeActiveMessage);
-  const bounded2 = boundedActiveMessages(activeMessages, limit, SESSION_HISTORY_CHARACTER_LIMIT);
-  let historicalMessageCount = 0;
-  let remainingCharacters = SESSION_HISTORY_CHARACTER_LIMIT - bounded2.characters;
-  const historicalMessageLimit = Math.max(0, limit - bounded2.messages.length);
-  for (let index = history.messages.length - 1; index >= 0 && historicalMessageCount < historicalMessageLimit; index -= 1) {
-    const message = history.messages[index];
-    if (message === void 0) {
-      break;
-    }
-    const characters = historyMessageCharacters(message);
-    if (characters > remainingCharacters) {
-      break;
-    }
-    historicalMessageCount += 1;
-    remainingCharacters -= characters;
+}
+function paginateActiveTurn(history, activeTurn, sessionId, endIndex, limit) {
+  if (endIndex > activeTurn.messages.length) {
+    throw new AcpExecutionError("The native Session history cursor is invalid", {}, "invalid_cursor");
   }
-  const page = historicalMessageCount === 0 ? {
-    coveredCommandIds: [],
-    coveredMessageIds: [],
-    messages: [],
-    nextCursor: history.messages.length === 0 ? null : liveHistoryCursor(sessionId, history.messages.length),
-    status: "available",
-    truncated: history.truncated
-  } : paginateAcpSessionHistory(history, sessionId, null, historicalMessageCount);
+  const activeMessages = activeTurn.messages.map(nativeActiveMessage);
+  const active = selectMessagesBefore(activeMessages, endIndex, limit, SESSION_HISTORY_CHARACTER_LIMIT);
+  const historicalLimit = limit - active.messages.length;
+  const historicalCharacterLimit = SESSION_HISTORY_CHARACTER_LIMIT - active.characters;
+  const pendingHistoricalCursor = history.status === "available" && history.messages.length > 0 ? nativeHistoryCursor(sessionId, history.messages.length) : null;
+  const latestHistoricalMessage = history.status === "available" ? history.messages.at(-1) : void 0;
+  const historicalPageFits = latestHistoricalMessage === void 0 || historyMessageCharacters(latestHistoricalMessage) <= historicalCharacterLimit;
+  const historical = active.startIndex === 0 && history.status === "available" && historicalLimit > 0 && historicalPageFits ? paginateAvailableNativeHistory(
+    history,
+    sessionId,
+    history.messages.length,
+    historicalLimit,
+    historicalCharacterLimit
+  ) : null;
   return {
-    ...page,
-    messages: [...page.messages, ...bounded2.messages],
-    truncated: page.truncated || activeTurn.truncated || bounded2.truncated
+    coveredCommandIds: historical?.coveredCommandIds ?? [],
+    coveredMessageIds: [
+      ...historical?.coveredMessageIds ?? [],
+      ...active.startIndex === 0 ? [`${activeTurn.commandId}:user`, `${activeTurn.commandId}:agent`] : []
+    ],
+    messages: [...historical?.messages ?? [], ...active.messages],
+    nextCursor: active.startIndex > 0 ? activeHistoryCursor(sessionId, activeTurn.epoch, active.startIndex) : historical === null ? pendingHistoricalCursor : historical.nextCursor,
+    status: "available",
+    truncated: activeTurn.truncated || (historical?.truncated ?? false)
   };
 }
+function paginateLiveSessionHistory(history, activeTurn, sessionId, encodedCursor, limit) {
+  const cursor = encodedCursor === null ? null : decodeLiveHistoryCursor(encodedCursor, sessionId);
+  if (activeTurn === null || activeTurn.state === "completed" && history.status === "available" && nativeHistoryCoversCompletedRecovery(history, activeTurn)) {
+    return paginateNativeHistory(history, sessionId, cursor, limit);
+  }
+  const historical = historyBeforeActiveTurn(history, activeTurn);
+  if (cursor?.kind === "native") {
+    return paginateNativeHistory(historical, sessionId, cursor, limit);
+  }
+  if (cursor !== null && cursor.epoch !== activeTurn.epoch) {
+    throw new AcpExecutionError("The active Turn history cursor is stale", {}, "stale_cursor");
+  }
+  return paginateActiveTurn(historical, activeTurn, sessionId, cursor?.endIndex ?? activeTurn.messages.length, limit);
+}
 function mergeLiveSessionHistory(history, activeTurn, sessionId) {
   const page = paginateLiveSessionHistory(history, activeTurn, sessionId, null, 1e3);
   if (page.status === "unavailable") {
@@ -41561,7 +41754,7 @@ function mergeLiveSessionHistory(history, activeTurn, sessionId) {
     coveredMessageIds: page.coveredMessageIds,
     messages: page.messages,
     status: "available",
-    truncated: page.truncated
+    truncated: page.truncated || page.nextCursor !== null
   };
 }
 
@@ -42080,15 +42273,13 @@ async function executePrompt({
     });
     operations.transitionExecution(command.commandId, "running");
     if (availability.disposition === SessionPromptDisposition.Steer) {
-      const updated = recordSteeringPrompt();
-      if (updated === null) {
+      if (!recordSteeringPrompt()) {
         throw new AcpExecutionError(
           "The steering target is unavailable",
           {},
           "prompt_queue_target_unavailable"
         );
       }
-      publisher.publish(command.sessionId, updated);
     }
     const stream = activateAttempt();
     publisher.publish(command.sessionId, {
@@ -42476,7 +42667,7 @@ function createDaemonCommandHandler({
     resolveEnvironment: resolveAgentCatalogEnvironment
   });
   const queueChanged = (sessionId) => publisher.publish(sessionId, { kind: "session.queue.changed", sessionId });
-  const activeTurnSnapshot = (sessionId) => activeTurns.snapshot((command) => command.sessionId === sessionId);
+  const activeTurnRecovery = (sessionId) => activeTurns.recovery((command) => command.sessionId === sessionId);
   const nativeRequestHandler = createNativeSessionRequestHandler({
     audit,
     diagnostics,
@@ -42497,7 +42688,7 @@ function createDaemonCommandHandler({
           directories,
           audit,
           sessions,
-          activeTurnSnapshot,
+          activeTurnRecovery,
           signal
         );
         return;
@@ -42511,7 +42702,7 @@ function createDaemonCommandHandler({
           directories,
           audit,
           sessions,
-          activeTurnSnapshot,
+          activeTurnRecovery,
           signal
         );
         return;
@@ -42983,6 +43174,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();
@@ -43102,6 +43294,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;
           }
@@ -43109,6 +43305,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);
@@ -43123,7 +43331,6 @@ async function runRelayConnection({
       socket.addEventListener("close", handleClose);
       socket.addEventListener("error", handleError);
       socket.addEventListener("message", handleMessage);
-      publisher.connect(socket);
       if (signal.aborted) {
         stop();
       }
@@ -43134,54 +43341,377 @@ async function runRelayConnection({
   }
 }
 
+// src/relay-connection/session-event-outbox.ts
+import { randomUUID as randomUUID7 } from "node:crypto";
+import { mkdirSync as mkdirSync3 } from "node:fs";
+import { dirname as dirname6 } 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(dirname6(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(randomUUID7());
+  }
+  acknowledge = (acknowledgement) => this.#remove(acknowledgement.eventId, acknowledgement.sessionId);
+  close = () => {
+    this.#database.close();
+  };
+  enqueue = (sessionId, payload, critical) => {
+    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 + 1)) {
+        throw new Error("The Session event source sequence is exhausted");
+      }
+      const envelope2 = {
+        delivery: {
+          eventId: randomUUID7(),
+          kind: "reliable",
+          sourceSeq: sourceSeq.toString(),
+          streamId: rowString(state, "stream_id")
+        },
+        kind: SESSION_EVENT_KIND,
+        payload,
+        sessionId
+      };
+      const encoded = encodeSessionEventEnvelope(envelope2);
+      const byteLength = Buffer.byteLength(encoded, "utf8");
+      const maximumBytes = critical ? this.#limits.criticalEventBytes : this.#limits.standardEventBytes;
+      if (rowNumber(state, "total_bytes") + byteLength > maximumBytes) {
+        throw new SessionEventOutboxCapacityError();
+      }
+      this.#database.prepare(
+        `INSERT INTO relay_session_event_outbox (
+                        event_id, session_id, source_seq, byte_length, envelope_json
+                    ) VALUES (?, ?, ?, ?, ?)`
+      ).run(envelope2.delivery.eventId, sessionId, sourceSeq, byteLength, encoded);
+      this.#database.prepare(
+        `UPDATE relay_session_event_outbox_state
+                     SET next_source_seq = next_source_seq + 1,
+                         total_bytes = total_bytes + ?
+                     WHERE singleton = 1`
+      ).run(byteLength);
+      this.#database.exec("COMMIT");
+      return envelope2;
+    } 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) {
+    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();
+  };
+  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;
   };
-  #reportDrop = () => {
-    if (this.#reportedDrop) {
+  #publishNextBatch = () => {
+    if (this.#deferredReplay !== null || this.#connection.kind !== "connected") {
       return;
     }
-    this.#reportedDrop = true;
-    console.warn("Mobius daemon dropped live Session events while the Relay was unavailable");
+    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;
+      }
+    }
+  };
+  #removeInFlight = (eventId) => {
+    const inFlight = this.#inFlight.get(eventId);
+    if (inFlight === void 0) {
+      return;
+    }
+    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;
+    }
   };
 };
 
@@ -43242,7 +43772,7 @@ async function installDetectedAgentIntegrations(config2, installations, signal)
       {
         agentId: agent.id,
         kind: AGENT_INSTALL_REQUEST_KIND,
-        requestId: `automatic-integration-${randomUUID7()}`
+        requestId: `automatic-integration-${randomUUID8()}`
       },
       signal
     );
@@ -43264,7 +43794,11 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
     join18(stateDirectory, "sessions", `${createHash6("sha256").update(config2.channelId).digest("hex")}.sqlite`)
   );
   const operations = new DaemonOperationState();
-  const publisher = new DaemonSessionEventPublisher();
+  const channelHash = createHash6("sha256").update(config2.channelId).digest("hex");
+  const publisher = new DaemonSessionEventPublisher(
+    new SessionEventOutbox(join18(stateDirectory, "events", `${channelHash}.sqlite`)),
+    timer
+  );
   const activeTurns = new DaemonTurnRegistry(operations);
   const recordSessionEvent = (sessionId, event) => {
     publisher.publish(sessionId, activeTurns.recordEvent(event));