@alan-ai-hq/agent-manager 0.1.113 → 0.1.115

package/dist/event-outbox.js

@@ -0,0 +1,707 @@
+import { randomUUID } from "node:crypto";
+import { rm } from "node:fs/promises";
+import { isDeepStrictEqual } from "node:util";
+import { decodeJournalKey, sealJournalRecord } from "./event-journal-crypto.js";
+import { eventJournalDir, segmentPath } from "./event-journal-paths.js";
+import { markLegacyImportDone, recoverEventJournal, writeJournalAckStateAsync, } from "./event-journal-recovery.js";
+import { EVENT_JOURNAL_ORDINARY_BATCH_MS, EVENT_JOURNAL_SEGMENT_BYTES, } from "./event-journal-types.js";
+import { EventJournalWriter, readSegmentFileSize } from "./event-journal-writer.js";
+const MAX_INTERMEDIATE_EVENTS_PER_RUN = 200;
+const MAX_ENCRYPTED_OUTBOX_BYTES = 64 * 1024 * 1024;
+const ACK_TIMEOUT_MS = 10_000;
+const RETRY_DELAY_MS = 1_000;
+const TERMINAL_EVENT_TYPES = new Set([
+    "agent_run_finished",
+    "query_complete",
+    "session_complete",
+    "session_error",
+    "complete",
+]);
+function decodeKey(encodedKey) {
+    try {
+        return decodeJournalKey(encodedKey);
+    }
+    catch {
+        throw new Error("event outbox encryption key must contain exactly 32 bytes");
+    }
+}
+function isTerminal(event) {
+    return TERMINAL_EVENT_TYPES.has(event.type);
+}
+/**
+ * background_work heartbeats (BaseMachineAgent.runBackendWithActivityHeartbeat,
+ * ~every 10s for the life of a quiet tool call) prove daemon liveness to a
+ * currently-connected backend only — they carry no transcript content. They
+ * must never be allowed to evict real events (including `start`) from the
+ * durable outbox, so callers can drop them outright while disconnected and
+ * the outbox always evicts them first if any do get enqueued.
+ */
+export function isBackgroundHeartbeat(event) {
+    return event.type === "activity" && event.status === "background_work";
+}
+function parentToolUseIdOf(event) {
+    if ((event.type === "text" || event.type === "thinking") &&
+        typeof event.parentToolUseId === "string") {
+        return event.parentToolUseId;
+    }
+    return null;
+}
+function canCoalesceEvents(left, right) {
+    if (left.type !== right.type)
+        return false;
+    if (left.type !== "text" && left.type !== "thinking")
+        return false;
+    if (right.type !== "text" && right.type !== "thinking")
+        return false;
+    return parentToolUseIdOf(left) === parentToolUseIdOf(right);
+}
+function coalesceEvents(left, right) {
+    if ((left.type === "text" && right.type === "text") ||
+        (left.type === "thinking" && right.type === "thinking")) {
+        const parentToolUseId = parentToolUseIdOf(right) ?? parentToolUseIdOf(left);
+        return {
+            type: left.type,
+            text: `${left.text}${right.text}`,
+            ts: right.ts ?? left.ts,
+            ...(parentToolUseId ? { parentToolUseId } : {}),
+        };
+    }
+    return right;
+}
+function payloadOf(entry) {
+    return {
+        event: entry.event,
+        ...(entry.explicitSource ? { explicitSource: true } : {}),
+        ...(entry.kind ? { kind: entry.kind } : {}),
+        ...(entry.terminalCondensed ? { terminalCondensed: true } : {}),
+    };
+}
+function estimateEntryBytes(entry) {
+    const record = {
+        eventId: entry.eventId,
+        runId: entry.runId,
+        conversationId: entry.conversationId,
+        sequence: entry.sequence,
+        createdAtMs: entry.createdAtMs,
+        payload: payloadOf(entry),
+    };
+    // length prefix + iv + tag + ciphertext ≈ plaintext
+    return 4 + 12 + 16 + Buffer.byteLength(JSON.stringify(record), "utf8");
+}
+function entryFromRecord(record) {
+    const payload = record.payload;
+    if (!payload || typeof payload !== "object" || !payload.event)
+        return null;
+    return {
+        eventId: record.eventId,
+        conversationId: record.conversationId ?? "",
+        runId: record.runId,
+        event: payload.event,
+        createdAtMs: record.createdAtMs,
+        sequence: record.sequence,
+        ...(payload.explicitSource ? { explicitSource: true } : {}),
+        ...(payload.kind ? { kind: payload.kind } : {}),
+        ...(payload.terminalCondensed ? { terminalCondensed: true } : {}),
+    };
+}
+/**
+ * Durable, encrypted, at-least-once event delivery for daemon-to-backend agent events.
+ * Compatibility facade over an append-only segmented journal: presenters enqueue memory
+ * work; AES/fsync runs on a single bounded async writer (≤25ms ordinary batching).
+ */
+export class EncryptedEventOutbox {
+    path;
+    pushLog;
+    entries = [];
+    segmentIds = new Map();
+    segmentSizes = new Map();
+    ackDirty = false;
+    ackFailure = null;
+    maintenance = null;
+    maintenanceTimer = null;
+    legacyImport = null;
+    acknowledgedEventIds;
+    sequences = new Map();
+    transmittedEventIds = new Set();
+    inFlight = new Map();
+    retryTimers = new Map();
+    deliveryTimer = null;
+    lastDeliveryAtMs = 0;
+    acknowledgementWaiters = new Map();
+    persistFailureLogged = false;
+    compactionState = "idle";
+    roundRobinCursor = 0;
+    runOrder = [];
+    writer;
+    journalDir;
+    key;
+    maxEncryptedBytes;
+    maxIntermediateEventsPerRun;
+    deliveryIntervalMs;
+    maxConcurrentDeliveries;
+    ordinaryBatchMs;
+    highWaterMarkLogged = false;
+    pendingBytes = 0;
+    cachedSegmentBytes = 0;
+    cachedSegmentCount = 0;
+    lastRecover;
+    refreshSegmentCache() {
+        this.cachedSegmentCount = this.segmentSizes.size;
+        this.cachedSegmentBytes = [...this.segmentSizes.values()].reduce((sum, bytes) => sum + bytes, 0);
+    }
+    constructor(path, encodedKey, pushLog = () => { }, options = {}) {
+        this.path = path;
+        this.pushLog = pushLog;
+        this.key = decodeKey(encodedKey);
+        this.journalDir = eventJournalDir(this.path);
+        this.maxEncryptedBytes = options.maxEncryptedBytes ?? MAX_ENCRYPTED_OUTBOX_BYTES;
+        this.maxIntermediateEventsPerRun =
+            options.maxIntermediateEventsPerRun ?? MAX_INTERMEDIATE_EVENTS_PER_RUN;
+        this.deliveryIntervalMs = options.deliveryIntervalMs ?? 0;
+        this.maxConcurrentDeliveries = options.maxConcurrentDeliveries ?? 1;
+        if (!Number.isSafeInteger(this.maxConcurrentDeliveries) ||
+            this.maxConcurrentDeliveries < 1 ||
+            this.maxConcurrentDeliveries > 4) {
+            throw new Error("event outbox maxConcurrentDeliveries must be between 1 and 4");
+        }
+        this.ordinaryBatchMs = options.ordinaryBatchMs ?? EVENT_JOURNAL_ORDINARY_BATCH_MS;
+        if (!Number.isSafeInteger(this.maxEncryptedBytes) || this.maxEncryptedBytes <= 0) {
+            throw new Error("event outbox maxEncryptedBytes must be a positive integer");
+        }
+        if (!Number.isSafeInteger(this.maxIntermediateEventsPerRun) ||
+            this.maxIntermediateEventsPerRun < 0) {
+            throw new Error("event outbox maxIntermediateEventsPerRun must be a non-negative integer");
+        }
+        if (!Number.isSafeInteger(this.deliveryIntervalMs) || this.deliveryIntervalMs < 0) {
+            throw new Error("event outbox deliveryIntervalMs must be a non-negative integer");
+        }
+        const pendingLegacy = [];
+        const recovered = recoverEventJournal({
+            legacyPath: this.path,
+            journalDir: this.journalDir,
+            key: this.key,
+            pushLog: this.pushLog,
+            appendLegacyRecords: (records) => {
+                pendingLegacy.push(...records);
+            },
+        });
+        this.lastRecover = {
+            truncatedIncompleteTail: recovered.truncatedIncompleteTail,
+            quarantinedSegments: recovered.quarantinedSegments,
+            importedLegacySnapshot: recovered.importedLegacySnapshot,
+        };
+        const segmentLimit = options.segmentBytes ?? EVENT_JOURNAL_SEGMENT_BYTES;
+        const { activeSequence, activeBytes } = this.resolveWriterCursor(recovered.segments, segmentLimit);
+        this.writer = new EventJournalWriter(this.journalDir, this.key, this.pushLog, {
+            onPersisted: (sequence, records, bytes) => {
+                const ids = this.segmentIds.get(sequence) ?? new Set();
+                for (const record of records)
+                    ids.add(record.eventId);
+                this.segmentIds.set(sequence, ids);
+                this.segmentSizes.set(sequence, bytes);
+                this.refreshSegmentCache();
+            },
+            segmentBytes: segmentLimit,
+            ordinaryBatchMs: this.ordinaryBatchMs,
+            onPersistFailure: (error) => {
+                if (!error) {
+                    this.persistFailureLogged = false;
+                    return;
+                }
+                if (!this.persistFailureLogged) {
+                    this.persistFailureLogged = true;
+                    this.pushLog(`event_outbox_persist_failed error=${error} pending_entries=${this.entries.length}`);
+                }
+            },
+        }, {
+            nextSegmentSequence: activeSequence,
+            currentSegmentBytes: activeBytes,
+        });
+        if (pendingLegacy.length > 0) {
+            for (const record of pendingLegacy) {
+                this.writer.enqueue(record, false);
+            }
+            if (recovered.needsImportMarker)
+                this.legacyImport = { count: recovered.legacyImportRecordCount ?? pendingLegacy.length };
+        }
+        this.refreshSegmentCache();
+        this.acknowledgedEventIds = new Set(recovered.ack.acknowledgedEventIds);
+        for (const segment of recovered.segments) {
+            this.segmentSizes.set(segment.sequence, segment.bytes);
+            this.segmentIds.set(segment.sequence, new Set(segment.records.map((record) => record.eventId)));
+        }
+        this.refreshSegmentCache();
+        const segmentsForHydrate = [...recovered.segments];
+        if (pendingLegacy.length)
+            segmentsForHydrate.push({
+                sequence: 0,
+                path: "",
+                bytes: 0,
+                records: pendingLegacy,
+                corrupt: false,
+                truncatedIncompleteTail: false,
+            });
+        this.hydrateFromSegments(segmentsForHydrate);
+        this.enforceRetentionPolicy();
+        if (this.acknowledgedEventIds.size)
+            this.persistAckState();
+        if (this.legacyImport)
+            void this.flushDurable().catch((error) => this.pushLog(`event_journal_import_failed ${String(error)}`));
+    }
+    resolveWriterCursor(segments, segmentLimit) {
+        if (segments.length === 0)
+            return { activeSequence: 1, activeBytes: 0 };
+        const last = segments[segments.length - 1];
+        if (last.bytes >= segmentLimit) {
+            return { activeSequence: last.sequence + 1, activeBytes: 0 };
+        }
+        return {
+            activeSequence: last.sequence,
+            activeBytes: last.bytes || readSegmentFileSize(this.journalDir, last.sequence),
+        };
+    }
+    hydrateFromSegments(segments) {
+        const pending = [];
+        for (const segment of segments) {
+            for (const record of segment.records) {
+                if (this.acknowledgedEventIds.has(record.eventId))
+                    continue;
+                const entry = entryFromRecord(record);
+                if (!entry)
+                    continue;
+                if (pending.some((existing) => existing.eventId === entry.eventId))
+                    continue;
+                pending.push(entry);
+                const prior = this.sequences.get(entry.runId) ?? 0;
+                if (entry.sequence > prior)
+                    this.sequences.set(entry.runId, entry.sequence);
+            }
+        }
+        pending.sort((a, b) => {
+            if (a.runId !== b.runId)
+                return a.runId.localeCompare(b.runId);
+            return a.sequence - b.sequence;
+        });
+        this.entries = pending;
+        this.pendingBytes = pending.reduce((sum, entry) => sum + estimateEntryBytes(entry), 0);
+        for (const entry of pending)
+            this.trackRun(entry.runId);
+    }
+    trackRun(runId) {
+        if (!this.runOrder.includes(runId))
+            this.runOrder.push(runId);
+    }
+    nextSequence(runId) {
+        const next = (this.sequences.get(runId) ?? 0) + 1;
+        this.sequences.set(runId, next);
+        return next;
+    }
+    toRecord(entry) {
+        return sealJournalRecord({
+            eventId: entry.eventId,
+            runId: entry.runId,
+            conversationId: entry.conversationId,
+            sequence: entry.sequence,
+            createdAtMs: entry.createdAtMs,
+            payload: payloadOf(entry),
+        });
+    }
+    appendEntry(entry, immediateFlush) {
+        this.entries.push(entry);
+        this.pendingBytes += estimateEntryBytes(entry);
+        this.trackRun(entry.runId);
+        this.writer.enqueue(this.toRecord(entry), immediateFlush);
+    }
+    rewriteQueued(entry) {
+        const record = this.toRecord(entry);
+        if (!this.writer.updateQueued(entry.eventId, record)) {
+            // Already durable — append a replacement frame and ACK the stale id is not
+            // possible without diverging eventId; leave coalesced mutation only while queued.
+        }
+    }
+    enqueue(conversationId, runId, event) {
+        const last = this.entries[this.entries.length - 1];
+        if (last &&
+            !last.explicitSource &&
+            !this.isInFlight(last.eventId) &&
+            !this.transmittedEventIds.has(last.eventId) &&
+            last.kind !== "condensation_marker" &&
+            last.conversationId === conversationId &&
+            last.runId === runId &&
+            this.writer.hasQueued(last.eventId) &&
+            canCoalesceEvents(last.event, event)) {
+            this.pendingBytes -= estimateEntryBytes(last);
+            last.event = coalesceEvents(last.event, event);
+            last.createdAtMs = Date.now();
+            this.pendingBytes += estimateEntryBytes(last);
+            this.rewriteQueued(last);
+            this.enforceRetentionPolicy(runId, false);
+            return last.eventId;
+        }
+        const entry = {
+            eventId: randomUUID(),
+            conversationId,
+            runId,
+            event,
+            createdAtMs: Date.now(),
+            sequence: this.nextSequence(runId),
+        };
+        this.appendEntry(entry, isTerminal(event));
+        this.enforceRetentionPolicy(runId, isBackgroundHeartbeat(event));
+        return entry.eventId;
+    }
+    /**
+     * Durably enqueue an event whose id is derived from an external source cursor.
+     * Identical retries are idempotent, while reusing an id for different content
+     * fails closed so the backend can never observe divergent payloads under one
+     * receipt key.
+     */
+    enqueueSource(conversationId, runId, eventId, event) {
+        if (!eventId.trim())
+            throw new Error("event outbox source event id must not be empty");
+        const existing = this.entries.find((entry) => entry.eventId === eventId);
+        if (existing) {
+            if (existing.explicitSource === true &&
+                existing.conversationId === conversationId &&
+                existing.runId === runId &&
+                isDeepStrictEqual(existing.event, event)) {
+                return eventId;
+            }
+            throw new Error(`event outbox source event id ${eventId} has divergent payload`);
+        }
+        if (this.acknowledgedEventIds.has(eventId)) {
+            return eventId;
+        }
+        const entry = {
+            eventId,
+            conversationId,
+            runId,
+            event,
+            createdAtMs: Date.now(),
+            sequence: this.nextSequence(runId),
+            explicitSource: true,
+        };
+        this.appendEntry(entry, true);
+        this.enforceRetentionPolicy(runId, false);
+        return eventId;
+    }
+    hasTerminalEvent(runId) {
+        return this.entries.some((entry) => entry.runId === runId && isTerminal(entry.event));
+    }
+    pendingCount() {
+        return this.entries.length;
+    }
+    /** Drain the async writer queue to durable segments. */
+    async flushDurable() {
+        await this.writer.flush();
+        if (this.writer.getPersistFailure())
+            return;
+        if (this.legacyImport) {
+            markLegacyImportDone(this.journalDir, this.legacyImport.count, this.pushLog);
+            this.legacyImport = null;
+        }
+        await this.flushMaintenance();
+        this.refreshSegmentCache();
+    }
+    metrics() {
+        const oldest = this.entries.reduce((min, entry) => {
+            if (min === null || entry.createdAtMs < min)
+                return entry.createdAtMs;
+            return min;
+        }, null);
+        const persistFailure = this.writer.getPersistFailure() ?? this.ackFailure;
+        const overloaded = this.pendingBytes > this.maxEncryptedBytes || this.writer.depth() > 2_000;
+        const degraded = persistFailure !== null ||
+            this.compactionState === "failed" ||
+            this.lastRecover.quarantinedSegments.length > 0;
+        return {
+            writerDepth: this.writer.depth(),
+            oldestPendingAgeMs: oldest === null ? null : Math.max(0, Date.now() - oldest),
+            segmentBytes: this.cachedSegmentBytes,
+            segmentCount: this.cachedSegmentCount,
+            compactionState: this.compactionState,
+            persistFailure,
+            overloaded,
+            degraded,
+        };
+    }
+    waitForAcknowledgement(eventId, signal) {
+        if (signal?.aborted)
+            return Promise.reject(signal.reason);
+        if (!this.entries.some((entry) => entry.eventId === eventId))
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            const finish = () => {
+                signal?.removeEventListener("abort", abort);
+                resolve();
+            };
+            const abort = () => {
+                const remaining = this.acknowledgementWaiters.get(eventId)?.filter((waiter) => waiter !== finish) ?? [];
+                if (remaining.length)
+                    this.acknowledgementWaiters.set(eventId, remaining);
+                else
+                    this.acknowledgementWaiters.delete(eventId);
+                reject(signal?.reason);
+            };
+            const waiters = this.acknowledgementWaiters.get(eventId) ?? [];
+            waiters.push(finish);
+            this.acknowledgementWaiters.set(eventId, waiters);
+            signal?.addEventListener("abort", abort, { once: true });
+        });
+    }
+    disconnect() {
+        for (const attempt of this.inFlight.values())
+            clearTimeout(attempt.timer);
+        for (const timer of this.retryTimers.values())
+            clearTimeout(timer);
+        this.inFlight.clear();
+        this.retryTimers.clear();
+        this.clearDeliveryTimer();
+    }
+    flush(socket) {
+        while (socket.connected &&
+            this.inFlight.size < this.maxConcurrentDeliveries &&
+            this.entries.length > 0) {
+            const now = Date.now();
+            // A wall-clock correction must not turn a short delivery interval into an
+            // overflowing Node timeout (which otherwise becomes a 1 ms retry loop).
+            if (this.lastDeliveryAtMs > now)
+                this.lastDeliveryAtMs = now;
+            const deliveryDelayMs = Math.min(this.lastDeliveryAtMs + this.deliveryIntervalMs - now, 2_147_483_647);
+            if (deliveryDelayMs > 0) {
+                this.scheduleDelivery(socket, deliveryDelayMs);
+                return;
+            }
+            this.clearDeliveryTimer();
+            const entry = this.pickDeliveryEntry();
+            if (!entry)
+                return;
+            this.lastDeliveryAtMs = Date.now();
+            this.transmittedEventIds.add(entry.eventId);
+            const attempt = {
+                eventId: entry.eventId,
+                timer: setTimeout(() => settle({ ok: false, retryable: true }), ACK_TIMEOUT_MS),
+            };
+            this.inFlight.set(entry.runId, attempt);
+            attempt.timer.unref?.();
+            const settle = (result) => {
+                // Attempt identity matters: an old callback can refer to the same event
+                // after reconnect or timeout, but must not acknowledge the new attempt.
+                if (this.inFlight.get(entry.runId) !== attempt)
+                    return;
+                clearTimeout(attempt.timer);
+                this.inFlight.delete(entry.runId);
+                if (result?.ok) {
+                    this.removeEntry(entry.eventId);
+                    this.transmittedEventIds.delete(entry.eventId);
+                    this.acknowledgedEventIds.add(entry.eventId);
+                    this.persistAckState();
+                    for (const resolve of this.acknowledgementWaiters.get(entry.eventId) ?? [])
+                        resolve();
+                    this.acknowledgementWaiters.delete(entry.eventId);
+                    queueMicrotask(() => this.flush(socket));
+                    return;
+                }
+                this.scheduleRetry(socket, entry.runId);
+                queueMicrotask(() => this.flush(socket));
+            };
+            try {
+                socket.emit("agent.event", {
+                    eventId: entry.eventId,
+                    conversationId: entry.conversationId,
+                    runId: entry.runId,
+                    event: entry.event,
+                }, settle);
+            }
+            catch {
+                settle({ ok: false, retryable: true });
+            }
+        }
+    }
+    isInFlight(eventId) {
+        return [...this.inFlight.values()].some((attempt) => attempt.eventId === eventId);
+    }
+    pickDeliveryEntry() {
+        if (this.entries.length === 0)
+            return undefined;
+        if (this.runOrder.length === 0)
+            return this.entries[0];
+        const runIds = this.runOrder.filter((runId) => this.entries.some((entry) => entry.runId === runId));
+        if (runIds.length === 0)
+            return this.entries[0];
+        for (let offset = 0; offset < runIds.length; offset += 1) {
+            const index = (this.roundRobinCursor + offset) % runIds.length;
+            const runId = runIds[index];
+            if (this.inFlight.has(runId) || this.retryTimers.has(runId))
+                continue;
+            const candidates = this.entries
+                .filter((entry) => entry.runId === runId)
+                .sort((a, b) => a.sequence - b.sequence);
+            const next = candidates[0];
+            if (!next)
+                continue;
+            this.roundRobinCursor = (index + 1) % runIds.length;
+            return next;
+        }
+        return undefined;
+    }
+    removeEntry(eventId) {
+        const index = this.entries.findIndex((entry) => entry.eventId === eventId);
+        if (index < 0)
+            return;
+        const [removed] = this.entries.splice(index, 1);
+        if (removed) {
+            this.pendingBytes -= estimateEntryBytes(removed);
+            if (!this.entries.some((entry) => entry.runId === removed.runId)) {
+                this.sequences.delete(removed.runId);
+                const runIndex = this.runOrder.indexOf(removed.runId);
+                if (runIndex >= 0)
+                    this.runOrder.splice(runIndex, 1);
+                if (runIndex < this.roundRobinCursor)
+                    this.roundRobinCursor--;
+            }
+        }
+        this.writer.removeQueued(eventId);
+    }
+    isDroppableHeartbeat(entry) {
+        return (!this.isInFlight(entry.eventId) &&
+            !entry.explicitSource &&
+            entry.kind !== "condensation_marker" &&
+            isBackgroundHeartbeat(entry.event));
+    }
+    pickHeartbeatDropCandidate(matches) {
+        return this.entries.find((entry) => matches(entry) && this.isDroppableHeartbeat(entry));
+    }
+    dropEntry(entry) {
+        this.removeEntry(entry.eventId);
+        this.acknowledgedEventIds.add(entry.eventId);
+    }
+    enforceRetentionPolicy(preferredRunId, pruneRunHeartbeats = true) {
+        const droppedHeartbeatsByRunId = new Map();
+        const runIds = pruneRunHeartbeats
+            ? preferredRunId
+                ? [preferredRunId]
+                : [...new Set(this.entries.map((entry) => entry.runId))]
+            : [];
+        for (const runId of runIds) {
+            const heartbeats = this.entries.filter((entry) => entry.runId === runId && this.isDroppableHeartbeat(entry));
+            const excessHeartbeats = heartbeats.slice(0, Math.max(0, heartbeats.length - this.maxIntermediateEventsPerRun));
+            for (const drop of excessHeartbeats) {
+                this.dropEntry(drop);
+                droppedHeartbeatsByRunId.set(runId, (droppedHeartbeatsByRunId.get(runId) ?? 0) + 1);
+            }
+        }
+        while (this.pendingBytes > this.maxEncryptedBytes) {
+            const drop = this.pickHeartbeatDropCandidate(() => true);
+            if (!drop)
+                break;
+            this.dropEntry(drop);
+            droppedHeartbeatsByRunId.set(drop.runId, (droppedHeartbeatsByRunId.get(drop.runId) ?? 0) + 1);
+        }
+        for (const [runId, count] of droppedHeartbeatsByRunId) {
+            this.pushLog(`event_outbox_heartbeat_pruned run=${runId} count=${count} max_encrypted_bytes=${this.maxEncryptedBytes}`);
+        }
+        if (this.pendingBytes > this.maxEncryptedBytes && !this.highWaterMarkLogged) {
+            this.highWaterMarkLogged = true;
+            this.pushLog(`event_outbox_high_watermark bytes=${this.pendingBytes} pending_entries=${this.entries.length} max_encrypted_bytes=${this.maxEncryptedBytes}`);
+        }
+        if (this.pendingBytes <= this.maxEncryptedBytes)
+            this.highWaterMarkLogged = false;
+        if (droppedHeartbeatsByRunId.size > 0)
+            this.persistAckState();
+    }
+    scheduleDelivery(socket, delayMs) {
+        if (this.deliveryTimer)
+            return;
+        this.deliveryTimer = setTimeout(() => {
+            this.deliveryTimer = null;
+            this.flush(socket);
+        }, delayMs);
+        this.deliveryTimer.unref?.();
+    }
+    persistAckState() {
+        this.ackDirty = true;
+        if (this.maintenanceTimer || this.maintenance)
+            return;
+        this.maintenanceTimer = setTimeout(() => {
+            this.maintenanceTimer = null;
+            void this.flushMaintenance();
+        }, this.ordinaryBatchMs);
+        this.maintenanceTimer.unref?.();
+    }
+    flushMaintenance() {
+        if (this.maintenanceTimer)
+            clearTimeout(this.maintenanceTimer);
+        this.maintenanceTimer = null;
+        if (this.maintenance)
+            return this.maintenance;
+        this.maintenance = this.maintain().finally(() => {
+            this.maintenance = null;
+        });
+        return this.maintenance;
+    }
+    async maintain() {
+        while (this.ackDirty) {
+            this.ackDirty = false;
+            this.compactionState = "running";
+            try {
+                await this.writer.flush();
+                if (this.writer.getPersistFailure()) {
+                    this.ackDirty = true;
+                    this.compactionState = "failed";
+                    return;
+                }
+                const durableAcks = new Set(this.acknowledgedEventIds);
+                const state = {
+                    acknowledgedEventIds: [...durableAcks],
+                    condensedRunIds: [],
+                };
+                await writeJournalAckStateAsync(this.journalDir, this.key, state);
+                for (const [sequence, ids] of this.segmentIds) {
+                    if (sequence === this.writer.activeSegmentSequence() ||
+                        ![...ids].every((id) => durableAcks.has(id)))
+                        continue;
+                    await rm(segmentPath(this.journalDir, sequence), { force: true });
+                    this.segmentIds.delete(sequence);
+                    this.segmentSizes.delete(sequence);
+                    this.refreshSegmentCache();
+                }
+                // ponytail: keep 10,000 recent receipts plus all retained frames. Older
+                // source retries use the backend's durable event-id deduplication.
+                const retained = new Set([...this.segmentIds.values()].flatMap((ids) => [...ids]));
+                const recent = new Set([...this.acknowledgedEventIds].slice(-10_000));
+                for (const id of this.acknowledgedEventIds) {
+                    if (!retained.has(id) && !recent.has(id)) {
+                        this.acknowledgedEventIds.delete(id);
+                        this.ackDirty = true;
+                    }
+                }
+                this.ackFailure = null;
+                this.compactionState = "idle";
+            }
+            catch (error) {
+                this.ackDirty = true;
+                this.ackFailure = error instanceof Error ? error.message : String(error);
+                this.compactionState = "failed";
+                this.pushLog(`event_outbox_ack_persist_failed error=${this.ackFailure}`);
+                return;
+            }
+        }
+    }
+    scheduleRetry(socket, runId) {
+        if (!socket.connected || this.retryTimers.has(runId))
+            return;
+        const timer = setTimeout(() => {
+            this.retryTimers.delete(runId);
+            this.flush(socket);
+        }, RETRY_DELAY_MS);
+        timer.unref?.();
+        this.retryTimers.set(runId, timer);
+    }
+    clearDeliveryTimer() {
+        if (this.deliveryTimer)
+            clearTimeout(this.deliveryTimer);
+        this.deliveryTimer = null;
+    }
+}
+//# sourceMappingURL=event-outbox.js.map