@nxuss/lemma 0.5.3 → 0.5.5

package/dist/esm/cli/lemma-proxy.js

@@ -24,7 +24,7 @@ function getVersion() {
             catch { }
         }
     }
-    return '0.5.3';
+    return '0.5.4';
 }
 const VERSION = getVersion();
 import ComplexityRouter from '../proxy/ComplexityRouter';
@@ -209,141 +209,207 @@ function ensureGitIgnore() {
     return added;
 }
 const CLIPBOARD_PID_FILE = path.join(CACHE_DIR, 'clipboard.pid');
-export function autoConfigureAll(projectName) {
+export function autoConfigureAll(projectName, cliOpts) {
     const project = projectName || detectProject();
     const HOME = process.env.HOME || process.env.USERPROFILE || '~';
-    // 1. Claude Desktop Config
+    // Load configuration if it exists
+    let configDisabled = false;
+    let configEditor = true;
+    let configShell = true;
+    let configClaude = true;
     try {
-        const isWin = process.platform === 'win32';
-        const claudePath = isWin
-            ? path.join(process.env.APPDATA || '', 'Claude/claude_desktop_config.json')
-            : path.join(HOME, 'Library/Application Support/Claude/claude_desktop_config.json');
-        if (fs.existsSync(path.dirname(claudePath))) {
-            let config = { mcpServers: {} };
-            if (fs.existsSync(claudePath)) {
-                try {
-                    config = JSON.parse(fs.readFileSync(claudePath, 'utf8'));
+        const configPath = path.join(process.cwd(), 'lemma.config.json');
+        if (fs.existsSync(configPath)) {
+            const rawConfig = fs.readFileSync(configPath, 'utf8');
+            const config = JSON.parse(rawConfig);
+            const systemConfig = config.system || {};
+            const autoConfig = systemConfig.autoConfigure || {};
+            if (autoConfig.disabled === true)
+                configDisabled = true;
+            if (autoConfig.editor === false)
+                configEditor = false;
+            if (autoConfig.shell === false)
+                configShell = false;
+            if (autoConfig.claude === false)
+                configClaude = false;
+        }
+    }
+    catch { }
+    // Merge CLI overrides and config
+    const shouldConfigure = cliOpts?.configure !== false && !configDisabled;
+    if (!shouldConfigure) {
+        console.log(`⏭️  [Auto-Configure] Skipped auto-configuration (disabled via options or config).`);
+        return;
+    }
+    const runEditor = cliOpts?.editor !== false && configEditor;
+    const runShell = cliOpts?.shell !== false && configShell;
+    const runClaude = cliOpts?.claude !== false && configClaude;
+    // 1. Claude Desktop Config
+    if (runClaude) {
+        try {
+            const isWin = process.platform === 'win32';
+            const claudePath = isWin
+                ? path.join(process.env.APPDATA || '', 'Claude/claude_desktop_config.json')
+                : path.join(HOME, 'Library/Application Support/Claude/claude_desktop_config.json');
+            if (fs.existsSync(path.dirname(claudePath))) {
+                let config = { mcpServers: {} };
+                if (fs.existsSync(claudePath)) {
+                    try {
+                        config = JSON.parse(fs.readFileSync(claudePath, 'utf8'));
+                    }
+                    catch { }
                 }
-                catch { }
+                if (!config.mcpServers)
+                    config.mcpServers = {};
+                config.mcpServers.lemma = {
+                    command: 'npx',
+                    args: ['-y', '@nxuss/lemma', 'mcp'],
+                    env: { LEMMA_PROJECT: project }
+                };
+                fs.writeFileSync(claudePath, JSON.stringify(config, null, 2));
+                console.log(`✅ [Claude Desktop] Configured automatically in: ${claudePath} (Restart Claude to activate)`);
             }
-            if (!config.mcpServers)
-                config.mcpServers = {};
-            config.mcpServers.lemma = {
-                command: 'npx',
-                args: ['-y', '@nxuss/lemma', 'mcp'],
-                env: { LEMMA_PROJECT: project }
-            };
-            fs.writeFileSync(claudePath, JSON.stringify(config, null, 2));
-            console.log(`✅ [Claude Desktop] Configured automatically! (Restart Claude to activate)`);
+        }
+        catch (e) {
+            console.log(`⚠️  Could not auto-configure Claude Desktop: ${e.message}`);
         }
     }
-    catch (e) {
-        console.log(`⚠️  Could not auto-configure Claude Desktop: ${e.message}`);
+    else {
+        console.log(`⏭️  [Claude Desktop] Skip auto-configuration.`);
     }
     // 2. Shell Profiles Environment Override
-    try {
-        const profiles = [
-            path.join(HOME, '.zshrc'),
-            path.join(HOME, '.bashrc'),
-            path.join(HOME, '.bash_profile'),
-            path.join(HOME, '.profile')
-        ];
-        const lines = [
-            '',
-            '# Lemma AI Gateway Overrides',
-            'export OPENAI_BASE_URL="http://localhost:8081/v1"',
-            'export ANTHROPIC_BASE_URL="http://localhost:8081"',
-            'export LEMMA_PROJECT="' + project + '"',
-            ''
-        ].join('\n');
-        for (const profile of profiles) {
-            if (fs.existsSync(profile)) {
-                try {
-                    const content = fs.readFileSync(profile, 'utf8');
-                    if (!content.includes('OPENAI_BASE_URL') && !content.includes('LEMMA_PROJECT')) {
-                        fs.appendFileSync(profile, lines);
-                        console.log(`✅ [Shell Profile] Configured ${path.basename(profile)} with local redirect variables!`);
+    if (runShell) {
+        try {
+            const profiles = [
+                path.join(HOME, '.zshrc'),
+                path.join(HOME, '.bashrc'),
+                path.join(HOME, '.bash_profile'),
+                path.join(HOME, '.profile')
+            ];
+            const lines = [
+                '',
+                '# Lemma AI Gateway Overrides',
+                'export OPENAI_BASE_URL="http://localhost:8081/v1"',
+                'export ANTHROPIC_BASE_URL="http://localhost:8081"',
+                'export LEMMA_PROJECT="' + project + '"',
+                ''
+            ].join('\n');
+            for (const profile of profiles) {
+                if (fs.existsSync(profile)) {
+                    try {
+                        const content = fs.readFileSync(profile, 'utf8');
+                        if (!content.includes('OPENAI_BASE_URL') && !content.includes('LEMMA_PROJECT')) {
+                            fs.appendFileSync(profile, lines);
+                            console.log(`✅ [Shell Profile] Configured ${path.basename(profile)} with local redirect variables!`);
+                        }
                     }
+                    catch { }
                 }
-                catch { }
             }
         }
+        catch (e) {
+            console.log(`⚠️  Could not auto-configure shell profiles: ${e.message}`);
+        }
     }
-    catch (e) {
-        console.log(`⚠️  Could not auto-configure shell profiles: ${e.message}`);
+    else {
+        console.log(`⏭️  [Shell Profile] Skip auto-configuration.`);
     }
     // 3. Cursor & Windsurf settings.json updates
-    try {
-        const isWin = process.platform === 'win32';
-        const isMac = process.platform === 'darwin';
-        const candidates = [];
-        if (isMac) {
-            candidates.push({
-                name: 'Cursor',
-                path: path.join(HOME, 'Library/Application Support/Cursor/User/settings.json')
-            });
-            candidates.push({
-                name: 'Windsurf',
-                path: path.join(HOME, 'Library/Application Support/Windsurf/User/settings.json')
-            });
-        }
-        else if (isWin) {
-            const appData = process.env.APPDATA || '';
-            candidates.push({
-                name: 'Cursor',
-                path: path.join(appData, 'Cursor/User/settings.json')
-            });
-            candidates.push({
-                name: 'Windsurf',
-                path: path.join(appData, 'Windsurf/User/settings.json')
-            });
-        }
-        else {
-            candidates.push({
-                name: 'Cursor',
-                path: path.join(HOME, '.config/Cursor/User/settings.json')
-            });
-            candidates.push({
-                name: 'Windsurf',
-                path: path.join(HOME, '.config/Windsurf/User/settings.json')
-            });
-        }
-        for (const cand of candidates) {
-            const dir = path.dirname(cand.path);
-            if (fs.existsSync(dir)) {
-                let settings = {};
-                if (fs.existsSync(cand.path)) {
-                    try {
-                        settings = JSON.parse(fs.readFileSync(cand.path, 'utf8'));
+    if (runEditor) {
+        try {
+            const isWin = process.platform === 'win32';
+            const isMac = process.platform === 'darwin';
+            const candidates = [];
+            if (isMac) {
+                candidates.push({
+                    name: 'Cursor',
+                    path: path.join(HOME, 'Library/Application Support/Cursor/User/settings.json')
+                });
+                candidates.push({
+                    name: 'Windsurf',
+                    path: path.join(HOME, 'Library/Application Support/Windsurf/User/settings.json')
+                });
+            }
+            else if (isWin) {
+                const appData = process.env.APPDATA || '';
+                candidates.push({
+                    name: 'Cursor',
+                    path: path.join(appData, 'Cursor/User/settings.json')
+                });
+                candidates.push({
+                    name: 'Windsurf',
+                    path: path.join(appData, 'Windsurf/User/settings.json')
+                });
+            }
+            else {
+                candidates.push({
+                    name: 'Cursor',
+                    path: path.join(HOME, '.config/Cursor/User/settings.json')
+                });
+                candidates.push({
+                    name: 'Windsurf',
+                    path: path.join(HOME, '.config/Windsurf/User/settings.json')
+                });
+            }
+            for (const cand of candidates) {
+                const dir = path.dirname(cand.path);
+                if (fs.existsSync(dir)) {
+                    let settings = {};
+                    if (fs.existsSync(cand.path)) {
+                        try {
+                            settings = JSON.parse(fs.readFileSync(cand.path, 'utf8'));
+                        }
+                        catch { }
                     }
-                    catch { }
-                }
-                let updated = false;
-                // Settings configuration to route custom openai/anthropic models through the proxy
-                const updates = {
-                    "openai.baseURL": "http://localhost:8081/v1",
-                    "openai.apiKey": "dummy-key-for-lemma",
-                    "anthropic.baseURL": "http://localhost:8081",
-                    "anthropic.apiKey": "dummy-key-for-lemma"
-                };
-                for (const [key, value] of Object.entries(updates)) {
-                    if (settings[key] !== value) {
-                        settings[key] = value;
-                        updated = true;
+                    let updated = false;
+                    // Settings configuration to route custom openai/anthropic models through the proxy
+                    const updates = {
+                        "openai.baseURL": "http://localhost:8081/v1",
+                        "openai.apiKey": "dummy-key-for-lemma",
+                        "anthropic.baseURL": "http://localhost:8081",
+                        "anthropic.apiKey": "dummy-key-for-lemma"
+                    };
+                    for (const [key, value] of Object.entries(updates)) {
+                        if (settings[key] !== value) {
+                            settings[key] = value;
+                            updated = true;
+                        }
+                    }
+                    if (updated) {
+                        fs.writeFileSync(cand.path, JSON.stringify(settings, null, 2));
+                        console.log(`✅ [${cand.name}] Configured editor settings in ${cand.path} to route via local gateway!`);
                     }
-                }
-                if (updated) {
-                    fs.writeFileSync(cand.path, JSON.stringify(settings, null, 2));
-                    console.log(`✅ [${cand.name}] Configured editor settings to route via local gateway!`);
                 }
             }
         }
+        catch (e) {
+            console.log(`⚠️  Could not auto-configure editor settings: ${e.message}`);
+        }
     }
-    catch (e) {
-        console.log(`⚠️  Could not auto-configure editor settings: ${e.message}`);
+    else {
+        console.log(`⏭️  [Editor Settings] Skip auto-configuration.`);
     }
 }
-export function startBackgroundClipboardWatcher() {
+export function startBackgroundClipboardWatcher(cliOpts) {
+    // Load configuration if it exists
+    let configDisabled = false;
+    try {
+        const configPath = path.join(process.cwd(), 'lemma.config.json');
+        if (fs.existsSync(configPath)) {
+            const rawConfig = fs.readFileSync(configPath, 'utf8');
+            const config = JSON.parse(rawConfig);
+            const systemConfig = config.system || {};
+            const clipConfig = systemConfig.clipboardWatcher || {};
+            if (clipConfig.disabled === true)
+                configDisabled = true;
+        }
+    }
+    catch { }
+    const shouldWatch = cliOpts?.clipboard !== false && !configDisabled;
+    if (!shouldWatch) {
+        console.log(`⏭️  [Clipboard] Background clipboard watcher is disabled (via options or config).`);
+        return;
+    }
     try {
         if (fs.existsSync(CLIPBOARD_PID_FILE)) {
             const oldPid = fs.readFileSync(CLIPBOARD_PID_FILE, 'utf8');
@@ -462,16 +528,21 @@ async function recordStat(stats, project, fromCache, latencyMs, provider, tokens
     s.total++;
     s.totalLatency += latencyMs;
     fromCache ? s.hits++ : s.misses++;
-    s.totalTokensSaved += (fromCache ? (tokensSaved || 2000) : (tokensSaved || 0));
+    const tkSaved = fromCache ? (tokensSaved || 2000) : (tokensSaved || 0);
+    s.totalTokensSaved += tkSaved;
     if (!s.providers[provider])
         s.providers[provider] = { hits: 0, misses: 0 };
     fromCache ? s.providers[provider].hits++ : s.providers[provider].misses++;
+    if (fromCache && tkSaved > 0) {
+        // Automatically report cache hits directly to the server session ledger for absolute sync consistency
+        savingsLedger.recordTokens('cache', tkSaved);
+    }
     logEvent({
         type: fromCache ? 'cache:hit' : 'cache:miss',
         project,
         latency: latencyMs,
         provider,
-        tokens: fromCache ? (tokensSaved || 2000) : (tokensSaved || 0)
+        tokens: tkSaved
     });
     await writeJson(STATS_FILE, stats);
 }
@@ -844,6 +915,18 @@ class LemmaServer {
                 const hitRate = stats.total > 0 ? stats.hits / stats.total : 0;
                 const avgLat = stats.total > 0 ? stats.totalLatency / stats.total : 0;
                 const secretsMasked = EVENT_LOG.filter(e => e.type === 'privacy:mask').length;
+                const ledgerSnap = savingsLedger.getSnapshot();
+                let activeAgents = 1; // Always include the Gateway itself
+                let totalAgents = 1;
+                // Query the stack orchestration API to merge active agents
+                try {
+                    const stackMetrics = await axios.get('http://127.0.0.1:8083/api/metrics', { timeout: 100 });
+                    if (stackMetrics.data) {
+                        activeAgents += stackMetrics.data.activeAgents || 0;
+                        totalAgents += stackMetrics.data.totalAgents || 0;
+                    }
+                }
+                catch { }
                 res.json({
                     timestamp: new Date().toISOString(),
                     totalRequests: stats.total,
@@ -851,30 +934,140 @@ class LemmaServer {
                     cacheMisses: stats.misses,
                     hitRate,
                     averageLatency: avgLat,
-                    tokensSaved: stats.totalTokensSaved,
-                    costSaved: (stats.totalTokensSaved / 1000) * 0.02,
+                    tokensSaved: ledgerSnap.total.tokensSaved,
+                    costSaved: ledgerSnap.total.costSaved,
                     secretsMasked: secretsMasked,
-                    activeAgents: 1,
-                    totalAgents: 1,
+                    activeAgents,
+                    totalAgents,
                     uptime: process.uptime(),
                     tier: (await isPro()) ? 'pro' : 'free'
                 });
             });
             this.app.get('/api/agents', async (req, res) => {
+                // Load statistics for the Gateway itself
                 const stats = await loadStats();
-                res.json({ agents: [
-                        { id: 'lemma-gateway', name: 'Lemma Gateway', status: 'active', capabilities: ['Privacy Firewall', 'Semantic Cache', 'Complexity Router'], tasksCompleted: stats[this.projectName]?.total || 0, lastSeen: new Date().toISOString(), errorCount: 0, cacheHitRate: 0.85 }
-                    ] });
+                const statsProj = stats[this.projectName] || { total: 0, hits: 0 };
+                const total = statsProj.total || 0;
+                const hits = statsProj.hits || 0;
+                const gatewayAgent = {
+                    id: 'lemma-gateway',
+                    name: 'Lemma Gateway',
+                    status: 'active',
+                    capabilities: ['Privacy Firewall', 'Semantic Cache', 'Complexity Router'],
+                    tasksCompleted: total,
+                    lastSeen: new Date().toISOString(),
+                    errorCount: 0,
+                    cacheHitRate: total > 0 ? hits / total : 0
+                };
+                let agentsList = [gatewayAgent];
+                // Query the stack orchestration API to merge dynamic websocket agents if running
+                try {
+                    const stackAgentsResponse = await axios.get('http://127.0.0.1:8083/api/agents', { timeout: 100 });
+                    if (stackAgentsResponse.data && Array.isArray(stackAgentsResponse.data.agents)) {
+                        const stackAgents = stackAgentsResponse.data.agents.filter((a) => a.id !== 'lemma-gateway');
+                        agentsList = [...agentsList, ...stackAgents];
+                    }
+                }
+                catch { }
+                res.json({ agents: agentsList });
             });
-            this.app.get('/api/events', (req, res) => {
+            this.app.get('/api/events', async (req, res) => {
                 const page = parseInt(req.query.page) || 1;
                 const limit = parseInt(req.query.limit) || 50;
                 const start = (page - 1) * limit;
-                const events = EVENT_LOG.slice().reverse().slice(start, start + limit);
-                res.json({ events, pagination: { total: EVENT_LOG.length, page, limit } });
+                // Get local proxy events (normalized schema matching what dashboard expects)
+                const localEvents = EVENT_LOG.map(e => ({
+                    id: e.id,
+                    timestamp: new Date(e.timestamp).toISOString(),
+                    type: e.type, // e.g., 'cache:hit' or 'cache:miss' which client normalizes to 'cache_hit' or 'cache_miss'
+                    latency: e.latency,
+                    tokensSaved: e.tokens,
+                    costSaved: e.tokens ? (e.tokens / 1000) * 0.002 : 0,
+                    metadata: {
+                        provider: e.provider,
+                        project: e.project
+                    }
+                }));
+                let mergedEvents = [...localEvents];
+                // Query the stack orchestration API if running to merge stack events
+                try {
+                    const stackEventsResponse = await axios.get(`http://127.0.0.1:8083/api/events?page=1&limit=100`, { timeout: 100 });
+                    if (stackEventsResponse.data && Array.isArray(stackEventsResponse.data.events)) {
+                        mergedEvents = [...mergedEvents, ...stackEventsResponse.data.events];
+                    }
+                }
+                catch { }
+                // Sort merged events chronologically (newest first)
+                mergedEvents.sort((a, b) => {
+                    const tA = new Date(a.timestamp).getTime();
+                    const tB = new Date(b.timestamp).getTime();
+                    return tB - tA;
+                });
+                const total = mergedEvents.length;
+                const paginatedEvents = mergedEvents.slice(start, start + limit);
+                res.json({
+                    events: paginatedEvents,
+                    pagination: {
+                        total,
+                        page,
+                        limit,
+                        hasMore: start + limit < total
+                    }
+                });
             });
-            this.app.get('/api/cache-stats', (req, res) => {
-                res.json({ topQueries: [] });
+            this.app.get('/api/cache-stats', async (req, res) => {
+                let topQueries = [];
+                let totalCached = CACHE.size;
+                // Try to query ChromaDB for semantic cache count
+                try {
+                    const collection = await chroma.getOrCreateCollection({
+                        name: 'lemma-cache',
+                        embeddingFunction: dummyEmbeddingFunction,
+                        metadata: { "hnsw:space": "cosine" }
+                    });
+                    const count = await collection.count();
+                    totalCached += count;
+                }
+                catch { }
+                // Build top queries from in-memory CACHE
+                for (const [key, entry] of CACHE.entries()) {
+                    const hitCount = EVENT_LOG.filter(e => e.type === 'cache:hit' && e.provider === entry.provider).length || 1;
+                    const tokens = 2000;
+                    topQueries.push({
+                        queryHash: key.substring(0, 16),
+                        query: entry.input,
+                        hitCount,
+                        totalTokens: tokens * hitCount,
+                        costSaved: (tokens * hitCount / 1000) * 0.002,
+                        lastHit: new Date(entry.createdAt).toISOString()
+                    });
+                }
+                // Try to query the stack orchestration API if running to append stack cache stats
+                try {
+                    const stackCache = await axios.get('http://127.0.0.1:8083/api/cache-stats', { timeout: 100 });
+                    if (stackCache.data) {
+                        totalCached += stackCache.data.totalCached || 0;
+                        if (Array.isArray(stackCache.data.topQueries)) {
+                            const stackTop = stackCache.data.topQueries.filter((q) => !topQueries.some(t => t.query === q.query));
+                            topQueries = [...topQueries, ...stackTop];
+                        }
+                    }
+                }
+                catch { }
+                // Sort by hitCount desc
+                topQueries.sort((a, b) => b.hitCount - a.hitCount);
+                // Latency percentiles from EVENT_LOG
+                const latencies = EVENT_LOG.filter(e => e.latency).map(e => e.latency).sort((a, b) => a - b);
+                const latencyPercentiles = {
+                    p50: latencies[Math.floor(latencies.length * 0.5)] || 0,
+                    p95: latencies[Math.floor(latencies.length * 0.95)] || 0,
+                    p99: latencies[Math.floor(latencies.length * 0.99)] || 0,
+                };
+                res.json({
+                    topQueries: topQueries.slice(0, 10),
+                    latencyPercentiles,
+                    totalCached
+                });
             });
             this.app.get('/api/search', async (req, res) => {
                 const query = req.query.q;
@@ -1010,7 +1203,6 @@ class LemmaServer {
         const hit = cacheGet(provider, prompt);
         if (hit) {
             const cacheTokensSaved = 2000;
-            savingsLedger.recordTokens('cache', cacheTokensSaved);
             await recordStat(this.stats, this.projectName, true, Date.now() - t0, provider, cacheTokensSaved);
             const unmaskedData = semanticScrubber.unmask(hit.data, tokenMap);
             if (isStream)
@@ -1198,6 +1390,43 @@ Adjusted Answer:`;
     }
     async callUpstream(body, provider) {
         let apiKey = provider === 'openai' ? process.env.OPENAI_API_KEY : (provider === 'anthropic' ? process.env.ANTHROPIC_API_KEY : process.env.GEMINI_API_KEY);
+        // If the API key is an OpenAI key (sk-proj-) but requested for Anthropic or Gemini,
+        // multiplex it internally to OpenAI gpt-4o-mini to allow live, cheap simulated provider routing.
+        const isMockedProvider = apiKey && apiKey.startsWith('sk-') && provider !== 'openai';
+        if (isMockedProvider) {
+            console.log(`\n\x1b[36m🔀 [Gateway Router] Multiplexing B2B ${provider.toUpperCase()} request to OpenAI using key: ...${apiKey.substring(8, 14)}...\x1b[0m`);
+            const payload = {
+                model: 'gpt-4o-mini',
+                messages: body.messages || [{ role: 'user', content: extractPrompt(body, provider) || 'Hello' }],
+                stream: false // keep stream false for simulation simplicity
+            };
+            const baseURL = 'https://api.openai.com/v1/chat/completions';
+            const resp = await axios.post(baseURL, payload, {
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            if (provider === 'anthropic') {
+                const text = resp.data.choices?.[0]?.message?.content || '';
+                return {
+                    id: `msg-${Date.now()}`,
+                    type: 'message',
+                    role: 'assistant',
+                    content: [{ type: 'text', text }],
+                    model: body.model || 'claude-3-5-sonnet'
+                };
+            }
+            else if (provider === 'gemini') {
+                const text = resp.data.choices?.[0]?.message?.content || '';
+                return {
+                    candidates: [{
+                            content: { parts: [{ text }] },
+                            finishReason: 'STOP'
+                        }]
+                };
+            }
+        }
         if (!apiKey) {
             console.log(`\n\x1b[33m⚠️  No API Key found for ${provider.toUpperCase()}. Falling back to local Ollama (Zero-Cost Mode)!\x1b[0m`);
             // If the requested model is a cloud model (e.g. gpt-4o, claude), map it to a local model like llama3
@@ -1343,6 +1572,8 @@ program.command('start')
     .option('--project <name>', 'Override project name')
     .option('--stack', 'Launch full development stack (Chroma + Router + Dashboard + Autopilot)')
     .option('--autopilot', 'Launch background compiler watcher & healer', false)
+    .option('--no-configure', 'Skip automatic configuration of editors, shell overrides, and Claude Desktop')
+    .option('--no-clipboard', 'Skip launching background clipboard watcher')
     .action(async (opts) => {
     const port = parseInt(opts.port, 10);
     // Ensure ChromaDB is running for semantic caching/search
@@ -1354,15 +1585,15 @@ program.command('start')
             console.log(`💡 Use 'lemma status' for details or 'lemma stop' to restart.\n`);
             // Keep configurations up to date even if server was already started
             const runningProject = resp.data.project || detectProject();
-            autoConfigureAll(runningProject);
-            startBackgroundClipboardWatcher();
+            autoConfigureAll(runningProject, { configure: opts.configure });
+            startBackgroundClipboardWatcher({ clipboard: opts.clipboard });
             process.exit(0);
         }
     }
     catch { }
     const startProject = opts.project || detectProject();
-    autoConfigureAll(startProject);
-    startBackgroundClipboardWatcher();
+    autoConfigureAll(startProject, { configure: opts.configure });
+    startBackgroundClipboardWatcher({ clipboard: opts.clipboard });
     // Automatically enable autopilot if stack is enabled and user is Pro
     const runAutopilot = opts.autopilot || opts.stack;
     if (runAutopilot) {
@@ -1538,7 +1769,8 @@ program.command('activate <key>')
 });
 program.command('init')
     .description('Initialize Lemma in the current project (auto-discovery)')
-    .action(async () => {
+    .option('--no-configure', 'Skip automatic configuration of editors, shell overrides, and Claude Desktop')
+    .action(async (opts) => {
     const project = detectProject();
     console.log(`\n🛠️  Initializing Lemma for [${project}]...`);
     // Ensure ChromaDB is running for semantic caching/search
@@ -1568,7 +1800,7 @@ program.command('init')
         console.log('✅ Created .env with Lemma configuration');
     }
     console.log('\n🧠 \x1b[35mAuto-Setup MCP and redirection overrides for AI IDEs...\x1b[0m');
-    autoConfigureAll(project);
+    autoConfigureAll(project, { configure: opts.configure });
     console.log('\n✨ Project initialized for the Agentic Era!');
     console.log('🚀 Run "lemma start" to begin.\n');
 });