@nxuss/lemma 0.7.2 → 0.7.4

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

@@ -32,6 +32,8 @@ import SemanticScrubber from '../security/SemanticScrubber';
 import CloudSyncClient from '../cloud/CloudSyncClient';
 import { pruneHistoryMessages, squeezePrompt } from '../utils/ContextSqueezer';
 import { AgentMultiplexer } from '../proxy/AgentMultiplexer';
+import { ProjectRegistry } from '../proxy/ProjectRegistry';
+import { shouldInject, buildMinimalContext, buildDeepContext, sniffProjectFromMessages } from '../proxy/ContextInjector';
 import { savingsLedger } from '../utils/SavingsLedger';
 const chroma = new ChromaClient({ host: 'localhost', port: 8000 });
 const dummyEmbeddingFunction = { generate: (texts) => Promise.resolve([]) };
@@ -47,381 +49,184 @@ const PORT_FILE = path.join(CACHE_DIR, 'proxy.port');
 const STATS_FILE = path.join(CACHE_DIR, 'stats.json');
 const USAGE_FILE = path.join(CACHE_DIR, 'usage.json');
 const LICENSE_FILE = path.join(CACHE_DIR, 'license.json');
-const EVENT_LOG = [];
-const MAX_EVENTS = 100;
-// MCP Status tracking
-const MCP_STATUS = {
-    lastActivity: Date.now(),
-    toolCallCount: 0,
-    status: 'idle'
-};
-function logEvent(event) {
-    const ev = { id: Math.random().toString(36).slice(2, 11), timestamp: Date.now(), ...event };
-    EVENT_LOG.push(ev);
-    if (EVENT_LOG.length > MAX_EVENTS)
-        EVENT_LOG.shift();
-    // Track MCP activity
-    if (event.type === 'mcp_tool_call') {
-        MCP_STATUS.lastActivity = Date.now();
-        MCP_STATUS.toolCallCount++;
-        MCP_STATUS.status = 'active';
+const CLIPBOARD_PID_FILE = path.join(CACHE_DIR, 'clipboard.pid');
+const FREE_LIMIT = 300;
+const VALIDATE_URL = 'https://lemma.nxus.studio/api/validate-license';
+async function checkDependency(url) {
+    try {
+        const resp = await fetch(url, { method: 'HEAD', signal: AbortSignal.timeout(2000) });
+        return resp.ok;
     }
-    // Print a terminal savings summary every 10 events
-    if (EVENT_LOG.length > 0 && EVENT_LOG.length % 10 === 0) {
-        const snap = savingsLedger.getSnapshot();
-        if (snap.total.tokensSaved > 0) {
-            console.log('\n' + savingsLedger.getTerminalSummary() + '\n');
-        }
+    catch {
+        return false;
     }
 }
-const FREE_LIMIT = 500;
-const WARN_PCT = 0.8;
-const VALIDATE_URL = 'https://lemma.nxus.studio/api/v1/validate';
-if (!fs.existsSync(CACHE_DIR))
-    fs.mkdirSync(CACHE_DIR, { recursive: true });
-// ── Helpers ────────────────────────────────────────────────────────────────────
-async function readJson(file, fallback) {
+function getPidByPort(port) {
     try {
-        if (await fs.promises.access(file).then(() => true).catch(() => false)) {
-            const content = await fs.promises.readFile(file, 'utf8');
-            return JSON.parse(content);
-        }
+        const result = require('child_process').execSync(`lsof -ti :${port} 2>/dev/null`, { encoding: 'utf8' }).trim();
+        return result || null;
+    }
+    catch {
+        return null;
     }
-    catch { }
-    return fallback;
 }
-const writeQueues = new Map();
-async function writeJson(file, data) {
-    const chain = writeQueues.get(file) || Promise.resolve();
-    const writeOperation = async () => {
-        try {
-            const tempFile = `${file}.${crypto.randomUUID ? crypto.randomUUID() : Math.random().toString(36).substring(2, 15)}.tmp`;
-            await fs.promises.writeFile(tempFile, JSON.stringify(data, null, 2));
-            await fs.promises.rename(tempFile, file);
+function readJson(filePath, defaultVal) {
+    try {
+        if (fs.existsSync(filePath)) {
+            return JSON.parse(fs.readFileSync(filePath, 'utf8'));
         }
-        catch { }
-    };
-    const nextChain = chain.then(writeOperation).catch(() => { });
-    writeQueues.set(file, nextChain);
-    return nextChain;
+    }
+    catch { }
+    return defaultVal;
 }
-function projectHash(name) {
-    return crypto.createHash('sha1').update(name).digest('hex').slice(0, 12);
+function writeJson(filePath, data) {
+    try {
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+    }
+    catch { }
 }
 function getCollectionName(projectName) {
-    let cleanName = projectName.replace(/[^a-zA-Z0-9._-]/g, '_');
-    cleanName = cleanName.replace(/^[^a-zA-Z0-9]+/, '');
-    cleanName = cleanName.replace(/[^a-zA-Z0-9]+$/, '');
-    if (cleanName.length < 3) {
-        cleanName = 'lemma_proj_' + cleanName;
-    }
-    return `lemma-cache-${cleanName}`;
+    return `lemma-cache-${projectName}`;
 }
 function detectProject() {
-    const pkgPath = path.join(process.cwd(), 'package.json');
+    const cwd = process.cwd();
+    const pkgPath = path.join(cwd, 'package.json');
     if (fs.existsSync(pkgPath)) {
         try {
-            const p = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-            if (p.name)
-                return p.name;
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            if (pkg.name)
+                return pkg.name;
         }
         catch { }
     }
-    return path.basename(process.cwd());
+    return path.basename(cwd);
 }
-function ensureProjectDir(name) {
-    const dir = path.join(CACHE_DIR, projectHash(name));
-    if (!fs.existsSync(dir))
+function ensureProjectDir(projectName) {
+    const hash = crypto.createHash('sha1').update(projectName).digest('hex').slice(0, 12);
+    const dir = path.join(CACHE_DIR, hash);
+    if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
-    const marker = path.join(dir, 'project-name.txt');
-    if (!fs.existsSync(marker))
-        fs.writeFileSync(marker, name);
+    }
     return dir;
 }
-function getPidByPort(port) {
-    const { execSync } = require('child_process');
-    try {
-        if (process.platform === 'win32') {
-            const out = execSync(`netstat -ano | findstr :${port}`).toString();
-            const match = out.match(/LISTENING\s+(\d+)/);
-            return match ? match[1] : null;
-        }
-        else {
-            const out = execSync(`lsof -t -i :${port}`).toString().trim();
-            return out.split('\n')[0]; // Take first if multiple
-        }
+function ensureGitIgnore() {
+    const gitignorePath = path.join(process.cwd(), '.gitignore');
+    const lemmaRules = '\n# Lemma AI Gateway\n.lemma/\n';
+    if (fs.existsSync(gitignorePath)) {
+        const content = fs.readFileSync(gitignorePath, 'utf8');
+        if (content.includes('.lemma/'))
+            return false;
+        fs.appendFileSync(gitignorePath, lemmaRules);
     }
-    catch {
-        return null;
+    else {
+        fs.writeFileSync(gitignorePath, lemmaRules);
     }
+    return true;
 }
-async function checkDependency(url) {
+async function ensureChromaRunning() {
     try {
-        const res = await axios.get(url, { timeout: 1000, validateStatus: () => true });
-        return res.status >= 200 && res.status < 500;
+        await chroma.heartbeat();
     }
     catch {
-        return false;
-    }
-}
-async function ensureChromaRunning() {
-    const chromaPort = process.env.CHROMA_PORT || '8000';
-    const chromaHost = process.env.CHROMA_HOST || 'http://localhost';
-    const chromaUrl = `${chromaHost}:${chromaPort}`;
-    const isChromaUp = await checkDependency(`${chromaUrl}/api/v1/heartbeat`);
-    if (isChromaUp) {
-        console.log(`✅ \x1b[32m[ChromaDB]\x1b[0m ChromaDB is already running on port ${chromaPort}`);
-        return true;
-    }
-    console.log(`\n📦 \x1b[35m[ChromaDB]\x1b[0m ChromaDB is not running on port ${chromaPort}.`);
-    console.log(`🔄 Starting ChromaDB in background...`);
-    const chromaDataPath = path.join(CACHE_DIR, 'chroma_data');
-    try {
+        console.log('⚠️  ChromaDB is not running. Starting it...');
         const { spawn } = require('child_process');
-        if (!fs.existsSync(chromaDataPath)) {
-            fs.mkdirSync(chromaDataPath, { recursive: true });
-        }
-        const chromaProcess = spawn('chroma', ['run', '--path', chromaDataPath, '--port', chromaPort], {
+        const cp = spawn('chroma', ['run', '--path', path.join(CACHE_DIR, 'chroma_data')], {
             stdio: 'ignore',
-            detached: true
+            detached: true,
         });
-        chromaProcess.unref();
-        // Wait up to 5 seconds for ChromaDB to start
-        for (let i = 0; i < 5; i++) {
-            await new Promise(r => setTimeout(r, 1000));
-            const up = await checkDependency(`${chromaUrl}/api/v1/heartbeat`);
-            if (up) {
-                console.log(`✅ \x1b[32m[ChromaDB]\x1b[0m ChromaDB has been started and is ready!`);
-                return true;
-            }
-        }
-        console.log(`⚠️  \x1b[33m[ChromaDB]\x1b[0m ChromaDB was started but is taking longer to respond. It will continue starting in the background.`);
-        return true;
-    }
-    catch (err) {
-        console.error(`❌ Failed to automatically start ChromaDB: ${err.message}`);
-        console.error(`👉 Please start it manually: chroma run --path ${chromaDataPath} --port ${chromaPort}`);
-        return false;
-    }
-}
-function ensureGitIgnore() {
-    const gi = path.join(process.cwd(), '.gitignore');
-    let added = false;
-    try {
-        let content = '';
-        if (fs.existsSync(gi)) {
-            content = fs.readFileSync(gi, 'utf8');
-        }
-        const appendLines = [];
-        if (!content.includes('.lemma/')) {
-            appendLines.push('# Lemma Context Logs', '.lemma/');
-            added = true;
-        }
-        if (!content.includes('chroma_data/')) {
-            appendLines.push('# Lemma Local Vector Database', 'chroma_data/');
-            added = true;
-        }
-        if (appendLines.length > 0) {
-            const prefix = content.endsWith('\n') || content === '' ? '' : '\n';
-            fs.appendFileSync(gi, prefix + appendLines.join('\n') + '\n');
-        }
+        cp.unref();
+        await new Promise(resolve => setTimeout(resolve, 3000));
     }
-    catch { }
-    return added;
 }
-const CLIPBOARD_PID_FILE = path.join(CACHE_DIR, 'clipboard.pid');
-export function autoConfigureAll(projectName, cliOpts) {
-    const project = projectName || detectProject();
-    const HOME = process.env.HOME || process.env.USERPROFILE || '~';
-    // Load configuration if it exists
-    let configDisabled = false;
-    let configEditor = true;
-    let configShell = true;
-    let configClaude = true;
-    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 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).`);
+function autoConfigureAll(project, opts) {
+    if (!opts.configure) {
+        console.log('⏭️  Skipping auto-configuration (--no-configure)');
         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 { }
-                }
-                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)`);
-            }
-        }
-        catch (e) {
-            console.log(`⚠️  Could not auto-configure Claude Desktop: ${e.message}`);
+    const envFile = path.join(process.cwd(), '.env');
+    const lemmaConfig = `\n# Lemma AI Gateway Configuration\nOPENAI_BASE_URL=http://localhost:8081/v1\nLEMMA_PROJECT=${project}\n`;
+    if (fs.existsSync(envFile)) {
+        const content = fs.readFileSync(envFile, 'utf8');
+        if (!content.includes('OPENAI_BASE_URL')) {
+            fs.appendFileSync(envFile, lemmaConfig);
         }
     }
-    else {
-        console.log(`⏭️  [Claude Desktop] Skip auto-configuration.`);
+    const mcpDir = path.join(process.cwd(), '.lemma', 'mcp');
+    if (!fs.existsSync(mcpDir)) {
+        fs.mkdirSync(mcpDir, { recursive: true });
     }
-    // 2. Shell Profiles Environment Override
-    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 (e) {
-            console.log(`⚠️  Could not auto-configure shell profiles: ${e.message}`);
-        }
+    console.log(`✅ Auto-configured Lemma for [${project}]`);
+}
+const EVENT_LOG = [];
+const MAX_EVENTS = 100;
+// MCP Status tracking
+const MCP_STATUS = {
+    lastActivity: Date.now(),
+    toolCallCount: 0,
+    status: 'idle'
+};
+function logEvent(event) {
+    const ev = { id: Math.random().toString(36).slice(2, 11), timestamp: Date.now(), ...event };
+    EVENT_LOG.push(ev);
+    if (EVENT_LOG.length > MAX_EVENTS)
+        EVENT_LOG.shift();
+    // Track MCP activity
+    if (event.type === 'mcp_tool_call') {
+        MCP_STATUS.lastActivity = Date.now();
+        MCP_STATUS.toolCallCount++;
+        MCP_STATUS.status = 'active';
     }
-    else {
-        console.log(`⏭️  [Shell Profile] Skip auto-configuration.`);
+    // Print a terminal savings summary every 10 events
+    if (EVENT_LOG.length > 0 && EVENT_LOG.length % 10 === 0) {
+        const snap = savingsLedger.getSnapshot();
+        if (snap.total.tokensSaved > 0) {
+            console.log('\n' + savingsLedger.getTerminalSummary() + '\n');
+        }
     }
-    // 3. Cursor, Windsurf & VS Code settings.json updates
-    if (runEditor) {
+}
+const LEMMA_RULES_BLOCK = `
+🧠 Lemma MCP — Autonomous Behaviors
+
+I have Lemma MCP tools connected. I MUST use them proactively:
+
+1. When starting work on a project, call \`get_project_onboarding\` or read \`lemma://project/context\` to understand the architecture.
+2. Before answering technical questions, call \`search_memory\` for relevant past solutions.
+3. When examining a file, call \`get_telepathic_hints\` for relevant context.
+4. After solving a problem, call \`store_memory\` to persist the solution for future sessions.
+5. Use \`read_workspace_file\`, \`list_workspace_dir\`, \`search_workspace\` instead of asking the user to read or navigate files.
+6. Always call \`validate_patch_sandbox\` before writing patches.
+7. Read \`lemma://runtime/context\` first when the user reports a bug.
+`;
+function injectIdeRules(projectName) {
+    const content = `\n# ${projectName} — ${LEMMA_RULES_BLOCK.trim()}\n`;
+    const rulesTargets = [
+        { name: 'Cursor', path: path.join(process.cwd(), '.cursorrules') },
+        { name: 'Cursor (v2)', path: path.join(process.cwd(), '.cursor/rules/lemma.mdc') },
+        { name: 'Windsurf', path: path.join(process.cwd(), '.windsurfrules') },
+        { name: 'Cline', path: path.join(process.cwd(), '.clinerules') },
+    ];
+    for (const target of rulesTargets) {
         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')
-                });
-                candidates.push({
-                    name: 'VS Code',
-                    path: path.join(HOME, 'Library/Application Support/Code/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')
-                });
-                candidates.push({
-                    name: 'VS Code',
-                    path: path.join(appData, 'Code/User/settings.json')
-                });
+            const dir = path.dirname(target.path);
+            if (target.name === 'Cursor (v2)') {
+                if (!fs.existsSync(dir))
+                    fs.mkdirSync(dir, { recursive: true });
             }
-            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')
-                });
-                candidates.push({
-                    name: 'VS Code',
-                    path: path.join(HOME, '.config/Code/User/settings.json')
-                });
+            else if (!fs.existsSync(dir)) {
+                continue;
             }
-            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 { }
-                    }
-                    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 (fs.existsSync(target.path)) {
+                const existing = fs.readFileSync(target.path, 'utf8');
+                if (existing.includes('Lemma MCP'))
+                    continue;
             }
+            fs.writeFileSync(target.path, content, { flag: 'a' });
+            console.log(`✅ [${target.name}] Injected Lemma rules: ${target.path}`);
         }
-        catch (e) {
-            console.log(`⚠️  Could not auto-configure editor settings: ${e.message}`);
+        catch {
+            console.log(`⚠️  Could not inject rules for ${target.name}`);
         }
     }
-    else {
-        console.log(`⏭️  [Editor Settings] Skip auto-configuration.`);
-    }
 }
 export function startBackgroundClipboardWatcher(cliOpts) {
     // Load configuration if it exists
@@ -950,6 +755,8 @@ class LemmaServer {
         this.sessions = new Map();
         this.timeline = [];
         this.lastFileContents = new Map();
+        this.registry = new ProjectRegistry();
+        this.projectSessions = new Map();
         this.port = port;
         this.projectName = projectName || detectProject();
         this.projectDir = ensureProjectDir(this.projectName);
@@ -995,6 +802,18 @@ class LemmaServer {
                 uptime: Math.floor(process.uptime())
             });
         });
+        // Project registration from MCP handshake
+        this.app.post('/api/handshake', (req, res) => {
+            const { projectPath, projectName, stack } = req.body;
+            if (projectPath && projectName) {
+                this.registry.register(projectPath, projectName, stack || '');
+                console.log(`📋 [Handshake] Project registered: "${projectName}" (${projectPath})`);
+                res.json({ ok: true });
+            }
+            else {
+                res.status(400).json({ error: 'projectPath and projectName required' });
+            }
+        });
         this.app.get('/v1/models', (req, res) => {
             res.json({ object: 'list', data: [
                     { id: 'gpt-4o', object: 'model', owned_by: 'lemma-proxy' },
@@ -1263,7 +1082,7 @@ class LemmaServer {
                             totalTokensSaved: 0,
                             providers: {}
                         };
-                        writeJson(STATS_FILE, this.stats).catch(() => { });
+                        writeJson(STATS_FILE, this.stats);
                     }
                     // Clear Chroma DB collection
                     try {
@@ -1487,7 +1306,7 @@ class LemmaServer {
                         s.providers['mcp'] = { hits: 0, misses: 0 };
                     source === 'cache' ? s.providers['mcp'].hits++ : s.providers['mcp'].misses++;
                     // Write updated stats back to disk immediately
-                    writeJson(STATS_FILE, this.stats).catch(() => { });
+                    writeJson(STATS_FILE, this.stats);
                     // Push to live telemetry logEvent array so the Dashboard event timeline updates instantly!
                     logEvent({
                         type: source === 'cache' ? 'cache:hit' : source,
@@ -1628,6 +1447,15 @@ class LemmaServer {
         }
         console.log(`🌌 \x1b[35m[Multiverse]\x1b[0m Captured micro-snapshot ${snapshot.id} (${changedFiles.length} file edits mapped).`);
     }
+    detectActiveProject(req) {
+        const mcpActive = this.registry.getActive();
+        if (mcpActive)
+            return mcpActive;
+        const sniffed = sniffProjectFromMessages(req.body.messages || [], this.registry);
+        if (sniffed)
+            return sniffed;
+        return null;
+    }
     async handleCompletion(req, res, provider) {
         const t0 = Date.now();
         const pro = await isPro();
@@ -1748,6 +1576,24 @@ Adjusted Answer:`;
                 return res.json(unmaskedData);
             }
         }
+        // ── 3. Context Injection (for cache misses) ──
+        const activeProject = this.detectActiveProject(req);
+        if (activeProject) {
+            const psKey = activeProject.path;
+            if (!this.projectSessions.has(psKey)) {
+                this.projectSessions.set(psKey, { alreadyInjected: false });
+            }
+            const session = this.projectSessions.get(psKey);
+            const injectionLevel = shouldInject(activeProject, req.body.messages, session);
+            if (injectionLevel !== 'none') {
+                const context = injectionLevel === 'deep'
+                    ? await buildDeepContext(activeProject, this.port)
+                    : buildMinimalContext(activeProject);
+                req.body.messages.unshift({ role: 'system', content: context });
+                session.alreadyInjected = true;
+                console.log(`🧠 [Context] Injected ${injectionLevel} context for "${activeProject.name}"`);
+            }
+        }
         // ── 2. Cache Miss Path ──
         const routingDecision = complexityRouter.evaluate(prompt, originalModel);
         const model = routingDecision.model;
@@ -1988,9 +1834,46 @@ Adjusted Answer:`;
     }
 }
 // ── CLI ────────────────────────────────────────────────────────────────────────
-program.name('lemma').description('Lemma Proxy CLI — Intelligent AI Gateway').version(VERSION);
+function showWelcomeScreen() {
+    console.log(`
+\x1b[1m\x1b[35m   _                         \x1b[0m
+\x1b[1m\x1b[35m  | |    ___ _ __ ___   __ _ \x1b[0m  \x1b[1mLEMMA\x1b[0m  \x1b[35mv${VERSION}\x1b[0m
+\x1b[1m\x1b[35m  | |   / _ \\ '_ \` _ \\ / _\` |\x1b[0m
+\x1b[1m\x1b[35m  | |__|  __/ | | | | | (_| |\x1b[0m  Intelligent AI Gateway
+\x1b[1m\x1b[35m  |_____\\___|_| |_| |_|\\__,_|\x1b[0m
+
+\x1b[1mQuick Start\x1b[0m
+  \x1b[33mlemma init\x1b[0m          Initialize Lemma in this project
+  \x1b[33mlemma start\x1b[0m         Start the proxy server
+  \x1b[33mlemma mcp\x1b[0m           Start MCP Server for Cursor/Claude
+
+\x1b[1mFree Features\x1b[0m (all included)
+  🔒  Privacy Firewall       💾  Exact-match Cache
+  🔀  Complexity Router      📡  Telepathic Clipboard
+  📊  Basic Usage Stats      🧠  MCP Tools & Resources
+
+\x1b[1mPro Features\x1b[0m (\x1b[35mlemma activate <key>\x1b[0m  or  \x1b[36mhttps://lemma.nxus.studio/upgrade\x1b[0m)
+  🎯  Semantic Vector Cache  🌐  Hive Mind Cloud Sync
+  🛸  Autopilot Healer       🩺  Auto-Diagnose & Heal
+  🌌  Codebase Multiverse    🏗️  Architecture Onboarding
+
+\x1b[90mRun \`lemma --help\` for all commands.\x1b[0m
+`);
+}
+program
+    .name('lemma')
+    .description('Intelligent AI Gateway — cache, route, and optimize AI requests')
+    .version(VERSION)
+    .addHelpText('after', `
+\x1b[1mPlan Comparison\x1b[0m
+  \x1b[32mFree\x1b[0m    500 req/mo · Exact cache · Privacy firewall · MCP tools
+  \x1b[35mPro\x1b[0m     Unlimited  · Semantic cache · Cloud sync · Autopilot · Heal
+         \x1b[36mhttps://lemma.nxus.studio/upgrade\x1b[0m
+
+\x1b[90mActivate Pro: lemma activate <key>\x1b[0m
+`);
 program.command('mcp')
-    .description('Start the Lemma MCP Server (Model Context Protocol)')
+    .description('Start the MCP Server for Cursor / Claude Desktop integration')
     .action(() => {
     const { spawn } = require('child_process');
     // Robust search candidates for both development (TS source) and compiled (JS production) environments.
@@ -2045,6 +1928,7 @@ program.command('start')
             // Keep configurations up to date even if server was already started
             const runningProject = resp.data.project || detectProject();
             autoConfigureAll(runningProject, { configure: opts.configure });
+            injectIdeRules(runningProject);
             startBackgroundClipboardWatcher({ clipboard: opts.clipboard });
             process.exit(0);
         }
@@ -2052,6 +1936,7 @@ program.command('start')
     catch { }
     const startProject = opts.project || detectProject();
     autoConfigureAll(startProject, { configure: opts.configure });
+    injectIdeRules(startProject);
     startBackgroundClipboardWatcher({ clipboard: opts.clipboard });
     // Automatically enable autopilot if stack is enabled and user is Pro
     const runAutopilot = opts.autopilot || opts.stack;
@@ -2264,8 +2149,12 @@ program.command('init')
     }
     console.log('\n🧠 \x1b[35mAuto-Setup MCP and redirection overrides for AI IDEs...\x1b[0m');
     autoConfigureAll(project, { configure: opts.configure });
-    console.log('\n✨ Project initialized for the Agentic Era!');
-    console.log('🚀 Run "lemma start" to begin.\n');
+    injectIdeRules(project);
+    console.log('\n✨ Project initialized for the Agentic Era!\n');
+    console.log('\x1b[1mNext steps:\x1b[0m');
+    console.log('  \x1b[33mlemma start\x1b[0m     Start the proxy & unlock AI savings');
+    console.log('  \x1b[33mlemma upgrade\x1b[0m   See Pro features & get a key');
+    console.log('  \x1b[33mlemma --help\x1b[0m    All available commands\n');
 });
 // ── Auto-Healing Diagnostics (Zero-Cost Suite) ───────────────────────────────
 export async function performAutoHeal(apply) {
@@ -2435,7 +2324,7 @@ Ensure you return strictly JSON. Do not return any other text outside the JSON b
     }
 }
 program.command('heal')
-    .description('Diagnose and auto-heal the latest local server crash from .lemma/live-context.md')
+    .description('[Pro] Diagnose and auto-heal the latest local server crash from .lemma/live-context.md')
     .option('--apply', 'Apply the auto-generated code fix automatically', false)
     .action(async (opts) => {
     try {
@@ -2464,7 +2353,7 @@ program.command('heal')
     }
 });
 program.command('autopilot')
-    .description('Start the autonomous background compiler watcher & active healer')
+    .description('[Pro] Start the autonomous background compiler watcher & active healer')
     .option('--dir <directory>', 'Directory to monitor for changes', 'src')
     .action(async (opts) => {
     try {
@@ -2489,6 +2378,26 @@ program.command('autopilot')
         process.exit(1);
     }
 });
+program.command('upgrade')
+    .description('Learn about Pro features and get an activation key')
+    .action(() => {
+    console.log(`
+\x1b[1m\x1b[35mLemma Pro\x1b[0m — Unlimited AI Gateway power
+
+\x1b[1mPro features:\x1b[0m
+  🎯  \x1b[1mSemantic Vector Cache\x1b[0m   — Smarter cache hits via vector similarity
+  🌐  \x1b[1mHive Mind Cloud Sync\x1b[0m    — Cross-project cache & bug telepathy
+  🛸  \x1b[1mAutopilot Healer\x1b[0m        — Autonomous background compiler watcher
+  🩺  \x1b[1mAuto-Diagnose & Heal\x1b[0m    — AI-driven crash analysis & patch
+  🌌  \x1b[1mCodebase Multiverse\x1b[0m     — AST time-travel & snapshots
+  🏗️  \x1b[1mArchitecture Onboarding\x1b[0m — Zero-shot project understanding
+  🔓  \x1b[1mUnlimited requests\x1b[0m       — No monthly caps
+
+\x1b[36m  https://lemma.nxus.studio/upgrade\x1b[0m
+
+Already have a key? Run:  \x1b[33mlemma activate <key>\x1b[0m
+`);
+});
 program.command('clipboard')
     .description('Start the Lemma Local Clipboard Telepathic Optimizer (auto-squeezes copied code blocks)')
     .option('--interval <ms>', 'Polling interval in milliseconds', '1000')
@@ -2506,6 +2415,11 @@ program.command('clipboard')
     }
 });
 if (process.argv[1] && (process.argv[1].includes('lemma') || process.argv[1].endsWith('.cjs') || process.argv[1].endsWith('.js'))) {
+    // Bare `lemma` with no args → show welcome screen
+    if (process.argv.length <= 2) {
+        showWelcomeScreen();
+        process.exit(0);
+    }
     program.parse(process.argv);
 }
 //# sourceMappingURL=lemma-proxy.js.map