comisai 1.0.4

package/node_modules/@comis/daemon/dist/notification/session-tracker.js

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * SessionTracker: in-memory tracker of last-active session per agent per platform.
+ * Used by channel resolver's fallback chain (levels 2 and 4) to find the best
+ * channel for notification delivery when no explicit target is provided.
+ * State is ephemeral (resets on daemon restart). This is acceptable because
+ * the tracker is a fallback mechanism -- agents with configured primaryChannel
+ * never reach the session-based fallback levels.
+ * @module
+ */
+export function createSessionTracker(opts) {
+    const getNow = opts?.nowMs ?? Date.now;
+    // Map<agentId, Map<channelType, { channelId, lastActiveMs }>>
+    const tracker = new Map();
+    return {
+        recordActivity(agentId, channelType, channelId) {
+            let agentMap = tracker.get(agentId);
+            if (!agentMap) {
+                agentMap = new Map();
+                tracker.set(agentId, agentMap);
+            }
+            agentMap.set(channelType, { channelId, lastActiveMs: getNow() });
+        },
+        getRecentForPlatform(agentId, channelType) {
+            return tracker.get(agentId)?.get(channelType)?.channelId;
+        },
+        getMostRecent(agentId) {
+            const agentMap = tracker.get(agentId);
+            if (!agentMap || agentMap.size === 0)
+                return undefined;
+            let best;
+            for (const [channelType, entry] of agentMap) {
+                if (!best || entry.lastActiveMs > best.lastActiveMs) {
+                    best = { channelType, channelId: entry.channelId, lastActiveMs: entry.lastActiveMs };
+                }
+            }
+            return best ? { channelType: best.channelType, channelId: best.channelId } : undefined;
+        },
+    };
+}

package/node_modules/@comis/daemon/dist/observability/billing-estimator.d.ts

@@ -0,0 +1,63 @@
+import type { CostTracker } from "@comis/agent";
+/**
+ * Aggregated billing snapshot: total cost, token count, and call count.
+ */
+export interface BillingSnapshot {
+    totalCost: number;
+    totalTokens: number;
+    callCount: number;
+    totalCacheSaved?: number;
+}
+/**
+ * Per-provider billing with model-level breakdown.
+ */
+export interface ProviderBilling extends BillingSnapshot {
+    provider: string;
+    models: Array<{
+        model: string;
+        cost: number;
+        tokens: number;
+        calls: number;
+    }>;
+}
+/**
+ * Hourly token usage data point for sparkline charts.
+ */
+export interface TokenUsagePoint {
+    hour: number;
+    tokens: number;
+}
+/**
+ * BillingEstimator: thin aggregation layer over CostTracker.
+ * Provides formatted billing summaries per provider, per agent, and per session
+ * with time-windowed filtering. Delegates to CostTracker.getAll() on every
+ * query -- no local data cache.
+ */
+export interface BillingEstimator {
+    /** Per-provider breakdown with model-level detail, sorted by totalCost descending. */
+    byProvider(opts?: {
+        sinceMs?: number;
+    }): ProviderBilling[];
+    /** Billing snapshot for a specific agent. */
+    byAgent(agentId: string, opts?: {
+        sinceMs?: number;
+    }): BillingSnapshot;
+    /** Billing snapshot for a specific session. */
+    bySession(sessionKey: string, opts?: {
+        sinceMs?: number;
+    }): BillingSnapshot;
+    /** Overall billing totals. */
+    total(opts?: {
+        sinceMs?: number;
+    }): BillingSnapshot;
+    /** Token usage aggregated by hour for the last 24 hours. Returns 24 data points (hours 0-23). */
+    usage24h(): TokenUsagePoint[];
+}
+/**
+ * Create a BillingEstimator wrapping a CostTracker.
+ * Every query delegates to costTracker.getAll() with no local data cache,
+ * ensuring consistency when CostTracker is pruned.
+ */
+export declare function createBillingEstimator(deps: {
+    costTracker: CostTracker;
+}): BillingEstimator;

package/node_modules/@comis/daemon/dist/observability/billing-estimator.js

@@ -0,0 +1,98 @@
+/** Filter records to those within a time window. */
+function filterByTime(records, sinceMs) {
+    if (sinceMs === undefined)
+        return records;
+    const cutoff = Date.now() - sinceMs;
+    return records.filter((r) => r.timestamp >= cutoff);
+}
+/** Sum records into a BillingSnapshot. */
+function sumSnapshot(records) {
+    let totalCost = 0;
+    let totalTokens = 0;
+    for (const r of records) {
+        totalCost += r.cost.total;
+        totalTokens += r.tokens.total;
+    }
+    return { totalCost, totalTokens, callCount: records.length };
+}
+/**
+ * Create a BillingEstimator wrapping a CostTracker.
+ * Every query delegates to costTracker.getAll() with no local data cache,
+ * ensuring consistency when CostTracker is pruned.
+ */
+export function createBillingEstimator(deps) {
+    const { costTracker } = deps;
+    return {
+        byProvider(opts) {
+            const records = filterByTime(costTracker.getAll(), opts?.sinceMs);
+            // Group by provider, then by model within each provider
+            const providerMap = new Map();
+            for (const r of records) {
+                let entry = providerMap.get(r.provider);
+                if (!entry) {
+                    entry = {
+                        totalCost: 0,
+                        totalTokens: 0,
+                        callCount: 0,
+                        models: new Map(),
+                    };
+                    providerMap.set(r.provider, entry);
+                }
+                entry.totalCost += r.cost.total;
+                entry.totalTokens += r.tokens.total;
+                entry.callCount += 1;
+                let modelEntry = entry.models.get(r.model);
+                if (!modelEntry) {
+                    modelEntry = { cost: 0, tokens: 0, calls: 0 };
+                    entry.models.set(r.model, modelEntry);
+                }
+                modelEntry.cost += r.cost.total;
+                modelEntry.tokens += r.tokens.total;
+                modelEntry.calls += 1;
+            }
+            // Build ProviderBilling array sorted by totalCost descending
+            const result = [];
+            for (const [provider, data] of providerMap) {
+                const models = [];
+                for (const [model, mData] of data.models) {
+                    models.push({ model, cost: mData.cost, tokens: mData.tokens, calls: mData.calls });
+                }
+                result.push({
+                    provider,
+                    totalCost: data.totalCost,
+                    totalTokens: data.totalTokens,
+                    callCount: data.callCount,
+                    models,
+                });
+            }
+            result.sort((a, b) => b.totalCost - a.totalCost);
+            return result;
+        },
+        byAgent(agentId, opts) {
+            const records = filterByTime(costTracker.getAll(), opts?.sinceMs);
+            const filtered = records.filter((r) => r.agentId === agentId);
+            return sumSnapshot(filtered);
+        },
+        bySession(sessionKey, opts) {
+            const records = filterByTime(costTracker.getAll(), opts?.sinceMs);
+            const filtered = records.filter((r) => r.sessionKey === sessionKey);
+            return sumSnapshot(filtered);
+        },
+        total(opts) {
+            const records = filterByTime(costTracker.getAll(), opts?.sinceMs);
+            return sumSnapshot(records);
+        },
+        usage24h() {
+            const now = Date.now();
+            const cutoff = now - 24 * 60 * 60 * 1000;
+            const records = costTracker.getAll().filter((r) => r.timestamp >= cutoff);
+            // Bucket tokens by hour-of-day (0-23)
+            const buckets = new Array(24).fill(0);
+            for (const r of records) {
+                const hour = new Date(r.timestamp).getHours();
+                buckets[hour] += r.tokens.total;
+            }
+            return buckets.map((tokens, hour) => ({ hour, tokens }));
+        },
+    };
+}

package/node_modules/@comis/daemon/dist/observability/channel-activity-tracker.d.ts

@@ -0,0 +1,36 @@
+import type { TypedEventBus } from "@comis/core";
+/**
+ * Per-channel activity snapshot: timestamps, message counters, and channel type.
+ */
+export interface ChannelActivity {
+    channelId: string;
+    channelType: string;
+    lastActiveAt: number;
+    messagesSent: number;
+    messagesReceived: number;
+}
+/**
+ * ChannelActivityTracker: records per-channel last-active timestamps
+ * from EventBus message events for stale connection detection.
+ */
+export interface ChannelActivityTracker {
+    /** Get all tracked channels. */
+    getAll(): ChannelActivity[];
+    /** Get a specific channel by ID. */
+    get(channelId: string): ChannelActivity | undefined;
+    /** Get channels inactive beyond thresholdMs. */
+    getStale(thresholdMs: number): ChannelActivity[];
+    /** Manually record activity for a channel. */
+    recordActivity(channelId: string, channelType: string, direction: "sent" | "received"): void;
+    /** Clear all tracked activity. */
+    reset(): void;
+    /** Unsubscribe all EventBus listeners. */
+    dispose(): void;
+}
+/**
+ * Create a ChannelActivityTracker that subscribes to message:received
+ * and message:sent events, maintaining per-channel timestamps and counters.
+ */
+export declare function createChannelActivityTracker(deps: {
+    eventBus: TypedEventBus;
+}): ChannelActivityTracker;

package/node_modules/@comis/daemon/dist/observability/channel-activity-tracker.js

@@ -0,0 +1,97 @@
+/**
+ * Create a ChannelActivityTracker that subscribes to message:received
+ * and message:sent events, maintaining per-channel timestamps and counters.
+ */
+export function createChannelActivityTracker(deps) {
+    const { eventBus } = deps;
+    const channels = new Map();
+    const handlers = [];
+    function recordActivity(channelId, channelType, direction) {
+        const existing = channels.get(channelId);
+        if (existing) {
+            existing.lastActiveAt = Date.now();
+            if (channelType !== "unknown") {
+                existing.channelType = channelType;
+            }
+            if (direction === "sent") {
+                existing.sent++;
+            }
+            else {
+                existing.received++;
+            }
+        }
+        else {
+            channels.set(channelId, {
+                channelType,
+                lastActiveAt: Date.now(),
+                sent: direction === "sent" ? 1 : 0,
+                received: direction === "received" ? 1 : 0,
+            });
+        }
+    }
+    function toActivity(channelId, entry) {
+        return {
+            channelId,
+            channelType: entry.channelType,
+            lastActiveAt: entry.lastActiveAt,
+            messagesSent: entry.sent,
+            messagesReceived: entry.received,
+        };
+    }
+    // Subscribe to message:received -- extract channelId and channelType from NormalizedMessage
+    const receivedHandler = ((payload) => {
+        const { message } = payload;
+        recordActivity(message.channelId, message.channelType ?? "unknown", "received");
+    });
+    eventBus.on("message:received", receivedHandler);
+    handlers.push({
+        event: "message:received",
+        handler: receivedHandler,
+    });
+    // Subscribe to message:sent -- channelType is not in the sent event payload
+    const sentHandler = ((payload) => {
+        const existing = channels.get(payload.channelId);
+        const channelType = existing?.channelType ?? "unknown";
+        recordActivity(payload.channelId, channelType, "sent");
+    });
+    eventBus.on("message:sent", sentHandler);
+    handlers.push({
+        event: "message:sent",
+        handler: sentHandler,
+    });
+    return {
+        getAll() {
+            const result = [];
+            for (const [channelId, entry] of channels) {
+                result.push(toActivity(channelId, entry));
+            }
+            return result;
+        },
+        get(channelId) {
+            const entry = channels.get(channelId);
+            if (!entry)
+                return undefined;
+            return toActivity(channelId, entry);
+        },
+        getStale(thresholdMs) {
+            const cutoff = Date.now() - thresholdMs;
+            const result = [];
+            for (const [channelId, entry] of channels) {
+                if (entry.lastActiveAt < cutoff) {
+                    result.push(toActivity(channelId, entry));
+                }
+            }
+            return result;
+        },
+        recordActivity,
+        reset() {
+            channels.clear();
+        },
+        dispose() {
+            for (const ref of handlers) {
+                eventBus.off(ref.event, ref.handler);
+            }
+            handlers.length = 0;
+        },
+    };
+}

package/node_modules/@comis/daemon/dist/observability/channel-health-logger.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Channel health observability: structured logging subscriber for health
+ * state transition and health check events.
+ * Subscribes to channel:health_changed and channel:health_check events
+ * and logs with canonical fields per the project logging rules.
+ * Logging levels follow the boundary-event convention:
+ * - WARN for problematic state transitions: disconnected, errored, stale,
+ *   stuck, unknown. WARN events include hint and errorKind as required.
+ * - INFO for recovery/normal transitions: healthy, startup-grace, idle.
+ * - DEBUG for per-poll health checks (N times per poll cycle, not boundary).
+ * Channel Health Monitoring.
+ * @module
+ */
+import type { TypedEventBus } from "@comis/core";
+import type { ComisLogger } from "@comis/infra";
+export interface ChannelHealthLoggerDeps {
+    eventBus: TypedEventBus;
+    logger: ComisLogger;
+}
+/**
+ * Subscribe to channel health events and log with canonical fields.
+ * @param deps.eventBus - TypedEventBus to subscribe to
+ * @param deps.logger - Pino logger instance (module field set per-call)
+ */
+export declare function setupChannelHealthLogging(deps: ChannelHealthLoggerDeps): void;

package/node_modules/@comis/daemon/dist/observability/channel-health-logger.js

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Channel health observability: structured logging subscriber for health
+ * state transition and health check events.
+ * Subscribes to channel:health_changed and channel:health_check events
+ * and logs with canonical fields per the project logging rules.
+ * Logging levels follow the boundary-event convention:
+ * - WARN for problematic state transitions: disconnected, errored, stale,
+ *   stuck, unknown. WARN events include hint and errorKind as required.
+ * - INFO for recovery/normal transitions: healthy, startup-grace, idle.
+ * - DEBUG for per-poll health checks (N times per poll cycle, not boundary).
+ * Channel Health Monitoring.
+ * @module
+ */
+/** States considered problematic -- logged at WARN with hint + errorKind. */
+const PROBLEMATIC_STATES = new Set(["disconnected", "errored", "stale", "stuck", "unknown"]);
+/** Actionable hints per problematic state. */
+const HINT_MAP = {
+    disconnected: "Check adapter credentials and network connectivity",
+    errored: "Adapter reports error. Check adapter logs for root cause",
+    stale: "No activity detected beyond stale threshold. Adapter may be silently disconnected",
+    stuck: "Active run exceeded stuck threshold. Check for hung agent execution",
+    unknown: "getStatus() unavailable or failing. Adapter may not implement health reporting",
+};
+/** Error classification per problematic state. */
+const ERROR_KIND_MAP = {
+    disconnected: "connection",
+    errored: "adapter",
+    stale: "timeout",
+    stuck: "timeout",
+    unknown: "internal",
+};
+const MODULE = "channel-health";
+/**
+ * Subscribe to channel health events and log with canonical fields.
+ * @param deps.eventBus - TypedEventBus to subscribe to
+ * @param deps.logger - Pino logger instance (module field set per-call)
+ */
+export function setupChannelHealthLogging(deps) {
+    const { eventBus, logger } = deps;
+    // State transitions -- WARN for problematic, INFO for recovery/normal
+    eventBus.on("channel:health_changed", (event) => {
+        const { channelType, previousState, currentState, connectionMode, error, lastMessageAt } = event;
+        if (PROBLEMATIC_STATES.has(currentState)) {
+            // Build hint: for "errored", append the error message if available
+            const baseHint = HINT_MAP[currentState] ?? "Check adapter health";
+            const hint = currentState === "errored" && error
+                ? `${baseHint}: ${error}`
+                : baseHint;
+            logger.warn({
+                channelType,
+                previousState,
+                currentState,
+                connectionMode,
+                err: error ? { message: error } : undefined,
+                lastMessageAt,
+                hint,
+                errorKind: ERROR_KIND_MAP[currentState] ?? "internal",
+                module: MODULE,
+            }, "Channel health degraded: %s -> %s", previousState, currentState);
+        }
+        else {
+            // Recovery or normal transitions (e.g., startup-grace -> healthy, idle -> healthy)
+            logger.info({
+                channelType,
+                previousState,
+                currentState,
+                connectionMode,
+                module: MODULE,
+            }, "Channel health changed: %s -> %s", previousState, currentState);
+        }
+    });
+    // Per-poll health checks -- DEBUG level (N times per poll cycle)
+    eventBus.on("channel:health_check", (event) => {
+        logger.debug({
+            channelType: event.channelType,
+            state: event.state,
+            responseTimeMs: event.responseTimeMs,
+            module: MODULE,
+        }, "Health check: %s = %s", event.channelType, event.state);
+    });
+}

package/node_modules/@comis/daemon/dist/observability/context-pipeline-collector.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Context pipeline collector: subscribes to context:pipeline and context:dag_compacted
+ * events and maintains queryable ring buffers for downstream RPC handlers.
+ * Follows the DiagnosticCollector pattern (ring buffer, HandlerRef cleanup, factory function).
+ * Context Engine observability data pipeline.
+ * @module
+ */
+import type { TypedEventBus } from "@comis/core";
+import type { ComisLogger } from "@comis/infra";
+/** Snapshot of a single context:pipeline event, stored in the ring buffer. */
+export interface PipelineSnapshot {
+    readonly agentId: string;
+    readonly sessionKey: string;
+    readonly tokensLoaded: number;
+    readonly tokensEvicted: number;
+    readonly tokensMasked: number;
+    readonly tokensCompacted: number;
+    readonly thinkingBlocksRemoved: number;
+    readonly budgetUtilization: number;
+    readonly evictionCategories: Record<string, number>;
+    readonly cacheHitTokens: number;
+    readonly cacheWriteTokens: number;
+    readonly cacheMissTokens: number;
+    readonly durationMs: number;
+    readonly layerCount: number;
+    readonly layers: Array<{
+        name: string;
+        durationMs: number;
+        messagesIn: number;
+        messagesOut: number;
+    }>;
+    readonly timestamp: number;
+}
+/** Snapshot of a single context:dag_compacted event, stored in the ring buffer. */
+export interface DagCompactionSnapshot {
+    readonly agentId: string;
+    readonly sessionKey: string;
+    readonly leafSummariesCreated: number;
+    readonly condensedSummariesCreated: number;
+    readonly maxDepthReached: number;
+    readonly totalSummariesCreated: number;
+    readonly durationMs: number;
+    readonly timestamp: number;
+}
+/** Filter options for querying recent pipeline/DAG snapshots. */
+export interface PipelineQueryOpts {
+    agentId?: string;
+    limit?: number;
+}
+/**
+ * ContextPipelineCollector: subscribes to context:pipeline and context:dag_compacted
+ * events and stores them in bounded ring buffers for RPC queries.
+ */
+export interface ContextPipelineCollector {
+    /** Get recent pipeline snapshots, optionally filtered by agentId and limited. */
+    getRecentPipelines(opts?: PipelineQueryOpts): PipelineSnapshot[];
+    /** Get recent DAG compaction snapshots, optionally filtered by agentId and limited. */
+    getRecentDagCompactions(opts?: PipelineQueryOpts): DagCompactionSnapshot[];
+    /** Clear both ring buffers. */
+    reset(): void;
+    /** Unsubscribe all EventBus handlers. */
+    dispose(): void;
+}
+/**
+ * Create a ContextPipelineCollector that subscribes to EventBus context events
+ * and stores snapshots in bounded ring buffers.
+ */
+export declare function createContextPipelineCollector(deps: {
+    eventBus: TypedEventBus;
+    maxPipelineEvents?: number;
+    maxDagEvents?: number;
+    logger?: ComisLogger;
+}): ContextPipelineCollector;

package/node_modules/@comis/daemon/dist/observability/context-pipeline-collector.js

@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Context pipeline collector: subscribes to context:pipeline and context:dag_compacted
+ * events and maintains queryable ring buffers for downstream RPC handlers.
+ * Follows the DiagnosticCollector pattern (ring buffer, HandlerRef cleanup, factory function).
+ * Context Engine observability data pipeline.
+ * @module
+ */
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * Create a ContextPipelineCollector that subscribes to EventBus context events
+ * and stores snapshots in bounded ring buffers.
+ */
+export function createContextPipelineCollector(deps) {
+    const { eventBus, maxPipelineEvents = 200, maxDagEvents = 100, logger } = deps;
+    const pipelines = [];
+    const dagCompactions = [];
+    const handlers = [];
+    // Subscribe to context:pipeline
+    const pipelineHandler = ((payload) => {
+        const snapshot = {
+            agentId: payload.agentId,
+            sessionKey: payload.sessionKey,
+            tokensLoaded: payload.tokensLoaded,
+            tokensEvicted: payload.tokensEvicted,
+            tokensMasked: payload.tokensMasked,
+            tokensCompacted: payload.tokensCompacted,
+            thinkingBlocksRemoved: payload.thinkingBlocksRemoved,
+            budgetUtilization: payload.budgetUtilization,
+            evictionCategories: payload.evictionCategories,
+            cacheHitTokens: payload.cacheHitTokens,
+            cacheWriteTokens: payload.cacheWriteTokens,
+            cacheMissTokens: payload.cacheMissTokens,
+            durationMs: payload.durationMs,
+            layerCount: payload.layerCount,
+            layers: payload.layers,
+            timestamp: payload.timestamp,
+        };
+        pipelines.push(snapshot);
+        if (pipelines.length > maxPipelineEvents) {
+            pipelines.splice(0, pipelines.length - maxPipelineEvents);
+        }
+    });
+    eventBus.on("context:pipeline", pipelineHandler);
+    handlers.push({
+        event: "context:pipeline",
+        handler: pipelineHandler,
+    });
+    // Subscribe to context:pipeline:cache -- merge actual cache data into most recent snapshot
+    // Timing fix: pre-LLM event has zeros; this patches real data from the post-LLM event
+    const cacheHandler = ((payload) => {
+        // Find the most recent pipeline snapshot for this agent+session to merge into.
+        // Walk backward since the pre-LLM event was just pushed.
+        for (let i = pipelines.length - 1; i >= 0; i--) {
+            const snap = pipelines[i];
+            if (snap.agentId === payload.agentId && snap.sessionKey === payload.sessionKey) {
+                // Merge cache data into the existing snapshot.
+                // PipelineSnapshot fields are readonly, so we cast for mutation.
+                const mutable = snap;
+                mutable.cacheHitTokens = payload.cacheHitTokens;
+                mutable.cacheWriteTokens = payload.cacheWriteTokens;
+                mutable.cacheMissTokens = payload.cacheMissTokens;
+                logger?.debug({
+                    agentId: payload.agentId,
+                    sessionKey: payload.sessionKey,
+                    cacheHitTokens: payload.cacheHitTokens,
+                    cacheWriteTokens: payload.cacheWriteTokens,
+                    cacheMissTokens: payload.cacheMissTokens,
+                }, "Context pipeline cache merged");
+                break;
+            }
+        }
+    });
+    eventBus.on("context:pipeline:cache", cacheHandler);
+    handlers.push({
+        event: "context:pipeline:cache",
+        handler: cacheHandler,
+    });
+    // Subscribe to context:dag_compacted
+    const dagHandler = ((payload) => {
+        const snapshot = {
+            agentId: payload.agentId,
+            sessionKey: payload.sessionKey,
+            leafSummariesCreated: payload.leafSummariesCreated,
+            condensedSummariesCreated: payload.condensedSummariesCreated,
+            maxDepthReached: payload.maxDepthReached,
+            totalSummariesCreated: payload.totalSummariesCreated,
+            durationMs: payload.durationMs,
+            timestamp: payload.timestamp,
+        };
+        dagCompactions.push(snapshot);
+        if (dagCompactions.length > maxDagEvents) {
+            dagCompactions.splice(0, dagCompactions.length - maxDagEvents);
+        }
+    });
+    eventBus.on("context:dag_compacted", dagHandler);
+    handlers.push({
+        event: "context:dag_compacted",
+        handler: dagHandler,
+    });
+    return {
+        getRecentPipelines(opts = {}) {
+            const { agentId, limit = 50 } = opts;
+            let filtered = pipelines;
+            if (agentId !== undefined) {
+                filtered = filtered.filter((s) => s.agentId === agentId);
+            }
+            // Return last N entries, newest first
+            return filtered.slice(-limit).reverse();
+        },
+        getRecentDagCompactions(opts = {}) {
+            const { agentId, limit = 50 } = opts;
+            let filtered = dagCompactions;
+            if (agentId !== undefined) {
+                filtered = filtered.filter((s) => s.agentId === agentId);
+            }
+            return filtered.slice(-limit).reverse();
+        },
+        reset() {
+            pipelines.length = 0;
+            dagCompactions.length = 0;
+        },
+        dispose() {
+            for (const ref of handlers) {
+                eventBus.off(ref.event, ref.handler);
+            }
+            handlers.length = 0;
+        },
+    };
+}