@unerr-ai/unerr 0.1.0 → 0.1.1

package/dist/proxy/transport-mux.js

@@ -0,0 +1,229 @@
+/**
+ * Sprint 7.2: Transport Multiplexer — multiple IDE sessions via Unix domain socket.
+ *
+ * Architecture:
+ *   IDE 1 (Claude Code) ──stdio──→ ┐
+ *                                   ├── Proxy Process
+ *   IDE 2 (Cursor)      ──UDS───→  ┘     ├── CozoDB (shared)
+ *                                         ├── QueryRouter (shared)
+ *                                         └── ShadowLedger (session_id per client)
+ *
+ * Primary client connects via stdio (backward compatible).
+ * Secondary clients connect via Unix domain socket at `.unerr/state/proxy.sock`.
+ * Each client gets an independent session_id in the Shadow Ledger.
+ */
+import { existsSync, unlinkSync } from "node:fs";
+import { createServer } from "node:net";
+/** stderr-only logger. stdout is MCP territory. */
+const _log = {
+    info: (msg) => process.stderr.write(`[unerr:mux] ${msg}\n`),
+    warn: (msg) => process.stderr.write(`[unerr:mux] WARN: ${msg}\n`),
+};
+export class TransportMux {
+    sockPath;
+    server = null;
+    clients = new Map();
+    handler = null;
+    customHttpHandlers = new Map();
+    nextClientId = 1;
+    constructor(sockPath) {
+        this.sockPath = sockPath;
+    }
+    /**
+     * Set the message handler for incoming JSON-RPC requests.
+     */
+    setHandler(handler) {
+        this.handler = handler;
+    }
+    /**
+     * Register a custom HTTP handler for a path prefix.
+     * When an HTTP GET/POST request comes in on the UDS, this handler responds.
+     * Handler receives the full URL (including query string) for param parsing.
+     */
+    setCustomHttpHandler(path, handler) {
+        this.customHttpHandlers.set(path, handler);
+    }
+    /**
+     * Start listening for secondary clients on the Unix domain socket.
+     */
+    start() {
+        // Clean up stale socket file
+        if (existsSync(this.sockPath)) {
+            try {
+                unlinkSync(this.sockPath);
+            }
+            catch {
+                _log.warn(`Could not remove stale socket: ${this.sockPath}`);
+                return;
+            }
+        }
+        this.server = createServer((socket) => {
+            this.onClientConnect(socket);
+        });
+        this.server.on("error", (err) => {
+            _log.warn(`UDS server error: ${err.message}`);
+        });
+        this.server.listen(this.sockPath, () => {
+            _log.info(`UDS transport listening at ${this.sockPath}`);
+        });
+        // Don't prevent process exit
+        this.server.unref();
+    }
+    /**
+     * Stop the UDS server and disconnect all secondary clients.
+     */
+    stop() {
+        // Close all client connections
+        for (const [id, client] of this.clients) {
+            if (client.socket && !client.socket.destroyed) {
+                client.socket.destroy();
+            }
+            this.clients.delete(id);
+        }
+        // Close server
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+        // Clean up socket file
+        if (existsSync(this.sockPath)) {
+            try {
+                unlinkSync(this.sockPath);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        _log.info("UDS transport stopped");
+    }
+    /**
+     * Get connected client count (excludes stdio primary).
+     */
+    get clientCount() {
+        return this.clients.size;
+    }
+    /**
+     * Get all connected clients.
+     */
+    getClients() {
+        return [...this.clients.values()];
+    }
+    onClientConnect(socket) {
+        const clientId = `uds-${this.nextClientId++}`;
+        const client = {
+            id: clientId,
+            transport: "uds",
+            connectedAt: new Date().toISOString(),
+            socket,
+        };
+        this.clients.set(clientId, client);
+        _log.info(`Client connected: ${clientId}`);
+        let buffer = "";
+        socket.on("data", (data) => {
+            buffer += data.toString();
+            // Sprint 10.5: Detect HTTP requests (from curl --unix-socket)
+            if (buffer.startsWith("GET ") || buffer.startsWith("POST ")) {
+                const httpMatch = buffer.match(/^(GET|POST) (\S+)/);
+                if (httpMatch) {
+                    const fullUrl = httpMatch[2] ?? "";
+                    // Match by path prefix (strip query string for matching)
+                    const pathOnly = fullUrl.split("?")[0] ?? fullUrl;
+                    const httpHandler = this.customHttpHandlers.get(pathOnly);
+                    if (httpHandler) {
+                        try {
+                            const body = httpHandler(fullUrl);
+                            const httpResponse = `HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: ${Buffer.byteLength(body)}\r\nConnection: close\r\n\r\n${body}`;
+                            socket.write(httpResponse);
+                        }
+                        catch {
+                            socket.write("HTTP/1.1 500 Internal Server Error\r\nConnection: close\r\n\r\n");
+                        }
+                        socket.end();
+                        return;
+                    }
+                    socket.write("HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n");
+                    socket.end();
+                    return;
+                }
+            }
+            // Process complete JSON-RPC messages (newline-delimited)
+            let newlineIdx = buffer.indexOf("\n");
+            while (newlineIdx !== -1) {
+                const line = buffer.slice(0, newlineIdx).trim();
+                buffer = buffer.slice(newlineIdx + 1);
+                if (line.length === 0)
+                    continue;
+                this.processMessage(clientId, line, socket).catch((err) => {
+                    _log.warn(`Error processing message from ${clientId}: ${err instanceof Error ? err.message : String(err)}`);
+                });
+                newlineIdx = buffer.indexOf("\n");
+            }
+        });
+        socket.on("close", () => {
+            this.clients.delete(clientId);
+            _log.info(`Client disconnected: ${clientId}`);
+        });
+        socket.on("error", (err) => {
+            _log.warn(`Client ${clientId} error: ${err.message}`);
+            this.clients.delete(clientId);
+        });
+    }
+    async processMessage(clientId, raw, socket) {
+        if (!this.handler) {
+            _log.warn("No message handler set — dropping message");
+            return;
+        }
+        let request;
+        try {
+            request = JSON.parse(raw);
+        }
+        catch {
+            const errorResponse = {
+                jsonrpc: "2.0",
+                error: { code: -32700, message: "Parse error" },
+            };
+            this.sendResponse(socket, errorResponse);
+            return;
+        }
+        // Heartbeat: respond to bridge health pings without forwarding to MCP handler
+        if (request.method === "unerr/ping") {
+            this.sendResponse(socket, {
+                jsonrpc: "2.0",
+                method: "unerr/pong",
+                params: { ts: Date.now() },
+            });
+            return;
+        }
+        try {
+            const response = await this.handler(clientId, request);
+            // JSON-RPC: notifications (no id) don't get responses
+            if (request.id === undefined || request.id === null) {
+                return;
+            }
+            // Preserve the request id in the response
+            response.id = request.id;
+            this.sendResponse(socket, response);
+        }
+        catch (err) {
+            const errorResponse = {
+                jsonrpc: "2.0",
+                id: request.id,
+                error: {
+                    code: -32603,
+                    message: err instanceof Error ? err.message : "Internal error",
+                },
+            };
+            this.sendResponse(socket, errorResponse);
+        }
+    }
+    sendResponse(socket, response) {
+        if (socket.destroyed)
+            return;
+        try {
+            socket.write(`${JSON.stringify(response)}\n`);
+        }
+        catch {
+            /* client disconnected */
+        }
+    }
+}

package/dist/proxy/wire-cap.js

@@ -0,0 +1,268 @@
+/**
+ * Tier-3 universal wire cap — paginated delivery for MCP responses.
+ *
+ * Why: Claude Code, OpenAI Agents SDK, and other MCP clients all share one
+ * connection per process; they don't expose whether the call originated from
+ * the parent agent or a sub-agent. Sub-agent contexts are smaller and thrash
+ * easily on uncapped responses (recall_facts ~3KB, file_outline ~6KB are
+ * typical offenders). A universal cap with paginated retrieval keeps both
+ * paths happy.
+ *
+ * Design principles:
+ *   1. Agent narrows the query, not the budget. Hints prefer `limit:N`,
+ *      `entity:<name>`, `fact_type:<T>` over bumping `token_budget`.
+ *   2. token_budget bump is the escape hatch — reserved for cases where the
+ *      agent genuinely needs the full payload (e.g. reading a complete
+ *      function body to refactor it).
+ *   3. State stays in the request. Cursor / offset / filter args travel with
+ *      each call — no session pinning.
+ *
+ * Pipeline integration: called at the wire boundary in mcp-server.ts and
+ * proxy.ts, AFTER buildSignalPrefix but BEFORE serialization.
+ */
+const PER_TOOL_CAPS = {
+    recall_facts: {
+        arrayKey: "facts",
+        defaultLimit: 5,
+        maxLimit: 25,
+        cursorArg: "limit",
+        // Concrete enum the agent can paste verbatim. Narrows to anti-patterns,
+        // which is the most common reason to re-call recall_facts after a
+        // generic recall returns mixed types.
+        filterHint: "fact_type:negative|convention|procedural|semantic",
+    },
+    get_references: {
+        arrayKey: "references",
+        defaultLimit: 10,
+        maxLimit: 50,
+        cursorArg: "limit",
+    },
+    search_code: {
+        defaultLimit: 10,
+        maxLimit: 50,
+        cursorArg: "limit",
+    },
+    get_critical_nodes: {
+        defaultLimit: 5,
+        maxLimit: 50,
+        cursorArg: "top_n",
+    },
+    get_cross_boundary_links: {
+        defaultLimit: 5,
+        maxLimit: 50,
+        cursorArg: "top_n",
+    },
+    get_imports: {
+        defaultLimit: 25,
+        maxLimit: 100,
+        cursorArg: "limit",
+    },
+    file_connections: {
+        arrayKey: "connections",
+        defaultLimit: 20,
+        maxLimit: 100,
+        cursorArg: "limit",
+    },
+    file_outline: {
+        arrayKey: "entities",
+        defaultLimit: 30,
+        maxLimit: 100,
+        cursorArg: "limit",
+        // No filterHint: `entity:` requires a concrete name we cannot supply
+        // statically. The caller should pick from the returned `entities[].name`
+        // and re-call file_read with that exact value. A literal `entity:<name>`
+        // hint trains the agent to paste the placeholder verbatim.
+    },
+};
+/** Final safety net: even if a tool ignored its own cap, never let one
+ * response exceed this many bytes on the wire. ~2K tokens. */
+const HARD_BYTE_CAP = 8192;
+/** Approximate bytes-per-token used to convert an agent's `token_budget`
+ * arg into a byte cap. Conservative; modern BPE tokenizers average ~3.5–4
+ * chars per token for English/code. */
+const BYTES_PER_TOKEN = 4;
+/** Upper bound on the byte cap reachable via `token_budget`, even if the
+ * agent passes a very large value. Keeps a runaway client from blowing the
+ * model context. ~16K tokens. */
+const MAX_BYTE_CAP = 65536;
+/**
+ * Resolve the effective byte cap for this call. Defaults to HARD_BYTE_CAP;
+ * agents can lift it (up to MAX_BYTE_CAP) by passing `token_budget:N` —
+ * the documented escape hatch for full-payload reads (e.g. function bodies
+ * for refactors). Anything <= the default keeps the default; we never
+ * shrink below HARD_BYTE_CAP based on a small budget.
+ */
+function resolveByteCap(args) {
+    const tb = args.token_budget;
+    if (typeof tb !== "number" || tb <= 0)
+        return HARD_BYTE_CAP;
+    const scaled = Math.floor(tb) * BYTES_PER_TOKEN;
+    if (scaled <= HARD_BYTE_CAP)
+        return HARD_BYTE_CAP;
+    return Math.min(scaled, MAX_BYTE_CAP);
+}
+/**
+ * Resolve effective limit from the agent's `args.limit` (clamped to maxLimit).
+ * Returns the cap rule's `defaultLimit` when args.limit is missing/invalid.
+ */
+function resolveLimit(cap, argsLimit) {
+    if (typeof argsLimit !== "number" || argsLimit <= 0)
+        return cap.defaultLimit;
+    return Math.min(Math.floor(argsLimit), cap.maxLimit);
+}
+function buildPageHint(toolName, remaining, cursorArg, args, delivered, filterHint) {
+    // Tight format: tag `pg` is one BPE token in modern tokenizers. Filter hint
+    // is included only when narrowing actually helps. Legend in
+    // SIGNAL_PREFIX_LEGEND / instruction-writer.ts already explains the pattern.
+    //
+    // Concrete cursor: surface the *next* offset/page so the caller can paste it
+    // back. For offset-style cursors, next = (current offset) + (items delivered
+    // this page). For page-style cursors, next = (current page) + 1.
+    const filter = filterHint ? `/${filterHint}` : "";
+    let nextCursor;
+    if (cursorArg === "page") {
+        const curPage = typeof args.page === "number" && args.page > 0 ? args.page : 1;
+        nextCursor = curPage + 1;
+    }
+    else {
+        const curOffset = typeof args.offset === "number" && args.offset >= 0 ? args.offset : 0;
+        nextCursor = curOffset + delivered;
+    }
+    return `ur|pg ${toolName} +${remaining} — ${cursorArg}:${nextCursor}${filter}`;
+}
+/**
+ * Apply the per-tool cap to the response body and produce a page hint when
+ * truncation occurred. Pure: does not mutate the input.
+ */
+export function applyWireCap(toolName, rawBody, args) {
+    const byteCap = resolveByteCap(args);
+    const cap = PER_TOOL_CAPS[toolName];
+    if (!cap) {
+        // Tool not in the cap table — apply only the hard byte safety net.
+        return enforceByteCap(toolName, rawBody, args, null, byteCap);
+    }
+    const limit = resolveLimit(cap, args[cap.cursorArg]);
+    // Top-level array (e.g. search_code returns a uniform array directly).
+    if (!cap.arrayKey && Array.isArray(rawBody)) {
+        if (rawBody.length <= limit)
+            return enforceByteCap(toolName, rawBody, args, null, byteCap);
+        const total = rawBody.length;
+        const sliced = rawBody.slice(0, limit);
+        const hint = buildPageHint(toolName, total - limit, cap.cursorArg, args, sliced.length, cap.filterHint);
+        return enforceByteCap(toolName, sliced, args, hint, byteCap);
+    }
+    // Wrapper object pattern: {<arrayKey>: [...], ...rest}
+    if (cap.arrayKey &&
+        typeof rawBody === "object" &&
+        rawBody !== null &&
+        cap.arrayKey in rawBody) {
+        const obj = rawBody;
+        const arr = obj[cap.arrayKey];
+        if (Array.isArray(arr) && arr.length > limit) {
+            // We're slicing here. Preserve the handler's `total` if it already
+            // knew the true count (e.g. get_references: handler returns 25 items
+            // but reports total:30 because it truncated upstream). Otherwise
+            // fall back to arr.length.
+            const handlerTotal = typeof obj.total === "number" && obj.total > arr.length
+                ? obj.total
+                : arr.length;
+            const sliced = arr.slice(0, limit);
+            const newBody = {
+                ...obj,
+                [cap.arrayKey]: sliced,
+                total: handlerTotal,
+                returned: sliced.length,
+                more_available: handlerTotal - sliced.length,
+                truncated: handlerTotal > sliced.length,
+            };
+            const hint = buildPageHint(toolName, handlerTotal - sliced.length, cap.cursorArg, args, sliced.length, cap.filterHint);
+            return enforceByteCap(toolName, newBody, args, hint, byteCap);
+        }
+        // The handler may have pre-sliced (e.g., recall_facts caps inside its
+        // handler). Surface a page hint if `more_available` was already set.
+        const moreAvailable = obj.more_available;
+        if (typeof moreAvailable === "number" && moreAvailable > 0) {
+            const deliveredCount = Array.isArray(arr) ? arr.length : 0;
+            const hint = buildPageHint(toolName, moreAvailable, cap.cursorArg, args, deliveredCount, cap.filterHint);
+            return enforceByteCap(toolName, rawBody, args, hint, byteCap);
+        }
+        return enforceByteCap(toolName, rawBody, args, null, byteCap);
+    }
+    return enforceByteCap(toolName, rawBody, args, null, byteCap);
+}
+/**
+ * Last line of defence: if the rendered body still blows past HARD_BYTE_CAP,
+ * drop a `too_large` summary instead of streaming a context-overflowing payload.
+ * The body and the page-hint string both name the *concrete* lever the caller
+ * should pull next: a numeric token_budget that would have fit, the
+ * entity/limit they already passed, and (when the call is already maximally
+ * narrow) the recommendation to read in offset/limit chunks.
+ */
+function enforceByteCap(toolName, body, args, existingHint = null, byteCap = HARD_BYTE_CAP) {
+    const serialized = typeof body === "string" ? body : JSON.stringify(body);
+    if (serialized.length <= byteCap) {
+        return { body, pageHint: existingHint };
+    }
+    // Compute the numeric token budget that would have fit this response. Round
+    // up to the next 100 so the caller doesn't bounce off a fractional miss.
+    const neededTokensRaw = Math.ceil(serialized.length / BYTES_PER_TOKEN);
+    const neededTokens = Math.ceil(neededTokensRaw / 100) * 100;
+    const cappedBudget = Math.min(neededTokens, MAX_BYTE_CAP / BYTES_PER_TOKEN);
+    const requestedBudget = typeof args.token_budget === "number" && args.token_budget > 0
+        ? Math.floor(args.token_budget)
+        : null;
+    const currentBudgetTokens = Math.floor(byteCap / BYTES_PER_TOKEN);
+    // Was the caller already narrowed by entity/key/name? If so the only
+    // remaining lever is token_budget (or splitting via offset/limit).
+    const entityArg = args.entity ??
+        args.key ??
+        args.name ??
+        null;
+    const hasLimit = typeof args.limit === "number" && args.limit > 0;
+    const hasOffset = typeof args.offset === "number" && args.offset >= 0;
+    let hintTail;
+    let reason;
+    if (entityArg) {
+        // Entity is already the narrowest selector. Don't tell the caller to
+        // narrow further by entity — they did.
+        reason = "entity_too_large";
+        hintTail = `pass token_budget:${cappedBudget} or read in offset/limit chunks`;
+    }
+    else if (hasLimit || hasOffset) {
+        // Already paginated; suggest a smaller window AND the budget bump.
+        reason = "page_too_large";
+        const suggestedLimit = hasLimit
+            ? Math.max(1, Math.floor(args.limit * (byteCap / serialized.length)))
+            : null;
+        const limitHint = suggestedLimit
+            ? `limit:${suggestedLimit}`
+            : "smaller limit";
+        hintTail = `${limitHint} or token_budget:${cappedBudget}`;
+    }
+    else if (byteCap > HARD_BYTE_CAP) {
+        // Budget was already lifted but still overflowed — caller must narrow.
+        reason = "narrow_required";
+        hintTail = `narrow with entity:<name> or limit:<n> (token_budget=${currentBudgetTokens} already lifted)`;
+    }
+    else {
+        reason = "too_large";
+        hintTail = `narrow with entity:<name>/limit:<n> or token_budget:${cappedBudget}`;
+    }
+    const oversize = {
+        status: "too_large",
+        reason,
+        bytes: serialized.length,
+        cap_bytes: byteCap,
+        needed_tokens: neededTokens,
+        suggested_token_budget: cappedBudget,
+        tool: toolName,
+    };
+    if (requestedBudget !== null) {
+        oversize.requested_token_budget = requestedBudget;
+    }
+    if (entityArg) {
+        oversize.entity = entityArg;
+    }
+    const overHint = `ur|pg ${toolName} ${serialized.length}B>${byteCap}B (≈${neededTokens}tok) — ${hintTail}`;
+    return { body: oversize, pageHint: overHint };
+}

package/dist/schemas/api/skills.js

@@ -0,0 +1,19 @@
+/**
+ * Zod schemas for the skill download & installation API.
+ *
+ * GET /api/cli/skills?ide={ide}&repoId={repoId}
+ */
+import { z } from "zod";
+export const SkillSchema = z.object({
+    /** Skill identifier (e.g. "unerr-atlas", "unerr-health") */
+    name: z.string(),
+    /** Human-readable description */
+    description: z.string(),
+    /** Skill content (Markdown) */
+    content: z.string(),
+    /** Skill version */
+    version: z.string().optional(),
+});
+export const SkillsResponseSchema = z.object({
+    skills: z.array(SkillSchema),
+});

package/dist/schemas/common/errors.js

@@ -0,0 +1,7 @@
+/**
+ * Standard error response schema shared across all API endpoints.
+ */
+import { z } from "zod";
+export const ErrorResponseSchema = z.object({
+    error: z.string(),
+});

package/dist/schemas/common/headers.js

@@ -0,0 +1,5 @@
+/**
+ * Constants for custom HTTP headers used across CLI-server communication.
+ */
+export const HEADER_SESSION_ID = "x-unerr-session-id";
+export const HEADER_INTENT_ID = "x-unerr-intent-id";

package/dist/schemas/entities/edge.js

@@ -0,0 +1,25 @@
+/**
+ * EdgeDoc schema — represents a relationship edge in the graph snapshot.
+ *
+ * Matches the CompactEdge interface in intelligence/local-graph.ts.
+ * Includes CFG (control-flow graph) fields present on "calls" and
+ * "mutates_state" edge types.
+ */
+import { z } from "zod";
+export const EdgeDocSchema = z.object({
+    from_key: z.string(),
+    to_key: z.string(),
+    type: z.string(),
+    // CFG control-flow fields
+    seq: z.number().optional(),
+    cond: z.string().optional(),
+    br: z.string().optional(),
+    lp: z.boolean().optional(),
+    lk: z.string().optional(),
+    nd: z.number().optional(),
+    tg: z.boolean().optional(),
+    eh: z.boolean().optional(),
+    mt: z.string().optional(),
+    mm: z.string().optional(),
+    mo: z.string().optional(),
+});

package/dist/schemas/entities/entity.js

@@ -0,0 +1,22 @@
+/**
+ * EntityDoc schema — represents a code entity in the graph snapshot.
+ *
+ * Matches the CompactEntity interface in intelligence/local-graph.ts.
+ */
+import { z } from "zod";
+export const EntityDocSchema = z.object({
+    key: z.string(),
+    kind: z.string(),
+    name: z.string(),
+    file_path: z.string(),
+    start_line: z.number().optional(),
+    signature: z.string().optional(),
+    body: z.string().optional(),
+    fan_in: z.number().optional(),
+    fan_out: z.number().optional(),
+    risk_level: z.enum(["high", "medium", "normal"]).optional(),
+    purpose: z.string().optional(),
+    taxonomy: z.string().optional(),
+    feature_area: z.string().optional(),
+    justification_confidence: z.number().optional(),
+});

package/dist/schemas/entities/rule.js

@@ -0,0 +1,18 @@
+/**
+ * RuleDoc schema — represents a code rule in the graph snapshot.
+ *
+ * Matches the CompactRule interface in intelligence/local-graph.ts.
+ */
+import { z } from "zod";
+export const RuleDocSchema = z.object({
+    key: z.string(),
+    name: z.string(),
+    scope: z.string(),
+    severity: z.string(),
+    engine: z.string(),
+    query: z.string(),
+    message: z.string(),
+    file_glob: z.string(),
+    enabled: z.boolean(),
+    repo_id: z.string(),
+});

package/dist/schemas/index.js

@@ -0,0 +1,14 @@
+/**
+ * Barrel export for shared Zod schemas.
+ *
+ * Local-first edition: only entity, edge, rule schemas and skill types.
+ */
+// ── Entity Schemas ─────────────────────────────────────────────────────
+export { EntityDocSchema, } from "./entities/entity.js";
+export { EdgeDocSchema, } from "./entities/edge.js";
+export { RuleDocSchema, } from "./entities/rule.js";
+// ── Skill Schema ──────────────────────────────────────────────────────
+export { SkillSchema, SkillsResponseSchema, } from "./api/skills.js";
+// ── Common ─────────────────────────────────────────────────────────────
+export { ErrorResponseSchema, } from "./common/errors.js";
+export { HEADER_SESSION_ID, HEADER_INTENT_ID, } from "./common/headers.js";

package/dist/server/event-bus.js

@@ -0,0 +1,59 @@
+/**
+ * Layer 7: Process-wide event bus for dashboard SSE transport.
+ *
+ * Bridges tool_call, drift, violation, circuit_breaker, and intent payloads to
+ * the SSE stream. The stream also emits session_stats and ping (not from the
+ * buffer). Circular buffer: 100 events for reconnect backfill.
+ */
+const BUFFER_SIZE = 100;
+class EventBus {
+    listeners = new Set();
+    buffer = [];
+    bufferIdx = 0;
+    bufferFull = false;
+    emit(type, data) {
+        const event = { type, data, timestamp: Date.now() };
+        // Write to circular buffer
+        this.buffer[this.bufferIdx] = event;
+        this.bufferIdx = (this.bufferIdx + 1) % BUFFER_SIZE;
+        if (this.bufferIdx === 0)
+            this.bufferFull = true;
+        // Notify all listeners
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // Never let a listener crash the emitter
+            }
+        }
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    /**
+     * Return recent events for SSE backfill (oldest first).
+     */
+    getRecentEvents(limit = 20) {
+        const total = this.bufferFull ? BUFFER_SIZE : this.bufferIdx;
+        if (total === 0)
+            return [];
+        const events = [];
+        const start = this.bufferFull ? this.bufferIdx : 0;
+        for (let i = 0; i < total; i++) {
+            const idx = (start + i) % BUFFER_SIZE;
+            const event = this.buffer[idx];
+            if (event)
+                events.push(event);
+        }
+        return events.slice(-limit);
+    }
+    get listenerCount() {
+        return this.listeners.size;
+    }
+}
+/** Singleton instance — shared across the entire proxy process. */
+export const eventBus = new EventBus();