aegis-bridge 0.1.0

package/dist/memory-bridge.d.ts

@@ -0,0 +1,27 @@
+interface MemoryEntry {
+    value: string;
+    namespace: string;
+    key: string;
+    created_at: number;
+    updated_at: number;
+    expires_at?: number;
+}
+export declare class MemoryBridge {
+    private reaperIntervalMs;
+    private store;
+    private persistPath;
+    private reaperTimer;
+    private saveTimer;
+    constructor(persistPath?: string | null, reaperIntervalMs?: number);
+    set(key: string, value: string, ttlSeconds?: number): MemoryEntry;
+    get(key: string): MemoryEntry | null;
+    delete(key: string): boolean;
+    list(prefix?: string): MemoryEntry[];
+    resolveKeys(keys: string[]): Map<string, string>;
+    load(): Promise<void>;
+    save(): Promise<void>;
+    private scheduleSave;
+    startReaper(): void;
+    stopReaper(): void;
+}
+export {};

package/dist/memory-bridge.js

@@ -0,0 +1,137 @@
+import { existsSync, renameSync, writeFileSync, readFileSync } from "fs";
+import { safeJsonParse } from './safe-json.js';
+function isMemoryEntry(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const entry = value;
+    if (typeof entry.key !== 'string')
+        return false;
+    if (typeof entry.value !== 'string')
+        return false;
+    if (typeof entry.namespace !== 'string')
+        return false;
+    if (typeof entry.created_at !== 'number')
+        return false;
+    if (typeof entry.updated_at !== 'number')
+        return false;
+    if (entry.expires_at !== undefined && typeof entry.expires_at !== 'number')
+        return false;
+    return true;
+}
+const KEY_REGEX = /^(.+?)\/(.+)$/;
+const MAX_KEY_LEN = 256;
+const MAX_VALUE_SIZE = 100 * 1024; // 100KB
+export class MemoryBridge {
+    reaperIntervalMs;
+    store = new Map();
+    persistPath = null;
+    reaperTimer = null;
+    saveTimer = null;
+    constructor(persistPath = null, reaperIntervalMs = 60_000) {
+        this.reaperIntervalMs = reaperIntervalMs;
+        this.persistPath = persistPath;
+    }
+    set(key, value, ttlSeconds) {
+        if (value.length > MAX_VALUE_SIZE)
+            throw new Error("Value exceeds maximum size");
+        const m = KEY_REGEX.exec(key);
+        if (!m)
+            throw new Error(`Invalid key format: must be namespace/key, got "${key}"`);
+        const [, namespace, keyName] = m;
+        if (key.length > MAX_KEY_LEN)
+            throw new Error("Key exceeds maximum length");
+        const now = Date.now();
+        const entry = {
+            value, namespace, key,
+            created_at: this.store.has(key) ? this.store.get(key).created_at : now,
+            updated_at: now,
+            expires_at: ttlSeconds ? now + ttlSeconds * 1000 : undefined,
+        };
+        this.store.set(key, entry);
+        this.scheduleSave();
+        return entry;
+    }
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return null;
+        if (entry.expires_at && Date.now() > entry.expires_at) {
+            this.store.delete(key);
+            return null;
+        }
+        return entry;
+    }
+    delete(key) {
+        const deleted = this.store.delete(key);
+        if (deleted)
+            this.scheduleSave();
+        return deleted;
+    }
+    list(prefix) {
+        const now = Date.now();
+        const entries = [...this.store.values()].filter(e => !e.expires_at || now <= e.expires_at);
+        if (!prefix)
+            return entries;
+        return entries.filter(e => e.key.startsWith(prefix));
+    }
+    resolveKeys(keys) {
+        const result = new Map();
+        for (const k of keys) {
+            const e = this.get(k);
+            if (e)
+                result.set(k, e.value);
+        }
+        return result;
+    }
+    async load() {
+        if (!this.persistPath || !existsSync(this.persistPath))
+            return;
+        const parsed = safeJsonParse(readFileSync(this.persistPath, 'utf-8'), 'Memory bridge store');
+        if (!parsed.ok)
+            return;
+        if (!Array.isArray(parsed.data))
+            return;
+        for (const rawEntry of parsed.data) {
+            if (!isMemoryEntry(rawEntry))
+                continue;
+            this.store.set(rawEntry.key, rawEntry);
+        }
+    }
+    async save() {
+        if (!this.persistPath)
+            return;
+        const entries = [...this.store.values()];
+        const tmp = this.persistPath + ".tmp";
+        writeFileSync(tmp, JSON.stringify(entries, null, 2));
+        renameSync(tmp, this.persistPath);
+    }
+    scheduleSave() {
+        if (this.saveTimer)
+            return;
+        this.saveTimer = setTimeout(async () => {
+            this.saveTimer = null;
+            await this.save();
+        }, 1000);
+    }
+    startReaper() {
+        if (this.reaperTimer)
+            return;
+        this.reaperTimer = setInterval(() => {
+            const now = Date.now();
+            for (const [k, e] of this.store) {
+                if (e.expires_at && now > e.expires_at)
+                    this.store.delete(k);
+            }
+        }, this.reaperIntervalMs);
+    }
+    stopReaper() {
+        if (this.reaperTimer) {
+            clearInterval(this.reaperTimer);
+            this.reaperTimer = null;
+        }
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = null;
+        }
+    }
+}

package/dist/memory-routes.d.ts

@@ -0,0 +1,3 @@
+import { FastifyInstance } from 'fastify';
+import { MemoryBridge } from './memory-bridge.js';
+export declare function registerMemoryRoutes(app: FastifyInstance, bridge: MemoryBridge): void;

package/dist/memory-routes.js

@@ -0,0 +1,100 @@
+import { isValidUUID } from './validation.js';
+import { z } from 'zod';
+const setMemorySchema = z.object({
+    key: z.string().max(256),
+    value: z.string().max(100 * 1024),
+    ttlSeconds: z.number().int().positive().max(86400 * 30).optional(),
+}).strict();
+const getMemorySchema = z.object({
+    prefix: z.string().optional(),
+});
+export function registerMemoryRoutes(app, bridge) {
+    // POST /v1/memory — write a memory entry
+    app.post('/v1/memory', async (req, reply) => {
+        const parsed = setMemorySchema.safeParse(req.body ?? {});
+        if (!parsed.success) {
+            return reply.status(400).send({ error: 'Invalid request body', details: parsed.error.issues });
+        }
+        const { key, value, ttlSeconds } = parsed.data;
+        try {
+            const entry = bridge.set(key, value, ttlSeconds);
+            return { ok: true, entry };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            if (msg.includes('Invalid key format'))
+                return reply.status(400).send({ error: msg });
+            if (msg.includes('exceeds maximum size'))
+                return reply.status(413).send({ error: msg });
+            throw e;
+        }
+    });
+    // GET /v1/memory/:key — read a memory entry
+    app.get('/v1/memory/:key', async (req, reply) => {
+        const key = decodeURIComponent(req.params.key);
+        const entry = bridge.get(key);
+        if (!entry)
+            return reply.status(404).send({ error: `Key not found: ${key}` });
+        return { entry };
+    });
+    // GET /v1/memory — list entries, optionally filtered by prefix
+    app.get('/v1/memory', async (req, reply) => {
+        const { prefix } = req.query;
+        const entries = bridge.list(prefix);
+        return { entries };
+    });
+    // DELETE /v1/memory/:key — delete a memory entry
+    app.delete('/v1/memory/:key', async (req, reply) => {
+        const key = decodeURIComponent(req.params.key);
+        const deleted = bridge.delete(key);
+        if (!deleted)
+            return reply.status(404).send({ error: `Key not found: ${key}` });
+        return { ok: true };
+    });
+    // Issue #705: Scoped memory retrieval — GET /v1/memories?scope=project|user|team
+    const VALID_SCOPES = new Set(['project', 'user', 'team']);
+    app.get('/v1/memories', async (req, reply) => {
+        const { scope } = req.query;
+        if (!scope || !VALID_SCOPES.has(scope)) {
+            return reply.status(400).send({ error: 'scope must be one of: project, user, team' });
+        }
+        const entries = bridge.list(`${scope}/`);
+        return { scope, entries };
+    });
+    // Issue #705: Session-linked memories — POST /v1/sessions/:id/memories
+    const sessionMemoryWriteSchema = z.object({
+        key: z.string().min(1).max(200),
+        value: z.string().max(100 * 1024),
+        ttlSeconds: z.number().int().positive().max(86400 * 30).optional(),
+    }).strict();
+    app.post('/v1/sessions/:id/memories', async (req, reply) => {
+        const { id } = req.params;
+        if (!isValidUUID(id))
+            return reply.status(400).send({ error: 'Invalid session ID — must be a UUID' });
+        const parsed = sessionMemoryWriteSchema.safeParse(req.body ?? {});
+        if (!parsed.success)
+            return reply.status(400).send({ error: 'Invalid body', details: parsed.error.issues });
+        const { key, value, ttlSeconds } = parsed.data;
+        const fullKey = `session:${id}/${key}`;
+        try {
+            const entry = bridge.set(fullKey, value, ttlSeconds);
+            return { ok: true, entry };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            if (msg.includes('Invalid key format'))
+                return reply.status(400).send({ error: msg });
+            if (msg.includes('exceeds maximum size'))
+                return reply.status(413).send({ error: msg });
+            throw e;
+        }
+    });
+    // Issue #705: Session-linked memories — GET /v1/sessions/:id/memories
+    app.get('/v1/sessions/:id/memories', async (req, reply) => {
+        const { id } = req.params;
+        if (!isValidUUID(id))
+            return reply.status(400).send({ error: 'Invalid session ID — must be a UUID' });
+        const entries = bridge.list(`session:${id}/`);
+        return { sessionId: id, entries };
+    });
+}

package/dist/metrics.d.ts

@@ -0,0 +1,126 @@
+/**
+ * metrics.ts — Usage metrics and counters.
+ *
+ * Issue #40: Global and per-session metrics for monitoring.
+ * Counters are in-memory, persisted to disk on shutdown, loaded on startup.
+ */
+import type { GlobalMetrics as GlobalMetricsResponse } from './api-contracts.js';
+import type { TokenUsageDelta } from './transcript.js';
+export interface GlobalMetrics {
+    sessionsCreated: number;
+    sessionsCompleted: number;
+    sessionsFailed: number;
+    totalMessages: number;
+    totalToolCalls: number;
+    autoApprovals: number;
+    webhooksSent: number;
+    webhooksFailed: number;
+    screenshotsTaken: number;
+    pipelinesCreated: number;
+    batchesCreated: number;
+    promptsSent: number;
+    promptsDelivered: number;
+    promptsFailed: number;
+}
+/** Issue #488: Cumulative token usage + estimated cost for a session. */
+export interface SessionTokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationTokens: number;
+    cacheReadTokens: number;
+    estimatedCostUsd: number;
+}
+export interface SessionMetrics {
+    durationSec: number;
+    messages: number;
+    toolCalls: number;
+    approvals: number;
+    autoApprovals: number;
+    statusChanges: string[];
+    /** Issue #488: Cumulative token usage and estimated cost. Present once tokens are first observed. */
+    tokenUsage?: SessionTokenUsage;
+}
+/** Issue #87: Per-session latency samples (rolling window). */
+export interface SessionLatency {
+    hook_latency_ms: number[];
+    state_change_detection_ms: number[];
+    permission_response_ms: number[];
+    channel_delivery_ms: number[];
+}
+/** Issue #87: Aggregated latency summary for a session. */
+export interface SessionLatencySummary {
+    hook_latency_ms: {
+        min: number | null;
+        max: number | null;
+        avg: number | null;
+        count: number;
+    };
+    state_change_detection_ms: {
+        min: number | null;
+        max: number | null;
+        avg: number | null;
+        count: number;
+    };
+    permission_response_ms: {
+        min: number | null;
+        max: number | null;
+        avg: number | null;
+        count: number;
+    };
+    channel_delivery_ms: {
+        min: number | null;
+        max: number | null;
+        avg: number | null;
+        count: number;
+    };
+}
+export declare class MetricsCollector {
+    private metricsFile;
+    private global;
+    private perSession;
+    private latency;
+    private startTime;
+    /** Maximum samples per latency type per session (rolling window). */
+    static readonly MAX_LATENCY_SAMPLES = 100;
+    /**
+     * Issue #488: Cost per million tokens by model family.
+     * Rates: [input $/M, output $/M, cacheWrite $/M, cacheRead $/M].
+     */
+    private static readonly COST_TABLE;
+    private static estimateCost;
+    constructor(metricsFile: string);
+    load(): Promise<void>;
+    save(): Promise<void>;
+    sessionCreated(sessionId: string): void;
+    sessionCompleted(sessionId: string): void;
+    sessionFailed(sessionId: string): void;
+    messageReceived(sessionId: string): void;
+    toolCallReceived(sessionId: string): void;
+    approvalGranted(sessionId: string, auto?: boolean): void;
+    statusChanged(sessionId: string, status: string): void;
+    webhookSent(): void;
+    webhookFailed(): void;
+    screenshotTaken(): void;
+    pipelineCreated(): void;
+    batchCreated(): void;
+    promptSent(delivered: boolean): void;
+    /** Issue #488: Accumulate token usage for a session. */
+    recordTokenUsage(sessionId: string, delta: TokenUsageDelta, model?: string): void;
+    private getOrCreateLatency;
+    private pushSample;
+    recordHookLatency(sessionId: string, latencyMs: number): void;
+    recordStateChangeDetection(sessionId: string, latencyMs: number): void;
+    recordPermissionResponse(sessionId: string, latencyMs: number): void;
+    recordChannelDelivery(sessionId: string, latencyMs: number): void;
+    private summarizeSamples;
+    /** Stream-aggregate a single latency field across all sessions without creating temp arrays. */
+    private aggregateLatencyField;
+    getSessionLatency(sessionId: string): SessionLatencySummary | null;
+    /** Clean up latency data for a session (called on session kill). */
+    clearSessionLatency(sessionId: string): void;
+    /** #357: Clean up all per-session data (call on session destroy). */
+    cleanupSession(sessionId: string): void;
+    getGlobalMetrics(activeSessionCount: number): GlobalMetricsResponse;
+    getSessionMetrics(sessionId: string): SessionMetrics | null;
+    getTotalSessionsCreated(): number;
+}

package/dist/metrics.js

@@ -0,0 +1,286 @@
+/**
+ * metrics.ts — Usage metrics and counters.
+ *
+ * Issue #40: Global and per-session metrics for monitoring.
+ * Counters are in-memory, persisted to disk on shutdown, loaded on startup.
+ */
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { metricsFileSchema } from './validation.js';
+export class MetricsCollector {
+    metricsFile;
+    global = {
+        sessionsCreated: 0,
+        sessionsCompleted: 0,
+        sessionsFailed: 0,
+        totalMessages: 0,
+        totalToolCalls: 0,
+        autoApprovals: 0,
+        webhooksSent: 0,
+        webhooksFailed: 0,
+        screenshotsTaken: 0,
+        pipelinesCreated: 0,
+        batchesCreated: 0,
+        promptsSent: 0,
+        promptsDelivered: 0,
+        promptsFailed: 0,
+    };
+    perSession = new Map();
+    latency = new Map();
+    startTime = Date.now();
+    /** Maximum samples per latency type per session (rolling window). */
+    static MAX_LATENCY_SAMPLES = 100;
+    /**
+     * Issue #488: Cost per million tokens by model family.
+     * Rates: [input $/M, output $/M, cacheWrite $/M, cacheRead $/M].
+     */
+    static COST_TABLE = {
+        'haiku': [0.80, 4.00, 1.00, 0.08],
+        'sonnet': [3.00, 15.00, 3.75, 0.30],
+        'opus': [15.00, 75.00, 18.75, 1.50],
+    };
+    static estimateCost(delta, model) {
+        let tier = MetricsCollector.COST_TABLE['sonnet'];
+        if (model) {
+            const lower = model.toLowerCase();
+            if (lower.includes('haiku'))
+                tier = MetricsCollector.COST_TABLE['haiku'];
+            else if (lower.includes('opus'))
+                tier = MetricsCollector.COST_TABLE['opus'];
+        }
+        const [inRate, outRate, cwRate, crRate] = tier;
+        return ((delta.inputTokens * inRate +
+            delta.outputTokens * outRate +
+            delta.cacheCreationTokens * cwRate +
+            delta.cacheReadTokens * crRate) / 1_000_000);
+    }
+    constructor(metricsFile) {
+        this.metricsFile = metricsFile;
+    }
+    async load() {
+        if (existsSync(this.metricsFile)) {
+            try {
+                const raw = await readFile(this.metricsFile, 'utf-8');
+                const parsed = metricsFileSchema.safeParse(JSON.parse(raw));
+                if (parsed.success && parsed.data.global) {
+                    this.global = { ...this.global, ...parsed.data.global };
+                }
+            }
+            catch { /* ignore corrupt file */ }
+        }
+    }
+    async save() {
+        const dir = dirname(this.metricsFile);
+        if (!existsSync(dir)) {
+            await mkdir(dir, { recursive: true });
+        }
+        await writeFile(this.metricsFile, JSON.stringify({ global: this.global, savedAt: Date.now() }, null, 2));
+    }
+    sessionCreated(sessionId) {
+        this.global.sessionsCreated++;
+        this.perSession.set(sessionId, {
+            durationSec: 0, messages: 0, toolCalls: 0,
+            approvals: 0, autoApprovals: 0, statusChanges: [],
+        });
+    }
+    sessionCompleted(sessionId) {
+        this.global.sessionsCompleted++;
+    }
+    sessionFailed(sessionId) {
+        this.global.sessionsFailed++;
+    }
+    messageReceived(sessionId) {
+        this.global.totalMessages++;
+        const m = this.perSession.get(sessionId);
+        if (m)
+            m.messages++;
+    }
+    toolCallReceived(sessionId) {
+        this.global.totalToolCalls++;
+        const m = this.perSession.get(sessionId);
+        if (m)
+            m.toolCalls++;
+    }
+    approvalGranted(sessionId, auto = false) {
+        if (auto)
+            this.global.autoApprovals++;
+        const m = this.perSession.get(sessionId);
+        if (m) {
+            m.approvals++;
+            if (auto)
+                m.autoApprovals++;
+        }
+    }
+    statusChanged(sessionId, status) {
+        const m = this.perSession.get(sessionId);
+        if (m)
+            m.statusChanges.push(status);
+    }
+    webhookSent() { this.global.webhooksSent++; }
+    webhookFailed() { this.global.webhooksFailed++; }
+    screenshotTaken() { this.global.screenshotsTaken++; }
+    pipelineCreated() { this.global.pipelinesCreated++; }
+    batchCreated() { this.global.batchesCreated++; }
+    promptSent(delivered) {
+        this.global.promptsSent++;
+        if (delivered) {
+            this.global.promptsDelivered++;
+        }
+        else {
+            this.global.promptsFailed++;
+        }
+    }
+    /** Issue #488: Accumulate token usage for a session. */
+    recordTokenUsage(sessionId, delta, model) {
+        const m = this.perSession.get(sessionId);
+        if (!m)
+            return;
+        const addedCost = MetricsCollector.estimateCost(delta, model);
+        if (!m.tokenUsage) {
+            m.tokenUsage = {
+                inputTokens: delta.inputTokens,
+                outputTokens: delta.outputTokens,
+                cacheCreationTokens: delta.cacheCreationTokens,
+                cacheReadTokens: delta.cacheReadTokens,
+                estimatedCostUsd: addedCost,
+            };
+        }
+        else {
+            m.tokenUsage.inputTokens += delta.inputTokens;
+            m.tokenUsage.outputTokens += delta.outputTokens;
+            m.tokenUsage.cacheCreationTokens += delta.cacheCreationTokens;
+            m.tokenUsage.cacheReadTokens += delta.cacheReadTokens;
+            m.tokenUsage.estimatedCostUsd += addedCost;
+        }
+    }
+    // ── Issue #87: Latency metric recording ─────────────────────────────
+    getOrCreateLatency(sessionId) {
+        let lat = this.latency.get(sessionId);
+        if (!lat) {
+            lat = { hook_latency_ms: [], state_change_detection_ms: [], permission_response_ms: [], channel_delivery_ms: [] };
+            this.latency.set(sessionId, lat);
+        }
+        return lat;
+    }
+    pushSample(arr, value) {
+        arr.push(value);
+        if (arr.length > MetricsCollector.MAX_LATENCY_SAMPLES) {
+            arr.shift();
+        }
+    }
+    recordHookLatency(sessionId, latencyMs) {
+        this.pushSample(this.getOrCreateLatency(sessionId).hook_latency_ms, latencyMs);
+    }
+    recordStateChangeDetection(sessionId, latencyMs) {
+        this.pushSample(this.getOrCreateLatency(sessionId).state_change_detection_ms, latencyMs);
+    }
+    recordPermissionResponse(sessionId, latencyMs) {
+        this.pushSample(this.getOrCreateLatency(sessionId).permission_response_ms, latencyMs);
+    }
+    recordChannelDelivery(sessionId, latencyMs) {
+        this.pushSample(this.getOrCreateLatency(sessionId).channel_delivery_ms, latencyMs);
+    }
+    summarizeSamples(samples) {
+        if (samples.length === 0) {
+            return { min: null, max: null, avg: null, count: 0 };
+        }
+        let min = samples[0];
+        let max = samples[0];
+        let sum = 0;
+        for (const s of samples) {
+            if (s < min)
+                min = s;
+            if (s > max)
+                max = s;
+            sum += s;
+        }
+        return { min, max, avg: Math.round(sum / samples.length), count: samples.length };
+    }
+    /** Stream-aggregate a single latency field across all sessions without creating temp arrays. */
+    aggregateLatencyField(field) {
+        let min;
+        let max;
+        let sum = 0;
+        let count = 0;
+        for (const lat of this.latency.values()) {
+            const samples = lat[field];
+            for (const s of samples) {
+                if (min === undefined || s < min)
+                    min = s;
+                if (max === undefined || s > max)
+                    max = s;
+                sum += s;
+                count++;
+            }
+        }
+        if (count === 0)
+            return { min: null, max: null, avg: null, count: 0 };
+        return { min: min, max: max, avg: Math.round(sum / count), count };
+    }
+    getSessionLatency(sessionId) {
+        const lat = this.latency.get(sessionId);
+        if (!lat)
+            return null;
+        return {
+            hook_latency_ms: this.summarizeSamples(lat.hook_latency_ms),
+            state_change_detection_ms: this.summarizeSamples(lat.state_change_detection_ms),
+            permission_response_ms: this.summarizeSamples(lat.permission_response_ms),
+            channel_delivery_ms: this.summarizeSamples(lat.channel_delivery_ms),
+        };
+    }
+    /** Clean up latency data for a session (called on session kill). */
+    clearSessionLatency(sessionId) {
+        this.latency.delete(sessionId);
+    }
+    /** #357: Clean up all per-session data (call on session destroy). */
+    cleanupSession(sessionId) {
+        this.perSession.delete(sessionId);
+        this.latency.delete(sessionId);
+    }
+    getGlobalMetrics(activeSessionCount) {
+        const avgMessages = this.global.sessionsCreated > 0
+            ? Math.round(this.global.totalMessages / this.global.sessionsCreated) : 0;
+        // Issue #87: Stream-aggregate latency across all sessions (no temp arrays)
+        const aggHook = this.aggregateLatencyField('hook_latency_ms');
+        const aggStateChange = this.aggregateLatencyField('state_change_detection_ms');
+        const aggPermission = this.aggregateLatencyField('permission_response_ms');
+        const aggChannel = this.aggregateLatencyField('channel_delivery_ms');
+        return {
+            uptime: Math.round((Date.now() - this.startTime) / 1000),
+            sessions: {
+                total_created: this.global.sessionsCreated,
+                currently_active: activeSessionCount,
+                completed: this.global.sessionsCompleted,
+                failed: this.global.sessionsFailed,
+                avg_duration_sec: 0,
+                avg_messages_per_session: avgMessages,
+            },
+            auto_approvals: this.global.autoApprovals,
+            webhooks_sent: this.global.webhooksSent,
+            webhooks_failed: this.global.webhooksFailed,
+            screenshots_taken: this.global.screenshotsTaken,
+            pipelines_created: this.global.pipelinesCreated,
+            batches_created: this.global.batchesCreated,
+            prompt_delivery: {
+                sent: this.global.promptsSent,
+                delivered: this.global.promptsDelivered,
+                failed: this.global.promptsFailed,
+                success_rate: this.global.promptsSent > 0
+                    ? Math.round((this.global.promptsDelivered / this.global.promptsSent) * 100) : null,
+            },
+            latency: {
+                hook_latency_ms: aggHook,
+                state_change_detection_ms: aggStateChange,
+                permission_response_ms: aggPermission,
+                channel_delivery_ms: aggChannel,
+            },
+        };
+    }
+    getSessionMetrics(sessionId) {
+        return this.perSession.get(sessionId) || null;
+    }
+    getTotalSessionsCreated() {
+        return this.global.sessionsCreated;
+    }
+}