total-recall-brain 3.2.3 → 3.4.0

package/src/core/fact-seeker.mjs

@@ -4,7 +4,8 @@ import matter from 'gray-matter';
 import crypto from 'crypto';
 import os from 'os';
 import { callLocalRuntime, cleanAndParseJSON } from './runtime.mjs';
-import { loadNodes, writeNode, atomicWrite, safeStringify } from './vault.mjs';
+import { writeNode, atomicWrite, safeStringify } from './vault.mjs';
+import { getNodes } from './vault-cache.mjs';
 import { logger } from './logger.mjs';
 import { addToQueue } from './research-queue.mjs';
 import { persistTaskToDisk } from './scheduler.mjs';
@@ -285,62 +286,87 @@ async function gatherFromSources(topicEntry, researchConfig) {
   const useGithub = (suggested_sources || []).includes('github') ||
     (tags || []).some(t => ['code', 'library', 'framework', 'open-source'].includes(t));
 
+  const tasks = [];
+
   // 1. Web search — Brave → Serper fallback, automatically selected
   if (availability.available.includes('brave-search') || availability.available.includes('serper')) {
-    try {
-      const webResults = await webSearch(topic, researchConfig, 5);
-      results.push(...webResults);
-      logger.info({ subsystem: 'fact-seeker', message: `Web search: ${webResults.length} results for "${topic}"` });
-    } catch (err) {
-      errors.push({ source: 'web-search', error: err.message });
-      logger.info({ subsystem: 'fact-seeker', message: `Web search failed: ${err.message}` });
-    }
+    tasks.push((async () => {
+      try {
+        const webResults = await webSearch(topic, researchConfig, 5);
+        logger.info({ subsystem: 'fact-seeker', message: `Web search: ${webResults.length} results for "${topic}"` });
+        return { success: true, results: webResults };
+      } catch (err) {
+        logger.info({ subsystem: 'fact-seeker', message: `Web search failed: ${err.message}` });
+        return { success: false, source: 'web-search', error: err.message };
+      }
+    })());
   }
 
   // 2. DuckDuckGo Instant Answers (always available, good for definitions/facts)
-  try {
-    const ddgResult = await duckduckgoInstant(topic, researchConfig);
-    if (ddgResult) results.push(ddgResult);
-  } catch (err) {
-    errors.push({ source: 'duckduckgo', error: err.message });
-  }
+  tasks.push((async () => {
+    try {
+      const ddgResult = await duckduckgoInstant(topic, researchConfig);
+      return { success: true, results: ddgResult ? [ddgResult] : [] };
+    } catch (err) {
+      return { success: false, source: 'duckduckgo', error: err.message };
+    }
+  })());
 
   // 3. Wikipedia (always available, high-quality structured knowledge)
-  try {
-    const wikiResult = await wikipediaFetch(topic, researchConfig);
-    if (wikiResult) results.push(wikiResult);
-  } catch (err) {
-    errors.push({ source: 'wikipedia', error: err.message });
-  }
-
-  // 4. arXiv (for academic/research topics)
-  if (useArxiv) {
+  tasks.push((async () => {
     try {
-      const arxivResults = await arxivSearch(topic, researchConfig, 3);
-      results.push(...arxivResults);
-      logger.info({ subsystem: 'fact-seeker', message: `arXiv: ${arxivResults.length} papers for "${topic}"` });
+      const wikiResult = await wikipediaFetch(topic, researchConfig);
+      return { success: true, results: wikiResult ? [wikiResult] : [] };
     } catch (err) {
-      errors.push({ source: 'arxiv', error: err.message });
+      return { success: false, source: 'wikipedia', error: err.message };
     }
+  })());
+
+  // 4. arXiv (for academic/research topics)
+  if (useArxiv) {
+    tasks.push((async () => {
+      try {
+        const arxivResults = await arxivSearch(topic, researchConfig, 3);
+        logger.info({ subsystem: 'fact-seeker', message: `arXiv: ${arxivResults.length} papers for "${topic}"` });
+        return { success: true, results: arxivResults };
+      } catch (err) {
+        return { success: false, source: 'arxiv', error: err.message };
+      }
+    })());
   }
 
   // 5. npm (for JS/Node topics)
   if (useNpm) {
-    try {
-      const npmResults = await npmSearch(topic, researchConfig, 3);
-      results.push(...npmResults);
-    } catch (err) {
-      errors.push({ source: 'npm', error: err.message });
-    }
+    tasks.push((async () => {
+      try {
+        const npmResults = await npmSearch(topic, researchConfig, 3);
+        return { success: true, results: npmResults };
+      } catch (err) {
+        return { success: false, source: 'npm', error: err.message };
+      }
+    })());
   }
 
   // 6. GitHub (for code/library topics)
   if (useGithub) {
-    try {
-      const ghResults = await githubSearch(topic, researchConfig, 'repositories', 3);
-      results.push(...ghResults);
-    } catch (err) {
-      errors.push({ source: 'github', error: err.message });
+    tasks.push((async () => {
+      try {
+        const ghResults = await githubSearch(topic, researchConfig, 'repositories', 3);
+        return { success: true, results: ghResults };
+      } catch (err) {
+        return { success: false, source: 'github', error: err.message };
+      }
+    })());
+  }
+
+  // Await all tasks concurrently in parallel
+  const taskResults = await Promise.all(tasks);
+
+  for (const res of taskResults) {
+    if (res.success) {
+      results.push(...res.results);
+    } else {
+      errors.push({ source: res.source, error: res.error });
     }
   }
 
@@ -730,7 +756,7 @@ Output ONLY valid JSON.`;
  * Evaluates coverage, temporal awareness, source diversity, and limitations.
  */
 export async function runSelfDiagnosis({ vaultDir, runtimeConfig }) {
-  const nodes = loadNodes(vaultDir);
+  const nodes = getNodes(vaultDir);
   const activeNodes = nodes.filter(n => n.status === 'active');
   const agenda = loadAgenda();
   const availability = checkSourceAvailability(loadResearchConfig());
@@ -994,7 +1020,7 @@ async function pushDeliberationConclusion(conclusions = []) {
  * Phase 2/5: Deliberation
  */
 export async function runResearchDeliberationCycle({ vaultDir, nodeSlug, topic, runtimeConfig }) {
-  const nodes = loadNodes(vaultDir);
+  const nodes = getNodes(vaultDir);
   const targetNode = nodes.find(n => n.slug === nodeSlug);
   if (!targetNode) {
     return { success: false, error: `Target node not found for slug: ${nodeSlug}` };
@@ -1309,7 +1335,7 @@ Output ONLY valid JSON.`;
  * Phase 3/5: Refinement & Clarity Auditing
  */
 export async function runResearchImprovementCycle({ vaultDir, nodeSlug, topic, runtimeConfig }) {
-  const nodes = loadNodes(vaultDir);
+  const nodes = getNodes(vaultDir);
   const targetNode = nodes.find(n => n.slug === nodeSlug);
   if (!targetNode) {
     return { success: false, error: `Target node not found for slug: ${nodeSlug}` };
@@ -1384,7 +1410,7 @@ export async function runResearchMonitoringCycle({
   derivedDir,
   instructionsFile
 }) {
-  const nodes = loadNodes(vaultDir);
+  const nodes = getNodes(vaultDir);
   const targetNode = nodes.find(n => n.slug === nodeSlug);
   if (!targetNode) {
     return { success: false, error: `Target node not found for slug: ${nodeSlug}` };
@@ -1490,7 +1516,7 @@ Output ONLY valid JSON.`;
  * Phase 5/5: Domain Tangents Expansion
  */
 export async function runResearchExpansionCycle({ vaultDir, nodeSlug, topic, runtimeConfig }) {
-  const nodes = loadNodes(vaultDir);
+  const nodes = getNodes(vaultDir);
   const targetNode = nodes.find(n => n.slug === nodeSlug);
   if (!targetNode) {
     return { success: false, error: `Target node not found for slug: ${nodeSlug}` };

package/src/core/import-rules.mjs

@@ -14,7 +14,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import crypto from 'node:crypto';
-import { writeNode, loadNodes } from './vault.mjs';
+import { writeNode } from './vault.mjs';
+import { getNodes } from './vault-cache.mjs';
 import { agentDir, brainDir } from './config.mjs';
 
 const AGENT_DIR = agentDir;
@@ -75,7 +76,7 @@ export function detectRuleFiles(dirs) {
   // Load existing vault nodes to detect already-imported files
   let existingSlugs = new Set();
   try {
-    existingSlugs = new Set(loadNodes(VAULT_DIR).map(n => n.slug));
+    existingSlugs = new Set(getNodes(VAULT_DIR).map(n => n.slug));
   } catch { /* vault may not exist yet */ }
 
   for (const dir of searchDirs) {

package/src/core/inference-engine.mjs

@@ -3,7 +3,8 @@ import path from 'path';
 import matter from 'gray-matter';
 import crypto from 'crypto';
 import { callLocalRuntime, cleanAndParseJSON } from './runtime.mjs';
-import { loadNodes, atomicWrite, safeStringify } from './vault.mjs';
+import { atomicWrite, safeStringify } from './vault.mjs';
+import { getNodes } from './vault-cache.mjs';
 import { logger } from './logger.mjs';
 import { brainDir } from './config.mjs';
 
@@ -83,7 +84,7 @@ function buildInferencePrompt(nodes) {
  * @returns {{ conclusions: object[], contradictions: object[], merge_candidates: object[], error? }}
  */
 export async function runInferenceTask(slugs, { vaultDir, inboxDir, runtimeConfig }) {
-  const allNodes = loadNodes(vaultDir);
+  const allNodes = getNodes(vaultDir);
   const nodes = allNodes.filter(n => slugs.includes(n.slug) && n.status === 'active');
 
   if (nodes.length < 2) {
@@ -154,7 +155,7 @@ function writeConclusionNode(inboxDir, conclusion, sourceSlugList, vaultDir) {
   
   if (vaultDir) {
     try {
-      const allNodes = loadNodes(vaultDir);
+      const allNodes = getNodes(vaultDir);
       citations = sourceSlugList.map(s => {
         const matchingNode = allNodes.find(n => n.slug === s);
         const cat = matchingNode ? matchingNode.category : 'facts';
@@ -312,7 +313,7 @@ Output valid JSON:
  * @param {object} opts.runtimeConfig
  */
 export async function runSynthesisTask(slugA, slugB, { vaultDir, inboxDir, runtimeConfig }) {
-  const allNodes = loadNodes(vaultDir);
+  const allNodes = getNodes(vaultDir);
   const nodeA = allNodes.find(n => n.slug === slugA);
   const nodeB = allNodes.find(n => n.slug === slugB);
 

package/src/core/migrate.mjs

@@ -1,7 +1,8 @@
 import fs from 'fs';
 import path from 'path';
 import crypto from 'crypto';
-import { loadNodes, writeNode, atomicWrite } from './vault.mjs';
+import { writeNode, atomicWrite } from './vault.mjs';
+import { getNodes } from './vault-cache.mjs';
 import { createSnapshot } from './snapshot.mjs';
 import { SSSS_SCHEMAS } from './schema.mjs';
 import { logger } from './logger.mjs';
@@ -33,7 +34,7 @@ export async function runMigration(vaultDir, fromVersion, toVersion, migrationFn
   };
 
   try {
-    const nodes = loadNodes(vaultDir);
+    const nodes = getNodes(vaultDir);
     logger.info('migration', `Loaded ${nodes.length} nodes for migration processing.`);
 
     // 2. Execute Migration
@@ -78,7 +79,7 @@ export async function runMigration(vaultDir, fromVersion, toVersion, migrationFn
 export async function testMigration(vaultDir, migrationFn, targetSchemaType) {
   logger.info('migration', 'Running migration harness in isolated context...');
   
-  const nodes = loadNodes(vaultDir).slice(0, 50); // Sample a subset
+  const nodes = getNodes(vaultDir).slice(0, 50); // Sample a subset
   
   try {
     const testMigrated = await migrationFn(nodes);

package/src/core/optimizer.mjs

@@ -2,7 +2,8 @@ import fs from 'fs';
 import path from 'path';
 import crypto from 'crypto';
 import matter from 'gray-matter';
-import { loadNodes, writeNode } from './vault.mjs';
+import { writeNode } from './vault.mjs';
+import { getNodes } from './vault-cache.mjs';
 import { logger } from './logger.mjs';
 import { brainDir } from './config.mjs';
 
@@ -31,7 +32,7 @@ export function createProposal(category, summary, targetPath = null, rationale =
  * Scans the vault for duplicate or contradictory memories and generates a cleanup proposal.
  */
 export async function generateMemoryCleanupProposals(vaultDir) {
-  const nodes = loadNodes(vaultDir);
+  const nodes = getNodes(vaultDir);
   const proposals = [];
   
   // Simple heuristic: find nodes with the same predicate and object but different subjects, or duplicate subjects.
@@ -163,7 +164,7 @@ export async function generateWorkflowRepairProposals(vaultDir) {
  */
 export async function generateModelRoutingProposals(vaultDir) {
   const proposals = [];
-  const nodes = loadNodes(vaultDir);
+  const nodes = getNodes(vaultDir);
 
   // Find high-importance facts with low confidence — likely needed frontier model
   const underconfident = nodes.filter(n =>
@@ -187,7 +188,7 @@ export async function generateModelRoutingProposals(vaultDir) {
 }
 
 export async function generateStaleKnowledgeRefreshProposals(vaultDir) {
-  const nodes = loadNodes(vaultDir);
+  const nodes = getNodes(vaultDir);
   const proposals = [];
   
   const now = Date.now();
@@ -272,7 +273,7 @@ Output ONLY valid JSON.`;
  */
 export async function runSmartDecay(vaultDir, runtimeConfig, ageThresholdDays = 60) {
   const { callLocalRuntime } = await import('./runtime.mjs');
-  const nodes = loadNodes(vaultDir);
+  const nodes = getNodes(vaultDir);
   const now = Date.now();
   const ageThresholdMs = ageThresholdDays * 24 * 60 * 60 * 1000;
   const proposals = [];

package/src/core/parallel-context.mjs

@@ -0,0 +1,288 @@
+/**
+ * src/core/parallel-context.mjs
+ *
+ * Parallel Flash Context Streaming Engine
+ *
+ * 1 node = 1 stream. Massive GPU-style parallelism.
+ * Every node in the vault gets its own concurrent micro-Flash call.
+ * Each call is tiny (~100 tokens in, ~30 tokens out).
+ * Results stream back as they complete.
+ *
+ * Cost: 1000 nodes × ~150 tokens = 150K tokens = $0.04
+ * Speed: All calls fire simultaneously, bounded only by API rate limits.
+ *
+ * Architecture:
+ *   1. SHATTER — every node becomes its own stream
+ *   2. FLOOD — fire all streams concurrently (rate-limited)
+ *   3. COLLECT — results arrive as futures resolve
+ *   4. RANK — sort by score, pack into budget
+ *   5. DELIVER — compressed context ready for inference
+ */
+
+import { getNodes } from './vault-cache.mjs';
+import { googleApiKey } from './config.mjs';
+import { logger } from './logger.mjs';
+import { inferMemoryLayer } from './memory-layers.mjs';
+
+// ─── Configuration ──────────────────────────────────────────────────────────
+
+const FLASH_MODEL = 'gemini-3.1-flash-lite';
+const FLASH_API_URL = 'https://generativelanguage.googleapis.com/v1beta/models';
+const MAX_CONCURRENCY = 50;       // concurrent HTTP connections
+const FLASH_TIMEOUT_MS = 6000;    // per-call timeout
+const DEFAULT_BUDGET_TOKENS = 8000;
+const CHARS_PER_TOKEN = 4;
+
+// ─── Flash Micro-Call ───────────────────────────────────────────────────────
+
+/**
+ * Single micro-call to Flash. Score ONE node against the query.
+ * Prompt is minimal — ~100 tokens in, ~30 tokens out.
+ */
+async function scoreOne(query, node, apiKey) {
+  const body = (node.body || node.content || '').slice(0, 400);
+  const prompt = `Score relevance 0-100 and extract the key bit.
+Q: "${query}"
+NODE [${node.slug}] ${node.category} imp:${node.importance || 3}: ${node.title || ''} — ${body}
+Reply EXACTLY: SCORE|KEY_BIT (one line, no explanation)`;
+
+  const url = `${FLASH_API_URL}/${FLASH_MODEL}:generateContent?key=${apiKey}`;
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FLASH_TIMEOUT_MS);
+
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      signal: controller.signal,
+      body: JSON.stringify({
+        contents: [{ parts: [{ text: prompt }] }],
+        generationConfig: { maxOutputTokens: 128, temperature: 0.0 },
+      }),
+    });
+
+    if (!response.ok) {
+      // Rate limited — return fallback score
+      if (response.status === 429) {
+        return { slug: node.slug, score: node.priority === 'absolute' ? 90 : 25, compressed: body.slice(0, 150), rateLimited: true };
+      }
+      throw new Error(`${response.status}`);
+    }
+
+    const data = await response.json();
+    const text = (data.candidates?.[0]?.content?.parts?.[0]?.text || '').trim();
+
+    // Parse "SCORE|KEY_BIT"
+    const pipeIdx = text.indexOf('|');
+    if (pipeIdx > 0) {
+      const score = parseInt(text.slice(0, pipeIdx).trim(), 10);
+      const compressed = text.slice(pipeIdx + 1).trim();
+      if (!isNaN(score)) {
+        return {
+          slug: node.slug,
+          score: Math.min(Math.max(score, 0), 100),
+          compressed: compressed.slice(0, 300),
+          title: node.title,
+          category: node.category,
+          layer: inferMemoryLayer(node),
+        };
+      }
+    }
+
+    // Parsing failed — fallback
+    return { slug: node.slug, score: 30, compressed: body.slice(0, 150), title: node.title, category: node.category, parseFail: true };
+  } catch (err) {
+    // Timeout or network error — fallback
+    return {
+      slug: node.slug,
+      score: node.priority === 'absolute' ? 90 : 20,
+      compressed: body.slice(0, 150),
+      title: node.title,
+      category: node.category,
+      error: err.name === 'AbortError' ? 'timeout' : err.message,
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+// ─── Flood Dispatcher ───────────────────────────────────────────────────────
+
+/**
+ * Fire all streams concurrently with bounded concurrency.
+ * Uses a semaphore pattern — N workers pulling from a shared queue.
+ */
+async function flood(items, fn, concurrency) {
+  const results = new Array(items.length);
+  let cursor = 0;
+  let completed = 0;
+
+  async function worker() {
+    while (cursor < items.length) {
+      const i = cursor++;
+      results[i] = await fn(items[i], i);
+      completed++;
+    }
+  }
+
+  const workers = Array.from(
+    { length: Math.min(concurrency, items.length) },
+    () => worker()
+  );
+  await Promise.all(workers);
+  return results;
+}
+
+// ─── Main Entry Point ───────────────────────────────────────────────────────
+
+/**
+ * Stream context from the entire vault — 1 node = 1 stream.
+ *
+ * @param {object} opts
+ * @param {string} opts.query - Query to score against
+ * @param {string} opts.vaultDir - Vault directory
+ * @param {number} [opts.budgetTokens=8000] - Token budget
+ * @param {number} [opts.concurrency=50] - Max concurrent streams
+ * @param {number} [opts.minScore=20] - Minimum score to include
+ * @returns {Promise<{ context: string, stats: object, scored: array }>}
+ */
+export async function streamParallelContext({
+  query,
+  vaultDir,
+  budgetTokens = DEFAULT_BUDGET_TOKENS,
+  concurrency = MAX_CONCURRENCY,
+  minScore = 20,
+} = {}) {
+  const startTime = Date.now();
+  const allNodes = getNodes(vaultDir).filter(n => n.status === 'active');
+  const totalNodes = allNodes.length;
+
+  if (!query || totalNodes === 0) {
+    return {
+      context: '',
+      stats: { total_nodes: totalNodes, streams: 0, compile_ms: 0 },
+      scored: [],
+    };
+  }
+
+  const apiKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || googleApiKey;
+  if (!apiKey) throw new Error('No Gemini API key available for Flash streaming');
+
+  // ── Tier 0: Invariants (instant, no LLM) ──
+  const invariants = allNodes.filter(n => n.priority === 'absolute');
+  const tier0 = invariants.map(n => ({
+    slug: n.slug,
+    score: 100,
+    compressed: (n.body || n.content || '').slice(0, 500),
+    title: n.title,
+    category: n.category,
+    layer: 'conscious',
+    tier: 0,
+  }));
+
+  // ── Tier 1: FLOOD — every non-invariant node gets its own stream ──
+  const scorable = allNodes.filter(n => n.priority !== 'absolute');
+  const effectiveConcurrency = Math.min(concurrency, scorable.length);
+
+  logger.info('parallel-context', `FLOOD: ${scorable.length} streams × ${effectiveConcurrency} concurrent (${totalNodes} total, ${invariants.length} invariants pre-loaded)`);
+
+  const tier1 = await flood(
+    scorable,
+    (node) => scoreOne(query, node, apiKey),
+    effectiveConcurrency,
+  );
+
+  const floodMs = Date.now() - startTime;
+
+  // ── MERGE: combine tiers, rank by score ──
+  const allScored = [...tier0, ...tier1].sort((a, b) => b.score - a.score);
+  const filtered = allScored.filter(r => r.score >= minScore);
+
+  // ── PACK: assemble into token budget ──
+  let tokenCount = 0;
+  const included = [];
+
+  for (const item of filtered) {
+    const text = `- **${item.title || item.slug}** [${item.category}]: ${item.compressed}`;
+    const tokens = Math.ceil(text.length / CHARS_PER_TOKEN);
+    if (tokenCount + tokens > budgetTokens) break;
+    included.push({ ...item, text, tokens });
+    tokenCount += tokens;
+  }
+
+  // ── Format by category ──
+  const sections = new Map();
+  for (const item of included) {
+    const section = item.category || 'general';
+    if (!sections.has(section)) sections.set(section, []);
+    sections.get(section).push(item);
+  }
+
+  let context = '';
+  for (const [section, items] of sections) {
+    const label = section.charAt(0).toUpperCase() + section.slice(1);
+    context += `## ${label}\n\n`;
+    for (const item of items) {
+      context += `${item.text}\n`;
+    }
+    context += '\n';
+  }
+
+  const totalMs = Date.now() - startTime;
+  const rateLimited = allScored.filter(r => r.rateLimited).length;
+  const errors = allScored.filter(r => r.error).length;
+  const parseFails = allScored.filter(r => r.parseFail).length;
+
+  const stats = {
+    total_nodes: totalNodes,
+    streams: scorable.length,
+    invariants_preloaded: invariants.length,
+    concurrency: effectiveConcurrency,
+    flood_ms: floodMs,
+    compile_ms: totalMs,
+    scored: allScored.length,
+    above_threshold: filtered.length,
+    included: included.length,
+    tokens_used: tokenCount,
+    tokens_budget: budgetTokens,
+    rate_limited: rateLimited,
+    errors,
+    parse_fails: parseFails,
+    avg_score: included.length > 0 ? Math.round(included.reduce((s, i) => s + i.score, 0) / included.length) : 0,
+    throughput_nodes_per_sec: Math.round((scorable.length / (floodMs / 1000)) * 10) / 10,
+  };
+
+  logger.info('parallel-context', `DELIVERED: ${included.length} nodes (${tokenCount} tok) from ${totalNodes} total in ${totalMs}ms | ${stats.throughput_nodes_per_sec} nodes/s | ${rateLimited} rate-limited | ${errors} errors`);
+
+  return { context: context.trim(), stats, scored: allScored };
+}
+
+/**
+ * Quick health check — verify Flash API connectivity.
+ */
+export async function checkFlashHealth() {
+  const apiKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || googleApiKey;
+  if (!apiKey) return { status: 'unhealthy', error: 'No API key' };
+
+  const url = `${FLASH_API_URL}/${FLASH_MODEL}:generateContent?key=${apiKey}`;
+
+  try {
+    const start = Date.now();
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        contents: [{ parts: [{ text: 'Reply with exactly: OK' }] }],
+        generationConfig: { maxOutputTokens: 8, temperature: 0 },
+      }),
+    });
+
+    if (!response.ok) throw new Error(`API ${response.status}`);
+    const data = await response.json();
+    const text = data.candidates?.[0]?.content?.parts?.[0]?.text || '';
+    return { status: 'healthy', response: text.trim().slice(0, 20), latency_ms: Date.now() - start, model: FLASH_MODEL };
+  } catch (err) {
+    return { status: 'unhealthy', error: err.message, model: FLASH_MODEL };
+  }
+}

package/src/core/post-mortem.mjs

@@ -3,7 +3,8 @@ import path from 'path';
 import matter from 'gray-matter';
 import crypto from 'crypto';
 import { callLocalRuntime, loadRuntimeConfig } from './runtime.mjs';
-import { atomicWrite, loadNodes, safeStringify } from './vault.mjs';
+import { atomicWrite, safeStringify } from './vault.mjs';
+import { getNodes } from './vault-cache.mjs';
 import { logger } from './logger.mjs';
 import { brainDir } from './config.mjs';
 
@@ -115,7 +116,7 @@ export async function runPostMortem(sessionPath, { vaultDir, inboxDir, runtimeCo
   }
 
   // Load active rules for violation checking
-  const nodes = loadNodes(vaultDir);
+  const nodes = getNodes(vaultDir);
   const rules = nodes.filter(n =>
     n.status === 'active' &&
     n.priority === 'absolute' &&
@@ -324,7 +325,7 @@ export async function runComplianceAudit(sessionPath, { vaultDir, runtimeConfig
     return { compliant: true, violations: [], skipped: 'too-short' };
   }
 
-  const nodes = loadNodes(vaultDir);
+  const nodes = getNodes(vaultDir);
   const rules = nodes.filter(n =>
     n.status === 'active' &&
     (n.modality === 'must' || n.modality === 'must_not')

package/src/core/research-queue.mjs

@@ -13,7 +13,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import matter from 'gray-matter';
-import { loadNodes, writeNode, deleteNode } from './vault.mjs';
+import { writeNode, deleteNode } from './vault.mjs';
+import { getNodes } from './vault-cache.mjs';
 import { brainDir } from './config.mjs';
 
 const getBrainDir = () => {
@@ -235,7 +236,7 @@ export function loadQueue(overrideBrainDir) {
       let node = null;
       if (item.node_slug) {
         try {
-          const nodes = loadNodes(vaultDir);
+          const nodes = getNodes(vaultDir);
           node = nodes.find(n => n.slug === item.node_slug);
           if (!node) {
             const inboxFile = path.join(effectiveBrainDir, 'memory-inbox', 'pending', `${item.node_slug}.md`);
@@ -384,7 +385,7 @@ export function updateQueueItem(id, patch = {}, overrideBrainDir) {
   let node = null;
   if (item.node_slug) {
     try {
-      const nodes = loadNodes(vaultDir);
+      const nodes = getNodes(vaultDir);
       node = nodes.find(n => n.slug === item.node_slug);
       
       if (!node) {

package/src/core/runtime.mjs

@@ -43,7 +43,6 @@ export function findBinaryInPath(binaryName) {
 
 const DEFAULT_AGENTS = [
   { name: 'antigravity', binary: 'antigravity', flags: '--sandbox=false --yolo -o json', priority: 1, enabled: true, exec: 'flag' },
-  { name: 'gemini',      binary: 'gemini',      flags: '--sandbox=false --yolo -o json', priority: 2, enabled: true, exec: 'flag' },
   { name: 'claude',      binary: 'claude',      flags: '--output-format json --permission-mode bypassPermissions', priority: 3, enabled: true, exec: 'flag' },
   { name: 'codex',       binary: 'codex',       flags: '--full-auto --json', priority: 4, enabled: true, exec: 'subcommand' },
 ];
@@ -290,7 +289,8 @@ export async function callLocalRuntime(prompt, system, config) {
       maxBuffer: 10 * 1024 * 1024,
       env: {
         ...process.env,
-        GOOGLE_API_KEY: process.env.GOOGLE_API_KEY || googleApiKey,
+        GOOGLE_API_KEY: process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY || googleApiKey,
+        GEMINI_API_KEY: process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || googleApiKey,
         TAVILY_API_KEY: process.env.TAVILY_API_KEY || tavilyApiKey,
         BRAVE_API_KEY: process.env.BRAVE_API_KEY || braveApiKey,
         EXA_API_KEY: process.env.EXA_API_KEY || exaApiKey,