@unerr-ai/unerr 0.2.1 → 0.2.3

package/dist/proxy/transport-mux.js

@@ -1,229 +0,0 @@
-/**
- * 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

@@ -1,268 +0,0 @@
-/**
- * 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/rules/developer.mozilla.org.json

@@ -1,9 +0,0 @@
-{
-  "host": "developer.mozilla.org",
-  "description": "Drop MDN language-selector and 'Find a translation' chrome lines.",
-  "drop": [
-    "^\\s*\\[Find a translation\\][^\\n]*$",
-    "^\\s*In this article\\s*$",
-    "^\\s*\\* \\[.*Edit this page.*\\][^\\n]*$"
-  ]
-}

package/dist/rules/github.com.json

@@ -1,21 +0,0 @@
-{
-  "host": "github.com",
-  "description": "Drop README badge image lines, GitHub UI chrome, and signed-out repo banner from extracted markdown.",
-  "drop": [
-    "^\\s*!\\[[^\\]]*\\]\\(https://img\\.shields\\.io[^)]*\\)\\s*$",
-    "^\\s*!\\[[^\\]]*\\]\\(https://badge\\.fury\\.io[^)]*\\)\\s*$",
-    "^\\s*!\\[[^\\]]*\\]\\(https://[^)]*badge[^)]*\\)\\s*$",
-    "^\\s*\\[!\\[[^\\]]*\\]\\([^)]+\\)\\]\\([^)]+\\)\\s*$"
-  ],
-  "extractor": {
-    "removeSelectors": [
-      "header.Header",
-      "div.js-header-wrapper",
-      "footer.footer",
-      "div.notification-shelf",
-      "div.flash-warn",
-      "details.dropdown",
-      "div.Bgc-shadow-secondary"
-    ]
-  }
-}

package/dist/schemas/api/skills.js

@@ -1,19 +0,0 @@
-/**
- * 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

@@ -1,7 +0,0 @@
-/**
- * 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

@@ -1,5 +0,0 @@
-/**
- * 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

@@ -1,25 +0,0 @@
-/**
- * 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

@@ -1,22 +0,0 @@
-/**
- * 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

@@ -1,18 +0,0 @@
-/**
- * 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

@@ -1,14 +0,0 @@
-/**
- * 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";