@exaudeus/memory-mcp 0.1.0 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/memory-mcp",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "Codebase memory MCP server - persistent, evolving knowledge for AI coding agents",
   "type": "module",
   "main": "dist/index.js",
@@ -17,7 +17,7 @@
     "typecheck": "tsc --noEmit",
     "dev": "tsx src/index.ts",
     "start": "node dist/index.js",
-    "test": "node --import tsx --test src/__tests__/**/*.test.ts",
+    "test": "sh -c 'node --import tsx --test src/__tests__/*.test.ts'",
     "prepublishOnly": "npm run build",
     "semantic-release": "semantic-release"
   },

package/dist/__tests__/clock-and-validators.test.d.ts

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

package/dist/__tests__/clock-and-validators.test.js

@@ -1,237 +0,0 @@
-import { describe, it, beforeEach } from 'node:test';
-import assert from 'node:assert';
-import { promises as fs } from 'fs';
-import path from 'path';
-import os from 'os';
-import { MarkdownMemoryStore } from '../store.js';
-import { DEFAULT_STORAGE_BUDGET_BYTES, parseTopicScope, parseTrustLevel } from '../types.js';
-// --- Fake clock: deterministic time for testing staleness ---
-function fakeClock(isoDate) {
-    const date = new Date(isoDate);
-    return {
-        now: () => new Date(date.getTime()),
-        isoNow: () => date.toISOString(),
-    };
-}
-function makeConfig(repoRoot, clock) {
-    return {
-        repoRoot,
-        memoryPath: path.join(repoRoot, '.memory'),
-        storageBudgetBytes: DEFAULT_STORAGE_BUDGET_BYTES,
-        clock,
-    };
-}
-async function createTempDir() {
-    return await fs.mkdtemp(path.join(os.tmpdir(), 'memory-mcp-clock-test-'));
-}
-// --- parseTopicScope tests ---
-describe('parseTopicScope', () => {
-    it('accepts all fixed topics', () => {
-        const fixed = ['user', 'preferences', 'architecture', 'conventions', 'gotchas', 'recent-work'];
-        for (const topic of fixed) {
-            assert.strictEqual(parseTopicScope(topic), topic, `Should accept "${topic}"`);
-        }
-    });
-    it('accepts modules/ prefixed topics', () => {
-        assert.strictEqual(parseTopicScope('modules/messaging'), 'modules/messaging');
-        assert.strictEqual(parseTopicScope('modules/auth'), 'modules/auth');
-        assert.strictEqual(parseTopicScope('modules/deep/nested'), 'modules/deep/nested');
-    });
-    it('rejects empty string', () => {
-        assert.strictEqual(parseTopicScope(''), null);
-    });
-    it('rejects arbitrary strings', () => {
-        assert.strictEqual(parseTopicScope('banana'), null);
-        assert.strictEqual(parseTopicScope('foobar'), null);
-        assert.strictEqual(parseTopicScope('arch'), null);
-    });
-    it('rejects "modules/" without a name', () => {
-        assert.strictEqual(parseTopicScope('modules/'), null);
-    });
-    it('is case-sensitive', () => {
-        assert.strictEqual(parseTopicScope('Architecture'), null);
-        assert.strictEqual(parseTopicScope('USER'), null);
-    });
-});
-// --- parseTrustLevel tests ---
-describe('parseTrustLevel', () => {
-    it('accepts all valid trust levels', () => {
-        assert.strictEqual(parseTrustLevel('user'), 'user');
-        assert.strictEqual(parseTrustLevel('agent-confirmed'), 'agent-confirmed');
-        assert.strictEqual(parseTrustLevel('agent-inferred'), 'agent-inferred');
-    });
-    it('rejects arbitrary strings', () => {
-        assert.strictEqual(parseTrustLevel('admin'), null);
-        assert.strictEqual(parseTrustLevel(''), null);
-        assert.strictEqual(parseTrustLevel('USER'), null);
-    });
-});
-// --- Fake clock: staleness and freshness ---
-describe('Clock injection for freshness', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await createTempDir();
-    });
-    it('entries older than 30 days are stale with fake clock', async () => {
-        // Store entries with a clock set to Jan 1, 2025
-        const jan1 = fakeClock('2025-01-01T00:00:00.000Z');
-        const store1 = new MarkdownMemoryStore(makeConfig(tempDir, jan1));
-        await store1.init();
-        await store1.store('architecture', 'Old Pattern', 'This was stored long ago', [], 'agent-inferred');
-        // Query with a clock set to Mar 1, 2025 (59 days later — well past 30)
-        const mar1 = fakeClock('2025-03-01T00:00:00.000Z');
-        const store2 = new MarkdownMemoryStore(makeConfig(tempDir, mar1));
-        await store2.init();
-        const result = await store2.query('architecture', 'brief');
-        assert.strictEqual(result.entries.length, 1);
-        assert.strictEqual(result.entries[0].fresh, false, 'Entry should be stale after 59 days');
-    });
-    it('entries within 30 days are fresh with fake clock', async () => {
-        const jan1 = fakeClock('2025-01-01T00:00:00.000Z');
-        const store1 = new MarkdownMemoryStore(makeConfig(tempDir, jan1));
-        await store1.init();
-        await store1.store('architecture', 'Recent Pattern', 'Just stored', [], 'agent-inferred');
-        // Query 15 days later — still within 30
-        const jan16 = fakeClock('2025-01-16T00:00:00.000Z');
-        const store2 = new MarkdownMemoryStore(makeConfig(tempDir, jan16));
-        await store2.init();
-        const result = await store2.query('architecture', 'brief');
-        assert.strictEqual(result.entries.length, 1);
-        assert.strictEqual(result.entries[0].fresh, true, 'Entry should be fresh within 30 days');
-    });
-    it('user topic entries are always fresh regardless of age', async () => {
-        const jan1 = fakeClock('2025-01-01T00:00:00.000Z');
-        const store1 = new MarkdownMemoryStore(makeConfig(tempDir, jan1));
-        await store1.init();
-        await store1.store('user', 'Identity', 'An engineer', [], 'user');
-        // Query 1 year later — user topic is exempt
-        const nextYear = fakeClock('2026-01-01T00:00:00.000Z');
-        const store2 = new MarkdownMemoryStore(makeConfig(tempDir, nextYear));
-        await store2.init();
-        const result = await store2.query('user', 'brief');
-        assert.strictEqual(result.entries[0].fresh, true, 'User topic should always be fresh');
-    });
-    it('preferences entries are stale after 90 days, fresh before', async () => {
-        // Use separate temp dirs to prevent query() from refreshing lastAccessed between scenarios
-        const dir60 = await fs.mkdtemp(path.join(os.tmpdir(), 'mem-pref-60-'));
-        const dir100 = await fs.mkdtemp(path.join(os.tmpdir(), 'mem-pref-100-'));
-        try {
-            const jan1 = fakeClock('2025-01-01T00:00:00.000Z');
-            // Scenario 1: written Jan 1, queried Mar 2 (60 days) — should be fresh
-            const write60 = new MarkdownMemoryStore(makeConfig(dir60, jan1));
-            await write60.init();
-            await write60.store('preferences', 'Style', 'Functional first', [], 'user');
-            const mar2 = fakeClock('2025-03-02T00:00:00.000Z'); // ~60 days later
-            const read60 = new MarkdownMemoryStore(makeConfig(dir60, mar2));
-            await read60.init();
-            const result60 = await read60.query('preferences', 'brief');
-            assert.strictEqual(result60.entries[0].fresh, true, 'Preference at 60 days should still be fresh (within 90-day window)');
-            // Scenario 2: written Jan 1, queried Apr 11 (100 days) — should be stale
-            const write100 = new MarkdownMemoryStore(makeConfig(dir100, jan1));
-            await write100.init();
-            await write100.store('preferences', 'Style', 'Functional first', [], 'user');
-            const apr11 = fakeClock('2025-04-11T00:00:00.000Z'); // ~100 days later
-            const read100 = new MarkdownMemoryStore(makeConfig(dir100, apr11));
-            await read100.init();
-            const result100 = await read100.query('preferences', 'brief');
-            assert.strictEqual(result100.entries[0].fresh, false, 'Preference at 100 days should be stale (exceeds 90-day window)');
-        }
-        finally {
-            await fs.rm(dir60, { recursive: true, force: true }).catch(() => { });
-            await fs.rm(dir100, { recursive: true, force: true }).catch(() => { });
-        }
-    });
-    it('gotchas go stale after 30 days (not always-fresh)', async () => {
-        const jan1 = fakeClock('2025-01-01T00:00:00.000Z');
-        const store1 = new MarkdownMemoryStore(makeConfig(tempDir, jan1));
-        await store1.init();
-        await store1.store('gotchas', 'Build Gotcha', 'Always clean build', [], 'agent-inferred');
-        // Query 1 year later — gotchas are NOT exempt from staleness
-        const nextYear = fakeClock('2026-01-01T00:00:00.000Z');
-        const store2 = new MarkdownMemoryStore(makeConfig(tempDir, nextYear));
-        await store2.init();
-        const result = await store2.query('gotchas', 'brief');
-        assert.strictEqual(result.entries[0].fresh, false, 'Gotchas should go stale after 30 days — code changes make them the most dangerous when outdated');
-    });
-    it('user-trusted entries in non-user topics go stale normally (trust != temporal validity)', async () => {
-        const jan1 = fakeClock('2025-01-01T00:00:00.000Z');
-        const store1 = new MarkdownMemoryStore(makeConfig(tempDir, jan1));
-        await store1.init();
-        await store1.store('conventions', 'User Convention', 'User confirmed this', [], 'user');
-        // Query 1 year later — trust level does not grant freshness exemption
-        const nextYear = fakeClock('2026-01-01T00:00:00.000Z');
-        const store2 = new MarkdownMemoryStore(makeConfig(tempDir, nextYear));
-        await store2.init();
-        const result = await store2.query('conventions', 'brief');
-        assert.strictEqual(result.entries[0].fresh, false, 'Trust level does not grant freshness exemption — a user-confirmed entry can still be outdated');
-    });
-    it('stale count in briefing reflects tiered thresholds', async () => {
-        const jan1 = fakeClock('2025-01-01T00:00:00.000Z');
-        const store1 = new MarkdownMemoryStore(makeConfig(tempDir, jan1));
-        await store1.init();
-        await store1.store('architecture', 'Old Arch', 'content', [], 'agent-inferred');
-        await store1.store('conventions', 'Old Conv', 'content', [], 'agent-confirmed');
-        await store1.store('gotchas', 'Gotcha', 'content', [], 'agent-inferred'); // stale after 30 days
-        // Briefing 60 days later
-        const mar2 = fakeClock('2025-03-02T00:00:00.000Z');
-        const store2 = new MarkdownMemoryStore(makeConfig(tempDir, mar2));
-        await store2.init();
-        const briefing = await store2.briefing(2000);
-        // arch + conv + gotcha are all stale at 60 days (all use 30-day threshold)
-        assert.strictEqual(briefing.staleEntries, 3, 'arch, conv, and gotcha should all be stale at 60 days');
-    });
-    it('clock is used for created/lastAccessed timestamps', async () => {
-        const fixedTime = fakeClock('2025-06-15T12:30:00.000Z');
-        const store1 = new MarkdownMemoryStore(makeConfig(tempDir, fixedTime));
-        await store1.init();
-        await store1.store('architecture', 'Test Entry', 'content');
-        const result = await store1.query('architecture', 'full');
-        assert.strictEqual(result.entries[0].created, '2025-06-15T12:30:00.000Z');
-        assert.strictEqual(result.entries[0].lastAccessed, '2025-06-15T12:30:00.000Z');
-    });
-});
-// --- Confidence range validation ---
-describe('confidence clamping on disk read', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await createTempDir();
-    });
-    it('clamps out-of-range confidence to valid range on reload', async () => {
-        const store1 = new MarkdownMemoryStore(makeConfig(tempDir));
-        await store1.init();
-        // Manually write a file with confidence: 999
-        const dir = path.join(tempDir, '.memory', 'architecture');
-        await fs.mkdir(dir, { recursive: true });
-        await fs.writeFile(path.join(dir, 'arch-bad1.md'), [
-            '# High Confidence',
-            '- **id**: arch-bad1',
-            '- **topic**: architecture',
-            '- **confidence**: 999',
-            '- **trust**: agent-inferred',
-            '- **created**: 2025-01-01T00:00:00.000Z',
-            '- **lastAccessed**: 2025-01-01T00:00:00.000Z',
-            '',
-            'This entry has absurd confidence.',
-        ].join('\n'));
-        // Manually write a file with confidence: -5
-        await fs.writeFile(path.join(dir, 'arch-bad2.md'), [
-            '# Negative Confidence',
-            '- **id**: arch-bad2',
-            '- **topic**: architecture',
-            '- **confidence**: -5',
-            '- **trust**: agent-inferred',
-            '- **created**: 2025-01-01T00:00:00.000Z',
-            '- **lastAccessed**: 2025-01-01T00:00:00.000Z',
-            '',
-            'This entry has negative confidence.',
-        ].join('\n'));
-        const store2 = new MarkdownMemoryStore(makeConfig(tempDir));
-        await store2.init();
-        const result = await store2.query('architecture', 'full');
-        assert.strictEqual(result.entries.length, 2);
-        for (const entry of result.entries) {
-            assert.ok(entry.confidence >= 0.0, `Confidence ${entry.confidence} should be >= 0.0`);
-            assert.ok(entry.confidence <= 1.0, `Confidence ${entry.confidence} should be <= 1.0`);
-        }
-    });
-});

package/dist/__tests__/config-manager.test.d.ts

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

package/dist/__tests__/config-manager.test.js

@@ -1,142 +0,0 @@
-import { describe, it, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { ConfigManager } from '../config-manager.js';
-// Test helper: ConfigManager subclass with injectable stat function
-class TestableConfigManager extends ConfigManager {
-    constructor() {
-        super(...arguments);
-        this.statImplementation = async () => {
-            return { mtimeMs: Date.now() - 1000 };
-        };
-    }
-    statFile(path) {
-        return this.statImplementation(path);
-    }
-}
-describe('ConfigManager', () => {
-    let initialConfig;
-    let initialStores;
-    let initialHealth;
-    let configPath;
-    beforeEach(() => {
-        configPath = '/fake/memory-config.json';
-        // Mock initial config
-        const mockConfig = {
-            repoRoot: '/fake/repo',
-            memoryPath: '/fake/memory',
-            storageBudgetBytes: 2 * 1024 * 1024,
-        };
-        initialConfig = {
-            configs: new Map([['test-lobe', mockConfig]]),
-            origin: { source: 'file', path: configPath },
-        };
-        // Mock initial stores
-        const mockStore = {};
-        initialStores = new Map([['test-lobe', mockStore]]);
-        initialHealth = new Map([['test-lobe', { status: 'healthy' }]]);
-    });
-    describe('ensureFresh', () => {
-        it('does not reload when mtime unchanged', async () => {
-            const manager = new TestableConfigManager(configPath, initialConfig, initialStores, initialHealth);
-            let statCallCount = 0;
-            manager.statImplementation = async () => {
-                statCallCount++;
-                return { mtimeMs: Date.now() - 1000 }; // mtime in the past (no change)
-            };
-            await manager.ensureFresh();
-            await manager.ensureFresh();
-            // Stat should be called, but reload should not happen
-            assert.equal(statCallCount, 2, 'stat should be called twice');
-            assert.equal(manager.getLobeNames().length, 1, 'Should still have 1 lobe');
-        });
-        it('gracefully handles stat ENOENT error (file deleted)', async () => {
-            const manager = new TestableConfigManager(configPath, initialConfig, initialStores, initialHealth);
-            manager.statImplementation = async () => {
-                const error = new Error('ENOENT: no such file');
-                error.code = 'ENOENT';
-                throw error;
-            };
-            // Should not throw, should keep old config
-            await manager.ensureFresh();
-            assert.equal(manager.getLobeNames().length, 1, 'Should keep old config on ENOENT');
-        });
-        it('gracefully handles stat EACCES error (permission denied)', async () => {
-            const manager = new TestableConfigManager(configPath, initialConfig, initialStores, initialHealth);
-            manager.statImplementation = async () => {
-                const error = new Error('EACCES: permission denied');
-                error.code = 'EACCES';
-                throw error;
-            };
-            // Should not throw, should keep old config
-            await manager.ensureFresh();
-            assert.equal(manager.getLobeNames().length, 1, 'Should keep old config on EACCES');
-        });
-        it('skips reload for env-var-based configs', async () => {
-            const envConfig = {
-                configs: new Map([['test-lobe', initialConfig.configs.get('test-lobe')]]),
-                origin: { source: 'env' },
-            };
-            let statCalled = false;
-            const manager = new TestableConfigManager(configPath, envConfig, initialStores, initialHealth);
-            manager.statImplementation = async () => {
-                statCalled = true;
-                return { mtimeMs: Date.now() };
-            };
-            await manager.ensureFresh();
-            // stat should NOT be called for env-based configs
-            assert.equal(statCalled, false, 'Should not stat for env-based configs');
-        });
-        it('skips reload for default-based configs', async () => {
-            const defaultConfig = {
-                configs: new Map([['default', initialConfig.configs.get('test-lobe')]]),
-                origin: { source: 'default' },
-            };
-            let statCalled = false;
-            const manager = new TestableConfigManager(configPath, defaultConfig, initialStores, initialHealth);
-            manager.statImplementation = async () => {
-                statCalled = true;
-                return { mtimeMs: Date.now() };
-            };
-            await manager.ensureFresh();
-            // stat should NOT be called for default configs
-            assert.equal(statCalled, false, 'Should not stat for default configs');
-        });
-    });
-    describe('accessors', () => {
-        it('getStore returns store for existing lobe', () => {
-            const manager = new ConfigManager(configPath, initialConfig, initialStores, initialHealth);
-            const store = manager.getStore('test-lobe');
-            assert.ok(store !== undefined, 'Should return store for existing lobe');
-        });
-        it('getStore returns undefined for non-existent lobe', () => {
-            const manager = new ConfigManager(configPath, initialConfig, initialStores, initialHealth);
-            const store = manager.getStore('nonexistent');
-            assert.equal(store, undefined, 'Should return undefined for missing lobe');
-        });
-        it('getLobeNames returns array of lobe names', () => {
-            const manager = new ConfigManager(configPath, initialConfig, initialStores, initialHealth);
-            const names = manager.getLobeNames();
-            assert.deepEqual(names, ['test-lobe']);
-        });
-        it('getConfigOrigin returns current origin', () => {
-            const manager = new ConfigManager(configPath, initialConfig, initialStores, initialHealth);
-            const origin = manager.getConfigOrigin();
-            assert.equal(origin.source, 'file');
-            if (origin.source === 'file') {
-                assert.equal(origin.path, configPath);
-            }
-        });
-        it('getLobeHealth returns health for existing lobe', () => {
-            const manager = new ConfigManager(configPath, initialConfig, initialStores, initialHealth);
-            const health = manager.getLobeHealth('test-lobe');
-            assert.ok(health !== undefined);
-            assert.equal(health.status, 'healthy');
-        });
-        it('getLobeConfig returns config for existing lobe', () => {
-            const manager = new ConfigManager(configPath, initialConfig, initialStores, initialHealth);
-            const config = manager.getLobeConfig('test-lobe');
-            assert.ok(config !== undefined);
-            assert.equal(config.repoRoot, '/fake/repo');
-        });
-    });
-});

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

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

package/dist/__tests__/config.test.js

@@ -1,236 +0,0 @@
-// Tests for config.ts — configuration loading with 3-tier fallback.
-// Tests the public API: getLobeConfigs() with different env/file setups.
-//
-// Strategy: We can't easily test file-based config (it reads relative to
-// the module), but we CAN test env-based and default-based config.
-import { describe, it, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert';
-import { promises as fs } from 'fs';
-import path from 'path';
-import os from 'os';
-import { getLobeConfigs, parseBehaviorConfig } from '../config.js';
-// Save original env vars so we can restore after each test
-const originalEnv = {};
-const envKeys = [
-    'MEMORY_MCP_WORKSPACES',
-    'MEMORY_MCP_DIR',
-    'MEMORY_MCP_BUDGET',
-    'MEMORY_MCP_REPO_ROOT',
-];
-function saveEnv() {
-    for (const key of envKeys) {
-        originalEnv[key] = process.env[key];
-    }
-}
-function restoreEnv() {
-    for (const key of envKeys) {
-        if (originalEnv[key] === undefined) {
-            delete process.env[key];
-        }
-        else {
-            process.env[key] = originalEnv[key];
-        }
-    }
-}
-function clearConfigEnv() {
-    for (const key of envKeys) {
-        delete process.env[key];
-    }
-}
-describe('getLobeConfigs', () => {
-    let tempDir;
-    beforeEach(async () => {
-        saveEnv();
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'memory-mcp-config-test-'));
-    });
-    afterEach(async () => {
-        restoreEnv();
-        await fs.rm(tempDir, { recursive: true, force: true }).catch(() => { });
-    });
-    describe('env var config (tier 2)', () => {
-        it('loads from MEMORY_MCP_WORKSPACES json', () => {
-            clearConfigEnv();
-            process.env.MEMORY_MCP_WORKSPACES = JSON.stringify({
-                'my-repo': tempDir,
-            });
-            process.env.MEMORY_MCP_DIR = '.test-memory';
-            const { configs, origin } = getLobeConfigs();
-            // May load file config first if memory-config.json exists
-            // But if we're here, it should have at least one lobe
-            assert.ok(configs.size >= 1, 'Should have at least one lobe');
-            if (origin.source === 'env') {
-                const config = configs.get('my-repo');
-                assert.ok(config, 'Should have my-repo lobe');
-                assert.strictEqual(config.repoRoot, tempDir);
-                assert.ok(config.memoryPath.includes('.test-memory'), `Memory path should use MEMORY_MCP_DIR: ${config.memoryPath}`);
-            }
-        });
-        it('loads multiple lobes from env', () => {
-            clearConfigEnv();
-            const dir2 = tempDir + '-2';
-            process.env.MEMORY_MCP_WORKSPACES = JSON.stringify({
-                'repo-a': tempDir,
-                'repo-b': dir2,
-            });
-            const { configs, origin } = getLobeConfigs();
-            if (origin.source === 'env') {
-                assert.strictEqual(configs.size, 2, 'Should have 2 lobes');
-                assert.ok(configs.has('repo-a'));
-                assert.ok(configs.has('repo-b'));
-            }
-        });
-        it('respects custom budget from env', () => {
-            clearConfigEnv();
-            process.env.MEMORY_MCP_WORKSPACES = JSON.stringify({
-                'my-repo': tempDir,
-            });
-            process.env.MEMORY_MCP_BUDGET = String(5 * 1024 * 1024); // 5MB
-            const { configs, origin } = getLobeConfigs();
-            if (origin.source === 'env') {
-                const config = configs.get('my-repo');
-                assert.strictEqual(config.storageBudgetBytes, 5 * 1024 * 1024);
-            }
-        });
-        it('falls through on invalid MEMORY_MCP_WORKSPACES JSON', () => {
-            clearConfigEnv();
-            process.env.MEMORY_MCP_WORKSPACES = 'not valid json';
-            process.env.MEMORY_MCP_REPO_ROOT = tempDir;
-            // Should not throw — falls through to default
-            const { configs } = getLobeConfigs();
-            assert.ok(configs.size >= 1, 'Should fall through to at least one lobe');
-        });
-    });
-    describe('default fallback config (tier 3)', () => {
-        it('uses MEMORY_MCP_REPO_ROOT when no config file or env workspaces', () => {
-            clearConfigEnv();
-            process.env.MEMORY_MCP_REPO_ROOT = tempDir;
-            const { configs, origin } = getLobeConfigs();
-            // If there's no memory-config.json and no MEMORY_MCP_WORKSPACES,
-            // it should fall back to default
-            if (origin.source === 'default') {
-                assert.ok(configs.has('default'), 'Should have a default lobe');
-                assert.strictEqual(configs.get('default').repoRoot, tempDir);
-            }
-        });
-        it('uses cwd when no env vars at all', () => {
-            clearConfigEnv();
-            // No env vars set — should use process.cwd()
-            const { configs } = getLobeConfigs();
-            assert.ok(configs.size >= 1, 'Should always return at least one lobe');
-        });
-        it('uses explicit MEMORY_MCP_DIR for default lobe', () => {
-            clearConfigEnv();
-            process.env.MEMORY_MCP_REPO_ROOT = tempDir;
-            process.env.MEMORY_MCP_DIR = '.custom-memory';
-            const { configs, origin } = getLobeConfigs();
-            if (origin.source === 'default') {
-                const config = configs.get('default');
-                assert.ok(config.memoryPath.includes('.custom-memory'), `Should use custom dir: ${config.memoryPath}`);
-            }
-        });
-    });
-    describe('behavior config parsing', () => {
-        it('returns empty object when no behavior block provided', () => {
-            const result = parseBehaviorConfig(undefined);
-            // All fields should be absent (caller falls back to defaults from thresholds.ts)
-            assert.strictEqual(Object.keys(result).length, 0);
-        });
-        it('passes through valid values within allowed ranges', () => {
-            const result = parseBehaviorConfig({
-                staleDaysStandard: 14,
-                staleDaysPreferences: 60,
-                maxStaleInBriefing: 3,
-                maxDedupSuggestions: 5,
-                maxConflictPairs: 2,
-            });
-            assert.strictEqual(result.staleDaysStandard, 14);
-            assert.strictEqual(result.staleDaysPreferences, 60);
-            assert.strictEqual(result.maxStaleInBriefing, 3);
-            assert.strictEqual(result.maxDedupSuggestions, 5);
-            assert.strictEqual(result.maxConflictPairs, 2);
-        });
-        it('falls back to default for out-of-range staleDaysStandard', () => {
-            const tooLow = parseBehaviorConfig({ staleDaysStandard: 0 });
-            assert.strictEqual(tooLow.staleDaysStandard, 30, 'Should use default 30 for value below minimum (1)');
-            const tooHigh = parseBehaviorConfig({ staleDaysStandard: 500 });
-            assert.strictEqual(tooHigh.staleDaysStandard, 30, 'Should use default 30 for value above maximum (365)');
-        });
-        it('falls back to default for out-of-range staleDaysPreferences', () => {
-            const tooHigh = parseBehaviorConfig({ staleDaysPreferences: 800 });
-            assert.strictEqual(tooHigh.staleDaysPreferences, 90, 'Should use default 90 for value above maximum (730)');
-        });
-        it('falls back to default for out-of-range maxStaleInBriefing', () => {
-            const tooHigh = parseBehaviorConfig({ maxStaleInBriefing: 50 });
-            assert.strictEqual(tooHigh.maxStaleInBriefing, 5, 'Should use default 5 for value above maximum (20)');
-        });
-        it('falls back to default for out-of-range maxConflictPairs', () => {
-            const tooHigh = parseBehaviorConfig({ maxConflictPairs: 10 });
-            assert.strictEqual(tooHigh.maxConflictPairs, 2, 'Should use default 2 for value above maximum (5)');
-        });
-        it('rounds fractional values to integers', () => {
-            const result = parseBehaviorConfig({ staleDaysStandard: 14.7 });
-            assert.strictEqual(result.staleDaysStandard, 15, 'Should round to nearest integer');
-        });
-        it('handles partial behavior config — omitted fields do not appear', () => {
-            const result = parseBehaviorConfig({ staleDaysStandard: 14 });
-            assert.strictEqual(result.staleDaysStandard, 14);
-            // Omitted fields should not be set (callers use thresholds.ts defaults)
-            assert.strictEqual(result.staleDaysPreferences, 90, 'Non-omitted field uses default');
-        });
-        it('writes a stderr warning for unknown behavior config keys (typo detection)', () => {
-            const stderrWrites = [];
-            const origWrite = process.stderr.write.bind(process.stderr);
-            // Capture stderr
-            process.stderr.write = ((chunk, ...rest) => {
-                if (typeof chunk === 'string')
-                    stderrWrites.push(chunk);
-                return origWrite(chunk, ...rest);
-            });
-            try {
-                // "staleDaysStanderd" is a typo of "staleDaysStandard"
-                parseBehaviorConfig({ staleDaysStandard: 14, staleDaysStanderd: 7 });
-            }
-            finally {
-                process.stderr.write = origWrite;
-            }
-            const warnings = stderrWrites.filter(s => s.includes('Unknown behavior config key'));
-            assert.ok(warnings.length > 0, 'Should warn about unknown key "staleDaysStanderd"');
-            assert.ok(warnings[0].includes('staleDaysStanderd'), 'Warning should name the offending key');
-        });
-        it('does not warn for valid behavior config keys', () => {
-            const stderrWrites = [];
-            const origWrite = process.stderr.write.bind(process.stderr);
-            process.stderr.write = ((chunk, ...rest) => {
-                if (typeof chunk === 'string')
-                    stderrWrites.push(chunk);
-                return origWrite(chunk, ...rest);
-            });
-            try {
-                parseBehaviorConfig({ staleDaysStandard: 14, maxStaleInBriefing: 3 });
-            }
-            finally {
-                process.stderr.write = origWrite;
-            }
-            const unknownWarnings = stderrWrites.filter(s => s.includes('Unknown behavior config key'));
-            assert.strictEqual(unknownWarnings.length, 0, 'Should not warn for valid keys');
-        });
-    });
-    describe('config structure', () => {
-        it('all configs have required fields', () => {
-            // Use whatever config is currently active
-            const { configs } = getLobeConfigs();
-            for (const [name, config] of configs) {
-                assert.ok(config.repoRoot, `${name}: repoRoot should be set`);
-                assert.ok(config.memoryPath, `${name}: memoryPath should be set`);
-                assert.ok(config.storageBudgetBytes > 0, `${name}: storageBudgetBytes should be positive`);
-            }
-        });
-        it('origin is always a valid discriminated union', () => {
-            const { origin } = getLobeConfigs();
-            assert.ok(['file', 'env', 'default'].includes(origin.source), `Origin source should be file, env, or default: ${origin.source}`);
-            if (origin.source === 'file') {
-                assert.ok('path' in origin && typeof origin.path === 'string', 'File origin should have a path');
-            }
-        });
-    });
-});

package/dist/__tests__/crash-journal.test.d.ts

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