@moxt-ai/mobius 0.0.153 → 0.0.155

package/dist/daemon-turn-registry.d.ts

@@ -20,19 +20,6 @@ export declare class DaemonTurnRegistry {
             epoch: string;
             hasOlder: boolean;
             interaction: Readonly<{
-                commandId: string;
-                interactionId: string;
-                kind: "session.permission.requested";
-                options: readonly Readonly<{
-                    kind: "allow_always" | "allow_once" | "reject_always" | "reject_once";
-                    name: string;
-                    optionId: string;
-                }>[];
-                sessionId: string;
-                title: string;
-                toolCallId: string;
-                toolKind: string;
-            }> | Readonly<{
                 accepted: boolean;
                 commandId: string;
                 elicitationId: string;
@@ -64,6 +51,19 @@ export declare class DaemonTurnRegistry {
                 mode: "form" | "url";
                 sessionId: string;
                 url: string;
+            }> | Readonly<{
+                commandId: string;
+                interactionId: string;
+                kind: "session.permission.requested";
+                options: readonly Readonly<{
+                    kind: "allow_always" | "allow_once" | "reject_always" | "reject_once";
+                    name: string;
+                    optionId: string;
+                }>[];
+                sessionId: string;
+                title: string;
+                toolCallId: string;
+                toolKind: string;
             }> | null;
             messages: readonly (Readonly<{
                 id: string;

package/dist/index.js

@@ -20767,16 +20767,8 @@ function decodeSessionQueuedEvent(encoded) {
 function decodeRuntimeLivenessReadyEvent(encoded) {
   const value = parseJson2(encoded);
   assertKind(value, 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 };
+  assertExactKeys(value, ["kind"]);
+  return { kind: RUNTIME_LIVENESS_READY_KIND };
 }
 function decodeRuntimeHeartbeatEvent(encoded) {
   const value = parseJson2(encoded);
@@ -21243,60 +21235,13 @@ 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 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,
+var sessionEventEnvelopeSchema = 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 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({
@@ -21329,14 +21274,8 @@ var encode4 = (message, schema) => {
   }
   return JSON.stringify(decoded.data);
 };
-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);
+var decodeSessionEventEnvelope = (encoded) => decode5(encoded, sessionEventEnvelopeSchema);
+var encodeSessionEventEnvelope = (message) => encode4(message, sessionEventEnvelopeSchema);
 function decodeRecordedSessionEvent(encoded) {
   const kind = decodeMessageKind(encoded);
   switch (kind) {
@@ -21510,21 +21449,6 @@ 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,
@@ -37660,7 +37584,7 @@ function isRuntimeRelayRevocation(closeCode, closeReason) {
 }
 
 // src/run-daemon.ts
-import { createHash as createHash6, randomUUID as randomUUID8 } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID7 } from "node:crypto";
 import { join as join18 } from "node:path";
 import { styleText } from "node:util";
 
@@ -43337,7 +43261,6 @@ 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();
@@ -43457,10 +43380,7 @@ 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"
-            );
+            publisher.connect(socket);
             connectionLiveness.start();
             return;
           }
@@ -43468,18 +43388,6 @@ 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);
@@ -43504,404 +43412,44 @@ 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) => {
-    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: randomUUID7(),
-            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 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 MAX_BUFFERED_BYTES = 32 * 1024 * 1024;
 var DaemonSessionEventPublisher = class {
-  #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);
+  #socket = null;
+  connect = (socket) => {
+    this.#socket = socket;
   };
   disconnect = (socket) => {
-    if (this.#connection.kind !== "connected" || this.#connection.socket !== socket) {
-      return;
-    }
-    this.#connection = { kind: "disconnected" };
-    this.#clearInFlight();
-  };
-  publish = (sessionId, event) => {
-    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;
-    }
-    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;
+    if (this.#socket === socket) {
+      this.#socket = null;
     }
-    this.#removeInFlight(rejection.eventId);
-    console.error(`Mobius Relay rejected Session event ${rejection.eventId} with code ${rejection.code}`);
-    this.#publishNextBatch();
   };
-  #clearInFlight = () => {
-    this.#inFlight.clear();
-    this.#inFlightBytes = 0;
+  close = () => {
+    this.#socket = null;
   };
-  #publishNextBatch = () => {
-    if (this.#deferredReplay !== null || this.#connection.kind !== "connected") {
+  publish = (sessionId, event) => {
+    const socket = this.#socket;
+    if (socket === null || socket.readyState !== WebSocket9.OPEN) {
       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;
-      }
-    }
-  };
-  #removeInFlight = (eventId) => {
-    const inFlight = this.#inFlight.get(eventId);
-    if (inFlight === void 0) {
+    const encoded = encodeDaemonToServiceMessage({
+      kind: SESSION_EVENT_KIND,
+      payload: encodeRecordedSessionEvent(event),
+      sessionId
+    });
+    if (socket.bufferedAmount + Buffer.byteLength(encoded, "utf8") > MAX_BUFFERED_BYTES) {
+      socket.close(1013, "Live event transport overloaded");
       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;
+      socket.send(encoded);
     } catch {
-      return false;
+    }
+  };
+  publishBatch = (sessionId, events) => {
+    for (const event of events) {
+      this.publish(sessionId, event);
     }
   };
 };
@@ -43963,7 +43511,7 @@ async function installDetectedAgentIntegrations(config2, installations, signal)
       {
         agentId: agent.id,
         kind: AGENT_INSTALL_REQUEST_KIND,
-        requestId: `automatic-integration-${randomUUID8()}`
+        requestId: `automatic-integration-${randomUUID7()}`
       },
       signal
     );
@@ -43985,11 +43533,7 @@ 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 channelHash = createHash6("sha256").update(config2.channelId).digest("hex");
-  const publisher = new DaemonSessionEventPublisher(
-    new SessionEventOutbox(join18(stateDirectory, "events", `${channelHash}.sqlite`)),
-    timer
-  );
+  const publisher = new DaemonSessionEventPublisher();
   const activeTurns = new DaemonTurnRegistry(operations);
   const recordSessionEvent = (sessionId, event) => {
     publisher.publish(sessionId, activeTurns.recordEvent(event));