persyst-mcp 2.2.5 → 2.2.6

package/src/setup-wasm.js

@@ -9,62 +9,57 @@ const require = createRequire(import.meta.url);
 const onnxWebPath = require.resolve('onnxruntime-web');
 const wasmDir = path.dirname(onnxWebPath);
 
-// Redirect native Node session creation to WebAssembly session creation
 ONNX_NODE.InferenceSession.create = ONNX_WEB.InferenceSession.create;
 
-// Override URL.createObjectURL to return file URL of the existing local file
 const originalCreateObjectURL = URL.createObjectURL;
-URL.createObjectURL = (blob) => {
+const patchedCreateObjectURL = (blob) => {
   const type = blob.type || '';
   if (type.includes('javascript') || type.includes('mjs')) {
     const filePath = path.join(wasmDir, 'ort-wasm-simd-threaded.asyncify.mjs');
-    const fileUrl = pathToFileURL(filePath).href;
-    return fileUrl;
+    return pathToFileURL(filePath).href;
   }
   return originalCreateObjectURL(blob);
 };
+URL.createObjectURL = patchedCreateObjectURL;
+
+function readLocalFile(filePath, urlStr) {
+  const normalized = path.normalize(filePath);
+  const buffer = fs.readFileSync(normalized);
+  let contentType = 'application/octet-stream';
+  if (normalized.endsWith('.wasm')) contentType = 'application/wasm';
+  else if (normalized.endsWith('.mjs') || normalized.endsWith('.js')) contentType = 'text/javascript';
+  else if (normalized.endsWith('.onnx') || normalized.endsWith('.ort')) contentType = 'application/octet-stream';
+  return new Response(buffer, {
+    status: 200,
+    statusText: 'OK',
+    headers: { 'Content-Type': contentType }
+  });
+}
 
-// Override global fetch to load ONNX WASM binaries and model files from local disk
 const originalFetch = globalThis.fetch;
-globalThis.fetch = async (url, options) => {
+const patchedFetch = async (url, options) => {
   const urlStr = typeof url === 'string' ? url : url.url;
-  
-  let isLocal = false;
-  let filePath = '';
-  
-  if (urlStr.startsWith('file://')) {
-    isLocal = true;
-    filePath = fileURLToPath(urlStr);
-  } else if (!urlStr.startsWith('http://') && !urlStr.startsWith('https://') && !urlStr.startsWith('data:')) {
-    isLocal = true;
-    filePath = urlStr;
-  }
-  
-  // Intercept onnxruntime-web CDN URLs and route them to node_modules/onnxruntime-web/dist
+
+  // onnxruntime-web WASM binaries — resolve from node_modules
   if (urlStr.includes('onnxruntime-web') || urlStr.includes('ort-wasm')) {
-    isLocal = true;
     const filename = urlStr.split('/').pop().split('?')[0].split('#')[0];
-    filePath = path.join(wasmDir, filename);
+    return readLocalFile(path.join(wasmDir, filename), urlStr);
   }
-  
-  if (isLocal) {
-    filePath = path.normalize(filePath);
+
+  // file:// URLs — Node.js fetch does not support them natively
+  if (urlStr.startsWith('file://')) {
+    return readLocalFile(fileURLToPath(urlStr), urlStr);
+  }
+
+  // fallback for any non-http/https/data URL (onnxruntime internal schemes, bare paths)
+  if (!urlStr.startsWith('http://') && !urlStr.startsWith('https://') && !urlStr.startsWith('data:')) {
     try {
-      const buffer = fs.readFileSync(filePath);
-      let contentType = 'application/octet-stream';
-      if (filePath.endsWith('.wasm')) contentType = 'application/wasm';
-      else if (filePath.endsWith('.mjs') || filePath.endsWith('.js')) contentType = 'text/javascript';
-      
-      return new Response(buffer, {
-        status: 200,
-        statusText: 'OK',
-        headers: { 'Content-Type': contentType }
-      });
-    } catch (err) {
-      console.error('[persyst] Failed to read local file:', filePath, err.message);
-      throw err;
+      return readLocalFile(urlStr, urlStr);
+    } catch (e) {
+      throw e;
     }
   }
-  
+
   return originalFetch(url, options);
 };
+globalThis.fetch = patchedFetch;

package/src/text-utils.js

@@ -0,0 +1,41 @@
+/**
+ * text-utils.js — Shared text-processing helpers used across Persyst.
+ *
+ * Keeping these in one place avoids duplicated logic and divergent behavior
+ * between modules.
+ */
+
+/**
+ * Compute Jaccard similarity between two text strings.
+ * Uses word-level tokenization for efficiency.
+ *
+ * @param {string} a - First text
+ * @param {string} b - Second text
+ * @returns {number} Similarity score between 0 and 1
+ */
+export function jaccardSimilarity(a, b) {
+  if (!a || !b) return 0;
+
+  const wordsA = new Set(a.toLowerCase().split(/\s+/));
+  const wordsB = new Set(b.toLowerCase().split(/\s+/));
+
+  let intersection = 0;
+  for (const word of wordsA) {
+    if (wordsB.has(word)) intersection++;
+  }
+
+  const union = wordsA.size + wordsB.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+
+/**
+ * Compute Jaccard distance between two text strings.
+ * Distance = 1 - similarity, so 0 means identical and 1 means completely different.
+ *
+ * @param {string} a - First text
+ * @param {string} b - Second text
+ * @returns {number} Distance score between 0 and 1
+ */
+export function jaccardDistance(a, b) {
+  return 1 - jaccardSimilarity(a, b);
+}

package/src/tools.js

@@ -14,8 +14,10 @@
 import { z } from 'zod';
 import { generateEmbedding } from './embeddings.js';
 import db, {
+  stmts,
   insertMemory,
   insertVector,
+  redactSecrets,
   getMemory,
   updateMemoryContent,
   deleteMemory,
@@ -45,6 +47,7 @@ import db, {
   getNamespaceStats
 } from './database.js';
 import { searchHybrid, getOptimizedContext, consolidateMemories } from './search.js';
+import { jaccardDistance } from './text-utils.js';
 import { getRecentCommits } from './git.js';
 import { verifyChainIntegrity } from './attestation.js';
 import { searchCache } from './cache.js';
@@ -109,8 +112,11 @@ export async function addMemoryInternal({ content, importance = 1.0, agent_id, s
   try {
     const normalizedAgentId = agent_id ? agent_id.toLowerCase() : null;
 
+    // Redact secrets/credentials on write
+    const redactedContent = redactSecrets(content);
+
     // Bug 7 + Feature 4: Validate content size
-    const validation = validateMemoryContent(content);
+    const validation = validateMemoryContent(redactedContent);
     if (!validation.valid) {
       return { error: validation.error };
     }
@@ -119,14 +125,13 @@ export async function addMemoryInternal({ content, importance = 1.0, agent_id, s
     const namespace = (shared || !normalizedAgentId) ? 'shared' : normalizedAgentId;
 
     // Deduplication check (namespace-aware)
-    const existing = getMemoryByContent(content, namespace);
+    const existing = getMemoryByContent(redactedContent, namespace);
     if (existing) {
       // Re-attribute provenance to the calling agent if it was previously auto-attributed to log-watcher
       const prov = getProvenance(existing.id);
       if (prov && (prov.source_id === 'antigravity-worker' || prov.source_id === 'user-dialogue') && normalizedAgentId) {
         try {
-          db.prepare("UPDATE provenance SET source_type = 'agent', source_id = ?, confidence = 1.0 WHERE memory_id = ?")
-            .run(normalizedAgentId, existing.id);
+          stmts.updateProvenanceOwner.run(normalizedAgentId, existing.id);
           incrementAgentStat(normalizedAgentId, 'created');
         } catch (e) {
           console.error(`[persyst] Re-attribute provenance error: ${e.message}`);
@@ -141,20 +146,20 @@ export async function addMemoryInternal({ content, importance = 1.0, agent_id, s
       };
     }
 
-    const id = insertMemory(content, importance, {
+    const id = insertMemory(redactedContent, importance, {
       source_type: normalizedAgentId ? 'agent' : 'manual',
       source_id: normalizedAgentId,
       confidence: 1.0
     }, namespace);
 
-    const embedding = await generateEmbedding(content);
+    const embedding = await generateEmbedding(redactedContent);
     insertVector(id, embedding);
 
     // Feature 1: Invalidate search cache on write
     searchCache.invalidate();
 
     // Broadcast to SSE subscribers (HTTP gateway + SSE clients)
-    memoryEventBus.emit('memory_added', { id, content, namespace, source: normalizedAgentId || 'manual' });
+    memoryEventBus.emit('memory_added', { id, content: redactedContent, namespace, source: normalizedAgentId || 'manual' });
 
     // Feature 2: Contradiction Detection
     let contradictions = [];
@@ -169,20 +174,20 @@ export async function addMemoryInternal({ content, importance = 1.0, agent_id, s
           const existingMemory = getMemoryById(hitId, namespace);
           if (!existingMemory) continue;
 
-          const jaccard = jaccardDistance(content, existingMemory.content);
+          const jaccard = jaccardDistance(redactedContent, existingMemory.content);
           // Contradiction: similar topic (high similarity), but differing key terms
           if (jaccard > 0 && jaccard < 0.65) {
             // Fetch provenances for trust calculation
             const oldProv = getProvenance(hitId);
             let oldReputation = 1.0;
             if (oldProv && oldProv.source_type === 'agent' && oldProv.source_id) {
-              const agentRow = db.prepare('SELECT reputation_score FROM agent_stats WHERE agent_id = ?').get(oldProv.source_id);
+              const agentRow = stmts.getReputationScore.get(oldProv.source_id);
               if (agentRow) oldReputation = agentRow.reputation_score;
             }
 
             let newReputation = 1.0;
             if (normalizedAgentId) {
-              const agentRow = db.prepare('SELECT reputation_score FROM agent_stats WHERE agent_id = ?').get(normalizedAgentId);
+              const agentRow = stmts.getReputationScore.get(normalizedAgentId);
               if (agentRow) newReputation = agentRow.reputation_score;
             }
 
@@ -191,7 +196,11 @@ export async function addMemoryInternal({ content, importance = 1.0, agent_id, s
 
             const isSelfUpdate = oldProv && oldProv.source_type === 'agent' && oldProv.source_id === normalizedAgentId;
 
-            if (isSelfUpdate || trustNew > trustOld) {
+            if (isSelfUpdate) {
+              continue; // Same agent: treat as complementary, not contradictory
+            }
+
+            if (trustNew > trustOld) {
               // New is preferred
               logContradiction(hitId, id, `Auto-detected contradiction: new memory is more trustworthy (similarity: ${sim.toFixed(3)}, content_diff: ${jaccard.toFixed(3)})`);
               contradictions.push({
@@ -320,11 +329,13 @@ export function registerTools(server) {
     'get_memory',
     'Get a specific memory by its ID. Boosts its importance automatically.',
     {
-      id: z.number().describe('Memory ID to retrieve')
+      id: z.number().describe('Memory ID to retrieve'),
+      agent_id: z.string().optional().describe('Agent ID — restricts access to this agent\'s namespace + shared')
     },
-    async ({ id }) => {
+    async ({ id, agent_id }) => {
       try {
-        const memory = getMemory(id);
+        const namespace = agent_id ? agent_id.toLowerCase() : null;
+        const memory = getMemory(id, namespace);
         if (!memory) return text({ error: `Memory #${id} not found` });
         return text(memory);
       } catch (err) {
@@ -346,13 +357,17 @@ export function registerTools(server) {
       try {
         const normalizedAgentId = agent_id ? agent_id.toLowerCase() : null;
 
+        // Redact secrets/credentials on update
+        const redactedContent = redactSecrets(content);
+
         // Bug 7 + Feature 4: Validate content size
-        const validation = validateMemoryContent(content);
+        const validation = validateMemoryContent(redactedContent);
         if (!validation.valid) {
           return text({ error: validation.error });
         }
 
-        const oldMemory = getMemory(id);
+        const namespace = normalizedAgentId;
+        const oldMemory = getMemory(id, namespace);
         if (!oldMemory) return text({ error: `Memory #${id} not found` });
 
         // Retrieve old agent_id from provenance
@@ -361,7 +376,7 @@ export function registerTools(server) {
 
         // Insert new version
         const newId = insertMemory(
-          content,
+          redactedContent,
           oldMemory.importance_score,
           {
             source_type: resolvedAgentId ? 'agent' : 'manual',
@@ -372,7 +387,7 @@ export function registerTools(server) {
           id
         );
 
-        const embedding = await generateEmbedding(content);
+        const embedding = await generateEmbedding(redactedContent);
         insertVector(newId, embedding);
 
         // Record contradiction and archive the old one
@@ -381,6 +396,9 @@ export function registerTools(server) {
         // Feature 1: Invalidate search cache on write
         searchCache.invalidate();
 
+        // Broadcast update to SSE subscribers
+        memoryEventBus.emit('memory_updated', { old_id: id, new_id: newId, namespace: oldMemory.namespace || 'shared' });
+
         return text({
           success: true,
           id: newId,
@@ -397,10 +415,15 @@ export function registerTools(server) {
     'delete_memory',
     'Permanently delete a memory by its ID.',
     {
-      id: z.number().describe('Memory ID to delete')
+      id: z.number().describe('Memory ID to delete'),
+      agent_id: z.string().optional().describe('Agent ID — restricts deletion to this agent\'s namespace + shared')
     },
-    async ({ id }) => {
+    async ({ id, agent_id }) => {
       try {
+        const namespace = agent_id ? agent_id.toLowerCase() : null;
+        const memory = getMemory(id, namespace);
+        if (!memory) return text({ error: `Memory #${id} not found` });
+
         const deleted = deleteMemory(id);
         if (!deleted) return text({ error: `Memory #${id} not found` });
 
@@ -408,7 +431,7 @@ export function registerTools(server) {
         searchCache.invalidate();
 
         // Broadcast deletion to SSE subscribers
-        memoryEventBus.emit('memory_deleted', { id });
+        memoryEventBus.emit('memory_deleted', { id, namespace: memory.namespace || 'shared' });
 
         return text({ success: true, id, message: `Memory #${id} deleted` });
       } catch (err) {
@@ -545,14 +568,16 @@ export function registerTools(server) {
     {
       entity_name: z.string().describe('Name of the entity'),
       memory_id: z.number().describe('ID of the memory to link'),
-      relation: z.string().default('mentions').describe('Relationship type')
+      relation: z.string().default('mentions').describe('Relationship type'),
+      agent_id: z.string().optional().describe('Agent ID — restricts linking to this agent\'s namespace + shared')
     },
-    async ({ entity_name, memory_id, relation }) => {
+    async ({ entity_name, memory_id, relation, agent_id }) => {
       try {
+        const namespace = agent_id ? agent_id.toLowerCase() : null;
         const entity = getEntityByName(entity_name);
         if (!entity) return text({ error: `Entity "${entity_name}" not found.` });
 
-        const memory = getMemory(memory_id);
+        const memory = getMemory(memory_id, namespace);
         if (!memory) return text({ error: `Memory #${memory_id} not found` });
 
         insertEdge(entity.id, memory_id, relation, 'entity', 'memory');
@@ -830,27 +855,6 @@ function text(data) {
   };
 }
 
-/**
- * Compute Jaccard distance between two text strings.
- * Used for contradiction detection — higher distance means more different content.
- * @param {string} a - First text
- * @param {string} b - Second text
- * @returns {number} Distance score between 0 (identical) and 1 (completely different)
- */
-function jaccardDistance(a, b) {
-  const wordsA = new Set(a.toLowerCase().split(/\s+/));
-  const wordsB = new Set(b.toLowerCase().split(/\s+/));
-
-  let intersection = 0;
-  for (const word of wordsA) {
-    if (wordsB.has(word)) intersection++;
-  }
-
-  const union = wordsA.size + wordsB.size - intersection;
-  if (union === 0) return 0;
-  return 1 - (intersection / union);
-}
-
 /**
  * Compute word-level diff between two text strings using dynamic programming.
  * Highlights additions as [+added+] and deletions as [-deleted-].

package/src/watcher.js

@@ -14,18 +14,20 @@ import {
   upsertWatchPosition,
   insertMemory,
   insertVector,
-  memoryExists
+  memoryExists,
+  deleteMemory
 } from './database.js';
 import { generateEmbedding } from './embeddings.js';
-import { extractHeuristic } from './extractor-heuristic.js';
+import { extractHeuristic, hasExtractableSignals } from './extractor-heuristic.js';
 import { searchHybrid } from './search.js';
 import { searchCache } from './cache.js';
 import { memoryEventBus } from './events.js';
+import chokidar from 'chokidar';
 
-// Config path: ~/.persyst/config.json
-const CONFIG_FILE = join(homedir(), '.persyst', 'config.json');
+// Config path: ~/.persyst/config.json (overridable for tests)
+const CONFIG_FILE = process.env.PERSYST_CONFIG_FILE || join(homedir(), '.persyst', 'config.json');
 
-let intervalId = null;
+let chokidarWatcher = null;
 const DEDUP_THRESHOLD = 0.80;
 
 /**
@@ -103,18 +105,31 @@ async function processJsonlFile(filePath) {
 
     const lines = text.split('\n');
     let addedCount = 0;
+    let processedOffset = lastPos;
 
-    for (const line of lines) {
-      if (!line.trim()) continue;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const isLastLine = i === lines.length - 1;
+
+      // Empty trailing line after a newline is expected; skip it without treating it as partial.
+      if (!line.trim()) {
+        if (!isLastLine) processedOffset += line.length + 1;
+        continue;
+      }
 
       let record;
       try {
         record = JSON.parse(line);
       } catch (_) {
-        // Line might be incomplete/partially written — skip and parse next time
+        // If the last line fails to parse, it may be partially written. Leave processedOffset
+        // before this line so the next scan re-reads it from the start.
+        if (!isLastLine) processedOffset += line.length + 1;
         continue;
       }
 
+      // Commit the bytes for this line (including the newline that produced the split).
+      processedOffset += line.length + 1;
+
       // Check if it's user prompt or assistant response
       if (
         record.content &&
@@ -122,7 +137,7 @@ async function processJsonlFile(filePath) {
       ) {
         // Strip XML/markdown wrapper tags (like <USER_REQUEST> or <ADDITIONAL_METADATA>)
         const cleanText = record.content.replace(/<[^>]+>[\s\S]*?<\/[^>]+>/g, '').trim();
-        if (cleanText.length < 15) continue;
+        if (cleanText.length < 15 || !hasExtractableSignals(cleanText)) continue;
 
         const facts = extractHeuristic(cleanText);
         for (const fact of facts) {
@@ -142,8 +157,16 @@ async function processJsonlFile(filePath) {
             confidence: fact.confidence
           });
 
-          const embedding = await generateEmbedding(fact.content);
-          insertVector(id, embedding);
+          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-antigravity' });
@@ -155,10 +178,13 @@ async function processJsonlFile(filePath) {
       searchCache.invalidate();
     }
 
-    // Persist new byte offset position
-    upsertWatchPosition(filePath, stat.size);
+    // Persist the byte offset up to the last successfully parsed complete line.
+    // Do not advance past an incomplete trailing line so it is re-read on the next scan.
+    upsertWatchPosition(filePath, processedOffset);
+    return addedCount;
   } catch (err) {
     console.error(`[persyst-watcher] Failed to process JSONL file ${filePath}: ${err.message}`);
+    return 0;
   }
 }
 
@@ -186,7 +212,7 @@ async function processJsonFile(filePath) {
     // Process only newly added messages
     for (let i = lastMsgCount; i < history.length; i++) {
       const msg = history[i];
-      if (!msg.content || typeof msg.content !== 'string') continue;
+      if (!msg.content || typeof msg.content !== 'string' || !hasExtractableSignals(msg.content)) continue;
 
       // Filter out system message structures
       if (msg.role === 'user' || msg.role === 'assistant') {
@@ -208,8 +234,16 @@ async function processJsonFile(filePath) {
             confidence: fact.confidence
           });
 
-          const embedding = await generateEmbedding(fact.content);
-          insertVector(id, embedding);
+          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' });
@@ -223,8 +257,10 @@ async function processJsonFile(filePath) {
 
     // Persist message count index
     upsertWatchPosition(filePath, history.length);
+    return addedCount;
   } catch (err) {
     console.error(`[persyst-watcher] Failed to process JSON file ${filePath}: ${err.message}`);
+    return 0;
   }
 }
 
@@ -263,6 +299,7 @@ function findFiles(dir, ext, depth = 3) {
  */
 export async function scanDirectories() {
   const watchDirs = loadWatchedDirs();
+  let totalAdded = 0;
 
   for (const dir of watchDirs) {
     if (!existsSync(dir)) continue;
@@ -270,7 +307,7 @@ export async function scanDirectories() {
     // Scan for JSONL (Antigravity transcripts)
     const jsonlFiles = findFiles(dir, 'transcript.jsonl', 3);
     for (const file of jsonlFiles) {
-      await processJsonlFile(file);
+      totalAdded += await processJsonlFile(file);
     }
 
     // Scan for JSON (Roo Code / Cline task files)
@@ -278,44 +315,116 @@ export async function scanDirectories() {
     for (const file of jsonFiles) {
       // Avoid processing general configurations/settings files
       if (file.includes('tasks')) {
-        await processJsonFile(file);
+        totalAdded += await processJsonFile(file);
       }
     }
   }
+
+  // Auto-consolidate memories if new ones were added to keep prompt context slim
+  if (totalAdded > 0) {
+    try {
+      console.error(`[persyst-watcher] Running automatic memory consolidation sweep...`);
+      const { consolidateMemories } = await import('./search.js');
+      const report = await consolidateMemories();
+      console.error(`[persyst-watcher] Auto-consolidation complete: merged ${report.consolidated_groups} duplicate groups.`);
+    } catch (e) {
+      console.error(`[persyst-watcher] Auto-consolidation failed: ${e.message}`);
+    }
+  }
+
+  // Run periodic auto-expiry check on every folder scan (fast query)
+  try {
+    const { archiveExpiredMemories } = await import('./database.js');
+    archiveExpiredMemories();
+  } catch (e) {
+    console.error(`[persyst-watcher] Auto-expiry execution failed: ${e.message}`);
+  }
+}
+
+/**
+ * Handle a file addition or modification event from Chokidar.
+ * @param {string} filePath 
+ */
+async function handleFileChange(filePath) {
+  const normalizedPath = filePath.replace(/\\/g, '/');
+  let addedCount = 0;
+  
+  if (normalizedPath.endsWith('transcript.jsonl')) {
+    addedCount = await processJsonlFile(filePath);
+  } else if (normalizedPath.endsWith('.json') && normalizedPath.includes('tasks')) {
+    addedCount = await processJsonFile(filePath);
+  }
+
+  if (addedCount > 0) {
+    try {
+      console.error(`[persyst-watcher] Running automatic memory consolidation sweep...`);
+      const { consolidateMemories } = await import('./search.js');
+      const report = await consolidateMemories();
+      console.error(`[persyst-watcher] Auto-consolidation complete: merged ${report.consolidated_groups} duplicate groups.`);
+    } catch (e) {
+      console.error(`[persyst-watcher] Auto-consolidation failed: ${e.message}`);
+    }
+  }
+
+  // Run periodic auto-expiry check on every change (fast query)
+  try {
+    const { archiveExpiredMemories } = await import('./database.js');
+    archiveExpiredMemories();
+  } catch (e) {
+    console.error(`[persyst-watcher] Auto-expiry execution failed: ${e.message}`);
+  }
 }
 
 /**
  * Start the background log watcher daemon.
  */
 export function startWatcher() {
-  if (intervalId) return;
-
-  console.error('[persyst-watcher] Starting background log watcher daemon...');
-  // Warm up config/paths
-  loadWatchedDirs();
+  if (chokidarWatcher) return;
 
-  // Run initial scan
-  scanDirectories().catch(err => {
-    console.error(`[persyst-watcher] Initial scan failed: ${err.message}`);
-  });
+  console.error('[persyst-watcher] Starting background log watcher daemon (Chokidar)...');
+  const watchDirs = loadWatchedDirs();
 
-  // Polling directory scan every 5 seconds
-  intervalId = setInterval(async () => {
-    try {
-      await scanDirectories();
-    } catch (err) {
-      console.error(`[persyst-watcher] Folder scan failed: ${err.message}`);
-    }
-  }, 5000);
+  // Run initial scan, then start watching
+  scanDirectories()
+    .catch(err => {
+      console.error(`[persyst-watcher] Initial scan failed: ${err.message}`);
+    })
+    .then(() => {
+      if (chokidarWatcher) return;
+      chokidarWatcher = chokidar.watch(watchDirs, {
+        persistent: true,
+        ignoreInitial: true, // we already ran scanDirectories
+        awaitWriteFinish: {
+          stabilityThreshold: 300,
+          pollInterval: 100
+        }
+      });
+
+      chokidarWatcher.on('add', filePath => {
+        handleFileChange(filePath).catch(err => {
+          console.error(`[persyst-watcher] Error handling added file ${filePath}:`, err);
+        });
+      });
+
+      chokidarWatcher.on('change', filePath => {
+        handleFileChange(filePath).catch(err => {
+          console.error(`[persyst-watcher] Error handling changed file ${filePath}:`, err);
+        });
+      });
+
+      chokidarWatcher.on('error', err => {
+        console.error(`[persyst-watcher] Chokidar watcher error: ${err.message}`);
+      });
+    });
 }
 
 /**
  * Stop the background log watcher daemon.
  */
 export function stopWatcher() {
-  if (intervalId) {
-    clearInterval(intervalId);
-    intervalId = null;
+  if (chokidarWatcher) {
+    chokidarWatcher.close().catch(() => {});
+    chokidarWatcher = null;
     console.error('[persyst-watcher] Background log watcher daemon stopped.');
   }
 }