@nxuss/lemma 1.36.0 → 1.38.0

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

@@ -46,12 +46,14 @@ import { Gatekeeper } from '../proxy/Gatekeeper.js';
 import { detectProjectName, isProjectMismatch } from '../utils/ProjectIdentity.js';
 import { ProjectRegistry } from '../proxy/ProjectRegistry.js';
 import { shouldInject, buildMinimalContext, buildDeepContext, sniffProjectFromMessages } from '../proxy/ContextInjector.js';
-import { savingsLedger } from '../utils/SavingsLedger.js';
+import { savingsLedger, AVG_COST_PER_TOKEN } from '../utils/SavingsLedger.js';
 import { isDebuggerPaused, setDebuggerPaused } from '../proxy/DebuggerState.js';
 import { CACHE_DIR, PID_FILE, PORT_FILE, STATS_FILE, USAGE_FILE, LICENSE_FILE, CLIPBOARD_PID_FILE, FREE_TIER_LIMIT } from '../proxy/ProjectStore.js';
 import { installBrainHooks } from './gitHooks.js';
 import { installHostHooks } from './hostHooks.js';
 import { getBrain } from '../subconscious/TheBrainV2.js';
+import { DEFAULT_MEMORY_SIMILARITY_FLOOR } from '../mcp/utils.js';
+import { cacheCollectionName } from '../utils/ProjectIdentity.js';
 const chroma = new ChromaClient({ host: 'localhost', port: 8000 });
 const dummyEmbeddingFunction = { generate: (_texts) => Promise.resolve([]) };
 const complexityRouter = new ComplexityRouter();
@@ -87,7 +89,7 @@ function writeJson(filePath, data) {
     catch { }
 }
 function getCollectionName(projectName) {
-    return `lemma-cache-${projectName}`;
+    return cacheCollectionName(projectName);
 }
 // detectProject/isProjectMismatch live in ../utils/ProjectIdentity — a side-effect-free
 // module shared with src/mcp/tools.ts, so the client and this daemon can never define
@@ -387,6 +389,11 @@ enabled = true
 }
 const EVENT_LOG = [];
 const MAX_EVENTS = 100;
+/**
+ * Secrets masked since this daemon started. Counting 'privacy:mask' entries in EVENT_LOG only
+ * ever saw the last 100 events, and counted requests rather than secrets.
+ */
+const SECRETS_MASKED = { count: 0 };
 // MCP Status tracking
 const MCP_STATUS = {
     lastActivity: Date.now(),
@@ -473,7 +480,7 @@ export function startBackgroundClipboardWatcher(cliOpts) {
         }
     }
     catch { }
-    const shouldWatch = cliOpts?.clipboard !== false && !configDisabled;
+    const shouldWatch = cliOpts?.clipboard !== false && !configDisabled && process.env.LEMMA_DISABLE_CLIPBOARD !== 'true';
     if (!shouldWatch) {
         console.log(`⏭️  [Clipboard] Background clipboard watcher is disabled (via options or config).`);
         return;
@@ -581,6 +588,20 @@ async function loadStats() {
  * Tokens a cache hit actually avoided regenerating, measured from the cached payload
  * that was served instead of an LLM call. Replaces the old hardcoded 2000 guess.
  */
+/** The answer text inside a cached provider response (OpenAI, Anthropic or Gemini shape). */
+function extractResponseText(data) {
+    const text = data?.choices?.[0]?.message?.content ??
+        data?.content?.find?.((c) => c?.type === 'text')?.text ??
+        data?.candidates?.[0]?.content?.parts?.[0]?.text;
+    if (typeof text === 'string')
+        return text;
+    try {
+        return JSON.stringify(data);
+    }
+    catch {
+        return '';
+    }
+}
 function measureCachedTokens(data) {
     try {
         const chars = JSON.stringify(data)?.length;
@@ -602,6 +623,33 @@ function measureCachedTokens(data) {
  * round-trip), so a miss costs latency, not tokens. Charging it a fabricated token
  * figure would repeat exactly the error the cost ledger exists to correct.
  */
+/**
+ * Machine-wide totals. Completions are attributed per project (see handleCompletion), and the
+ * dashboard — like the savings ledger — reports the whole daemon, not one project's slice.
+ */
+function aggregateStats(stats) {
+    const sum = { total: 0, hits: 0, misses: 0, totalLatency: 0, totalTokensSaved: 0 };
+    for (const s of Object.values(stats || {})) {
+        // Stats written before /api/savings-record stopped touching them counted every MCP saving
+        // as a completion under provider 'mcp', with a mock 15ms latency. Those counts are exact in
+        // the provider breakdown, so take them back out; only real completions remain.
+        const mcp = s?.providers?.mcp || { hits: 0, misses: 0 };
+        const mcpCalls = (mcp.hits || 0) + (mcp.misses || 0);
+        sum.total += Math.max(0, (s?.total || 0) - mcpCalls);
+        sum.hits += Math.max(0, (s?.hits || 0) - (mcp.hits || 0));
+        sum.misses += Math.max(0, (s?.misses || 0) - (mcp.misses || 0));
+        sum.totalLatency += Math.max(0, (s?.totalLatency || 0) - mcpCalls * 15);
+        sum.totalTokensSaved += s?.totalTokensSaved || 0;
+    }
+    return sum;
+}
+/** Every semantic-cache collection the daemon writes: one per project, all "lemma-cache" prefixed. */
+async function listCacheCollections() {
+    const cols = await chroma.listCollections();
+    return cols
+        .map((c) => (typeof c === 'string' ? c : c?.name))
+        .filter((n) => typeof n === 'string' && n.startsWith('lemma-cache'));
+}
 async function recordStat(stats, project, fromCache, latencyMs, provider, tokensSaved) {
     if (!stats[project]) {
         stats[project] = { total: 0, hits: 0, misses: 0, totalLatency: 0, totalTokensSaved: 0, providers: {} };
@@ -613,7 +661,8 @@ async function recordStat(stats, project, fromCache, latencyMs, provider, tokens
         s.hits++;
     else
         s.misses++;
-    const tkSaved = fromCache ? (tokensSaved || 2000) : (tokensSaved || 0);
+    // Unmeasured is 0, not a guess: a 2000 placeholder used to surface as "2000 tokens saved".
+    const tkSaved = tokensSaved || 0;
     s.totalTokensSaved += tkSaved;
     if (!s.providers[provider])
         s.providers[provider] = { hits: 0, misses: 0 };
@@ -621,9 +670,7 @@ async function recordStat(stats, project, fromCache, latencyMs, provider, tokens
         s.providers[provider].hits++;
     else
         s.providers[provider].misses++;
-    // Only measured savings reach the ledger. `tokensSaved === undefined` means the
-    // caller never counted, so tkSaved is the 2000 placeholder — usable for the
-    // dashboard, not for a net-position claim.
+    // Only measured savings reach the ledger.
     if (fromCache && typeof tokensSaved === 'number' && tokensSaved > 0) {
         savingsLedger.recordTokens('cache', tokensSaved);
     }
@@ -650,6 +697,9 @@ function cacheGet(provider, prompt) {
         CACHE.delete(k);
         return null;
     }
+    // The only caller is the exact-hit path, so a returned entry is a served hit.
+    e.hits++;
+    e.lastHitAt = Date.now();
     return e;
 }
 function cacheSet(provider, prompt, data) {
@@ -661,7 +711,7 @@ function cacheSet(provider, prompt, data) {
         if (oldestKey)
             CACHE.delete(oldestKey);
     }
-    CACHE.set(k, { input: prompt, data, createdAt: Date.now(), ttl: TTL_MS, provider });
+    CACHE.set(k, { input: prompt, data, createdAt: Date.now(), ttl: TTL_MS, provider, hits: 0 });
 }
 // ── Semantic Search (Pro) ──────────────────────────────────────────────────────
 async function getEmbedding(text) {
@@ -1047,18 +1097,33 @@ class LemmaServer {
             console.log('▶️  [Debugger] Resumed');
             res.json({ resumed: true, paused: false, timestamp: new Date().toISOString() });
         });
-        // Project registration from MCP handshake
+        // Project registration from MCP handshake; type "mcp_heartbeat" is the 30s keep-alive
         this.app.post('/api/handshake', (req, res) => {
-            const { projectPath, projectName, stack } = req.body;
+            const { projectPath, projectName, type } = req.body;
+            // MCP servers send techStack as an array; older callers sent stack as a string.
+            const rawStack = req.body.techStack ?? req.body.stack;
+            const stack = Array.isArray(rawStack) ? rawStack.join(',') : typeof rawStack === 'string' ? rawStack : '';
             if (projectPath && projectName) {
-                this.registry.register(projectPath, projectName, stack || '');
-                console.log(`📋 [Handshake] Project registered: "${projectName}" (${projectPath})`);
+                if (type === 'mcp_heartbeat') {
+                    const known = !!this.registry.get(projectPath);
+                    this.registry.heartbeat(projectPath, projectName, stack);
+                    if (!known)
+                        console.log(`📋 [Handshake] Project re-registered by heartbeat: "${projectName}" (${projectPath})`);
+                }
+                else {
+                    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' });
             }
         });
+        // Every project with an MCP server connected to this daemon, idle ones included
+        this.app.get('/api/projects', (req, res) => {
+            res.json({ projects: this.registry.snapshot() });
+        });
         this.app.get('/v1/models', (req, res) => {
             res.json({ object: 'list', data: [
                     { id: 'gpt-4o', object: 'model', owned_by: 'lemma-proxy' },
@@ -1087,10 +1152,10 @@ class LemmaServer {
         if (fs.existsSync(this.dashboardPath)) {
             this.app.use('/dashboard/', express.static(this.dashboardPath));
             this.app.get('/api/metrics', async (req, res) => {
-                const stats = this.stats[this.projectName] || { total: 0, hits: 0, misses: 0, totalLatency: 0, totalTokensSaved: 0 };
+                const stats = aggregateStats(this.stats);
                 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 secretsMasked = SECRETS_MASKED.count;
                 const ledgerSnap = savingsLedger.getSnapshot();
                 let activeAgents = 1; // Always include the Gateway itself
                 let totalAgents = 1;
@@ -1121,8 +1186,7 @@ class LemmaServer {
             });
             this.app.get('/api/agents', async (req, res) => {
                 // Load statistics for the Gateway itself
-                const stats = await loadStats();
-                const statsProj = stats[this.projectName] || { total: 0, hits: 0 };
+                const statsProj = aggregateStats(await loadStats());
                 const total = statsProj.total || 0;
                 const hits = statsProj.hits || 0;
                 const gatewayAgent = {
@@ -1159,7 +1223,8 @@ class LemmaServer {
                         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 || e.tokensImpact || 0,
-                        costSaved: (e.tokens || e.tokensImpact || 0) ? ((e.tokens || e.tokensImpact || 0) / 1000) * 0.002 : 0,
+                        // Same per-token price as the savings ledger, so a row and the totals agree.
+                        costSaved: (e.tokens || e.tokensImpact || 0) * AVG_COST_PER_TOKEN,
                         metadata: {
                             provider: e.provider,
                             project: e.project
@@ -1171,6 +1236,12 @@ class LemmaServer {
                         eventData.args = e.args;
                         eventData.result = e.result;
                         eventData.tokensImpact = e.tokensImpact;
+                        eventData.error = e.error;
+                        eventData.receipt = e.receipt;
+                        eventData.projectPath = e.projectPath;
+                        // tokensImpact is the size of the tool result — a context cost, not a saving.
+                        eventData.tokensSaved = 0;
+                        eventData.costSaved = 0;
                     }
                     return eventData;
                 });
@@ -1204,28 +1275,34 @@ class LemmaServer {
             this.app.get('/api/cache-stats', async (req, res) => {
                 let topQueries = [];
                 let totalCached = CACHE.size;
-                // Try to query ChromaDB for semantic cache count
+                // Semantic entries across every project's collection (completions are cached per project)
                 try {
-                    const collection = await chroma.getOrCreateCollection({
-                        name: getCollectionName(this.projectName),
-                        embeddingFunction: dummyEmbeddingFunction,
-                        metadata: { "hnsw:space": "cosine" }
-                    });
-                    const count = await collection.count();
-                    totalCached += count;
+                    for (const name of await listCacheCollections()) {
+                        const collection = await chroma.getOrCreateCollection({
+                            name,
+                            embeddingFunction: dummyEmbeddingFunction,
+                            metadata: { "hnsw:space": "cosine" }
+                        });
+                        totalCached += await collection.count();
+                    }
                 }
                 catch { }
-                // Build top queries from in-memory CACHE
+                // Most reused answers: per-entry hit counts and the measured size of the cached response.
+                // These used to be a flat 2000 tokens at $2/M with the provider's hit count stamped on
+                // every entry, and "last hit" was really the creation time.
                 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;
+                    if (entry.hits === 0)
+                        continue;
+                    const tokensPerHit = measureCachedTokens(entry.data) || 0;
+                    const totalTokens = tokensPerHit * entry.hits;
                     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()
+                        hitCount: entry.hits,
+                        totalTokens,
+                        costSaved: totalTokens * AVG_COST_PER_TOKEN,
+                        lastHit: new Date(entry.lastHitAt || entry.createdAt).toISOString(),
+                        responsePreview: extractResponseText(entry.data).slice(0, 600),
                     });
                 }
                 // Try to query the stack orchestration API if running to append stack cache stats
@@ -1242,8 +1319,11 @@ class LemmaServer {
                 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);
+                // Latency percentiles of proxy completions only — MCP tool calls share EVENT_LOG.
+                const latencies = EVENT_LOG
+                    .filter(e => (e.type === 'cache:hit' || e.type === 'cache:miss') && e.provider !== 'mcp' && typeof e.latency === 'number')
+                    .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,
@@ -1309,32 +1389,33 @@ class LemmaServer {
                 }
             });
             this.app.post('/api/cache/clear', async (req, res) => {
-                const { provider } = req.body || {};
+                // resetHistory must be asked for explicitly: the ledger and stats are persisted lifetime
+                // accounting, and a "clear cache" click used to wipe them to disk as a side effect.
+                const { provider, resetHistory } = req.body || {};
                 let clearedCount = 0;
                 if (!provider) {
                     // Global clear
                     clearedCount = CACHE.size;
                     CACHE.clear();
                     EVENT_LOG.length = 0; // Clear live event log
-                    savingsLedger.reset(); // Reset savings counters
-                    // Reset and persist statistics for the current project
-                    if (this.stats[this.projectName]) {
-                        this.stats[this.projectName] = {
-                            total: 0,
-                            hits: 0,
-                            misses: 0,
-                            totalLatency: 0,
-                            totalTokensSaved: 0,
-                            providers: {}
-                        };
+                    if (resetHistory === true) {
+                        savingsLedger.reset();
+                    }
+                    // Stats are per project but reported machine-wide, so a history reset covers them all.
+                    if (resetHistory === true) {
+                        for (const key of Object.keys(this.stats))
+                            delete this.stats[key];
                         writeJson(STATS_FILE, this.stats);
                     }
-                    // Clear Chroma DB collection
+                    // Completions are cached per project, so clearing the cache clears every project's
+                    // collection — not only the one this daemon happened to be started for.
                     try {
-                        await chroma.deleteCollection({ name: getCollectionName(this.projectName) }).catch(() => { });
+                        for (const name of await listCacheCollections()) {
+                            await chroma.deleteCollection({ name }).catch(() => { });
+                        }
                     }
                     catch (e) {
-                        console.error(`[CacheClear] Failed to clear Chroma collection: ${e.message}`);
+                        console.error(`[CacheClear] Failed to clear Chroma collections: ${e.message}`);
                     }
                 }
                 else {
@@ -1345,14 +1426,16 @@ class LemmaServer {
                             clearedCount++;
                         }
                     }
-                    // Selective delete from Chroma DB collection using provider metadata filter
+                    // Selective delete, by provider metadata, across every project's collection
                     try {
-                        const collection = await chroma.getOrCreateCollection({
-                            name: getCollectionName(this.projectName),
-                            embeddingFunction: dummyEmbeddingFunction,
-                            metadata: { "hnsw:space": "cosine" }
-                        });
-                        await collection.delete({ where: { provider } });
+                        for (const name of await listCacheCollections()) {
+                            const collection = await chroma.getOrCreateCollection({
+                                name,
+                                embeddingFunction: dummyEmbeddingFunction,
+                                metadata: { "hnsw:space": "cosine" }
+                            });
+                            await collection.delete({ where: { provider } });
+                        }
                     }
                     catch (e) {
                         console.error(`[CacheClear] Failed to selectively delete provider ${provider} from Chroma: ${e.message}`);
@@ -1377,8 +1460,40 @@ class LemmaServer {
                     res.status(500).json({ error: e.message });
                 }
             });
+            // Dashboard search over Brain memories. /api/search queries the completions cache in Chroma
+            // and needs Ollama for embeddings; this needs neither. countStats:false — browsing the
+            // corpus from the dashboard must not count as a recall or credit reuse to any memory.
+            this.app.get('/api/brain/search', async (req, res) => {
+                const query = typeof req.query.q === 'string' ? req.query.q.trim() : '';
+                if (!query)
+                    return res.status(400).json({ error: 'Query required' });
+                try {
+                    // Same floor as search_memory, so the dashboard shows what the model would actually get.
+                    const results = await getBrain().searchHybrid(query, 10, DEFAULT_MEMORY_SIMILARITY_FLOOR, { countStats: false });
+                    res.json({
+                        results: results.map((r) => ({
+                            id: r.id,
+                            prompt: r.query,
+                            response: r.response,
+                            timestamp: r.timestamp,
+                            similarity: r.similarity,
+                            fresh: r.fresh,
+                            untracked: !!r.untracked,
+                        })),
+                    });
+                }
+                catch (e) {
+                    res.status(500).json({ error: e.message });
+                }
+            });
             // Serve codebase timeline snapshots (AST Time-Travel Telemetry)
+            // Snapshots come from watching this daemon's own cwd. Like onboarding, decline a caller from
+            // another project instead of serving this project's history as theirs.
             this.app.get('/api/project/timeline', (req, res) => {
+                const expectedProject = typeof req.query.expectedProject === 'string' ? req.query.expectedProject : null;
+                if (isProjectMismatch(expectedProject, this.projectName)) {
+                    return res.json({ success: false, mismatch: true, servingProject: this.projectName, timeline: [] });
+                }
                 res.json({ success: true, timeline: this.timeline });
             });
             // Dynamic Zero-Shot Onboarding mental model builder
@@ -1557,36 +1672,15 @@ class LemmaServer {
                     tk = Math.floor(Math.max(0, charsBefore - charsAfter) / 4);
                     savingsLedger.record(source, charsBefore, charsAfter);
                 }
-                // Update active project stats to immediately reflect on Dashboard total requests & charts
+                // A saving reported by an MCP tool is not a proxy completion: it used to bump the
+                // completion stats (total++, a "miss" for every non-cache source, a mock 15ms latency),
+                // which skewed the proxy's hit rate, request count and average latency. Ledger only;
+                // the event just shows the saving in the activity feed, with nothing invented.
                 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 };
-                    if (source === 'cache')
-                        s.providers['mcp'].hits++;
-                    else
-                        s.providers['mcp'].misses++;
-                    // Write updated stats back to disk immediately
-                    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,
-                        project: this.projectName,
-                        latency: 15,
+                        type: source === 'cache' ? 'brain_hit' : source,
                         provider: 'mcp',
-                        tokens: tk
+                        tokens: tk,
                     });
                 }
                 res.json({ ok: true, snapshot: savingsLedger.getSnapshot().total });
@@ -1636,11 +1730,15 @@ class LemmaServer {
                         result: event.result || 'UNKNOWN',
                         latency: event.latency || 0,
                         tokensImpact: event.tokensImpact || 0,
-                        error: event.error || null,
+                        error: typeof event.error === 'string' ? event.error.slice(0, 200) : null,
+                        receipt: typeof event.receipt === 'string' ? event.receipt : undefined,
+                        projectPath: typeof event.projectPath === 'string' ? event.projectPath : undefined,
                         timestamp: event.timestamp || new Date().toISOString(),
                     };
                     // Add to EVENT_LOG
                     logEvent(mcpEvent);
+                    if (mcpEvent.projectPath)
+                        this.registry.recordToolCall(mcpEvent.projectPath);
                     res.json({ success: true, eventId: mcpEvent.id });
                 }
                 catch (error) {
@@ -1841,6 +1939,12 @@ class LemmaServer {
         const tier = pro ? 'pro' : 'standard';
         const isStream = !!req.body.stream;
         let historyTokensSaved = 0;
+        // The daemon is one process for every project on the machine; its own projectName is just
+        // whichever cwd it was started from. Attribute each completion — stats, and above all the
+        // semantic-cache collection — to the project the request comes from (MCP handshake
+        // registry, then the messages themselves), so one project's cached answer is never served
+        // to another. Falls back to the daemon's project when nothing identifies the caller.
+        const requestProject = this.detectActiveProject(req)?.name ?? this.projectName;
         if (isDebuggerPaused()) {
             res.setHeader('Retry-After', '5');
             return res.status(503).json({ error: { message: 'Lemma is paused from the dashboard debugger. Resume it to continue.' } });
@@ -1856,15 +1960,17 @@ class LemmaServer {
             return res.status(400).json({ error: 'Invalid request format' });
         const { maskedPrompt: prompt, tokenMap } = semanticScrubber.mask(rawPrompt);
         if (Object.keys(tokenMap).length > 0) {
-            logEvent({ type: 'privacy:mask', count: Object.keys(tokenMap).length, project: this.projectName });
+            logEvent({ type: 'privacy:mask', count: Object.keys(tokenMap).length, project: requestProject });
+            SECRETS_MASKED.count += Object.keys(tokenMap).length;
         }
         const originalModel = req.body.model || 'gpt-4o';
         // ── 1. Cache-First Hot Path ──
         // Perform exact cache check immediately (resolves in <1ms)
         const hit = cacheGet(provider, prompt);
         if (hit) {
-            const cacheTokensSaved = 2000;
-            await recordStat(this.stats, this.projectName, true, Date.now() - t0, provider, cacheTokensSaved);
+            // Measured from the cached response, like the semantic path — a flat 2000 used to go
+            // straight into the ledger as if it had been counted.
+            await recordStat(this.stats, requestProject, true, Date.now() - t0, provider, measureCachedTokens(hit.data));
             const unmaskedData = semanticScrubber.unmask(hit.data, tokenMap);
             if (isStream)
                 return SseRelay.simulateHit(res, unmaskedData, { provider: provider, tier, similarity: 1.0 });
@@ -1875,10 +1981,10 @@ class LemmaServer {
         }
         // Perform semantic cache check (resolves in ~15ms)
         if (pro) {
-            const semHit = await semanticGet(provider, prompt, this.projectName);
+            const semHit = await semanticGet(provider, prompt, requestProject);
             if (semHit) {
                 if (semHit.similarity >= 0.90) {
-                    await recordStat(this.stats, this.projectName, true, Date.now() - t0, provider, measureCachedTokens(semHit.data));
+                    await recordStat(this.stats, requestProject, true, Date.now() - t0, provider, measureCachedTokens(semHit.data));
                     const unmaskedData = semanticScrubber.unmask(semHit.data, tokenMap);
                     const cacheHeader = semHit.hiveMind ? 'HIT-HIVE-MIND' : 'HIT';
                     if (isStream)
@@ -1929,7 +2035,7 @@ Adjusted Answer:`;
                                 else if (provider === 'anthropic') {
                                     synthesizedData.content[0].text = adjustedText;
                                 }
-                                await recordStat(this.stats, this.projectName, true, Date.now() - t0, provider, measureCachedTokens(synthesizedData));
+                                await recordStat(this.stats, requestProject, true, Date.now() - t0, provider, measureCachedTokens(synthesizedData));
                                 const unmaskedData = semanticScrubber.unmask(synthesizedData, tokenMap);
                                 if (isStream) {
                                     return SseRelay.simulateHit(res, unmaskedData, { provider: provider, tier, similarity: semHit.similarity });
@@ -1949,7 +2055,7 @@ Adjusted Answer:`;
             const cloudHit = await cloudSync.get(prompt);
             if (cloudHit) {
                 cacheSet(provider, prompt, cloudHit.data);
-                await recordStat(this.stats, this.projectName, true, Date.now() - t0, provider, measureCachedTokens(cloudHit.data));
+                await recordStat(this.stats, requestProject, true, Date.now() - t0, provider, measureCachedTokens(cloudHit.data));
                 const unmaskedData = semanticScrubber.unmask(cloudHit.data, tokenMap);
                 if (isStream)
                     return SseRelay.simulateHit(res, unmaskedData, { provider: provider, tier, similarity: cloudHit.similarity || 0.95 });
@@ -2045,7 +2151,7 @@ Adjusted Answer:`;
             }
         }
         if (isStream) {
-            await recordStat(this.stats, this.projectName, false, Date.now() - t0, provider, historyTokensSaved);
+            await recordStat(this.stats, requestProject, false, Date.now() - t0, provider, historyTokensSaved);
             if (!pro) {
                 await usageWriteQueue.enqueue(async () => {
                     const u = await loadUsage();
@@ -2059,7 +2165,7 @@ Adjusted Answer:`;
             const data = await this.callUpstream(req.body, provider);
             cacheSet(provider, prompt, data);
             if (pro) {
-                await semanticSet(provider, prompt, data, this.projectName);
+                await semanticSet(provider, prompt, data, requestProject);
                 await cloudSync.set(prompt, data);
             }
             if (!pro) {
@@ -2069,7 +2175,7 @@ Adjusted Answer:`;
                     await writeJson(USAGE_FILE, u);
                 });
             }
-            await recordStat(this.stats, this.projectName, false, Date.now() - t0, provider, historyTokensSaved);
+            await recordStat(this.stats, requestProject, false, Date.now() - t0, provider, historyTokensSaved);
             return res.json(semanticScrubber.unmask(data, tokenMap));
         }
         catch (err) {
@@ -2221,23 +2327,31 @@ Adjusted Answer:`;
             console.log('simply copy-paste this command into your MCP settings:');
             console.log(`\n   \x1b[1m\x1b[33mlemma mcp\x1b[0m\n`);
             console.log('────────────────────────────────────────────────\n');
-            // Auto-start the Local Clipboard Optimizer Watcher in the background
-            const clipboardDisabled = process.env.LEMMA_DISABLE_CLIPBOARD === 'true';
-            if (clipboardDisabled) {
+            // The clipboard watcher runs as its own background process (startBackgroundClipboardWatcher,
+            // tracked in CLIPBOARD_PID_FILE and stopped by `lemma stop`). This used to also start a
+            // second, in-process watcher here: two pollers on one clipboard squeezed and reported the
+            // same copy twice.
+            if (process.env.LEMMA_DISABLE_CLIPBOARD === 'true') {
                 console.log(`📋 Clipboard Watcher     : \x1b[90m[DISABLED via LEMMA_DISABLE_CLIPBOARD]\x1b[0m`);
             }
-            else {
-                console.log(`📋 Clipboard Watcher     : \x1b[33m[ACTIVE]\x1b[0m — polling clipboard every 1s (disable: LEMMA_DISABLE_CLIPBOARD=true)`);
-                try {
-                    const { startClipboardWatcher } = require('../utils/ClipboardWatcher');
-                    startClipboardWatcher(1000);
-                }
-                catch (err) {
-                    console.warn(`⚠️ Could not auto-initialize Clipboard Watcher: ${err.message}`);
-                }
-            }
         });
-        process.on('SIGTERM', () => server.close());
+        // A SIGTERM listener replaces Node's default exit, and server.close() only stops accepting:
+        // keep-alive and socket.io connections, file watchers and intervals keep the loop alive, so
+        // `lemma stop` used to leave a daemon with no port that never exited. Flush the Brain's
+        // debounced write (same reason as the MCP bootstrap), close, and exit — with a hard cap.
+        const shutdown = () => {
+            try {
+                getBrain().flushSync();
+            }
+            catch {
+                // A flush failure must never block shutdown — the next save() heals.
+            }
+            server.close(() => process.exit(0));
+            server.closeAllConnections();
+            setTimeout(() => process.exit(0), 3000).unref();
+        };
+        process.once('SIGTERM', shutdown);
+        process.once('SIGINT', shutdown);
     }
 }
 // ── CLI ────────────────────────────────────────────────────────────────────────
@@ -2932,6 +3046,20 @@ program.command('clipboard')
     .option('--interval <ms>', 'Polling interval in milliseconds', '1000')
     .action((opts) => {
     try {
+        // One watcher per machine: every poller on the same clipboard squeezes and reports the
+        // same copy again. Defer to a live watcher recorded in the pid file; otherwise record us.
+        try {
+            const recorded = parseInt(fs.readFileSync(CLIPBOARD_PID_FILE, 'utf8'), 10);
+            if (recorded && recorded !== process.pid) {
+                process.kill(recorded, 0); // throws if it's gone
+                console.log(`✅ [Clipboard] Watcher already running (PID: ${recorded}) — not starting another.`);
+                process.exit(0);
+            }
+        }
+        catch {
+            // No pid file, or its process is dead: this one is the watcher.
+        }
+        fs.writeFileSync(CLIPBOARD_PID_FILE, String(process.pid));
         const interval = parseInt(opts.interval) || 1000;
         const { startClipboardWatcher } = require('../utils/ClipboardWatcher');
         startClipboardWatcher(interval);