@kinqs/brainrouter-mcp-server 0.3.4

package/dist/__tests__/api-routes.test.js

@@ -0,0 +1,170 @@
+import express from "express";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+vi.mock("../memory/engine.js", () => ({
+    memoryEngine: {
+        capturePassiveL0: vi.fn((params) => ({
+            id: `l0-${params.sessionKey}`,
+            userId: "user-1",
+            sessionKey: params.sessionKey,
+            sessionId: "",
+            role: "tool",
+            messageText: "{}",
+            recordedAt: new Date().toISOString(),
+            timestamp: Date.now(),
+            skillTag: "host:claude-code",
+        })),
+        getUserByApiKey: vi.fn((apiKey) => {
+            if (apiKey === "br_admin") {
+                return {
+                    userId: "admin",
+                    isAdmin: true,
+                    email: "admin@example.test",
+                    status: "active",
+                };
+            }
+            if (apiKey === "br_user") {
+                return {
+                    userId: "user-1",
+                    isAdmin: false,
+                    email: "user@example.test",
+                    status: "active",
+                };
+            }
+            return null;
+        }),
+        getUserById: vi.fn(() => ({
+            userId: "user-1",
+            isAdmin: false,
+            email: "user@example.test",
+            status: "active",
+        })),
+        store: {
+            deleteContextualFocus: vi.fn(),
+        },
+    },
+}));
+async function createServer() {
+    const [{ workingRouter }, { hooksRouter }, { scenesRouter }] = await Promise.all([
+        import("../api/routes/working.js"),
+        import("../api/routes/hooks.js"),
+        import("../api/routes/scenes.js"),
+    ]);
+    const app = express();
+    app.use(express.json());
+    app.use("/api/working", workingRouter);
+    app.use("/api/hooks", hooksRouter);
+    app.use("/api/scenes", scenesRouter);
+    const server = app.listen(0);
+    await new Promise((resolve) => server.once("listening", resolve));
+    const address = server.address();
+    if (!address || typeof address === "string")
+        throw new Error("No test server port");
+    return { server, baseUrl: `http://127.0.0.1:${address.port}` };
+}
+describe("Phase 4 and 5 API routes", () => {
+    let server;
+    let baseUrl = "";
+    beforeEach(async () => {
+        const created = await createServer();
+        server = created.server;
+        baseUrl = created.baseUrl;
+    });
+    afterEach(async () => {
+        await new Promise((resolve, reject) => {
+            server.close((error) => error ? reject(error) : resolve());
+        });
+    });
+    it("serves working context, offload, and reset endpoints", async () => {
+        const workspacePath = mkdtempSync(join(tmpdir(), "brainrouter-api-working-"));
+        const auth = { Authorization: "Bearer br_user" };
+        const offload = await fetch(`${baseUrl}/api/working/offload`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", ...auth },
+            body: JSON.stringify({
+                workspacePath,
+                sessionKey: "api-working-session",
+                payload: "tool output",
+                title: "Tool output",
+            }),
+        });
+        expect(offload.status).toBe(201);
+        const offloadJson = await offload.json();
+        expect(offloadJson.nodeId).toMatch(/^w/);
+        const context = await fetch(`${baseUrl}/api/working/context?sessionKey=api-working-session&workspacePath=${encodeURIComponent(workspacePath)}`, {
+            headers: auth,
+        });
+        expect(context.status).toBe(200);
+        const contextJson = await context.json();
+        expect(contextJson.canvas).toContain("flowchart TD");
+        expect(contextJson.steps).toHaveLength(1);
+        const reset = await fetch(`${baseUrl}/api/working/reset`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", ...auth },
+            body: JSON.stringify({ workspacePath, sessionKey: "api-working-session" }),
+        });
+        expect(reset.status).toBe(200);
+        const resetJson = await reset.json();
+        expect(resetJson.deleted).toBe(true);
+    });
+    it("registers hooks and reports status", async () => {
+        const auth = { Authorization: "Bearer br_user" };
+        const register = await fetch(`${baseUrl}/api/hooks/register`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", ...auth },
+            body: JSON.stringify({
+                source: "claude-code",
+                events: ["PostToolUse"],
+                sessionKey: "api-hook-session",
+                event: "PostToolUse",
+                payload: { tool_name: "Bash", tool_input: { command: "echo ok" } },
+            }),
+        });
+        expect(register.status).toBe(201);
+        const registerJson = await register.json();
+        expect(registerJson.captureResult.l0RecordedCount).toBe(1);
+        const status = await fetch(`${baseUrl}/api/hooks/status?source=claude-code`, { headers: auth });
+        expect(status.status).toBe(200);
+        const statusJson = await status.json();
+        expect(statusJson.hooks.some((hook) => hook.id === "user-1:claude-code:api-hook-session" && hook.userId === "user-1")).toBe(true);
+    });
+    it("rejects non-admin hook registration for another user", async () => {
+        const response = await fetch(`${baseUrl}/api/hooks/register`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Authorization: "Bearer br_user" },
+            body: JSON.stringify({
+                source: "codex",
+                userId: "other-user",
+                sessionKey: "blocked-session",
+            }),
+        });
+        expect(response.status).toBe(403);
+    });
+    it("rejects non-admin working memory access for another user", async () => {
+        const workspacePath = mkdtempSync(join(tmpdir(), "brainrouter-api-working-rbac-"));
+        const response = await fetch(`${baseUrl}/api/working/context?sessionKey=blocked-session&userId=other-user&workspacePath=${encodeURIComponent(workspacePath)}`, {
+            headers: { Authorization: "Bearer br_user" },
+        });
+        expect(response.status).toBe(403);
+    });
+    it("rejects non-admin hook status reads for another user", async () => {
+        const response = await fetch(`${baseUrl}/api/hooks/status?userId=other-user`, {
+            headers: { Authorization: "Bearer br_user" },
+        });
+        expect(response.status).toBe(403);
+    });
+    it("evicts scenes via delete endpoint", async () => {
+        const auth = { Authorization: "Bearer br_user" };
+        const response = await fetch(`${baseUrl}/api/scenes/scene-123`, {
+            method: "DELETE",
+            headers: auth,
+        });
+        expect(response.status).toBe(200);
+        const json = await response.json();
+        expect(json.success).toBe(true);
+        const { memoryEngine } = await import("../memory/engine.js");
+        expect(memoryEngine.store.deleteContextualFocus).toHaveBeenCalledWith("user-1", ["scene-123"]);
+    });
+});

package/dist/__tests__/crypto.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/crypto.test.js

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { hashPassword, signJwt, verifyJwt, verifyPassword } from "../api/auth/crypto.js";
+describe("crypto auth helpers", () => {
+    it("hashPassword + verifyPassword round-trip", async () => {
+        const stored = await hashPassword("S3cret123!");
+        await expect(verifyPassword("S3cret123!", stored)).resolves.toBe(true);
+    });
+    it("verifyPassword fails with wrong password", async () => {
+        const stored = await hashPassword("S3cret123!");
+        await expect(verifyPassword("wrong", stored)).resolves.toBe(false);
+    });
+    it("signJwt + verifyJwt round-trip", () => {
+        const token = signJwt({ userId: "u1", isAdmin: true }, "secret", 60);
+        const payload = verifyJwt(token, "secret");
+        expect(payload).not.toBeNull();
+        expect(payload?.userId).toBe("u1");
+        expect(payload?.isAdmin).toBe(true);
+    });
+    it("verifyJwt returns null for expired token", () => {
+        const token = signJwt({ userId: "u1" }, "secret", -1);
+        expect(verifyJwt(token, "secret")).toBeNull();
+    });
+    it("verifyJwt returns null for tampered signature", () => {
+        const token = signJwt({ userId: "u1" }, "secret", 60);
+        const tampered = `${token.slice(0, -1)}x`;
+        expect(verifyJwt(tampered, "secret")).toBeNull();
+    });
+});

package/dist/__tests__/host-integrations.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/host-integrations.test.js

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+import { processClaudeCodeHook } from "../integrations/claude-code.js";
+import { listHostHooks, registerHostHook } from "../integrations/generic-mcp.js";
+describe("host integrations", () => {
+    it("captures a Claude Code PostToolUse event as redacted L0 memory", async () => {
+        const records = [];
+        const engine = {
+            capturePassiveL0(params) {
+                const record = {
+                    id: "l0-test",
+                    userId: "user-1",
+                    sessionKey: "claude-session",
+                    sessionId: "",
+                    role: "tool",
+                    messageText: params.content,
+                    recordedAt: new Date().toISOString(),
+                    timestamp: Date.now(),
+                    skillTag: params.skillTag ?? "",
+                };
+                records.push(record);
+                return record;
+            },
+        };
+        const result = await processClaudeCodeHook(engine, {
+            event: "PostToolUse",
+            userId: "user-1",
+            sessionKey: "claude-session",
+            tool_name: "Bash",
+            tool_input: {
+                command: "curl -H 'Authorization: Bearer sk-test-key-value' https://example.test",
+                apiKey: "sk-test-key-value",
+            },
+        }, "default");
+        expect(result.l0RecordedCount).toBe(1);
+        expect(records).toHaveLength(1);
+        expect(records[0].skillTag).toBe("host:claude-code");
+        expect(records[0].messageText).toContain("PostToolUse");
+        expect(records[0].messageText).toContain("Bash");
+        expect(records[0].messageText).not.toContain("sk-test-key-value");
+        expect(records[0].messageText).toContain("[REDACTED]");
+    });
+    it("registers hooks and reports last-seen status", async () => {
+        registerHostHook({
+            userId: "user-1",
+            source: "claude-code",
+            events: ["PreToolUse", "PostToolUse", "Stop", "SubagentStop"],
+            sessionKey: "status-session",
+        });
+        const status = { hooks: listHostHooks("user-1").filter((hook) => hook.source === "claude-code") };
+        expect(status.hooks.some((hook) => hook.id === "user-1:claude-code:status-session")).toBe(true);
+    });
+    it("resolves workspacePath from registration database if omitted in a Stop event", async () => {
+        registerHostHook({
+            userId: "user-1",
+            source: "claude-code",
+            events: ["Stop"],
+            sessionKey: "session-without-path",
+            workspacePath: "/resolved/path/from/db",
+        });
+        const engine = {
+            capturePassiveL0(params) {
+                return {
+                    id: "l0-test",
+                    userId: params.userId,
+                    sessionKey: params.sessionKey,
+                    sessionId: params.sessionId ?? "",
+                    role: params.role,
+                    messageText: params.content,
+                    recordedAt: new Date().toISOString(),
+                    timestamp: params.timestamp ?? Date.now(),
+                    skillTag: params.skillTag ?? "",
+                };
+            },
+        };
+        const result = await processClaudeCodeHook(engine, {
+            event: "Stop",
+            userId: "user-1",
+            sessionKey: "session-without-path",
+        }, "default");
+        expect(result.flushedWorkingMemory).toBe(true);
+    });
+});

package/dist/__tests__/integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/integration.test.js

@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest';
+import { Registry } from '../registry.js';
+import { resolveRegistryConfig } from '../resolver.js';
+import { loadSkillSection } from '../loader.js';
+import { existsSync } from 'fs';
+describe('BrainRouter Skill Compliance', () => {
+    const config = resolveRegistryConfig();
+    const registry = new Registry(config);
+    registry.build();
+    const allSkills = registry.listSkills(); // No arguments = all categories, all scopes
+    it('should have indexed skills', () => {
+        expect(allSkills.length).toBeGreaterThan(0);
+    });
+    // Dynamically create a test case for every single skill in the repo
+    allSkills.forEach((skill) => {
+        describe(`Skill: ${skill.name}`, () => {
+            it('should have valid frontmatter (name and description)', () => {
+                expect(skill.name).toBeDefined();
+                expect(skill.description).toBeDefined();
+                expect(skill.description.length).toBeGreaterThan(10);
+            });
+            it('should have a Workflow or Core Process section', () => {
+                const fragment = loadSkillSection(skill.filePath, 'workflow');
+                // If it returns the "Section not found" comment, it means it failed to find a workflow
+                expect(fragment.content).not.toContain('Section "workflow" not found');
+                expect(fragment.content.length).toBeGreaterThan(50);
+            });
+            it('should have an Overview section', () => {
+                const fragment = loadSkillSection(skill.filePath, 'overview');
+                expect(fragment.content).not.toContain('Section "overview" not found');
+            });
+            it('should produce a valid token estimate', () => {
+                const fragment = loadSkillSection(skill.filePath, 'full');
+                expect(fragment.tokenEstimate).toBeGreaterThan(0);
+            });
+        });
+    });
+});
+describe('BrainRouter Persona Compliance', () => {
+    const config = resolveRegistryConfig();
+    const registry = new Registry(config);
+    registry.build();
+    const personas = registry.listPersonas();
+    personas.forEach((persona) => {
+        it(`Persona "${persona.name}" should be a valid markdown file`, () => {
+            expect(existsSync(persona.filePath)).toBe(true);
+            expect(persona.filePath.endsWith('.md')).toBe(true);
+        });
+    });
+});

package/dist/__tests__/loader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/loader.test.js

@@ -0,0 +1,89 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { loadSkillSection, loadDescription } from '../loader.js';
+import { writeFileSync, mkdirSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+describe('loader.ts', () => {
+    const testDir = join(tmpdir(), 'brainrouter-loader-test');
+    beforeEach(() => {
+        rmSync(testDir, { recursive: true, force: true });
+        mkdirSync(testDir, { recursive: true });
+    });
+    it('should extract frontmatter description', () => {
+        const filePath = join(testDir, 'SKILL.md');
+        writeFileSync(filePath, '---\nname: test-skill\ndescription: A test description\n---\n# Content');
+        const fragment = loadDescription(filePath);
+        expect(fragment.content).toBe('A test description');
+    });
+    it('should extract a named section', () => {
+        const filePath = join(testDir, 'SKILL.md');
+        const content = `---
+name: test-skill
+description: test
+---
+# Test Skill
+## Overview
+This is the overview.
+## Workflow
+1. Step 1
+2. Step 2
+`;
+        writeFileSync(filePath, content);
+        const fragment = loadSkillSection(filePath, 'workflow');
+        expect(fragment.content).toContain('## Workflow');
+        expect(fragment.content).toContain('1. Step 1');
+        expect(fragment.content).not.toContain('## Overview');
+    });
+    it('should handle section aliases', () => {
+        const filePath = join(testDir, 'SKILL.md');
+        const content = `---
+name: test-skill
+description: test
+---
+## Core Process
+Specific process steps here.
+`;
+        writeFileSync(filePath, content);
+        // "workflow" should match "Core Process"
+        const fragment = loadSkillSection(filePath, 'workflow');
+        expect(fragment.content).toContain('## Core Process');
+        expect(fragment.content).toContain('Specific process steps here.');
+    });
+    it('should extract phases (### Phase N)', () => {
+        const filePath = join(testDir, 'SKILL.md');
+        const content = `---
+name: test-skill
+description: test
+---
+## Steps
+### Phase 1: Planning
+Do this first.
+### Phase 2: Execution
+Do this second.
+## Other Section
+Noise.
+`;
+        writeFileSync(filePath, content);
+        const fragment = loadSkillSection(filePath, 'phases');
+        expect(fragment.content).toContain('### Phase 1');
+        expect(fragment.content).toContain('### Phase 2');
+        expect(fragment.content).not.toContain('## Other Section');
+    });
+    it('should extract checklists', () => {
+        const filePath = join(testDir, 'SKILL.md');
+        const content = `---
+name: test-skill
+description: test
+---
+## Verification
+- [ ] Task 1
+- [x] Task 2
+- Not a task.
+`;
+        writeFileSync(filePath, content);
+        const fragment = loadSkillSection(filePath, 'checklist');
+        expect(fragment.content).toContain('- [ ] Task 1');
+        expect(fragment.content).toContain('- [x] Task 2');
+        expect(fragment.content).not.toContain('Not a task.');
+    });
+});

package/dist/__tests__/neural-spark.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/neural-spark.test.js

@@ -0,0 +1,112 @@
+import { describe, expect, it } from "vitest";
+import { NeuralSparkEngine } from "../memory/pipeline/neural-spark.js";
+class MockMemoryStore {
+    connections = [];
+    memories = new Map();
+    upsertConnection(userId, sourceId, targetId, weight) {
+        const existing = this.connections.find(c => c.sourceId === sourceId && c.targetId === targetId);
+        if (existing) {
+            existing.weight = weight;
+            existing.lastActivatedAt = new Date().toISOString();
+        }
+        else {
+            this.connections.push({ sourceId, targetId, weight, lastActivatedAt: new Date().toISOString() });
+        }
+    }
+    getConnectionsForSource(userId, sourceId) {
+        return this.connections
+            .filter(c => c.sourceId === sourceId)
+            .map(c => ({ targetId: c.targetId, weight: c.weight }));
+    }
+    strengthenConnectionsBatch(userId, pairs, delta) {
+        for (const pair of pairs) {
+            // Bi-directional
+            this.upsertConnection(userId, pair.source, pair.target, Math.min(1.0, this.getWeight(pair.source, pair.target) + delta));
+            this.upsertConnection(userId, pair.target, pair.source, Math.min(1.0, this.getWeight(pair.target, pair.source) + delta));
+        }
+    }
+    decayConnections(userId, decayFactor) {
+        for (const conn of this.connections) {
+            conn.weight = Math.max(0.0, conn.weight * decayFactor);
+        }
+    }
+    pruneConnections(userId, threshold) {
+        this.connections = this.connections.filter(c => c.weight >= threshold);
+    }
+    getWeight(sourceId, targetId) {
+        const c = this.connections.find(conn => conn.sourceId === sourceId && conn.targetId === targetId);
+        return c ? c.weight : 0.5; // Default baseline is 0.5
+    }
+}
+describe("Neural Spark Engine & Spreading Activation", () => {
+    it("should propagate potentials to neighbors correctly up to 2 hops", () => {
+        const store = new MockMemoryStore();
+        const engine = new NeuralSparkEngine(store);
+        // Setup network: A -> B -> C
+        // Weight A -> B: 0.8
+        // Weight B -> C: 0.9
+        store.upsertConnection("user-1", "node-A", "node-B", 0.8);
+        store.upsertConnection("user-1", "node-B", "node-C", 0.9);
+        // Initial inputs: node-A starts with potential 1.0 (fired)
+        const initialNodes = [
+            { id: "node-A", potential: 1.0, fired: false },
+            { id: "node-B", potential: 0.0, fired: false },
+            { id: "node-C", potential: 0.0, fired: false },
+        ];
+        const results = engine.propagateSparks("user-1", initialNodes);
+        // Node-B potential = 1.0 * 0.8 = 0.8 (since 0.8 >= 0.7, it fires)
+        // Node-C potential = 0.8 * 0.9 = 0.72 (since 0.72 >= 0.7, it fires)
+        const nodeA = results.find(n => n.id === "node-A");
+        const nodeB = results.find(n => n.id === "node-B");
+        const nodeC = results.find(n => n.id === "node-C");
+        expect(nodeA?.fired).toBe(true);
+        expect(nodeB?.fired).toBe(true);
+        expect(nodeB?.potential).toBeCloseTo(0.8);
+        expect(nodeC?.fired).toBe(true);
+        expect(nodeC?.potential).toBeCloseTo(0.72);
+    });
+    it("should respect refractory period and avoid double firing/infinite loops", () => {
+        const store = new MockMemoryStore();
+        const engine = new NeuralSparkEngine(store);
+        // Cycle network: A -> B -> A
+        store.upsertConnection("user-1", "node-A", "node-B", 0.9);
+        store.upsertConnection("user-1", "node-B", "node-A", 0.9);
+        const initialNodes = [
+            { id: "node-A", potential: 1.0, fired: false },
+        ];
+        const results = engine.propagateSparks("user-1", initialNodes);
+        const nodeA = results.find(n => n.id === "node-A");
+        const nodeB = results.find(n => n.id === "node-B");
+        expect(nodeA?.fired).toBe(true);
+        expect(nodeB?.fired).toBe(true);
+        // Node-A potential shouldn't loop indefinitely
+        expect(nodeA?.potential).toBe(1.0);
+    });
+    it("should strengthen co-cited pairs (Hebbian LTP)", () => {
+        const store = new MockMemoryStore();
+        const engine = new NeuralSparkEngine(store);
+        // Initial connection weight = 0.5
+        store.upsertConnection("user-1", "node-A", "node-B", 0.5);
+        store.upsertConnection("user-1", "node-B", "node-A", 0.5);
+        // Co-cite A and B
+        engine.strengthenSpines("user-1", ["node-A", "node-B"]);
+        const connections = store.getConnectionsForSource("user-1", "node-A");
+        const abConn = connections.find(c => c.targetId === "node-B");
+        // LTP step is 0.15, so 0.5 + 0.15 = 0.65
+        expect(abConn?.weight).toBeCloseTo(0.65);
+    });
+    it("should decay weights and prune weak connections (LTD)", () => {
+        const store = new MockMemoryStore();
+        const engine = new NeuralSparkEngine(store);
+        // node-A -> node-B: weight 0.8 (decays to 0.72)
+        // node-A -> node-C: weight 0.1 (decays to 0.09 and gets pruned < 0.10)
+        store.upsertConnection("user-1", "node-A", "node-B", 0.8);
+        store.upsertConnection("user-1", "node-A", "node-C", 0.1);
+        engine.decayAndPrune("user-1");
+        const connections = store.getConnectionsForSource("user-1", "node-A");
+        const abConn = connections.find(c => c.targetId === "node-B");
+        const acConn = connections.find(c => c.targetId === "node-C");
+        expect(abConn?.weight).toBeCloseTo(0.72);
+        expect(acConn).toBeUndefined(); // Pruned!
+    });
+});

package/dist/__tests__/pagination.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/pagination.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { decodeCursor, encodeCursor, pageItems, PaginationQuerySchema } from "../api/pagination.js";
+describe("cursor pagination", () => {
+    it("encodes and decodes opaque cursor payloads", () => {
+        const cursor = encodeCursor({ createdTime: "2026-05-19T00:00:00.000Z", recordId: "l1-1" });
+        expect(decodeCursor(cursor)).toEqual({ createdTime: "2026-05-19T00:00:00.000Z", recordId: "l1-1" });
+        expect(() => decodeCursor("not-a-cursor")).toThrow("Invalid cursor");
+    });
+    it("validates cursor query params and caps page size", () => {
+        expect(PaginationQuerySchema.parse({ limit: "2" })).toEqual({ limit: 2 });
+        expect(() => PaginationQuerySchema.parse({ limit: "101" })).toThrow();
+    });
+    it("returns a next cursor only when more items exist", () => {
+        const page = pageItems([{ id: "a" }, { id: "b" }, { id: "c" }], 2, (item) => ({ id: item.id }));
+        expect(page.items).toEqual([{ id: "a" }, { id: "b" }]);
+        expect(decodeCursor(page.nextCursor ?? undefined)).toEqual({ id: "b" });
+    });
+    it("omits next cursor when the result set fits in one page", () => {
+        const page = pageItems([{ id: "a" }], 2, (item) => ({ id: item.id }));
+        expect(page.items).toEqual([{ id: "a" }]);
+        expect(page.nextCursor).toBeNull();
+    });
+});

package/dist/__tests__/redaction.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/redaction.test.js

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import { redactSensitiveMemoryText } from "../memory/redaction.js";
+describe("memory redaction", () => {
+    it("redacts tokens and env-style secrets before capture", () => {
+        const redacted = redactSensitiveMemoryText("Bearer sk-test-key-value\nSECRET_TOKEN=abc123");
+        expect(redacted).not.toContain("sk-test-key-value");
+        expect(redacted).not.toContain("SECRET_TOKEN=abc123");
+        expect(redacted).toContain("[REDACTED]");
+    });
+    it("redacts database connection strings and IPv4 addresses", () => {
+        const redacted = redactSensitiveMemoryText("Connect to postgresql://admin:s3cret@10.0.0.5:5432/app from 192.168.1.10");
+        expect(redacted).not.toContain("s3cret");
+        expect(redacted).not.toContain("192.168.1.10");
+        expect(redacted).toContain("[REDACTED_CONN_STR]");
+        expect(redacted).toContain("[REDACTED_IP]");
+    });
+});

package/dist/__tests__/registry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/registry.test.js

@@ -0,0 +1,56 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Registry } from '../registry.js';
+import { writeFileSync, mkdirSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+describe('registry.ts', () => {
+    const globalRoot = join(tmpdir(), 'brainrouter-registry-test-global');
+    const localRoot = join(tmpdir(), 'brainrouter-registry-test-local');
+    beforeEach(() => {
+        rmSync(globalRoot, { recursive: true, force: true });
+        rmSync(localRoot, { recursive: true, force: true });
+        mkdirSync(join(globalRoot, 'skills', 'agent', 'global-skill'), { recursive: true });
+        mkdirSync(join(localRoot, 'skills', 'agent', 'local-skill'), { recursive: true });
+        mkdirSync(join(localRoot, 'docs', 'api'), { recursive: true });
+        mkdirSync(join(globalRoot, 'agents'), { recursive: true });
+        mkdirSync(join(localRoot, 'agents'), { recursive: true });
+        writeFileSync(join(globalRoot, 'skills', 'agent', 'global-skill', 'SKILL.md'), '---\nname: global-skill\ndescription: global desc\n---\n');
+        writeFileSync(join(localRoot, 'skills', 'agent', 'local-skill', 'SKILL.md'), '---\nname: local-skill\ndescription: local desc\n---\n');
+        writeFileSync(join(localRoot, 'docs', 'api', 'API.md'), '# API');
+        writeFileSync(join(globalRoot, 'agents', 'global-persona.md'), 'global persona content');
+        writeFileSync(join(localRoot, 'agents', 'local-persona.md'), 'local persona content');
+    });
+    it('should index both global and local skills', () => {
+        const registry = new Registry({ globalRoot, localRoot });
+        registry.build();
+        const skills = registry.listSkills();
+        expect(skills.length).toBe(2);
+        expect(skills.find(s => s.name === 'global-skill')?.scope).toBe('global');
+        expect(skills.find(s => s.name === 'local-skill')?.scope).toBe('local');
+    });
+    it('should shadow global skills with local ones if names conflict', () => {
+        // Create a local skill with same name as global
+        mkdirSync(join(localRoot, 'skills', 'agent', 'global-skill'), { recursive: true });
+        writeFileSync(join(localRoot, 'skills', 'agent', 'global-skill', 'SKILL.md'), '---\nname: global-skill\ndescription: shadowed desc\n---\n');
+        const registry = new Registry({ globalRoot, localRoot });
+        registry.build();
+        const skill = registry.getSkill('global-skill');
+        expect(skill?.scope).toBe('local');
+        expect(skill?.description).toBe('shadowed desc');
+    });
+    it('should index local docs', () => {
+        const registry = new Registry({ globalRoot, localRoot });
+        registry.build();
+        const docs = registry.listDocs();
+        expect(docs.length).toBe(1);
+        expect(docs[0].name).toBe('api');
+    });
+    it('should index both global and local personas (agents)', () => {
+        const registry = new Registry({ globalRoot, localRoot });
+        registry.build();
+        const personas = registry.listPersonas();
+        expect(personas.length).toBe(2);
+        expect(personas.find(p => p.name === 'global-persona')).toBeDefined();
+        expect(personas.find(p => p.name === 'local-persona')).toBeDefined();
+    });
+});

package/dist/__tests__/retry.test.d.ts

@@ -0,0 +1 @@
+export {};