@moxt-ai/mobius 0.0.152 → 0.0.154

package/dist/index.js

@@ -20990,6 +20990,11 @@ var assistantHistoryMessageSchema = external_exports.strictObject({
 }).readonly();
 var historyMessage = external_exports.discriminatedUnion("role", [userHistoryMessage, assistantHistoryMessageSchema]);
 var availableSessionHistoryObjectSchema = external_exports.strictObject({
+  streamPosition: external_exports.strictObject({
+    commandId: identifierStringSchema,
+    epoch: identifierStringSchema,
+    sequence: external_exports.number().int().nonnegative()
+  }).readonly().optional(),
   status: external_exports.literal("available"),
   messages: external_exports.array(historyMessage).max(SESSION_HISTORY_MESSAGE_LIMIT).readonly(),
   truncated: external_exports.boolean(),
@@ -39111,6 +39116,7 @@ var ActiveDaemonTurn = class {
       commandId: decodeIdentifier(this.command.commandId),
       epoch: this.#epoch,
       messages: this.timelineMessages(),
+      sequence: this.#sequence,
       state: "running",
       truncated: false
     };
@@ -39138,7 +39144,7 @@ var ActiveDaemonTurn = class {
 };
 
 // src/daemon-turn-registry.ts
-var COMPLETED_TURN_RECOVERY_LIMIT = 32;
+var MAX_SESSIONS_WITH_COMPLETED_RECOVERY = 32;
 var waitForTurnCompletion = (turn, waitSignal) => {
   waitSignal.throwIfAborted();
   return new Promise((resolve9, reject) => {
@@ -39164,46 +39170,46 @@ var waitForTurnCompletion = (turn, waitSignal) => {
   });
 };
 var DaemonTurnRegistry = class {
-  #turns = /* @__PURE__ */ new Map();
-  #completed = /* @__PURE__ */ new Map();
+  #inFlightByCommandId = /* @__PURE__ */ new Map();
+  #latestCompletedBySessionId = /* @__PURE__ */ new Map();
   #operations;
   constructor(operations) {
     this.#operations = operations;
   }
   start = (command, attemptId) => {
     const turn = new ActiveDaemonTurn(command, attemptId);
-    this.#turns.set(command.commandId, turn);
+    this.#inFlightByCommandId.set(command.commandId, turn);
     return turn;
   };
-  get = (commandId) => this.#turns.get(commandId);
+  get = (commandId) => this.#inFlightByCommandId.get(commandId);
   finish = (turn) => {
     const recovery = turn.recovery();
-    this.#turns.delete(turn.command.commandId);
+    this.#inFlightByCommandId.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);
-      }
+      this.retainLatestCompletedRecovery(turn.command, { ...recovery, state: "completed" });
     }
     turn.finish();
   };
+  retainLatestCompletedRecovery = (command, recovery) => {
+    this.#latestCompletedBySessionId.delete(command.sessionId);
+    this.#latestCompletedBySessionId.set(command.sessionId, { command, recovery });
+    while (this.#latestCompletedBySessionId.size > MAX_SESSIONS_WITH_COMPLETED_RECOVERY) {
+      const oldestSessionId = this.#latestCompletedBySessionId.keys().next().value;
+      if (oldestSessionId === void 0) {
+        break;
+      }
+      this.#latestCompletedBySessionId.delete(oldestSessionId);
+    }
+  };
   recordEvent = (event) => {
     if ("commandId" in event) {
-      const turn = this.#turns.get(event.commandId);
+      const turn = this.#inFlightByCommandId.get(event.commandId);
       if (turn !== void 0 && turn.command.sessionId === event.sessionId) {
         return turn.recordEvent(event);
       }
     }
     if (event.kind === SESSION_PERMISSION_RESOLVED_KIND || event.kind === SESSION_ELICITATION_RESOLVED_KIND) {
-      for (const turn of this.#turns.values()) {
+      for (const turn of this.#inFlightByCommandId.values()) {
         if (turn.matchesInteraction(event.interactionId, event.sessionId)) {
           return turn.recordEvent(event);
         }
@@ -39212,17 +39218,17 @@ var DaemonTurnRegistry = class {
     return event;
   };
   recordSteeringPrompt = (command) => {
-    const target = this.#turns.get(command.targetCommandId);
+    const target = this.#inFlightByCommandId.get(command.targetCommandId);
     return target?.recordSteeringPrompt(command) ?? false;
   };
   executionSnapshot = async (matches) => {
     const matching = [];
-    for (const turn of this.#turns.values()) {
+    for (const turn of this.#inFlightByCommandId.values()) {
       if (await matches(turn.command)) {
         matching.push(turn);
       }
     }
-    const current = matching.filter((turn) => this.#turns.get(turn.command.commandId) === turn);
+    const current = matching.filter((turn) => this.#inFlightByCommandId.get(turn.command.commandId) === turn);
     return {
       turn: current.map((turn) => turn.snapshot()).find((snapshot) => snapshot !== null) ?? null,
       queued: current.filter((turn) => turn.isQueued()).map(({ command }) => ({
@@ -39233,7 +39239,7 @@ var DaemonTurnRegistry = class {
     };
   };
   snapshot = (matches) => {
-    for (const turn of this.#turns.values()) {
+    for (const turn of this.#inFlightByCommandId.values()) {
       if (!matches(turn.command)) {
         continue;
       }
@@ -39245,7 +39251,7 @@ var DaemonTurnRegistry = class {
     return null;
   };
   recovery = (matches) => {
-    for (const turn of this.#turns.values()) {
+    for (const turn of this.#inFlightByCommandId.values()) {
       if (!matches(turn.command)) {
         continue;
       }
@@ -39254,7 +39260,7 @@ var DaemonTurnRegistry = class {
         return recovery;
       }
     }
-    for (const completed of this.#completed.values()) {
+    for (const completed of this.#latestCompletedBySessionId.values()) {
       if (matches(completed.command)) {
         return completed.recovery;
       }
@@ -39262,17 +39268,17 @@ var DaemonTurnRegistry = class {
     return null;
   };
   close = async () => {
-    const turns = [...this.#turns.values()];
+    const turns = [...this.#inFlightByCommandId.values()];
     for (const turn of turns) {
       turn.abortDaemon();
     }
     await Promise.all(turns.map((turn) => turn.completion));
-    this.#completed.clear();
+    this.#latestCompletedBySessionId.clear();
   };
   admitAndWait = async (turn, waitSignal, onQueued) => {
     const command = turn.command;
     waitSignal.throwIfAborted();
-    const head = () => [...this.#turns.values()].find(
+    const head = () => [...this.#inFlightByCommandId.values()].find(
       (turn2) => turn2.command.sessionId === command.sessionId && turn2.command.disposition !== SessionPromptDisposition.Steer
     );
     if (command.disposition === SessionPromptDisposition.Queue) {
@@ -41842,6 +41848,7 @@ function paginateActiveTurn(history, activeTurn, sessionId, endIndex, limit) {
     historicalCharacterLimit
   ) : null;
   return {
+    streamPosition: { commandId: activeTurn.commandId, epoch: activeTurn.epoch, sequence: activeTurn.sequence },
     coveredCommandIds: historical?.coveredCommandIds ?? [],
     coveredMessageIds: [
       ...historical?.coveredMessageIds ?? [],
@@ -41874,6 +41881,7 @@ function mergeLiveSessionHistory(history, activeTurn, sessionId) {
   }
   return {
     coveredCommandIds: page.coveredCommandIds,
+    ...page.streamPosition === void 0 ? {} : { streamPosition: page.streamPosition },
     coveredMessageIds: page.coveredMessageIds,
     messages: page.messages,
     status: "available",
@@ -43469,7 +43477,7 @@ async function runRelayConnection({
             return;
           }
           if (kind === SESSION_EVENT_REJECTED_KIND) {
-            publisher.quarantine(message);
+            publisher.reject(message);
             return;
           }
           commands.handle(message);
@@ -43496,250 +43504,84 @@ async function runRelayConnection({
   }
 }
 
-// src/relay-connection/session-event-outbox.ts
+// src/relay-connection/session-event-publisher.ts
+import { WebSocket as WebSocket9 } from "undici";
+
+// src/relay-connection/session-event-queue.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";
+var STANDARD_EVENT_BYTES = 96 * 1024 * 1024;
+var CRITICAL_EVENT_BYTES = 128 * 1024 * 1024;
+var SessionEventQueueCapacityError = class extends Error {
+  code = "session_event_queue_full";
   constructor() {
-    super("The persistent Session event outbox is full");
-    this.name = "SessionEventOutboxCapacityError";
+    super("The in-memory Session event queue is full");
+    this.name = "SessionEventQueueCapacityError";
   }
 };
-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;
-  };
+var SessionEventQueue = class {
+  #streamId = randomUUID7();
+  #events = /* @__PURE__ */ new Map();
+  #nextSourceSeq = 1;
+  #totalBytes = 0;
   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;
+    if (!Number.isSafeInteger(this.#nextSourceSeq + payloads.length)) {
+      throw new Error("The Session event source sequence is exhausted");
     }
-  };
-  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;
+    const entries = payloads.map((payload, index) => {
+      const envelope2 = {
+        delivery: {
+          eventId: randomUUID7(),
+          kind: "reliable",
+          sourceSeq: (this.#nextSourceSeq + index).toString(),
+          streamId: this.#streamId
+        },
+        kind: SESSION_EVENT_KIND,
+        payload,
+        sessionId
+      };
+      return { envelope: envelope2, byteLength: Buffer.byteLength(encodeSessionEventEnvelope(envelope2), "utf8") };
     });
+    const byteLength = entries.reduce((total, entry) => total + entry.byteLength, 0);
+    if (this.#totalBytes + byteLength > (critical ? CRITICAL_EVENT_BYTES : STANDARD_EVENT_BYTES)) {
+      throw new SessionEventQueueCapacityError();
+    }
+    for (const entry of entries) {
+      this.#events.set(entry.envelope.delivery.eventId, entry);
+    }
+    this.#nextSourceSeq += entries.length;
+    this.#totalBytes += byteLength;
   };
-  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;
+  pending = (limit, excludedEventIds) => {
+    const result = [];
+    for (const [eventId, entry] of this.#events) {
+      if (!excludedEventIds.has(eventId)) {
+        result.push(entry.envelope);
+        if (result.length === limit) {
+          break;
+        }
       }
-      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;
     }
+    return result;
   };
-  #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) => {
+    const entry = this.#events.get(eventId);
+    if (entry === void 0 || entry.envelope.sessionId !== sessionId) {
+      return false;
     }
+    this.#events.delete(eventId);
+    this.#totalBytes -= entry.byteLength;
+    return true;
   };
-  #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;
-    }
+  clear = () => {
+    this.#events.clear();
+    this.#totalBytes = 0;
   };
 };
 
 // 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) {
@@ -43750,18 +43592,17 @@ function reservesSessionEventCapacity(event) {
 }
 var DaemonSessionEventPublisher = class {
   #inFlight = /* @__PURE__ */ new Map();
-  #outbox;
+  #queue = new SessionEventQueue();
   #reportedCapacityKinds = /* @__PURE__ */ new Set();
   #timer;
   #connection = { kind: "disconnected" };
   #deferredReplay = null;
   #inFlightBytes = 0;
-  constructor(outbox, timer) {
-    this.#outbox = outbox;
+  constructor(timer) {
     this.#timer = timer;
   }
   acknowledge = (acknowledgement) => {
-    if (!this.#outbox.acknowledge(acknowledgement)) {
+    if (!this.#queue.remove(acknowledgement.eventId, acknowledgement.sessionId)) {
       return;
     }
     this.#removeInFlight(acknowledgement.eventId);
@@ -43772,7 +43613,7 @@ var DaemonSessionEventPublisher = class {
     this.#deferredReplay = null;
     this.#connection = { kind: "disconnected" };
     this.#clearInFlight();
-    this.#outbox.close();
+    this.#queue.clear();
   };
   connect = (socket, delivery) => {
     this.#connection = { delivery, kind: "connected", socket };
@@ -43801,16 +43642,18 @@ var DaemonSessionEventPublisher = class {
   };
   publish = (sessionId, event) => {
     try {
-      this.#outbox.enqueue(sessionId, encodeRecordedSessionEvent(event), reservesSessionEventCapacity(event));
+      this.#queue.enqueueBatch(
+        sessionId,
+        [encodeRecordedSessionEvent(event)],
+        reservesSessionEventCapacity(event)
+      );
     } catch (error62) {
-      if (!(error62 instanceof SessionEventOutboxCapacityError)) {
+      if (!(error62 instanceof SessionEventQueueCapacityError)) {
         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`
-        );
+        console.warn(`Mobius daemon could not buffer "${event.kind}" because the Session event queue is full`);
       }
       return;
     }
@@ -43818,11 +43661,11 @@ var DaemonSessionEventPublisher = class {
   };
   publishBatch = (sessionId, events) => {
     const critical = events.some(reservesSessionEventCapacity);
-    this.#outbox.enqueueBatch(sessionId, events.map(encodeRecordedSessionEvent), critical);
+    this.#queue.enqueueBatch(sessionId, events.map(encodeRecordedSessionEvent), critical);
     this.#publishNextBatch();
   };
-  quarantine = (rejection) => {
-    if (!this.#outbox.quarantine(rejection)) {
+  reject = (rejection) => {
+    if (!this.#queue.remove(rejection.eventId, rejection.sessionId)) {
       return;
     }
     this.#removeInFlight(rejection.eventId);
@@ -43838,9 +43681,10 @@ var DaemonSessionEventPublisher = class {
       return;
     }
     while (this.#inFlight.size < SESSION_EVENT_REPLAY_WINDOW) {
-      const batch = this.#outbox.pending(SESSION_EVENT_REPLAY_WINDOW - this.#inFlight.size, [
-        ...this.#inFlight.keys()
-      ]);
+      const batch = this.#queue.pending(
+        SESSION_EVENT_REPLAY_WINDOW - this.#inFlight.size,
+        new Set(this.#inFlight.keys())
+      );
       let sent = 0;
       for (const envelope2 of batch) {
         const encoded = encodeDaemonToServiceMessage(
@@ -43859,12 +43703,7 @@ var DaemonSessionEventPublisher = class {
           return;
         }
         if (this.#connection.delivery === "ephemeral") {
-          this.#outbox.acknowledge({
-            eventId: envelope2.delivery.eventId,
-            kind: "session.event.ack",
-            outcome: { kind: "relayed" },
-            sessionId: envelope2.sessionId
-          });
+          this.#queue.remove(envelope2.delivery.eventId, envelope2.sessionId);
           sent += 1;
           continue;
         }
@@ -43977,11 +43816,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(timer);
   const activeTurns = new DaemonTurnRegistry(operations);
   const recordSessionEvent = (sessionId, event) => {
     publisher.publish(sessionId, activeTurns.recordEvent(event));