@nxuss/lemma 0.5.8 → 0.6.0

package/README.md

@@ -1,4 +1,4 @@
-# 🧠 Lemma v0.5.3
+# 🧠 Lemma v0.6.0
 
 [![npm version](https://img.shields.io/npm/v/@nxuss/lemma.svg?color=orange&style=flat-square)](https://www.npmjs.com/package/@nxuss/lemma)
 [![License](https://img.shields.io/npm/l/@nxuss/lemma.svg?color=blue&style=flat-square)](https://github.com/Nxusbets/lemma/blob/main/LICENSE)
@@ -25,8 +25,20 @@ Lemma is a high-performance orchestration layer that sits between your developme
 ### 🖥️ Real-Time Telemetry & Time-Travel Dashboard
 **Full Observability & Interactive Debugging.** Spin up a gorgeous React-based dashboard at `http://localhost:8081/dashboard/` to monitor your entire AI workflow. View real-time charts of cost savings, token compactions, and cache hits. Walk through complex multi-agent conversations step-by-step using a time-travel slider, select and inspect active agent states, and export detailed telemetry audits instantly.
 
-### ✂️ Codebase Context Squeezer & Incremental Diff Engine
-**Massive Speedups & Zero Token Waste.** Get instant model responses and make your context windows go up to 10x further. Lemma dynamically optimizes outgoing codebase payloads to prevent redundant data from cluttering your chat, letting you enjoy incredibly long chat histories and ultra-fast generation speeds in Cursor, VS Code, and other IDEs without changing your workflow. Save up to 95% on token consumption automatically.
+### 🛸 Kiro/Cursor Composer Bypass (Pro Option) 💎
+**Autonomous Multi-File Editing For Free.** Exposes `write_workspace_file`, smart `apply_workspace_patch` (smart search-and-replace patching), and sandbox terminal tool `run_workspace_command` (compile/lint check) to Cursor's standard chat or Claude Desktop via MCP. Any standard free chat instantly acts as a fully-featured, unlimited autonomous multi-file Composer without needing a premium Kiro/Cursor Pro subscription.
+
+### 🌌 AST Time-Travel Telemetry: El Multiverso de Código (Pro Option) 💎
+**Regressive Error Debugging & Time-Travel.** Spawns a background recursive file watcher that debounces filesystem edits and calculates incremental AST diffs on every save. Merges active compiler crash logs to package a chronologically ordered time-traveling timeline resource (`lemma://multiverse/timeline`) so your LLM agents can inspect past codebase states and regressions instantly when you say "It broke".
+
+### 🗺️ Zero-Shot Project Onboarding (Pro Option) 💎
+**One-Shot Architecture Map.** Exposes a dynamic onboard resource (`lemma://project/onboarding`) that scans package files, folders, and key directory markers to compile a beautiful, structured markdown guide of your codebase's stack, directory layouts, and design principles so the LLM gets fully onboarded in a single shot.
+
+### 🧠 Cross-Project Bug Telepathy (Pro Option) 💎
+**Global Developer Hive Mind.** Lemma dynamically scans and queries vector memory indexes of all other local projects on your computer. If you solved a compiler issue or technical blocker in a different workspace last week, Lemma will telepathically inject that high-confidence solution to the current project's chat without you typing a single word.
+
+### ✂️ Codebase Context Squeezer & Log Collapsing
+**Massive Speedups & Zero Token Waste.** Get instant model responses and make your context windows go up to 10x further. Lemma dynamically squeezes outgoing codebase payloads, strips comments/whitespaces, and collapses repetitive console logs or redundant compiler stack traces, saving up to 95% on token consumption automatically.
 
 ### 🛸 Local Cache-Augmented Response Synthesis (CARS)
 **Zero-Cost Answer Synthesis.** Experience instantaneous responses for questions similar to what you've asked before—without hitting the cloud or spending a single penny on API tokens. Lemma automatically refines past knowledge to answer your current questions in under a second, keeping your work completely private and free of charge.
@@ -141,8 +153,10 @@ Create or edit `lemma.config.json` in your project root to disable or fine-tune
 | **Privacy Firewall** | ✅ Included | ✅ Advanced Masking |
 | **Complexity Router** | ✅ Included | ✅ Custom Routing Policies |
 | **Caching** | Exact Match | **Semantic Memory** |
-| **Hive Mind** | Local Only | **Cloud Sync (Team Memory)** |
-| **Telepathy** | Basic Sync | **Advanced State Injection** |
+| **Hive Mind** | Local Only | **Cloud Sync (Team Memory) + Cross-Project Telepathy 💎** |
+| **AST Time-Travel Telemetry** | ❌ None | **Codebase Multiverse (Cap 10 AST Snapshots) 💎** |
+| **Kiro/Cursor Composer Bypass** | ❌ None | **Smart Patches & Sandbox Terminal MCP 💎** |
+| **Zero-Shot Onboarding Guide** | ❌ None | **Codebase Architecture Map MCP 💎** |
 | **Telemetry Dashboard** | Basic Stats | **Time-Travel Debugger & 60fps Graph** |
 | **Limits** | 300 requests/mo | **Unlimited Agentic Power** |
 
@@ -160,7 +174,7 @@ You don't need to change your habits. Just point your tool's "Base URL" to Lemma
 *   **Custom Apps:** Replace `https://api.openai.com/v1` with `http://localhost:8081/v1` in your SDK initialization.
 
 ### 💎 Pro Integration (Model Context Protocol - MCP)
-For **Lemma Pro** users, you can expose Lemma's entire intelligence layer (Privacy Firewall, Semantic Brain Search, and Auto-Heal) directly as native tools using the **Model Context Protocol (MCP)**.
+For **Lemma Pro** users, you can expose Lemma's entire intelligence layer (Privacy Firewall, Semantic Brain Search, and Auto-Heal, plus the new Composer Bypass Suite, AST Timeline, and Zero-Shot Onboarding Map) directly as native tools using the **Model Context Protocol (MCP)**. This lets the LLM read, search, write, patch, and compile files in your workspace autonomously.
 
 #### 🟢 Cursor:
 1. Go to **Settings > Features > MCP**.

package/dist/cjs/cli/lemma-proxy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lemma-proxy.d.ts","sourceRoot":"","sources":["../../../src/cli/lemma-proxy.ts"],"names":[],"mappings":";AA8NA,wBAAgB,gBAAgB,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAkMnJ;AAED,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CA4DvF;AA2gDD,wBAAsB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA6KhL"}
+{"version":3,"file":"lemma-proxy.d.ts","sourceRoot":"","sources":["../../../src/cli/lemma-proxy.ts"],"names":[],"mappings":";AA8NA,wBAAgB,gBAAgB,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAkMnJ;AAED,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CA4DvF;AAm2DD,wBAAsB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA6KhL"}

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

@@ -162,9 +162,9 @@ async function ensureChromaRunning() {
     }
     console.log(`\n📦 \x1b[35m[ChromaDB]\x1b[0m ChromaDB is not running on port ${chromaPort}.`);
     console.log(`🔄 Starting ChromaDB in background...`);
+    const chromaDataPath = path_1.default.join(CACHE_DIR, 'chroma_data');
     try {
         const { spawn } = require('child_process');
-        const chromaDataPath = path_1.default.join(process.cwd(), 'chroma_data');
         if (!fs_1.default.existsSync(chromaDataPath)) {
             fs_1.default.mkdirSync(chromaDataPath, { recursive: true });
         }
@@ -187,7 +187,7 @@ async function ensureChromaRunning() {
     }
     catch (err) {
         console.error(`❌ Failed to automatically start ChromaDB: ${err.message}`);
-        console.error(`👉 Please start it manually: chroma run --path ./chroma_data --port ${chromaPort}`);
+        console.error(`👉 Please start it manually: chroma run --path ${chromaDataPath} --port ${chromaPort}`);
         return false;
     }
 }
@@ -608,15 +608,16 @@ async function getEmbedding(text) {
         return null;
     }
 }
-async function semanticGet(provider, prompt) {
+async function semanticGet(provider, prompt, projectName = 'global') {
     if (!await isPro())
         return null;
     const emb = await getEmbedding(prompt);
     if (!emb)
         return null;
+    let localHit = null;
     try {
         const collection = await chroma.getOrCreateCollection({
-            name: 'lemma-cache',
+            name: `lemma-cache-${projectName}`,
             embeddingFunction: dummyEmbeddingFunction,
             metadata: { "hnsw:space": "cosine" }
         });
@@ -624,33 +625,83 @@ async function semanticGet(provider, prompt) {
             queryEmbeddings: [emb],
             nResults: 10
         });
-        if (!res.ids[0] || res.ids[0].length === 0)
-            return null;
-        for (let i = 0; i < res.ids[0].length; i++) {
-            const metadata = res.metadatas[0][i];
-            if (metadata.provider !== provider)
-                continue;
-            const distances = res.distances;
-            let distance = 1.0;
-            if (distances && distances[0] && typeof distances[0][i] === 'number') {
-                distance = distances[0][i];
-            }
-            const similarity = Math.max(0, 1 - distance);
-            const THRESHOLD = 0.82; // raised from 0.7 to 0.82 to prevent false positives
-            if (similarity >= THRESHOLD) {
-                return {
-                    data: JSON.parse(metadata.response),
-                    similarity,
-                    id: res.ids[0][i],
-                    prompt: metadata.prompt
-                };
+        if (res.ids[0] && res.ids[0].length > 0) {
+            for (let i = 0; i < res.ids[0].length; i++) {
+                const metadata = res.metadatas[0][i];
+                if (metadata.provider !== provider)
+                    continue;
+                const distances = res.distances;
+                let distance = 1.0;
+                if (distances && distances[0] && typeof distances[0][i] === 'number') {
+                    distance = distances[0][i];
+                }
+                const similarity = Math.max(0, 1 - distance);
+                const THRESHOLD = 0.82; // raised from 0.7 to 0.82 to prevent false positives
+                if (similarity >= THRESHOLD) {
+                    localHit = {
+                        data: JSON.parse(metadata.response),
+                        similarity,
+                        id: res.ids[0][i],
+                        prompt: metadata.prompt,
+                        hiveMind: false
+                    };
+                    break;
+                }
             }
         }
     }
     catch (e) { }
+    if (localHit)
+        return localHit;
+    // ─── Cross-Project Bug Telepathy Fallback ───
+    try {
+        const collections = await chroma.listCollections();
+        const projectCollections = collections.filter((c) => c.name.startsWith('lemma-cache-') && c.name !== `lemma-cache-${projectName}`);
+        for (const colInfo of projectCollections) {
+            try {
+                const col = await chroma.getOrCreateCollection({
+                    name: colInfo.name,
+                    embeddingFunction: dummyEmbeddingFunction,
+                    metadata: { "hnsw:space": "cosine" }
+                });
+                const otherRes = await col.query({
+                    queryEmbeddings: [emb],
+                    nResults: 3
+                });
+                if (otherRes.ids[0] && otherRes.ids[0].length > 0) {
+                    for (let i = 0; i < otherRes.ids[0].length; i++) {
+                        const metadata = otherRes.metadatas[0][i];
+                        if (metadata.provider !== provider)
+                            continue;
+                        const distances = otherRes.distances;
+                        let distance = 1.0;
+                        if (distances && distances[0] && typeof distances[0][i] === 'number') {
+                            distance = distances[0][i];
+                        }
+                        const similarity = Math.max(0, 1 - distance);
+                        const HIVE_THRESHOLD = 0.90; // Higher threshold to avoid false positives across different domains
+                        if (similarity >= HIVE_THRESHOLD) {
+                            const originProject = colInfo.name.replace('lemma-cache-', '');
+                            console.log(`\n🎯 \x1b[32m[Hive Mind Telepathy]\x1b[0m Found a high-confidence solution (Similarity: ${(similarity * 100).toFixed(1)}%) in Project [\x1b[36m${originProject}\x1b[0m]! Reusing solution telepathically.\n`);
+                            return {
+                                data: JSON.parse(metadata.response),
+                                similarity,
+                                id: otherRes.ids[0][i],
+                                prompt: metadata.prompt,
+                                hiveMind: true,
+                                originProject
+                            };
+                        }
+                    }
+                }
+            }
+            catch { }
+        }
+    }
+    catch { }
     return null;
 }
-async function semanticSet(provider, prompt, data) {
+async function semanticSet(provider, prompt, data, projectName = 'global') {
     if (!await isPro())
         return;
     const emb = await getEmbedding(prompt);
@@ -658,7 +709,7 @@ async function semanticSet(provider, prompt, data) {
         return;
     try {
         const collection = await chroma.getOrCreateCollection({
-            name: 'lemma-cache',
+            name: `lemma-cache-${projectName}`,
             embeddingFunction: dummyEmbeddingFunction,
             metadata: { "hnsw:space": "cosine" }
         });
@@ -750,7 +801,7 @@ function setSseHeaders(res, fromCache, similarity, tier) {
     res.setHeader('Cache-Control', 'no-cache');
     res.setHeader('Connection', 'keep-alive');
     res.setHeader('X-Accel-Buffering', 'no');
-    res.setHeader('X-Lemma-Cache', fromCache ? 'HIT' : 'MISS');
+    res.setHeader('X-Lemma-Cache', typeof fromCache === 'string' ? fromCache : (fromCache ? 'HIT' : 'MISS'));
     res.setHeader('X-Lemma-Similarity', (similarity || 1.0).toFixed(3));
     res.setHeader('X-Lemma-Tier', tier);
 }
@@ -766,8 +817,8 @@ function buildAntChunk(text, stop) {
 function buildGemChunk(text, stop) {
     return { candidates: [{ content: { parts: [{ text }] }, finishReason: stop ? 'STOP' : undefined }] };
 }
-async function simulateHitStream(res, cachedData, provider, model, tier, similarity) {
-    setSseHeaders(res, true, similarity, tier);
+async function simulateHitStream(res, cachedData, provider, model, tier, similarity, cacheHeader = 'HIT') {
+    setSseHeaders(res, cacheHeader, similarity, tier);
     const id = `lemma-${Date.now()}`;
     let text = '';
     try {
@@ -884,6 +935,8 @@ class LemmaServer {
         this.stats = {};
         this.dashboardPath = '';
         this.sessions = new Map();
+        this.timeline = [];
+        this.lastFileContents = new Map();
         this.port = port;
         this.projectName = projectName || detectProject();
         this.projectDir = ensureProjectDir(this.projectName);
@@ -891,6 +944,7 @@ class LemmaServer {
         this.app = (0, express_1.default)();
         this.setupMiddleware();
         this.setupRoutes();
+        this.startWorkspaceTimeWatcher();
     }
     setupMiddleware() {
         this.app.use(express_1.default.json({ limit: '10mb' }));
@@ -1046,7 +1100,7 @@ class LemmaServer {
                 // Try to query ChromaDB for semantic cache count
                 try {
                     const collection = await chroma.getOrCreateCollection({
-                        name: 'lemma-cache',
+                        name: `lemma-cache-${this.projectName}`,
                         embeddingFunction: dummyEmbeddingFunction,
                         metadata: { "hnsw:space": "cosine" }
                     });
@@ -1103,7 +1157,7 @@ class LemmaServer {
                     if (!emb)
                         throw new Error('Failed to generate embedding');
                     const collection = await chroma.getOrCreateCollection({
-                        name: 'lemma-cache',
+                        name: `lemma-cache-${this.projectName}`,
                         embeddingFunction: dummyEmbeddingFunction,
                         metadata: { "hnsw:space": "cosine" }
                     });
@@ -1152,7 +1206,7 @@ class LemmaServer {
                     }
                     // Clear Chroma DB collection
                     try {
-                        await chroma.deleteCollection({ name: 'lemma-cache' }).catch(() => { });
+                        await chroma.deleteCollection({ name: `lemma-cache-${this.projectName}` }).catch(() => { });
                     }
                     catch (e) {
                         console.error(`[CacheClear] Failed to clear Chroma collection: ${e.message}`);
@@ -1169,7 +1223,7 @@ class LemmaServer {
                     // Selective delete from Chroma DB collection using provider metadata filter
                     try {
                         const collection = await chroma.getOrCreateCollection({
-                            name: 'lemma-cache',
+                            name: `lemma-cache-${this.projectName}`,
                             embeddingFunction: dummyEmbeddingFunction,
                             metadata: { "hnsw:space": "cosine" }
                         });
@@ -1185,6 +1239,117 @@ class LemmaServer {
             this.app.get('/api/savings-breakdown', (req, res) => {
                 res.json(SavingsLedger_1.savingsLedger.getSnapshot());
             });
+            // Serve codebase timeline snapshots (AST Time-Travel Telemetry)
+            this.app.get('/api/project/timeline', (req, res) => {
+                res.json({ success: true, timeline: this.timeline });
+            });
+            // Dynamic Zero-Shot Onboarding mental model builder
+            this.app.get('/api/project/onboarding', async (req, res) => {
+                try {
+                    const cwd = process.cwd();
+                    // 1. Parse package.json
+                    let pkg = {};
+                    const pkgPath = path_1.default.join(cwd, 'package.json');
+                    if (fs_1.default.existsSync(pkgPath)) {
+                        try {
+                            pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf8'));
+                        }
+                        catch { }
+                    }
+                    // 2. Identify stack & tools
+                    const techStack = [];
+                    const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+                    if (deps['next'])
+                        techStack.push('Next.js (React Web App Framework)');
+                    else if (deps['react'])
+                        techStack.push('React.js (Frontend library)');
+                    if (deps['typescript'])
+                        techStack.push('TypeScript (Strict static type safety)');
+                    if (deps['prisma'])
+                        techStack.push('Prisma (Object-Relational Mapping)');
+                    if (deps['tailwindcss'])
+                        techStack.push('TailwindCSS (Utility-first styling)');
+                    if (deps['express'])
+                        techStack.push('Express (NodeJS REST API framework)');
+                    if (deps['jest'])
+                        techStack.push('Jest (Automated Unit Testing framework)');
+                    if (fs_1.default.existsSync(path_1.default.join(cwd, 'Dockerfile')) || fs_1.default.existsSync(path_1.default.join(cwd, 'docker-compose.yml'))) {
+                        techStack.push('Docker / Containerization');
+                    }
+                    if (techStack.length === 0) {
+                        techStack.push('Vanilla Node.js / Web stack');
+                    }
+                    // 3. Scan directory structure
+                    let files = [];
+                    try {
+                        files = fs_1.default.readdirSync(cwd).filter(f => !['node_modules', '.git', 'dist', 'chroma_data', '.lemma'].includes(f));
+                    }
+                    catch { }
+                    // 4. Query core architecture notes from ChromaDB
+                    let archMemoriesText = '';
+                    try {
+                        const emb = await getEmbedding("architectural design guidelines and core stack configuration decisions");
+                        if (emb) {
+                            const collection = await chroma.getOrCreateCollection({
+                                name: `lemma-cache-${this.projectName}`,
+                                embeddingFunction: dummyEmbeddingFunction,
+                                metadata: { "hnsw:space": "cosine" }
+                            });
+                            const searchRes = await collection.query({
+                                queryEmbeddings: [emb],
+                                nResults: 3
+                            });
+                            if (searchRes.ids[0] && searchRes.ids[0].length > 0) {
+                                archMemoriesText = '### 🧠 Stored Architectural Brain Memories\n';
+                                searchRes.ids[0].forEach((id, idx) => {
+                                    const meta = (searchRes.metadatas && searchRes.metadatas[0]) ? searchRes.metadatas[0][idx] : null;
+                                    if (meta && typeof meta.response === 'string') {
+                                        try {
+                                            const responseObj = JSON.parse(meta.response);
+                                            const contentText = responseObj.choices?.[0]?.message?.content || responseObj.content?.[0]?.text || '';
+                                            const promptText = typeof meta.prompt === 'string' ? meta.prompt : 'Architecture Note';
+                                            archMemoriesText += `#### 📌 Decisión: ${promptText}\n${contentText.substring(0, 500)}${contentText.length > 500 ? '...' : ''}\n\n`;
+                                        }
+                                        catch { }
+                                    }
+                                });
+                            }
+                        }
+                    }
+                    catch (e) {
+                        // Silently swallow vector db query errors
+                    }
+                    // 5. Construct gorgeous onboarding markdown guide
+                    const mentalModel = [
+                        `# 🧠 Codebase Onboarding & Mental Model: ${this.projectName}`,
+                        `This onboarding document was automatically generated by Lemma's Project Brain to align your context in a single shot.`,
+                        `\n## 🔌 Project Specifications`,
+                        `- **Name:** \`${pkg.name || this.projectName}\``,
+                        `- **Version:** \`${pkg.version || '0.1.0'}\``,
+                        `- **Description:** ${pkg.description || 'No description available in package.json.'}`,
+                        `\n## 🛠️ Detected Technical Stack`,
+                        techStack.map(s => `- **${s}**`).join('\n'),
+                        `\n## 📂 Directory Structure (Root)`,
+                        files.map(f => {
+                            const isDir = fs_1.default.statSync(path_1.default.join(cwd, f)).isDirectory();
+                            return `- \`${f}${isDir ? '/' : ''}\``;
+                        }).join('\n'),
+                        pkg.scripts && Object.keys(pkg.scripts).length > 0
+                            ? `\n## 📋 Standard Project Scripts\n${Object.entries(pkg.scripts).map(([name, cmd]) => `- \`npm run ${name}\`: \`${cmd}\``).join('\n')}`
+                            : '',
+                        `\n${archMemoriesText}`,
+                        `## 💡 AI Coding Guidelines for this Project`,
+                        `1. **Respect Core Stack:** Adhere strictly to the codebase structure and libraries listed above.`,
+                        `2. **Leverage the Brain:** Use Lemma MCP tools (\`search_memory\` and \`store_memory\`) to retrieve past solutions and register key architectural changes.`,
+                        `3. **Optimize Context:** Keep conversations focused. Lemma transparently compresses repetitive logs and file blocks to protect context window limits.`,
+                        `4. **Cortafuegos Local:** Do not worry about API key exposures. Lemma automatically masks local private variables and credentials.`
+                    ].filter(Boolean).join('\n');
+                    res.json({ success: true, markdown: mentalModel });
+                }
+                catch (err) {
+                    res.status(500).json({ success: false, error: err.message });
+                }
+            });
             // Explicit memory storage endpoint (store_memory)
             this.app.post('/api/memory/store', async (req, res) => {
                 const { query, response, provider = 'generic' } = req.body || {};
@@ -1197,7 +1362,7 @@ class LemmaServer {
                         return res.status(500).json({ error: 'Failed to generate embedding' });
                     }
                     const collection = await chroma.getOrCreateCollection({
-                        name: 'lemma-cache',
+                        name: `lemma-cache-${this.projectName}`,
                         embeddingFunction: dummyEmbeddingFunction,
                         metadata: { "hnsw:space": "cosine" }
                     });
@@ -1233,17 +1398,148 @@ class LemmaServer {
                 if (!source || !validSources.includes(source)) {
                     return res.status(400).json({ error: 'Invalid source' });
                 }
+                let tk = 0;
                 if (typeof tokens === 'number' && tokens > 0) {
+                    tk = tokens;
                     SavingsLedger_1.savingsLedger.recordTokens(source, tokens);
                 }
                 else if (typeof charsBefore === 'number' && typeof charsAfter === 'number') {
+                    tk = Math.floor(Math.max(0, charsBefore - charsAfter) / 4);
                     SavingsLedger_1.savingsLedger.record(source, charsBefore, charsAfter);
                 }
+                // Update active project stats to immediately reflect on Dashboard total requests & charts
+                if (tk > 0) {
+                    if (!this.stats[this.projectName]) {
+                        this.stats[this.projectName] = { total: 0, hits: 0, misses: 0, totalLatency: 0, totalTokensSaved: 0, providers: {} };
+                    }
+                    const s = this.stats[this.projectName];
+                    s.total++;
+                    s.totalTokensSaved += tk;
+                    s.totalLatency += 15; // mock latency for local MCP metrics
+                    if (source === 'cache') {
+                        s.hits++;
+                    }
+                    else {
+                        s.misses++;
+                    }
+                    if (!s.providers['mcp'])
+                        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(() => { });
+                    // Push to live telemetry logEvent array so the Dashboard event timeline updates instantly!
+                    logEvent({
+                        type: source === 'cache' ? 'cache:hit' : source,
+                        project: this.projectName,
+                        latency: 15,
+                        provider: 'mcp',
+                        tokens: tk
+                    });
+                }
                 res.json({ ok: true, snapshot: SavingsLedger_1.savingsLedger.getSnapshot().total });
             });
             this.app.get('/dashboard/*', (req, res) => res.sendFile(path_1.default.join(this.dashboardPath, 'index.html')));
         }
     }
+    startWorkspaceTimeWatcher() {
+        const cwd = process.cwd();
+        const { watch } = require('fs');
+        // Debounced capture function
+        let debounceTimer = null;
+        const pendingChanges = new Set();
+        const ignoreDirs = ['node_modules', '.git', 'dist', 'chroma_data', '.lemma', 'dashboard', 'bin', 'sdks'];
+        const watchDirRecursive = (dir) => {
+            try {
+                const watcher = watch(dir, (eventType, filename) => {
+                    if (!filename)
+                        return;
+                    const fullPath = path_1.default.join(dir, filename);
+                    // Heuristic to ignore generated/system folders
+                    const relPath = path_1.default.relative(cwd, fullPath);
+                    if (ignoreDirs.some(d => relPath.split(path_1.default.sep).includes(d)))
+                        return;
+                    // Ignore non-source files
+                    const ext = path_1.default.extname(filename);
+                    if (!['.ts', '.js', '.tsx', '.jsx', '.json', '.py', '.css'].includes(ext))
+                        return;
+                    pendingChanges.add(fullPath);
+                    if (debounceTimer)
+                        clearTimeout(debounceTimer);
+                    debounceTimer = setTimeout(() => this.captureSnapshot(pendingChanges), 1500);
+                });
+                // Prevent watcher from keeping process alive if in background
+                if (watcher.unref)
+                    watcher.unref();
+                // Recursively watch subfolders
+                const files = fs_1.default.readdirSync(dir, { withFileTypes: true });
+                for (const file of files) {
+                    if (file.isDirectory() && !ignoreDirs.includes(file.name)) {
+                        watchDirRecursive(path_1.default.join(dir, file.name));
+                    }
+                }
+            }
+            catch { }
+        };
+        watchDirRecursive(cwd); // Time travel watcher active!
+    }
+    async captureSnapshot(pendingChanges) {
+        const changes = Array.from(pendingChanges);
+        pendingChanges.clear();
+        const changedFiles = [];
+        for (const filePath of changes) {
+            if (!fs_1.default.existsSync(filePath))
+                continue;
+            try {
+                const content = fs_1.default.readFileSync(filePath, 'utf8');
+                const relPath = path_1.default.relative(process.cwd(), filePath);
+                const previousContent = this.lastFileContents.get(filePath) || '';
+                if (content === previousContent)
+                    continue;
+                let diff = '';
+                if (previousContent) {
+                    const { generateAstDiff } = require('../utils/ContextSqueezer');
+                    diff = generateAstDiff(previousContent, content);
+                }
+                this.lastFileContents.set(filePath, content);
+                changedFiles.push({
+                    filePath: relPath,
+                    content,
+                    diff
+                });
+            }
+            catch { }
+        }
+        if (changedFiles.length === 0)
+            return;
+        // Detect current compiler state/errors
+        let status = 'stable';
+        let errorLog = '';
+        // Check if there is a recent crash log in .lemma/live-context.md
+        try {
+            const liveContextPath = path_1.default.join(process.cwd(), '.lemma', 'live-context.md');
+            if (fs_1.default.existsSync(liveContextPath)) {
+                const content = fs_1.default.readFileSync(liveContextPath, 'utf8');
+                if (content.includes('crashed') || content.includes('error') || content.includes('Exception')) {
+                    status = 'failure';
+                    errorLog = content.substring(0, 1000);
+                }
+            }
+        }
+        catch { }
+        const snapshot = {
+            id: Math.random().toString(36).substring(2, 9),
+            timestamp: Date.now(),
+            changedFiles,
+            status,
+            errorLog
+        };
+        this.timeline.push(snapshot);
+        // Cap at 10 snapshots (FIFO eviction)
+        if (this.timeline.length > 10) {
+            this.timeline.shift();
+        }
+        console.log(`🌌 \x1b[35m[Multiverse]\x1b[0m Captured micro-snapshot ${snapshot.id} (${changedFiles.length} file edits mapped).`);
+    }
     async handleCompletion(req, res, provider) {
         const t0 = Date.now();
         const pro = await isPro();
@@ -1280,16 +1576,20 @@ class LemmaServer {
         }
         // Perform semantic cache check (resolves in ~15ms)
         if (pro) {
-            const semHit = await semanticGet(provider, prompt);
+            const semHit = await semanticGet(provider, prompt, this.projectName);
             if (semHit) {
                 if (semHit.similarity >= 0.90) {
                     await recordStat(this.stats, this.projectName, true, Date.now() - t0, provider, 2000);
                     const unmaskedData = semanticScrubber.unmask(semHit.data, tokenMap);
+                    const cacheHeader = semHit.hiveMind ? 'HIT-HIVE-MIND' : 'HIT';
                     if (isStream)
-                        return simulateHitStream(res, unmaskedData, provider, originalModel, tier, semHit.similarity);
-                    res.setHeader('X-Lemma-Cache', 'HIT');
+                        return simulateHitStream(res, unmaskedData, provider, originalModel, tier, semHit.similarity, cacheHeader);
+                    res.setHeader('X-Lemma-Cache', cacheHeader);
                     res.setHeader('X-Lemma-Similarity', semHit.similarity.toFixed(3));
                     res.setHeader('X-Lemma-Tier', tier);
+                    if (semHit.hiveMind && semHit.originProject) {
+                        res.setHeader('X-Lemma-Hive-Origin', semHit.originProject);
+                    }
                     return res.json(unmaskedData);
                 }
                 else if (semHit.similarity >= 0.82) { // raised from 0.70 to 0.82 to prevent false positives
@@ -1437,7 +1737,7 @@ Adjusted Answer:`;
             const data = await this.callUpstream(req.body, provider);
             cacheSet(provider, prompt, data);
             if (pro) {
-                await semanticSet(provider, prompt, data);
+                await semanticSet(provider, prompt, data, this.projectName);
                 await cloudSync.set(prompt, data);
             }
             if (!pro) {
@@ -1692,7 +1992,11 @@ commander_1.program.command('start')
     if (opts.stack) {
         const { spawn } = require('child_process');
         console.log('🚀 Launching Lemma Full Stack...');
-        const chromaProcess = spawn('chroma', ['run', '--path', './chroma_data'], { stdio: 'ignore', detached: true });
+        const chromaDataPath = path_1.default.join(CACHE_DIR, 'chroma_data');
+        if (!fs_1.default.existsSync(chromaDataPath)) {
+            fs_1.default.mkdirSync(chromaDataPath, { recursive: true });
+        }
+        const chromaProcess = spawn('chroma', ['run', '--path', chromaDataPath], { stdio: 'ignore', detached: true });
         chromaProcess.unref();
         console.log('   ✅ ChromaDB requested');
         const dash = spawn('npm', ['run', 'dev', '--prefix', 'dashboard', '--', '--port', '8082'], { stdio: 'ignore', detached: true });