total-recall-brain 3.13.0 → 3.13.2

package/src/core/daemon-loop.mjs

@@ -1,26 +1,25 @@
 /**
- * Total Recall Active Intelligence Daemon Loop — v2 (Deterministic)
+ * Total Recall Active Intelligence Daemon Loop — v3
  *
- * A deterministic automation engine that runs crons, manages the research
- * queue, ingests sessions, and maintains the skill folder. No local LLM required.
+ * Durable worker over the open task envelope queue.
+ * - Dispatches via executor registry (fail-loud on unknown)
+ * - Does NOT invent idle work unless TR_IDLE_TASKS=1
+ * - Periodically runs dream (system memory consolidation)
+ * - Ingests sessions on boot; recompiles surfaces every N ticks
  *
- * Phases per tick:
- *   1. Ingest new IDE conversation logs
- *   2. Load/refresh task queue from disk
- *   3. Dispatch next task (deterministic only — no LLM tasks)
- *   4. Periodically recompile surfaces
- *
- * This script is spawned by `total-recall daemon start` and runs until killed.
+ * Spawned by `total-recall daemon start`.
  */
 
 import path from 'path';
 import fs from 'fs';
-import { createScheduler, updateTaskStatus } from './scheduler.mjs';
+import { createScheduler, updateTaskStatus, persistTaskToDisk } from './scheduler.mjs';
 import { scanAndIngest } from './session-watcher.mjs';
 import { logger } from './logger.mjs';
-import { updateQueueItem, loadQueue } from './research-queue.mjs';
-import { execFileSync } from "node:child_process";
+import { updateQueueItem } from './research-queue.mjs';
 import { agentDir, brainDir } from './config.mjs';
+import { runCrons } from './crons.mjs';
+import { dispatchTask as registryDispatch } from './task-executors.mjs';
+import { buildTaskEnvelope } from './task-envelope.mjs';
 
 const AGENT_DIR = agentDir;
 const BRAIN_DIR = brainDir;
@@ -35,84 +34,32 @@ const INSTRUCTIONS_FILE = path.join(BRAIN_DIR, 'INSTRUCTIONS.md');
 // How often to recompile surfaces (every N task ticks)
 const RECOMPILE_EVERY_N_TASKS = 20;
 
-// Pause between task iterations (ms)
+// Empty-queue sleep (ms) — longer when idle so we don't spin
 const TASK_SLEEP_MS = 10000;
-
-// ─── Tasks are no longer skipped to conserve resources. We use CLI agents! ───
+const EMPTY_SLEEP_MS = 30000;
+
+// Run a system dream every N empty ticks (memory consolidation without busy-work)
+const DREAM_EVERY_N_EMPTY = 20;
+
+function executorContext(runtimeConfig) {
+  return {
+    brainDir: BRAIN_DIR,
+    vaultDir: VAULT_DIR,
+    skillsDir: SKILLS_DIR,
+    derivedDir: DERIVED_DIR,
+    sessionsDir: SESSIONS_DIR,
+    queueDir: QUEUE_DIR,
+    conflictsDir: CONFLICTS_DIR,
+    instructionsFile: INSTRUCTIONS_FILE,
+    runtimeConfig,
+  };
+}
 
 async function dispatchTask(task) {
-  const category = task.category;
-
   try {
     const { loadRuntimeConfig } = await import('./runtime.mjs');
     const runtimeConfig = await loadRuntimeConfig();
-
-    // ─── Research & Proactive Tasks (LLM + Fetching) ───
-    if (task.slug.startsWith('research-') || category === 'proactive-research' || category === 'research-acquisition') {
-      if (task.slug.startsWith('staleness-check-')) {
-         const { runStalenessCheck } = await import('./clarity-rewriter.mjs');
-         const result = await runStalenessCheck(task.target, { vaultDir: VAULT_DIR, queueDir: QUEUE_DIR, runtimeConfig });
-         return { success: true, output: `Staleness check complete: ${result.verdict} (conf: ${result.confidence})` };
-      }
-      return await runResearchTask(task, runtimeConfig);
-    }
-    
-    // ─── System 2 Inference ───
-    if (category === 'system2-deliberation') {
-      const { runInferenceTask } = await import('./inference-engine.mjs');
-      const slugs = task.target ? task.target.split(',') : [];
-      const result = await runInferenceTask(slugs, {
-        vaultDir: VAULT_DIR,
-        inboxDir: path.join(BRAIN_DIR, 'memory-inbox', 'pending'),
-        runtimeConfig
-      });
-      return { success: true, output: `Inference complete: ${result.conclusions?.length || 0} conclusions` };
-    }
-
-    // ─── Cutoff Audit ───
-    if (category === 'cutoff-audit' || task.slug.startsWith('cutoff-audit-')) {
-      const { runCutoffAudit } = await import('./clarity-rewriter.mjs');
-      const result = await runCutoffAudit({ vaultDir: VAULT_DIR, queueDir: QUEUE_DIR, runtimeConfig });
-      return { success: true, output: `Cutoff audit complete: ${result.audited} audited, ${result.flagged} flagged, ${result.critical} critical` };
-    }
-
-    // ─── Self Diagnosis & Conscious Enforcement ───
-    if (category === 'conscious-enforcement' || task.slug.includes('self-diagnosis')) {
-      if (task.slug.startsWith('post-mortem-')) {
-        const { runPostMortem } = await import('./post-mortem.mjs');
-        const sessionPath = path.join(brainDir, 'sessions', task.target);
-        const result = await runPostMortem(sessionPath, { vaultDir: VAULT_DIR, inboxDir: path.join(BRAIN_DIR, 'memory-inbox', 'pending'), runtimeConfig });
-        return { success: true, output: `Post-mortem complete: ${result.nodesCreated || 0} nodes extracted` };
-      }
-
-      if (task.slug.includes('self-diagnosis')) {
-        const { runSelfDiagnosis } = await import('./fact-seeker.mjs');
-        await runSelfDiagnosis({ vaultDir: VAULT_DIR, runtimeConfig });
-        return { success: true, output: `Self-diagnosis complete` };
-      }
-      return { success: true, output: `Conscious enforcement handled` };
-    }
-
-    // ─── Memory Maintenance ───
-    if (category === 'memory-maintenance') {
-      if (task.slug.startsWith('clarity-review-')) {
-        const { runClarityReview } = await import('./clarity-rewriter.mjs');
-        const result = await runClarityReview(task.target, { vaultDir: VAULT_DIR, inboxDir: path.join(BRAIN_DIR, 'memory-inbox', 'pending'), runtimeConfig });
-        return { success: true, output: `Clarity review complete: rewrote=${result.rewrote}` };
-      }
-      if (task.slug.startsWith('memory-compaction-')) {
-        const { runMemoryCompaction } = await import('./fact-seeker.mjs');
-        const result = await runMemoryCompaction({ vaultDir: VAULT_DIR, inboxDir: path.join(BRAIN_DIR, 'memory-inbox', 'pending'), runtimeConfig });
-        return { success: true, output: `Memory compaction complete. Consolidated nodes: ${result.consolidatedCount || 0}` };
-      }
-      return await runMaintenanceTask(task);
-    }
-
-    logger.info({
-      subsystem: 'daemon-loop',
-      message: `Skipping unhandled task category: ${task.slug} [${category}]`,
-    });
-    return { success: true, output: 'Skipped unhandled task' };
+    return await registryDispatch(task, executorContext(runtimeConfig));
   } catch (err) {
     logger.info({
       subsystem: 'daemon-loop',
@@ -122,137 +69,6 @@ async function dispatchTask(task) {
   }
 }
 
-// ─── Research Engine (Web Fetching Only — No LLM Synthesis) ─────────────────────
-
-async function runResearchTask(task, runtimeConfig) {
-  const inboxDir = path.join(BRAIN_DIR, 'memory-inbox', 'pending');
-
-  // Phase 1: Knowledge acquisition
-  if (task.slug.startsWith('research-acquisition-') || task.category === 'proactive-research' || task.slug.includes('fact-seeker') || task.slug.includes('knowledge-acquisition')) {
-    const { runKnowledgeAcquisitionCycle } = await import('./fact-seeker.mjs');
-    const forceTopic = task.target || null;
-    const result = await runKnowledgeAcquisitionCycle({
-      vaultDir: VAULT_DIR,
-      inboxDir,
-      queueDir: QUEUE_DIR,
-      forceTopic,
-      skillsDir: SKILLS_DIR,
-      derivedDir: DERIVED_DIR,
-      instructionsFile: INSTRUCTIONS_FILE,
-      runtimeConfig
-    });
-    if (result.skipped) return { success: true, output: `Knowledge acquisition: ${result.skipped}` };
-    const surfaceNote = result.surfaced ? ' [SURFACED]' : ' [staged]';
-    return {
-      success: true,
-      output: `Researched "${result.topic}": ${result.sources?.join(', ')} | confidence: ${result.confidence || 'n/a'} | slug: ${result.factSlug}${surfaceNote}`,
-      factSlug: result.factSlug,
-    };
-  }
-
-  // Phase 2: Deliberation
-  if (task.slug.startsWith('research-deliberation-')) {
-    const { runResearchDeliberationCycle } = await import('./fact-seeker.mjs');
-    const result = await runResearchDeliberationCycle({
-      vaultDir: VAULT_DIR,
-      nodeSlug: task._node_slug || 'pending',
-      topic: task.title || task.target || 'Unknown Topic',
-      runtimeConfig
-    });
-    return { success: true, output: `Deliberation complete: ${result.slug || 'done'}` };
-  }
-
-  // Phase 3: Improvement
-  if (task.slug.startsWith('research-improvement-')) {
-    const { runResearchImprovementCycle } = await import('./fact-seeker.mjs');
-    const result = await runResearchImprovementCycle({
-      vaultDir: VAULT_DIR,
-      nodeSlug: task._node_slug || 'pending',
-      topic: task.title || task.target || 'Unknown Topic',
-      runtimeConfig
-    });
-    return { success: true, output: `Improvement complete` };
-  }
-
-  // Phase 4: Monitoring
-  if (task.slug.startsWith('research-monitoring-')) {
-    const { runResearchMonitoringCycle } = await import('./fact-seeker.mjs');
-    const result = await runResearchMonitoringCycle({
-      vaultDir: VAULT_DIR,
-      nodeSlug: task._node_slug || 'pending',
-      topic: task.title || task.target || 'Unknown Topic',
-      runtimeConfig,
-      skillsDir: SKILLS_DIR,
-      derivedDir: DERIVED_DIR,
-      instructionsFile: INSTRUCTIONS_FILE
-    });
-    return { success: true, output: `Monitoring complete` };
-  }
-
-  // Phase 5: Expansion
-  if (task.slug.startsWith('research-expansion-')) {
-    const { runResearchExpansionCycle } = await import('./fact-seeker.mjs');
-    const result = await runResearchExpansionCycle({
-      vaultDir: VAULT_DIR,
-      nodeSlug: task._node_slug || 'pending',
-      topic: task.title || task.target || 'Unknown Topic',
-      runtimeConfig
-    });
-    return { success: true, output: `Expansion complete` };
-  }
-
-  // Conclusion writer — validate pending drafts (deterministic checks)
-  if (task.slug.includes('validate')) {
-    const { runConclusionWriter } = await import('./conclusion-writer.mjs');
-    const result = await runConclusionWriter({
-      inboxDir,
-      vaultDir: VAULT_DIR,
-      quarantineDir: path.join(BRAIN_DIR, 'memory-inbox', 'quarantine'),
-    });
-    if (result.skipped) return { success: true, output: `Conclusion writer: ${result.skipped}` };
-    return {
-      success: true,
-      output: `Validated ${result.processed} drafts: ${result.approved} approved, ${result.rejected} rejected`,
-    };
-  }
-
-  return { success: true, output: 'No-op research task' };
-}
-
-// ─── Maintenance Engine (Deterministic Only) ────────────────────────────────────
-
-async function runMaintenanceTask(task) {
-  // Lease vacuuming — purely filesystem, no LLM
-  try {
-    const leasesDir = path.join(BRAIN_DIR, 'leases');
-    if (fs.existsSync(leasesDir)) {
-      const workspaces = fs.readdirSync(leasesDir);
-      for (const ws of workspaces) {
-        const wsDir = path.join(leasesDir, ws);
-        if (!fs.statSync(wsDir).isDirectory()) continue;
-        const files = fs.readdirSync(wsDir);
-        for (const file of files) {
-          if (!file.endsWith('.lease.json')) continue;
-          const fp = path.join(wsDir, file);
-          try {
-            const lease = JSON.parse(fs.readFileSync(fp, 'utf8'));
-            if (new Date(lease.expires_at) < new Date()) {
-              fs.unlinkSync(fp);
-              logger.info({ subsystem: 'daemon-loop', message: `Vacuumed expired lease: ${fp}` });
-            }
-          } catch {
-            try { fs.unlinkSync(fp); } catch {}
-          }
-        }
-      }
-    }
-  } catch (err) {
-    logger.info({ subsystem: 'daemon-loop', message: `Lease vacuuming failed: ${err.message}` });
-  }
-
-  return { success: true, output: 'Maintenance complete' };
-}
-
 // ─── Interrupt Writer ───────────────────────────────────────────────────────────
 
 /**
@@ -304,7 +120,7 @@ process.on('unhandledRejection', (reason, promise) => {
 async function main() {
   logger.info({
     subsystem: 'daemon-loop',
-    message: `Deterministic Daemon starting. Vault: ${VAULT_DIR}`,
+    message: `Daemon starting (open task envelope). Vault: ${VAULT_DIR} idle=${process.env.TR_IDLE_TASKS === '1' ? 'on' : 'off'}`,
   });
 
   // Initial session ingest
@@ -318,6 +134,8 @@ async function main() {
     logger.info({ subsystem: 'daemon-loop', message: `Boot ingest failed: ${err.message}` });
   }
 
+  let emptyTicks = 0;
+
   while (running) {
     try {
       // Periodically recompile surfaces
@@ -335,7 +153,6 @@ async function main() {
           logger.info({ subsystem: 'daemon-loop', message: `Surface recompile error: ${err.message}` });
         }
 
-        // Compact any append logs with accumulated dirty entries
         try {
           const { compactAppendLogs } = await import('./append-log.mjs');
           const compactResult = compactAppendLogs();
@@ -345,25 +162,63 @@ async function main() {
         } catch (err) {
           logger.info({ subsystem: 'daemon-loop', message: `Append log compaction error: ${err.message}` });
         }
+
+        try {
+          await runCrons({ vaultDir: VAULT_DIR, skillsDir: SKILLS_DIR, brainDir: BRAIN_DIR });
+        } catch (err) {
+          logger.error({ subsystem: 'daemon-loop', message: `Cron execution failed: ${err.message}` });
+        }
       }
 
-      // Refresh scheduler from disk on each iteration
       const scheduler = createScheduler({
         queueDir: QUEUE_DIR,
         vaultDir: VAULT_DIR,
         sessionsDir: SESSIONS_DIR,
       });
 
-      const { task, source } = scheduler.next();
+      let { task, source } = scheduler.next();
+
+      // Empty queue: optional system dream, then sleep (no busy-work invention)
+      if (!task) {
+        emptyTicks++;
+        if (emptyTicks % DREAM_EVERY_N_EMPTY === 0) {
+          const dreamEnv = buildTaskEnvelope({
+            intent: 'Scheduled system dream cycle',
+            slug: `dream-system-${Date.now().toString(36)}`,
+            kind: 'system',
+            executor: 'dream',
+            category: 'memory-maintenance',
+            priority: 70,
+            system: true,
+            origin: { agent: 'daemon', created_by: 'daemon-system' },
+            capabilities: ['vault:read', 'vault:write'],
+          });
+          task = persistTaskToDisk(dreamEnv, QUEUE_DIR);
+          source = 'system';
+          logger.info({
+            subsystem: 'daemon-loop',
+            message: `Empty queue → enqueue system dream (${emptyTicks} empty ticks)`,
+          });
+        } else {
+          logger.info({
+            subsystem: 'daemon-loop',
+            message: `Queue empty (tick ${emptyTicks}) — sleeping ${EMPTY_SLEEP_MS}ms`,
+          });
+          await new Promise((r) => setTimeout(r, EMPTY_SLEEP_MS));
+          continue;
+        }
+      } else {
+        emptyTicks = 0;
+      }
+
       taskCount++;
 
       logger.info({
         subsystem: 'daemon-loop',
-        message: `Task #${taskCount} [${source}] ${task.category}: ${task.slug}`,
+        message: `Task #${taskCount} [${source}] ${task.category || task.kind}: ${task.slug}`,
       });
 
-      // Mark in-progress
-      if ((source === 'explicit' || source === 'idle') && task._filepath) {
+      if ((source === 'explicit' || source === 'idle' || source === 'system') && task._filepath) {
         try {
           updateTaskStatus(task, 'in-progress', QUEUE_DIR);
         } catch (statusErr) {
@@ -386,22 +241,23 @@ async function main() {
 
       const result = await dispatchTask(task);
 
-      // Mark complete
-      if ((source === 'explicit' || source === 'idle') && task._filepath) {
+      if ((source === 'explicit' || source === 'idle' || source === 'system') && task._filepath) {
         try {
           if (result.skippedLLM) {
             updateTaskStatus(task, 'pending', QUEUE_DIR);
           } else if (result.success) {
             updateTaskStatus(task, 'completed', QUEUE_DIR);
           } else {
-            // Dead Letter Queue / Retry Logic
             task.retry_count = (task.retry_count || 0) + 1;
+            task.last_error = result.error || 'Unknown error';
             if (task.retry_count >= 3) {
-              logger.info({ subsystem: 'daemon-loop', message: `Task ${task.slug} failed 3 times. Moving to DLQ (failed).` });
-              updateTaskStatus(task, 'failed', QUEUE_DIR);
+              logger.info({ subsystem: 'daemon-loop', message: `Task ${task.slug} failed ${task.retry_count} times. Moving to DLQ (failed). Last error: ${task.last_error}` });
+              updateTaskStatus(task, 'failed', QUEUE_DIR, result.error || 'Unknown error');
             } else {
-              logger.info({ subsystem: 'daemon-loop', message: `Task ${task.slug} failed. Retry ${task.retry_count}/3. Requeueing.` });
-              updateTaskStatus(task, 'pending', QUEUE_DIR);
+              const backoffMs = Math.min(Math.pow(2, task.retry_count) * 1000, 60000);
+              logger.info({ subsystem: 'daemon-loop', message: `Task ${task.slug} failed. Retry ${task.retry_count}/3 after ${backoffMs}ms backoff. Error: ${task.last_error}` });
+              updateTaskStatus(task, 'pending', QUEUE_DIR, result.error || 'Unknown error');
+              await new Promise(r => setTimeout(r, backoffMs));
             }
           }
         } catch (statusErr) {
@@ -415,13 +271,11 @@ async function main() {
         try {
           const patch = {
             status: result.success ? 'pending' : 'failed',
-            // Append the output rather than completely overwriting the original rationale
             notes: result.output ? `Phase output: ${result.output}` : (result.error || null),
           };
           if (result.factSlug) {
             patch.node_slug = result.factSlug;
           }
-          // If the task was skipped because it requires an LLM, DO NOT complete the research project.
           if (result.skippedLLM) {
             patch.status = 'pending';
           } else if (result.success) {
@@ -460,11 +314,9 @@ async function main() {
         message: `Task #${taskCount} done: ${result.output || result.error || 'ok'}`,
       });
 
-      // Throttle to protect local resources
       await new Promise(r => setTimeout(r, TASK_SLEEP_MS));
 
     } catch (loopErr) {
-      // Individual task failures must NEVER kill the daemon.
       logger.info({
         subsystem: 'daemon-loop',
         message: `Task loop iteration crashed (non-fatal, continuing): ${loopErr.message}`,
@@ -473,7 +325,7 @@ async function main() {
     }
   }
 
-  logger.info({ subsystem: 'daemon-loop', message: 'Deterministic Daemon stopped.' });
+  logger.info({ subsystem: 'daemon-loop', message: 'Daemon stopped.' });
 }
 
 main().catch(async (err) => {

package/src/core/dream.mjs

@@ -1,6 +1,8 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import crypto from 'crypto';
+import matter from 'gray-matter';
 import { writeNode, atomicWrite, walkMd } from './vault.mjs';
 import { getNodes } from './vault-cache.mjs';
 import { logger } from './logger.mjs';
@@ -231,6 +233,139 @@ export function scanModifiedVault(vaultDir, sinceHours = 24) {
   });
 }
 
+/**
+ * Load REM candidates from memory-inbox (pending + capture drafts).
+ */
+export function loadCandidatesFromInbox(brainDirPath) {
+  const candidates = [];
+  const roots = [
+    path.join(brainDirPath, 'memory-inbox', 'pending'),
+    path.join(brainDirPath, 'memory-inbox', 'capture'),
+  ];
+
+  for (const dir of roots) {
+    if (!fs.existsSync(dir)) continue;
+    let files = [];
+    try {
+      files = fs.readdirSync(dir).filter((f) => f.endsWith('.md'));
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      try {
+        const raw = fs.readFileSync(path.join(dir, file), 'utf8');
+        const { data, content } = matter(raw);
+        if (!data || (!data.slug && !data.title && !String(content || '').trim())) continue;
+        const status = data.status || 'draft';
+        if (status === 'archived' || status === 'active') continue;
+        candidates.push({
+          ...data,
+          slug: data.slug || path.basename(file, '.md'),
+          category: data.category || 'facts',
+          title: data.title || data.slug || file,
+          status: 'draft',
+          confidence: data.confidence ?? 0.55,
+          importance: data.importance ?? 2,
+          evidence_count: data.evidence_count || data.source?.evidence_count || 1,
+          body: content,
+          _inbox_path: path.join(dir, file),
+        });
+      } catch (err) {
+        logger.warn('dream', `Inbox candidate skip ${file}: ${err.message}`);
+      }
+    }
+  }
+  return candidates;
+}
+
+/**
+ * Lightweight session → candidate extraction (deterministic heuristics).
+ * User lines that signal durable preferences/rules become draft candidates.
+ */
+export function loadCandidatesFromSessions(sessionsDir, { maxFiles = 8, maxCandidates = 20 } = {}) {
+  const candidates = [];
+  if (!fs.existsSync(sessionsDir)) return candidates;
+
+  const signal =
+    /\b(always|never|prefer|remember|must not|must|invariant|don't|do not|from now on)\b/i;
+
+  let files = [];
+  try {
+    files = fs
+      .readdirSync(sessionsDir)
+      .filter((f) => f.endsWith('.jsonl'))
+      .map((f) => ({
+        name: f,
+        mtime: fs.statSync(path.join(sessionsDir, f)).mtimeMs,
+      }))
+      .sort((a, b) => b.mtime - a.mtime)
+      .slice(0, maxFiles);
+  } catch {
+    return candidates;
+  }
+
+  for (const file of files) {
+    let lines;
+    try {
+      lines = fs.readFileSync(path.join(sessionsDir, file.name), 'utf8').split('\n').filter(Boolean);
+    } catch {
+      continue;
+    }
+    for (const line of lines) {
+      if (candidates.length >= maxCandidates) return candidates;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const content = entry.content || entry.text || '';
+      if (!content || content.length < 24 || content.length > 2000) continue;
+      if (entry.type === 'tool_call') continue;
+      const role = entry.role;
+      if (role && role !== 'user' && role !== 'human') continue;
+      if (!signal.test(content)) continue;
+
+      const hash = crypto.createHash('sha256').update(content).digest('hex').slice(0, 10);
+      candidates.push({
+        slug: `session-extract-${hash}`,
+        category: 'preferences',
+        title: content.slice(0, 80).replace(/\s+/g, ' '),
+        status: 'draft',
+        confidence: 0.55,
+        importance: 3,
+        evidence_count: 1,
+        modality: /must not|never|don't|do not/i.test(content) ? 'must_not' : 'should',
+        subject: 'user',
+        predicate: 'prefers',
+        object: 'behavior',
+        tags: ['session-extract', 'dream-rem'],
+        source: {
+          type: 'session',
+          session_id: path.basename(file.name, '.jsonl'),
+          evidence_count: 1,
+        },
+        body: content,
+      });
+    }
+  }
+  return candidates;
+}
+
+/**
+ * Collect all REM candidates (inbox + sessions). Dedupe by slug.
+ */
+export function collectRemCandidates({ brainDirPath, sessionsDir }) {
+  const bySlug = new Map();
+  for (const c of loadCandidatesFromInbox(brainDirPath)) {
+    bySlug.set(c.slug, c);
+  }
+  for (const c of loadCandidatesFromSessions(sessionsDir)) {
+    if (!bySlug.has(c.slug)) bySlug.set(c.slug, c);
+  }
+  return [...bySlug.values()];
+}
+
 /**
  * Phase 2: REM Sleep. Score nodes, check conflicts, promote/decay.
  */
@@ -285,17 +420,43 @@ export async function runDreamCycle({
   const modified = scanModifiedVault(vaultDir);
   logger.info('dream', `Modified vault files: ${modified.length}`);
 
-  // In a real system, we'd extract candidates from sessions. For now, we simulate.
-  const candidates = []; 
+  const candidates = collectRemCandidates({
+    brainDirPath: brainDir,
+    sessionsDir,
+  });
+  logger.info('dream', `REM candidates collected: ${candidates.length}`);
 
   logger.info('dream', 'PHASE 2 — REM (Pattern Recognition)');
   const existingNodes = getNodes(vaultDir);
-  
-  if (candidates.length > 0) {
-    const { promoted, conflicted } = evaluateCandidates(candidates, existingNodes, conflictsDir);
+  const existingSlugs = new Set(existingNodes.map((n) => n.slug));
+  // Skip candidates already active in vault
+  const fresh = candidates.filter((c) => !existingSlugs.has(c.slug) || c.status === 'draft');
+
+  let promotedCount = 0;
+  let conflictedCount = 0;
+  if (fresh.length > 0) {
+    const { promoted, conflicted } = evaluateCandidates(fresh, existingNodes, conflictsDir);
+    promotedCount = promoted.length;
+    conflictedCount = conflicted.length;
     logger.info('dream', `Promoted: ${promoted.length} | Conflicts: ${conflicted.length}`);
     for (const node of promoted) {
-      writeNode(node, vaultDir);
+      try {
+        // Strip inbox-only fields before vault write
+        const { body, _inbox_path, ...nodeFields } = node;
+        const toWrite = {
+          ...nodeFields,
+          status: 'active',
+          content: body || nodeFields.content,
+        };
+        await writeNode(toWrite, vaultDir);
+        if (_inbox_path && fs.existsSync(_inbox_path)) {
+          try {
+            fs.unlinkSync(_inbox_path);
+          } catch {}
+        }
+      } catch (err) {
+        logger.warn('dream', `Promote write failed for ${node.slug}: ${err.message}`);
+      }
     }
   } else {
     logger.info('dream', 'No new candidates to evaluate.');
@@ -312,9 +473,6 @@ export async function runDreamCycle({
   logger.info('dream', 'PHASE 4 — Lucid Dreaming (Optimizer Proposals)');
   let proposalCount = 0;
   try {
-    const proposalsDir = path.join(vaultDir, 'proposals');
-    if (!fs.existsSync(proposalsDir)) fs.mkdirSync(proposalsDir, { recursive: true });
-
     const cleanupProposals = await generateMemoryCleanupProposals(vaultDir);
     const staleProposals = await generateStaleKnowledgeRefreshProposals(vaultDir);
     const allProposals = [...cleanupProposals, ...staleProposals];
@@ -324,7 +482,8 @@ export async function runDreamCycle({
       for (const p of allProposals) {
         const passed = await evaluateProposalGate(p, null);
         logger.info('dream', `Proposal [${p.category}]: ${p.summary} -> ${passed ? 'ACCEPTED' : 'REJECTED'}`);
-        writeNode(p, proposalsDir);
+        // Contract write under vault root → proposals/<slug>.md
+        await writeNode(p, vaultDir);
         if (passed) proposalCount++;
       }
     } else {
@@ -339,6 +498,7 @@ export async function runDreamCycle({
     const existingNodes = getNodes(vaultDir);
     writeDailyNote(vaultDir, [
       `Modified vault files scanned: ${modified.length}`,
+      `REM candidates: ${candidates.length} (promoted ${promotedCount}, conflicted ${conflictedCount})`,
       `Active nodes: ${existingNodes.filter(n => n.status === 'active').length}`,
       `Proposals accepted: ${proposalCount}`,
     ]);