feat(daemon): add memory monitor service with auto-capture/clear cycle

- DaemonMemoryService monitors RAM/heap at 30s intervals, triggers
  capture/clear when >90% threshold, writes signal file for hook
- memory-guard.sh hook notifies user on next prompt submit
- Wired into UnifiedDaemon lifecycle + CLI status display

Also fixes pre-existing bugs:
- fix(capture): use test:run instead of test to avoid vitest watch hang
- fix(clear): add getStack() shim to RefactoredFrameManager
- fix(clear): align saveLedger/restoreFromLedger with actual return types
- fix(clear): add missing dbManager stubs (getRecentTraces, etc.)

0.8.0

Author: StackMemory Bot (CLI)

.claude/hooks/memory-guard.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+# Memory Guard Hook
+# Checks for memory-clear signal file written by the daemon memory service.
+# Registered as a UserPromptSubmit hook in ~/.claude/hooks.json.
+
+SIGNAL_FILE="${PROJECT_ROOT:-.}/.stackmemory/.memory-clear-signal"
+
+if [ -f "$SIGNAL_FILE" ]; then
+  REASON=$(grep -o '"reason" *: *"[^"]*"' "$SIGNAL_FILE" | head -1 | sed 's/"reason" *: *"//;s/"$//')
+  RAM=$(grep -o '"ramPercent" *: *[0-9]*' "$SIGNAL_FILE" | head -1 | sed 's/"ramPercent" *: *//')
+  rm -f "$SIGNAL_FILE"
+  echo "MEMORY CRITICAL: ${REASON:-RAM/heap exceeded threshold}. Context has been captured."
+  echo "RAM: ${RAM:-?}% | Run /clear now, then stackmemory restore to continue."
+fi

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Project-scoped memory for AI coding tools. Durable context across sessions with MCP integration, frames, smart retrieval, Claude Code skills, and automatic hooks.",
   "engines": {
     "node": ">=20.0.0",

src/cli/commands/clear.ts

@@ -56,10 +56,13 @@ const clearCommand = new Command('clear')
         generateHandoff: () => Promise.resolve('Mock handoff'),
         getHandoffPath: () => 'mock.md',
       };
-      // Create a mock DatabaseManager for ClearSurvival
+      // Create a stub DatabaseManager for ClearSurvival
       const dbManager = {
         getCurrentSessionId: () => Promise.resolve(session.id),
         getSession: () => Promise.resolve(session),
+        getRecentTraces: () => Promise.resolve([]),
+        getRecentFrames: () => Promise.resolve([]),
+        addAnchor: () => Promise.resolve(),
       } as any;
       const clearSurvival = new ClearSurvival(
         frameManager,
@@ -147,19 +150,15 @@ async function saveLedger(
 ): Promise<void> {
   spinner.start('Saving continuity ledger...');
 
-  const ledgerPath = await clearSurvival.saveContinuityLedger();
+  const ledger = await clearSurvival.saveContinuityLedger();
 
   spinner.succeed(chalk.green('Continuity ledger saved'));
-  console.log(chalk.cyan(`Location: ${ledgerPath}`));
 
   // Show what was saved
-  const ledger = JSON.parse(await fs.readFile(ledgerPath, 'utf-8'));
   console.log('\nSaved:');
-  console.log(`  • ${ledger.activeFrames.length} active frames`);
-  console.log(`  • ${ledger.decisions.length} key decisions`);
-  console.log(
-    `  • ${ledger.context.importantTasks?.length || 0} important tasks`
-  );
+  console.log(`  • ${ledger.active_frame_stack?.length || 0} active frames`);
+  console.log(`  • ${ledger.key_decisions?.length || 0} key decisions`);
+  console.log(`  • ${ledger.active_tasks?.length || 0} active tasks`);
 }
 
 async function restoreFromLedger(
@@ -168,16 +167,12 @@ async function restoreFromLedger(
 ): Promise<void> {
   spinner.start('Restoring from continuity ledger...');
 
-  const result = await clearSurvival.restoreFromLedger();
+  const success = await clearSurvival.restoreFromLedger();
 
-  if (result.success) {
+  if (success) {
     spinner.succeed(chalk.green('Context restored from ledger'));
-    console.log('\nRestored:');
-    console.log(`  • ${result.restoredFrames} frames`);
-    console.log(`  • ${result.restoredDecisions} decisions`);
   } else {
     spinner.fail(chalk.red('Failed to restore from ledger'));
-    console.log(chalk.yellow(result.message));
   }
 }
 

src/cli/commands/daemon.ts

@@ -140,6 +140,7 @@ The daemon provides:
           if (newStatus.services.linear.enabled) services.push('linear');
           if (newStatus.services.maintenance?.enabled)
             services.push('maintenance');
+          if (newStatus.services.memory?.enabled) services.push('memory');
           if (newStatus.services.fileWatch.enabled) services.push('file-watch');
           if (services.length > 0) {
             console.log(chalk.gray(`Services: ${services.join(', ')}`));
@@ -327,6 +328,38 @@ The daemon provides:
         }
       }
 
+      // Memory service
+      const mem = status.services.memory;
+      if (mem) {
+        console.log(
+          `  Memory: ${mem.enabled ? chalk.green('Enabled') : chalk.gray('Disabled')}`
+        );
+        if (mem.enabled) {
+          console.log(
+            chalk.gray(`    Interval: ${config.memory.interval} min`)
+          );
+          console.log(
+            chalk.gray(
+              `    Thresholds: RAM ${config.memory.ramThreshold * 100}% / Heap ${config.memory.heapThreshold * 100}%`
+            )
+          );
+          if (mem.currentRamPercent !== undefined) {
+            console.log(
+              chalk.gray(
+                `    Current RAM: ${Math.round(mem.currentRamPercent * 100)}%`
+              )
+            );
+          }
+          if (mem.triggerCount) {
+            console.log(chalk.gray(`    Triggers: ${mem.triggerCount}`));
+          }
+          if (mem.lastTrigger) {
+            const ago = Math.round((Date.now() - mem.lastTrigger) / 1000 / 60);
+            console.log(chalk.gray(`    Last trigger: ${ago} min ago`));
+          }
+        }
+      }
+
       // File watch
       const fw = status.services.fileWatch;
       console.log(

src/core/context/refactored-frame-manager.ts

@@ -484,6 +484,14 @@ export class RefactoredFrameManager {
     return this.frameStack.getCurrentFrameId();
   }
 
+  /**
+   * Get stack as { frames } — compat shim for ClearSurvival
+   */
+  getStack(): { frames: Frame[] } {
+    const frames = this.frameDb.getFramesByProject(this.projectId);
+    return { frames };
+  }
+
   /**
    * Get stack depth
    */

src/core/session/enhanced-handoff.ts

@@ -499,7 +499,7 @@ export class EnhancedHandoffGenerator {
 
     // Check for failing tests
     try {
-      const testResult = execSync('npm test 2>&1 || true', {
+      const testResult = execSync('npm run test:run 2>&1 || true', {
         encoding: 'utf-8',
         cwd: this.projectRoot,
         timeout: 30000,

src/daemon/daemon-config.ts

@@ -46,6 +46,12 @@ export interface MaintenanceServiceConfig extends DaemonServiceConfig {
   coldTierRehydrateCacheMinutes?: number; // default: 30
 }
 
+export interface MemoryServiceConfig extends DaemonServiceConfig {
+  ramThreshold: number; // 0.9 = 90% system RAM
+  heapThreshold: number; // 0.9 = 90% Node.js heap
+  cooldownMinutes: number; // avoid repeated triggers
+}
+
 export interface FileWatchConfig extends DaemonServiceConfig {
   paths: string[];
   extensions: string[];
@@ -58,6 +64,7 @@ export interface DaemonConfig {
   context: ContextServiceConfig;
   linear: LinearServiceConfig;
   maintenance: MaintenanceServiceConfig;
+  memory: MemoryServiceConfig;
   fileWatch: FileWatchConfig;
   heartbeatInterval: number; // seconds
   inactivityTimeout: number; // minutes, 0 = disabled
@@ -86,6 +93,13 @@ export const DEFAULT_DAEMON_CONFIG: DaemonConfig = {
     embeddingBatchSize: 50,
     vacuumInterval: 168, // weekly
   },
+  memory: {
+    enabled: true,
+    interval: 0.5, // 30 seconds
+    ramThreshold: 0.9,
+    heapThreshold: 0.9,
+    cooldownMinutes: 10,
+  },
   fileWatch: {
     enabled: false, // Disabled by default
     interval: 0, // Not interval-based
@@ -118,6 +132,12 @@ export interface DaemonStatus {
       framesGarbageCollected?: number;
       lastGcRun?: number;
     };
+    memory: {
+      enabled: boolean;
+      lastTrigger?: number;
+      triggerCount?: number;
+      currentRamPercent?: number;
+    };
     fileWatch: { enabled: boolean; eventsProcessed?: number };
   };
   errors: string[];
@@ -181,6 +201,7 @@ export function loadDaemonConfig(): DaemonConfig {
         ...DEFAULT_DAEMON_CONFIG.maintenance,
         ...config.maintenance,
       },
+      memory: { ...DEFAULT_DAEMON_CONFIG.memory, ...config.memory },
       fileWatch: { ...DEFAULT_DAEMON_CONFIG.fileWatch, ...config.fileWatch },
     };
   } catch {
@@ -200,6 +221,7 @@ export function saveDaemonConfig(config: Partial<DaemonConfig>): void {
     context: { ...currentConfig.context, ...config.context },
     linear: { ...currentConfig.linear, ...config.linear },
     maintenance: { ...currentConfig.maintenance, ...config.maintenance },
+    memory: { ...currentConfig.memory, ...config.memory },
     fileWatch: { ...currentConfig.fileWatch, ...config.fileWatch },
   };
   writeFileSync(configFile, JSON.stringify(newConfig, null, 2));
@@ -217,6 +239,7 @@ export function readDaemonStatus(): DaemonStatus {
       context: { enabled: false },
       linear: { enabled: false },
       maintenance: { enabled: false },
+      memory: { enabled: false },
       fileWatch: { enabled: false },
     },
     errors: [],