persyst-mcp 2.2.6 → 2.2.7

package/src/events.js

@@ -8,6 +8,8 @@
  * Events emitted:
  *   memory_added       { id, content, namespace, source }
  *   memory_deleted     { id }
+ *   memory_updated     { old_id, new_id, namespace }
+ *   memory_retrieved   { tool, query, count, agent_id, namespace, memory_ids, token_budget? }
  *   memories_consolidated { consolidated_groups, details }
  */
 

package/src/search.js

@@ -20,7 +20,7 @@ import db, {
 import { generateEmbedding } from './embeddings.js';
 import { createAttestation } from './attestation.js';
 import { searchCache, LRUCache } from './cache.js';
-import { jaccardSimilarity } from './text-utils.js';
+import { jaccardSimilarity, logInfo } from './text-utils.js';
 
 let lastDataVersion = 0;
 
@@ -57,7 +57,7 @@ export async function searchHybrid(queryText, limit = 5, agentId = null, session
   const cacheKey = LRUCache.key(`${ns}:${queryText}`, parsedLimit);
   const cached = searchCache.get(cacheKey);
   if (cached) {
-    console.error(`[persyst-cache] Cache HIT for query: "${queryText.slice(0, 50)}..."`);
+    logInfo(`[persyst-cache] Cache HIT for query: "${queryText.slice(0, 50)}..."`);
     return cached;
   }
 

package/src/server.js

@@ -35,6 +35,7 @@ import { consolidateMemories, searchHybrid, getOptimizedContext } from './search
 import { startWatcher, stopWatcher } from './watcher.js';
 import { verifyChainIntegrity } from './attestation.js';
 import { memoryEventBus } from './events.js';
+import { logInfo } from './text-utils.js';
 
 // Track server birth time for uptime reporting
 const SERVER_START_TIME = Date.now();
@@ -348,7 +349,7 @@ async function handleGetRequest(req, res, url) {
     res.write(`event: connected\ndata: ${JSON.stringify({
       ok: true,
       timestamp: new Date().toISOString(),
-      server_version: '2.2.6'
+      server_version: '2.2.7'
     })}\n\n`);
 
     sseClients.add(res);
@@ -364,18 +365,28 @@ async function handleGetRequest(req, res, url) {
     const onDeleted = (data) => {
       try { res.write(`event: memory_deleted\ndata: ${JSON.stringify(data)}\n\n`); } catch (_) {}
     };
+    const onUpdated = (data) => {
+      try { res.write(`event: memory_updated\ndata: ${JSON.stringify(data)}\n\n`); } catch (_) {}
+    };
+    const onRetrieved = (data) => {
+      try { res.write(`event: memory_retrieved\ndata: ${JSON.stringify(data)}\n\n`); } catch (_) {}
+    };
     const onConsolidated = (data) => {
       try { res.write(`event: memories_consolidated\ndata: ${JSON.stringify(data)}\n\n`); } catch (_) {}
     };
 
     memoryEventBus.on('memory_added', onAdded);
     memoryEventBus.on('memory_deleted', onDeleted);
+    memoryEventBus.on('memory_updated', onUpdated);
+    memoryEventBus.on('memory_retrieved', onRetrieved);
     memoryEventBus.on('memories_consolidated', onConsolidated);
 
     req.on('close', () => {
       clearInterval(heartbeat);
       memoryEventBus.off('memory_added', onAdded);
       memoryEventBus.off('memory_deleted', onDeleted);
+      memoryEventBus.off('memory_updated', onUpdated);
+      memoryEventBus.off('memory_retrieved', onRetrieved);
       memoryEventBus.off('memories_consolidated', onConsolidated);
       sseClients.delete(res);
       console.error(`[persyst-sse] Client disconnected. Active: ${sseClients.size}`);
@@ -463,6 +474,16 @@ async function handlePostRequest(req, res, payload) {
       return;
     }
     const results = await searchHybrid(query, limit, agent_id, session_id, agent_id || null);
+    if (results && results.length > 0) {
+      memoryEventBus.emit('memory_retrieved', {
+        tool: 'http/search',
+        query,
+        count: results.length,
+        agent_id: agent_id || 'http',
+        namespace: agent_id || 'shared',
+        memory_ids: results.map(r => r.id)
+      });
+    }
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify({ success: true, results }));
     return;
@@ -506,6 +527,18 @@ async function handlePostRequest(req, res, payload) {
       return;
     }
     const context = await getOptimizedContext(query, max_tokens, agent_id, session_id, agent_id || null, intent);
+    const retrievedCount = context?.memories?.length ?? 0;
+    if (retrievedCount > 0) {
+      memoryEventBus.emit('memory_retrieved', {
+        tool: 'http/context',
+        query,
+        count: retrievedCount,
+        agent_id: agent_id || 'http',
+        namespace: agent_id || 'shared',
+        token_budget: max_tokens,
+        memory_ids: context.memories.map(m => m.id)
+      });
+    }
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(context));
     return;
@@ -668,9 +701,6 @@ async function handlePostRequest(req, res, payload) {
 // MAIN SERVER STARTUP
 // ============================================================
 
-/**
- * Start the Persyst MCP server & HTTP Gateway.
- */
 export async function startServer() {
   // --- Create MCP server ---
   const server = new McpServer({
@@ -680,177 +710,175 @@ export async function startServer() {
 
   // --- Register all tools ---
   const registeredCount = registerTools(server);
-  console.error(`[persyst] ${registeredCount} tools registered ✓`);
+  logInfo(`[persyst] ${registeredCount} tools registered ✓`);
 
-  // --- Start background log watcher daemon (skip in test mode) ---
-  if (process.env.NODE_ENV !== 'test') {
-    startWatcher();
-  }
+  // --- Connect via stdio IMMEDIATELY so MCP handshake completes instantly (<10ms) ---
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
 
-  // --- Gateway configuration ---
-  const httpPort = parseInt(process.env.PORT || '4321', 10);
-  const httpHost = process.env.PERSYST_HOST || '127.0.0.1';
-  const configuredApiKey = process.env.PERSYST_API_KEY || null;
+  logInfo('[persyst] MCP server running on stdio ✓');
+  logInfo('[persyst] Ready to receive tool calls');
 
-  if (configuredApiKey) {
-    console.error(`[persyst] API key auth enabled — endpoints require Authorization: Bearer <key>`);
-  }
-  if (httpHost !== '127.0.0.1') {
-    console.error(`[persyst] ⚠️  Gateway bound to ${httpHost} — ensure PERSYST_API_KEY is set for security`);
+  // Interactive Terminal Banner (only shown when run directly by a user in terminal)
+  if (process.stderr.isTTY || process.stdout.isTTY) {
+    console.error(`\n[OK] Persyst MCP Server is active and listening (stdio mode)`);
+    console.error(`[OK] Workspace Project: ${process.env.PERSYST_PROJECT || 'shared'}`);
+    console.error(`[OK] Local HTTP Gateway: http://127.0.0.1:${process.env.PORT || '4321'}`);
+    console.error(`[OK] Process ID: ${process.pid} | Press Ctrl+C to stop.\n`);
   }
 
-  // --- Start local HTTP Gateway ---
-  const httpServer = http.createServer((req, res) => {
-    // CORS headers
-    res.setHeader('Access-Control-Allow-Origin', '*');
-    res.setHeader('Access-Control-Allow-Methods', 'POST, GET, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+  // Defer background services & HTTP server so stdio handshake is never blocked
+  let httpServer = null;
+  let decayTimer = null;
+  let consolidationTimer = null;
+  let sseHealthCheck = null;
 
-    if (req.method === 'OPTIONS') {
-      res.writeHead(204);
-      res.end();
-      return;
-    }
+  const shutdown = () => {
+    logInfo('[persyst] Shutting down...');
+    if (decayTimer) clearInterval(decayTimer);
+    if (consolidationTimer) clearInterval(consolidationTimer);
+    if (sseHealthCheck) clearInterval(sseHealthCheck);
+    stopWatcher();
+    cleanupWatchers();
 
-    // API key authentication middleware
-    // /health is always public (for orchestrators / Docker health checks)
-    if (configuredApiKey) {
-      const urlPath = new URL(req.url || '/', 'http://127.0.0.1').pathname;
-      if (urlPath !== '/health') {
-        const authHeader = req.headers['authorization'] || '';
-        const token = authHeader.startsWith('Bearer ') ? authHeader.slice(7) : null;
-        if (token !== configuredApiKey) {
-          res.writeHead(401, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({
-            error: 'Unauthorized. Set header: Authorization: Bearer <PERSYST_API_KEY>'
-          }));
-          return;
-        }
-      }
+    for (const client of sseClients) {
+      try {
+        client.write(`event: server_shutdown\ndata: ${JSON.stringify({ message: 'Server shutting down' })}\n\n`);
+        client.end();
+      } catch (_) {}
     }
+    sseClients.clear();
 
-    // Route GET requests (no body reading needed)
-    if (req.method === 'GET') {
-      try {
-        const url = new URL(req.url || '/', `http://${httpHost}`);
-        handleGetRequest(req, res, url).catch(err => {
-          try {
-            res.writeHead(500, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: err.message }));
-          } catch (_) {}
-        });
-      } catch (err) {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Bad request URL' }));
-      }
-      return;
+    if (httpServer) httpServer.close();
+    closeDatabase();
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  setTimeout(() => {
+    // --- Start background log watcher daemon (skip in test mode) ---
+    if (process.env.NODE_ENV !== 'test') {
+      startWatcher();
     }
 
-    // Route POST requests
-    if (req.method !== 'POST') {
-      res.writeHead(405, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Method Not Allowed. Use POST or GET.' }));
-      return;
+    // --- Gateway configuration ---
+    const httpPort = parseInt(process.env.PORT || '4321', 10);
+    const httpHost = process.env.PERSYST_HOST || '127.0.0.1';
+    const configuredApiKey = process.env.PERSYST_API_KEY || null;
+
+    if (configuredApiKey) {
+      logInfo(`[persyst] API key auth enabled — endpoints require Authorization: Bearer <key>`);
+    }
+    if (httpHost !== '127.0.0.1') {
+      logInfo(`[persyst] ⚠️  Gateway bound to ${httpHost} — ensure PERSYST_API_KEY is set for security`);
     }
 
-    let body = '';
-    req.on('data', chunk => { body += chunk; });
-    req.on('end', async () => {
-      try {
-        // Handle both JSON and plain-text bodies (plain text used by /remember)
-        const contentType = req.headers['content-type'] || '';
-        let payload;
-        if (contentType.includes('text/plain')) {
-          payload = body.trim(); // Will be handled as string in /remember
-        } else {
-          payload = JSON.parse(body || '{}');
-        }
-        await handlePostRequest(req, res, payload);
-      } catch (err) {
-        try {
-          res.writeHead(500, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ error: err.message }));
-        } catch (_) {}
+    // --- Start local HTTP Gateway ---
+    httpServer = http.createServer((req, res) => {
+      // CORS headers
+      res.setHeader('Access-Control-Allow-Origin', '*');
+      res.setHeader('Access-Control-Allow-Methods', 'POST, GET, OPTIONS');
+      res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+
+      if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        res.end();
+        return;
       }
-    });
-  });
 
-  httpServer.on('error', (err) => {
-    if (err.code === 'EADDRINUSE') {
-      console.error(`[persyst] HTTP Gateway port ${httpPort} already in use. Stdio MCP server will continue.`);
-    } else {
-      console.error('[persyst] HTTP Gateway error:', err.message);
-    }
-  });
+      if (configuredApiKey) {
+        const urlPath = new URL(req.url || '/', 'http://127.0.0.1').pathname;
+        if (urlPath !== '/health') {
+          const authHeader = req.headers['authorization'] || '';
+          const token = authHeader.startsWith('Bearer ') ? authHeader.slice(7) : null;
+          if (token !== configuredApiKey) {
+            res.writeHead(401, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+              error: 'Unauthorized. Set header: Authorization: Bearer <PERSYST_API_KEY>'
+            }));
+            return;
+          }
+        }
+      }
 
-  httpServer.listen(httpPort, httpHost, () => {
-    console.error(`[persyst] HTTP Gateway listening on http://${httpHost}:${httpPort} ✓`);
-    console.error(`[persyst] Endpoints: /health /stats /system-prompt /events /remember /search /add /context /tool /verify /batch/add /batch/search`);
-  });
+      const url = new URL(req.url || '/', `http://${req.headers.host || '127.0.0.1'}`);
+      const path = url.pathname;
 
-  // --- Start temporal decay timer (every hour) ---
-  const decayTimer = setInterval(applyTemporalDecay, 3600000);
+      if (req.method === 'GET') {
+        handleGetRequest(req, res, path, url);
+        return;
+      }
 
-  // --- Start daily consolidation sweep ---
-  const consolidationTimer = setInterval(async () => {
-    console.error('[persyst] Running scheduled daily memory consolidation sweep...');
-    try {
-      const report = await consolidateMemories();
-      console.error(`[persyst] Consolidation sweep: consolidated ${report.consolidated_groups} duplicate groups.`);
-      if (report.consolidated_groups > 0) {
-        memoryEventBus.emit('memories_consolidated', {
-          consolidated_groups: report.consolidated_groups,
-          details: report.details
+      if (req.method === 'POST') {
+        let body = '';
+        req.on('data', chunk => {
+          body += chunk;
+          if (body.length > 10 * 1024 * 1024) {
+            res.writeHead(413, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Payload too large. Max 10MB.' }));
+            req.destroy();
+          }
+        });
+        req.on('end', () => {
+          try {
+            const payload = body ? JSON.parse(body) : {};
+            handlePostRequest(req, res, payload).catch(err => {
+              try {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: err.message }));
+              } catch (_) {}
+            });
+          } catch (err) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: `Invalid JSON payload: ${err.message}` }));
+          }
         });
+        return;
       }
-    } catch (err) {
-      console.error('[persyst] Daily consolidation sweep failed:', err.message);
-    }
-  }, 86400000);
 
-  // --- SSE client health-check every 30 seconds (removes stale connections) ---
-  const sseHealthCheck = setInterval(() => {
-    for (const client of sseClients) {
-      try {
-        client.write(': health-check\n\n');
-      } catch (_) {
-        // Client is stale — remove it
-        try { client.end(); } catch (_) {}
-        sseClients.delete(client);
-      }
-    }
-  }, 30000);
+      res.writeHead(405, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Method not allowed' }));
+    });
 
-  // --- Graceful shutdown ---
-  const shutdown = () => {
-    console.error('[persyst] Shutting down...');
-    clearInterval(decayTimer);
-    clearInterval(consolidationTimer);
-    clearInterval(sseHealthCheck);
-    stopWatcher();
-    cleanupWatchers();
+    httpServer.on('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        logInfo(`[persyst] HTTP Gateway port ${httpPort} already in use. Stdio MCP server will continue.`);
+      } else {
+        console.error('[persyst] HTTP Gateway error:', err.message);
+      }
+    });
 
-    // Close all SSE connections gracefully
-    for (const client of sseClients) {
-      try {
-        client.write(`event: server_shutdown\ndata: ${JSON.stringify({ message: 'Server shutting down' })}\n\n`);
-        client.end();
-      } catch (_) {}
-    }
-    sseClients.clear();
+    httpServer.listen(httpPort, httpHost, () => {
+      logInfo(`[persyst] HTTP Gateway listening on http://${httpHost}:${httpPort} ✓`);
+    });
 
-    httpServer.close();
-    closeDatabase();
-    // Let the process exit naturally after all handles are closed
-    // process.exit(0) removed — Node exits on its own when event loop is empty
-  };
-  process.on('SIGINT', shutdown);
-  process.on('SIGTERM', shutdown);
+    decayTimer = setInterval(applyTemporalDecay, 3600000);
 
-  // --- Connect via stdio ---
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
+    consolidationTimer = setInterval(async () => {
+      logInfo('[persyst] Running scheduled daily memory consolidation sweep...');
+      try {
+        const report = await consolidateMemories();
+        logInfo(`[persyst] Consolidation sweep: consolidated ${report.consolidated_groups} duplicate groups.`);
+        if (report.consolidated_groups > 0) {
+          memoryEventBus.emit('memories_consolidated', {
+            consolidated_groups: report.consolidated_groups,
+            details: report.details
+          });
+        }
+      } catch (err) {
+        console.error('[persyst] Daily consolidation sweep failed:', err.message);
+      }
+    }, 86400000);
 
-  console.error('[persyst] MCP server running on stdio ✓');
-  console.error('[persyst] Ready to receive tool calls');
+    sseHealthCheck = setInterval(() => {
+      for (const client of sseClients) {
+        try {
+          client.write(': health-check\n\n');
+        } catch (_) {
+          try { client.end(); } catch (_) {}
+          sseClients.delete(client);
+        }
+      }
+    }, 30000);
+  }, 50);
 }

package/src/text-utils.js

@@ -39,3 +39,14 @@ export function jaccardSimilarity(a, b) {
 export function jaccardDistance(a, b) {
   return 1 - jaccardSimilarity(a, b);
 }
+
+/**
+ * Log informational messages to stderr only when PERSYST_DEBUG or DEBUG is enabled.
+ * Prevents MCP hosts (Cursor, Antigravity, VS Code) from treating startup info logs as MCP errors.
+ */
+export function logInfo(...args) {
+  if (process.env.PERSYST_DEBUG || process.env.DEBUG) {
+    console.error(...args);
+  }
+}
+

package/src/tools.js

@@ -121,8 +121,10 @@ export async function addMemoryInternal({ content, importance = 1.0, agent_id, s
       return { error: validation.error };
     }
 
-    // Derive namespace from agent_id and shared flag
-    const namespace = (shared || !normalizedAgentId) ? 'shared' : normalizedAgentId;
+    // Derive namespace from agent_id, project env, and shared flag
+    const project = process.env.PERSYST_PROJECT;
+    const defaultNs = project || 'shared';
+    const namespace = (shared && !project) ? 'shared' : (normalizedAgentId || defaultNs);
 
     // Deduplication check (namespace-aware)
     const existing = getMemoryByContent(redactedContent, namespace);
@@ -309,9 +311,22 @@ export function registerTools(server) {
     },
     async ({ query, limit, agent_id, session_id }) => {
       try {
-        // Derive namespace from agent_id (null = search all)
-        const namespace = agent_id || null;
+        // Derive namespace from agent_id or PERSYST_PROJECT env
+        const namespace = agent_id || process.env.PERSYST_PROJECT || null;
         const results = await searchHybrid(query, limit, agent_id, session_id, namespace);
+
+        // Broadcast retrieval event to SSE subscribers and monitor
+        if (results && results.length > 0) {
+          memoryEventBus.emit('memory_retrieved', {
+            tool: 'search_memories',
+            query,
+            count: results.length,
+            agent_id: agent_id || 'unknown',
+            namespace: namespace || 'shared',
+            memory_ids: results.map(r => r.id)
+          });
+        }
+
         return text({
           results,
           count: results.length,
@@ -337,6 +352,17 @@ export function registerTools(server) {
         const namespace = agent_id ? agent_id.toLowerCase() : null;
         const memory = getMemory(id, namespace);
         if (!memory) return text({ error: `Memory #${id} not found` });
+
+        // Broadcast retrieval event
+        memoryEventBus.emit('memory_retrieved', {
+          tool: 'get_memory',
+          query: `#${id}`,
+          count: 1,
+          agent_id: agent_id || 'unknown',
+          namespace: memory.namespace || 'shared',
+          memory_ids: [id]
+        });
+
         return text(memory);
       } catch (err) {
         return text({ error: err.message });
@@ -450,7 +476,7 @@ export function registerTools(server) {
     },
     async ({ limit, agent_id }) => {
       try {
-        const namespace = agent_id || null;
+        const namespace = agent_id || process.env.PERSYST_PROJECT || null;
         const memories = getRecentMemories(limit, namespace);
         return text({ memories, count: memories.length, namespace: namespace || 'all' });
       } catch (err) {
@@ -469,7 +495,7 @@ export function registerTools(server) {
     },
     async ({ limit, agent_id }) => {
       try {
-        const namespace = agent_id || null;
+        const namespace = agent_id || process.env.PERSYST_PROJECT || null;
         const memories = getImportantMemories(limit, namespace);
         return text({ memories, count: memories.length, namespace: namespace || 'all' });
       } catch (err) {
@@ -505,7 +531,7 @@ export function registerTools(server) {
             source_type: 'git',
             source_id: commit.hash,
             confidence: 0.8
-          });
+          }, process.env.PERSYST_PROJECT || 'shared');
 
           const embedding = await generateEmbedding(commit.fullText);
           insertVector(id, embedding);
@@ -815,8 +841,23 @@ export function registerTools(server) {
     },
     async ({ query, max_tokens, agent_id, session_id, intent }) => {
       try {
-        const namespace = agent_id || null;
+        const namespace = agent_id || process.env.PERSYST_PROJECT || null;
         const contextData = await getOptimizedContext(query, max_tokens, agent_id, session_id, namespace, intent);
+
+        // Broadcast context retrieval event
+        const retrievedCount = contextData?.memories?.length ?? 0;
+        if (retrievedCount > 0) {
+          memoryEventBus.emit('memory_retrieved', {
+            tool: 'get_optimized_context',
+            query,
+            count: retrievedCount,
+            agent_id: agent_id || 'unknown',
+            namespace: namespace || 'shared',
+            token_budget: max_tokens,
+            memory_ids: contextData.memories.map(m => m.id)
+          });
+        }
+
         return text(contextData);
       } catch (err) {
         return text({ error: err.message });

package/src/watcher.js

@@ -22,6 +22,7 @@ import { extractHeuristic, hasExtractableSignals } from './extractor-heuristic.j
 import { searchHybrid } from './search.js';
 import { searchCache } from './cache.js';
 import { memoryEventBus } from './events.js';
+import { logInfo } from './text-utils.js';
 import chokidar from 'chokidar';
 
 // Config path: ~/.persyst/config.json (overridable for tests)
@@ -150,12 +151,13 @@ async function processJsonlFile(filePath) {
             continue;
           }
 
-          // Insert memory with provenance (written to 'shared' by default)
+          // Insert memory with provenance (written to project namespace or 'shared')
+          const watcherNs = process.env.PERSYST_PROJECT || 'shared';
           const id = insertMemory(fact.content, fact.confidence, {
             source_type: 'agent',
             source_id: record.source === 'MODEL' ? 'antigravity-worker' : 'user-dialogue',
             confidence: fact.confidence
-          });
+          }, watcherNs);
 
           try {
             const embedding = await generateEmbedding(fact.content);
@@ -169,7 +171,7 @@ async function processJsonlFile(filePath) {
 
           addedCount++;
           console.error(`[persyst-watcher] Auto-extracted fact: "${fact.content}" (Memory #${id})`);
-          memoryEventBus.emit('memory_added', { id, content: fact.content, namespace: 'shared', source: 'watcher-antigravity' });
+          memoryEventBus.emit('memory_added', { id, content: fact.content, namespace: watcherNs, source: 'watcher-antigravity' });
         }
       }
     }
@@ -218,35 +220,32 @@ async function processJsonFile(filePath) {
       if (msg.role === 'user' || msg.role === 'assistant') {
         const facts = extractHeuristic(msg.content);
         for (const fact of facts) {
-          // Verify against exact duplicate (Bug A fix: check namespace 'shared')
-          if (memoryExists(fact.content, 'shared')) continue;
+          const watcherNs = process.env.PERSYST_PROJECT || 'shared';
+          if (memoryExists(fact.content, watcherNs)) continue;
 
-          // Verify against semantic similarity (Bug B fix: check namespace 'shared')
-          const similar = await searchHybrid(fact.content, 1, null, null, 'shared');
+          const similar = await searchHybrid(fact.content, 1, null, null, watcherNs);
           if (similar.length > 0 && parseFloat(similar[0].similarity) >= DEDUP_THRESHOLD) {
             continue;
           }
 
-          // Insert memory with provenance (written to 'shared' by default)
           const id = insertMemory(fact.content, fact.confidence, {
             source_type: 'agent',
             source_id: msg.role === 'assistant' ? 'roo-worker' : 'user-dialogue',
             confidence: fact.confidence
-          });
+          }, watcherNs);
 
           try {
             const embedding = await generateEmbedding(fact.content);
             insertVector(id, embedding);
           } catch (embedErr) {
             console.error(`[persyst-watcher] Embedding failed for fact #${id}: ${embedErr.message}`);
-            // Clean up: delete the memory so we don't have orphaned entries
             try { deleteMemory(id); } catch (_) {}
             continue;
           }
 
           addedCount++;
           console.error(`[persyst-watcher] Auto-extracted fact: "${fact.content}" (Memory #${id})`);
-          memoryEventBus.emit('memory_added', { id, content: fact.content, namespace: 'shared', source: 'watcher-roo' });
+          memoryEventBus.emit('memory_added', { id, content: fact.content, namespace: watcherNs, source: 'watcher-roo' });
         }
       }
     }
@@ -381,7 +380,7 @@ async function handleFileChange(filePath) {
 export function startWatcher() {
   if (chokidarWatcher) return;
 
-  console.error('[persyst-watcher] Starting background log watcher daemon (Chokidar)...');
+  logInfo('[persyst-watcher] Starting background log watcher daemon (Chokidar)...');
   const watchDirs = loadWatchedDirs();
 
   // Run initial scan, then start watching
@@ -425,6 +424,6 @@ export function stopWatcher() {
   if (chokidarWatcher) {
     chokidarWatcher.close().catch(() => {});
     chokidarWatcher = null;
-    console.error('[persyst-watcher] Background log watcher daemon stopped.');
+    logInfo('[persyst-watcher] Background log watcher daemon stopped.');
   }
 }