total-recall-brain 3.19.0 → 3.19.1

package/frontend/dist/index.html

@@ -17,7 +17,7 @@
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet" />
     <title>Total Recall — Portable Memory</title>
-    <script type="module" crossorigin src="/assets/index-B6AfuKv9.js"></script>
+    <script type="module" crossorigin src="/assets/index-D0XeeXhG.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-B4RASWbV.css">
   </head>
   <body>

package/frontend/src/pages/SkillsPage.tsx

@@ -189,6 +189,22 @@ export default function SkillsPage({ activeBrainId }: { activeBrainId?: string }
   const [installingPkg, setInstallingPkg] = useState<string | null>(null);
   const [quarantineAlert, setQuarantineAlert] = useState<{ pkg: string; reason: string } | null>(null);
 
+  // ─── Active brain → single deployable repo target ──────────────────────────
+  // activeBrainId is 'global', 'project:<name>', or a comma-joined multi-select
+  // (see BrainSelector). Only a single, non-global selection maps to one concrete
+  // project repo we can deploy a global skill into.
+  const activeRepoName = useMemo(() => {
+    if (!activeBrainId) return null;
+    const ids = activeBrainId.split(',').map((s) => s.trim()).filter(Boolean);
+    if (ids.length !== 1 || ids[0] === 'global') return null;
+    const id = ids[0];
+    return id.startsWith('project:') ? id.slice('project:'.length) : id;
+  }, [activeBrainId]);
+  const activeRepoGroup = useMemo(
+    () => (activeRepoName ? repoGroups.find((g) => g.repo === activeRepoName) || null : null),
+    [activeRepoName, repoGroups],
+  );
+
   // ─── Lifecycle tab state ────────────────────────────────────────────────────
   const lifecycleVersion = useMemo(() => selectedSkill && skillContent ? extractVersion(skillContent) : '0.0.0', [selectedSkill, skillContent]);
   const changelogEntries = useMemo(() => selectedSkill && skillContent ? parseChangelog(skillContent) : [], [selectedSkill, skillContent]);
@@ -269,14 +285,23 @@ export default function SkillsPage({ activeBrainId }: { activeBrainId?: string }
         groups = (data.repos || []) as RepoSkillsGroup[];
       }
 
-      if (activeBrainId && activeBrainId !== 'global') {
-        const targetRepoId = activeBrainId.startsWith('project:') ? activeBrainId.replace('project:', '') : activeBrainId;
+      // activeBrainId may be a comma-joined multi-select (see BrainSelector) — split it
+      // rather than treating the whole string as a single repo id, else selecting more
+      // than one brain collapsed the list down to only the "Global" group.
+      const selectedBrainIds = (activeBrainId || '').split(',').map((s) => s.trim()).filter(Boolean);
+      if (selectedBrainIds.length > 0 && !selectedBrainIds.includes('global')) {
+        const targetRepoIds = selectedBrainIds.map((id) =>
+          id.startsWith('project:') ? id.slice('project:'.length) : id,
+        );
         groups = groups.filter(
-          g => g.repo === 'Global' || 
-               g.repo === targetRepoId || 
-               targetRepoId.endsWith(`/${g.repo}`) || 
-               g.repo.endsWith(`/${targetRepoId}`) ||
-               activeBrainId === `project:${g.repo}`
+          g => g.repo === 'Global' ||
+               targetRepoIds.some(
+                 (targetRepoId) =>
+                   g.repo === targetRepoId ||
+                   targetRepoId.endsWith(`/${g.repo}`) ||
+                   g.repo.endsWith(`/${targetRepoId}`),
+               ) ||
+               selectedBrainIds.includes(`project:${g.repo}`)
         );
         list = groups.flatMap(g => g.skills || []);
       }
@@ -713,24 +738,26 @@ Configure triggers, options, and prompts inside this rules sheet to hot-recompil
                             {skill.name}
                           </span>
                           <div style={{ display: 'flex', gap: '8px', alignItems: 'center' }}>
-                            {activeBrainId && activeBrainId !== 'Global' && group.repo === 'Global' && (
+                            {activeRepoGroup?.path && group.repo === 'Global' && (
                               <input
                                 type="checkbox"
-                                checked={!!repoGroups.find(g => g.repo === activeBrainId)?.skills?.some(s => s.name === skill.name)}
+                                checked={!!activeRepoGroup?.skills?.some(s => s.name === skill.name)}
                                 onClick={(e) => e.stopPropagation()}
                                 onChange={async (e) => {
                                   e.stopPropagation();
                                   const checked = e.target.checked;
+                                  const targetRepoPath = activeRepoGroup?.path;
+                                  if (!targetRepoPath) return;
                                   if (checked) {
                                     // Open preview modal instead of instantly deploying
                                     setPreviewModalOpen(true);
                                     setPreviewLoading(true);
                                     setPreviewData(null);
                                     try {
-                                      const res = await previewSkillRepo(skill.name, activeBrainId);
+                                      const res = await previewSkillRepo(skill.name, targetRepoPath);
                                       setPreviewData({
                                         skillName: skill.name,
-                                        targetRepo: activeBrainId,
+                                        targetRepo: targetRepoPath,
                                         original: res.original,
                                         preview: res.preview,
                                         signals: res.signals
@@ -744,7 +771,7 @@ Configure triggers, options, and prompts inside this rules sheet to hot-recompil
                                   } else {
                                     // Uncheck (disable) happens immediately
                                     try {
-                                      await toggleSkillRepo(skill.name, activeBrainId, false);
+                                      await toggleSkillRepo(skill.name, targetRepoPath, false);
                                       void fetchSkillsList();
                                     } catch (err) {
                                       setError((err as Error).message);
@@ -831,7 +858,7 @@ Configure triggers, options, and prompts inside this rules sheet to hot-recompil
             <h2 style={{ marginTop: 0, marginBottom: 12 }}>Skill Adaptation Preview</h2>
             {previewLoading ? (
               <div style={{ flex: 1, display: 'flex', justifyContent: 'center', alignItems: 'center' }}>
-                <p>Generating adaptive preview for {activeBrainId}...</p>
+                <p>Generating adaptive preview for {activeRepoName || activeBrainId}...</p>
               </div>
             ) : previewData ? (
               <>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "total-recall-brain",
-  "version": "3.19.0",
+  "version": "3.19.1",
   "description": "Personal AI system — database-free, SSSS-powered intelligence engine deployable to any POSIX host.",
   "type": "module",
   "workspaces": [

package/src/core/embeddings.mjs

@@ -215,8 +215,7 @@ async function getGoogleEmbedding(text, model) {
       model: `models/${resolved}`,
       content: { parts: [{ text }] },
     }),
-    signal: AbortSignal.timeout(30000),
-  });
+  }, 30000);
 
   if (!res.ok) {
     const body = await res.text().catch(() => '');
@@ -246,7 +245,6 @@ async function getOpenRouterEmbedding(text, model = 'openai/text-embedding-3-sma
     // Request 768 dims to match the existing vault vss0(embedding(768)) schema
     // and stay comparable against previously-stored Google embeddings.
     body: JSON.stringify({ model, input: text, dimensions: 768 }),
-    signal: AbortSignal.timeout(30000),
   }, 20000);
 
   if (!res.ok) {
@@ -275,8 +273,7 @@ async function getOpenAIEmbedding(text, model = 'text-embedding-3-small') {
       'Authorization': `Bearer ${openaiKey}`,
     },
     body: JSON.stringify({ model, input: text }),
-    signal: AbortSignal.timeout(30000),
-  });
+  }, 30000);
 
   if (!res.ok) {
     const body = await res.text().catch(() => '');

package/src/core/source-adapters.mjs

@@ -980,7 +980,7 @@ export function checkSourceAvailability(config) {
     config.braveApiKey || config.tavilyApiKey || config.exaApiKey || config.serperApiKey;
   if (!config.searxUrl && !hasPaidSearch) {
     warnings.push(
-      'No SearX URL and no paid web-search key. Set SEARX_URL (preferred) or Brave/Tavily/Exa/Serper — otherwise only DuckDuckGo Instant Answer.',
+      'No SearX URL and no paid web-search key. Set SEARX_URL (preferred), or BRAVE_SEARCH_API_KEY / TAVILY_API_KEY / EXA_API_KEY / SERPER_API_KEY — otherwise only DuckDuckGo Instant Answer.',
     );
   } else if (config.searxUrl) {
     warnings.push(

package/src/core/throttled-fetch.mjs

@@ -231,22 +231,52 @@ function appendAuditLog(entry) {
   }
 }
 
+/**
+ * Persisting an audit event goes through the full SSSS kernel (schema
+ * registry build + validation), which is CPU-heavy enough to starve the
+ * event loop for seconds at a time. Firing it inline — even un-awaited —
+ * competes with concurrent I/O (like the body-stream read of the very
+ * request being audited) for event-loop turns. Queue + flush on a deferred
+ * macrotask so in-flight I/O always gets priority.
+ */
+const policyEventQueue = [];
+let policyEventFlushScheduled = false;
+
+function schedulePolicyEventFlush() {
+  if (policyEventFlushScheduled) return;
+  policyEventFlushScheduled = true;
+  setImmediate(async () => {
+    policyEventFlushScheduled = false;
+    const batch = policyEventQueue.splice(0, policyEventQueue.length);
+    if (batch.length === 0) return;
+    try {
+      const [{ processViaPackageKernel }, crypto, { brainDir }, path] = await Promise.all([
+        import('./ssss-kernel-bridge.mjs'),
+        import('node:crypto'),
+        import('./config.mjs'),
+        import('node:path'),
+      ]);
+      const vaultRoot = path.join(brainDir, 'memory-vault');
+      for (const eventContent of batch) {
+        const envelope = {
+          type: 'event',
+          idempotency_key: crypto.randomUUID(),
+          path: 'system/network-policy.md',
+          workspace_id: 'default',
+          actor: { role: 'system' },
+          content: JSON.stringify(eventContent),
+        };
+        await processViaPackageKernel(envelope, vaultRoot, { agentRole: 'system' }).catch(() => {});
+      }
+    } catch {
+      // Best-effort audit trail; never let it affect request handling.
+    }
+  });
+}
+
 async function emitPolicyEvent(eventContent) {
-  import('./ssss-kernel-bridge.mjs').then(async ({ processViaPackageKernel }) => {
-    const crypto = await import('node:crypto');
-    const { brainDir } = await import('./config.mjs');
-    const path = await import('node:path');
-    const vaultRoot = path.join(brainDir, 'memory-vault');
-    const envelope = {
-      type: 'event',
-      idempotency_key: crypto.randomUUID(),
-      path: 'system/network-policy.md',
-      workspace_id: 'default',
-      actor: { role: 'system' },
-      content: JSON.stringify(eventContent)
-    };
-    await processViaPackageKernel(envelope, vaultRoot, { agentRole: 'system' }).catch(() => {});
-  }).catch(() => {});
+  policyEventQueue.push(eventContent);
+  schedulePolicyEventFlush();
 }
 
 // ─── Rate Limiting (minIntervalMs) ──────────────────────────────────────────
@@ -397,15 +427,15 @@ async function executeFetch(url, options, timeoutMs, domain, queueWaitMs = 0, ra
         rate_wait_ms: rateWaitMs,
       });
 
-      emitPolicyEvent({
-        domain,
-        url,
-        status: errorMsg ? 'error' : finalStatus,
-        error: errorMsg,
-        duration_ms: durationMs,
-        queue_wait_ms: queueWaitMs,
-        rate_wait_ms: rateWaitMs,
-      });
+      // NOTE: audit events used to also be persisted via emitPolicyEvent()
+      // (a full SSSS kernel write per request). Measured at 30s+ per call —
+      // processViaPackageKernel/getTotalRecallEngine is catastrophically slow
+      // on this vault, and even deferred via setImmediate it still blocks the
+      // single-threaded event loop for its full duration once it runs,
+      // stalling concurrent I/O (e.g. the very response body being read).
+      // In-memory appendAuditLog() above (queryable via getAuditLog()) is the
+      // audit trail for network activity now. Re-enable emitPolicyEvent()
+      // only after the kernel commit path itself is fixed to be fast.
     }
   }
 }

package/src/server/routes/rules.mjs

@@ -1,7 +1,7 @@
 import express from 'express';
-import { getBothBrains } from '../../cli/agent-dir.mjs';
 import { getNodes } from '../../core/vault-cache.mjs';
 import { logger } from '../../core/logger.mjs';
+import { resolveAllVaultsFromQuery, VAULT_DIR } from './_shared.mjs';
 
 import path from 'node:path';
 
@@ -10,21 +10,6 @@ export const rulesRouter = express.Router();
 /** Rule categories that surface on the Agent Rules page / instruction compiler. */
 const RULE_CATEGORIES = new Set(['invariants', 'preferences', 'anti-patterns', 'corrections']);
 
-/**
- * Resolve the vault root for a brain layer.
- * getBothBrains() returns `brainDir` (not `brainRoot`).
- * Project layer also carries `agentDir` — fall back to skills/total-recall under it.
- */
-function resolveBrainDir(layer) {
-  if (!layer) return null;
-  if (typeof layer.brainDir === 'string' && layer.brainDir) return layer.brainDir;
-  if (typeof layer.brainRoot === 'string' && layer.brainRoot) return layer.brainRoot; // legacy alias
-  if (typeof layer.agentDir === 'string' && layer.agentDir) {
-    return path.join(layer.agentDir, 'skills', 'total-recall');
-  }
-  return null;
-}
-
 function serializeRule(node, scope) {
   const importanceRaw = Number(node.importance);
   const importance = Number.isFinite(importanceRaw)
@@ -49,16 +34,17 @@ function serializeRule(node, scope) {
 
 rulesRouter.get('/api/rules', (req, res) => {
   try {
-    const { global: globalBrain, project: projectBrain } = getBothBrains();
+    // Scoped by req.query.brain / x-total-recall-brain header, same as memory/graph —
+    // this used to always merge the global vault with getBothBrains()'s cwd-detected
+    // project brain, ignoring whichever brain the user had selected in the UI.
+    const vaultDirs = resolveAllVaultsFromQuery(req);
+    const globalVaultKey = path.resolve(VAULT_DIR);
     const rules = [];
     const seenVaults = new Set();
 
-    const addRules = (brainDir, scope) => {
-      if (!brainDir) return;
-      const vaultDir = path.join(brainDir, 'memory-vault');
+    for (const vaultDir of vaultDirs) {
       const vaultKey = path.resolve(vaultDir);
-      // Avoid double-listing when project brainDir incorrectly points at global.
-      if (seenVaults.has(vaultKey)) return;
+      if (seenVaults.has(vaultKey)) continue;
       seenVaults.add(vaultKey);
 
       let nodes = [];
@@ -66,18 +52,16 @@ rulesRouter.get('/api/rules', (req, res) => {
         nodes = getNodes(vaultDir) || [];
       } catch (err) {
         logger.warn('rules', 'Failed to load vault nodes', { vaultDir, error: err.message });
-        return;
+        continue;
       }
 
+      const scope = vaultKey === globalVaultKey ? 'global' : 'project';
       for (const n of nodes) {
         if (!RULE_CATEGORIES.has(n.category)) continue;
         // Prefer active rules first in natural order; archived still included for restore UI
         rules.push(serializeRule(n, scope));
       }
-    };
-
-    addRules(resolveBrainDir(globalBrain), 'global');
-    addRules(resolveBrainDir(projectBrain), 'project');
+    }
 
     res.json({ rules, count: rules.length });
   } catch (err) {

package/src/server/routes/skills.mjs

@@ -303,6 +303,9 @@ export function collectSkillsByRepo() {
 
 function resolveRegisteredProject(repoName) {
   if (!repoName) return null;
+  // "Global" is the synthetic repo collectSkillsByRepo() unshifts for os.homedir() —
+  // it isn't a real project-registry.json entry, so resolve it directly here too.
+  if (repoName === 'Global') return { name: 'Global', path: os.homedir() };
   const registry = loadProjectRegistry();
   const entry = registry.find(
     (p) => p.name === repoName || path.basename(p.path || p.project_root || '') === repoName,