delimit-cli 4.1.38 → 4.1.41

package/README.md

@@ -167,6 +167,9 @@ npx delimit-cli recall                           # Show recent memories
 npx delimit-cli recall --tag deploy --all        # Filter by tag, show all
 npx delimit-cli recall --export                  # Export as markdown
 npx delimit-cli forget abc123                    # Delete a memory by ID
+npx delimit-cli models                            # Configure deliberation API keys (BYOK wizard)
+npx delimit-cli models --status                   # Show current model config
+npx delimit-cli status                           # Compact dashboard of your Delimit setup
 npx delimit-cli doctor                           # Check setup health
 npx delimit-cli uninstall --dry-run              # Preview removal
 ```
@@ -270,6 +273,22 @@ rules:
 
 ---
 
+## FAQ
+
+**How does this compare to Obsidian Mind?**
+
+Obsidian Mind is a great Obsidian vault template for Claude Code users who want persistent memory via markdown files. Delimit takes a different approach: it's an MCP server that works across Claude Code, Codex, Gemini CLI, and Cursor. Your memory, ledger, and governance travel with you when you switch models. Delimit also adds API governance (27-type breaking change detection), CI gates, git hooks, and policy enforcement that Obsidian Mind doesn't cover. Use Obsidian Mind if you're all-in on Claude + Obsidian. Use Delimit if you switch between models or need governance.
+
+**Does this work without Claude Code?**
+
+Yes. Delimit works with Claude Code, Codex (OpenAI), Gemini CLI (Google), and Cursor. The `remember`/`recall` commands work standalone with zero config. The MCP server integrates with any client that supports the Model Context Protocol.
+
+**Is this free?**
+
+The free tier includes API governance, persistent memory, zero-spec extraction, project scanning, and 3 multi-model deliberations. Pro ($10/mo) adds unlimited deliberation, security audit, test verification, deploy pipeline, and agent orchestration.
+
+---
+
 ## Links
 
 - [delimit.ai](https://delimit.ai) -- homepage

package/bin/delimit-cli.js

@@ -128,6 +128,20 @@ if (process.env.DELIMIT_DEBUG_CONTINUITY === '1') {
     console.log('');
 }
 
+// Helper to format a timestamp as relative time (e.g. "2h ago", "3d ago")
+function _relativeTime(ts) {
+    const diff = Date.now() - ts;
+    const mins = Math.floor(diff / 60000);
+    if (mins < 1) return 'just now';
+    if (mins < 60) return mins + 'm ago';
+    const hrs = Math.floor(mins / 60);
+    if (hrs < 24) return hrs + 'h ago';
+    const days = Math.floor(hrs / 24);
+    if (days < 30) return days + 'd ago';
+    const months = Math.floor(days / 30);
+    return months + 'mo ago';
+}
+
 // Helper to check if agent is running
 async function checkAgent() {
     try {
@@ -311,99 +325,193 @@ program
 // Status command
 program
     .command('status')
-    .description('Show governance status')
+    .description('Show a compact dashboard of your Delimit setup')
 
     .option('--verbose', 'Show detailed status')
     .action(async (options) => {
-        const agentRunning = await checkAgent();
-        
-        console.log(chalk.blue.bold('\nDelimit Governance Status\n'));
-        console.log('Agent:', agentRunning ? chalk.green('✓ Running') : chalk.red('✗ Not running'));
+        const homedir = os.homedir();
+        const delimitHome = path.join(homedir, '.delimit');
+        const target = process.cwd();
+
+        console.log(chalk.bold('\n  Delimit Status\n'));
+
+        // --- Memory stats ---
+        const memoryDir = path.join(delimitHome, 'memory');
+        let memTotal = 0;
+        let memRecent = 0;
+        let recentMemories = [];
+        const oneWeekAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
+        try {
+            const memFiles = fs.readdirSync(memoryDir).filter(f => f.startsWith('mem-') && f.endsWith('.json'));
+            memTotal = memFiles.length;
+            for (const f of memFiles) {
+                try {
+                    const data = JSON.parse(fs.readFileSync(path.join(memoryDir, f), 'utf-8'));
+                    const ts = new Date(data.created_at || data.timestamp || data.created || 0).getTime();
+                    if (ts > oneWeekAgo) memRecent++;
+                    recentMemories.push({ text: data.text || data.content || '', tags: data.tags || [], ts });
+                } catch {}
+            }
+            recentMemories.sort((a, b) => b.ts - a.ts);
+            recentMemories = recentMemories.slice(0, 3);
+        } catch {}
+        console.log(`  Memory:     ${chalk.white.bold(memTotal)} memories${memRecent > 0 ? ` (${memRecent} this week)` : ''}`);
 
-        if (options.verbose) {
-            console.log('\n' + chalk.bold('Continuity Context:'));
-            console.log(formatContinuityReport(continuityContext).split('\n').slice(1).map(line => '  ' + line.trimStart()).join('\n'));
-        }
-        
-        if (agentRunning) {
-            const { data } = await axios.get(`${AGENT_URL}/status`);
-            
-            // Mode information
-            console.log('\n' + chalk.bold('Mode Configuration:'));
-            console.log(`  Current Mode: ${chalk.bold(data.sessionMode)}`);
-            if (data.defaultMode) {
-                console.log(`  Default Mode: ${data.defaultMode}`);
+        // --- Governance / Policy ---
+        const policyPath = path.join(target, '.delimit', 'policies.yml');
+        let policyLabel = chalk.gray('none');
+        let hasPolicy = false;
+        if (fs.existsSync(policyPath)) {
+            hasPolicy = true;
+            try {
+                const policyContent = yaml.load(fs.readFileSync(policyPath, 'utf-8'));
+                const preset = policyContent?.preset || policyContent?.name || 'custom';
+                policyLabel = chalk.green(preset + ' policy');
+            } catch {
+                policyLabel = chalk.green('custom policy');
             }
-            if (data.effectiveMode && data.effectiveMode !== data.sessionMode) {
-                console.log(`  Effective Mode: ${chalk.yellow(data.effectiveMode)} (escalated)`);
+        }
+        // Count tracked specs
+        const specPatterns = ['openapi.yaml', 'openapi.yml', 'openapi.json', 'swagger.yaml', 'swagger.yml', 'swagger.json'];
+        let specCount = 0;
+        const _countSpecs = (dir, depth) => {
+            if (depth > 3) return;
+            try {
+                for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                    if (['node_modules', '.next', 'venv', '.git'].includes(entry.name)) continue;
+                    const full = path.join(dir, entry.name);
+                    if (entry.isFile() && specPatterns.includes(entry.name.toLowerCase())) {
+                        specCount++;
+                    } else if (entry.isDirectory()) {
+                        _countSpecs(full, depth + 1);
+                    }
+                }
+            } catch {}
+        };
+        _countSpecs(target, 0);
+        const specLabel = specCount > 0 ? `${specCount} spec${specCount > 1 ? 's' : ''} tracked` : chalk.gray('no specs');
+        console.log(`  Governance: ${policyLabel}${hasPolicy ? ' | ' : ' | '}${specLabel}`);
+
+        // --- Git hooks ---
+        const preCommitPath = path.join(target, '.git', 'hooks', 'pre-commit');
+        let hasGitHooks = false;
+        try {
+            const hookContent = fs.readFileSync(preCommitPath, 'utf-8');
+            hasGitHooks = hookContent.includes('delimit');
+        } catch {}
+        console.log(`  Git Hooks:  ${hasGitHooks ? chalk.green('pre-commit installed') : chalk.gray('not installed')}`);
+
+        // --- CI ---
+        const workflowPath = path.join(target, '.github', 'workflows', 'api-governance.yml');
+        const hasCI = fs.existsSync(workflowPath);
+        console.log(`  CI:         ${hasCI ? chalk.green('GitHub Action active') : chalk.gray('not configured')}`);
+
+        // --- MCP ---
+        const mcpConfigPath = path.join(homedir, '.mcp.json');
+        let hasMcp = false;
+        let toolCount = 0;
+        try {
+            const mcpContent = fs.readFileSync(mcpConfigPath, 'utf-8');
+            hasMcp = mcpContent.includes('delimit');
+        } catch {}
+        if (hasMcp) {
+            // Count tools from server.py if available
+            const serverPyPaths = [
+                path.join(delimitHome, 'server', 'ai', 'server.py'),
+                path.join(delimitHome, 'server', 'server.py'),
+            ];
+            for (const sp of serverPyPaths) {
+                try {
+                    const serverContent = fs.readFileSync(sp, 'utf-8');
+                    const toolMatches = serverContent.match(/@mcp\.tool/g);
+                    if (toolMatches) {
+                        toolCount = toolMatches.length;
+                        break;
+                    }
+                } catch {}
             }
-            
-            // Policies
-            console.log('\n' + chalk.bold('Policies:'));
-            if (data.policiesLoaded.length > 0) {
-                data.policiesLoaded.forEach(policy => {
-                    console.log(`  • ${policy}`);
-                });
-                if (data.totalRules) {
-                    console.log(`  Total Rules: ${data.totalRules}`);
+            console.log(`  MCP:        ${chalk.green('connected')}${toolCount > 0 ? ` (${toolCount} tools)` : ''}`);
+        } else {
+            console.log(`  MCP:        ${chalk.gray('not configured')}`);
+        }
+
+        // --- Models ---
+        const modelsPath = path.join(delimitHome, 'models.json');
+        let modelsLabel = chalk.gray('none configured');
+        try {
+            const modelsData = JSON.parse(fs.readFileSync(modelsPath, 'utf-8'));
+            const modelNames = [];
+            for (const [key, val] of Object.entries(modelsData)) {
+                if (val && typeof val === 'object' && (val.api_key || val.enabled !== false)) {
+                    modelNames.push(key.charAt(0).toUpperCase() + key.slice(1));
                 }
-            } else {
-                console.log('  No policies loaded');
             }
-            
-            // Recent activity
-            console.log('\n' + chalk.bold('Activity:'));
-            console.log(`  Audit Log Entries: ${data.auditLogSize}`);
-            if (data.lastDecision) {
-                const timeSince = Date.now() - new Date(data.lastDecision.timestamp);
-                const minutes = Math.floor(timeSince / 60000);
-                console.log(`  Last Decision: ${minutes} minutes ago (${data.lastDecision.action})`);
+            if (modelNames.length > 0) {
+                modelsLabel = chalk.white(modelNames.join(' + ')) + chalk.gray(' (BYOK)');
             }
-            console.log(`  Uptime: ${Math.floor(data.uptime / 60)} minutes`);
-            
-            // Verbose mode shows recent decisions
-            if (options.verbose && data.recentDecisions) {
-                console.log('\n' + chalk.bold('Recent Decisions:'));
-                data.recentDecisions.forEach(decision => {
-                    const color = decision.action === 'block' ? chalk.red :
-                                 decision.action === 'prompt' ? chalk.yellow :
-                                 chalk.green;
-                    console.log(`  ${decision.timestamp} | ${color(decision.mode)} | ${decision.rule || 'no rule'}`);
-                });
+        } catch {}
+        console.log(`  Models:     ${modelsLabel}`);
+
+        // --- License ---
+        const licensePath = path.join(delimitHome, 'license.json');
+        let licenseLabel = chalk.gray('Free');
+        try {
+            const licenseData = JSON.parse(fs.readFileSync(licensePath, 'utf-8'));
+            const tier = licenseData.tier || licenseData.plan || 'Free';
+            const active = licenseData.status === 'active' || licenseData.valid === true;
+            if (tier.toLowerCase() !== 'free') {
+                licenseLabel = active ? chalk.green(`${tier} (active)`) : chalk.yellow(`${tier} (${licenseData.status || 'unknown'})`);
+            }
+        } catch {}
+        console.log(`  License:    ${licenseLabel}`);
+
+        // --- Recent memories ---
+        if (recentMemories.length > 0) {
+            console.log(chalk.bold('\n  Recent memories:'));
+            for (const mem of recentMemories) {
+                const ago = _relativeTime(mem.ts);
+                const tagStr = mem.tags.length > 0 ? '  ' + chalk.gray(mem.tags.map(t => '#' + t).join(' ')) : '';
+                const text = mem.text.length > 55 ? mem.text.slice(0, 55) + '...' : mem.text;
+                console.log(`    ${chalk.gray('[' + ago + ']')}  ${text}${tagStr}`);
             }
         }
-        
-        // System integration
-        console.log('\n' + chalk.bold('System Integration:'));
-        
-        // Git hooks
+
+        // --- Last session ---
+        const sessionsDir = path.join(delimitHome, 'sessions');
         try {
-            const hooksPath = execSync('git config --global core.hooksPath').toString().trim();
-            const hooksActive = hooksPath.includes('.delimit');
-            console.log(`  Git Hooks: ${hooksActive ? chalk.green('✓ Active') : chalk.yellow('⚠ Not configured')}`);
-        } catch (e) {
-            console.log(`  Git Hooks: ${chalk.red('✗ Not configured')}`);
-        }
-        
-        // PATH
-        if (process.env.PATH.includes('.delimit/shims')) {
-            console.log(`  AI Tool Interception: ${chalk.green('✓ Active')}`);
-        } else {
-            console.log(`  AI Tool Interception: ${chalk.gray('Not active')}`);
-        }
-        
-        // Policy files
-        const policyFiles = [];
-        if (fs.existsSync('delimit.yml')) {
-            policyFiles.push('project');
-        }
-        if (fs.existsSync(path.join(process.env.HOME, '.config', 'delimit', 'delimit.yml'))) {
-            policyFiles.push('user');
-        }
-        console.log(`  Policy Files: ${policyFiles.length > 0 ? policyFiles.join(', ') : chalk.gray('none')}`);
-        
+            const sessFiles = fs.readdirSync(sessionsDir)
+                .filter(f => f.startsWith('session_') && f.endsWith('.json'))
+                .sort()
+                .reverse();
+            if (sessFiles.length > 0) {
+                const latest = JSON.parse(fs.readFileSync(path.join(sessionsDir, sessFiles[0]), 'utf-8'));
+                const summary = latest.summary || latest.description || latest.title || null;
+                if (summary) {
+                    const truncated = summary.length > 60 ? summary.slice(0, 60) + '...' : summary;
+                    console.log(chalk.bold('\n  Last session: ') + truncated);
+                }
+            }
+        } catch {}
+
+        // --- Governance readiness ---
+        const hasSpecs = specCount > 0;
+        const checks = [
+            { name: 'API spec', done: hasSpecs },
+            { name: 'Policy', done: hasPolicy },
+            { name: 'CI gate', done: hasCI },
+            { name: 'Git hooks', done: hasGitHooks },
+            { name: 'MCP', done: hasMcp },
+        ];
+        const score = checks.filter(c => c.done).length;
+
+        console.log(chalk.bold(`\n  Governance readiness: ${score}/${checks.length}`));
+        console.log('    ' + checks.map(c => c.done ? chalk.green('\u25cf') + ' ' + c.name : chalk.gray('\u25cb') + ' ' + chalk.gray(c.name)).join('    '));
+        console.log('');
+
         if (options.verbose) {
-            console.log('\n' + chalk.gray('Run "delimit doctor" for detailed diagnostics'));
+            console.log(chalk.bold('  Continuity Context:'));
+            console.log(formatContinuityReport(continuityContext).split('\n').slice(1).map(line => '    ' + line.trimStart()).join('\n'));
+            console.log('');
         }
     });
 
@@ -4159,6 +4267,267 @@ if result.get('summary'):
         }
     });
 
+// ---------------------------------------------------------------------------
+// Models command: BYOK deliberation key management wizard
+// ---------------------------------------------------------------------------
+
+const MODELS_CONFIG_PATH = path.join(os.homedir(), '.delimit', 'models.json');
+const DELIBERATION_USAGE_PATH = path.join(os.homedir(), '.delimit', 'deliberation_usage.json');
+
+const DEFAULT_MODELS = {
+    grok: { enabled: false, api_key: '', model: 'grok-4-0709', name: 'Grok 4' },
+    gemini: { enabled: false, api_key: '', model: 'gemini-2.5-pro', name: 'Gemini Pro' },
+    openai: { enabled: false, api_key: '', model: 'gpt-4o', name: 'Codex (GPT-4o)' },
+};
+
+const MODEL_PROVIDERS = {
+    grok: { label: 'Grok (xAI)', prefix: 'xai-', endpoint: 'https://api.x.ai/v1/chat/completions', defaultModel: 'grok-4-0709', defaultName: 'Grok 4', variants: ['grok-4-0709', 'grok-3', 'grok-3-mini'] },
+    gemini: { label: 'Gemini (Google)', prefix: 'AIza', endpoint: 'https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent', defaultModel: 'gemini-2.5-pro', defaultName: 'Gemini Pro', variants: ['gemini-2.5-pro', 'gemini-2.5-flash', 'gemini-2.0-flash'] },
+    openai: { label: 'Codex/GPT-4o (OpenAI)', prefix: 'sk-', endpoint: 'https://api.openai.com/v1/chat/completions', defaultModel: 'gpt-4o', defaultName: 'Codex (GPT-4o)', variants: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o3-mini'] },
+};
+
+function loadModelsConfig() {
+    try {
+        if (fs.existsSync(MODELS_CONFIG_PATH)) {
+            return JSON.parse(fs.readFileSync(MODELS_CONFIG_PATH, 'utf-8'));
+        }
+    } catch {}
+    return {};
+}
+
+function saveModelsConfig(config) {
+    const dir = path.dirname(MODELS_CONFIG_PATH);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(MODELS_CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+function loadDeliberationUsage() {
+    try {
+        if (fs.existsSync(DELIBERATION_USAGE_PATH)) {
+            return JSON.parse(fs.readFileSync(DELIBERATION_USAGE_PATH, 'utf-8'));
+        }
+    } catch {}
+    return { used: 0, limit: 3 };
+}
+
+function getModelStatus(config, key) {
+    const entry = config[key];
+    if (entry && entry.enabled && entry.api_key) {
+        return { configured: true, model: entry.model || DEFAULT_MODELS[key].model };
+    }
+    return { configured: false, model: null };
+}
+
+function printModelStatus(config) {
+    const usage = loadDeliberationUsage();
+    const remaining = Math.max(0, (usage.limit || 3) - (usage.used || 0));
+    let configuredCount = 0;
+
+    console.log(chalk.bold.blue('\n  Delimit Models -- Deliberation Config\n'));
+    console.log(chalk.bold('  Current models:'));
+
+    for (const [key, defaults] of Object.entries(DEFAULT_MODELS)) {
+        const status = getModelStatus(config, key);
+        if (status.configured) {
+            configuredCount++;
+            console.log(`    ${chalk.green('*')} ${defaults.name.split(' ')[0].padEnd(10)} -- configured (${status.model})`);
+        } else {
+            const extra = key === 'openai' ? '' : '';
+            console.log(`    ${chalk.gray('o')} ${defaults.name.split(' ')[0].padEnd(10)} -- ${chalk.gray('not configured')}${extra}`);
+        }
+    }
+    console.log(`    ${chalk.gray('o')} ${'Claude'.padEnd(10)} -- ${chalk.gray('not configured (uses your Claude Code subscription)')}`);
+
+    console.log('');
+    console.log(`  ${remaining} free deliberation${remaining === 1 ? '' : 's'} remaining (of ${usage.limit || 3}).`);
+    if (configuredCount > 0) {
+        console.log(`  Mode: ${chalk.green('BYOK')} (${configuredCount} model${configuredCount === 1 ? '' : 's'})`);
+    } else {
+        console.log('  Add API keys for unlimited deliberation with your own models.');
+    }
+    console.log('');
+
+    return { configuredCount, remaining };
+}
+
+async function testModelKey(providerKey, apiKey, model) {
+    const provider = MODEL_PROVIDERS[providerKey];
+    const prompt = 'What is 2+2? Reply with just the number.';
+
+    try {
+        if (providerKey === 'gemini') {
+            const url = provider.endpoint.replace('{model}', model) + `?key=${apiKey}`;
+            const resp = await axios.post(url, {
+                contents: [{ parts: [{ text: prompt }] }],
+            }, { timeout: 15000, headers: { 'Content-Type': 'application/json' } });
+            const text = resp.data?.candidates?.[0]?.content?.parts?.[0]?.text || '';
+            return { ok: true, response: text.trim() };
+        } else {
+            const headers = { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` };
+            const body = { model, messages: [{ role: 'user', content: prompt }], max_tokens: 10 };
+            const resp = await axios.post(provider.endpoint, body, { timeout: 15000, headers });
+            const text = resp.data?.choices?.[0]?.message?.content || '';
+            return { ok: true, response: text.trim() };
+        }
+    } catch (err) {
+        const status = err.response?.status;
+        const msg = err.response?.data?.error?.message || err.message || 'Unknown error';
+        return { ok: false, error: `${status ? `HTTP ${status}: ` : ''}${msg}` };
+    }
+}
+
+program
+    .command('models')
+    .description('Configure deliberation model API keys (BYOK)')
+    .option('--status', 'Show current model configuration (non-interactive)')
+    .action(async (options) => {
+        const config = loadModelsConfig();
+
+        // --status: non-interactive output
+        if (options.status) {
+            let configuredCount = 0;
+            console.log('');
+            for (const [key, defaults] of Object.entries(DEFAULT_MODELS)) {
+                const status = getModelStatus(config, key);
+                const label = defaults.name.split(' ')[0] + ':';
+                if (status.configured) {
+                    configuredCount++;
+                    console.log(`  ${label.padEnd(10)} configured (${status.model})`);
+                } else {
+                    console.log(`  ${label.padEnd(10)} ${chalk.gray('not configured')}`);
+                }
+            }
+            console.log(`  ${'Mode:'.padEnd(10)} ${configuredCount > 0 ? `BYOK (${configuredCount} model${configuredCount === 1 ? '' : 's'})` : 'free tier'}`);
+            console.log('');
+            return;
+        }
+
+        // Interactive wizard
+        printModelStatus(config);
+
+        let running = true;
+        while (running) {
+            const choices = [
+                { name: 'Add Grok (xAI)', value: 'add_grok' },
+                { name: 'Add Gemini (Google)', value: 'add_gemini' },
+                { name: 'Add Codex/GPT-4o (OpenAI)', value: 'add_openai' },
+                new inquirer.Separator(),
+                { name: 'Remove a model', value: 'remove' },
+                { name: 'Test deliberation', value: 'test' },
+                { name: 'Exit', value: 'exit' },
+            ];
+
+            const { action } = await inquirer.prompt([{
+                type: 'list',
+                name: 'action',
+                message: 'Configure a model:',
+                choices,
+            }]);
+
+            if (action === 'exit') {
+                running = false;
+                break;
+            }
+
+            if (action.startsWith('add_')) {
+                const providerKey = action.replace('add_', '');
+                const provider = MODEL_PROVIDERS[providerKey];
+                const existing = config[providerKey];
+
+                // Warn if already configured
+                if (existing && existing.enabled && existing.api_key) {
+                    const { overwrite } = await inquirer.prompt([{
+                        type: 'confirm',
+                        name: 'overwrite',
+                        message: `${provider.label} is already configured. Overwrite?`,
+                        default: false,
+                    }]);
+                    if (!overwrite) continue;
+                }
+
+                // Prompt for API key
+                const { apiKey } = await inquirer.prompt([{
+                    type: 'password',
+                    name: 'apiKey',
+                    message: `Enter your ${provider.label} API key:`,
+                    mask: '*',
+                    validate: (input) => {
+                        if (!input || input.trim().length === 0) return 'API key cannot be empty.';
+                        if (!input.startsWith(provider.prefix)) {
+                            return `Key should start with "${provider.prefix}". Got: "${input.slice(0, 6)}..."`;
+                        }
+                        return true;
+                    },
+                }]);
+
+                // Optionally choose model variant
+                const { modelChoice } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'modelChoice',
+                    message: 'Select model:',
+                    choices: provider.variants.map(v => ({ name: v === provider.defaultModel ? `${v} (default)` : v, value: v })),
+                    default: provider.defaultModel,
+                }]);
+
+                config[providerKey] = {
+                    enabled: true,
+                    api_key: apiKey.trim(),
+                    model: modelChoice,
+                    name: provider.defaultName,
+                };
+                saveModelsConfig(config);
+                console.log(chalk.green(`\n  ${provider.label} configured with model ${modelChoice}.\n`));
+            }
+
+            if (action === 'remove') {
+                const configuredModels = Object.entries(config)
+                    .filter(([, v]) => v && v.enabled && v.api_key)
+                    .map(([k]) => ({ name: `${DEFAULT_MODELS[k]?.name || k} (${config[k].model})`, value: k }));
+
+                if (configuredModels.length === 0) {
+                    console.log(chalk.yellow('\n  No models configured to remove.\n'));
+                    continue;
+                }
+
+                const { toRemove } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'toRemove',
+                    message: 'Select model to remove:',
+                    choices: configuredModels,
+                }]);
+
+                config[toRemove] = { enabled: false, api_key: '', model: DEFAULT_MODELS[toRemove].model, name: DEFAULT_MODELS[toRemove].name };
+                saveModelsConfig(config);
+                console.log(chalk.green(`\n  ${DEFAULT_MODELS[toRemove].name} removed.\n`));
+            }
+
+            if (action === 'test') {
+                const configuredModels = Object.entries(config)
+                    .filter(([, v]) => v && v.enabled && v.api_key);
+
+                if (configuredModels.length === 0) {
+                    console.log(chalk.yellow('\n  No models configured. Add a model first.\n'));
+                    continue;
+                }
+
+                console.log(chalk.blue('\n  Testing deliberation models...\n'));
+                console.log(chalk.gray('  Prompt: "What is 2+2?"\n'));
+
+                for (const [key, entry] of configuredModels) {
+                    const label = (entry.name || key).padEnd(18);
+                    process.stdout.write(`  ${label} `);
+                    const result = await testModelKey(key, entry.api_key, entry.model);
+                    if (result.ok) {
+                        console.log(chalk.green(`pass`) + chalk.gray(` -- "${result.response}"`));
+                    } else {
+                        console.log(chalk.red(`fail`) + chalk.gray(` -- ${result.error}`));
+                    }
+                }
+                console.log('');
+            }
+        }
+    });
+
 // Version subcommand alias (users type 'delimit version' not 'delimit -V')
 program
     .command('version')
@@ -4297,18 +4666,80 @@ function extractTags(text) {
 }
 
 function readMemories() {
-    if (!fs.existsSync(MEMORY_FILE)) return [];
-    const lines = fs.readFileSync(MEMORY_FILE, 'utf-8').split('\n').filter(l => l.trim());
+    if (!fs.existsSync(MEMORY_DIR)) return [];
     const memories = [];
-    for (const line of lines) {
-        try { memories.push(JSON.parse(line)); } catch {}
+
+    // Read individual .json files (MCP format — primary)
+    try {
+        const files = fs.readdirSync(MEMORY_DIR).filter(f => f.endsWith('.json') && f.startsWith('mem-'));
+        for (const f of files) {
+            try {
+                const entry = JSON.parse(fs.readFileSync(path.join(MEMORY_DIR, f), 'utf-8'));
+                // Normalize: MCP uses "content", CLI used "text"
+                if (entry.content && !entry.text) entry.text = entry.content;
+                if (entry.text && !entry.content) entry.content = entry.text;
+                if (entry.created_at && !entry.created) entry.created = entry.created_at;
+                if (entry.created && !entry.created_at) entry.created_at = entry.created;
+                memories.push(entry);
+            } catch {}
+        }
+    } catch {}
+
+    // Also read legacy .jsonl file (CLI format — backwards compat)
+    if (fs.existsSync(MEMORY_FILE)) {
+        const lines = fs.readFileSync(MEMORY_FILE, 'utf-8').split('\n').filter(l => l.trim());
+        for (const line of lines) {
+            try {
+                const entry = JSON.parse(line);
+                // Skip if already loaded from .json file
+                if (!memories.find(m => m.id === entry.id)) {
+                    if (entry.text && !entry.content) entry.content = entry.text;
+                    if (entry.created && !entry.created_at) entry.created_at = entry.created;
+                    memories.push(entry);
+                }
+            } catch {}
+        }
     }
+
+    // Sort by created date, newest first
+    memories.sort((a, b) => new Date(b.created_at || b.created || 0) - new Date(a.created_at || a.created || 0));
     return memories;
 }
 
-function writeMemories(memories) {
+function writeMemory(entry) {
+    // Write in MCP-compatible format (individual .json files)
     fs.mkdirSync(MEMORY_DIR, { recursive: true });
-    fs.writeFileSync(MEMORY_FILE, memories.map(m => JSON.stringify(m)).join('\n') + (memories.length ? '\n' : ''));
+    const memId = 'mem-' + require('crypto').createHash('sha256').update(entry.text.slice(0, 100)).digest('hex').slice(0, 12);
+    const mcpEntry = {
+        id: memId,
+        content: entry.text,
+        tags: entry.tags || [],
+        context: entry.source || 'cli',
+        created_at: entry.created || new Date().toISOString(),
+    };
+    fs.writeFileSync(path.join(MEMORY_DIR, `${memId}.json`), JSON.stringify(mcpEntry, null, 2));
+    return memId;
+}
+
+function deleteMemory(id) {
+    // Delete from .json files
+    const jsonFile = path.join(MEMORY_DIR, `${id}.json`);
+    if (fs.existsSync(jsonFile)) {
+        fs.unlinkSync(jsonFile);
+        return true;
+    }
+    // Also check legacy .jsonl
+    if (fs.existsSync(MEMORY_FILE)) {
+        const lines = fs.readFileSync(MEMORY_FILE, 'utf-8').split('\n').filter(l => l.trim());
+        const filtered = lines.filter(l => {
+            try { return JSON.parse(l).id !== id; } catch { return true; }
+        });
+        if (filtered.length < lines.length) {
+            fs.writeFileSync(MEMORY_FILE, filtered.join('\n') + (filtered.length ? '\n' : ''));
+            return true;
+        }
+    }
+    return false;
 }
 
 function relativeTime(isoDate) {
@@ -4349,18 +4780,16 @@ program
         const manualTags = (options.tag || []).map(t => t.toLowerCase());
         const allTags = [...new Set([...autoTags, ...manualTags])];
 
-        const memories = readMemories();
         const entry = {
-            id: generateShortId(),
             text,
             tags: allTags,
             created: new Date().toISOString(),
             source: 'cli',
         };
-        memories.push(entry);
-        writeMemories(memories);
+        writeMemory(entry);
+        const total = readMemories().length;
 
-        console.log(chalk.green(`\n  Remembered.`) + chalk.gray(` (${memories.length} memor${memories.length === 1 ? 'y' : 'ies'} total)\n`));
+        console.log(chalk.green(`\n  Remembered.`) + chalk.gray(` (${total} memor${total === 1 ? 'y' : 'ies'} total)\n`));
     });
 
 program
@@ -4375,14 +4804,13 @@ program
 
         // --forget mode
         if (options.forget) {
-            const idx = memories.findIndex(m => m.id === options.forget);
-            if (idx === -1) {
+            if (deleteMemory(options.forget)) {
+                const remaining = readMemories().length;
+                console.log(chalk.green(`\n  Forgotten.`) + chalk.gray(` (${remaining} memor${remaining === 1 ? 'y' : 'ies'} remaining)\n`));
+            } else {
                 console.log(chalk.red(`\n  No memory found with ID: ${options.forget}\n`));
                 process.exit(1);
             }
-            memories.splice(idx, 1);
-            writeMemories(memories);
-            console.log(chalk.green(`\n  Forgotten.`) + chalk.gray(` (${memories.length} memor${memories.length === 1 ? 'y' : 'ies'} remaining)\n`));
             return;
         }
 
@@ -4454,15 +4882,13 @@ program
     .command('forget <id>')
     .description('Delete a memory by ID (alias for recall --forget)')
     .action((id) => {
-        const memories = readMemories();
-        const idx = memories.findIndex(m => m.id === id);
-        if (idx === -1) {
+        if (deleteMemory(id)) {
+            const remaining = readMemories().length;
+            console.log(chalk.green(`\n  Forgotten.`) + chalk.gray(` (${remaining} memor${remaining === 1 ? 'y' : 'ies'} remaining)\n`));
+        } else {
             console.log(chalk.red(`\n  No memory found with ID: ${id}\n`));
             process.exit(1);
         }
-        memories.splice(idx, 1);
-        writeMemories(memories);
-        console.log(chalk.green(`\n  Forgotten.`) + chalk.gray(` (${memories.length} memor${memories.length === 1 ? 'y' : 'ies'} remaining)\n`));
     });
 
 const normalizedArgs = normalizeNaturalLanguageArgs(process.argv);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "delimit-cli",
   "mcpName": "io.github.delimit-ai/delimit-mcp-server",
-  "version": "4.1.38",
+  "version": "4.1.41",
   "description": "Unify Claude Code, Codex, Cursor, and Gemini CLI with persistent context, governance, and multi-model debate.",
   "main": "index.js",
   "files": [

package/server.json

@@ -7,13 +7,13 @@
     "url": "https://github.com/delimit-ai/delimit-mcp-server",
     "source": "github"
   },
-  "version": "4.1.34",
+  "version": "4.1.40",
   "websiteUrl": "https://delimit.ai",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "delimit-cli",
-      "version": "4.1.34",
+      "version": "4.1.40",
       "transport": {
         "type": "stdio"
       }