@holon-run/agentinbox 0.1.0

package/dist/src/service.js

@@ -0,0 +1,1338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivationDispatcher = exports.AgentInboxService = void 0;
+const backend_1 = require("./backend");
+const util_1 = require("./util");
+const source_schema_1 = require("./source_schema");
+const filter_1 = require("./filter");
+const terminal_1 = require("./terminal");
+const DEFAULT_SUBSCRIPTION_POLL_LIMIT = 100;
+const DEFAULT_ACTIVATION_WINDOW_MS = 3_000;
+const DEFAULT_ACTIVATION_MAX_ITEMS = 20;
+const DEFAULT_NOTIFY_LEASE_MS = 10 * 60 * 1000;
+const DEFAULT_NOTIFY_RETRY_MS = 5_000;
+const DEFAULT_ACKED_RETENTION_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_OFFLINE_AGENT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const DEFAULT_GC_INTERVAL_MS = 60 * 1000;
+const WEBHOOK_ACTIVATION_MODES = new Set(["activation_only", "activation_with_items"]);
+const SUBSCRIPTION_START_POLICIES = new Set(["latest", "earliest", "at_offset", "at_time"]);
+const SUBSCRIPTION_LIFECYCLE_MODES = new Set(["standing", "temporary"]);
+class AgentInboxService {
+    store;
+    adapters;
+    backend;
+    inFlightSubscriptions = new Set();
+    activationWindowMs;
+    activationMaxItems;
+    ackedRetentionMs;
+    notificationBuffers = new Map();
+    inboxWatchers = new Map();
+    syncInterval = null;
+    stopping = false;
+    lastAckedInboxGcAt = 0;
+    lastOfflineAgentGcAt = 0;
+    constructor(store, adapters, activationDispatcher = new ActivationDispatcher(), backend, activationPolicy, terminalDispatcher = new terminal_1.TerminalDispatcher()) {
+        this.store = store;
+        this.adapters = adapters;
+        this.activationDispatcher = activationDispatcher;
+        this.backend = backend ?? new backend_1.SqliteEventBusBackend(store);
+        this.activationWindowMs = activationPolicy?.windowMs ?? DEFAULT_ACTIVATION_WINDOW_MS;
+        this.activationMaxItems = activationPolicy?.maxItems ?? DEFAULT_ACTIVATION_MAX_ITEMS;
+        this.ackedRetentionMs = DEFAULT_ACKED_RETENTION_MS;
+        this.terminalDispatcher = terminalDispatcher;
+    }
+    activationDispatcher;
+    terminalDispatcher;
+    async start() {
+        if (this.syncInterval) {
+            return;
+        }
+        this.stopping = false;
+        this.syncInterval = setInterval(() => {
+            void this.syncAllSubscriptions();
+            void this.syncActivationDispatchStates();
+            void this.runAckedInboxGcIfDue();
+            void this.syncLifecycleGc();
+        }, 2_000);
+        await this.syncAllSubscriptions();
+        await this.syncActivationDispatchStates();
+        await this.runAckedInboxGcIfDue(true);
+        await this.syncLifecycleGc();
+    }
+    async stop() {
+        this.stopping = true;
+        for (const buffer of this.notificationBuffers.values()) {
+            if (buffer.timer) {
+                clearTimeout(buffer.timer);
+                buffer.timer = null;
+            }
+        }
+        if (this.syncInterval) {
+            clearInterval(this.syncInterval);
+            this.syncInterval = null;
+        }
+        await this.flushAllPendingNotifications();
+    }
+    async registerSource(input) {
+        if (input.sourceType === "remote_source") {
+            throw new Error("source type is reserved and not yet supported: remote_source");
+        }
+        const existing = this.store.getSourceByKey(input.sourceType, input.sourceKey);
+        if (existing) {
+            return existing;
+        }
+        const now = (0, util_1.nowIso)();
+        const source = {
+            sourceId: (0, util_1.generateId)("src"),
+            sourceType: input.sourceType,
+            sourceKey: input.sourceKey,
+            configRef: input.configRef ?? null,
+            config: input.config ?? {},
+            status: "active",
+            checkpoint: null,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.store.insertSource(source);
+        await this.ensureStreamForSource(source);
+        await this.adapters.sourceAdapterFor(source.sourceType).ensureSource(source);
+        return source;
+    }
+    listSources() {
+        return this.store.listSources();
+    }
+    getSource(sourceId) {
+        const source = this.store.getSource(sourceId);
+        if (!source) {
+            throw new Error(`unknown source: ${sourceId}`);
+        }
+        return source;
+    }
+    getSourceDetails(sourceId) {
+        const source = this.getSource(sourceId);
+        return {
+            source,
+            schema: (0, source_schema_1.getSourceSchema)(source.sourceType),
+            stream: this.store.getStreamBySourceId(sourceId),
+            subscriptions: this.store.listSubscriptionsForSource(sourceId),
+        };
+    }
+    getSourceSchema(sourceType) {
+        return (0, source_schema_1.getSourceSchema)(sourceType);
+    }
+    registerAgent(input) {
+        validateNotifyLeaseMs(input.notifyLeaseMs);
+        validateTerminalRegistration(input);
+        const runtimeKind = input.runtimeKind ?? "unknown";
+        const agentId = input.agentId ?? (0, terminal_1.assignedAgentIdFromContext)({
+            runtimeKind,
+            runtimeSessionId: input.runtimeSessionId ?? null,
+            backend: input.backend,
+            tmuxPaneId: input.tmuxPaneId ?? null,
+            itermSessionId: input.itermSessionId ?? null,
+            tty: input.tty ?? null,
+        });
+        const now = (0, util_1.nowIso)();
+        this.handleAgentRegistrationConflicts(agentId, input);
+        const existingAgent = this.store.getAgent(agentId);
+        const agent = existingAgent
+            ? this.store.updateAgent(agentId, {
+                status: "active",
+                offlineSince: null,
+                runtimeKind,
+                runtimeSessionId: input.runtimeSessionId ?? null,
+                updatedAt: now,
+                lastSeenAt: now,
+            })
+            : (() => {
+                const created = {
+                    agentId,
+                    status: "active",
+                    offlineSince: null,
+                    runtimeKind,
+                    runtimeSessionId: input.runtimeSessionId ?? null,
+                    createdAt: now,
+                    updatedAt: now,
+                    lastSeenAt: now,
+                };
+                this.store.insertAgent(created);
+                return created;
+            })();
+        const terminalTarget = this.upsertTerminalActivationTarget(agent.agentId, input, now);
+        const inbox = this.ensureInboxForAgent(agent.agentId);
+        return {
+            agent,
+            terminalTarget,
+            inbox,
+        };
+    }
+    detectAndRegisterAgent(notifyLeaseMs, env = process.env) {
+        const detected = (0, terminal_1.detectTerminalContext)(env);
+        return this.registerAgent({
+            runtimeKind: detected.runtimeKind,
+            runtimeSessionId: detected.runtimeSessionId ?? null,
+            backend: detected.backend,
+            mode: "agent_prompt",
+            tmuxPaneId: detected.tmuxPaneId ?? null,
+            tty: detected.tty ?? null,
+            termProgram: detected.termProgram ?? null,
+            itermSessionId: detected.itermSessionId ?? null,
+            notifyLeaseMs: notifyLeaseMs ?? null,
+        });
+    }
+    listAgents() {
+        return this.store.listAgents();
+    }
+    getAgent(agentId) {
+        const agent = this.store.getAgent(agentId);
+        if (!agent) {
+            throw new Error(`unknown agent: ${agentId}`);
+        }
+        return agent;
+    }
+    getAgentDetails(agentId) {
+        const agent = this.getAgent(agentId);
+        return {
+            agent,
+            inbox: this.ensureInboxForAgent(agent.agentId),
+            subscriptions: this.store.listSubscriptionsForAgent(agent.agentId),
+            activationTargets: this.store.listActivationTargetsForAgent(agent.agentId),
+            activationDispatchStates: this.store.listActivationDispatchStatesForAgent(agent.agentId),
+            itemCounts: this.inboxCounts(agent.agentId),
+        };
+    }
+    removeAgent(agentId) {
+        this.getAgent(agentId);
+        this.store.deleteAgent(agentId);
+        this.notificationBuffers.forEach((buffer, key) => {
+            if (key.startsWith(`${agentId}:`)) {
+                if (buffer.timer) {
+                    clearTimeout(buffer.timer);
+                }
+                this.notificationBuffers.delete(key);
+            }
+        });
+        this.inboxWatchers.delete(agentId);
+        return { removed: true };
+    }
+    addWebhookActivationTarget(agentId, input) {
+        this.getAgent(agentId);
+        validateNotifyLeaseMs(input.notifyLeaseMs);
+        const mode = normalizeWebhookActivationMode(input.activationMode);
+        const now = (0, util_1.nowIso)();
+        const target = {
+            targetId: (0, util_1.generateId)("tgt"),
+            agentId,
+            kind: "webhook",
+            status: "active",
+            offlineSince: null,
+            consecutiveFailures: 0,
+            lastDeliveredAt: null,
+            lastError: null,
+            mode,
+            url: input.url,
+            notifyLeaseMs: input.notifyLeaseMs ?? DEFAULT_NOTIFY_LEASE_MS,
+            createdAt: now,
+            updatedAt: now,
+            lastSeenAt: now,
+        };
+        this.store.insertActivationTarget(target);
+        this.markAgentActive(agentId);
+        return target;
+    }
+    listActivationTargets(agentId) {
+        if (agentId) {
+            this.getAgent(agentId);
+            return this.store.listActivationTargetsForAgent(agentId);
+        }
+        return this.store.listActivationTargets();
+    }
+    getActivationTarget(targetId) {
+        const target = this.store.getActivationTarget(targetId);
+        if (!target) {
+            throw new Error(`unknown activation target: ${targetId}`);
+        }
+        return target;
+    }
+    removeActivationTarget(agentId, targetId) {
+        const target = this.getActivationTarget(targetId);
+        if (target.agentId !== agentId) {
+            throw new Error(`activation target ${targetId} does not belong to agent ${agentId}`);
+        }
+        this.store.deleteActivationTarget(agentId, targetId);
+        this.reconcileAgentStatus(agentId);
+        return { removed: true };
+    }
+    async registerSubscription(input) {
+        this.getAgent(input.agentId);
+        const source = this.store.getSource(input.sourceId);
+        if (!source) {
+            throw new Error(`unknown source: ${input.sourceId}`);
+        }
+        await (0, filter_1.validateSubscriptionFilter)(input.filter ?? {});
+        const lifecycleMode = input.lifecycleMode ?? "standing";
+        if (!SUBSCRIPTION_LIFECYCLE_MODES.has(lifecycleMode)) {
+            throw new Error(`unsupported lifecycle mode: ${lifecycleMode}`);
+        }
+        const subscription = {
+            subscriptionId: (0, util_1.generateId)("sub"),
+            agentId: input.agentId,
+            sourceId: input.sourceId,
+            filter: input.filter ?? {},
+            lifecycleMode,
+            expiresAt: input.expiresAt ?? null,
+            startPolicy: input.startPolicy ?? "latest",
+            startOffset: input.startOffset ?? null,
+            startTime: input.startTime ?? null,
+            createdAt: (0, util_1.nowIso)(),
+        };
+        this.ensureInboxForAgent(subscription.agentId);
+        this.store.insertSubscription(subscription);
+        const stream = await this.ensureStreamForSource(source);
+        await this.backend.ensureConsumer({
+            streamId: stream.streamId,
+            subscriptionId: subscription.subscriptionId,
+            consumerKey: `subscription:${subscription.subscriptionId}`,
+            startPolicy: subscription.startPolicy,
+            startOffset: subscription.startOffset ?? null,
+            startTime: subscription.startTime ?? null,
+        });
+        return subscription;
+    }
+    async removeSubscription(subscriptionId) {
+        const subscription = this.getSubscription(subscriptionId);
+        await this.backend.deleteConsumer({ subscriptionId });
+        this.store.deleteSubscription(subscriptionId);
+        this.clearSubscriptionRuntimeState(subscription);
+        return { removed: true, subscriptionId };
+    }
+    listSubscriptions(filters) {
+        return this.store.listSubscriptions().filter((subscription) => {
+            if (filters?.sourceId && subscription.sourceId !== filters.sourceId) {
+                return false;
+            }
+            if (filters?.agentId && subscription.agentId !== filters.agentId) {
+                return false;
+            }
+            return true;
+        });
+    }
+    getSubscription(subscriptionId) {
+        const subscription = this.store.getSubscription(subscriptionId);
+        if (!subscription) {
+            throw new Error(`unknown subscription: ${subscriptionId}`);
+        }
+        return subscription;
+    }
+    async getSubscriptionDetails(subscriptionId) {
+        const subscription = this.getSubscription(subscriptionId);
+        const consumer = await this.backend.getConsumer({ subscriptionId });
+        if (!consumer) {
+            throw new Error(`unknown consumer for subscription: ${subscriptionId}`);
+        }
+        return {
+            subscription,
+            source: this.getSource(subscription.sourceId),
+            inbox: this.ensureInboxForAgent(subscription.agentId),
+            activationTargets: this.store.listActivationTargetsForAgent(subscription.agentId),
+            consumer,
+            lag: await this.backend.getConsumerLag({ consumerId: consumer.consumerId }),
+        };
+    }
+    async getSubscriptionLag(subscriptionId) {
+        this.getSubscription(subscriptionId);
+        return this.backend.getConsumerLag({ subscriptionId });
+    }
+    async resetSubscription(input) {
+        this.getSubscription(input.subscriptionId);
+        if (!SUBSCRIPTION_START_POLICIES.has(input.startPolicy)) {
+            throw new Error(`unsupported start policy: ${input.startPolicy}`);
+        }
+        const consumer = await this.backend.getConsumer({ subscriptionId: input.subscriptionId });
+        if (!consumer) {
+            throw new Error(`unknown consumer for subscription: ${input.subscriptionId}`);
+        }
+        const reset = await this.backend.reset({
+            consumerId: consumer.consumerId,
+            startPolicy: input.startPolicy,
+            startOffset: input.startOffset ?? null,
+            startTime: input.startTime ?? null,
+        });
+        return {
+            subscription: this.getSubscription(input.subscriptionId),
+            consumer: reset,
+            lag: await this.backend.getConsumerLag({ consumerId: reset.consumerId }),
+        };
+    }
+    async appendSourceEvent(input) {
+        const source = this.store.getSource(input.sourceId);
+        if (!source) {
+            throw new Error(`unknown source: ${input.sourceId}`);
+        }
+        const stream = await this.ensureStreamForSource(source);
+        const result = await this.backend.append({
+            streamId: stream.streamId,
+            events: [input],
+        });
+        return (0, backend_1.toAppendResult)(result);
+    }
+    async appendSourceEventByCaller(sourceId, input) {
+        const source = this.getSource(sourceId);
+        if (source.sourceType !== "local_event") {
+            throw new Error(`manual append is not supported for source type: ${source.sourceType}`);
+        }
+        return this.appendSourceEvent({ ...input, sourceId });
+    }
+    async appendFixtureEvent(sourceId, input) {
+        const source = this.getSource(sourceId);
+        if (source.sourceType !== "fixture") {
+            throw new Error(`fixtures/emit requires fixture source, received: ${source.sourceType}`);
+        }
+        return this.appendSourceEvent({ ...input, sourceId });
+    }
+    listInboxAgentIds() {
+        return this.store.listInboxes().map((inbox) => inbox.ownerAgentId);
+    }
+    getInboxDetailsByAgent(agentId) {
+        const inbox = this.ensureInboxForAgent(agentId);
+        return {
+            agent: this.getAgent(agentId),
+            inbox,
+            subscriptions: this.store.listSubscriptionsForAgent(agentId),
+            activationTargets: this.store.listActivationTargetsForAgent(agentId),
+            activationDispatchStates: this.store.listActivationDispatchStatesForAgent(agentId),
+            itemCounts: this.inboxCounts(agentId),
+        };
+    }
+    listInboxItems(agentId, options) {
+        return this.store.listInboxItems(this.ensureInboxForAgent(agentId).inboxId, options);
+    }
+    watchInbox(agentId, options, onEvent) {
+        const inbox = this.ensureInboxForAgent(agentId);
+        const pendingItems = [];
+        let started = false;
+        const emitItems = (items) => {
+            if (items.length === 0) {
+                return;
+            }
+            onEvent({
+                event: "items",
+                agentId,
+                items,
+            });
+        };
+        const watcher = {
+            onItems: (items) => {
+                if (!started) {
+                    pendingItems.push(...items);
+                    return;
+                }
+                emitItems(items);
+            },
+        };
+        let watchers = this.inboxWatchers.get(agentId);
+        if (!watchers) {
+            watchers = new Set();
+            this.inboxWatchers.set(agentId, watchers);
+        }
+        watchers.add(watcher);
+        let initialItems;
+        try {
+            initialItems = this.store.listInboxItems(inbox.inboxId, {
+                afterItemId: options.afterItemId,
+                includeAcked: options.includeAcked ?? false,
+            });
+        }
+        catch (error) {
+            watchers.delete(watcher);
+            if (watchers.size === 0) {
+                this.inboxWatchers.delete(agentId);
+            }
+            throw error;
+        }
+        const initialItemIds = new Set(initialItems.map((item) => item.itemId));
+        return {
+            initialItems,
+            start: () => {
+                if (started) {
+                    return;
+                }
+                started = true;
+                const replayItems = pendingItems.filter((item) => !initialItemIds.has(item.itemId));
+                pendingItems.length = 0;
+                emitItems(replayItems);
+            },
+            close: () => {
+                const activeWatchers = this.inboxWatchers.get(agentId);
+                if (!activeWatchers) {
+                    return;
+                }
+                activeWatchers.delete(watcher);
+                if (activeWatchers.size === 0) {
+                    this.inboxWatchers.delete(agentId);
+                }
+            },
+        };
+    }
+    ackInboxItems(agentId, itemIds) {
+        const inbox = this.ensureInboxForAgent(agentId);
+        const acked = this.store.ackItems(inbox.inboxId, itemIds, (0, util_1.nowIso)());
+        if (acked > 0) {
+            void this.handleInboxAckEffects(agentId);
+        }
+        return { acked };
+    }
+    ackInboxItemsThrough(agentId, itemId) {
+        const inbox = this.ensureInboxForAgent(agentId);
+        const acked = this.store.ackItemsThrough(inbox.inboxId, itemId, (0, util_1.nowIso)());
+        if (acked > 0) {
+            void this.handleInboxAckEffects(agentId);
+        }
+        return { acked };
+    }
+    ackAllInboxItems(agentId) {
+        const inbox = this.ensureInboxForAgent(agentId);
+        const itemIds = this.store.listInboxItems(inbox.inboxId, { includeAcked: false }).map((item) => item.itemId);
+        const acked = this.store.ackItems(inbox.inboxId, itemIds, (0, util_1.nowIso)());
+        if (acked > 0) {
+            void this.handleInboxAckEffects(agentId);
+        }
+        return { acked };
+    }
+    compactInbox(agentId) {
+        const inbox = this.ensureInboxForAgent(agentId);
+        return {
+            deleted: this.store.deleteAckedInboxItems(inbox.inboxId, retentionCutoffIso(this.ackedRetentionMs)),
+            retentionMs: this.ackedRetentionMs,
+        };
+    }
+    gcAckedInboxItems() {
+        return {
+            deleted: this.store.deleteAckedInboxItemsGlobal(retentionCutoffIso(this.ackedRetentionMs)),
+            retentionMs: this.ackedRetentionMs,
+        };
+    }
+    gc() {
+        const acked = this.gcAckedInboxItems();
+        const lifecycle = this.gcOfflineAgents();
+        return {
+            deleted: acked.deleted,
+            retentionMs: acked.retentionMs,
+            removedAgents: lifecycle.removedAgents,
+        };
+    }
+    async pollSource(sourceId) {
+        return this.adapters.pollSource(this.getSource(sourceId));
+    }
+    async pollSubscription(subscriptionId) {
+        if (this.inFlightSubscriptions.has(subscriptionId)) {
+            const subscription = this.getSubscription(subscriptionId);
+            return {
+                subscriptionId,
+                sourceId: subscription.sourceId,
+                eventsRead: 0,
+                matched: 0,
+                inboxItemsCreated: 0,
+                committedOffset: null,
+                note: "subscription poll already in flight",
+            };
+        }
+        this.inFlightSubscriptions.add(subscriptionId);
+        try {
+            const subscription = this.getSubscription(subscriptionId);
+            const source = this.getSource(subscription.sourceId);
+            const stream = await this.ensureStreamForSource(source);
+            const consumer = await this.backend.ensureConsumer({
+                streamId: stream.streamId,
+                subscriptionId: subscription.subscriptionId,
+                consumerKey: `subscription:${subscription.subscriptionId}`,
+                startPolicy: subscription.startPolicy,
+                startOffset: subscription.startOffset ?? null,
+                startTime: subscription.startTime ?? null,
+            });
+            const batch = await this.backend.read({
+                streamId: stream.streamId,
+                consumerId: consumer.consumerId,
+                limit: DEFAULT_SUBSCRIPTION_POLL_LIMIT,
+            });
+            const inbox = this.ensureInboxForAgent(subscription.agentId);
+            const targets = this.store.listActivationTargetsForAgent(subscription.agentId).filter((target) => target.status === "active");
+            let matched = 0;
+            let inboxItemsCreated = 0;
+            let lastProcessedOffset = null;
+            const insertedItems = [];
+            try {
+                for (const event of batch.events) {
+                    lastProcessedOffset = event.offset;
+                    const match = await (0, filter_1.matchSubscriptionFilter)(subscription.filter, {
+                        metadata: event.metadata,
+                        payload: event.rawPayload,
+                        eventVariant: event.eventVariant,
+                        sourceType: source.sourceType,
+                        sourceKey: source.sourceKey,
+                    });
+                    if (!match.matched) {
+                        continue;
+                    }
+                    matched += 1;
+                    const item = {
+                        itemId: (0, util_1.generateId)("item"),
+                        sourceId: event.sourceId,
+                        sourceNativeId: event.sourceNativeId,
+                        eventVariant: event.eventVariant,
+                        inboxId: inbox.inboxId,
+                        occurredAt: event.occurredAt,
+                        metadata: { ...event.metadata, matchReason: match.reason, agentId: subscription.agentId },
+                        rawPayload: event.rawPayload,
+                        deliveryHandle: event.deliveryHandle,
+                        ackedAt: null,
+                    };
+                    const inserted = this.store.insertInboxItem(item);
+                    if (!inserted) {
+                        continue;
+                    }
+                    inboxItemsCreated += 1;
+                    insertedItems.push(item);
+                    const activationItem = {
+                        itemId: item.itemId,
+                        sourceId: item.sourceId,
+                        sourceNativeId: item.sourceNativeId,
+                        eventVariant: item.eventVariant,
+                        inboxId: item.inboxId,
+                        occurredAt: item.occurredAt,
+                        metadata: item.metadata,
+                        rawPayload: item.rawPayload,
+                        deliveryHandle: item.deliveryHandle,
+                    };
+                    for (const target of targets) {
+                        this.enqueueActivationTarget(target, {
+                            agentId: subscription.agentId,
+                            subscriptionId: subscription.subscriptionId,
+                            sourceId: source.sourceId,
+                            summary: summarizeSourceEvent(source.sourceType, source.sourceKey, event.eventVariant),
+                            item: activationItem,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                if (insertedItems.length > 0) {
+                    this.notifyInboxWatchers(subscription.agentId, insertedItems);
+                }
+                if (lastProcessedOffset != null) {
+                    await this.backend.commit({
+                        consumerId: consumer.consumerId,
+                        committedOffset: lastProcessedOffset,
+                    });
+                }
+                throw error;
+            }
+            if (insertedItems.length > 0) {
+                this.notifyInboxWatchers(subscription.agentId, insertedItems);
+            }
+            if (lastProcessedOffset != null) {
+                await this.backend.commit({
+                    consumerId: consumer.consumerId,
+                    committedOffset: lastProcessedOffset,
+                });
+            }
+            return {
+                subscriptionId: subscription.subscriptionId,
+                sourceId: subscription.sourceId,
+                eventsRead: batch.events.length,
+                matched,
+                inboxItemsCreated,
+                committedOffset: lastProcessedOffset,
+                note: batch.events.length === 0 ? "no new stream events" : "subscription batch processed",
+            };
+        }
+        finally {
+            this.inFlightSubscriptions.delete(subscriptionId);
+        }
+    }
+    async sendDelivery(request) {
+        const handle = resolveDeliveryHandle(request);
+        const attempt = {
+            deliveryId: (0, util_1.generateId)("dlv"),
+            provider: handle.provider,
+            surface: handle.surface,
+            targetRef: handle.targetRef,
+            threadRef: handle.threadRef ?? null,
+            replyMode: handle.replyMode ?? null,
+            kind: request.kind,
+            payload: request.payload,
+            status: "accepted",
+            createdAt: (0, util_1.nowIso)(),
+        };
+        const adapter = this.adapters.deliveryAdapterFor(handle.provider);
+        const result = await adapter.send(request, attempt);
+        const storedAttempt = { ...attempt, status: result.status };
+        this.store.insertDelivery(storedAttempt);
+        return { ...storedAttempt, note: result.note };
+    }
+    status() {
+        return {
+            retention: {
+                ackedInboxItemsMs: this.ackedRetentionMs,
+                gcIntervalMs: DEFAULT_GC_INTERVAL_MS,
+                lastAckedInboxGcAt: this.lastAckedInboxGcAt > 0 ? new Date(this.lastAckedInboxGcAt).toISOString() : null,
+            },
+            counts: this.store.getCounts(),
+            agents: this.store.listAgents(),
+            sources: this.store.listSources(),
+            subscriptions: this.store.listSubscriptions(),
+            inboxes: this.store.listInboxes(),
+            activationTargets: this.store.listActivationTargets(),
+            activationDispatchStates: this.store.listActivationDispatchStates(),
+            streams: this.store.listStreams(),
+            consumers: this.store.listConsumers(),
+            adapters: this.adapters.status(),
+            recentActivations: this.store.listActivations().slice(0, 10),
+            recentDeliveries: this.store.listDeliveries().slice(0, 10),
+            lifecycle: {
+                offlineAgentTtlMs: DEFAULT_OFFLINE_AGENT_TTL_MS,
+                gcIntervalMs: DEFAULT_GC_INTERVAL_MS,
+                lastOfflineAgentGcAt: this.lastOfflineAgentGcAt > 0 ? new Date(this.lastOfflineAgentGcAt).toISOString() : null,
+            },
+        };
+    }
+    ensureInboxForAgent(agentId) {
+        const existing = this.store.getInboxByAgentId(agentId);
+        if (existing) {
+            return existing;
+        }
+        const inbox = {
+            inboxId: (0, backend_1.defaultInboxIdForAgent)(agentId),
+            ownerAgentId: agentId,
+            createdAt: (0, util_1.nowIso)(),
+        };
+        this.store.insertInbox(inbox);
+        return inbox;
+    }
+    inboxCounts(agentId) {
+        const inbox = this.ensureInboxForAgent(agentId);
+        const total = this.store.countInboxItems(inbox.inboxId, true);
+        const unacked = this.store.countInboxItems(inbox.inboxId, false);
+        return {
+            total,
+            unacked,
+            acked: total - unacked,
+        };
+    }
+    async runAckedInboxGcIfDue(force = false) {
+        const now = Date.now();
+        if (!force && now - this.lastAckedInboxGcAt < DEFAULT_GC_INTERVAL_MS) {
+            return;
+        }
+        this.lastAckedInboxGcAt = now;
+        this.gcAckedInboxItems();
+    }
+    async ensureStreamForSource(source) {
+        return this.backend.ensureStream({
+            sourceId: source.sourceId,
+            streamKey: (0, backend_1.streamKeyForSource)(source.sourceType, source.sourceKey),
+            backend: "sqlite",
+        });
+    }
+    notifyInboxWatchers(agentId, items) {
+        const watchers = this.inboxWatchers.get(agentId);
+        if (!watchers || watchers.size === 0) {
+            return;
+        }
+        for (const watcher of watchers) {
+            watcher.onItems(items);
+        }
+    }
+    handleAgentRegistrationConflicts(agentId, input) {
+        const currentTarget = findExistingTerminalActivationTarget(this.store, input);
+        if (currentTarget && currentTarget.agentId !== agentId) {
+            if (!input.forceRebind) {
+                throw new Error(`agent register conflict: current terminal target ${currentTarget.targetId} is already bound to agent ${currentTarget.agentId}; retry with forceRebind to rebind`);
+            }
+            this.store.deleteActivationTarget(currentTarget.agentId, currentTarget.targetId);
+            this.reconcileAgentStatus(currentTarget.agentId);
+        }
+        const conflictingTargets = this.store
+            .listActivationTargetsForAgent(agentId)
+            .filter((target) => target.kind === "terminal")
+            .filter((target) => !isSameTerminalIdentity(target, input));
+        if (conflictingTargets.length > 0 && !input.forceRebind) {
+            throw new Error(`agent register conflict: agent ${agentId} is already bound to terminal target ${conflictingTargets[0].targetId}; retry with forceRebind to rebind`);
+        }
+        if (input.forceRebind) {
+            for (const target of conflictingTargets) {
+                this.store.deleteActivationTarget(agentId, target.targetId);
+            }
+        }
+    }
+    upsertTerminalActivationTarget(agentId, input, now) {
+        const existing = findExistingTerminalActivationTarget(this.store, input);
+        if (existing) {
+            const target = this.store.updateTerminalActivationTargetHeartbeat(existing.targetId, {
+                runtimeKind: input.runtimeKind ?? "unknown",
+                runtimeSessionId: input.runtimeSessionId ?? null,
+                tmuxPaneId: input.tmuxPaneId ?? null,
+                tty: input.tty ?? null,
+                termProgram: input.termProgram ?? null,
+                itermSessionId: input.itermSessionId ?? null,
+                updatedAt: now,
+                lastSeenAt: now,
+            });
+            if (target.agentId !== agentId) {
+                throw new Error(`terminal target ${target.targetId} is already bound to agent ${target.agentId}`);
+            }
+            this.markAgentActive(agentId);
+            return target;
+        }
+        const target = {
+            targetId: (0, util_1.generateId)("tgt"),
+            agentId,
+            kind: "terminal",
+            status: "active",
+            offlineSince: null,
+            consecutiveFailures: 0,
+            lastDeliveredAt: null,
+            lastError: null,
+            mode: "agent_prompt",
+            notifyLeaseMs: input.notifyLeaseMs ?? DEFAULT_NOTIFY_LEASE_MS,
+            runtimeKind: input.runtimeKind ?? "unknown",
+            runtimeSessionId: input.runtimeSessionId ?? null,
+            backend: input.backend,
+            tmuxPaneId: input.tmuxPaneId ?? null,
+            tty: input.tty ?? null,
+            termProgram: input.termProgram ?? null,
+            itermSessionId: input.itermSessionId ?? null,
+            createdAt: now,
+            updatedAt: now,
+            lastSeenAt: now,
+        };
+        this.store.insertActivationTarget(target);
+        this.markAgentActive(agentId);
+        return target;
+    }
+    enqueueActivationTarget(target, input) {
+        const key = notificationBufferKey(target.agentId, target.targetId);
+        let buffer = this.notificationBuffers.get(key);
+        if (!buffer) {
+            buffer = {
+                agentId: target.agentId,
+                targetId: target.targetId,
+                pending: [],
+                timer: null,
+                inFlight: false,
+            };
+            this.notificationBuffers.set(key, buffer);
+        }
+        buffer.pending.push({
+            subscriptionId: input.subscriptionId,
+            sourceId: input.sourceId,
+            summary: input.summary,
+            item: input.item,
+        });
+        if (!buffer.timer && !buffer.inFlight) {
+            buffer.timer = setTimeout(() => {
+                void this.flushNotificationBuffer(key);
+            }, this.activationWindowMs);
+        }
+        if (buffer.pending.length >= this.activationMaxItems) {
+            if (buffer.timer) {
+                clearTimeout(buffer.timer);
+                buffer.timer = null;
+            }
+            void this.flushNotificationBuffer(key);
+        }
+    }
+    clearSubscriptionRuntimeState(subscription) {
+        for (const [key, buffer] of this.notificationBuffers.entries()) {
+            const retained = buffer.pending.filter((entry) => entry.subscriptionId !== subscription.subscriptionId);
+            if (retained.length === buffer.pending.length) {
+                continue;
+            }
+            buffer.pending = retained;
+            if (buffer.pending.length === 0) {
+                if (buffer.timer) {
+                    clearTimeout(buffer.timer);
+                    buffer.timer = null;
+                }
+                this.notificationBuffers.delete(key);
+            }
+        }
+        const remainingSubscriptions = this.store.listSubscriptionsForAgent(subscription.agentId);
+        const states = this.store.listActivationDispatchStatesForAgent(subscription.agentId);
+        for (const state of states) {
+            const directlyReferencesRemovedSubscription = state.pendingSubscriptionIds.includes(subscription.subscriptionId);
+            if (!directlyReferencesRemovedSubscription && remainingSubscriptions.length > 0) {
+                continue;
+            }
+            // Dispatch state is stored per target rather than per subscription.
+            // Drop states that still directly reference the removed subscription.
+            // If the agent has no subscriptions left, also clear any residual lease
+            // state so future subscriptions do not inherit a stale notified window.
+            this.store.deleteActivationDispatchState(state.agentId, state.targetId);
+        }
+    }
+    async flushAllPendingNotifications() {
+        const keys = Array.from(this.notificationBuffers.keys());
+        for (const key of keys) {
+            await this.flushNotificationBuffer(key);
+        }
+    }
+    async flushNotificationBuffer(key) {
+        const buffer = this.notificationBuffers.get(key);
+        if (!buffer || buffer.inFlight || buffer.pending.length === 0) {
+            return;
+        }
+        if (buffer.timer) {
+            clearTimeout(buffer.timer);
+            buffer.timer = null;
+        }
+        buffer.inFlight = true;
+        const entries = buffer.pending.splice(0, buffer.pending.length);
+        try {
+            const state = this.store.getActivationDispatchState(buffer.agentId, buffer.targetId);
+            if (!state) {
+                const dispatched = await this.dispatchActivationTarget({
+                    agentId: buffer.agentId,
+                    targetId: buffer.targetId,
+                    newItemCount: entries.length,
+                    summary: entries[0]?.summary ?? null,
+                    subscriptionIds: uniqueSorted(entries.map((entry) => entry.subscriptionId)),
+                    sourceIds: uniqueSorted(entries.map((entry) => entry.sourceId)),
+                    items: entries.map((entry) => entry.item),
+                });
+                if (dispatched === "retryable_failure") {
+                    this.upsertDirtyDispatchState(buffer.agentId, buffer.targetId, entries);
+                }
+            }
+            else {
+                this.store.upsertActivationDispatchState({
+                    agentId: buffer.agentId,
+                    targetId: buffer.targetId,
+                    status: "dirty",
+                    leaseExpiresAt: state.leaseExpiresAt,
+                    pendingNewItemCount: state.pendingNewItemCount + entries.length,
+                    pendingSummary: state.pendingSummary ?? entries[0]?.summary ?? null,
+                    pendingSubscriptionIds: uniqueSorted([...state.pendingSubscriptionIds, ...entries.map((entry) => entry.subscriptionId)]),
+                    pendingSourceIds: uniqueSorted([...state.pendingSourceIds, ...entries.map((entry) => entry.sourceId)]),
+                    updatedAt: (0, util_1.nowIso)(),
+                });
+            }
+            const hasPendingDuringFlight = buffer.pending.length > 0;
+            buffer.inFlight = false;
+            if (hasPendingDuringFlight) {
+                buffer.timer = setTimeout(() => {
+                    void this.flushNotificationBuffer(key);
+                }, this.activationWindowMs);
+                return;
+            }
+            this.notificationBuffers.delete(key);
+        }
+        catch (error) {
+            buffer.pending.unshift(...entries);
+            buffer.inFlight = false;
+            if (!this.stopping && !buffer.timer) {
+                buffer.timer = setTimeout(() => {
+                    void this.flushNotificationBuffer(key);
+                }, this.activationWindowMs);
+            }
+            throw error;
+        }
+    }
+    async handleInboxAckEffects(agentId) {
+        const states = this.store.listActivationDispatchStatesForAgent(agentId);
+        for (const state of states) {
+            await this.maybeDispatchActivationTarget(agentId, state.targetId, "ack");
+        }
+    }
+    async maybeDispatchActivationTarget(agentId, targetId, reason) {
+        const state = this.store.getActivationDispatchState(agentId, targetId);
+        if (!state) {
+            return;
+        }
+        const inbox = this.ensureInboxForAgent(agentId);
+        const unacked = this.store.countInboxItems(inbox.inboxId, false);
+        if (unacked === 0) {
+            this.store.deleteActivationDispatchState(agentId, targetId);
+            return;
+        }
+        if (reason === "ack" && state.status !== "dirty") {
+            return;
+        }
+        const dispatched = await this.dispatchActivationTarget({
+            agentId,
+            targetId,
+            newItemCount: state.pendingNewItemCount > 0 ? state.pendingNewItemCount : unacked,
+            summary: state.pendingSummary,
+            subscriptionIds: state.pendingSubscriptionIds,
+            sourceIds: state.pendingSourceIds,
+            items: this.store.listInboxItems(inbox.inboxId, { includeAcked: false }).map((item) => ({
+                itemId: item.itemId,
+                sourceId: item.sourceId,
+                sourceNativeId: item.sourceNativeId,
+                eventVariant: item.eventVariant,
+                inboxId: item.inboxId,
+                occurredAt: item.occurredAt,
+                metadata: item.metadata,
+                rawPayload: item.rawPayload,
+                deliveryHandle: item.deliveryHandle,
+            })),
+        });
+        if (dispatched === "offline") {
+            this.store.deleteActivationDispatchState(agentId, targetId);
+            return;
+        }
+        if (dispatched === "retryable_failure") {
+            this.store.upsertActivationDispatchState({
+                ...state,
+                status: "dirty",
+                leaseExpiresAt: new Date(Date.now() + DEFAULT_NOTIFY_RETRY_MS).toISOString(),
+                updatedAt: (0, util_1.nowIso)(),
+            });
+        }
+    }
+    async dispatchActivationTarget(input) {
+        const target = this.getActivationTarget(input.targetId);
+        if (target.status === "offline") {
+            return "offline";
+        }
+        const inbox = this.ensureInboxForAgent(input.agentId);
+        const summary = summarizeActivation(inbox.inboxId, input.newItemCount, input.summary);
+        try {
+            if (target.kind === "terminal") {
+                const prompt = (0, terminal_1.renderAgentPrompt)({
+                    inboxId: inbox.inboxId,
+                    newItemCount: input.newItemCount,
+                    summary: input.summary,
+                });
+                await this.terminalDispatcher.dispatch(target, prompt);
+            }
+            else {
+                const activation = {
+                    kind: "agentinbox.activation",
+                    activationId: (0, util_1.generateId)("act"),
+                    agentId: input.agentId,
+                    inboxId: inbox.inboxId,
+                    targetId: target.targetId,
+                    targetKind: target.kind,
+                    subscriptionIds: input.subscriptionIds,
+                    sourceIds: input.sourceIds,
+                    newItemCount: input.newItemCount,
+                    summary,
+                    items: target.mode === "activation_with_items" && input.items.length > 0 ? input.items : undefined,
+                    createdAt: (0, util_1.nowIso)(),
+                    deliveredAt: null,
+                };
+                await this.activationDispatcher.dispatch(target.url, activation);
+                this.store.insertActivation(activation);
+            }
+            this.markActivationTargetDelivered(target.targetId);
+            this.markAgentActive(input.agentId);
+            this.store.upsertActivationDispatchState({
+                agentId: input.agentId,
+                targetId: input.targetId,
+                status: "notified",
+                leaseExpiresAt: new Date(Date.now() + target.notifyLeaseMs).toISOString(),
+                pendingNewItemCount: 0,
+                pendingSummary: null,
+                pendingSubscriptionIds: [],
+                pendingSourceIds: [],
+                updatedAt: (0, util_1.nowIso)(),
+            });
+            return "dispatched";
+        }
+        catch (error) {
+            console.warn(`activation target dispatch failed for ${target.targetId}:`, error);
+            const message = error instanceof Error ? error.message : String(error);
+            if (target.kind === "terminal") {
+                const exists = await this.terminalDispatcher.probe(target);
+                if (!exists) {
+                    this.markActivationTargetOffline(target.targetId, message);
+                    this.reconcileAgentStatus(target.agentId);
+                    return "offline";
+                }
+            }
+            this.markActivationTargetDispatchFailure(target.targetId, message);
+            return "retryable_failure";
+        }
+    }
+    upsertDirtyDispatchState(agentId, targetId, entries) {
+        this.store.upsertActivationDispatchState({
+            agentId,
+            targetId,
+            status: "dirty",
+            leaseExpiresAt: new Date(Date.now() + DEFAULT_NOTIFY_RETRY_MS).toISOString(),
+            pendingNewItemCount: entries.length,
+            pendingSummary: entries[0]?.summary ?? null,
+            pendingSubscriptionIds: uniqueSorted(entries.map((entry) => entry.subscriptionId)),
+            pendingSourceIds: uniqueSorted(entries.map((entry) => entry.sourceId)),
+            updatedAt: (0, util_1.nowIso)(),
+        });
+    }
+    markActivationTargetDelivered(targetId) {
+        const now = (0, util_1.nowIso)();
+        this.store.updateActivationTargetRuntime(targetId, {
+            status: "active",
+            offlineSince: null,
+            consecutiveFailures: 0,
+            lastDeliveredAt: now,
+            lastError: null,
+            updatedAt: now,
+            lastSeenAt: now,
+        });
+    }
+    markActivationTargetDispatchFailure(targetId, message) {
+        const target = this.getActivationTarget(targetId);
+        this.store.updateActivationTargetRuntime(targetId, {
+            status: "active",
+            offlineSince: null,
+            consecutiveFailures: target.consecutiveFailures + 1,
+            lastError: message,
+            updatedAt: (0, util_1.nowIso)(),
+        });
+    }
+    markActivationTargetOffline(targetId, message) {
+        const now = (0, util_1.nowIso)();
+        const target = this.getActivationTarget(targetId);
+        this.store.updateActivationTargetRuntime(targetId, {
+            status: "offline",
+            offlineSince: target.offlineSince ?? now,
+            consecutiveFailures: target.consecutiveFailures + 1,
+            lastError: message,
+            updatedAt: now,
+        });
+    }
+    markAgentActive(agentId) {
+        const agent = this.getAgent(agentId);
+        if (agent.status === "active" && !agent.offlineSince) {
+            return;
+        }
+        const now = (0, util_1.nowIso)();
+        this.store.updateAgent(agentId, {
+            status: "active",
+            offlineSince: null,
+            runtimeKind: agent.runtimeKind,
+            runtimeSessionId: agent.runtimeSessionId ?? null,
+            updatedAt: now,
+            lastSeenAt: now,
+        });
+    }
+    reconcileAgentStatus(agentId) {
+        const agent = this.getAgent(agentId);
+        if (this.store.countActiveActivationTargetsForAgent(agentId) > 0) {
+            this.markAgentActive(agentId);
+            return;
+        }
+        const now = (0, util_1.nowIso)();
+        this.store.updateAgent(agentId, {
+            status: "offline",
+            offlineSince: agent.offlineSince ?? now,
+            runtimeKind: agent.runtimeKind,
+            runtimeSessionId: agent.runtimeSessionId ?? null,
+            updatedAt: now,
+            lastSeenAt: agent.lastSeenAt,
+        });
+    }
+    gcOfflineAgents(now = Date.now()) {
+        const cutoffIso = new Date(now - DEFAULT_OFFLINE_AGENT_TTL_MS).toISOString();
+        const agents = this.store.listOfflineAgentsOlderThan(cutoffIso);
+        for (const agent of agents) {
+            this.store.deleteAgent(agent.agentId, { persist: false });
+            this.notificationBuffers.forEach((buffer, key) => {
+                if (key.startsWith(`${agent.agentId}:`)) {
+                    if (buffer.timer) {
+                        clearTimeout(buffer.timer);
+                    }
+                    this.notificationBuffers.delete(key);
+                }
+            });
+            this.inboxWatchers.delete(agent.agentId);
+        }
+        if (agents.length > 0) {
+            this.store.save();
+        }
+        return { removedAgents: agents.length };
+    }
+    async syncAllSubscriptions() {
+        const subscriptions = this.store.listSubscriptions();
+        for (const subscription of subscriptions) {
+            try {
+                await this.pollSubscription(subscription.subscriptionId);
+            }
+            catch (error) {
+                console.warn(`subscription poll failed for ${subscription.subscriptionId}:`, error);
+            }
+        }
+    }
+    async syncActivationDispatchStates() {
+        const now = Date.now();
+        const states = this.store.listActivationDispatchStates();
+        for (const state of states) {
+            if (!state.leaseExpiresAt) {
+                continue;
+            }
+            const expiresAt = Date.parse(state.leaseExpiresAt);
+            if (Number.isNaN(expiresAt) || expiresAt > now) {
+                continue;
+            }
+            try {
+                await this.maybeDispatchActivationTarget(state.agentId, state.targetId, "lease");
+            }
+            catch (error) {
+                console.warn(`activation target lease sync failed for ${state.targetId}/${state.agentId}:`, error);
+            }
+        }
+    }
+    async syncLifecycleGc() {
+        const now = Date.now();
+        if (now - this.lastOfflineAgentGcAt < DEFAULT_GC_INTERVAL_MS) {
+            return;
+        }
+        this.lastOfflineAgentGcAt = now;
+        try {
+            this.gcOfflineAgents(now);
+        }
+        catch (error) {
+            console.warn("offline agent gc failed:", error);
+        }
+    }
+}
+exports.AgentInboxService = AgentInboxService;
+function retentionCutoffIso(retentionMs) {
+    return new Date(Date.now() - retentionMs).toISOString();
+}
+function resolveDeliveryHandle(request) {
+    if (request.deliveryHandle) {
+        return request.deliveryHandle;
+    }
+    if (!request.provider || !request.surface || !request.targetRef) {
+        throw new Error("delivery requires either deliveryHandle or provider/surface/targetRef");
+    }
+    return {
+        provider: request.provider,
+        surface: request.surface,
+        targetRef: request.targetRef,
+        threadRef: request.threadRef ?? null,
+        replyMode: request.replyMode ?? null,
+    };
+}
+class ActivationDispatcher {
+    async dispatch(targetUrl, activation) {
+        try {
+            const response = await fetch(targetUrl, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify(activation),
+            });
+            if (!response.ok) {
+                throw new Error(`activation dispatch failed for ${targetUrl}: ${response.status}`);
+            }
+        }
+        catch (error) {
+            console.warn(`activation dispatch error for ${targetUrl}:`, error);
+            throw error;
+        }
+    }
+}
+exports.ActivationDispatcher = ActivationDispatcher;
+function validateTerminalRegistration(input) {
+    if (input.backend === "tmux") {
+        if (!input.tmuxPaneId) {
+            throw new Error("tmux agent registration requires tmuxPaneId");
+        }
+        return;
+    }
+    if (input.backend === "iterm2") {
+        if (!input.itermSessionId && !input.tty) {
+            throw new Error("iterm2 agent registration requires itermSessionId or tty");
+        }
+        return;
+    }
+    throw new Error(`unsupported terminal backend: ${String(input.backend)}`);
+}
+function validateNotifyLeaseMs(value) {
+    if (value == null) {
+        return;
+    }
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error("notifyLeaseMs must be a positive integer");
+    }
+}
+function normalizeWebhookActivationMode(mode) {
+    const resolved = mode ?? "activation_only";
+    if (!WEBHOOK_ACTIVATION_MODES.has(resolved)) {
+        throw new Error(`unsupported activation mode: ${String(mode)}`);
+    }
+    return resolved;
+}
+function findExistingTerminalActivationTarget(store, input) {
+    if (input.runtimeSessionId) {
+        const target = store.getTerminalActivationTargetByRuntimeSession(input.runtimeKind ?? "unknown", input.runtimeSessionId);
+        if (target) {
+            return target;
+        }
+    }
+    if (input.backend === "tmux" && input.tmuxPaneId) {
+        return store.getTerminalActivationTargetByTmuxPaneId(input.tmuxPaneId);
+    }
+    if (input.backend === "iterm2") {
+        if (input.itermSessionId) {
+            return store.getTerminalActivationTargetByItermSessionId(input.itermSessionId);
+        }
+        if (input.tty) {
+            return store.getTerminalActivationTargetByTty(input.tty);
+        }
+    }
+    return null;
+}
+function isSameTerminalIdentity(target, input) {
+    if (input.runtimeSessionId && target.runtimeKind === (input.runtimeKind ?? "unknown") && target.runtimeSessionId === input.runtimeSessionId) {
+        return true;
+    }
+    if (input.backend === "tmux" && input.tmuxPaneId && target.backend === "tmux" && target.tmuxPaneId === input.tmuxPaneId) {
+        return true;
+    }
+    if (input.backend === "iterm2" && target.backend === "iterm2") {
+        if (input.itermSessionId && target.itermSessionId === input.itermSessionId) {
+            return true;
+        }
+        if (input.tty && target.tty === input.tty) {
+            return true;
+        }
+    }
+    return false;
+}
+function uniqueSorted(values) {
+    return Array.from(new Set(values)).sort();
+}
+function notificationBufferKey(agentId, targetId) {
+    return `${agentId}::${targetId}`;
+}
+function summarizeActivation(inboxId, newItemCount, firstSummary) {
+    const itemWord = newItemCount === 1 ? "item" : "items";
+    if (firstSummary) {
+        return `${newItemCount} new ${itemWord} in ${inboxId} from ${firstSummary}`;
+    }
+    return `${newItemCount} new ${itemWord} in ${inboxId}`;
+}
+function summarizeSourceEvent(sourceType, sourceKey, eventVariant) {
+    if (sourceType === "github_repo_ci") {
+        const parts = eventVariant.split(".");
+        const [, second, third, fourth] = parts;
+        const knownStatuses = new Set(["completed", "in_progress", "queued", "requested", "waiting", "pending", "observed"]);
+        const workflowName = second && !knownStatuses.has(second) ? second : null;
+        const status = workflowName ? third : second;
+        const conclusion = workflowName ? fourth : third;
+        const summaryParts = [`${sourceType}:${sourceKey}`];
+        if (workflowName) {
+            summaryParts.push(workflowName);
+        }
+        if (status) {
+            summaryParts.push(status);
+        }
+        if (conclusion) {
+            summaryParts.push(conclusion);
+        }
+        return summaryParts.join(":");
+    }
+    return `${sourceType}:${sourceKey}:${eventVariant}`;
+}