@smallironman/mcp-memory-keeper 0.12.2-fork1

package/dist/__tests__/integration/summarization.test.js

@@ -0,0 +1,308 @@
+"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 database_1 = require("../../utils/database");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const uuid_1 = require("uuid");
+describe('Summarization Integration Tests', () => {
+    let dbManager;
+    let tempDbPath;
+    let db;
+    let testSessionId;
+    beforeEach(() => {
+        tempDbPath = path.join(os.tmpdir(), `test-summary-${Date.now()}.db`);
+        dbManager = new database_1.DatabaseManager({
+            filename: tempDbPath,
+            maxSize: 10 * 1024 * 1024,
+            walMode: true,
+        });
+        db = dbManager.getDatabase();
+        // Create test session
+        testSessionId = (0, uuid_1.v4)();
+        db.prepare('INSERT INTO sessions (id, name, description) VALUES (?, ?, ?)').run(testSessionId, 'Summary Test Session', 'Testing summarization functionality');
+    });
+    afterEach(() => {
+        dbManager.close();
+        try {
+            fs.unlinkSync(tempDbPath);
+            fs.unlinkSync(`${tempDbPath}-wal`);
+            fs.unlinkSync(`${tempDbPath}-shm`);
+        }
+        catch (_e) {
+            // Ignore
+        }
+    });
+    describe('context_summarize', () => {
+        beforeEach(() => {
+            // Add diverse test data
+            const items = [
+                // Tasks
+                {
+                    key: 'task_1',
+                    value: 'Implement authentication system',
+                    category: 'task',
+                    priority: 'high',
+                },
+                { key: 'task_2', value: 'Add rate limiting to API', category: 'task', priority: 'high' },
+                {
+                    key: 'task_3',
+                    value: 'Write unit tests for auth module',
+                    category: 'task',
+                    priority: 'normal',
+                },
+                { key: 'task_4', value: 'Update documentation', category: 'task', priority: 'low' },
+                // Decisions
+                {
+                    key: 'decision_1',
+                    value: 'Use JWT for authentication tokens',
+                    category: 'decision',
+                    priority: 'high',
+                },
+                {
+                    key: 'decision_2',
+                    value: 'Set token expiry to 24 hours',
+                    category: 'decision',
+                    priority: 'normal',
+                },
+                // Progress
+                {
+                    key: 'progress_1',
+                    value: 'Completed login endpoint',
+                    category: 'progress',
+                    priority: 'normal',
+                },
+                { key: 'progress_2', value: 'Fixed CORS issues', category: 'progress', priority: 'normal' },
+                // Notes
+                {
+                    key: 'note_1',
+                    value: 'Redis connection string: redis://localhost:6379',
+                    category: 'note',
+                    priority: 'normal',
+                },
+                {
+                    key: 'note_2',
+                    value: 'API rate limit: 100 requests per minute',
+                    category: 'note',
+                    priority: 'normal',
+                },
+                // Warnings
+                {
+                    key: 'warning_1',
+                    value: 'Deprecation warning in auth library',
+                    category: 'warning',
+                    priority: 'high',
+                },
+            ];
+            items.forEach(item => {
+                db.prepare('INSERT INTO context_items (id, session_id, key, value, category, priority) VALUES (?, ?, ?, ?, ?, ?)').run((0, uuid_1.v4)(), testSessionId, item.key, item.value, item.category, item.priority);
+            });
+        });
+        it('should summarize all items in session', () => {
+            const items = db
+                .prepare('SELECT * FROM context_items WHERE session_id = ? ORDER BY priority DESC, created_at DESC')
+                .all(testSessionId);
+            expect(items).toHaveLength(11);
+            // Group by category
+            const grouped = items.reduce((acc, item) => {
+                if (!acc[item.category])
+                    acc[item.category] = [];
+                acc[item.category].push(item);
+                return acc;
+            }, {});
+            expect(Object.keys(grouped)).toHaveLength(5);
+            expect(grouped.task).toHaveLength(4);
+            expect(grouped.decision).toHaveLength(2);
+            expect(grouped.progress).toHaveLength(2);
+            expect(grouped.note).toHaveLength(2);
+            expect(grouped.warning).toHaveLength(1);
+        });
+        it('should filter by categories', () => {
+            const categories = ['task', 'decision'];
+            const items = db
+                .prepare(`SELECT * FROM context_items 
+         WHERE session_id = ? 
+         AND category IN (${categories.map(() => '?').join(',')})
+         ORDER BY priority DESC, created_at DESC`)
+                .all(testSessionId, ...categories);
+            expect(items).toHaveLength(6); // 4 tasks + 2 decisions
+            expect(items.every((i) => categories.includes(i.category))).toBe(true);
+        });
+        it('should limit summary length', () => {
+            // Add many items
+            for (let i = 0; i < 50; i++) {
+                db.prepare('INSERT INTO context_items (id, session_id, key, value, category) VALUES (?, ?, ?, ?, ?)').run((0, uuid_1.v4)(), testSessionId, `extra_${i}`, `Extra item ${i}`, 'note');
+            }
+            // Get limited summary
+            const limit = 20;
+            const items = db
+                .prepare('SELECT * FROM context_items WHERE session_id = ? ORDER BY priority DESC, created_at DESC LIMIT ?')
+                .all(testSessionId, limit);
+            expect(items).toHaveLength(limit);
+        });
+        it('should prioritize high priority items', () => {
+            const items = db
+                .prepare(`SELECT * FROM context_items 
+         WHERE session_id = ? 
+         ORDER BY 
+           CASE priority 
+             WHEN 'critical' THEN 1
+             WHEN 'high' THEN 2
+             WHEN 'normal' THEN 3
+             WHEN 'low' THEN 4
+           END,
+           created_at DESC`)
+                .all(testSessionId);
+            // Check that high priority items come first (after critical if any)
+            const highPriorityItems = items.filter((i) => i.priority === 'high');
+            const firstHighIndex = items.findIndex((i) => i.priority === 'high');
+            // Find last high index manually (findLastIndex not available in older Node)
+            let lastHighIndex = -1;
+            for (let i = items.length - 1; i >= 0; i--) {
+                if (items[i].priority === 'high') {
+                    lastHighIndex = i;
+                    break;
+                }
+            }
+            if (highPriorityItems.length > 0) {
+                // All high priority items should be consecutive
+                const expectedLastIndex = firstHighIndex + highPriorityItems.length - 1;
+                expect(lastHighIndex).toBe(expectedLastIndex);
+            }
+            // Verify we have the expected high priority items
+            expect(highPriorityItems).toHaveLength(4); // 2 tasks + 1 decision + 1 warning
+        });
+        it('should generate summary with statistics', () => {
+            // Get statistics
+            const stats = db
+                .prepare(`SELECT 
+          category,
+          priority,
+          COUNT(*) as count
+         FROM context_items 
+         WHERE session_id = ?
+         GROUP BY category, priority`)
+                .all(testSessionId);
+            // Verify statistics
+            const taskHighCount = stats.find((s) => s.category === 'task' && s.priority === 'high')?.count;
+            expect(taskHighCount).toBe(2);
+            const totalCount = stats.reduce((sum, s) => sum + s.count, 0);
+            expect(totalCount).toBe(11);
+        });
+        it('should include session metadata in summary', () => {
+            const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(testSessionId);
+            expect(session.name).toBe('Summary Test Session');
+            expect(session.description).toBe('Testing summarization functionality');
+            expect(session.created_at).toBeDefined();
+        });
+        it('should handle empty sessions', () => {
+            // Create empty session
+            const emptySessionId = (0, uuid_1.v4)();
+            db.prepare('INSERT INTO sessions (id, name) VALUES (?, ?)').run(emptySessionId, 'Empty Session');
+            const items = db
+                .prepare('SELECT * FROM context_items WHERE session_id = ?')
+                .all(emptySessionId);
+            expect(items).toHaveLength(0);
+        });
+        it('should generate category-specific summaries', () => {
+            // Tasks summary
+            const tasks = db
+                .prepare('SELECT * FROM context_items WHERE session_id = ? AND category = ? ORDER BY priority DESC')
+                .all(testSessionId, 'task');
+            const taskSummary = {
+                total: tasks.length,
+                high: tasks.filter((t) => t.priority === 'high').length,
+                normal: tasks.filter((t) => t.priority === 'normal').length,
+                low: tasks.filter((t) => t.priority === 'low').length,
+                items: tasks.slice(0, 5), // Top 5 tasks
+            };
+            expect(taskSummary.total).toBe(4);
+            expect(taskSummary.high).toBe(2);
+            expect(taskSummary.normal).toBe(1);
+            expect(taskSummary.low).toBe(1);
+        });
+        it('should format summary for AI consumption', () => {
+            const items = db
+                .prepare('SELECT * FROM context_items WHERE session_id = ? ORDER BY category, priority DESC')
+                .all(testSessionId);
+            // Format for AI
+            const summary = [];
+            let currentCategory = '';
+            items.forEach((item) => {
+                if (item.category !== currentCategory) {
+                    currentCategory = item.category;
+                    summary.push(`\n## ${currentCategory.toUpperCase()}`);
+                }
+                const priorityMarker = item.priority === 'high' ? '🔴' : item.priority === 'normal' ? '🟡' : '⚪';
+                summary.push(`${priorityMarker} ${item.key}: ${item.value}`);
+            });
+            const formattedSummary = summary.join('\n');
+            expect(formattedSummary).toContain('## TASK');
+            expect(formattedSummary).toContain('## DECISION');
+            expect(formattedSummary).toContain('🔴'); // High priority markers
+        });
+        it('should include temporal information in summary', () => {
+            // Get items with time info
+            const items = db
+                .prepare(`SELECT 
+          *,
+          strftime('%Y-%m-%d %H:%M', created_at) as formatted_time
+         FROM context_items 
+         WHERE session_id = ?
+         ORDER BY created_at DESC
+         LIMIT 5`)
+                .all(testSessionId);
+            expect(items).toHaveLength(5);
+            items.forEach((item) => {
+                expect(item.formatted_time).toBeDefined();
+                expect(item.formatted_time).toMatch(/\d{4}-\d{2}-\d{2} \d{2}:\d{2}/);
+            });
+        });
+    });
+    describe('Summary with file information', () => {
+        it('should include file cache statistics', () => {
+            // Add some files
+            for (let i = 0; i < 5; i++) {
+                db.prepare('INSERT INTO file_cache (id, session_id, file_path, content, hash) VALUES (?, ?, ?, ?, ?)').run((0, uuid_1.v4)(), testSessionId, `/src/file${i}.ts`, `content${i}`, `hash${i}`);
+            }
+            const fileStats = db
+                .prepare('SELECT COUNT(*) as count, SUM(LENGTH(content)) as total_size FROM file_cache WHERE session_id = ?')
+                .get(testSessionId);
+            expect(fileStats.count).toBe(5);
+            expect(fileStats.total_size).toBeGreaterThan(0);
+        });
+    });
+});

package/dist/__tests__/integration/tokenLimitEnforcement.test.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+// Helper functions from the main index.ts file
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+function calculateSafeItemCount(items, tokenLimit) {
+    if (items.length === 0)
+        return 0;
+    let safeCount = 0;
+    let currentTokens = 0;
+    // Include base response structure in token calculation
+    const baseResponse = {
+        items: [],
+        pagination: {
+            total: 0,
+            returned: 0,
+            offset: 0,
+            hasMore: false,
+            nextOffset: null,
+            totalCount: 0,
+            page: 1,
+            pageSize: 0,
+            totalPages: 1,
+            hasNextPage: false,
+            hasPreviousPage: false,
+            previousOffset: null,
+            totalSize: 0,
+            averageSize: 0,
+            defaultsApplied: {},
+            truncated: false,
+            truncatedCount: 0,
+        },
+    };
+    // Estimate tokens for base response structure
+    const baseTokens = estimateTokens(JSON.stringify(baseResponse, null, 2));
+    currentTokens = baseTokens;
+    // Add items one by one until we approach the token limit
+    for (let i = 0; i < items.length; i++) {
+        const itemTokens = estimateTokens(JSON.stringify(items[i], null, 2));
+        // Leave some buffer (10%) to account for formatting and additional metadata
+        if (currentTokens + itemTokens > tokenLimit * 0.9) {
+            break;
+        }
+        currentTokens += itemTokens;
+        safeCount++;
+    }
+    // Always return at least 1 item if any exist, even if it exceeds limit
+    // This prevents infinite loops and ensures progress
+    return Math.max(safeCount, items.length > 0 ? 1 : 0);
+}
+(0, globals_1.describe)('Token Limit Enforcement Unit Tests', () => {
+    (0, globals_1.describe)('calculateSafeItemCount', () => {
+        (0, globals_1.it)('should return 0 for empty items array', () => {
+            const result = calculateSafeItemCount([], 20000);
+            (0, globals_1.expect)(result).toBe(0);
+        });
+        (0, globals_1.it)('should return at least 1 item if any exist', () => {
+            const largeItem = {
+                key: 'large.item',
+                value: 'X'.repeat(100000), // Very large item
+                category: 'test',
+                priority: 'high',
+            };
+            const result = calculateSafeItemCount([largeItem], 20000);
+            (0, globals_1.expect)(result).toBe(1);
+        });
+        (0, globals_1.it)('should truncate items when approaching token limit', () => {
+            // Create multiple medium-sized items
+            const items = [];
+            for (let i = 0; i < 50; i++) {
+                items.push({
+                    key: `item.${i}`,
+                    value: 'This is a medium-sized test value that contains enough text to trigger token limit enforcement when many items are returned together. '.repeat(20),
+                    category: 'test',
+                    priority: 'high',
+                });
+            }
+            const result = calculateSafeItemCount(items, 20000);
+            (0, globals_1.expect)(result).toBeLessThan(50);
+            (0, globals_1.expect)(result).toBeGreaterThan(0);
+        });
+        (0, globals_1.it)('should handle small items that all fit within limit', () => {
+            const items = [];
+            for (let i = 0; i < 10; i++) {
+                items.push({
+                    key: `small.item.${i}`,
+                    value: 'Small value',
+                    category: 'test',
+                    priority: 'high',
+                });
+            }
+            const result = calculateSafeItemCount(items, 20000);
+            (0, globals_1.expect)(result).toBe(10);
+        });
+        (0, globals_1.it)('should respect token limit with buffer', () => {
+            // Create items that would exceed token limit
+            const items = [];
+            const itemValue = 'X'.repeat(2000); // 2KB item that will definitely cause truncation
+            for (let i = 0; i < 100; i++) {
+                items.push({
+                    key: `large.buffer.item.${i}`,
+                    value: itemValue,
+                    category: 'test',
+                    priority: 'high',
+                });
+            }
+            const result = calculateSafeItemCount(items, 20000);
+            // Should be significantly less than all items due to token limits
+            (0, globals_1.expect)(result).toBeLessThan(100);
+            (0, globals_1.expect)(result).toBeGreaterThan(0);
+            // Verify that the result respects the buffer by checking actual tokens
+            const actualTokens = result * estimateTokens(JSON.stringify(items[0], null, 2));
+            (0, globals_1.expect)(actualTokens).toBeLessThan(20000 * 0.9); // Should be under 90% of limit
+        });
+    });
+    (0, globals_1.describe)('estimateTokens', () => {
+        (0, globals_1.it)('should estimate tokens correctly', () => {
+            const text = 'This is a test string';
+            const tokens = estimateTokens(text);
+            (0, globals_1.expect)(tokens).toBe(Math.ceil(text.length / 4));
+        });
+        (0, globals_1.it)('should handle empty strings', () => {
+            const tokens = estimateTokens('');
+            (0, globals_1.expect)(tokens).toBe(0);
+        });
+        (0, globals_1.it)('should handle large strings', () => {
+            const largeText = 'X'.repeat(10000);
+            const tokens = estimateTokens(largeText);
+            (0, globals_1.expect)(tokens).toBe(2500); // 10000 / 4
+        });
+    });
+});

package/dist/__tests__/integration/tool-profiles-integration.test.js

@@ -0,0 +1,150 @@
+"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 fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const tool_profiles_1 = require("../../utils/tool-profiles");
+/**
+ * Drift-detection: extract tool names from the ListToolsRequestSchema handler
+ * in src/index.ts to verify ALL_TOOL_NAMES stays in sync with actual tool definitions.
+ */
+function extractToolNamesFromIndexTs() {
+    const indexPath = path.join(__dirname, '..', '..', 'index.ts');
+    const src = fs.readFileSync(indexPath, 'utf-8');
+    // Find the allTools array: starts after "const allTools" and ends at the matching "];"
+    // We look for tool name strings inside the ListToolsRequestSchema handler
+    const toolNameRegex = /^\s+name:\s+'(context_[a-z_]+)'/gm;
+    const names = [];
+    let match;
+    // Only capture tool names outside of block comments (skip commented-out tools)
+    // Split by block comment boundaries and only scan non-comment sections
+    const sections = src.split(/\/\*[\s\S]*?\*\//);
+    for (const section of sections) {
+        toolNameRegex.lastIndex = 0;
+        while ((match = toolNameRegex.exec(section)) !== null) {
+            names.push(match[1]);
+        }
+    }
+    return names;
+}
+(0, globals_1.describe)('Tool Profile Integration Tests', () => {
+    const originalEnv = process.env.TOOL_PROFILE;
+    afterEach(() => {
+        if (originalEnv !== undefined) {
+            process.env.TOOL_PROFILE = originalEnv;
+        }
+        else {
+            delete process.env.TOOL_PROFILE;
+        }
+    });
+    (0, globals_1.describe)('Drift detection: ALL_TOOL_NAMES vs index.ts', () => {
+        (0, globals_1.it)('ALL_TOOL_NAMES should match active tools defined in index.ts', () => {
+            const indexToolNames = extractToolNamesFromIndexTs();
+            const allToolNamesArray = [...tool_profiles_1.ALL_TOOL_NAMES];
+            // Same count
+            (0, globals_1.expect)(allToolNamesArray.length).toBe(indexToolNames.length);
+            // Same set of names
+            (0, globals_1.expect)(new Set(allToolNamesArray)).toEqual(new Set(indexToolNames));
+        });
+        (0, globals_1.it)('should not include commented-out tools', () => {
+            // context_share and context_get_shared are commented out in index.ts
+            (0, globals_1.expect)(tool_profiles_1.ALL_TOOL_NAMES_SET.has('context_share')).toBe(false);
+            (0, globals_1.expect)(tool_profiles_1.ALL_TOOL_NAMES_SET.has('context_get_shared')).toBe(false);
+        });
+    });
+    (0, globals_1.describe)('Profile filtering behavior', () => {
+        (0, globals_1.it)('minimal profile should include core tools and exclude advanced tools', () => {
+            process.env.TOOL_PROFILE = 'minimal';
+            const profile = (0, tool_profiles_1.resolveActiveProfile)('/nonexistent/config.json');
+            // Core tools present
+            (0, globals_1.expect)(profile.tools.has('context_save')).toBe(true);
+            (0, globals_1.expect)(profile.tools.has('context_get')).toBe(true);
+            (0, globals_1.expect)(profile.tools.has('context_search')).toBe(true);
+            (0, globals_1.expect)(profile.tools.has('context_checkpoint')).toBe(true);
+            // Advanced tools absent
+            (0, globals_1.expect)(profile.tools.has('context_analyze')).toBe(false);
+            (0, globals_1.expect)(profile.tools.has('context_visualize')).toBe(false);
+            (0, globals_1.expect)(profile.tools.has('context_delegate')).toBe(false);
+            (0, globals_1.expect)(profile.tools.has('context_semantic_search')).toBe(false);
+        });
+        (0, globals_1.it)('default (no env var) should expose all tools with backwards-compatible behavior', () => {
+            delete process.env.TOOL_PROFILE;
+            const profile = (0, tool_profiles_1.resolveActiveProfile)('/nonexistent/config.json');
+            (0, globals_1.expect)(profile.tools.size).toBe(tool_profiles_1.ALL_TOOL_NAMES.length);
+            (0, globals_1.expect)(profile.profileName).toBe('full');
+            (0, globals_1.expect)(profile.source).toBe('default');
+            (0, globals_1.expect)(profile.warnings).toHaveLength(0);
+        });
+    });
+    (0, globals_1.describe)('CallTool guard behavior', () => {
+        (0, globals_1.it)('disabled tool should be in ALL_TOOL_NAMES_SET but not in profile tools', () => {
+            process.env.TOOL_PROFILE = 'minimal';
+            const profile = (0, tool_profiles_1.resolveActiveProfile)('/nonexistent/config.json');
+            const disabledTool = 'context_analyze';
+            // The guard logic: known tool that is not enabled
+            const isKnown = tool_profiles_1.ALL_TOOL_NAMES_SET.has(disabledTool);
+            const isEnabled = profile.tools.has(disabledTool);
+            (0, globals_1.expect)(isKnown).toBe(true);
+            (0, globals_1.expect)(isEnabled).toBe(false);
+            // In index.ts: isKnown && !isEnabled → return isError: true
+        });
+        (0, globals_1.it)('unknown tool should not be in ALL_TOOL_NAMES_SET (falls through to default switch)', () => {
+            const unknownTool = 'non_existent_tool';
+            (0, globals_1.expect)(tool_profiles_1.ALL_TOOL_NAMES_SET.has(unknownTool)).toBe(false);
+            // In index.ts: !isKnown → falls through to default: throw new Error()
+        });
+        (0, globals_1.it)('enabled tool should pass both checks', () => {
+            process.env.TOOL_PROFILE = 'minimal';
+            const profile = (0, tool_profiles_1.resolveActiveProfile)('/nonexistent/config.json');
+            const enabledTool = 'context_save';
+            const isKnown = tool_profiles_1.ALL_TOOL_NAMES_SET.has(enabledTool);
+            const isEnabled = profile.tools.has(enabledTool);
+            (0, globals_1.expect)(isKnown).toBe(true);
+            (0, globals_1.expect)(isEnabled).toBe(true);
+            // In index.ts: isKnown && isEnabled → guard does not fire, proceeds to switch
+        });
+    });
+    (0, globals_1.describe)('TOOL_PROFILE_CONFIG support', () => {
+        (0, globals_1.it)('resolveActiveProfile accepts custom config path (used by TOOL_PROFILE_CONFIG)', () => {
+            // This tests the mechanism that index.ts uses:
+            // resolveActiveProfile(process.env.TOOL_PROFILE_CONFIG)
+            const result = (0, tool_profiles_1.resolveActiveProfile)('/nonexistent/custom/path/config.json');
+            // Missing file → no config → falls back to built-in 'full'
+            (0, globals_1.expect)(result.profileName).toBe('full');
+            (0, globals_1.expect)(result.tools.size).toBe(38);
+        });
+    });
+});