@crowley/rag-mcp 1.5.0 → 1.6.0

package/dist/__tests__/tool-middleware.test.js

@@ -1,83 +1,83 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { summarizeInput, countResults, formatToolError, TRACKING_EXCLUDE, SESSION_TOOLS, TOOL_TIMEOUTS, } from '../tool-middleware.js';
-describe('Tool Middleware', () => {
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { summarizeInput, countResults, formatToolError, TRACKING_EXCLUDE, SESSION_TOOLS, TOOL_TIMEOUTS, } from "../tool-middleware.js";
+describe("Tool Middleware", () => {
     beforeEach(() => {
         vi.resetAllMocks();
     });
-    describe('summarizeInput', () => {
-        it('extracts query field', () => {
-            expect(summarizeInput('search', { query: 'find auth code' })).toBe('find auth code');
+    describe("summarizeInput", () => {
+        it("extracts query field", () => {
+            expect(summarizeInput("search", { query: "find auth code" })).toBe("find auth code");
         });
-        it('extracts question field', () => {
-            expect(summarizeInput('ask', { question: 'what is auth?' })).toBe('what is auth?');
+        it("extracts question field", () => {
+            expect(summarizeInput("ask", { question: "what is auth?" })).toBe("what is auth?");
         });
-        it('extracts content field as fallback', () => {
-            expect(summarizeInput('remember', { content: 'important note' })).toBe('important note');
+        it("extracts content field as fallback", () => {
+            expect(summarizeInput("remember", { content: "important note" })).toBe("important note");
         });
-        it('extracts file path as fallback', () => {
-            expect(summarizeInput('explain', { filePath: 'src/auth.ts' })).toBe('src/auth.ts');
+        it("extracts file path as fallback", () => {
+            expect(summarizeInput("explain", { filePath: "src/auth.ts" })).toBe("src/auth.ts");
         });
-        it('truncates long strings to 200 chars', () => {
-            const long = 'a'.repeat(300);
-            expect(summarizeInput('search', { query: long }).length).toBeLessThanOrEqual(200);
+        it("truncates long strings to 200 chars", () => {
+            const long = "a".repeat(300);
+            expect(summarizeInput("search", { query: long }).length).toBeLessThanOrEqual(200);
         });
-        it('returns tool name when no useful field', () => {
-            expect(summarizeInput('get_stats', {})).toBe('get_stats');
+        it("returns tool name when no useful field", () => {
+            expect(summarizeInput("get_stats", {})).toBe("get_stats");
         });
     });
-    describe('countResults', () => {
+    describe("countResults", () => {
         it('returns 0 for "No results" messages', () => {
-            expect(countResults('No results found.')).toBe(0);
+            expect(countResults("No results found.")).toBe(0);
         });
         it('returns 0 for "not found" messages', () => {
-            expect(countResults('Memory not found')).toBe(0);
+            expect(countResults("Memory not found")).toBe(0);
         });
-        it('counts numbered items', () => {
-            const text = '1. First\n2. Second\n3. Third';
+        it("counts numbered items", () => {
+            const text = "1. First\n2. Second\n3. Third";
             expect(countResults(text)).toBe(3);
         });
-        it('counts bullet items', () => {
-            const text = '- item1\n- item2';
+        it("counts bullet items", () => {
+            const text = "- item1\n- item2";
             expect(countResults(text)).toBe(2);
         });
-        it('returns 1 for generic content', () => {
-            expect(countResults('Some response text')).toBe(1);
+        it("returns 1 for generic content", () => {
+            expect(countResults("Some response text")).toBe(1);
         });
     });
-    describe('formatToolError', () => {
+    describe("formatToolError", () => {
         const ctx = {
-            api: { defaults: { baseURL: 'http://localhost:3100' } },
+            api: { defaults: { baseURL: "http://localhost:3100" } },
         };
-        it('formats ECONNREFUSED error', () => {
-            const err = { code: 'ECONNREFUSED' };
+        it("formats ECONNREFUSED error", () => {
+            const err = { code: "ECONNREFUSED" };
             const result = formatToolError(err, ctx);
-            expect(result).toContain('Cannot connect');
-            expect(result).toContain('localhost:3100');
+            expect(result).toContain("Cannot connect");
+            expect(result).toContain("localhost:3100");
         });
-        it('formats API error with status', () => {
-            const err = { response: { status: 404, data: { error: 'not found' } } };
+        it("formats API error with status", () => {
+            const err = { response: { status: 404, data: { error: "not found" } } };
             const result = formatToolError(err, ctx);
-            expect(result).toContain('404');
+            expect(result).toContain("404");
         });
-        it('formats generic error message', () => {
-            const err = { message: 'Something broke' };
+        it("formats generic error message", () => {
+            const err = { message: "Something broke" };
             const result = formatToolError(err, ctx);
-            expect(result).toContain('Something broke');
+            expect(result).toContain("Something broke");
         });
     });
-    describe('constants', () => {
-        it('TRACKING_EXCLUDE contains meta tools', () => {
-            expect(TRACKING_EXCLUDE.has('get_tool_analytics')).toBe(true);
-            expect(TRACKING_EXCLUDE.has('get_quality_metrics')).toBe(true);
-        });
-        it('SESSION_TOOLS contains session management', () => {
-            expect(SESSION_TOOLS.has('start_session')).toBe(true);
-            expect(SESSION_TOOLS.has('end_session')).toBe(true);
-        });
-        it('TOOL_TIMEOUTS has correct tiers', () => {
-            expect(TOOL_TIMEOUTS['index_codebase']).toBe(120_000);
-            expect(TOOL_TIMEOUTS['search_codebase']).toBe(15_000);
-            expect(TOOL_TIMEOUTS['recall']).toBe(10_000);
+    describe("constants", () => {
+        it("TRACKING_EXCLUDE contains meta tools", () => {
+            expect(TRACKING_EXCLUDE.has("get_tool_analytics")).toBe(true);
+            expect(TRACKING_EXCLUDE.has("get_quality_metrics")).toBe(true);
+        });
+        it("SESSION_TOOLS contains session management", () => {
+            expect(SESSION_TOOLS.has("start_session")).toBe(true);
+            expect(SESSION_TOOLS.has("end_session")).toBe(true);
+        });
+        it("TOOL_TIMEOUTS has correct tiers", () => {
+            expect(TOOL_TIMEOUTS["index_codebase"]).toBe(120_000);
+            expect(TOOL_TIMEOUTS["search_codebase"]).toBe(15_000);
+            expect(TOOL_TIMEOUTS["recall"]).toBe(10_000);
         });
     });
 });

package/dist/__tests__/tools/memory.test.js

@@ -1,5 +1,5 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createMemoryTools } from '../../tools/memory.js';
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createMemoryTools } from "../../tools/memory.js";
 function createMockCtx() {
     return {
         api: {
@@ -7,121 +7,136 @@ function createMockCtx() {
             get: vi.fn(),
             delete: vi.fn(),
             patch: vi.fn(),
-            defaults: { baseURL: 'http://localhost:3100' },
+            defaults: { baseURL: "http://localhost:3100" },
         },
-        projectName: 'testproject',
-        projectPath: '/tmp/testproject',
-        collectionPrefix: 'testproject',
+        projectName: "testproject",
+        projectPath: "/tmp/testproject",
+        collectionPrefix: "testproject",
         enrichmentEnabled: false,
     };
 }
-describe('Memory Tools', () => {
+describe("Memory Tools", () => {
     let tools;
     let ctx;
     beforeEach(() => {
         vi.resetAllMocks();
-        tools = createMemoryTools('testproject');
+        tools = createMemoryTools("testproject");
         ctx = createMockCtx();
     });
     function findTool(name) {
         return tools.find((t) => t.name === name);
     }
-    describe('remember', () => {
-        it('stores memory and returns formatted result', async () => {
-            const mem = { id: 'mem-1', type: 'note', content: 'test note', createdAt: new Date().toISOString() };
+    describe("remember", () => {
+        it("stores memory and returns formatted result", async () => {
+            const mem = {
+                id: "mem-1",
+                type: "note",
+                content: "test note",
+                createdAt: new Date().toISOString(),
+            };
             ctx.api.post.mockResolvedValue({ data: { memory: mem } });
-            const result = await findTool('remember').handler({ content: 'test note', type: 'note', tags: ['tag1'] }, ctx);
-            expect(ctx.api.post).toHaveBeenCalledWith('/api/memory', expect.objectContaining({
-                projectName: 'testproject',
-                content: 'test note',
-                type: 'note',
+            const result = await findTool("remember").handler({ content: "test note", type: "note", tags: ["tag1"] }, ctx);
+            expect(ctx.api.post).toHaveBeenCalledWith("/api/memory", expect.objectContaining({
+                projectName: "testproject",
+                content: "test note",
+                type: "note",
             }));
-            expect(result).toContain('Memory stored');
-            expect(result).toContain('mem-1');
+            expect(result).toContain("Memory stored");
+            expect(result).toContain("mem-1");
         });
     });
-    describe('recall', () => {
-        it('returns formatted results', async () => {
+    describe("recall", () => {
+        it("returns formatted results", async () => {
             ctx.api.post.mockResolvedValue({
                 data: {
                     results: [
-                        { memory: { type: 'insight', content: 'found it', createdAt: new Date().toISOString(), tags: [] }, score: 0.85 },
+                        {
+                            memory: {
+                                type: "insight",
+                                content: "found it",
+                                createdAt: new Date().toISOString(),
+                                tags: [],
+                            },
+                            score: 0.85,
+                        },
                     ],
                 },
             });
-            const result = await findTool('recall').handler({ query: 'find something', limit: 5 }, ctx);
-            expect(result).toContain('Recalled Memories');
+            const result = await findTool("recall").handler({ query: "find something", limit: 5 }, ctx);
+            expect(result).toContain("Recalled Memories");
         });
-        it('returns empty message when no results', async () => {
+        it("returns empty message when no results", async () => {
             ctx.api.post.mockResolvedValue({ data: { results: [] } });
-            const result = await findTool('recall').handler({ query: 'nothing' }, ctx);
-            expect(result).toContain('No memories found');
+            const result = await findTool("recall").handler({ query: "nothing" }, ctx);
+            expect(result).toContain("No memories found");
         });
     });
-    describe('forget', () => {
-        it('deletes by memoryId', async () => {
+    describe("forget", () => {
+        it("deletes by memoryId", async () => {
             ctx.api.delete.mockResolvedValue({ data: { success: true } });
-            const result = await findTool('forget').handler({ memoryId: 'mem-1' }, ctx);
-            expect(ctx.api.delete).toHaveBeenCalledWith(expect.stringContaining('/api/memory/mem-1'));
-            expect(result).toContain('deleted');
+            const result = await findTool("forget").handler({ memoryId: "mem-1" }, ctx);
+            expect(ctx.api.delete).toHaveBeenCalledWith(expect.stringContaining("/api/memory/mem-1"));
+            expect(result).toContain("deleted");
         });
-        it('deletes by type', async () => {
+        it("deletes by type", async () => {
             ctx.api.delete.mockResolvedValue({ data: {} });
-            const result = await findTool('forget').handler({ type: 'note' }, ctx);
-            expect(ctx.api.delete).toHaveBeenCalledWith(expect.stringContaining('/api/memory/type/note'));
-            expect(result).toContain('note');
+            const result = await findTool("forget").handler({ type: "note" }, ctx);
+            expect(ctx.api.delete).toHaveBeenCalledWith(expect.stringContaining("/api/memory/type/note"));
+            expect(result).toContain("note");
         });
-        it('deletes by olderThanDays', async () => {
+        it("deletes by olderThanDays", async () => {
             ctx.api.post.mockResolvedValue({ data: { deleted: 10 } });
-            const result = await findTool('forget').handler({ olderThanDays: 30 }, ctx);
-            expect(ctx.api.post).toHaveBeenCalledWith('/api/memory/forget-older', expect.objectContaining({
+            const result = await findTool("forget").handler({ olderThanDays: 30 }, ctx);
+            expect(ctx.api.post).toHaveBeenCalledWith("/api/memory/forget-older", expect.objectContaining({
                 olderThanDays: 30,
             }));
-            expect(result).toContain('10');
+            expect(result).toContain("10");
         });
-        it('returns message when nothing specified', async () => {
-            const result = await findTool('forget').handler({}, ctx);
-            expect(result).toContain('specify');
+        it("returns message when nothing specified", async () => {
+            const result = await findTool("forget").handler({}, ctx);
+            expect(result).toContain("specify");
         });
     });
-    describe('promote_memory', () => {
-        it('promotes and returns formatted result', async () => {
-            const mem = { id: 'mem-1', type: 'insight', content: 'promoted' };
+    describe("promote_memory", () => {
+        it("promotes and returns formatted result", async () => {
+            const mem = { id: "mem-1", type: "insight", content: "promoted" };
             ctx.api.post.mockResolvedValue({ data: { memory: mem } });
-            const result = await findTool('promote_memory').handler({ memoryId: 'mem-1', reason: 'human_validated' }, ctx);
-            expect(result).toContain('promoted to durable');
-            expect(result).toContain('mem-1');
+            const result = await findTool("promote_memory").handler({ memoryId: "mem-1", reason: "human_validated" }, ctx);
+            expect(result).toContain("promoted to durable");
+            expect(result).toContain("mem-1");
         });
     });
-    describe('memory_maintenance', () => {
-        it('formats maintenance results', async () => {
+    describe("memory_maintenance", () => {
+        it("formats maintenance results", async () => {
             ctx.api.post.mockResolvedValue({
                 data: {
-                    quarantine_cleanup: { rejected: ['q-1', 'q-2'], errors: [] },
-                    feedback_maintenance: { promoted: ['f-1'], pruned: [], errors: [] },
+                    quarantine_cleanup: { rejected: ["q-1", "q-2"], errors: [] },
+                    feedback_maintenance: { promoted: ["f-1"], pruned: [], errors: [] },
                 },
             });
-            const result = await findTool('memory_maintenance').handler({}, ctx);
-            expect(result).toContain('Maintenance Results');
-            expect(result).toContain('Quarantine Cleanup');
-            expect(result).toContain('Feedback Maintenance');
+            const result = await findTool("memory_maintenance").handler({}, ctx);
+            expect(result).toContain("Maintenance Results");
+            expect(result).toContain("Quarantine Cleanup");
+            expect(result).toContain("Feedback Maintenance");
         });
     });
-    describe('batch_remember', () => {
-        it('stores multiple memories', async () => {
+    describe("batch_remember", () => {
+        it("stores multiple memories", async () => {
             ctx.api.post.mockResolvedValue({
                 data: {
                     savedCount: 2,
                     memories: [
-                        { id: 'b-1', type: 'note', content: 'first' },
-                        { id: 'b-2', type: 'insight', content: 'second' },
+                        { id: "b-1", type: "note", content: "first" },
+                        { id: "b-2", type: "insight", content: "second" },
                     ],
                     errors: [],
                 },
             });
-            const result = await findTool('batch_remember').handler({ items: [{ content: 'first' }, { content: 'second', type: 'insight' }] }, ctx);
-            expect(result).toContain('Saved');
-            expect(result).toContain('2');
+            const result = await findTool("batch_remember").handler({
+                items: [{ content: "first" }, { content: "second", type: "insight" }],
+            }, ctx);
+            expect(result).toContain("Saved");
+            expect(result).toContain("2");
         });
     });
 });

package/dist/api-client.d.ts

@@ -1,4 +1,51 @@
 /**
- * API Client - Shared axios instance for RAG API calls.
+ * API Client — lightweight fetch-based HTTP client for RAG API calls.
+ * Drop-in replacement for axios with identical interface at call sites:
+ *   ctx.api.post(path, data)  →  { data: T }
+ *   ctx.api.get(path)         →  { data: T }
+ *   err.response.status / err.code — same shape as AxiosError
+ *
+ * Phase 5: Unix domain socket support via API_SOCKET_PATH env var.
  */
-export declare function createApiClient(ragApiUrl: string, projectName: string, projectPath: string, apiKey?: string): import("axios").AxiosInstance;
+export interface ApiResponse<T = any> {
+    data: T;
+    status: number;
+    headers: Headers;
+}
+export declare class ApiError extends Error {
+    code?: string;
+    response?: {
+        status: number;
+        data: any;
+    };
+    constructor(message: string, opts?: {
+        code?: string;
+        status?: number;
+        data?: any;
+    });
+}
+interface RequestConfig {
+    headers?: Record<string, string>;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+export declare class ApiClient {
+    readonly defaults: {
+        baseURL: string;
+    };
+    private _headers;
+    private _timeout;
+    private _pool?;
+    constructor(baseURL: string, timeout: number, headers: Record<string, string>, socketPath?: string);
+    get<T = any>(path: string, config?: RequestConfig): Promise<ApiResponse<T>>;
+    post<T = any>(path: string, data?: unknown, config?: RequestConfig): Promise<ApiResponse<T>>;
+    patch<T = any>(path: string, data?: unknown, config?: RequestConfig): Promise<ApiResponse<T>>;
+    delete<T = any>(path: string, config?: RequestConfig): Promise<ApiResponse<T>>;
+    private _request;
+    /** Unix socket request via undici Pool */
+    private _requestViaPool;
+    /** Map network errors to axios-compatible ApiError */
+    private _mapNetworkError;
+}
+export declare function createApiClient(ragApiUrl: string, projectName: string, projectPath: string, apiKey?: string): ApiClient;
+export {};

package/dist/api-client.js

@@ -1,7 +1,141 @@
 /**
- * API Client - Shared axios instance for RAG API calls.
+ * API Client — lightweight fetch-based HTTP client for RAG API calls.
+ * Drop-in replacement for axios with identical interface at call sites:
+ *   ctx.api.post(path, data)  →  { data: T }
+ *   ctx.api.get(path)         →  { data: T }
+ *   err.response.status / err.code — same shape as AxiosError
+ *
+ * Phase 5: Unix domain socket support via API_SOCKET_PATH env var.
  */
-import axios from "axios";
+import { Pool } from "undici";
+export class ApiError extends Error {
+    code;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    response;
+    constructor(message, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    opts) {
+        super(message);
+        this.name = "ApiError";
+        if (opts?.code)
+            this.code = opts.code;
+        if (opts?.status !== undefined) {
+            this.response = { status: opts.status, data: opts.data };
+        }
+    }
+}
+export class ApiClient {
+    defaults;
+    _headers;
+    _timeout;
+    _pool;
+    constructor(baseURL, timeout, headers, socketPath) {
+        this.defaults = { baseURL };
+        this._headers = headers;
+        this._timeout = timeout;
+        // Phase 5: Unix domain socket — use undici Pool with socketPath
+        if (socketPath) {
+            this._pool = new Pool("http://localhost", {
+                socketPath,
+                connections: 10,
+                keepAliveTimeout: 30_000,
+            });
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async get(path, config) {
+        return this._request("GET", path, undefined, config);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async post(path, data, config) {
+        return this._request("POST", path, data, config);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async patch(path, data, config) {
+        return this._request("PATCH", path, data, config);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async delete(path, config) {
+        return this._request("DELETE", path, undefined, config);
+    }
+    async _request(method, path, body, config) {
+        const timeout = config?.timeout ?? this._timeout;
+        const signal = config?.signal ?? AbortSignal.timeout(timeout);
+        const headers = { ...this._headers, ...config?.headers };
+        // Phase 5: Unix socket path — use undici Pool directly
+        if (this._pool) {
+            return this._requestViaPool(method, path, body, headers, signal);
+        }
+        // Standard fetch path (TCP)
+        const url = `${this.defaults.baseURL}${path}`;
+        let res;
+        try {
+            res = await fetch(url, {
+                method,
+                headers,
+                body: body !== undefined ? JSON.stringify(body) : undefined,
+                signal,
+            });
+        }
+        catch (err) {
+            throw this._mapNetworkError(err, timeout);
+        }
+        const data = (await res.json().catch(() => null));
+        if (!res.ok) {
+            throw new ApiError(`Request failed with status ${res.status}`, {
+                status: res.status,
+                data,
+            });
+        }
+        return { data, status: res.status, headers: res.headers };
+    }
+    /** Unix socket request via undici Pool */
+    async _requestViaPool(method, path, body, headers, signal) {
+        try {
+            const { statusCode, headers: resHeaders, body: resBody, } = await this._pool.request({
+                method,
+                path,
+                headers,
+                body: body !== undefined ? JSON.stringify(body) : undefined,
+                signal,
+            });
+            const text = await resBody.text();
+            const data = text ? JSON.parse(text) : null;
+            if (statusCode >= 400) {
+                throw new ApiError(`Request failed with status ${statusCode}`, {
+                    status: statusCode,
+                    data,
+                });
+            }
+            // Convert undici headers to standard Headers
+            const stdHeaders = new Headers();
+            for (const [key, val] of Object.entries(resHeaders)) {
+                if (val)
+                    stdHeaders.set(key, Array.isArray(val) ? val.join(", ") : val);
+            }
+            return { data, status: statusCode, headers: stdHeaders };
+        }
+        catch (err) {
+            if (err instanceof ApiError)
+                throw err;
+            throw this._mapNetworkError(err, this._timeout);
+        }
+    }
+    /** Map network errors to axios-compatible ApiError */
+    _mapNetworkError(err, timeout) {
+        const e = err;
+        if (e.cause?.code === "ECONNREFUSED" ||
+            e.message?.includes("ECONNREFUSED")) {
+            return new ApiError("connect ECONNREFUSED", { code: "ECONNREFUSED" });
+        }
+        if (e.name === "TimeoutError" || e.name === "AbortError") {
+            return new ApiError(`timeout of ${timeout}ms exceeded`, {
+                code: "ECONNABORTED",
+            });
+        }
+        return new ApiError(e.message || String(err), { code: e.cause?.code });
+    }
+}
 export function createApiClient(ragApiUrl, projectName, projectPath, apiKey) {
     const headers = {
         "Content-Type": "application/json",
@@ -11,9 +145,7 @@ export function createApiClient(ragApiUrl, projectName, projectPath, apiKey) {
     if (apiKey) {
         headers["Authorization"] = `Bearer ${apiKey}`;
     }
-    return axios.create({
-        baseURL: ragApiUrl,
-        timeout: 120000,
-        headers,
-    });
+    // Phase 5: Use Unix socket if API_SOCKET_PATH is set
+    const socketPath = process.env.API_SOCKET_PATH;
+    return new ApiClient(ragApiUrl, 120_000, headers, socketPath);
 }

package/dist/connection-pool.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Connection pool tuning for RAG API communication.
+ * Configures undici global dispatcher to optimize localhost HTTP calls.
+ *
+ * Env overrides:
+ *   MCP_POOL_CONNECTIONS  — max concurrent connections (default 10)
+ *   MCP_POOL_KEEPALIVE    — keep-alive timeout ms (default 30000)
+ *   MCP_POOL_PIPELINING   — HTTP pipelining depth (default 1; 4 for aggressive)
+ */
+export interface PoolConfig {
+    connections?: number;
+    keepAliveTimeout?: number;
+    pipelining?: number;
+}
+export declare function configureConnectionPool(config?: PoolConfig): void;

package/dist/connection-pool.js

@@ -0,0 +1,24 @@
+/**
+ * Connection pool tuning for RAG API communication.
+ * Configures undici global dispatcher to optimize localhost HTTP calls.
+ *
+ * Env overrides:
+ *   MCP_POOL_CONNECTIONS  — max concurrent connections (default 10)
+ *   MCP_POOL_KEEPALIVE    — keep-alive timeout ms (default 30000)
+ *   MCP_POOL_PIPELINING   — HTTP pipelining depth (default 1; 4 for aggressive)
+ */
+import { Agent, setGlobalDispatcher } from "undici";
+const DEFAULTS = {
+    connections: 10,
+    keepAliveTimeout: 30_000,
+    pipelining: 1,
+};
+export function configureConnectionPool(config) {
+    const merged = { ...DEFAULTS, ...config };
+    const agent = new Agent({
+        connections: merged.connections,
+        keepAliveTimeout: merged.keepAliveTimeout,
+        pipelining: merged.pipelining,
+    });
+    setGlobalDispatcher(agent);
+}

package/dist/context-enrichment.js

@@ -77,7 +77,7 @@ export class ContextEnricher {
         if (!query)
             return null;
         // Check per-session cache
-        const cacheKey = `${ctx.activeSessionId || 'no-session'}:${query.slice(0, 100)}`;
+        const cacheKey = `${ctx.activeSessionId || "no-session"}:${query.slice(0, 100)}`;
         const cached = this.cache.get(cacheKey);
         if (cached && Date.now() < cached.expiresAt) {
             return cached.result;
@@ -214,7 +214,8 @@ export class ContextEnricher {
             // Process general memories
             if (memoriesRes?.data?.memories) {
                 for (const m of memoriesRes.data.memories) {
-                    if (m.score >= this.config.minRelevance && !seenIds.has(m.memory?.id)) {
+                    if (m.score >= this.config.minRelevance &&
+                        !seenIds.has(m.memory?.id)) {
                         seenIds.add(m.memory?.id);
                         memories.push({
                             type: m.memory?.type || "note",
@@ -227,7 +228,8 @@ export class ContextEnricher {
             // Process decisions/ADRs
             if (decisionsRes?.data?.memories) {
                 for (const m of decisionsRes.data.memories) {
-                    if (m.score >= this.config.minRelevance && !seenIds.has(m.memory?.id)) {
+                    if (m.score >= this.config.minRelevance &&
+                        !seenIds.has(m.memory?.id)) {
                         seenIds.add(m.memory?.id);
                         memories.push({
                             type: m.memory?.type || "decision",