nexus-prime 3.2.0 → 3.2.2

package/dist/dashboard/server.js

@@ -3,98 +3,321 @@ import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { nexusEventBus } from '../engines/event-bus.js';
+import { podNetwork } from '../engines/pod-network.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const PORT = parseInt(process.env.NEXUS_DASHBOARD_PORT || '3377', 10);
 const HOST = process.env.NEXUS_DASHBOARD_HOST || '127.0.0.1';
+const DEFAULT_PORT = parseInt(process.env.NEXUS_DASHBOARD_PORT || '3377', 10);
+const MAX_PORT_SCAN = 24;
+const DASHBOARD_API_VERSION = '2';
+const REQUIRED_CAPABILITIES = {
+    runs: true,
+    memory: true,
+    pod: true,
+    clients: true,
+    events: true,
+    stream: true,
+};
 export class DashboardServer {
     server;
     clients = new Set();
     unsubscribeBus = null;
     runtimeProvider;
+    memoryProvider;
+    adaptersProvider;
+    clientRegistryProvider;
     repoRoot;
+    dashboardUrl = null;
+    dashboardMode = 'idle';
+    activePort = null;
+    started = false;
+    initializePromise = null;
     constructor(options = {}) {
         this.runtimeProvider = options.runtimeProvider;
+        this.memoryProvider = options.memoryProvider;
+        this.adaptersProvider = options.adaptersProvider;
+        this.clientRegistryProvider = options.clientRegistryProvider;
         this.repoRoot = options.repoRoot ?? process.cwd();
-        this.server = http.createServer(this.requestHandler.bind(this));
+        this.server = http.createServer((req, res) => {
+            void this.requestHandler(req, res);
+        });
+        this.server.on('error', (error) => {
+            if (this.dashboardMode === 'bound') {
+                console.error('[Dashboard] Server error:', error.message);
+            }
+        });
     }
     start() {
         if (process.env.NEXUS_DASHBOARD_DISABLED === '1') {
             console.error('[Dashboard] Disabled by NEXUS_DASHBOARD_DISABLED=1');
             return;
         }
-        this.server.listen(PORT, HOST, () => {
-            const address = this.server.address();
-            const printablePort = typeof address === 'object' && address ? address.port : PORT;
-            console.error(`[Dashboard] Runtime console live at http://${HOST}:${printablePort}`);
-        });
-        this.server.on('error', (e) => {
-            if (e.code === 'EADDRINUSE') {
-                console.error(`[Dashboard] Port ${PORT} occupied. Bridging to active dashboard cluster.`);
-            }
-            else {
-                console.error(`[Dashboard] Server error:`, e.message);
-            }
-        });
-        this.unsubscribeBus = nexusEventBus.onEvent((event) => {
-            this.broadcast(event);
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        this.initializePromise = this.initialize().catch((error) => {
+            this.started = false;
+            this.dashboardMode = 'idle';
+            this.dashboardUrl = null;
+            this.activePort = null;
+            console.error('[Dashboard] Failed to start dashboard:', error instanceof Error ? error.message : String(error));
         });
-        nexusEventBus.startFilePolling(1500);
     }
     stop() {
         if (this.unsubscribeBus) {
             this.unsubscribeBus();
             this.unsubscribeBus = null;
         }
-        nexusEventBus.stopFilePolling();
-        for (const res of this.clients) {
-            res.end();
+        if (this.dashboardMode === 'bound') {
+            nexusEventBus.stopFilePolling();
+            for (const res of this.clients) {
+                res.end();
+            }
+            this.clients.clear();
+            this.server.close();
         }
-        this.clients.clear();
-        this.server.close();
+        this.dashboardMode = 'idle';
+        this.dashboardUrl = null;
+        this.activePort = null;
+        this.started = false;
     }
     getAddress() {
-        const address = this.server.address();
-        if (!address || typeof address === 'string')
-            return null;
-        return `http://${HOST}:${address.port}`;
-    }
-    requestHandler(req, res) {
-        const url = new URL(req.url || '/', `http://${HOST}:${PORT}`);
-        if (url.pathname === '/' || url.pathname === '/index.html') {
+        return this.dashboardUrl;
+    }
+    async initialize() {
+        const probe = await this.probeDashboard(DEFAULT_PORT);
+        if (probe.status === 'compatible') {
+            this.dashboardMode = 'reused';
+            this.dashboardUrl = probe.url;
+            this.activePort = DEFAULT_PORT;
+            console.error(`[Dashboard] Reusing compatible dashboard at ${probe.url}`);
+            return;
+        }
+        const startPort = probe.status === 'incompatible' ? DEFAULT_PORT + 1 : DEFAULT_PORT;
+        const fallbackPort = await this.bindFirstAvailablePort(startPort, DEFAULT_PORT + MAX_PORT_SCAN);
+        this.dashboardMode = 'bound';
+        this.activePort = fallbackPort;
+        this.dashboardUrl = this.buildUrl(fallbackPort);
+        this.unsubscribeBus = nexusEventBus.onEvent((event) => this.broadcast(event));
+        nexusEventBus.startFilePolling();
+        if (probe.status === 'incompatible') {
+            console.error(`[Dashboard] Incompatible dashboard detected at ${probe.url} (${probe.reason || 'missing compatibility contract'}). New dashboard started at ${this.dashboardUrl}`);
+            return;
+        }
+        console.error(`[Dashboard] Topology console listening at ${this.dashboardUrl}`);
+    }
+    async requestHandler(req, res) {
+        const url = new URL(req.url || '/', this.dashboardUrl ?? this.buildUrl(this.activePort ?? DEFAULT_PORT));
+        if (req.method === 'OPTIONS') {
+            this.respondOptions(res);
+            return;
+        }
+        if (req.method === 'GET' && (url.pathname === '/' || url.pathname === '/index.html')) {
             this.serveDashboard(res);
             return;
         }
-        if (url.pathname === '/stream') {
+        if (req.method === 'GET' && url.pathname === '/stream') {
             this.serveSSE(req, res);
             return;
         }
-        if (url.pathname === '/api/runs') {
-            this.respondJson(res, this.getRuntime()?.listRuns(20) ?? []);
+        if (req.method === 'GET' && url.pathname === '/api/runs') {
+            const limit = parseInt(url.searchParams.get('limit') || '20', 10);
+            this.respondJson(res, this.getRuntime()?.listRuns(limit) ?? []);
             return;
         }
-        if (url.pathname.startsWith('/api/runs/')) {
+        if (req.method === 'GET' && url.pathname.startsWith('/api/runs/')) {
             const runId = decodeURIComponent(url.pathname.replace('/api/runs/', ''));
             const run = this.getRuntime()?.getRun(runId);
             this.respondJson(res, run ?? { error: 'run-not-found', runId }, run ? 200 : 404);
             return;
         }
-        if (url.pathname === '/api/skills') {
+        if (req.method === 'GET' && url.pathname === '/api/skills') {
             this.respondJson(res, this.getRuntime()?.listSkills() ?? []);
             return;
         }
-        if (url.pathname === '/api/workflows') {
+        if (req.method === 'GET' && url.pathname === '/api/workflows') {
             this.respondJson(res, this.getRuntime()?.listWorkflows() ?? []);
             return;
         }
-        if (url.pathname === '/api/backends') {
+        if (req.method === 'GET' && url.pathname === '/api/backends') {
             this.respondJson(res, this.getRuntime()?.getBackendCatalog() ?? {});
             return;
         }
-        if (url.pathname === '/api/health') {
+        if (req.method === 'GET' && url.pathname === '/api/health') {
             this.respondJson(res, this.collectHealth());
             return;
         }
+        if (req.method === 'GET' && url.pathname === '/api/memory') {
+            const limit = parseInt(url.searchParams.get('limit') || '40', 10);
+            const tier = url.searchParams.get('tier') ?? undefined;
+            const tag = url.searchParams.get('tag') ?? undefined;
+            const linkedType = url.searchParams.get('linkedType') ?? undefined;
+            const recencyMs = url.searchParams.get('recencyMs');
+            const memory = this.getMemory();
+            this.respondJson(res, memory?.listSnapshots(limit, {
+                tier: tier,
+                tag,
+                linkedType: linkedType,
+                recencyMs: recencyMs ? parseInt(recencyMs, 10) : undefined,
+            }) ?? []);
+            return;
+        }
+        if (req.method === 'GET' && url.pathname.startsWith('/api/memory/') && url.pathname.endsWith('/network')) {
+            const id = decodeURIComponent(url.pathname.replace('/api/memory/', '').replace('/network', '').replace(/\/$/, ''));
+            const depth = parseInt(url.searchParams.get('depth') || '2', 10);
+            const limit = parseInt(url.searchParams.get('limit') || '18', 10);
+            const memory = this.getMemory();
+            this.respondJson(res, memory?.getNetworkSnapshot(id, depth, limit) ?? { focusId: id, nodes: [], links: [] });
+            return;
+        }
+        if (req.method === 'GET' && url.pathname.startsWith('/api/memory/')) {
+            const id = decodeURIComponent(url.pathname.replace('/api/memory/', ''));
+            const memory = this.getMemory();
+            const detail = memory?.getDetail(id);
+            this.respondJson(res, detail ?? { error: 'memory-not-found', id }, detail ? 200 : 404);
+            return;
+        }
+        if (req.method === 'GET' && url.pathname === '/api/pod') {
+            const limit = parseInt(url.searchParams.get('limit') || '40', 10);
+            this.respondJson(res, podNetwork.getDashboardSnapshot(limit));
+            return;
+        }
+        if (req.method === 'GET' && url.pathname.startsWith('/api/pod/')) {
+            const workerId = decodeURIComponent(url.pathname.replace('/api/pod/', ''));
+            const limit = parseInt(url.searchParams.get('limit') || '20', 10);
+            this.respondJson(res, podNetwork.getWorker(workerId, limit));
+            return;
+        }
+        if (req.method === 'GET' && url.pathname === '/api/clients') {
+            this.respondJson(res, this.getClientRegistry()?.listClients(this.getAdapters()) ?? []);
+            return;
+        }
+        if (req.method === 'GET' && url.pathname === '/api/events') {
+            const category = url.searchParams.get('category');
+            const type = url.searchParams.get('type');
+            const limit = parseInt(url.searchParams.get('limit') || '80', 10);
+            const events = this.getEventCards()
+                .filter((event) => !category || event.category === category)
+                .filter((event) => !type || event.type === type)
+                .slice(0, Math.max(limit, 1));
+            this.respondJson(res, events);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/api/skills/deploy') {
+            const body = await this.readJsonBody(req);
+            const runtime = this.getRuntime();
+            const deployed = runtime?.deploySkill(String(body.skillId), body.scope);
+            if (deployed) {
+                nexusEventBus.emit('skill.deploy', {
+                    skillId: deployed.skillId,
+                    scope: deployed.scope,
+                    status: deployed.rolloutStatus,
+                });
+            }
+            this.respondJson(res, deployed ?? { error: 'skill-not-found' }, deployed ? 200 : 404);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/api/skills/revoke') {
+            const body = await this.readJsonBody(req);
+            const runtime = this.getRuntime();
+            const revoked = runtime?.revokeSkill(String(body.skillId));
+            if (revoked) {
+                nexusEventBus.emit('skill.revoke', {
+                    skillId: revoked.skillId,
+                    status: revoked.rolloutStatus,
+                });
+            }
+            this.respondJson(res, revoked ?? { error: 'skill-not-found' }, revoked ? 200 : 404);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/api/workflows/deploy') {
+            const body = await this.readJsonBody(req);
+            const runtime = this.getRuntime();
+            const deployed = runtime?.deployWorkflow(String(body.workflowId), body.scope);
+            if (deployed) {
+                nexusEventBus.emit('workflow.deploy', {
+                    workflowId: deployed.workflowId,
+                    scope: deployed.scope,
+                    status: deployed.rolloutStatus,
+                });
+            }
+            this.respondJson(res, deployed ?? { error: 'workflow-not-found' }, deployed ? 200 : 404);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/api/workflows/run') {
+            const body = await this.readJsonBody(req);
+            const runtime = this.getRuntime();
+            if (!runtime) {
+                this.respondJson(res, { error: 'runtime-unavailable' }, 503);
+                return;
+            }
+            try {
+                const run = await runtime.runWorkflow(String(body.workflowId), body.goal ? String(body.goal) : undefined);
+                nexusEventBus.emit('workflow.run', {
+                    workflowId: String(body.workflowId),
+                    runId: run.runId,
+                    status: run.state,
+                });
+                this.respondJson(res, run);
+            }
+            catch (error) {
+                this.respondJson(res, { error: error instanceof Error ? error.message : 'workflow-run-failed' }, 400);
+            }
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/api/runtime/execute') {
+            const body = await this.readJsonBody(req);
+            const runtime = this.getRuntime();
+            if (!runtime) {
+                this.respondJson(res, { error: 'runtime-unavailable' }, 503);
+                return;
+            }
+            if (!body.goal || typeof body.goal !== 'string') {
+                this.respondJson(res, { error: 'goal-required' }, 400);
+                return;
+            }
+            const run = await runtime.run(body);
+            nexusEventBus.emit('dashboard.action', {
+                action: 'runtime.execute',
+                status: run.state,
+                target: run.runId,
+            });
+            this.respondJson(res, run, 201);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname.startsWith('/api/clients/') && url.pathname.endsWith('/reconnect')) {
+            const clientId = decodeURIComponent(url.pathname.replace('/api/clients/', '').replace('/reconnect', '').replace(/\/$/, ''));
+            const registry = this.getClientRegistry();
+            if (!registry) {
+                this.respondJson(res, { error: 'client-registry-unavailable' }, 503);
+                return;
+            }
+            const client = registry.reconnect(clientId);
+            nexusEventBus.emit('dashboard.action', {
+                action: 'client.reconnect',
+                status: 'ok',
+                target: clientId,
+            });
+            this.respondJson(res, client);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname.startsWith('/api/clients/') && url.pathname.endsWith('/clear')) {
+            const clientId = decodeURIComponent(url.pathname.replace('/api/clients/', '').replace('/clear', '').replace(/\/$/, ''));
+            const registry = this.getClientRegistry();
+            if (!registry) {
+                this.respondJson(res, { error: 'client-registry-unavailable' }, 503);
+                return;
+            }
+            registry.clear(clientId);
+            nexusEventBus.emit('dashboard.action', {
+                action: 'client.clear',
+                status: 'ok',
+                target: clientId,
+            });
+            this.respondJson(res, { ok: true, clientId });
+            return;
+        }
         res.writeHead(404);
         res.end('Not found');
     }
@@ -114,12 +337,12 @@ export class DashboardServer {
         res.writeHead(200, {
             'Content-Type': 'text/event-stream',
             'Cache-Control': 'no-cache',
-            'Connection': 'keep-alive',
-            'Access-Control-Allow-Origin': '*'
+            Connection: 'keep-alive',
+            'Access-Control-Allow-Origin': '*',
         });
         res.write('retry: 3000\n\n');
         res.write(`event: bootstrap\ndata: ${JSON.stringify({ connected: true, timestamp: Date.now() })}\n\n`);
-        const history = nexusEventBus.getHistory();
+        const history = this.getEventCards();
         for (const evt of history) {
             res.write(`data: ${JSON.stringify(evt)}\n\n`);
         }
@@ -134,11 +357,20 @@ export class DashboardServer {
         });
     }
     broadcast(event) {
-        const dataStr = `data: ${JSON.stringify(event)}\n\n`;
+        const normalized = this.normalizeEvent(event);
+        const dataStr = `data: ${JSON.stringify(normalized)}\n\n`;
         for (const res of this.clients) {
             res.write(dataStr);
         }
     }
+    respondOptions(res) {
+        res.writeHead(204, {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET,POST,OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type',
+        });
+        res.end();
+    }
     respondJson(res, data, statusCode = 200) {
         res.writeHead(statusCode, {
             'Content-Type': 'application/json',
@@ -147,14 +379,58 @@ export class DashboardServer {
         });
         res.end(JSON.stringify(data, null, 2));
     }
+    async readJsonBody(req) {
+        const chunks = [];
+        for await (const chunk of req) {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        if (!chunks.length)
+            return {};
+        try {
+            return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        }
+        catch {
+            return {};
+        }
+    }
     getRuntime() {
         return this.runtimeProvider?.();
     }
+    getMemory() {
+        return this.memoryProvider?.();
+    }
+    getAdapters() {
+        return this.adaptersProvider?.() ?? [];
+    }
+    getClientRegistry() {
+        return this.clientRegistryProvider?.();
+    }
+    getEventCards() {
+        return nexusEventBus.getHistory().map((event) => this.normalizeEvent(event)).reverse();
+    }
+    normalizeEvent(event) {
+        const category = mapEventCategory(event.type);
+        const severity = mapEventSeverity(event.type, event.data);
+        return {
+            id: event.id,
+            type: event.type,
+            title: mapEventTitle(event.type),
+            source: mapEventSource(event.type, event.data),
+            time: event.timestamp,
+            severity,
+            category,
+            summary: summarizeEvent(event.type, event.data),
+            payload: event.data,
+        };
+    }
     collectHealth() {
         const packageJsonPath = path.join(this.repoRoot, 'package.json');
         const workflowPath = path.join(this.repoRoot, '.github', 'workflows', 'pages.yml');
         const docsDir = path.join(this.repoRoot, 'docs');
         const runtime = this.getRuntime();
+        const memory = this.getMemory();
+        const clientRegistry = this.getClientRegistry();
+        const podSnapshot = podNetwork.getDashboardSnapshot(20);
         let packageVersion = 'unknown';
         if (fs.existsSync(packageJsonPath)) {
             try {
@@ -169,12 +445,28 @@ export class DashboardServer {
             const raw = fs.readFileSync(workflowPath, 'utf-8');
             pagesWorkflowValid = raw.includes('steps.deployment.outputs.page_url');
         }
+        const clients = clientRegistry?.listClients(this.getAdapters()) ?? [];
         return {
+            dashboardApiVersion: DASHBOARD_API_VERSION,
+            capabilities: { ...REQUIRED_CAPABILITIES },
+            dashboardUrl: this.getAddress(),
+            dashboardMode: this.dashboardMode,
             connection: {
                 stream: this.clients.size > 0 ? 'connected' : 'idle',
                 subscribers: this.clients.size,
             },
             runtime: runtime?.getHealth() ?? { runtime: 'unavailable' },
+            memory: memory?.getStats() ?? { prefrontal: 0, hippocampus: 0, cortex: 0, totalLinks: 0, oldestEntry: null, topTags: [] },
+            pod: {
+                workers: podSnapshot.activeWorkers.length,
+                lastMessageTimestamp: podSnapshot.lastMessageTimestamp,
+                confidenceBands: podSnapshot.confidenceBands,
+            },
+            clients: {
+                total: clients.length,
+                active: clients.filter((client) => client.state === 'active').length,
+                inferred: clients.filter((client) => client.state === 'inferred').length,
+            },
             release: {
                 packageVersion,
             },
@@ -188,5 +480,236 @@ export class DashboardServer {
             },
         };
     }
+    buildUrl(port) {
+        return `http://${HOST}:${port}`;
+    }
+    async probeDashboard(port) {
+        const url = this.buildUrl(port);
+        try {
+            const response = await this.requestProbe(`${url}/api/health`);
+            if (response.statusCode !== 200) {
+                return {
+                    status: 'incompatible',
+                    url,
+                    reason: `health-status-${response.statusCode}`,
+                };
+            }
+            let payload = null;
+            try {
+                payload = JSON.parse(response.body);
+            }
+            catch {
+                return {
+                    status: 'incompatible',
+                    url,
+                    reason: 'health-invalid-json',
+                };
+            }
+            if (this.isCompatibleHealth(payload)) {
+                return {
+                    status: 'compatible',
+                    url,
+                    health: payload,
+                };
+            }
+            return {
+                status: 'incompatible',
+                url,
+                health: payload,
+                reason: 'health-incompatible',
+            };
+        }
+        catch (error) {
+            if (this.isFreePortProbeError(error)) {
+                return {
+                    status: 'free',
+                    url,
+                    reason: error instanceof Error ? error.message : 'connection-refused',
+                };
+            }
+            return {
+                status: 'incompatible',
+                url,
+                reason: error instanceof Error ? error.message : 'probe-failed',
+            };
+        }
+    }
+    isCompatibleHealth(payload) {
+        if (!payload || payload.dashboardApiVersion !== DASHBOARD_API_VERSION) {
+            return false;
+        }
+        return Object.entries(REQUIRED_CAPABILITIES).every(([key, expected]) => payload.capabilities?.[key] === expected);
+    }
+    isFreePortProbeError(error) {
+        const code = typeof error === 'object' && error && 'code' in error ? String(error.code) : '';
+        return code === 'ECONNREFUSED' || code === 'ECONNRESET' || code === 'EHOSTUNREACH' || code === 'ENOTFOUND';
+    }
+    requestProbe(url) {
+        return new Promise((resolve, reject) => {
+            const req = http.get(url, { timeout: 1200 }, (res) => {
+                const chunks = [];
+                res.on('data', (chunk) => {
+                    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                });
+                res.on('end', () => {
+                    resolve({
+                        statusCode: res.statusCode ?? 0,
+                        body: Buffer.concat(chunks).toString('utf8'),
+                    });
+                });
+            });
+            req.on('timeout', () => {
+                req.destroy(new Error('probe-timeout'));
+            });
+            req.on('error', reject);
+        });
+    }
+    async bindFirstAvailablePort(startPort, endPort) {
+        let lastError = null;
+        for (let port = startPort; port <= endPort; port += 1) {
+            try {
+                await this.listenOnPort(port);
+                return port;
+            }
+            catch (error) {
+                lastError = error;
+                const code = typeof error === 'object' && error && 'code' in error ? String(error.code) : '';
+                if (code !== 'EADDRINUSE') {
+                    throw error;
+                }
+            }
+        }
+        throw lastError instanceof Error
+            ? lastError
+            : new Error(`No free dashboard port found in range ${startPort}-${endPort}`);
+    }
+    listenOnPort(port) {
+        return new Promise((resolve, reject) => {
+            const handleListening = () => {
+                cleanup();
+                resolve();
+            };
+            const handleError = (error) => {
+                cleanup();
+                reject(error);
+            };
+            const cleanup = () => {
+                this.server.off('listening', handleListening);
+                this.server.off('error', handleError);
+            };
+            this.server.once('listening', handleListening);
+            this.server.once('error', handleError);
+            this.server.listen(port, HOST);
+        });
+    }
+}
+function mapEventCategory(type) {
+    if (type.startsWith('memory.'))
+        return 'memory';
+    if (type.startsWith('pod.'))
+        return 'pod';
+    if (type.startsWith('phantom.'))
+        return 'runtime';
+    if (type.startsWith('client.'))
+        return 'clients';
+    if (type.startsWith('skill.'))
+        return 'skills';
+    if (type.startsWith('workflow.'))
+        return 'workflows';
+    if (type.startsWith('tokens.') || type.startsWith('cas.') || type.startsWith('kv.'))
+        return 'tokens';
+    return 'system';
+}
+function mapEventSeverity(type, payload) {
+    if (type === 'guardrail.check') {
+        return payload.passed ? 'good' : 'bad';
+    }
+    if (type === 'phantom.merge' || type === 'phantom.merge.complete' || type === 'workflow.run') {
+        return payload.status === 'failed' ? 'bad' : 'good';
+    }
+    if (type === 'client.inferred')
+        return 'warn';
+    if (type === 'dashboard.action' && payload.status === 'failed')
+        return 'bad';
+    if (type === 'pod.signal')
+        return 'info';
+    return 'info';
+}
+function mapEventTitle(type) {
+    return {
+        'system.boot': 'Runtime boot',
+        'memory.store': 'Memory stored',
+        'memory.recall': 'Memory recall',
+        'pod.signal': 'POD signal',
+        'tokens.optimized': 'Tokens optimized',
+        'phantom.worker.start': 'Worker start',
+        'phantom.worker.complete': 'Worker complete',
+        'phantom.merge.complete': 'Merge complete',
+        'phantom.merge': 'Merge decision',
+        'guardrail.check': 'Guardrail check',
+        'ghost.pass': 'Ghost pass',
+        'graph.query': 'Graph query',
+        'darwin.cycle': 'Darwin cycle',
+        'session.dna': 'Session DNA',
+        'skill.register': 'Skill registered',
+        'skill.deploy': 'Skill deployed',
+        'skill.revoke': 'Skill revoked',
+        'workflow.deploy': 'Workflow deployed',
+        'workflow.run': 'Workflow run',
+        'client.heartbeat': 'Client heartbeat',
+        'client.inferred': 'Client inferred',
+        'client.status': 'Client status',
+        'dashboard.action': 'Dashboard action',
+        'nexusnet.publish': 'NexusNet publish',
+        'nexusnet.sync': 'NexusNet sync',
+        'entanglement.create': 'Entanglement created',
+        'entanglement.collapse': 'Entanglement collapsed',
+        'entanglement.correlate': 'Entanglement correlated',
+        'cas.encode': 'CAS encode',
+        'cas.decode': 'CAS decode',
+        'cas.pattern_learned': 'CAS pattern',
+        'kv.merge': 'KV merge',
+        'kv.adapt': 'KV adapt',
+        'kv.consensus': 'KV consensus',
+    }[type] ?? type;
+}
+function mapEventSource(type, payload) {
+    if (type.startsWith('client.'))
+        return String(payload.displayName ?? payload.clientId ?? 'client');
+    if (type === 'pod.signal')
+        return String(payload.workerId ?? 'pod');
+    if (type.startsWith('phantom.'))
+        return String(payload.workerId ?? payload.winner ?? 'runtime');
+    if (type.startsWith('skill.'))
+        return String(payload.skillId ?? payload.name ?? 'skill');
+    if (type.startsWith('workflow.'))
+        return String(payload.workflowId ?? 'workflow');
+    return 'nexus-prime';
+}
+function summarizeEvent(type, payload) {
+    switch (type) {
+        case 'memory.store':
+            return `Priority ${payload.priority ?? 'n/a'} · ${payload.tags?.join(', ') ?? 'no tags'}`;
+        case 'memory.recall':
+            return `Recalled ${payload.count ?? 0} memories for "${payload.query ?? ''}"`;
+        case 'pod.signal':
+            return String(payload.content ?? 'POD signal received');
+        case 'tokens.optimized':
+            return `Saved ${payload.savings ?? 0} tokens across ${payload.files ?? 0} files`;
+        case 'phantom.worker.start':
+            return `${payload.approach ?? 'worker'} started for ${payload.goal ?? 'task'}`;
+        case 'phantom.worker.complete':
+            return `Confidence ${payload.confidence ?? 0}`;
+        case 'phantom.merge':
+            return `${payload.action ?? 'merge'} · ${payload.winner ?? 'unknown winner'}`;
+        case 'client.heartbeat':
+        case 'client.inferred':
+        case 'client.status':
+            return JSON.stringify(payload);
+        case 'dashboard.action':
+            return `${payload.action ?? 'action'} → ${payload.status ?? 'unknown'}`;
+        default:
+            return JSON.stringify(payload);
+    }
 }
 //# sourceMappingURL=server.js.map