total-recall-brain 3.1.0

package/src/core/emergency-alerts.mjs

@@ -0,0 +1,137 @@
+/**
+ * Total Recall Emergency Alert System
+ *
+ * When a catastrophic failure occurs (daemon crash, LLM unreachable, model missing),
+ * this module writes an alert to ~/.agent/alerts/emergency.md.
+ *
+ * The surface compiler reads this file and injects it at the TOP of every
+ * compiled instruction file (INSTRUCTIONS.md, AGENTS.md, GEMINI.md, etc.).
+ * This means EVERY agent in EVERY IDE will see the alert on their next turn
+ * and be compelled to notify the user immediately.
+ *
+ * Alert lifecycle:
+ *   1. writeEmergencyAlert(msg) — appends a timestamped alert
+ *   2. Surface compiler injects alerts at top of all instruction files
+ *   3. clearEmergencyAlerts() — called when the issue is resolved (e.g. daemon restarts healthy)
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { agentDir, brainDir } from './config.mjs';
+import { logger } from './logger.mjs';
+import { sendSystemNotification } from './notifications.mjs';
+
+const BRAIN_DIR = brainDir;
+const ALERTS_DIR = path.join(BRAIN_DIR, 'alerts');
+const EMERGENCY_FILE = path.join(ALERTS_DIR, 'emergency.md');
+
+// ─── Core Alert Operations ──────────────────────────────────────────────────────
+
+/**
+ * Write an emergency alert. Multiple alerts append to the same file.
+ * Each alert is timestamped and will be injected into all IDE instruction files.
+ *
+ * @param {string} message  Human-readable description of the catastrophic failure
+ */
+export function writeEmergencyAlert(message) {
+  if (!fs.existsSync(ALERTS_DIR)) {
+    fs.mkdirSync(ALERTS_DIR, { recursive: true });
+  }
+
+  const timestamp = new Date().toISOString();
+  const isNewFile = !fs.existsSync(EMERGENCY_FILE);
+
+  const lines = [];
+  if (isNewFile) {
+    lines.push(
+      '<!-- EMERGENCY ALERT -->',
+      '## 🚨 CRITICAL SYSTEM FAILURE — NOTIFY THE USER IMMEDIATELY',
+      '',
+      '> **You MUST tell the user about this alert before doing anything else.**',
+      '> Do NOT proceed with normal work until the user acknowledges this.',
+      '',
+    );
+  }
+
+  lines.push(`**[${timestamp}]** ${message}`, '');
+
+  fs.appendFileSync(EMERGENCY_FILE, lines.join('\n'));
+
+  logger.info({
+    subsystem: 'emergency-alerts',
+    message: `EMERGENCY ALERT WRITTEN: ${message}`,
+  });
+
+  // Fire macOS notification — this is the loudest channel
+  sendSystemNotification('🚨 TOTAL RECALL EMERGENCY', message, {
+    open: EMERGENCY_FILE,
+    sound: 'Sosumi',
+    subtitle: 'Critical Failure Detected',
+    group: 'total-recall-emergency'
+  }).catch((err) => {
+    logger.debug('emergency-alerts: notification failed', { err: err.message });
+  });
+}
+
+/**
+ * Clear all emergency alerts. Called when the system recovers
+ * (e.g. daemon starts successfully with a healthy LLM connection).
+ */
+export function clearEmergencyAlerts() {
+  if (fs.existsSync(EMERGENCY_FILE)) {
+    fs.unlinkSync(EMERGENCY_FILE);
+    logger.info({
+      subsystem: 'emergency-alerts',
+      message: 'Emergency alerts cleared — system recovered.',
+    });
+  }
+}
+
+/**
+ * Read current emergency alerts. Returns empty string if none.
+ * Used by the surface compiler to inject alerts at the top of instruction files.
+ */
+export function readEmergencyAlerts() {
+  if (!fs.existsSync(EMERGENCY_FILE)) return '';
+  try {
+    return fs.readFileSync(EMERGENCY_FILE, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+// ─── Startup Health Check ───────────────────────────────────────────────────────
+
+/**
+ * Run a basic health check on startup.
+ * Verifies filesystem structure is intact. No LLM checks — daemon is deterministic.
+ *
+ * @returns {{ healthy: boolean, issues: string[] }}
+ */
+export async function runStartupHealthCheck() {
+  const issues = [];
+
+  // Check: Does the vault directory exist?
+  const vaultDir = path.join(BRAIN_DIR, 'memory-vault');
+  if (!fs.existsSync(vaultDir)) {
+    issues.push(`Memory vault directory not found at ${vaultDir}. Run: npx total-recall init`);
+  }
+
+  // Check: Does the skills directory exist?
+  const skillsDir = path.join(agentDir, 'skills');
+  if (!fs.existsSync(skillsDir)) {
+    issues.push(`Skills directory not found at ${skillsDir}. Run: npx total-recall init`);
+  }
+
+  // Verdict
+  if (issues.length > 0) {
+    for (const issue of issues) {
+      writeEmergencyAlert(issue);
+    }
+    return { healthy: false, issues };
+  }
+
+  // All good — clear any stale alerts from previous failures
+  clearEmergencyAlerts();
+  return { healthy: true, issues: [] };
+}

package/src/core/evolution.mjs

@@ -0,0 +1,107 @@
+import { executeWithEscalation } from './sandbox.mjs';
+import { logger } from './logger.mjs';
+import { callLocalRuntime, loadRuntimeConfig } from './runtime.mjs';
+
+/**
+ * Total Recall Evolution Engine
+ * Implements SSSS Eval Workflows and Self-Evolution testing.
+ */
+
+export async function runSsssEvalWorkflow(skillTestScript, targetTask, configPath) {
+  logger.info('evolution', `Starting SSSS Eval Workflow for ${targetTask.slug}...`);
+
+  // Step 1: Run the skill test locally
+  const result = await executeWithEscalation(targetTask, skillTestScript, 1, configPath);
+
+  // Step 2: Frontier Judge Eval
+  logger.info('evolution', 'Consulting Frontier Judge for evaluation...');
+  const evalPrompt = `Evaluate the execution of the skill test.
+Target Task: ${targetTask.target}
+Output:
+${result.output}
+
+Provide a critique and generate a few-shot SSSS pattern node that captures the learning.`;
+  
+  const system = 'You are the Total Recall SSSS Evaluator. Your goal is to extract reusable patterns from execution outcomes.';
+  
+  try {
+    const config = loadRuntimeConfig(configPath);
+    const evaluation = await callLocalRuntime(evalPrompt, system, config);
+    
+    logger.info('evolution', `Evaluation Complete:\n${evaluation.slice(0, 200)}...`);
+    return { success: true, evaluation };
+  } catch (err) {
+    logger.error('evolution', `Eval failed: ${err.message}`);
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Self-Evolution Test
+ * Allows the kernel to analyze the current SSSS schema and propose upgrades.
+ */
+export async function proposeSchemaUpgrades(schemaPath, configPath) {
+  logger.info('evolution', 'Initiating Self-Evolution Schema Test...');
+
+  let currentSchema = '';
+  try {
+    const fs = await import('fs');
+    currentSchema = fs.readFileSync(schemaPath, 'utf8');
+  } catch (err) {
+    throw new Error(`Failed to read schema: ${err.message}`);
+  }
+
+  const prompt = `Review the current Total Recall SSSS Zod Schemas below:
+${currentSchema}
+
+Propose any backwards-compatible schema upgrades or new fields that would enhance memory routing, confidence decay, or pattern detection.
+Return ONLY valid JavaScript code exporting the updated Zod schemas.`;
+
+  const system = 'You are the Total Recall Kernel Architect. You write flawless Zod schemas in pure JS/ESM.';
+
+  try {
+    const config = loadRuntimeConfig(configPath);
+    const upgrade = await callLocalRuntime(prompt, system, config);
+    
+    logger.info('evolution', 'Schema Upgrade Proposed.');
+    return { success: true, proposedSchema: upgrade };
+  } catch (err) {
+    logger.error('evolution', `Schema upgrade test failed: ${err.message}`);
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Apply Schema Upgrade
+ * Tests the proposed schema by validating it dynamically, and applies it if successful.
+ */
+export async function applySchemaUpgrade(proposedSchemaCode, schemaPath) {
+  logger.info('evolution', 'Testing and Applying Schema Upgrade...');
+  const fs = await import('fs');
+  const path = await import('path');
+  const os = await import('os');
+  const tempFile = path.join(os.tmpdir(), `test-schema-${Date.now()}.mjs`);
+  
+  try {
+    fs.writeFileSync(tempFile, proposedSchemaCode);
+    
+    // Test: dynamically import it
+    const newSchema = await import(tempFile);
+    if (!newSchema.MemoryNodeSchema || !newSchema.TaskSchema) {
+      throw new Error("Proposed schema is missing required exported schemas.");
+    }
+    
+    logger.info('evolution', 'Schema test passed. Applying upgrade...');
+    fs.writeFileSync(schemaPath, proposedSchemaCode);
+    logger.info('evolution', 'Schema upgrade applied successfully.');
+    return { success: true };
+  } catch (err) {
+    logger.error('evolution', `Schema apply failed: ${err.message}`);
+    return { success: false, error: err.message };
+  } finally {
+    if (fs.existsSync(tempFile)) {
+      fs.unlinkSync(tempFile);
+    }
+  }
+}
+