@ulrichc1/sparn 1.1.1 → 1.2.0

package/dist/daemon/index.js

@@ -1,5 +1,672 @@
 // src/daemon/index.ts
-import { appendFileSync, existsSync, unlinkSync } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync2, unlinkSync } from "fs";
+
+// src/core/kv-memory.ts
+import { copyFileSync, existsSync } from "fs";
+import Database from "better-sqlite3";
+function createBackup(dbPath) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${dbPath}.backup-${timestamp}`;
+  try {
+    copyFileSync(dbPath, backupPath);
+    console.log(`\u2713 Database backed up to: ${backupPath}`);
+    return backupPath;
+  } catch (error) {
+    console.error(`Warning: Could not create backup: ${error}`);
+    return "";
+  }
+}
+async function createKVMemory(dbPath) {
+  let db;
+  try {
+    db = new Database(dbPath);
+    const integrityCheck = db.pragma("quick_check", { simple: true });
+    if (integrityCheck !== "ok") {
+      console.error("\u26A0 Database corruption detected!");
+      if (existsSync(dbPath)) {
+        const backupPath = createBackup(dbPath);
+        if (backupPath) {
+          console.log(`Backup created at: ${backupPath}`);
+        }
+      }
+      console.log("Attempting database recovery...");
+      db.close();
+      db = new Database(dbPath);
+    }
+  } catch (error) {
+    console.error("\u26A0 Database error detected:", error);
+    if (existsSync(dbPath)) {
+      createBackup(dbPath);
+      console.log("Creating new database...");
+    }
+    db = new Database(dbPath);
+  }
+  db.pragma("journal_mode = WAL");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS entries_index (
+      id TEXT PRIMARY KEY NOT NULL,
+      hash TEXT UNIQUE NOT NULL,
+      timestamp INTEGER NOT NULL,
+      score REAL NOT NULL DEFAULT 0.0 CHECK(score >= 0.0 AND score <= 1.0),
+      ttl INTEGER NOT NULL CHECK(ttl >= 0),
+      state TEXT NOT NULL CHECK(state IN ('silent', 'ready', 'active')),
+      accessCount INTEGER NOT NULL DEFAULT 0 CHECK(accessCount >= 0),
+      isBTSP INTEGER NOT NULL DEFAULT 0 CHECK(isBTSP IN (0, 1)),
+      created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now'))
+    );
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS entries_value (
+      id TEXT PRIMARY KEY NOT NULL,
+      content TEXT NOT NULL,
+      tags TEXT,
+      metadata TEXT,
+      FOREIGN KEY (id) REFERENCES entries_index(id) ON DELETE CASCADE
+    );
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS optimization_stats (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
+      tokens_before INTEGER NOT NULL,
+      tokens_after INTEGER NOT NULL,
+      entries_pruned INTEGER NOT NULL,
+      duration_ms INTEGER NOT NULL
+    );
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_entries_state ON entries_index(state);
+    CREATE INDEX IF NOT EXISTS idx_entries_score ON entries_index(score DESC);
+    CREATE INDEX IF NOT EXISTS idx_entries_hash ON entries_index(hash);
+    CREATE INDEX IF NOT EXISTS idx_entries_timestamp ON entries_index(timestamp DESC);
+    CREATE INDEX IF NOT EXISTS idx_stats_timestamp ON optimization_stats(timestamp DESC);
+  `);
+  const putIndexStmt = db.prepare(`
+    INSERT OR REPLACE INTO entries_index
+    (id, hash, timestamp, score, ttl, state, accessCount, isBTSP)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const putValueStmt = db.prepare(`
+    INSERT OR REPLACE INTO entries_value
+    (id, content, tags, metadata)
+    VALUES (?, ?, ?, ?)
+  `);
+  const getStmt = db.prepare(`
+    SELECT
+      i.id, i.hash, i.timestamp, i.score, i.ttl, i.state, i.accessCount, i.isBTSP,
+      v.content, v.tags, v.metadata
+    FROM entries_index i
+    JOIN entries_value v ON i.id = v.id
+    WHERE i.id = ?
+  `);
+  const deleteIndexStmt = db.prepare("DELETE FROM entries_index WHERE id = ?");
+  const deleteValueStmt = db.prepare("DELETE FROM entries_value WHERE id = ?");
+  return {
+    async put(entry) {
+      const transaction = db.transaction(() => {
+        putIndexStmt.run(
+          entry.id,
+          entry.hash,
+          entry.timestamp,
+          entry.score,
+          entry.ttl,
+          entry.state,
+          entry.accessCount,
+          entry.isBTSP ? 1 : 0
+        );
+        putValueStmt.run(
+          entry.id,
+          entry.content,
+          JSON.stringify(entry.tags),
+          JSON.stringify(entry.metadata)
+        );
+      });
+      transaction();
+    },
+    async get(id) {
+      const row = getStmt.get(id);
+      if (!row) {
+        return null;
+      }
+      const r = row;
+      return {
+        id: r.id,
+        content: r.content,
+        hash: r.hash,
+        timestamp: r.timestamp,
+        score: r.score,
+        ttl: r.ttl,
+        state: r.state,
+        accessCount: r.accessCount,
+        tags: r.tags ? JSON.parse(r.tags) : [],
+        metadata: r.metadata ? JSON.parse(r.metadata) : {},
+        isBTSP: r.isBTSP === 1
+      };
+    },
+    async query(filters) {
+      let sql = `
+        SELECT
+          i.id, i.hash, i.timestamp, i.score, i.ttl, i.state, i.accessCount, i.isBTSP,
+          v.content, v.tags, v.metadata
+        FROM entries_index i
+        JOIN entries_value v ON i.id = v.id
+        WHERE 1=1
+      `;
+      const params = [];
+      if (filters.state) {
+        sql += " AND i.state = ?";
+        params.push(filters.state);
+      }
+      if (filters.minScore !== void 0) {
+        sql += " AND i.score >= ?";
+        params.push(filters.minScore);
+      }
+      if (filters.maxScore !== void 0) {
+        sql += " AND i.score <= ?";
+        params.push(filters.maxScore);
+      }
+      if (filters.isBTSP !== void 0) {
+        sql += " AND i.isBTSP = ?";
+        params.push(filters.isBTSP ? 1 : 0);
+      }
+      sql += " ORDER BY i.score DESC";
+      if (filters.limit) {
+        sql += " LIMIT ?";
+        params.push(filters.limit);
+      }
+      if (filters.offset) {
+        sql += " OFFSET ?";
+        params.push(filters.offset);
+      }
+      const stmt = db.prepare(sql);
+      const rows = stmt.all(...params);
+      return rows.map((row) => {
+        const r = row;
+        return {
+          id: r.id,
+          content: r.content,
+          hash: r.hash,
+          timestamp: r.timestamp,
+          score: r.score,
+          ttl: r.ttl,
+          state: r.state,
+          accessCount: r.accessCount,
+          tags: r.tags ? JSON.parse(r.tags) : [],
+          metadata: r.metadata ? JSON.parse(r.metadata) : {},
+          isBTSP: r.isBTSP === 1
+        };
+      });
+    },
+    async delete(id) {
+      const transaction = db.transaction(() => {
+        deleteIndexStmt.run(id);
+        deleteValueStmt.run(id);
+      });
+      transaction();
+    },
+    async list() {
+      const stmt = db.prepare("SELECT id FROM entries_index");
+      const rows = stmt.all();
+      return rows.map((r) => r.id);
+    },
+    async compact() {
+      const before = db.prepare("SELECT COUNT(*) as count FROM entries_index").get();
+      db.exec("DELETE FROM entries_index WHERE ttl <= 0");
+      db.exec("VACUUM");
+      const after = db.prepare("SELECT COUNT(*) as count FROM entries_index").get();
+      return before.count - after.count;
+    },
+    async close() {
+      db.close();
+    },
+    async recordOptimization(stats) {
+      const stmt = db.prepare(`
+        INSERT INTO optimization_stats (timestamp, tokens_before, tokens_after, entries_pruned, duration_ms)
+        VALUES (?, ?, ?, ?, ?)
+      `);
+      stmt.run(
+        stats.timestamp,
+        stats.tokens_before,
+        stats.tokens_after,
+        stats.entries_pruned,
+        stats.duration_ms
+      );
+    },
+    async getOptimizationStats() {
+      const stmt = db.prepare(`
+        SELECT id, timestamp, tokens_before, tokens_after, entries_pruned, duration_ms
+        FROM optimization_stats
+        ORDER BY timestamp DESC
+      `);
+      const rows = stmt.all();
+      return rows;
+    },
+    async clearOptimizationStats() {
+      db.exec("DELETE FROM optimization_stats");
+    }
+  };
+}
+
+// src/daemon/consolidation-scheduler.ts
+import { appendFileSync } from "fs";
+
+// src/core/engram-scorer.ts
+function createEngramScorer(config2) {
+  const { defaultTTL } = config2;
+  function calculateDecay(ageInSeconds, ttlInSeconds) {
+    if (ttlInSeconds === 0) return 1;
+    if (ageInSeconds <= 0) return 0;
+    const ratio = ageInSeconds / ttlInSeconds;
+    const decay = 1 - Math.exp(-ratio);
+    return Math.max(0, Math.min(1, decay));
+  }
+  function calculateScore(entry, currentTime = Date.now()) {
+    const ageInMilliseconds = currentTime - entry.timestamp;
+    const ageInSeconds = Math.max(0, ageInMilliseconds / 1e3);
+    const decay = calculateDecay(ageInSeconds, entry.ttl);
+    let score = entry.score * (1 - decay);
+    if (entry.accessCount > 0) {
+      const accessBonus = Math.log(entry.accessCount + 1) * 0.1;
+      score = Math.min(1, score + accessBonus);
+    }
+    if (entry.isBTSP) {
+      score = Math.max(score, 0.9);
+    }
+    return Math.max(0, Math.min(1, score));
+  }
+  function refreshTTL(entry) {
+    return {
+      ...entry,
+      ttl: defaultTTL * 3600,
+      // Convert hours to seconds
+      timestamp: Date.now()
+    };
+  }
+  return {
+    calculateScore,
+    refreshTTL,
+    calculateDecay
+  };
+}
+
+// src/core/sleep-compressor.ts
+function createSleepCompressor() {
+  const scorer = createEngramScorer({ defaultTTL: 24, decayThreshold: 0.95 });
+  function consolidate(entries) {
+    const startTime = Date.now();
+    const originalCount = entries.length;
+    const now = Date.now();
+    const nonDecayed = entries.filter((entry) => {
+      const ageInSeconds = (now - entry.timestamp) / 1e3;
+      const decay = scorer.calculateDecay(ageInSeconds, entry.ttl);
+      return decay < 0.95;
+    });
+    const decayedRemoved = originalCount - nonDecayed.length;
+    const duplicateGroups = findDuplicates(nonDecayed);
+    const merged = mergeDuplicates(duplicateGroups);
+    const duplicateIds = new Set(duplicateGroups.flatMap((g) => g.entries.map((e) => e.id)));
+    const nonDuplicates = nonDecayed.filter((e) => !duplicateIds.has(e.id));
+    const kept = [...merged, ...nonDuplicates];
+    const removed = entries.filter((e) => !kept.some((k) => k.id === e.id));
+    const duplicatesRemoved = duplicateGroups.reduce((sum, g) => sum + (g.entries.length - 1), 0);
+    return {
+      kept,
+      removed,
+      entriesBefore: originalCount,
+      entriesAfter: kept.length,
+      decayedRemoved,
+      duplicatesRemoved,
+      compressionRatio: originalCount > 0 ? kept.length / originalCount : 0,
+      durationMs: Date.now() - startTime
+    };
+  }
+  function findDuplicates(entries) {
+    const groups = [];
+    const processed = /* @__PURE__ */ new Set();
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (!entry || processed.has(entry.id)) continue;
+      const duplicates = entries.filter((e, idx) => idx !== i && e.hash === entry.hash);
+      if (duplicates.length > 0) {
+        const group = {
+          entries: [entry, ...duplicates],
+          similarity: 1
+          // Exact match
+        };
+        groups.push(group);
+        processed.add(entry.id);
+        for (const dup of duplicates) {
+          processed.add(dup.id);
+        }
+      }
+    }
+    for (let i = 0; i < entries.length; i++) {
+      const entryI = entries[i];
+      if (!entryI || processed.has(entryI.id)) continue;
+      for (let j = i + 1; j < entries.length; j++) {
+        const entryJ = entries[j];
+        if (!entryJ || processed.has(entryJ.id)) continue;
+        const similarity = cosineSimilarity(entryI.content, entryJ.content);
+        if (similarity >= 0.85) {
+          const group = {
+            entries: [entryI, entryJ],
+            similarity
+          };
+          groups.push(group);
+          processed.add(entryI.id);
+          processed.add(entryJ.id);
+          break;
+        }
+      }
+    }
+    return groups;
+  }
+  function mergeDuplicates(groups) {
+    const merged = [];
+    for (const group of groups) {
+      const sorted = [...group.entries].sort((a, b) => b.score - a.score);
+      const best = sorted[0];
+      if (!best) continue;
+      const totalAccessCount = group.entries.reduce((sum, e) => sum + e.accessCount, 0);
+      const allTags = new Set(group.entries.flatMap((e) => e.tags));
+      merged.push({
+        ...best,
+        accessCount: totalAccessCount,
+        tags: Array.from(allTags)
+      });
+    }
+    return merged;
+  }
+  function cosineSimilarity(text1, text2) {
+    const words1 = tokenize(text1);
+    const words2 = tokenize(text2);
+    const vocab = /* @__PURE__ */ new Set([...words1, ...words2]);
+    const vec1 = {};
+    const vec2 = {};
+    for (const word of vocab) {
+      vec1[word] = words1.filter((w) => w === word).length;
+      vec2[word] = words2.filter((w) => w === word).length;
+    }
+    let dotProduct = 0;
+    let mag1 = 0;
+    let mag2 = 0;
+    for (const word of vocab) {
+      const count1 = vec1[word] ?? 0;
+      const count2 = vec2[word] ?? 0;
+      dotProduct += count1 * count2;
+      mag1 += count1 * count1;
+      mag2 += count2 * count2;
+    }
+    mag1 = Math.sqrt(mag1);
+    mag2 = Math.sqrt(mag2);
+    if (mag1 === 0 || mag2 === 0) return 0;
+    return dotProduct / (mag1 * mag2);
+  }
+  function tokenize(text) {
+    return text.toLowerCase().split(/\s+/).filter((word) => word.length > 0);
+  }
+  return {
+    consolidate,
+    findDuplicates,
+    mergeDuplicates
+  };
+}
+
+// src/cli/commands/consolidate.ts
+async function consolidateCommand(options) {
+  const { memory: memory2 } = options;
+  const allIds = await memory2.list();
+  const allEntries = await Promise.all(
+    allIds.map(async (id) => {
+      const entry = await memory2.get(id);
+      return entry;
+    })
+  );
+  const entries = allEntries.filter((e) => e !== null);
+  const compressor = createSleepCompressor();
+  const result = compressor.consolidate(entries);
+  for (const removed of result.removed) {
+    await memory2.delete(removed.id);
+  }
+  for (const kept of result.kept) {
+    await memory2.put(kept);
+  }
+  await memory2.compact();
+  return {
+    entriesBefore: result.entriesBefore,
+    entriesAfter: result.entriesAfter,
+    decayedRemoved: result.decayedRemoved,
+    duplicatesRemoved: result.duplicatesRemoved,
+    compressionRatio: result.compressionRatio,
+    durationMs: result.durationMs,
+    vacuumCompleted: true
+  };
+}
+
+// src/core/metrics.ts
+function createMetricsCollector() {
+  const optimizations = [];
+  let daemonMetrics = {
+    startTime: Date.now(),
+    sessionsWatched: 0,
+    totalOptimizations: 0,
+    totalTokensSaved: 0,
+    averageLatency: 0,
+    memoryUsage: 0
+  };
+  let cacheHits = 0;
+  let cacheMisses = 0;
+  function recordOptimization(metric) {
+    optimizations.push(metric);
+    daemonMetrics.totalOptimizations++;
+    daemonMetrics.totalTokensSaved += metric.tokensBefore - metric.tokensAfter;
+    if (metric.cacheHitRate > 0) {
+      const hits = Math.round(metric.entriesProcessed * metric.cacheHitRate);
+      cacheHits += hits;
+      cacheMisses += metric.entriesProcessed - hits;
+    }
+    daemonMetrics.averageLatency = (daemonMetrics.averageLatency * (daemonMetrics.totalOptimizations - 1) + metric.duration) / daemonMetrics.totalOptimizations;
+    if (optimizations.length > 1e3) {
+      optimizations.shift();
+    }
+  }
+  function updateDaemon(metric) {
+    daemonMetrics = {
+      ...daemonMetrics,
+      ...metric
+    };
+  }
+  function calculatePercentile(values, percentile) {
+    if (values.length === 0) return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = Math.ceil(percentile / 100 * sorted.length) - 1;
+    return sorted[index] || 0;
+  }
+  function getSnapshot() {
+    const totalRuns = optimizations.length;
+    const totalDuration = optimizations.reduce((sum, m) => sum + m.duration, 0);
+    const totalTokensSaved = optimizations.reduce(
+      (sum, m) => sum + (m.tokensBefore - m.tokensAfter),
+      0
+    );
+    const totalTokensBefore = optimizations.reduce((sum, m) => sum + m.tokensBefore, 0);
+    const averageReduction = totalTokensBefore > 0 ? totalTokensSaved / totalTokensBefore : 0;
+    const durations = optimizations.map((m) => m.duration);
+    const totalCacheQueries = cacheHits + cacheMisses;
+    const hitRate = totalCacheQueries > 0 ? cacheHits / totalCacheQueries : 0;
+    return {
+      timestamp: Date.now(),
+      optimization: {
+        totalRuns,
+        totalDuration,
+        totalTokensSaved,
+        averageReduction,
+        p50Latency: calculatePercentile(durations, 50),
+        p95Latency: calculatePercentile(durations, 95),
+        p99Latency: calculatePercentile(durations, 99)
+      },
+      cache: {
+        hitRate,
+        totalHits: cacheHits,
+        totalMisses: cacheMisses,
+        size: optimizations.reduce((sum, m) => sum + m.entriesKept, 0)
+      },
+      daemon: {
+        uptime: Date.now() - daemonMetrics.startTime,
+        sessionsWatched: daemonMetrics.sessionsWatched,
+        memoryUsage: daemonMetrics.memoryUsage
+      }
+    };
+  }
+  function exportMetrics() {
+    return JSON.stringify(getSnapshot(), null, 2);
+  }
+  function reset() {
+    optimizations.length = 0;
+    cacheHits = 0;
+    cacheMisses = 0;
+    daemonMetrics = {
+      startTime: Date.now(),
+      sessionsWatched: 0,
+      totalOptimizations: 0,
+      totalTokensSaved: 0,
+      averageLatency: 0,
+      memoryUsage: 0
+    };
+  }
+  return {
+    recordOptimization,
+    updateDaemon,
+    getSnapshot,
+    export: exportMetrics,
+    reset
+  };
+}
+var globalMetrics = null;
+function getMetrics() {
+  if (!globalMetrics) {
+    globalMetrics = createMetricsCollector();
+  }
+  return globalMetrics;
+}
+
+// src/daemon/consolidation-scheduler.ts
+function createConsolidationScheduler(options) {
+  const { memory: memory2, config: config2, logFile: logFile2 } = options;
+  const intervalHours = config2.realtime.consolidationInterval;
+  let timerId = null;
+  let totalRuns = 0;
+  let lastRun = null;
+  let lastResult = null;
+  let nextRun = null;
+  function log2(message) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const logMessage = `[${timestamp}] [Consolidation] ${message}
+`;
+    const logPath = logFile2 || config2.realtime.logFile;
+    if (logPath) {
+      try {
+        appendFileSync(logPath, logMessage, "utf-8");
+      } catch {
+      }
+    }
+  }
+  async function runConsolidation() {
+    const startTime = Date.now();
+    log2("Starting scheduled consolidation");
+    try {
+      const result = await consolidateCommand({ memory: memory2 });
+      lastRun = startTime;
+      totalRuns++;
+      lastResult = {
+        timestamp: startTime,
+        entriesBefore: result.entriesBefore,
+        entriesAfter: result.entriesAfter,
+        decayedRemoved: result.decayedRemoved,
+        duplicatesRemoved: result.duplicatesRemoved,
+        compressionRatio: result.compressionRatio,
+        durationMs: result.durationMs,
+        success: true
+      };
+      log2(
+        `Consolidation completed: ${result.entriesBefore} -> ${result.entriesAfter} entries (${result.decayedRemoved} decayed, ${result.duplicatesRemoved} duplicates, ${Math.round(result.compressionRatio * 100)}% compression) in ${result.durationMs}ms`
+      );
+      const metrics = getMetrics();
+      metrics.recordOptimization({
+        timestamp: startTime,
+        duration: result.durationMs,
+        tokensBefore: result.entriesBefore * 100,
+        // Rough estimate
+        tokensAfter: result.entriesAfter * 100,
+        // Rough estimate
+        entriesProcessed: result.entriesBefore,
+        entriesKept: result.entriesAfter,
+        cacheHitRate: 0,
+        // N/A for consolidation
+        memoryUsage: process.memoryUsage().heapUsed
+      });
+    } catch (error) {
+      lastRun = startTime;
+      totalRuns++;
+      lastResult = {
+        timestamp: startTime,
+        entriesBefore: 0,
+        entriesAfter: 0,
+        decayedRemoved: 0,
+        duplicatesRemoved: 0,
+        compressionRatio: 0,
+        durationMs: Date.now() - startTime,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+      log2(`Consolidation failed: ${lastResult.error}`);
+    }
+    if (intervalHours !== null && intervalHours > 0) {
+      nextRun = Date.now() + intervalHours * 60 * 60 * 1e3;
+    }
+  }
+  function start() {
+    if (intervalHours === null || intervalHours <= 0) {
+      log2("Consolidation scheduler disabled (consolidationInterval not set)");
+      return;
+    }
+    if (timerId !== null) {
+      log2("Consolidation scheduler already running");
+      return;
+    }
+    const intervalMs = intervalHours * 60 * 60 * 1e3;
+    timerId = setInterval(() => {
+      void runConsolidation();
+    }, intervalMs);
+    nextRun = Date.now() + intervalMs;
+    log2(
+      `Consolidation scheduler started (interval: ${intervalHours}h, next run: ${new Date(nextRun).toISOString()})`
+    );
+  }
+  function stop() {
+    if (timerId !== null) {
+      clearInterval(timerId);
+      timerId = null;
+      nextRun = null;
+      log2("Consolidation scheduler stopped");
+    }
+  }
+  function getStatus() {
+    return {
+      running: timerId !== null,
+      intervalHours,
+      nextRun,
+      totalRuns,
+      lastRun,
+      lastResult
+    };
+  }
+  return {
+    start,
+    stop,
+    getStatus
+  };
+}
 
 // src/daemon/session-watcher.ts
 import { readdirSync, statSync as statSync2, watch } from "fs";
@@ -92,45 +759,6 @@ function estimateTokens(text) {
   return Math.max(wordEstimate, charEstimate);
 }
 
-// src/core/engram-scorer.ts
-function createEngramScorer(config2) {
-  const { defaultTTL } = config2;
-  function calculateDecay(ageInSeconds, ttlInSeconds) {
-    if (ttlInSeconds === 0) return 1;
-    if (ageInSeconds <= 0) return 0;
-    const ratio = ageInSeconds / ttlInSeconds;
-    const decay = 1 - Math.exp(-ratio);
-    return Math.max(0, Math.min(1, decay));
-  }
-  function calculateScore(entry, currentTime = Date.now()) {
-    const ageInMilliseconds = currentTime - entry.timestamp;
-    const ageInSeconds = Math.max(0, ageInMilliseconds / 1e3);
-    const decay = calculateDecay(ageInSeconds, entry.ttl);
-    let score = entry.score * (1 - decay);
-    if (entry.accessCount > 0) {
-      const accessBonus = Math.log(entry.accessCount + 1) * 0.1;
-      score = Math.min(1, score + accessBonus);
-    }
-    if (entry.isBTSP) {
-      score = Math.max(score, 0.9);
-    }
-    return Math.max(0, Math.min(1, score));
-  }
-  function refreshTTL(entry) {
-    return {
-      ...entry,
-      ttl: defaultTTL * 3600,
-      // Convert hours to seconds
-      timestamp: Date.now()
-    };
-  }
-  return {
-    calculateScore,
-    refreshTTL,
-    calculateDecay
-  };
-}
-
 // src/core/budget-pruner.ts
 function createBudgetPruner(config2) {
   const { tokenBudget, decay } = config2;
@@ -229,113 +857,6 @@ function createBudgetPruner(config2) {
   };
 }
 
-// src/core/metrics.ts
-function createMetricsCollector() {
-  const optimizations = [];
-  let daemonMetrics = {
-    startTime: Date.now(),
-    sessionsWatched: 0,
-    totalOptimizations: 0,
-    totalTokensSaved: 0,
-    averageLatency: 0,
-    memoryUsage: 0
-  };
-  let cacheHits = 0;
-  let cacheMisses = 0;
-  function recordOptimization(metric) {
-    optimizations.push(metric);
-    daemonMetrics.totalOptimizations++;
-    daemonMetrics.totalTokensSaved += metric.tokensBefore - metric.tokensAfter;
-    if (metric.cacheHitRate > 0) {
-      const hits = Math.round(metric.entriesProcessed * metric.cacheHitRate);
-      cacheHits += hits;
-      cacheMisses += metric.entriesProcessed - hits;
-    }
-    daemonMetrics.averageLatency = (daemonMetrics.averageLatency * (daemonMetrics.totalOptimizations - 1) + metric.duration) / daemonMetrics.totalOptimizations;
-    if (optimizations.length > 1e3) {
-      optimizations.shift();
-    }
-  }
-  function updateDaemon(metric) {
-    daemonMetrics = {
-      ...daemonMetrics,
-      ...metric
-    };
-  }
-  function calculatePercentile(values, percentile) {
-    if (values.length === 0) return 0;
-    const sorted = [...values].sort((a, b) => a - b);
-    const index = Math.ceil(percentile / 100 * sorted.length) - 1;
-    return sorted[index] || 0;
-  }
-  function getSnapshot() {
-    const totalRuns = optimizations.length;
-    const totalDuration = optimizations.reduce((sum, m) => sum + m.duration, 0);
-    const totalTokensSaved = optimizations.reduce(
-      (sum, m) => sum + (m.tokensBefore - m.tokensAfter),
-      0
-    );
-    const totalTokensBefore = optimizations.reduce((sum, m) => sum + m.tokensBefore, 0);
-    const averageReduction = totalTokensBefore > 0 ? totalTokensSaved / totalTokensBefore : 0;
-    const durations = optimizations.map((m) => m.duration);
-    const totalCacheQueries = cacheHits + cacheMisses;
-    const hitRate = totalCacheQueries > 0 ? cacheHits / totalCacheQueries : 0;
-    return {
-      timestamp: Date.now(),
-      optimization: {
-        totalRuns,
-        totalDuration,
-        totalTokensSaved,
-        averageReduction,
-        p50Latency: calculatePercentile(durations, 50),
-        p95Latency: calculatePercentile(durations, 95),
-        p99Latency: calculatePercentile(durations, 99)
-      },
-      cache: {
-        hitRate,
-        totalHits: cacheHits,
-        totalMisses: cacheMisses,
-        size: optimizations.reduce((sum, m) => sum + m.entriesKept, 0)
-      },
-      daemon: {
-        uptime: Date.now() - daemonMetrics.startTime,
-        sessionsWatched: daemonMetrics.sessionsWatched,
-        memoryUsage: daemonMetrics.memoryUsage
-      }
-    };
-  }
-  function exportMetrics() {
-    return JSON.stringify(getSnapshot(), null, 2);
-  }
-  function reset() {
-    optimizations.length = 0;
-    cacheHits = 0;
-    cacheMisses = 0;
-    daemonMetrics = {
-      startTime: Date.now(),
-      sessionsWatched: 0,
-      totalOptimizations: 0,
-      totalTokensSaved: 0,
-      averageLatency: 0,
-      memoryUsage: 0
-    };
-  }
-  return {
-    recordOptimization,
-    updateDaemon,
-    getSnapshot,
-    export: exportMetrics,
-    reset
-  };
-}
-var globalMetrics = null;
-function getMetrics() {
-  if (!globalMetrics) {
-    globalMetrics = createMetricsCollector();
-  }
-  return globalMetrics;
-}
-
 // src/core/incremental-optimizer.ts
 function createIncrementalOptimizer(config2) {
   const pruner = createBudgetPruner(config2);
@@ -830,20 +1351,26 @@ function log(message) {
 `;
   if (logFile) {
     try {
-      appendFileSync(logFile, logMessage, "utf-8");
+      appendFileSync2(logFile, logMessage, "utf-8");
     } catch {
     }
   }
 }
 function cleanup() {
   log("Daemon shutting down");
-  if (pidFile && existsSync(pidFile)) {
+  if (pidFile && existsSync2(pidFile)) {
     try {
       unlinkSync(pidFile);
     } catch {
     }
   }
+  if (scheduler) {
+    scheduler.stop();
+  }
   watcher.stop();
+  if (memory) {
+    void memory.close();
+  }
   process.exit(0);
 }
 process.on("SIGTERM", cleanup);
@@ -857,6 +1384,8 @@ process.on("unhandledRejection", (reason) => {
   log(`Unhandled rejection: ${reason}`);
   cleanup();
 });
+var memory = null;
+var scheduler = null;
 log("Daemon starting");
 var watcher = createSessionWatcher({
   config,
@@ -869,8 +1398,26 @@ var watcher = createSessionWatcher({
     log(`Error: ${error.message}`);
   }
 });
-watcher.start().then(() => {
+watcher.start().then(async () => {
   log("Daemon ready - watching Claude Code sessions");
+  if (config.realtime.consolidationInterval !== null && config.realtime.consolidationInterval > 0) {
+    try {
+      memory = await createKVMemory(".sparn/memory.db");
+      scheduler = createConsolidationScheduler({
+        memory,
+        config,
+        logFile
+      });
+      scheduler.start();
+      log(
+        `Consolidation scheduler started (interval: ${config.realtime.consolidationInterval}h)`
+      );
+    } catch (error) {
+      log(
+        `Failed to start consolidation scheduler: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
 }).catch((error) => {
   log(`Failed to start: ${error.message}`);
   cleanup();