@moxt-ai/mobius 0.0.149 → 0.0.150

package/dist/cli.js

@@ -3381,7 +3381,7 @@ var program = new Command();
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.149",
+  version: "0.0.150",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -29330,9 +29330,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 = readString2(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);
@@ -29782,12 +29790,59 @@ 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 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 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();
 function decode5(encoded, schema) {
@@ -29816,6 +29871,12 @@ 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) {
@@ -29987,6 +30048,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,
@@ -31045,7 +31121,7 @@ var AuditStore = class {
 };
 
 // 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";
 
@@ -46594,6 +46670,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();
@@ -46713,6 +46790,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;
           }
@@ -46720,6 +46801,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);
@@ -46734,7 +46827,6 @@ async function runRelayConnection({
       socket.addEventListener("close", handleClose);
       socket.addEventListener("error", handleError);
       socket.addEventListener("message", handleMessage);
-      publisher.connect(socket);
       if (signal.aborted) {
         stop();
       }
@@ -46745,54 +46837,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(path3, limits = DEFAULT_LIMITS) {
+    validateLimits(limits);
+    mkdirSync3(dirname6(path3), { mode: 448, recursive: true });
+    this.#limits = limits;
+    this.#database = new DatabaseSync(path3);
+    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;
+  };
+  #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;
+    }
   };
 };
 
@@ -46853,7 +47268,7 @@ async function installDetectedAgentIntegrations(config2, installations, signal)
       {
         agentId: agent.id,
         kind: AGENT_INSTALL_REQUEST_KIND,
-        requestId: `automatic-integration-${randomUUID7()}`
+        requestId: `automatic-integration-${randomUUID8()}`
       },
       signal
     );
@@ -46875,7 +47290,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));