@smallironman/mcp-memory-keeper 0.12.2-fork1

package/bin/mcp-memory-keeper

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+/**
+ * MCP Memory Keeper CLI
+ * This wrapper ensures the server runs correctly when invoked via npx
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// Determine the data directory
+const DATA_DIR = process.env.DATA_DIR || path.join(os.homedir(), 'mcp-data', 'memory-keeper');
+
+// Ensure data directory exists
+if (!fs.existsSync(DATA_DIR)) {
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+}
+
+// Set environment variable for the server
+process.env.DATA_DIR = DATA_DIR;
+
+// Get the path to the actual server
+const serverPath = path.join(__dirname, '..', 'dist', 'index.js');
+
+// Check if the server is built
+if (!fs.existsSync(serverPath)) {
+  console.error('Error: Server not built. This should not happen with the npm package.');
+  console.error(
+    'Please report this issue at: https://github.com/mkreyman/mcp-memory-keeper/issues'
+  );
+  process.exit(1);
+}
+
+// Change to data directory (where context.db will be created)
+process.chdir(DATA_DIR);
+
+// Spawn the server
+const child = spawn(process.execPath, [serverPath, ...process.argv.slice(2)], {
+  stdio: 'inherit',
+  env: process.env,
+});
+
+// Handle exit
+child.on('exit', code => {
+  process.exit(code);
+});
+
+// Handle errors
+child.on('error', err => {
+  console.error('Failed to start memory-keeper server:', err);
+  process.exit(1);
+});

package/dist/__tests__/e2e/issue33-reproduce.test.js

@@ -0,0 +1,234 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+/**
+ * Issue #33 reproduction test.
+ *
+ * Reproduces the exact scenario reported: spawn the MCP server with each
+ * tool profile (minimal, standard, full), call tools/list, and validate
+ * that every returned tool schema passes strict JSON Schema validation
+ * that OpenAI-compatible providers enforce.
+ *
+ * The reporter found:
+ *   - minimal: works
+ *   - standard: works
+ *   - full: fails (context_delegate.input.insights missing items)
+ *
+ * After the fix, all three profiles must pass.
+ *
+ * @see https://github.com/mkreyman/mcp-memory-keeper/issues/33
+ */
+/**
+ * Strict schema validation matching what OpenAI-compatible providers enforce.
+ * Returns violation strings. Empty array = valid.
+ */
+function strictValidateSchema(prop, path, toolName) {
+    const violations = [];
+    if (!prop.type) {
+        violations.push(`${toolName}: ${path} — missing 'type'`);
+        return violations;
+    }
+    // Arrays MUST have items (the exact bug from issue #33)
+    if (prop.type === 'array' && !prop.items) {
+        violations.push(`${toolName}: ${path} — array missing 'items' (issue #33)`);
+    }
+    // Enum values must match declared type
+    if (prop.enum && prop.type === 'string') {
+        for (const val of prop.enum) {
+            if (typeof val !== 'string') {
+                violations.push(`${toolName}: ${path} — enum value '${val}' is not a string`);
+            }
+        }
+    }
+    // Required fields must exist in properties
+    if (prop.type === 'object' && prop.required && prop.properties) {
+        for (const req of prop.required) {
+            if (!(req in prop.properties)) {
+                violations.push(`${toolName}: ${path} — required '${req}' not in properties`);
+            }
+        }
+    }
+    // Recurse into object properties
+    if (prop.type === 'object' && prop.properties) {
+        for (const [key, value] of Object.entries(prop.properties)) {
+            violations.push(...strictValidateSchema(value, `${path}.${key}`, toolName));
+        }
+    }
+    // Recurse into array items
+    if (prop.type === 'array' && prop.items && typeof prop.items === 'object') {
+        violations.push(...strictValidateSchema(prop.items, `${path}.items`, toolName));
+    }
+    return violations;
+}
+/**
+ * Spawn a server with a given TOOL_PROFILE, call tools/list, return the tools.
+ */
+async function getToolsForProfile(profile) {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), `mcp-issue33-${profile}-`));
+    const proc = (0, child_process_1.spawn)('node', [path.join(__dirname, '../../../dist/index.js')], {
+        env: { ...process.env, DATA_DIR: tempDir, TOOL_PROFILE: profile },
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    if (global.testProcesses) {
+        global.testProcesses.push(proc);
+    }
+    let msgId = 0;
+    let outputBuffer = '';
+    const sendRequest = (method, params = {}) => {
+        return new Promise((resolve, reject) => {
+            const id = ++msgId;
+            const timeout = setTimeout(() => reject(new Error(`Timeout: ${method} on ${profile}`)), 10000);
+            const onData = (data) => {
+                outputBuffer += data.toString();
+                const lines = outputBuffer.split('\n');
+                outputBuffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const msg = JSON.parse(line);
+                        if (msg.id === id) {
+                            clearTimeout(timeout);
+                            proc.stdout?.removeListener('data', onData);
+                            resolve(msg);
+                        }
+                    }
+                    catch {
+                        // skip
+                    }
+                }
+            };
+            proc.stdout?.on('data', onData);
+            proc.stdin?.write(JSON.stringify({ jsonrpc: '2.0', method, params, id }) + '\n');
+        });
+    };
+    // Initialize
+    await sendRequest('initialize', {
+        protocolVersion: '2024-11-05',
+        capabilities: {},
+        clientInfo: { name: 'issue33-repro', version: '1.0.0' },
+    });
+    proc.stdin?.write(JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' }) + '\n');
+    await new Promise(resolve => setTimeout(resolve, 200));
+    // Get tools
+    const response = await sendRequest('tools/list');
+    return { tools: response.result.tools, process: proc, tempDir };
+}
+const profiles = ['minimal', 'standard', 'full'];
+const servers = [];
+(0, globals_1.describe)('Issue #33 reproduction: all profiles must pass strict schema validation', () => {
+    (0, globals_1.afterAll)(async () => {
+        for (const server of servers) {
+            if (server.process && !server.process.killed) {
+                server.process.kill('SIGTERM');
+                await new Promise(resolve => {
+                    const timeout = setTimeout(() => {
+                        server.process?.kill('SIGKILL');
+                        resolve();
+                    }, 3000);
+                    server.process?.on('exit', () => {
+                        clearTimeout(timeout);
+                        resolve();
+                    });
+                });
+                server.process?.removeAllListeners();
+            }
+            try {
+                fs.rmSync(server.tempDir, { recursive: true, force: true });
+            }
+            catch {
+                // ignore
+            }
+        }
+    });
+    for (const profile of profiles) {
+        (0, globals_1.describe)(`TOOL_PROFILE=${profile}`, () => {
+            let tools;
+            beforeAll(async () => {
+                const result = await getToolsForProfile(profile);
+                tools = result.tools;
+                servers.push({ process: result.process, tempDir: result.tempDir });
+            }, 15000);
+            (0, globals_1.it)('should return tools', () => {
+                (0, globals_1.expect)(tools.length).toBeGreaterThan(0);
+            });
+            (0, globals_1.it)('all tool schemas should pass strict validation', () => {
+                const allViolations = [];
+                for (const tool of tools) {
+                    allViolations.push(...strictValidateSchema(tool.inputSchema, 'inputSchema', tool.name));
+                }
+                if (allViolations.length > 0) {
+                    throw new Error(`Profile "${profile}" has ${allViolations.length} schema violation(s):\n` +
+                        allViolations.map(v => `  ${v}`).join('\n'));
+                }
+            });
+            (0, globals_1.it)('specifically: no array property should be missing items', () => {
+                const arrayViolations = [];
+                for (const tool of tools) {
+                    arrayViolations.push(...strictValidateSchema(tool.inputSchema, 'inputSchema', tool.name).filter(v => v.includes('missing')));
+                }
+                (0, globals_1.expect)(arrayViolations).toHaveLength(0);
+            });
+        });
+    }
+    // The reporter specifically bisected these tools
+    (0, globals_1.describe)('reporter-flagged tools', () => {
+        let fullTools;
+        beforeAll(async () => {
+            const result = await getToolsForProfile('full');
+            fullTools = result.tools;
+            servers.push({ process: result.process, tempDir: result.tempDir });
+        }, 15000);
+        const flaggedTools = [
+            'context_delegate',
+            'context_find_related',
+            'context_visualize',
+            'context_branch_session',
+        ];
+        for (const toolName of flaggedTools) {
+            (0, globals_1.it)(`${toolName} should pass strict schema validation`, () => {
+                const tool = fullTools.find((t) => t.name === toolName);
+                (0, globals_1.expect)(tool).toBeDefined();
+                const violations = strictValidateSchema(tool.inputSchema, 'inputSchema', toolName);
+                (0, globals_1.expect)(violations).toHaveLength(0);
+            });
+        }
+    });
+});

package/dist/__tests__/e2e/server-e2e.test.js

@@ -0,0 +1,341 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+/**
+ * End-to-end tests for the MCP Memory Keeper server.
+ *
+ * These tests spawn the actual server process over stdio, send real MCP
+ * protocol messages, and validate the responses. Unlike integration tests
+ * that instantiate internal classes directly, these exercise the full stack:
+ * transport → protocol → handler → database → response.
+ *
+ * @see https://github.com/mkreyman/mcp-memory-keeper/issues/33
+ */
+// Valid JSON Schema types per the spec
+const VALID_JSON_SCHEMA_TYPES = new Set([
+    'string',
+    'number',
+    'integer',
+    'boolean',
+    'array',
+    'object',
+    'null',
+]);
+let serverProcess = null;
+let tempDir;
+let msgId = 0;
+let outputBuffer = '';
+/** Send a JSON-RPC message to the server and wait for a response with the matching id. */
+function sendRequest(method, params = {}, timeoutMs = 5000) {
+    return new Promise((resolve, reject) => {
+        const id = ++msgId;
+        const timeout = setTimeout(() => {
+            reject(new Error(`Timeout waiting for response to ${method} (id=${id})`));
+        }, timeoutMs);
+        const onData = (data) => {
+            outputBuffer += data.toString();
+            const lines = outputBuffer.split('\n');
+            // Keep the last incomplete line in the buffer
+            outputBuffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const msg = JSON.parse(line);
+                    if (msg.id === id) {
+                        clearTimeout(timeout);
+                        serverProcess?.stdout?.removeListener('data', onData);
+                        resolve(msg);
+                    }
+                }
+                catch {
+                    // Not JSON, skip
+                }
+            }
+        };
+        serverProcess?.stdout?.on('data', onData);
+        serverProcess?.stdin?.write(JSON.stringify({ jsonrpc: '2.0', method, params, id }) + '\n');
+    });
+}
+/**
+ * Recursively validate a JSON Schema property definition.
+ * Returns an array of human-readable violation strings.
+ */
+function validateSchemaProperty(prop, path, toolName) {
+    const violations = [];
+    // Every property should have a type
+    if (!prop.type) {
+        violations.push(`${toolName}: ${path} — missing 'type'`);
+        return violations; // Can't validate further without type
+    }
+    // Type must be a valid JSON Schema type
+    if (!VALID_JSON_SCHEMA_TYPES.has(prop.type)) {
+        violations.push(`${toolName}: ${path} — invalid type '${prop.type}'`);
+    }
+    // Arrays must have items
+    if (prop.type === 'array' && !prop.items) {
+        violations.push(`${toolName}: ${path} — type 'array' missing 'items'`);
+    }
+    // If enum is present, values should match the declared type
+    if (prop.enum && prop.type) {
+        for (const val of prop.enum) {
+            if (prop.type === 'string' && typeof val !== 'string') {
+                violations.push(`${toolName}: ${path} — enum value '${val}' is not a string`);
+            }
+            if (prop.type === 'number' && typeof val !== 'number') {
+                violations.push(`${toolName}: ${path} — enum value '${val}' is not a number`);
+            }
+        }
+    }
+    // Required must reference existing properties
+    if (prop.type === 'object' && prop.required && prop.properties) {
+        for (const req of prop.required) {
+            if (!(req in prop.properties)) {
+                violations.push(`${toolName}: ${path} — required field '${req}' not found in properties`);
+            }
+        }
+    }
+    // Recurse into object properties
+    if (prop.type === 'object' && prop.properties) {
+        for (const [key, value] of Object.entries(prop.properties)) {
+            violations.push(...validateSchemaProperty(value, `${path}.${key}`, toolName));
+        }
+    }
+    // Recurse into array items
+    if (prop.type === 'array' && prop.items && typeof prop.items === 'object') {
+        violations.push(...validateSchemaProperty(prop.items, `${path}.items`, toolName));
+    }
+    return violations;
+}
+(0, globals_1.describe)('MCP Server E2E Tests', () => {
+    (0, globals_1.beforeAll)(async () => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcp-e2e-'));
+        serverProcess = (0, child_process_1.spawn)('node', [path.join(__dirname, '../../../dist/index.js')], {
+            env: { ...process.env, DATA_DIR: tempDir },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        if (global.testProcesses) {
+            global.testProcesses.push(serverProcess);
+        }
+        // Initialize the MCP session
+        const initResponse = await sendRequest('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'e2e-test', version: '1.0.0' },
+        });
+        (0, globals_1.expect)(initResponse.result).toHaveProperty('protocolVersion');
+        // Send initialized notification (no response expected)
+        serverProcess?.stdin?.write(JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' }) + '\n');
+        // Brief pause for server to process the notification
+        await new Promise(resolve => setTimeout(resolve, 200));
+    }, 10000);
+    (0, globals_1.afterAll)(async () => {
+        if (serverProcess && !serverProcess.killed) {
+            serverProcess.kill('SIGTERM');
+            await new Promise(resolve => {
+                const timeout = setTimeout(() => {
+                    serverProcess?.kill('SIGKILL');
+                    resolve();
+                }, 3000);
+                serverProcess?.on('exit', () => {
+                    clearTimeout(timeout);
+                    resolve();
+                });
+            });
+            serverProcess?.removeAllListeners();
+        }
+        serverProcess = null;
+        try {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch {
+            // ignore cleanup errors
+        }
+    });
+    // ─── ListTools Schema Validation ────────────────────────────────────
+    (0, globals_1.describe)('tools/list — schema validation', () => {
+        let tools;
+        (0, globals_1.beforeAll)(async () => {
+            const response = await sendRequest('tools/list');
+            (0, globals_1.expect)(response.result).toHaveProperty('tools');
+            tools = response.result.tools;
+        });
+        (0, globals_1.it)('should return a non-empty list of tools', () => {
+            (0, globals_1.expect)(tools.length).toBeGreaterThan(0);
+        });
+        (0, globals_1.it)('every tool should have name, description, and inputSchema', () => {
+            for (const tool of tools) {
+                (0, globals_1.expect)(tool).toHaveProperty('name');
+                (0, globals_1.expect)(tool).toHaveProperty('description');
+                (0, globals_1.expect)(tool).toHaveProperty('inputSchema');
+                (0, globals_1.expect)(typeof tool.name).toBe('string');
+                (0, globals_1.expect)(typeof tool.description).toBe('string');
+                (0, globals_1.expect)(tool.name.length).toBeGreaterThan(0);
+                (0, globals_1.expect)(tool.description.length).toBeGreaterThan(0);
+            }
+        });
+        (0, globals_1.it)('every tool name should follow the context_ convention', () => {
+            for (const tool of tools) {
+                (0, globals_1.expect)(tool.name).toMatch(/^context_[a-z_]+$/);
+            }
+        });
+        (0, globals_1.it)('every inputSchema should be type object with properties', () => {
+            for (const tool of tools) {
+                (0, globals_1.expect)(tool.inputSchema.type).toBe('object');
+                (0, globals_1.expect)(tool.inputSchema).toHaveProperty('properties');
+                (0, globals_1.expect)(typeof tool.inputSchema.properties).toBe('object');
+            }
+        });
+        (0, globals_1.it)('no tool names should be duplicated', () => {
+            const names = tools.map((t) => t.name);
+            (0, globals_1.expect)(new Set(names).size).toBe(names.length);
+        });
+        (0, globals_1.it)('every array property should have items declared (issue #33)', () => {
+            const violations = [];
+            for (const tool of tools) {
+                violations.push(...validateSchemaProperty(tool.inputSchema, 'inputSchema', tool.name).filter(v => v.includes("missing 'items'")));
+            }
+            (0, globals_1.expect)(violations).toHaveLength(0);
+        });
+        (0, globals_1.it)('every property type should be a valid JSON Schema type', () => {
+            const violations = [];
+            for (const tool of tools) {
+                violations.push(...validateSchemaProperty(tool.inputSchema, 'inputSchema', tool.name).filter(v => v.includes('invalid type')));
+            }
+            (0, globals_1.expect)(violations).toHaveLength(0);
+        });
+        (0, globals_1.it)('every required field should reference an existing property', () => {
+            const violations = [];
+            for (const tool of tools) {
+                violations.push(...validateSchemaProperty(tool.inputSchema, 'inputSchema', tool.name).filter(v => v.includes('not found in properties')));
+            }
+            (0, globals_1.expect)(violations).toHaveLength(0);
+        });
+        (0, globals_1.it)('enum values should match their declared type', () => {
+            const violations = [];
+            for (const tool of tools) {
+                violations.push(...validateSchemaProperty(tool.inputSchema, 'inputSchema', tool.name).filter(v => v.includes('enum value')));
+            }
+            (0, globals_1.expect)(violations).toHaveLength(0);
+        });
+        (0, globals_1.it)('full schema validation should find zero violations across all tools', () => {
+            const allViolations = [];
+            for (const tool of tools) {
+                allViolations.push(...validateSchemaProperty(tool.inputSchema, 'inputSchema', tool.name));
+            }
+            if (allViolations.length > 0) {
+                throw new Error(`Found ${allViolations.length} schema violation(s):\n${allViolations.map(v => `  ${v}`).join('\n')}`);
+            }
+        });
+    });
+    // ─── Tool Call Smoke Tests ──────────────────────────────────────────
+    (0, globals_1.describe)('tools/call — smoke tests', () => {
+        (0, globals_1.it)('should save and retrieve a context item', async () => {
+            // Save
+            const saveResponse = await sendRequest('tools/call', {
+                name: 'context_save',
+                arguments: {
+                    key: 'e2e_test_key',
+                    value: 'e2e_test_value',
+                    category: 'note',
+                },
+            });
+            (0, globals_1.expect)(saveResponse.result).toHaveProperty('content');
+            const saveText = saveResponse.result.content[0].text;
+            (0, globals_1.expect)(saveText).toContain('e2e_test_key');
+            // Retrieve
+            const getResponse = await sendRequest('tools/call', {
+                name: 'context_get',
+                arguments: { key: 'e2e_test_key' },
+            });
+            (0, globals_1.expect)(getResponse.result).toHaveProperty('content');
+            const getResult = JSON.parse(getResponse.result.content[0].text);
+            (0, globals_1.expect)(getResult.items).toBeDefined();
+            (0, globals_1.expect)(getResult.items.length).toBeGreaterThan(0);
+            (0, globals_1.expect)(getResult.items[0].value).toBe('e2e_test_value');
+        });
+        (0, globals_1.it)('should search for saved items', async () => {
+            const response = await sendRequest('tools/call', {
+                name: 'context_search',
+                arguments: { query: 'e2e_test' },
+            });
+            (0, globals_1.expect)(response.result).toHaveProperty('content');
+            const text = response.result.content[0].text;
+            (0, globals_1.expect)(text).toContain('e2e_test');
+        });
+        (0, globals_1.it)('should return status', async () => {
+            const response = await sendRequest('tools/call', {
+                name: 'context_status',
+                arguments: {},
+            });
+            (0, globals_1.expect)(response.result).toHaveProperty('content');
+            const text = response.result.content[0].text;
+            // Status response contains session info regardless of format
+            (0, globals_1.expect)(text.length).toBeGreaterThan(0);
+            (0, globals_1.expect)(text).toMatch(/session|item/i);
+        });
+        (0, globals_1.it)('should reject unknown tools with an error', async () => {
+            const response = await sendRequest('tools/call', {
+                name: 'nonexistent_tool',
+                arguments: {},
+            });
+            // MCP SDK wraps handler errors
+            (0, globals_1.expect)(response.error || response.result?.isError).toBeTruthy();
+        });
+        (0, globals_1.it)('should handle missing required arguments gracefully', async () => {
+            const response = await sendRequest('tools/call', {
+                name: 'context_save',
+                arguments: {},
+            });
+            (0, globals_1.expect)(response.result).toHaveProperty('content');
+            const text = response.result.content[0].text;
+            // Should return an error message, not crash
+            (0, globals_1.expect)(text.toLowerCase()).toMatch(/error|required|key/i);
+        });
+    });
+    // ─── Tool Profile Filtering ────────────────────────────────────────
+    (0, globals_1.describe)('tool profile filtering', () => {
+        (0, globals_1.it)('default profile should expose all tools', async () => {
+            const response = await sendRequest('tools/list');
+            // Default is "full" profile with 38 tools
+            (0, globals_1.expect)(response.result.tools.length).toBe(38);
+        });
+    });
+});