@ulrichc1/sparn 1.0.1 → 1.1.1

package/dist/index.js

@@ -1,6 +1,3 @@
-// src/adapters/claude-code.ts
-import { randomUUID as randomUUID2 } from "crypto";
-
 // src/core/btsp-embedder.ts
 import { randomUUID } from "crypto";
 
@@ -214,6 +211,82 @@ function createSparsePruner(config) {
   };
 }
 
+// src/utils/context-parser.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function parseClaudeCodeContext(context) {
+  const entries = [];
+  const now = Date.now();
+  const lines = context.split("\n");
+  let currentBlock = [];
+  let blockType = "other";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("User:") || trimmed.startsWith("Assistant:")) {
+      if (currentBlock.length > 0) {
+        entries.push(createEntry(currentBlock.join("\n"), blockType, now));
+        currentBlock = [];
+      }
+      blockType = "conversation";
+      currentBlock.push(line);
+    } else if (trimmed.includes("<function_calls>") || trimmed.includes("<invoke>") || trimmed.includes("<tool_use>")) {
+      if (currentBlock.length > 0) {
+        entries.push(createEntry(currentBlock.join("\n"), blockType, now));
+        currentBlock = [];
+      }
+      blockType = "tool";
+      currentBlock.push(line);
+    } else if (trimmed.includes("<function_results>") || trimmed.includes("</function_results>")) {
+      if (currentBlock.length > 0 && blockType !== "result") {
+        entries.push(createEntry(currentBlock.join("\n"), blockType, now));
+        currentBlock = [];
+      }
+      blockType = "result";
+      currentBlock.push(line);
+    } else if (currentBlock.length > 0) {
+      currentBlock.push(line);
+    } else if (trimmed.length > 0) {
+      currentBlock.push(line);
+      blockType = "other";
+    }
+  }
+  if (currentBlock.length > 0) {
+    entries.push(createEntry(currentBlock.join("\n"), blockType, now));
+  }
+  return entries.filter((e) => e.content.trim().length > 0);
+}
+function createEntry(content, type, baseTime) {
+  const tags = [type];
+  let initialScore = 0.5;
+  if (type === "conversation") initialScore = 0.8;
+  if (type === "tool") initialScore = 0.7;
+  if (type === "result") initialScore = 0.4;
+  return {
+    id: randomUUID2(),
+    content,
+    hash: hashContent(content),
+    timestamp: baseTime,
+    score: initialScore,
+    state: initialScore > 0.7 ? "active" : initialScore > 0.3 ? "ready" : "silent",
+    ttl: 24 * 3600,
+    // 24 hours default
+    accessCount: 0,
+    tags,
+    metadata: { type },
+    isBTSP: false
+  };
+}
+function parseGenericContext(context) {
+  const entries = [];
+  const now = Date.now();
+  const blocks = context.split(/\n\n+/);
+  for (const block of blocks) {
+    const trimmed = block.trim();
+    if (trimmed.length === 0) continue;
+    entries.push(createEntry(trimmed, "other", now));
+  }
+  return entries;
+}
+
 // src/adapters/claude-code.ts
 var CLAUDE_CODE_PROFILE = {
   // More aggressive pruning for tool results (they can be verbose)
@@ -333,68 +406,6 @@ function createClaudeCodeAdapter(memory, config) {
     optimize
   };
 }
-function parseClaudeCodeContext(context) {
-  const entries = [];
-  const now = Date.now();
-  const lines = context.split("\n");
-  let currentBlock = [];
-  let blockType = "other";
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith("User:") || trimmed.startsWith("Assistant:")) {
-      if (currentBlock.length > 0) {
-        entries.push(createEntry(currentBlock.join("\n"), blockType, now));
-        currentBlock = [];
-      }
-      blockType = "conversation";
-      currentBlock.push(line);
-    } else if (trimmed.includes("<function_calls>") || trimmed.includes("<invoke>") || trimmed.includes("<tool_use>")) {
-      if (currentBlock.length > 0) {
-        entries.push(createEntry(currentBlock.join("\n"), blockType, now));
-        currentBlock = [];
-      }
-      blockType = "tool";
-      currentBlock.push(line);
-    } else if (trimmed.includes("<function_results>") || trimmed.includes("</function_results>")) {
-      if (currentBlock.length > 0 && blockType !== "result") {
-        entries.push(createEntry(currentBlock.join("\n"), blockType, now));
-        currentBlock = [];
-      }
-      blockType = "result";
-      currentBlock.push(line);
-    } else if (currentBlock.length > 0) {
-      currentBlock.push(line);
-    } else if (trimmed.length > 0) {
-      currentBlock.push(line);
-      blockType = "other";
-    }
-  }
-  if (currentBlock.length > 0) {
-    entries.push(createEntry(currentBlock.join("\n"), blockType, now));
-  }
-  return entries.filter((e) => e.content.trim().length > 0);
-}
-function createEntry(content, type, baseTime) {
-  const tags = [type];
-  let initialScore = 0.5;
-  if (type === "conversation") initialScore = 0.8;
-  if (type === "tool") initialScore = 0.7;
-  if (type === "result") initialScore = 0.4;
-  return {
-    id: randomUUID2(),
-    content,
-    hash: hashContent(content),
-    timestamp: baseTime,
-    score: initialScore,
-    state: initialScore > 0.7 ? "active" : initialScore > 0.3 ? "ready" : "silent",
-    ttl: 24 * 3600,
-    // 24 hours default
-    accessCount: 0,
-    tags,
-    metadata: { type },
-    isBTSP: false
-  };
-}
 
 // src/adapters/generic.ts
 import { randomUUID as randomUUID3 } from "crypto";
@@ -472,6 +483,459 @@ function createGenericAdapter(memory, config) {
   };
 }
 
+// src/core/budget-pruner.ts
+function createBudgetPruner(config) {
+  const { tokenBudget, decay } = config;
+  const engramScorer = createEngramScorer(decay);
+  function tokenize(text) {
+    return text.toLowerCase().split(/\s+/).filter((word) => word.length > 0);
+  }
+  function calculateTF(term, tokens) {
+    const count = tokens.filter((t) => t === term).length;
+    return Math.sqrt(count);
+  }
+  function calculateIDF(term, allEntries) {
+    const totalDocs = allEntries.length;
+    const docsWithTerm = allEntries.filter((entry) => {
+      const tokens = tokenize(entry.content);
+      return tokens.includes(term);
+    }).length;
+    if (docsWithTerm === 0) return 0;
+    return Math.log(totalDocs / docsWithTerm);
+  }
+  function calculateTFIDF(entry, allEntries) {
+    const tokens = tokenize(entry.content);
+    if (tokens.length === 0) return 0;
+    const uniqueTerms = [...new Set(tokens)];
+    let totalScore = 0;
+    for (const term of uniqueTerms) {
+      const tf = calculateTF(term, tokens);
+      const idf = calculateIDF(term, allEntries);
+      totalScore += tf * idf;
+    }
+    return totalScore / tokens.length;
+  }
+  function getStateMultiplier(entry) {
+    if (entry.isBTSP) return 2;
+    switch (entry.state) {
+      case "active":
+        return 2;
+      case "ready":
+        return 1;
+      case "silent":
+        return 0.5;
+      default:
+        return 1;
+    }
+  }
+  function priorityScore(entry, allEntries) {
+    const tfidf = calculateTFIDF(entry, allEntries);
+    const currentScore = engramScorer.calculateScore(entry);
+    const engramDecay = 1 - currentScore;
+    const stateMultiplier = getStateMultiplier(entry);
+    return tfidf * (1 - engramDecay) * stateMultiplier;
+  }
+  function pruneToFit(entries, budget = tokenBudget) {
+    if (entries.length === 0) {
+      return {
+        kept: [],
+        removed: [],
+        originalTokens: 0,
+        prunedTokens: 0,
+        budgetUtilization: 0
+      };
+    }
+    const originalTokens = entries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    const btspEntries = entries.filter((e) => e.isBTSP);
+    const regularEntries = entries.filter((e) => !e.isBTSP);
+    const btspTokens = btspEntries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    const scored = regularEntries.map((entry) => ({
+      entry,
+      score: priorityScore(entry, entries),
+      tokens: estimateTokens(entry.content)
+    }));
+    scored.sort((a, b) => b.score - a.score);
+    const kept = [...btspEntries];
+    const removed = [];
+    let currentTokens = btspTokens;
+    for (const item of scored) {
+      if (currentTokens + item.tokens <= budget) {
+        kept.push(item.entry);
+        currentTokens += item.tokens;
+      } else {
+        removed.push(item.entry);
+      }
+    }
+    const budgetUtilization = budget > 0 ? currentTokens / budget : 0;
+    return {
+      kept,
+      removed,
+      originalTokens,
+      prunedTokens: currentTokens,
+      budgetUtilization
+    };
+  }
+  return {
+    pruneToFit,
+    priorityScore
+  };
+}
+function createBudgetPrunerFromConfig(realtimeConfig, decayConfig, statesConfig) {
+  return createBudgetPruner({
+    tokenBudget: realtimeConfig.tokenBudget,
+    decay: decayConfig,
+    states: statesConfig
+  });
+}
+
+// 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(config) {
+  const pruner = createBudgetPruner(config);
+  const { fullOptimizationInterval } = config;
+  let state = {
+    entryCache: /* @__PURE__ */ new Map(),
+    documentFrequency: /* @__PURE__ */ new Map(),
+    totalDocuments: 0,
+    updateCount: 0,
+    lastFullOptimization: Date.now()
+  };
+  function tokenize(text) {
+    return text.toLowerCase().split(/\s+/).filter((word) => word.length > 0);
+  }
+  function updateDocumentFrequency(entries, remove = false) {
+    for (const entry of entries) {
+      const tokens = tokenize(entry.content);
+      const uniqueTerms = [...new Set(tokens)];
+      for (const term of uniqueTerms) {
+        const current = state.documentFrequency.get(term) || 0;
+        const updated = remove ? Math.max(0, current - 1) : current + 1;
+        if (updated === 0) {
+          state.documentFrequency.delete(term);
+        } else {
+          state.documentFrequency.set(term, updated);
+        }
+      }
+    }
+    state.totalDocuments += remove ? -entries.length : entries.length;
+    state.totalDocuments = Math.max(0, state.totalDocuments);
+  }
+  function getCachedEntry(hash) {
+    const cached = state.entryCache.get(hash);
+    if (!cached) return null;
+    return cached.entry;
+  }
+  function cacheEntry(entry, score) {
+    state.entryCache.set(entry.hash, {
+      entry,
+      score,
+      timestamp: Date.now()
+    });
+  }
+  function optimizeIncremental(newEntries, budget) {
+    const startTime = Date.now();
+    state.updateCount++;
+    if (state.updateCount >= fullOptimizationInterval) {
+      const allEntries2 = Array.from(state.entryCache.values()).map((c) => c.entry);
+      return optimizeFull([...allEntries2, ...newEntries], budget);
+    }
+    const uncachedEntries = [];
+    const cachedEntries = [];
+    for (const entry of newEntries) {
+      const cached = getCachedEntry(entry.hash);
+      if (cached) {
+        cachedEntries.push(cached);
+      } else {
+        uncachedEntries.push(entry);
+      }
+    }
+    if (uncachedEntries.length > 0) {
+      updateDocumentFrequency(uncachedEntries, false);
+    }
+    const allEntries = [...cachedEntries, ...uncachedEntries];
+    for (const entry of uncachedEntries) {
+      const score = pruner.priorityScore(entry, allEntries);
+      cacheEntry(entry, score);
+    }
+    const currentEntries = Array.from(state.entryCache.values()).map((c) => c.entry);
+    const tokensBefore = currentEntries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    const result = pruner.pruneToFit(currentEntries, budget);
+    const tokensAfter = result.kept.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    for (const removed of result.removed) {
+      state.entryCache.delete(removed.hash);
+    }
+    if (result.removed.length > 0) {
+      updateDocumentFrequency(result.removed, true);
+    }
+    const duration = Date.now() - startTime;
+    const cacheHitRate = newEntries.length > 0 ? cachedEntries.length / newEntries.length : 0;
+    getMetrics().recordOptimization({
+      timestamp: Date.now(),
+      duration,
+      tokensBefore,
+      tokensAfter,
+      entriesProcessed: newEntries.length,
+      entriesKept: result.kept.length,
+      cacheHitRate,
+      memoryUsage: process.memoryUsage().heapUsed
+    });
+    return result;
+  }
+  function optimizeFull(allEntries, budget) {
+    const startTime = Date.now();
+    const tokensBefore = allEntries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    state.entryCache.clear();
+    state.documentFrequency.clear();
+    state.totalDocuments = 0;
+    state.updateCount = 0;
+    state.lastFullOptimization = Date.now();
+    updateDocumentFrequency(allEntries, false);
+    for (const entry of allEntries) {
+      const score = pruner.priorityScore(entry, allEntries);
+      cacheEntry(entry, score);
+    }
+    const result = pruner.pruneToFit(allEntries, budget);
+    const tokensAfter = result.kept.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    for (const removed of result.removed) {
+      state.entryCache.delete(removed.hash);
+    }
+    if (result.removed.length > 0) {
+      updateDocumentFrequency(result.removed, true);
+    }
+    const duration = Date.now() - startTime;
+    getMetrics().recordOptimization({
+      timestamp: Date.now(),
+      duration,
+      tokensBefore,
+      tokensAfter,
+      entriesProcessed: allEntries.length,
+      entriesKept: result.kept.length,
+      cacheHitRate: 0,
+      // Full optimization has no cache hits
+      memoryUsage: process.memoryUsage().heapUsed
+    });
+    return result;
+  }
+  function getState() {
+    return {
+      entryCache: new Map(state.entryCache),
+      documentFrequency: new Map(state.documentFrequency),
+      totalDocuments: state.totalDocuments,
+      updateCount: state.updateCount,
+      lastFullOptimization: state.lastFullOptimization
+    };
+  }
+  function restoreState(restoredState) {
+    state = {
+      entryCache: new Map(restoredState.entryCache),
+      documentFrequency: new Map(restoredState.documentFrequency),
+      totalDocuments: restoredState.totalDocuments,
+      updateCount: restoredState.updateCount,
+      lastFullOptimization: restoredState.lastFullOptimization
+    };
+  }
+  function reset() {
+    state = {
+      entryCache: /* @__PURE__ */ new Map(),
+      documentFrequency: /* @__PURE__ */ new Map(),
+      totalDocuments: 0,
+      updateCount: 0,
+      lastFullOptimization: Date.now()
+    };
+  }
+  function getStats() {
+    return {
+      cachedEntries: state.entryCache.size,
+      uniqueTerms: state.documentFrequency.size,
+      totalDocuments: state.totalDocuments,
+      updateCount: state.updateCount,
+      lastFullOptimization: state.lastFullOptimization
+    };
+  }
+  return {
+    optimizeIncremental,
+    optimizeFull,
+    getState,
+    restoreState,
+    reset,
+    getStats
+  };
+}
+
+// src/core/context-pipeline.ts
+function createContextPipeline(config) {
+  const optimizer = createIncrementalOptimizer(config);
+  const { windowSize, tokenBudget } = config;
+  let totalIngested = 0;
+  let evictedEntries = 0;
+  let currentEntries = [];
+  let budgetUtilization = 0;
+  function ingest(content, metadata = {}) {
+    const newEntries = parseClaudeCodeContext(content);
+    if (newEntries.length === 0) return 0;
+    const entriesWithMetadata = newEntries.map((entry) => ({
+      ...entry,
+      metadata: { ...entry.metadata, ...metadata }
+    }));
+    const result = optimizer.optimizeIncremental(entriesWithMetadata, tokenBudget);
+    totalIngested += newEntries.length;
+    evictedEntries += result.removed.length;
+    currentEntries = result.kept;
+    budgetUtilization = result.budgetUtilization;
+    if (currentEntries.length > windowSize) {
+      const sorted = [...currentEntries].sort((a, b) => b.timestamp - a.timestamp);
+      const toKeep = sorted.slice(0, windowSize);
+      const toRemove = sorted.slice(windowSize);
+      currentEntries = toKeep;
+      evictedEntries += toRemove.length;
+    }
+    return newEntries.length;
+  }
+  function getContext() {
+    const sorted = [...currentEntries].sort((a, b) => a.timestamp - b.timestamp);
+    return sorted.map((e) => e.content).join("\n\n");
+  }
+  function getEntries() {
+    return [...currentEntries].sort((a, b) => a.timestamp - b.timestamp);
+  }
+  function getStats() {
+    const optimizerStats = optimizer.getStats();
+    const currentTokens = currentEntries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    return {
+      totalIngested,
+      currentEntries: currentEntries.length,
+      currentTokens,
+      budgetUtilization,
+      evictedEntries,
+      optimizer: {
+        cachedEntries: optimizerStats.cachedEntries,
+        uniqueTerms: optimizerStats.uniqueTerms,
+        updateCount: optimizerStats.updateCount
+      }
+    };
+  }
+  function clear() {
+    totalIngested = 0;
+    evictedEntries = 0;
+    currentEntries = [];
+    budgetUtilization = 0;
+    optimizer.reset();
+  }
+  return {
+    ingest,
+    getContext,
+    getEntries,
+    getStats,
+    clear
+  };
+}
+
 // src/core/kv-memory.ts
 import { copyFileSync, existsSync } from "fs";
 import Database from "better-sqlite3";
@@ -841,6 +1305,408 @@ function createSleepCompressor() {
   };
 }
 
+// src/daemon/daemon-process.ts
+import { fork } from "child_process";
+import { existsSync as existsSync2, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function createDaemonCommand() {
+  function isDaemonRunning(pidFile) {
+    if (!existsSync2(pidFile)) {
+      return { running: false };
+    }
+    try {
+      const pidStr = readFileSync(pidFile, "utf-8").trim();
+      const pid = Number.parseInt(pidStr, 10);
+      if (Number.isNaN(pid)) {
+        return { running: false };
+      }
+      try {
+        process.kill(pid, 0);
+        return { running: true, pid };
+      } catch {
+        unlinkSync(pidFile);
+        return { running: false };
+      }
+    } catch {
+      return { running: false };
+    }
+  }
+  function writePidFile(pidFile, pid) {
+    const dir = dirname(pidFile);
+    if (!existsSync2(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(pidFile, String(pid), "utf-8");
+  }
+  function removePidFile(pidFile) {
+    if (existsSync2(pidFile)) {
+      unlinkSync(pidFile);
+    }
+  }
+  async function start(config) {
+    const { pidFile, logFile } = config.realtime;
+    const status2 = isDaemonRunning(pidFile);
+    if (status2.running) {
+      return {
+        success: false,
+        pid: status2.pid,
+        message: `Daemon already running (PID ${status2.pid})`,
+        error: "Already running"
+      };
+    }
+    try {
+      const __filename2 = fileURLToPath(import.meta.url);
+      const __dirname2 = dirname(__filename2);
+      const daemonPath = join(__dirname2, "index.js");
+      const child = fork(daemonPath, [], {
+        detached: true,
+        stdio: "ignore",
+        env: {
+          ...process.env,
+          SPARN_CONFIG: JSON.stringify(config),
+          SPARN_PID_FILE: pidFile,
+          SPARN_LOG_FILE: logFile
+        }
+      });
+      child.unref();
+      if (child.pid) {
+        writePidFile(pidFile, child.pid);
+        return {
+          success: true,
+          pid: child.pid,
+          message: `Daemon started (PID ${child.pid})`
+        };
+      }
+      return {
+        success: false,
+        message: "Failed to start daemon (no PID)",
+        error: "No PID"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: "Failed to start daemon",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async function stop(config) {
+    const { pidFile } = config.realtime;
+    const status2 = isDaemonRunning(pidFile);
+    if (!status2.running || !status2.pid) {
+      return {
+        success: true,
+        message: "Daemon not running"
+      };
+    }
+    try {
+      process.kill(status2.pid, "SIGTERM");
+      const maxWait = 5e3;
+      const interval = 100;
+      let waited = 0;
+      while (waited < maxWait) {
+        try {
+          process.kill(status2.pid, 0);
+          await new Promise((resolve) => setTimeout(resolve, interval));
+          waited += interval;
+        } catch {
+          removePidFile(pidFile);
+          return {
+            success: true,
+            message: `Daemon stopped (PID ${status2.pid})`
+          };
+        }
+      }
+      try {
+        process.kill(status2.pid, "SIGKILL");
+        removePidFile(pidFile);
+        return {
+          success: true,
+          message: `Daemon force killed (PID ${status2.pid})`
+        };
+      } catch {
+        removePidFile(pidFile);
+        return {
+          success: true,
+          message: `Daemon stopped (PID ${status2.pid})`
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        message: "Failed to stop daemon",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async function status(config) {
+    const { pidFile } = config.realtime;
+    const daemonStatus = isDaemonRunning(pidFile);
+    if (!daemonStatus.running || !daemonStatus.pid) {
+      return {
+        running: false,
+        message: "Daemon not running"
+      };
+    }
+    const metrics = getMetrics().getSnapshot();
+    return {
+      running: true,
+      pid: daemonStatus.pid,
+      uptime: metrics.daemon.uptime,
+      sessionsWatched: metrics.daemon.sessionsWatched,
+      tokensSaved: metrics.optimization.totalTokensSaved,
+      message: `Daemon running (PID ${daemonStatus.pid})`
+    };
+  }
+  return {
+    start,
+    stop,
+    status
+  };
+}
+
+// src/daemon/file-tracker.ts
+import { readFileSync as readFileSync2, statSync } from "fs";
+function createFileTracker() {
+  const positions = /* @__PURE__ */ new Map();
+  function readNewLines(filePath) {
+    try {
+      const stats = statSync(filePath);
+      const currentSize = stats.size;
+      const currentModified = stats.mtimeMs;
+      let pos = positions.get(filePath);
+      if (!pos) {
+        pos = {
+          path: filePath,
+          position: 0,
+          partialLine: "",
+          lastModified: currentModified,
+          lastSize: 0
+        };
+        positions.set(filePath, pos);
+      }
+      if (currentSize < pos.lastSize || currentSize === pos.position) {
+        if (currentSize < pos.lastSize) {
+          pos.position = 0;
+          pos.partialLine = "";
+        }
+        return [];
+      }
+      const buffer = Buffer.alloc(currentSize - pos.position);
+      const fd = readFileSync2(filePath);
+      fd.copy(buffer, 0, pos.position, currentSize);
+      const newContent = (pos.partialLine + buffer.toString("utf-8")).split("\n");
+      const partialLine = newContent.pop() || "";
+      pos.position = currentSize;
+      pos.partialLine = partialLine;
+      pos.lastModified = currentModified;
+      pos.lastSize = currentSize;
+      return newContent.filter((line) => line.trim().length > 0);
+    } catch (_error) {
+      return [];
+    }
+  }
+  function getPosition(filePath) {
+    return positions.get(filePath) || null;
+  }
+  function resetPosition(filePath) {
+    positions.delete(filePath);
+  }
+  function clearAll() {
+    positions.clear();
+  }
+  function getTrackedFiles() {
+    return Array.from(positions.keys());
+  }
+  return {
+    readNewLines,
+    getPosition,
+    resetPosition,
+    clearAll,
+    getTrackedFiles
+  };
+}
+
+// src/daemon/session-watcher.ts
+import { readdirSync, statSync as statSync2, watch } from "fs";
+import { homedir } from "os";
+import { dirname as dirname2, join as join2 } from "path";
+function createSessionWatcher(config) {
+  const { config: sparnConfig, onOptimize, onError } = config;
+  const { realtime, decay, states } = sparnConfig;
+  const pipelines = /* @__PURE__ */ new Map();
+  const fileTracker = createFileTracker();
+  const watchers = [];
+  const debounceTimers = /* @__PURE__ */ new Map();
+  function getProjectsDir() {
+    return join2(homedir(), ".claude", "projects");
+  }
+  function getSessionId(filePath) {
+    const filename = filePath.split(/[/\\]/).pop() || "";
+    return filename.replace(/\.jsonl$/, "");
+  }
+  function getPipeline(sessionId) {
+    let pipeline = pipelines.get(sessionId);
+    if (!pipeline) {
+      pipeline = createContextPipeline({
+        tokenBudget: realtime.tokenBudget,
+        decay,
+        states,
+        windowSize: realtime.windowSize,
+        fullOptimizationInterval: 50
+        // Full re-optimization every 50 incremental updates
+      });
+      pipelines.set(sessionId, pipeline);
+    }
+    return pipeline;
+  }
+  function handleFileChange(filePath) {
+    const existingTimer = debounceTimers.get(filePath);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+    }
+    const timer = setTimeout(() => {
+      try {
+        const newLines = fileTracker.readNewLines(filePath);
+        if (newLines.length === 0) return;
+        const content = newLines.join("\n");
+        const sessionId = getSessionId(filePath);
+        const pipeline = getPipeline(sessionId);
+        pipeline.ingest(content, { sessionId, filePath });
+        const stats = pipeline.getStats();
+        if (stats.currentTokens >= realtime.autoOptimizeThreshold) {
+          getMetrics().updateDaemon({
+            sessionsWatched: pipelines.size,
+            memoryUsage: process.memoryUsage().heapUsed
+          });
+          if (onOptimize) {
+            const sessionStats = computeSessionStats(sessionId, pipeline);
+            onOptimize(sessionId, sessionStats);
+          }
+        }
+      } catch (error) {
+        if (onError) {
+          onError(error instanceof Error ? error : new Error(String(error)));
+        }
+      } finally {
+        debounceTimers.delete(filePath);
+      }
+    }, realtime.debounceMs);
+    debounceTimers.set(filePath, timer);
+  }
+  function findJsonlFiles(dir) {
+    const files = [];
+    try {
+      const entries = readdirSync(dir);
+      for (const entry of entries) {
+        const fullPath = join2(dir, entry);
+        const stat = statSync2(fullPath);
+        if (stat.isDirectory()) {
+          files.push(...findJsonlFiles(fullPath));
+        } else if (entry.endsWith(".jsonl")) {
+          const matches = realtime.watchPatterns.some((pattern) => {
+            const regex = new RegExp(
+              pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/\\\\]*").replace(/\./g, "\\.")
+            );
+            return regex.test(fullPath);
+          });
+          if (matches) {
+            files.push(fullPath);
+          }
+        }
+      }
+    } catch (_error) {
+    }
+    return files;
+  }
+  function computeSessionStats(sessionId, pipeline) {
+    const stats = pipeline.getStats();
+    const entries = pipeline.getEntries();
+    const totalTokens = entries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    return {
+      sessionId,
+      totalTokens: stats.totalIngested,
+      optimizedTokens: stats.currentTokens,
+      reduction: totalTokens > 0 ? (totalTokens - stats.currentTokens) / totalTokens : 0,
+      entryCount: stats.currentEntries,
+      budgetUtilization: stats.budgetUtilization
+    };
+  }
+  async function start() {
+    const projectsDir = getProjectsDir();
+    const jsonlFiles = findJsonlFiles(projectsDir);
+    const watchedDirs = /* @__PURE__ */ new Set();
+    for (const file of jsonlFiles) {
+      const dir = dirname2(file);
+      if (!watchedDirs.has(dir)) {
+        const watcher = watch(dir, { recursive: false }, (_eventType, filename) => {
+          if (filename?.endsWith(".jsonl")) {
+            const fullPath = join2(dir, filename);
+            handleFileChange(fullPath);
+          }
+        });
+        watchers.push(watcher);
+        watchedDirs.add(dir);
+      }
+    }
+    const projectsWatcher = watch(projectsDir, { recursive: true }, (_eventType, filename) => {
+      if (filename?.endsWith(".jsonl")) {
+        const fullPath = join2(projectsDir, filename);
+        handleFileChange(fullPath);
+      }
+    });
+    watchers.push(projectsWatcher);
+    getMetrics().updateDaemon({
+      startTime: Date.now(),
+      sessionsWatched: jsonlFiles.length,
+      memoryUsage: process.memoryUsage().heapUsed
+    });
+  }
+  function stop() {
+    for (const watcher of watchers) {
+      watcher.close();
+    }
+    watchers.length = 0;
+    for (const timer of debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    debounceTimers.clear();
+    pipelines.clear();
+    fileTracker.clearAll();
+  }
+  function getStats() {
+    const stats = [];
+    for (const [sessionId, pipeline] of pipelines.entries()) {
+      stats.push(computeSessionStats(sessionId, pipeline));
+    }
+    return stats;
+  }
+  function getSessionStats(sessionId) {
+    const pipeline = pipelines.get(sessionId);
+    if (!pipeline) return null;
+    return computeSessionStats(sessionId, pipeline);
+  }
+  function optimizeSession(sessionId) {
+    const pipeline = pipelines.get(sessionId);
+    if (!pipeline) return;
+    const entries = pipeline.getEntries();
+    pipeline.clear();
+    pipeline.ingest(entries.map((e) => e.content).join("\n\n"));
+    if (onOptimize) {
+      const stats = computeSessionStats(sessionId, pipeline);
+      onOptimize(sessionId, stats);
+    }
+  }
+  return {
+    start,
+    stop,
+    getStats,
+    getSessionStats,
+    optimizeSession
+  };
+}
+
 // src/types/config.ts
 var DEFAULT_CONFIG = {
   pruning: {
@@ -861,7 +1727,17 @@ var DEFAULT_CONFIG = {
     sounds: false,
     verbose: false
   },
-  autoConsolidate: null
+  autoConsolidate: null,
+  realtime: {
+    tokenBudget: 5e4,
+    autoOptimizeThreshold: 8e4,
+    watchPatterns: ["**/*.jsonl"],
+    pidFile: ".sparn/daemon.pid",
+    logFile: ".sparn/daemon.log",
+    debounceMs: 5e3,
+    incremental: true,
+    windowSize: 500
+  }
 };
 
 // src/utils/logger.ts
@@ -886,15 +1762,25 @@ function createLogger(verbose = false) {
 export {
   DEFAULT_CONFIG,
   createBTSPEmbedder,
+  createBudgetPruner,
+  createBudgetPrunerFromConfig,
   createClaudeCodeAdapter,
   createConfidenceStates,
+  createContextPipeline,
+  createDaemonCommand,
   createEngramScorer,
+  createEntry,
+  createFileTracker,
   createGenericAdapter,
+  createIncrementalOptimizer,
   createKVMemory,
   createLogger,
+  createSessionWatcher,
   createSleepCompressor,
   createSparsePruner,
   estimateTokens,
-  hashContent
+  hashContent,
+  parseClaudeCodeContext,
+  parseGenericContext
 };
 //# sourceMappingURL=index.js.map