total-recall-brain 3.18.3 → 3.19.0

package/src/server/routes/memory.mjs

@@ -23,18 +23,14 @@ import { buildEmbeddingsIndex, buildSessionEmbeddingsIndex } from '../../core/em
 import { detectAndResolve } from '../../core/conflict-detector.mjs';
 import { listQueue, updateQueueItem } from '../../core/research-queue.mjs';
 import {
-  BRAIN_DIR,
   VAULT_DIR,
-  SKILLS_DIR,
-  DERIVED_DIR,
-  SESSIONS_DIR,
-  INSTRUCTIONS,
   notFound,
   badRequest,
   serverError,
   sanitizeNode,
   resolveVaultFromQuery,
   resolveAllVaultsFromQuery,
+  pathsForVault,
 } from './_shared.mjs';
 
 const router = express.Router();
@@ -42,6 +38,8 @@ const router = express.Router();
 /* ── OPT-6: debounce recompilation across rapid consecutive writes ── */
 let recompileTimer = null;
 const RECOMPILE_DEBOUNCE_MS = 2000; // 2-second quiet period
+/** @type {Map<string, ReturnType<typeof setTimeout>>} */
+const recompileTimersByVault = new Map();
 
 function nodes(vaultDir = VAULT_DIR) {
   return getNodes(vaultDir);
@@ -52,40 +50,47 @@ function nodes(vaultDir = VAULT_DIR) {
  * Auto-mutates the brain in real time when any fact is written, updated, or deleted!
  */
 async function triggerMutation(node, vaultDir = VAULT_DIR) {
+  const paths = pathsForVault(vaultDir);
+
   // 1. Semantic conflict detection runs IMMEDIATELY (lightweight, per-node)
   try {
     const existing = nodes(vaultDir);
     if (node && node.type === 'memory') {
       detectAndResolve(node, existing, {
         vaultDir,
-        inboxDir: path.join(BRAIN_DIR, 'memory-inbox'),
+        inboxDir: paths.inboxDir,
       });
     }
   } catch (conflictErr) {
     // Non-fatal fallback
   }
 
-  // 2+3. Debounce the EXPENSIVE recompile + embeddings rebuild.
+  // 2+3. Debounce the EXPENSIVE recompile + embeddings rebuild per vault.
   //       Rapid consecutive writes accumulate; only ONE compile fires
   //       after a quiet period. Vault-cache is already invalidated
   //       immediately at each call-site via invalidate().
-  if (recompileTimer) clearTimeout(recompileTimer);
-  recompileTimer = setTimeout(async () => {
-    recompileTimer = null;
+  const prev = recompileTimersByVault.get(vaultDir);
+  if (prev) clearTimeout(prev);
+  // Keep legacy single-timer field in sync for default vault (tests/introspection)
+  if (vaultDir === VAULT_DIR && recompileTimer) clearTimeout(recompileTimer);
+
+  const timer = setTimeout(async () => {
+    recompileTimersByVault.delete(vaultDir);
+    if (vaultDir === VAULT_DIR) recompileTimer = null;
     try {
-      // Recompile instructions surface
+      // Recompile instructions surface for THIS vault's brain
       await compileSurface({
         vaultDir,
-        skillsDir:       SKILLS_DIR,
-        derivedDir:      DERIVED_DIR,
-        instructionsFile: INSTRUCTIONS,
+        skillsDir: paths.skillsDir,
+        derivedDir: paths.derivedDir,
+        instructionsFile: paths.instructionsFile,
       });
 
-      // Rebuild dense embeddings index
+      // Rebuild dense embeddings index for THIS vault
       try {
         const vaultNodes = nodes(vaultDir);
-        await buildEmbeddingsIndex(vaultNodes, DERIVED_DIR);
-        await buildSessionEmbeddingsIndex(SESSIONS_DIR, DERIVED_DIR);
+        await buildEmbeddingsIndex(vaultNodes, paths.derivedDir);
+        await buildSessionEmbeddingsIndex(paths.sessionsDir, paths.derivedDir);
       } catch (embedErr) {
         // local_llm/embeddings offline non-fatal
       }
@@ -93,6 +98,9 @@ async function triggerMutation(node, vaultDir = VAULT_DIR) {
       // Non-fatal background log
     }
   }, RECOMPILE_DEBOUNCE_MS);
+
+  recompileTimersByVault.set(vaultDir, timer);
+  if (vaultDir === VAULT_DIR) recompileTimer = timer;
 }
 
 
@@ -414,16 +422,48 @@ router.delete('/api/memory/:slug', requireAuth, requireScope('memory:write'), (r
 
 /**
  * POST /api/memory/search/semantic
- * Body: { query: string, top_k?: number }
+ * Body: { query: string, top_k?: number, brainId?: string }
+ * Query/header: brain (same as other memory routes) — project:name, global, or multi.
  * Returns top-k vault nodes ranked by vector similarity to the query.
  */
 router.post('/api/memory/search/semantic', requireAuth, requireScope('memory:read'), async (req, res) => {
   try {
     const { query, top_k, include_sessions = true } = req.body || {};
     if (!query) return badRequest(res, 'query is required');
-    const results = await semanticSearch(query, { vaultDir: VAULT_DIR, derivedDir: DERIVED_DIR, top_k, includeSessions: include_sessions });
-    if (results.length === 0) return res.status(503).json({ error: 'Embeddings index is empty. Run POST /api/vault/compile to build it.' });
-    res.json({ query, top_k: Math.min(Number(top_k) || 5, 20), results });
+
+    const k = Math.min(Number(top_k) || 5, 20);
+    const vaultDirs = resolveAllVaultsFromQuery(req);
+    const merged = [];
+    let anyIndex = false;
+
+    for (const vaultDir of vaultDirs) {
+      const { derivedDir } = pathsForVault(vaultDir);
+      try {
+        const part = await semanticSearch(query, {
+          vaultDir,
+          derivedDir,
+          top_k: k,
+          // Sessions only on the primary (first) vault to avoid cross-brain noise
+          includeSessions: include_sessions && vaultDir === vaultDirs[0],
+        });
+        if (part.length > 0) anyIndex = true;
+        for (const r of part) {
+          merged.push({ ...r, _brainVault: vaultDir });
+        }
+      } catch {
+        // per-vault search failure is non-fatal when multi-brain
+      }
+    }
+
+    merged.sort((a, b) => (b.score || 0) - (a.score || 0));
+    const results = merged.slice(0, k);
+
+    if (!anyIndex || results.length === 0) {
+      return res.status(503).json({
+        error: 'Embeddings index is empty. Run POST /api/vault/compile to build it.',
+      });
+    }
+    res.json({ query, top_k: k, results });
   } catch (err) {
     serverError(res, err);
   }

package/src/server/routes/share.mjs

@@ -129,7 +129,8 @@ router.post('/api/share', requireAuth, requireScope('memory:write'), async (req,
         validation: vaultResult.validation,
       });
     }
-    invalidate();
+    // Invalidate only the vault we wrote to (avoid thrashing other brain caches)
+    invalidate(vaultDir);
 
     // Mark extension as connected when share comes from the extension
     if (source && source.includes('extension')) {

package/src/server/routes/ssss.mjs

@@ -139,15 +139,23 @@ router.get('/api/ssss', requireAuth, requireScope('ssss:read'), (req, res) => {
 
 router.get('/api/ssss/instructions', requireAuth, requireScope('ssss:read', 'instructions:read'), (req, res) => {
   const surface = req.query.surface;
+  // Prefer live INSTRUCTIONS constant (agent brain), then package ROOT fallback
+  const instructionsPath = fs.existsSync(INSTRUCTIONS)
+    ? INSTRUCTIONS
+    : path.join(ROOT, 'INSTRUCTIONS.md');
   if (surface) {
     if (surface === 'INSTRUCTIONS.md') {
-      return sendTextResource(res, path.join(ROOT, 'INSTRUCTIONS.md'), 'instructions');
+      return sendTextResource(res, instructionsPath, 'instructions');
     }
     const safeSurface = path.basename(surface);
-    const surfacePath = path.join(ROOT, safeSurface);
+    const candidates = [
+      path.join(path.dirname(instructionsPath), safeSurface),
+      path.join(ROOT, safeSurface),
+    ];
+    const surfacePath = candidates.find(p => fs.existsSync(p)) || candidates[0];
     return sendTextResource(res, surfacePath, safeSurface);
   }
-  return sendTextResource(res, path.join(ROOT, 'INSTRUCTIONS.md'), 'instructions');
+  return sendTextResource(res, instructionsPath, 'instructions');
 });
 
 router.get('/api/ssss/skill/ssss', requireAuth, requireScope('ssss:read'), (_req, res) => {

package/src/server/routes/update.mjs

@@ -100,11 +100,30 @@ router.post('/api/update/run', requireAuth, requireScope('config:write'), async
       }
     }
 
+    const failed = Number(summary?.failed || 0);
+    const updated = Number(summary?.updated || 0);
+    const upToDate = Number(summary?.up_to_date || 0);
+    const skipped = Number(
+      (summary?.results || []).filter((r) => String(r.status || '').startsWith('skipped')).length,
+    );
+    const ok = !summary?.skipped && failed === 0;
+    const parts = [];
+    if (updated) parts.push(`${updated} updated`);
+    if (upToDate) parts.push(`${upToDate} already current`);
+    if (skipped) parts.push(`${skipped} skipped`);
+    if (failed) parts.push(`${failed} failed`);
+    const detail = parts.length ? parts.join(', ') : 'no projects checked';
+
     res.json({
-      updating: !dryRun,
+      success: ok,
+      updating: !dryRun && ok,
       message: dryRun
-        ? 'Dry-run complete — see projects list'
-        : 'Package auto-update finished for registered projects',
+        ? `Dry-run complete — ${detail}`
+        : ok
+          ? `Package auto-update finished for registered projects (${detail}). Latest: ${summary?.latest || 'n/a'}`
+          : summary?.reason === 'npm-view-failed'
+            ? 'Could not resolve latest version from npm (network or registry). Try again.'
+            : `Package auto-update finished with errors (${detail}). Latest: ${summary?.latest || 'n/a'}`,
       summary,
     });
   } catch (err) {

package/src/server/routes/vault.mjs

@@ -1,10 +1,17 @@
 import { Router } from 'express';
 import fs from 'node:fs';
 import path from 'node:path';
-import crypto from 'node:crypto';
 import { requireAuth, requireScope } from '../auth.mjs';
-import { serverError, ROOT, BRAIN_DIR, VAULT_DIR, SKILLS_DIR, INSTRUCTIONS, DERIVED_DIR, SESSIONS_DIR } from './_shared.mjs';
-import { logger } from '../../core/logger.mjs';
+import {
+  serverError,
+  VAULT_DIR,
+  SKILLS_DIR,
+  INSTRUCTIONS,
+  DERIVED_DIR,
+  SESSIONS_DIR,
+  resolveVaultFromQuery,
+  pathsForVault,
+} from './_shared.mjs';
 import { compileSurface } from '../../core/surface.mjs';
 import { getNodes, invalidate } from '../../core/vault-cache.mjs';
 import { loadEmbeddingsIndex, loadSessionEmbeddingsIndex } from '../../core/embeddings.mjs';
@@ -14,22 +21,32 @@ const router = Router();
 router.post('/api/vault/compile', requireAuth, requireScope('memory:recompile'), async (req, res) => {
   try {
     const start = Date.now();
+    const vaultDir = resolveVaultFromQuery(req);
+    const paths = pathsForVault(vaultDir);
+
     await compileSurface({
-      vaultDir:        VAULT_DIR,
-      skillsDir:       SKILLS_DIR,
-      derivedDir:      DERIVED_DIR,
-      instructionsFile: INSTRUCTIONS,
+      vaultDir,
+      skillsDir: paths.skillsDir,
+      derivedDir: paths.derivedDir,
+      instructionsFile: paths.instructionsFile,
+      force: true,
     });
-    // Incrementally embed any new vault nodes and sessions
+    // Incrementally embed any new vault nodes and sessions for THIS brain
     let vaultEmbed = null, sessionEmbed = null;
     try {
       const { buildEmbeddingsIndex, buildSessionEmbeddingsIndex } = await import('../../core/embeddings.mjs');
-      invalidate();
-      const vaultNodes = getNodes(VAULT_DIR);
-      vaultEmbed = await buildEmbeddingsIndex(vaultNodes, DERIVED_DIR);
-      sessionEmbed = await buildSessionEmbeddingsIndex(SESSIONS_DIR, DERIVED_DIR);
+      invalidate(vaultDir);
+      const vaultNodes = getNodes(vaultDir);
+      vaultEmbed = await buildEmbeddingsIndex(vaultNodes, paths.derivedDir);
+      sessionEmbed = await buildSessionEmbeddingsIndex(paths.sessionsDir, paths.derivedDir);
     } catch { /* embedding service may be unavailable — non-fatal */ }
-    res.json({ compiled: true, elapsed_ms: Date.now() - start, vault_embeddings: vaultEmbed, session_embeddings: sessionEmbed });
+    res.json({
+      compiled: true,
+      elapsed_ms: Date.now() - start,
+      vault_dir: vaultDir,
+      vault_embeddings: vaultEmbed,
+      session_embeddings: sessionEmbed,
+    });
   } catch (err) {
     serverError(res, err);
   }
@@ -47,9 +64,11 @@ router.post('/api/vault/compact', requireAuth, requireScope('memory:write'), asy
 
 router.get('/api/vault/hash', requireAuth, requireScope('memory:read'), (req, res) => {
   try {
-    const hashFile = path.join(DERIVED_DIR, 'vault-hash.txt');
+    const vaultDir = resolveVaultFromQuery(req);
+    const { derivedDir } = pathsForVault(vaultDir);
+    const hashFile = path.join(derivedDir, 'vault-hash.txt');
     const hash = fs.existsSync(hashFile) ? fs.readFileSync(hashFile, 'utf8').trim() : null;
-    res.json({ vault_hash: hash });
+    res.json({ vault_hash: hash, vault_dir: vaultDir });
   } catch (err) {
     serverError(res, err);
   }
@@ -57,19 +76,25 @@ router.get('/api/vault/hash', requireAuth, requireScope('memory:read'), (req, re
 
 router.get('/api/vault/status', requireAuth, requireScope('memory:read'), async (req, res) => {
   try {
-    // Use vault-cache instead of scanning every .md file from disk
-    const nodeCount = getNodes(VAULT_DIR).length;
-    const skillCount  = fs.existsSync(SKILLS_DIR)  ? fs.readdirSync(SKILLS_DIR, { withFileTypes: true }).filter(d =>
-      d.isDirectory() && fs.existsSync(path.join(SKILLS_DIR, d.name, 'SKILL.md'))).length : 0;
-    const lastCompile = fs.existsSync(INSTRUCTIONS)
-      ? fs.statSync(INSTRUCTIONS).mtime.toISOString()
+    const vaultDir = resolveVaultFromQuery(req);
+    const paths = pathsForVault(vaultDir);
+    // Prefer request-scoped paths; fall back to global constants for skills when agent dir is odd
+    const skillsDir = paths.skillsDir || SKILLS_DIR;
+    const derivedDir = paths.derivedDir || DERIVED_DIR;
+    const instructionsFile = paths.instructionsFile || INSTRUCTIONS;
+    const sessionsDir = paths.sessionsDir || SESSIONS_DIR;
+
+    const nodeCount = getNodes(vaultDir).length;
+    const skillCount  = fs.existsSync(skillsDir)  ? fs.readdirSync(skillsDir, { withFileTypes: true }).filter(d =>
+      d.isDirectory() && fs.existsSync(path.join(skillsDir, d.name, 'SKILL.md'))).length : 0;
+    const lastCompile = fs.existsSync(instructionsFile)
+      ? fs.statSync(instructionsFile).mtime.toISOString()
       : null;
-    const derivedFiles = fs.existsSync(DERIVED_DIR)
-      ? fs.readdirSync(DERIVED_DIR).length : 0;
+    const derivedFiles = fs.existsSync(derivedDir)
+      ? fs.readdirSync(derivedDir).length : 0;
 
-    // Use mtime-cached loaders instead of raw readFile + JSON.parse
-    const vaultEmbedCount   = Object.keys(loadEmbeddingsIndex(DERIVED_DIR)).length;
-    const sessionEmbedCount = Object.keys(loadSessionEmbeddingsIndex(DERIVED_DIR)).length;
+    const vaultEmbedCount   = Object.keys(loadEmbeddingsIndex(derivedDir)).length;
+    const sessionEmbedCount = Object.keys(loadSessionEmbeddingsIndex(derivedDir)).length;
 
     // CLI agent availability (best-effort)
     const { findBinaryInPath } = await import('../../core/runtime.mjs');
@@ -79,12 +104,12 @@ router.get('/api/vault/status', requireAuth, requireScope('memory:read'), async
     }
 
     res.json({
-      vault_dir:     VAULT_DIR,
+      vault_dir:     vaultDir,
       node_count:    nodeCount,
       skill_count:   skillCount,
       derived_files: derivedFiles,
       last_compile:  lastCompile,
-      instructions_exists: fs.existsSync(INSTRUCTIONS),
+      instructions_exists: fs.existsSync(instructionsFile),
       embeddings: {
         vault_nodes:    vaultEmbedCount,
         session_chunks: sessionEmbedCount,