@ulrichc1/sparn 1.2.2 → 1.4.0

package/dist/cli/index.js

@@ -18,6 +18,34 @@ var init_esm_shims = __esm({
   }
 });
 
+// src/utils/tokenizer.ts
+import { encode } from "gpt-tokenizer";
+function setPreciseTokenCounting(enabled) {
+  usePrecise = enabled;
+}
+function estimateTokens(text) {
+  if (!text || text.length === 0) {
+    return 0;
+  }
+  if (usePrecise) {
+    return encode(text).length;
+  }
+  const words = text.split(/\s+/).filter((w) => w.length > 0);
+  const wordCount = words.length;
+  const charCount = text.length;
+  const charEstimate = Math.ceil(charCount / 4);
+  const wordEstimate = Math.ceil(wordCount * 0.75);
+  return Math.max(wordEstimate, charEstimate);
+}
+var usePrecise;
+var init_tokenizer = __esm({
+  "src/utils/tokenizer.ts"() {
+    "use strict";
+    init_esm_shims();
+    usePrecise = false;
+  }
+});
+
 // src/cli/ui/colors.ts
 var colors_exports = {};
 __export(colors_exports, {
@@ -64,7 +92,7 @@ var init_banner = __esm({
  ___/ / ____/ __ _/ _, _/ /|  /
 /____/_/   /_/ |_/_/ |_/_/ |_/
 `;
-    TAGLINE = "\u{1F9E0} Neuroscience-inspired context optimization";
+    TAGLINE = "\u{1F9E0} Context optimization for AI coding agents";
   }
 });
 
@@ -73,7 +101,7 @@ var kv_memory_exports = {};
 __export(kv_memory_exports, {
   createKVMemory: () => createKVMemory
 });
-import { copyFileSync, existsSync } from "fs";
+import { copyFileSync, existsSync as existsSync2 } from "fs";
 import Database from "better-sqlite3";
 function createBackup(dbPath) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -94,25 +122,26 @@ async function createKVMemory(dbPath) {
     const integrityCheck = db.pragma("quick_check", { simple: true });
     if (integrityCheck !== "ok") {
       console.error("\u26A0 Database corruption detected!");
-      if (existsSync(dbPath)) {
+      db.close();
+      if (existsSync2(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)) {
+    if (existsSync2(dbPath)) {
       createBackup(dbPath);
       console.log("Creating new database...");
     }
     db = new Database(dbPath);
   }
   db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
   db.exec(`
     CREATE TABLE IF NOT EXISTS entries_index (
       id TEXT PRIMARY KEY NOT NULL,
@@ -152,6 +181,36 @@ async function createKVMemory(dbPath) {
     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);
   `);
+  db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS entries_fts USING fts5(id, content, tokenize='porter');
+  `);
+  db.exec(`
+    CREATE TRIGGER IF NOT EXISTS entries_fts_insert
+    AFTER INSERT ON entries_value
+    BEGIN
+      INSERT OR REPLACE INTO entries_fts(id, content) VALUES (NEW.id, NEW.content);
+    END;
+  `);
+  db.exec(`
+    CREATE TRIGGER IF NOT EXISTS entries_fts_delete
+    AFTER DELETE ON entries_value
+    BEGIN
+      DELETE FROM entries_fts WHERE id = OLD.id;
+    END;
+  `);
+  db.exec(`
+    CREATE TRIGGER IF NOT EXISTS entries_fts_update
+    AFTER UPDATE ON entries_value
+    BEGIN
+      DELETE FROM entries_fts WHERE id = OLD.id;
+      INSERT INTO entries_fts(id, content) VALUES (NEW.id, NEW.content);
+    END;
+  `);
+  db.exec(`
+    INSERT OR IGNORE INTO entries_fts(id, content)
+    SELECT id, content FROM entries_value
+    WHERE id NOT IN (SELECT id FROM entries_fts);
+  `);
   const putIndexStmt = db.prepare(`
     INSERT OR REPLACE INTO entries_index
     (id, hash, timestamp, score, ttl, state, accessCount, isBTSP)
@@ -240,14 +299,20 @@ async function createKVMemory(dbPath) {
         sql += " AND i.isBTSP = ?";
         params.push(filters.isBTSP ? 1 : 0);
       }
+      if (filters.tags && filters.tags.length > 0) {
+        for (const tag of filters.tags) {
+          sql += " AND v.tags LIKE ?";
+          params.push(`%"${tag}"%`);
+        }
+      }
       sql += " ORDER BY i.score DESC";
       if (filters.limit) {
         sql += " LIMIT ?";
         params.push(filters.limit);
-      }
-      if (filters.offset) {
-        sql += " OFFSET ?";
-        params.push(filters.offset);
+        if (filters.offset) {
+          sql += " OFFSET ?";
+          params.push(filters.offset);
+        }
       }
       const stmt = db.prepare(sql);
       const rows = stmt.all(...params);
@@ -282,7 +347,22 @@ async function createKVMemory(dbPath) {
     },
     async compact() {
       const before = db.prepare("SELECT COUNT(*) as count FROM entries_index").get();
-      db.exec("DELETE FROM entries_index WHERE ttl <= 0");
+      const now = Date.now();
+      db.prepare("DELETE FROM entries_index WHERE isBTSP = 0 AND (timestamp + ttl * 1000) < ?").run(
+        now
+      );
+      db.exec("DELETE FROM entries_index WHERE isBTSP = 0 AND ttl <= 0");
+      const candidates = db.prepare("SELECT id, timestamp, ttl FROM entries_index WHERE isBTSP = 0").all();
+      for (const row of candidates) {
+        const ageSeconds = Math.max(0, (now - row.timestamp) / 1e3);
+        const ttlSeconds = row.ttl;
+        if (ttlSeconds <= 0) continue;
+        const decay = 1 - Math.exp(-ageSeconds / ttlSeconds);
+        if (decay >= 0.95) {
+          db.prepare("DELETE FROM entries_index WHERE id = ?").run(row.id);
+        }
+      }
+      db.exec("DELETE FROM entries_value WHERE id NOT IN (SELECT id FROM entries_index)");
       db.exec("VACUUM");
       const after = db.prepare("SELECT COUNT(*) as count FROM entries_index").get();
       return before.count - after.count;
@@ -302,6 +382,9 @@ async function createKVMemory(dbPath) {
         stats.entries_pruned,
         stats.duration_ms
       );
+      db.prepare(
+        "DELETE FROM optimization_stats WHERE id NOT IN (SELECT id FROM optimization_stats ORDER BY timestamp DESC LIMIT 1000)"
+      ).run();
     },
     async getOptimizationStats() {
       const stmt = db.prepare(`
@@ -314,6 +397,44 @@ async function createKVMemory(dbPath) {
     },
     async clearOptimizationStats() {
       db.exec("DELETE FROM optimization_stats");
+    },
+    async searchFTS(query, limit = 10) {
+      if (!query || query.trim().length === 0) return [];
+      const sanitized = query.replace(/[{}()[\]"':*^~]/g, " ").trim();
+      if (sanitized.length === 0) return [];
+      const stmt = db.prepare(`
+        SELECT
+          f.id, f.content, rank,
+          i.hash, i.timestamp, i.score, i.ttl, i.state, i.accessCount, i.isBTSP,
+          v.tags, v.metadata
+        FROM entries_fts f
+        JOIN entries_index i ON f.id = i.id
+        JOIN entries_value v ON f.id = v.id
+        WHERE entries_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `);
+      try {
+        const rows = stmt.all(sanitized, limit);
+        return rows.map((r) => ({
+          entry: {
+            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
+          },
+          rank: r.rank
+        }));
+      } catch {
+        return [];
+      }
     }
   };
 }
@@ -373,26 +494,25 @@ __export(init_exports, {
 });
 import { readFileSync } from "fs";
 import { access, mkdir, writeFile } from "fs/promises";
-import { dirname, join } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 import { dump as dumpYAML } from "js-yaml";
 function getVersion() {
   try {
-    const pkg = JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8"));
+    const __filename2 = fileURLToPath3(import.meta.url);
+    const __dirname2 = dirname2(__filename2);
+    const pkg = JSON.parse(readFileSync(join2(__dirname2, "../../package.json"), "utf-8"));
     return pkg.version;
   } catch {
-    const __filename2 = fileURLToPath2(import.meta.url);
-    const __dirname2 = dirname(__filename2);
-    const pkg = JSON.parse(readFileSync(join(__dirname2, "../../package.json"), "utf-8"));
-    return pkg.version;
+    return "1.4.0";
   }
 }
 async function initCommand(options = {}) {
   const startTime = Date.now();
   const cwd = options.cwd || process.cwd();
-  const sparnDir = join(cwd, ".sparn");
-  const configPath = join(sparnDir, "config.yaml");
-  const dbPath = join(sparnDir, "memory.db");
+  const sparnDir = join2(cwd, ".sparn");
+  const configPath = join2(sparnDir, "config.yaml");
+  const dbPath = join2(sparnDir, "memory.db");
   const exists = await checkExists(sparnDir);
   if (exists && !options.force) {
     throw new Error(
@@ -588,7 +708,7 @@ var init_hash = __esm({
 
 // src/core/btsp-embedder.ts
 import { randomUUID } from "crypto";
-function createBTSPEmbedder() {
+function createBTSPEmbedder(config) {
   const BTSP_PATTERNS = [
     // Error patterns
     /\b(error|exception|failure|fatal|critical|panic)\b/i,
@@ -607,6 +727,14 @@ function createBTSPEmbedder() {
     /^=======/m,
     /^>>>>>>> /m
   ];
+  if (config?.customPatterns) {
+    for (const pattern of config.customPatterns) {
+      try {
+        BTSP_PATTERNS.push(new RegExp(pattern));
+      } catch {
+      }
+    }
+  }
   function detectBTSP(content) {
     return BTSP_PATTERNS.some((pattern) => pattern.test(content));
   }
@@ -648,7 +776,7 @@ function createConfidenceStates(config) {
     if (entry.isBTSP) {
       return "active";
     }
-    if (entry.score > activeThreshold) {
+    if (entry.score >= activeThreshold) {
       return "active";
     }
     if (entry.score >= readyThreshold) {
@@ -692,6 +820,8 @@ var init_confidence_states = __esm({
 // src/core/engram-scorer.ts
 function createEngramScorer(config) {
   const { defaultTTL } = config;
+  const recencyWindowMs = (config.recencyBoostMinutes ?? 30) * 60 * 1e3;
+  const recencyMultiplier = config.recencyBoostMultiplier ?? 1.3;
   function calculateDecay(ageInSeconds, ttlInSeconds) {
     if (ttlInSeconds === 0) return 1;
     if (ageInSeconds <= 0) return 0;
@@ -711,6 +841,13 @@ function createEngramScorer(config) {
     if (entry.isBTSP) {
       score = Math.max(score, 0.9);
     }
+    if (!entry.isBTSP && recencyWindowMs > 0) {
+      const ageMs = currentTime - entry.timestamp;
+      if (ageMs >= 0 && ageMs < recencyWindowMs) {
+        const boostFactor = 1 + (recencyMultiplier - 1) * (1 - ageMs / recencyWindowMs);
+        score = score * boostFactor;
+      }
+    }
     return Math.max(0, Math.min(1, score));
   }
   function refreshTTL(entry) {
@@ -734,20 +871,44 @@ var init_engram_scorer = __esm({
   }
 });
 
-// src/utils/tokenizer.ts
-function estimateTokens(text) {
-  if (!text || text.length === 0) {
-    return 0;
+// src/utils/tfidf.ts
+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 createTFIDFIndex(entries) {
+  const documentFrequency = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const tokens = tokenize(entry.content);
+    const uniqueTerms = new Set(tokens);
+    for (const term of uniqueTerms) {
+      documentFrequency.set(term, (documentFrequency.get(term) || 0) + 1);
+    }
   }
-  const words = text.split(/\s+/).filter((w) => w.length > 0);
-  const wordCount = words.length;
-  const charCount = text.length;
-  const charEstimate = Math.ceil(charCount / 4);
-  const wordEstimate = Math.ceil(wordCount * 0.75);
-  return Math.max(wordEstimate, charEstimate);
+  return {
+    documentFrequency,
+    totalDocuments: entries.length
+  };
 }
-var init_tokenizer = __esm({
-  "src/utils/tokenizer.ts"() {
+function scoreTFIDF(entry, index) {
+  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 docsWithTerm = index.documentFrequency.get(term) || 0;
+    if (docsWithTerm === 0) continue;
+    const idf = Math.log(index.totalDocuments / docsWithTerm);
+    totalScore += tf * idf;
+  }
+  return totalScore / tokens.length;
+}
+var init_tfidf = __esm({
+  "src/utils/tfidf.ts"() {
     "use strict";
     init_esm_shims();
   }
@@ -756,33 +917,8 @@ var init_tokenizer = __esm({
 // src/core/sparse-pruner.ts
 function createSparsePruner(config) {
   const { threshold } = config;
-  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 scoreEntry(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;
+    return scoreTFIDF(entry, createTFIDFIndex(allEntries));
   }
   function prune(entries) {
     if (entries.length === 0) {
@@ -794,9 +930,10 @@ function createSparsePruner(config) {
       };
     }
     const originalTokens = entries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    const tfidfIndex = createTFIDFIndex(entries);
     const scored = entries.map((entry) => ({
       entry,
-      score: scoreEntry(entry, entries)
+      score: scoreTFIDF(entry, tfidfIndex)
     }));
     scored.sort((a, b) => b.score - a.score);
     const keepCount = Math.max(1, Math.ceil(entries.length * (threshold / 100)));
@@ -819,6 +956,7 @@ var init_sparse_pruner = __esm({
   "src/core/sparse-pruner.ts"() {
     "use strict";
     init_esm_shims();
+    init_tfidf();
     init_tokenizer();
   }
 });
@@ -829,25 +967,28 @@ function createGenericAdapter(memory, config) {
   const pruner = createSparsePruner(config.pruning);
   const scorer = createEngramScorer(config.decay);
   const states = createConfidenceStates(config.states);
-  const btsp = createBTSPEmbedder();
+  const btsp = createBTSPEmbedder({ customPatterns: config.btspPatterns });
   async function optimize(context, options = {}) {
     const startTime = Date.now();
     const lines = context.split("\n").filter((line) => line.trim().length > 0);
-    const entries = lines.map((content) => ({
-      id: randomUUID2(),
-      content,
-      hash: hashContent(content),
-      timestamp: Date.now(),
-      score: btsp.detectBTSP(content) ? 1 : 0.5,
-      // BTSP gets high initial score
-      ttl: config.decay.defaultTTL * 3600,
-      // Convert hours to seconds
-      state: "ready",
-      accessCount: 0,
-      tags: [],
-      metadata: {},
-      isBTSP: btsp.detectBTSP(content)
-    }));
+    const now = Date.now();
+    const entries = lines.map((content, index) => {
+      const isBTSP = btsp.detectBTSP(content);
+      return {
+        id: randomUUID2(),
+        content,
+        hash: hashContent(content),
+        timestamp: now + index,
+        // Unique timestamps preserve ordering
+        score: isBTSP ? 1 : 0.5,
+        ttl: config.decay.defaultTTL * 3600,
+        state: "ready",
+        accessCount: 0,
+        tags: [],
+        metadata: {},
+        isBTSP
+      };
+    });
     const tokensBefore = entries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
     const scoredEntries = entries.map((entry) => ({
       ...entry,
@@ -1059,7 +1200,7 @@ async function relayCommand(options) {
   return result;
 }
 function executeCommand(command, args) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve12) => {
     const child = spawn(command, args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -1072,14 +1213,14 @@ function executeCommand(command, args) {
       stderr += data.toString();
     });
     child.on("close", (code) => {
-      resolve3({
+      resolve12({
         stdout,
         stderr,
         exitCode: code ?? 0
       });
     });
     child.on("error", (error) => {
-      resolve3({
+      resolve12({
         stdout,
         stderr: error.message,
         exitCode: 1
@@ -1187,13 +1328,15 @@ function createSleepCompressor() {
   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;
+    for (const word of words1) {
+      vec1[word] = (vec1[word] ?? 0) + 1;
+    }
+    for (const word of words2) {
+      vec2[word] = (vec2[word] ?? 0) + 1;
     }
+    const vocab = /* @__PURE__ */ new Set([...words1, ...words2]);
     let dotProduct = 0;
     let mag1 = 0;
     let mag2 = 0;
@@ -1209,9 +1352,6 @@ function createSleepCompressor() {
     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,
@@ -1222,6 +1362,7 @@ var init_sleep_compressor = __esm({
   "src/core/sleep-compressor.ts"() {
     "use strict";
     init_esm_shims();
+    init_tfidf();
     init_engram_scorer();
   }
 });
@@ -1520,132 +1661,18 @@ var init_config2 = __esm({
   }
 });
 
-// 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
-  };
-}
-function getMetrics() {
-  if (!globalMetrics) {
-    globalMetrics = createMetricsCollector();
-  }
-  return globalMetrics;
-}
-var globalMetrics;
-var init_metrics = __esm({
-  "src/core/metrics.ts"() {
-    "use strict";
-    init_esm_shims();
-    globalMetrics = null;
-  }
-});
-
 // src/daemon/daemon-process.ts
 var daemon_process_exports = {};
 __export(daemon_process_exports, {
   createDaemonCommand: () => createDaemonCommand
 });
-import { fork } from "child_process";
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname3, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 function createDaemonCommand() {
   function isDaemonRunning(pidFile) {
-    if (!existsSync2(pidFile)) {
+    if (!existsSync3(pidFile)) {
       return { running: false };
     }
     try {
@@ -1666,14 +1693,14 @@ function createDaemonCommand() {
     }
   }
   function writePidFile(pidFile, pid) {
-    const dir = dirname2(pidFile);
-    if (!existsSync2(dir)) {
+    const dir = dirname3(pidFile);
+    if (!existsSync3(dir)) {
       mkdirSync(dir, { recursive: true });
     }
     writeFileSync2(pidFile, String(pid), "utf-8");
   }
   function removePidFile(pidFile) {
-    if (existsSync2(pidFile)) {
+    if (existsSync3(pidFile)) {
       unlinkSync(pidFile);
     }
   }
@@ -1689,18 +1716,62 @@ function createDaemonCommand() {
       };
     }
     try {
-      const __filename2 = fileURLToPath3(import.meta.url);
-      const __dirname2 = dirname2(__filename2);
-      const daemonPath = join2(__dirname2, "index.js");
-      const child = fork(daemonPath, [], {
+      const __filename2 = fileURLToPath4(import.meta.url);
+      const __dirname2 = dirname3(__filename2);
+      const daemonPath = join3(__dirname2, "..", "daemon", "index.js");
+      const isWindows = process.platform === "win32";
+      const childEnv = {
+        ...process.env,
+        SPARN_CONFIG: JSON.stringify(config),
+        SPARN_PID_FILE: pidFile,
+        SPARN_LOG_FILE: logFile
+      };
+      if (isWindows) {
+        const configFile = join3(dirname3(pidFile), "daemon-config.json");
+        writeFileSync2(configFile, JSON.stringify({ config, pidFile, logFile }), "utf-8");
+        const launcherFile = join3(dirname3(pidFile), "daemon-launcher.mjs");
+        const launcherCode = [
+          `import { readFileSync } from 'node:fs';`,
+          `const cfg = JSON.parse(readFileSync(${JSON.stringify(configFile)}, 'utf-8'));`,
+          `process.env.SPARN_CONFIG = JSON.stringify(cfg.config);`,
+          `process.env.SPARN_PID_FILE = cfg.pidFile;`,
+          `process.env.SPARN_LOG_FILE = cfg.logFile;`,
+          `await import(${JSON.stringify(`file:///${daemonPath.replace(/\\/g, "/")}`)});`
+        ].join("\n");
+        writeFileSync2(launcherFile, launcherCode, "utf-8");
+        const ps = spawn2(
+          "powershell.exe",
+          [
+            "-NoProfile",
+            "-WindowStyle",
+            "Hidden",
+            "-Command",
+            `Start-Process -FilePath '${process.execPath}' -ArgumentList '${launcherFile}' -WindowStyle Hidden`
+          ],
+          { stdio: "ignore", windowsHide: true }
+        );
+        ps.unref();
+        await new Promise((resolve12) => setTimeout(resolve12, 2e3));
+        if (existsSync3(pidFile)) {
+          const pid = Number.parseInt(readFileSync3(pidFile, "utf-8").trim(), 10);
+          if (!Number.isNaN(pid)) {
+            return {
+              success: true,
+              pid,
+              message: `Daemon started (PID ${pid})`
+            };
+          }
+        }
+        return {
+          success: false,
+          message: "Daemon failed to start (no PID file written)",
+          error: "Timeout waiting for daemon PID"
+        };
+      }
+      const child = spawn2(process.execPath, [daemonPath], {
         detached: true,
         stdio: "ignore",
-        env: {
-          ...process.env,
-          SPARN_CONFIG: JSON.stringify(config),
-          SPARN_PID_FILE: pidFile,
-          SPARN_LOG_FILE: logFile
-        }
+        env: childEnv
       });
       child.unref();
       if (child.pid) {
@@ -1734,14 +1805,19 @@ function createDaemonCommand() {
       };
     }
     try {
-      process.kill(status2.pid, "SIGTERM");
+      const isWindows = process.platform === "win32";
+      if (isWindows) {
+        process.kill(status2.pid);
+      } else {
+        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((resolve3) => setTimeout(resolve3, interval));
+          await new Promise((resolve12) => setTimeout(resolve12, interval));
           waited += interval;
         } catch {
           removePidFile(pidFile);
@@ -1752,7 +1828,9 @@ function createDaemonCommand() {
         }
       }
       try {
-        process.kill(status2.pid, "SIGKILL");
+        if (!isWindows) {
+          process.kill(status2.pid, "SIGKILL");
+        }
         removePidFile(pidFile);
         return {
           success: true,
@@ -1782,13 +1860,9 @@ function createDaemonCommand() {
         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})`
     };
   }
@@ -1802,7 +1876,6 @@ var init_daemon_process = __esm({
   "src/daemon/daemon-process.ts"() {
     "use strict";
     init_esm_shims();
-    init_metrics();
   }
 });
 
@@ -1811,25 +1884,32 @@ var hooks_exports = {};
 __export(hooks_exports, {
   hooksCommand: () => hooksCommand
 });
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 import { homedir } from "os";
-import { dirname as dirname3, join as join3 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import { dirname as dirname4, join as join4 } from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
 async function hooksCommand(options) {
   const { subcommand, global } = options;
-  const settingsPath = global ? join3(homedir(), ".claude", "settings.json") : join3(process.cwd(), ".claude", "settings.json");
-  const __filename2 = fileURLToPath4(import.meta.url);
-  const __dirname2 = dirname3(__filename2);
-  const hooksDir = join3(dirname3(__dirname2), "hooks");
-  const prePromptPath = join3(hooksDir, "pre-prompt.js");
-  const postToolResultPath = join3(hooksDir, "post-tool-result.js");
+  const settingsPath = global ? join4(homedir(), ".claude", "settings.json") : join4(process.cwd(), ".claude", "settings.json");
+  const __filename2 = fileURLToPath5(import.meta.url);
+  const __dirname2 = dirname4(__filename2);
+  const hooksDir = join4(dirname4(__dirname2), "hooks");
+  const prePromptPath = join4(hooksDir, "pre-prompt.js");
+  const postToolResultPath = join4(hooksDir, "post-tool-result.js");
+  const stopDocsRefreshPath = join4(hooksDir, "stop-docs-refresh.js");
   switch (subcommand) {
     case "install":
-      return await installHooks(settingsPath, prePromptPath, postToolResultPath, global);
+      return installHooks(
+        settingsPath,
+        prePromptPath,
+        postToolResultPath,
+        stopDocsRefreshPath,
+        global
+      );
     case "uninstall":
-      return await uninstallHooks(settingsPath, global);
+      return uninstallHooks(settingsPath, global);
     case "status":
-      return await hooksStatus(settingsPath, global);
+      return hooksStatus(settingsPath, global);
     default:
       return {
         success: false,
@@ -1838,37 +1918,79 @@ async function hooksCommand(options) {
       };
   }
 }
-async function installHooks(settingsPath, prePromptPath, postToolResultPath, global) {
+function installHooks(settingsPath, prePromptPath, postToolResultPath, stopDocsRefreshPath, global) {
   try {
-    if (!existsSync3(prePromptPath)) {
+    if (!existsSync4(prePromptPath)) {
       return {
         success: false,
         message: `Hook script not found: ${prePromptPath}`,
         error: "Hook scripts not built. Run `npm run build` first."
       };
     }
-    if (!existsSync3(postToolResultPath)) {
+    if (!existsSync4(postToolResultPath)) {
       return {
         success: false,
         message: `Hook script not found: ${postToolResultPath}`,
         error: "Hook scripts not built. Run `npm run build` first."
       };
     }
+    if (!existsSync4(stopDocsRefreshPath)) {
+      return {
+        success: false,
+        message: `Hook script not found: ${stopDocsRefreshPath}`,
+        error: "Hook scripts not built. Run `npm run build` first."
+      };
+    }
     let settings = {};
-    if (existsSync3(settingsPath)) {
+    if (existsSync4(settingsPath)) {
       const settingsJson = readFileSync4(settingsPath, "utf-8");
       settings = JSON.parse(settingsJson);
     } else {
-      const claudeDir = dirname3(settingsPath);
-      if (!existsSync3(claudeDir)) {
+      const claudeDir = dirname4(settingsPath);
+      if (!existsSync4(claudeDir)) {
         mkdirSync2(claudeDir, { recursive: true });
       }
     }
-    settings["hooks"] = {
-      ...typeof settings["hooks"] === "object" && settings["hooks"] !== null ? settings["hooks"] : {},
-      prePrompt: `node ${prePromptPath}`,
-      postToolResult: `node ${postToolResultPath}`
-    };
+    const hooks = typeof settings["hooks"] === "object" && settings["hooks"] !== null ? settings["hooks"] : {};
+    removeSparnHooks(hooks);
+    if (!hooks[PRE_PROMPT_EVENT]) {
+      hooks[PRE_PROMPT_EVENT] = [];
+    }
+    hooks[PRE_PROMPT_EVENT].push({
+      hooks: [
+        {
+          type: "command",
+          command: `node "${prePromptPath.replace(/\\/g, "/")}"`,
+          timeout: 10
+        }
+      ]
+    });
+    if (!hooks[POST_TOOL_EVENT]) {
+      hooks[POST_TOOL_EVENT] = [];
+    }
+    hooks[POST_TOOL_EVENT].push({
+      matcher: POST_TOOL_MATCHER,
+      hooks: [
+        {
+          type: "command",
+          command: `node "${postToolResultPath.replace(/\\/g, "/")}"`,
+          timeout: 10
+        }
+      ]
+    });
+    if (!hooks[STOP_DOCS_EVENT]) {
+      hooks[STOP_DOCS_EVENT] = [];
+    }
+    hooks[STOP_DOCS_EVENT].push({
+      hooks: [
+        {
+          type: "command",
+          command: `node "${stopDocsRefreshPath.replace(/\\/g, "/")}"`,
+          timeout: 10
+        }
+      ]
+    });
+    settings["hooks"] = hooks;
     writeFileSync3(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
     return {
       success: true,
@@ -1876,7 +1998,8 @@ async function installHooks(settingsPath, prePromptPath, postToolResultPath, glo
       installed: true,
       hookPaths: {
         prePrompt: prePromptPath,
-        postToolResult: postToolResultPath
+        postToolResult: postToolResultPath,
+        stopDocsRefresh: stopDocsRefreshPath
       }
     };
   } catch (error) {
@@ -1887,9 +2010,9 @@ async function installHooks(settingsPath, prePromptPath, postToolResultPath, glo
     };
   }
 }
-async function uninstallHooks(settingsPath, global) {
+function uninstallHooks(settingsPath, global) {
   try {
-    if (!existsSync3(settingsPath)) {
+    if (!existsSync4(settingsPath)) {
       return {
         success: true,
         message: "No hooks installed (settings.json not found)",
@@ -1900,8 +2023,12 @@ async function uninstallHooks(settingsPath, global) {
     const settings = JSON.parse(settingsJson);
     if (settings["hooks"] && typeof settings["hooks"] === "object" && settings["hooks"] !== null) {
       const hooks = settings["hooks"];
-      delete hooks["prePrompt"];
-      delete hooks["postToolResult"];
+      removeSparnHooks(hooks);
+      for (const event of Object.keys(hooks)) {
+        if (Array.isArray(hooks[event]) && hooks[event].length === 0) {
+          delete hooks[event];
+        }
+      }
       if (Object.keys(hooks).length === 0) {
         delete settings["hooks"];
       }
@@ -1920,9 +2047,9 @@ async function uninstallHooks(settingsPath, global) {
     };
   }
 }
-async function hooksStatus(settingsPath, global) {
+function hooksStatus(settingsPath, global) {
   try {
-    if (!existsSync3(settingsPath)) {
+    if (!existsSync4(settingsPath)) {
       return {
         success: true,
         message: global ? "No global hooks installed (settings.json not found)" : "No project hooks installed (settings.json not found)",
@@ -1931,22 +2058,25 @@ async function hooksStatus(settingsPath, global) {
     }
     const settingsJson = readFileSync4(settingsPath, "utf-8");
     const settings = JSON.parse(settingsJson);
-    const hasHooks = settings["hooks"] && typeof settings["hooks"] === "object" && settings["hooks"] !== null && "prePrompt" in settings["hooks"] && "postToolResult" in settings["hooks"];
-    if (!hasHooks) {
+    const hooks = settings["hooks"] && typeof settings["hooks"] === "object" && settings["hooks"] !== null ? settings["hooks"] : {};
+    const prePromptHook = findSparnHook(hooks, PRE_PROMPT_EVENT);
+    const postToolHook = findSparnHook(hooks, POST_TOOL_EVENT);
+    const stopDocsHook = findSparnHook(hooks, STOP_DOCS_EVENT);
+    if (!prePromptHook && !postToolHook && !stopDocsHook) {
       return {
         success: true,
-        message: global ? "No global hooks installed" : "No project hooks installed",
+        message: global ? "No global sparn hooks installed" : "No project sparn hooks installed",
         installed: false
       };
     }
-    const hooks = settings["hooks"];
     return {
       success: true,
-      message: global ? "Global hooks active" : "Project hooks active",
+      message: global ? "Global sparn hooks active" : "Project sparn hooks active",
       installed: true,
       hookPaths: {
-        prePrompt: hooks["prePrompt"] || "",
-        postToolResult: hooks["postToolResult"] || ""
+        prePrompt: prePromptHook || "(not installed)",
+        postToolResult: postToolHook || "(not installed)",
+        stopDocsRefresh: stopDocsHook || "(not installed)"
       }
     };
   } catch (error) {
@@ -1957,20 +2087,163 @@ async function hooksStatus(settingsPath, global) {
     };
   }
 }
+function removeSparnHooks(hooks) {
+  for (const event of Object.keys(hooks)) {
+    if (!Array.isArray(hooks[event])) continue;
+    hooks[event] = hooks[event].filter((group) => {
+      if (!Array.isArray(group.hooks)) return true;
+      return !group.hooks.some(
+        (h) => typeof h.command === "string" && h.command.includes(SPARN_MARKER)
+      );
+    });
+  }
+}
+function findSparnHook(hooks, event) {
+  const groups = hooks[event];
+  if (!Array.isArray(groups)) return null;
+  for (const group of groups) {
+    if (!Array.isArray(group.hooks)) continue;
+    for (const h of group.hooks) {
+      if (typeof h.command === "string" && h.command.includes(SPARN_MARKER)) {
+        return h.command;
+      }
+    }
+  }
+  return null;
+}
+var PRE_PROMPT_EVENT, POST_TOOL_EVENT, STOP_DOCS_EVENT, POST_TOOL_MATCHER, SPARN_MARKER;
 var init_hooks = __esm({
   "src/cli/commands/hooks.ts"() {
     "use strict";
     init_esm_shims();
+    PRE_PROMPT_EVENT = "UserPromptSubmit";
+    POST_TOOL_EVENT = "PostToolUse";
+    STOP_DOCS_EVENT = "Stop";
+    POST_TOOL_MATCHER = "Bash|Read|Grep|Glob";
+    SPARN_MARKER = "sparn";
   }
 });
 
-// src/cli/commands/interactive.ts
-var interactive_exports = {};
-__export(interactive_exports, {
-  interactiveCommand: () => interactiveCommand
-});
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { resolve } from "path";
+// 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(sortedValues, percentile) {
+    if (sortedValues.length === 0) return 0;
+    const index = Math.ceil(percentile / 100 * sortedValues.length) - 1;
+    return sortedValues[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 sortedDurations = optimizations.map((m) => m.duration).sort((a, b) => a - b);
+    const totalCacheQueries = cacheHits + cacheMisses;
+    const hitRate = totalCacheQueries > 0 ? cacheHits / totalCacheQueries : 0;
+    return {
+      timestamp: Date.now(),
+      optimization: {
+        totalRuns,
+        totalDuration,
+        totalTokensSaved,
+        averageReduction,
+        p50Latency: calculatePercentile(sortedDurations, 50),
+        p95Latency: calculatePercentile(sortedDurations, 95),
+        p99Latency: calculatePercentile(sortedDurations, 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
+  };
+}
+function getMetrics() {
+  if (!globalMetrics) {
+    globalMetrics = createMetricsCollector();
+  }
+  return globalMetrics;
+}
+var globalMetrics;
+var init_metrics = __esm({
+  "src/core/metrics.ts"() {
+    "use strict";
+    init_esm_shims();
+    globalMetrics = null;
+  }
+});
+
+// src/cli/commands/interactive.ts
+var interactive_exports = {};
+__export(interactive_exports, {
+  interactiveCommand: () => interactiveCommand
+});
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve2 } from "path";
 import { confirm, input, number, select } from "@inquirer/prompts";
 import { load as parseYAML2, dump as stringifyYAML2 } from "js-yaml";
 function showWelcomeBanner() {
@@ -2023,9 +2296,9 @@ async function configureWizard(configPath) {
   const section = await select({
     message: "Which settings would you like to configure?",
     choices: [
-      { name: "\u{1F52A} Pruning (Sparse Coding)", value: "pruning" },
-      { name: "\u23F3 Decay (Engram Theory)", value: "decay" },
-      { name: "\u{1F3AF} States (Multi-State Synapses)", value: "states" },
+      { name: "\u{1F52A} Pruning (Relevance Filtering)", value: "pruning" },
+      { name: "\u23F3 Decay (Time-Based)", value: "decay" },
+      { name: "\u{1F3AF} States (Entry Classification)", value: "states" },
       { name: "\u26A1 Real-time Optimization", value: "realtime" },
       { name: "\u{1F3A8} UI Preferences", value: "ui" },
       { name: "\u2190 Back to Main Menu", value: "back" }
@@ -2035,7 +2308,7 @@ async function configureWizard(configPath) {
   switch (section) {
     case "pruning": {
       console.log(synapseViolet("\n\u{1F52A} Pruning Configuration"));
-      console.log(dim("Sparse coding: Keep only the most relevant context\n"));
+      console.log(dim("Keep only the most relevant context\n"));
       const threshold = await number({
         message: "Pruning threshold (percentage of entries to keep):",
         default: config.pruning.threshold,
@@ -2055,7 +2328,7 @@ async function configureWizard(configPath) {
     }
     case "decay": {
       console.log(synapseViolet("\n\u23F3 Decay Configuration"));
-      console.log(dim("Engram theory: Apply time-based decay to memories\n"));
+      console.log(dim("Apply time-based decay to older entries\n"));
       const defaultTTL = await number({
         message: "Default TTL in hours:",
         default: config.decay.defaultTTL,
@@ -2075,7 +2348,7 @@ async function configureWizard(configPath) {
     }
     case "states": {
       console.log(synapseViolet("\n\u{1F3AF} State Threshold Configuration"));
-      console.log(dim("Multi-state synapses: Classify entries as active/ready/silent\n"));
+      console.log(dim("Classify entries as active/ready/silent based on score\n"));
       const activeThreshold = await number({
         message: "Active state threshold (0.0-1.0):",
         default: config.states.activeThreshold,
@@ -2158,7 +2431,7 @@ async function optimizePreview(memory) {
     return;
   }
   try {
-    const content = readFileSync5(resolve(process.cwd(), inputFile), "utf-8");
+    const content = readFileSync5(resolve2(process.cwd(), inputFile), "utf-8");
     const tokensBefore = Math.ceil(content.length / 4);
     console.log(synapseViolet("\n\u{1F4C4} File Preview:"));
     console.log(dim(`  Length: ${content.length} characters`));
@@ -2198,7 +2471,7 @@ async function optimizePreview(memory) {
         message: "Output file path:",
         default: inputFile.replace(/(\.[^.]+)$/, ".optimized$1")
       });
-      writeFileSync4(resolve(process.cwd(), outputFile), result.output, "utf-8");
+      writeFileSync4(resolve2(process.cwd(), outputFile), result.output, "utf-8");
       console.log(neuralCyan(`
 \u{1F4BE} Saved to ${outputFile}
 `));
@@ -2371,7 +2644,7 @@ async function showQuickActions(memory, configPath) {
         default: false
       });
       if (shouldSave) {
-        const outputPath = resolve(configPath.replace(/\.yaml$/, ".json"));
+        const outputPath = resolve2(configPath.replace(/\.yaml$/, ".json"));
         writeFileSync4(outputPath, json, "utf-8");
         console.log(neuralCyan(`
 \u{1F4BE} Saved to ${outputPath}
@@ -2389,7 +2662,7 @@ It includes some sample content to demonstrate the optimization process.
 
 ## Features
 - Token counting
-- Sparse coding
+- Relevance filtering
 - Decay application
 - State classification
       `.trim();
@@ -2468,94 +2741,2891 @@ var init_interactive = __esm({
   }
 });
 
-// src/cli/index.ts
-init_esm_shims();
-init_banner();
-import { spawn as spawn2 } from "child_process";
-import { readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname4, join as join4, resolve as resolve2 } from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
-import { Command } from "commander";
-function getVersion2() {
+// src/core/dependency-graph.ts
+import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync6, statSync } from "fs";
+import { extname, join as join5, relative, resolve as resolve3 } from "path";
+function parseImports(content, filePath) {
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of IMPORT_PATTERNS) {
+    const regex = new RegExp(pattern.source, pattern.flags);
+    const matches = [...content.matchAll(regex)];
+    for (const match of matches) {
+      if (pattern.source.includes("from")) {
+        const symbolsRaw = match[1] || "";
+        const target = match[2] || "";
+        if (!target || target.startsWith(".") === false && !target.startsWith("/")) {
+          continue;
+        }
+        const symbols = symbolsRaw.split(",").map(
+          (s) => s.trim().split(/\s+as\s+/)[0]?.trim() || ""
+        ).filter(Boolean);
+        const key = `${filePath}->${target}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          edges.push({ source: filePath, target, symbols });
+        }
+      } else if (pattern.source.includes("require")) {
+        const target = match[1] || "";
+        if (!target || !target.startsWith(".") && !target.startsWith("/")) {
+          continue;
+        }
+        const key = `${filePath}->${target}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          edges.push({ source: filePath, target, symbols: [] });
+        }
+      } else {
+        const target = match[1] || "";
+        if (!target || !target.startsWith(".") && !target.startsWith("/")) {
+          continue;
+        }
+        const key = `${filePath}->${target}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          edges.push({ source: filePath, target, symbols: [] });
+        }
+      }
+    }
+  }
+  return edges;
+}
+function parseExports(content) {
+  const exportsList = [];
+  for (const pattern of EXPORT_PATTERNS) {
+    const regex = new RegExp(pattern.source, pattern.flags);
+    const matches = [...content.matchAll(regex)];
+    for (const match of matches) {
+      if (match[1]) {
+        const symbols = match[1].split(",").map(
+          (s) => s.trim().split(/\s+as\s+/)[0]?.trim() || ""
+        ).filter(Boolean);
+        exportsList.push(...symbols);
+      } else {
+        exportsList.push("default");
+      }
+    }
+  }
+  return [...new Set(exportsList)];
+}
+function resolveImportPath(importPath, fromFile, projectRoot, extensions) {
+  const cleanImport = importPath.replace(/\.(js|ts|tsx|jsx)$/, "");
+  const baseDir = join5(projectRoot, fromFile, "..");
+  const candidates = [
+    ...extensions.map((ext) => resolve3(baseDir, `${cleanImport}${ext}`)),
+    ...extensions.map((ext) => resolve3(baseDir, cleanImport, `index${ext}`))
+  ];
+  for (const candidate of candidates) {
+    if (existsSync5(candidate)) {
+      return relative(projectRoot, candidate).replace(/\\/g, "/");
+    }
+  }
+  return null;
+}
+function collectFiles(dir, projectRoot, extensions, ignoreDirs) {
+  const files = [];
   try {
-    const pkg = JSON.parse(readFileSync6(join4(process.cwd(), "package.json"), "utf-8"));
-    return pkg.version;
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join5(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!ignoreDirs.includes(entry.name)) {
+          files.push(...collectFiles(fullPath, projectRoot, extensions, ignoreDirs));
+        }
+      } else if (entry.isFile() && extensions.includes(extname(entry.name))) {
+        files.push(relative(projectRoot, fullPath).replace(/\\/g, "/"));
+      }
+    }
   } catch {
-    const __filename2 = fileURLToPath5(import.meta.url);
-    const __dirname2 = dirname4(__filename2);
-    const pkg = JSON.parse(readFileSync6(join4(__dirname2, "../../package.json"), "utf-8"));
-    return pkg.version;
   }
+  return files;
 }
-var VERSION2 = getVersion2();
-async function handleError(error, context) {
-  const { errorRed: errorRed2, synapseViolet: synapseViolet2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
-  const errorMsg = error instanceof Error ? error.message : String(error);
-  const stack = error instanceof Error ? error.stack : void 0;
-  console.error(errorRed2("\n\u2717 Error:"), errorMsg);
-  if (context) {
-    console.error(errorRed2("Context:"), context);
-  }
-  if (errorMsg.includes("SQLITE") || errorMsg.includes("database")) {
-    console.error(synapseViolet2("\n\u{1F4A1} Database issue detected:"));
-    console.error("  Try running: rm -rf .sparn/ && sparn init");
-    console.error("  This will reinitialize your Sparn database.\n");
+function createDependencyGraph(config) {
+  const {
+    projectRoot,
+    maxDepth = 50,
+    extensions = [".ts", ".tsx", ".js", ".jsx"],
+    ignoreDirs = ["node_modules", "dist", ".git", ".sparn", "coverage"]
+  } = config;
+  const nodes = /* @__PURE__ */ new Map();
+  let built = false;
+  async function build() {
+    nodes.clear();
+    const files = collectFiles(projectRoot, projectRoot, extensions, ignoreDirs);
+    for (const filePath of files) {
+      const fullPath = join5(projectRoot, filePath);
+      try {
+        const content = readFileSync6(fullPath, "utf-8");
+        const stat = statSync(fullPath);
+        const exports = parseExports(content);
+        const imports = parseImports(content, filePath);
+        const resolvedImports = [];
+        for (const imp of imports) {
+          const resolved = resolveImportPath(imp.target, filePath, projectRoot, extensions);
+          if (resolved) {
+            resolvedImports.push({ ...imp, target: resolved });
+          }
+        }
+        nodes.set(filePath, {
+          filePath,
+          exports,
+          imports: resolvedImports,
+          callers: [],
+          // Populated in second pass
+          engram_score: 0,
+          lastModified: stat.mtimeMs,
+          tokenEstimate: estimateTokens(content)
+        });
+      } catch {
+      }
+    }
+    for (const [filePath, node] of nodes) {
+      for (const imp of node.imports) {
+        const targetNode = nodes.get(imp.target);
+        if (targetNode && !targetNode.callers.includes(filePath)) {
+          targetNode.callers.push(filePath);
+        }
+      }
+    }
+    built = true;
+    return nodes;
   }
-  if (errorMsg.includes("EACCES") || errorMsg.includes("permission")) {
-    console.error(synapseViolet2("\n\u{1F4A1} Permission issue detected:"));
-    console.error("  Check file permissions in .sparn/ directory");
-    console.error("  Try: chmod -R u+rw .sparn/\n");
+  async function analyze() {
+    if (!built) await build();
+    const entryPoints = [];
+    const orphans = [];
+    const callerCounts = /* @__PURE__ */ new Map();
+    for (const [filePath, node] of nodes) {
+      if (node.callers.length === 0 && node.imports.length > 0) {
+        entryPoints.push(filePath);
+      }
+      if (node.callers.length === 0 && node.imports.length === 0) {
+        orphans.push(filePath);
+      }
+      callerCounts.set(filePath, node.callers.length);
+    }
+    const sortedByCallers = [...callerCounts.entries()].sort((a, b) => b[1] - a[1]).filter(([, count]) => count > 0);
+    const hotPaths = sortedByCallers.slice(0, 10).map(([path2]) => path2);
+    const totalTokens = [...nodes.values()].reduce((sum, n) => sum + n.tokenEstimate, 0);
+    const hotPathTokens = hotPaths.reduce(
+      (sum, path2) => sum + (nodes.get(path2)?.tokenEstimate || 0),
+      0
+    );
+    return {
+      entryPoints,
+      hotPaths,
+      orphans,
+      totalTokens,
+      optimizedTokens: hotPathTokens
+    };
   }
-  if (errorMsg.includes("ENOENT") || errorMsg.includes("no such file")) {
-    console.error(synapseViolet2("\n\u{1F4A1} File not found:"));
-    console.error("  Make sure you have run: sparn init");
-    console.error("  Or check that the specified file exists.\n");
+  async function focus(pattern) {
+    if (!built) await build();
+    const matching = /* @__PURE__ */ new Map();
+    const lowerPattern = pattern.toLowerCase();
+    for (const [filePath, node] of nodes) {
+      if (filePath.toLowerCase().includes(lowerPattern)) {
+        matching.set(filePath, node);
+        for (const imp of node.imports) {
+          const depNode = nodes.get(imp.target);
+          if (depNode) {
+            matching.set(imp.target, depNode);
+          }
+        }
+        for (const caller of node.callers) {
+          const callerNode = nodes.get(caller);
+          if (callerNode) {
+            matching.set(caller, callerNode);
+          }
+        }
+      }
+    }
+    return matching;
   }
-  if (errorMsg.includes("out of memory") || errorMsg.includes("heap")) {
-    console.error(synapseViolet2("\n\u{1F4A1} Memory issue detected:"));
-    console.error("  Try processing smaller chunks of context");
-    console.error("  Or increase Node.js memory: NODE_OPTIONS=--max-old-space-size=4096\n");
+  async function getFilesFromEntry(entryPoint, depth = maxDepth) {
+    if (!built) await build();
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [{ path: entryPoint, depth: 0 }];
+    while (queue.length > 0) {
+      const item = queue.shift();
+      if (!item) break;
+      if (visited.has(item.path) || item.depth > depth) continue;
+      visited.add(item.path);
+      const node = nodes.get(item.path);
+      if (node) {
+        for (const imp of node.imports) {
+          if (!visited.has(imp.target)) {
+            queue.push({ path: imp.target, depth: item.depth + 1 });
+          }
+        }
+      }
+    }
+    return [...visited];
   }
-  if (process.env["SPARN_DEBUG"] === "true" && stack) {
-    console.error(errorRed2("\nStack trace:"));
-    console.error(stack);
-  } else {
-    console.error("  Run with SPARN_DEBUG=true for stack trace\n");
+  function getNodes() {
+    return nodes;
   }
-  process.exit(1);
+  return {
+    build,
+    analyze,
+    focus,
+    getFilesFromEntry,
+    getNodes
+  };
 }
-process.on("unhandledRejection", (reason) => {
-  void handleError(reason, "Unhandled promise rejection");
-});
-process.on("uncaughtException", (error) => {
-  void handleError(error, "Uncaught exception");
+var IMPORT_PATTERNS, EXPORT_PATTERNS;
+var init_dependency_graph = __esm({
+  "src/core/dependency-graph.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_tokenizer();
+    IMPORT_PATTERNS = [
+      // import { Foo, Bar } from './module'
+      /import\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g,
+      // import Foo from './module'
+      /import\s+(\w+)\s+from\s+['"]([^'"]+)['"]/g,
+      // import * as Foo from './module'
+      /import\s+\*\s+as\s+(\w+)\s+from\s+['"]([^'"]+)['"]/g,
+      // import './module' (side-effect)
+      /import\s+['"]([^'"]+)['"]/g,
+      // require('./module')
+      /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+    ];
+    EXPORT_PATTERNS = [
+      // export { Foo, Bar }
+      /export\s+\{([^}]+)\}/g,
+      // export function/class/const/let/var/type/interface
+      /export\s+(?:default\s+)?(?:function|class|const|let|var|type|interface|enum)\s+(\w+)/g,
+      // export default
+      /export\s+default\s+/g
+    ];
+  }
 });
-var program = new Command();
-program.name("sparn").description("Neuroscience-inspired context optimization for AI coding agents").version(VERSION2, "-v, --version", "Output the current version").helpOption("-h, --help", "Display help for command");
-program.command("init").description("Initialize Sparn in the current project").option("-f, --force", "Force overwrite if .sparn/ already exists").addHelpText(
-  "after",
-  `
-Examples:
-  $ sparn init                  # Initialize in current directory
-  $ sparn init --force          # Overwrite existing .sparn/ directory
 
-Files Created:
-  .sparn/config.yaml            # Configuration with neuroscience parameters
-  .sparn/memory.db              # SQLite database for context storage
+// src/cli/commands/graph.ts
+var graph_exports = {};
+__export(graph_exports, {
+  graphCommand: () => graphCommand
+});
+import { resolve as resolve4 } from "path";
+async function graphCommand(options) {
+  const projectRoot = resolve4(process.cwd());
+  const graph = createDependencyGraph({
+    projectRoot,
+    maxDepth: options.depth
+  });
+  await graph.build();
+  let nodes = graph.getNodes();
+  if (options.focus) {
+    nodes = await graph.focus(options.focus);
+  }
+  if (options.entry) {
+    const allNodes = graph.getNodes();
+    if (!allNodes.has(options.entry)) {
+      throw new Error(
+        `Entry point not found in graph: ${options.entry}. Available: ${[...allNodes.keys()].slice(0, 5).join(", ")}${allNodes.size > 5 ? "..." : ""}`
+      );
+    }
+    const files = await graph.getFilesFromEntry(options.entry, options.depth);
+    const entryNodes = /* @__PURE__ */ new Map();
+    for (const f of files) {
+      const node = nodes.get(f);
+      if (node) entryNodes.set(f, node);
+    }
+    nodes = entryNodes;
+  }
+  const analysis = await graph.analyze();
+  const result = {
+    analysis,
+    nodeCount: nodes.size
+  };
+  if (options.json) {
+    result.json = JSON.stringify(
+      {
+        analysis,
+        nodeCount: nodes.size,
+        nodes: Object.fromEntries(
+          [...nodes.entries()].map(([k, v]) => [
+            k,
+            {
+              exports: v.exports,
+              imports: v.imports.map((i) => i.target),
+              callers: v.callers,
+              tokens: v.tokenEstimate
+            }
+          ])
+        )
+      },
+      null,
+      2
+    );
+  }
+  return result;
+}
+var init_graph = __esm({
+  "src/cli/commands/graph.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_dependency_graph();
+  }
+});
 
-Next Steps:
-  After initialization, use 'sparn optimize' to start optimizing context.
-`
-).action(async (options) => {
-  const { initCommand: initCommand2, displayInitSuccess: displayInitSuccess2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-  const { createInitSpinner: createInitSpinner2 } = await Promise.resolve().then(() => (init_progress(), progress_exports));
-  const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
-  const spinner = createInitSpinner2("\u{1F9E0} Initializing Sparn...");
+// src/core/search-engine.ts
+import { execFileSync as execFileSync2, execSync } from "child_process";
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync7, statSync as statSync2 } from "fs";
+import { extname as extname2, join as join6, relative as relative2 } from "path";
+import Database2 from "better-sqlite3";
+function hasRipgrep() {
   try {
-    spinner.start();
-    spinner.text = "\u{1F4C1} Creating .sparn/ directory...";
-    const result = await initCommand2({ force: options.force });
-    spinner.succeed(neuralCyan2("Sparn initialized successfully!"));
+    execSync("rg --version", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ripgrepSearch(query, projectRoot, opts = {}) {
+  try {
+    const args = ["--line-number", "--no-heading", "--color=never"];
+    if (opts.fileGlob) {
+      args.push("--glob", opts.fileGlob);
+    }
+    args.push(
+      "--glob",
+      "!node_modules",
+      "--glob",
+      "!dist",
+      "--glob",
+      "!.git",
+      "--glob",
+      "!.sparn",
+      "--glob",
+      "!coverage"
+    );
+    const maxResults = opts.maxResults || 20;
+    args.push("--max-count", String(maxResults));
+    if (opts.includeContext) {
+      args.push("-C", "2");
+    }
+    args.push("--", query, projectRoot);
+    const output = execFileSync2("rg", args, { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
+    const results = [];
+    const lines = output.split("\n").filter(Boolean);
+    for (const line of lines) {
+      const match = line.match(/^(.+?):(\d+):(.*)/);
+      if (match) {
+        const filePath = relative2(projectRoot, match[1] || "").replace(/\\/g, "/");
+        const lineNumber = Number.parseInt(match[2] || "0", 10);
+        const content = (match[3] || "").trim();
+        results.push({
+          filePath,
+          lineNumber,
+          content,
+          score: 0.8,
+          // Exact match gets high base score
+          context: [],
+          engram_score: 0
+        });
+      }
+    }
+    return results.slice(0, maxResults);
+  } catch {
+    return [];
+  }
+}
+function collectIndexableFiles(dir, projectRoot, ignoreDirs = ["node_modules", "dist", ".git", ".sparn", "coverage"], exts = [".ts", ".tsx", ".js", ".jsx", ".json", ".md", ".yaml", ".yml"]) {
+  const files = [];
+  try {
+    const entries = readdirSync2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join6(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!ignoreDirs.includes(entry.name)) {
+          files.push(...collectIndexableFiles(fullPath, projectRoot, ignoreDirs, exts));
+        }
+      } else if (entry.isFile() && exts.includes(extname2(entry.name))) {
+        try {
+          const stat = statSync2(fullPath);
+          if (stat.size < 100 * 1024) {
+            files.push(relative2(projectRoot, fullPath).replace(/\\/g, "/"));
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function createSearchEngine(dbPath) {
+  let db = null;
+  let projectRoot = "";
+  const rgAvailable = hasRipgrep();
+  async function init(root) {
+    if (db) {
+      try {
+        db.close();
+      } catch {
+      }
+    }
+    projectRoot = root;
+    db = new Database2(dbPath);
+    db.pragma("journal_mode = WAL");
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS search_index USING fts5(
+        filepath, line_number, content, tokenize='porter'
+      );
+    `);
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS search_meta (
+        filepath TEXT PRIMARY KEY,
+        mtime INTEGER NOT NULL,
+        indexed_at INTEGER NOT NULL
+      );
+    `);
+  }
+  async function index(paths) {
+    if (!db) throw new Error("Search engine not initialized. Call init() first.");
+    const startTime = Date.now();
+    const filesToIndex = paths || collectIndexableFiles(projectRoot, projectRoot);
+    let filesIndexed = 0;
+    let totalLines = 0;
+    const insertStmt = db.prepare(
+      "INSERT INTO search_index(filepath, line_number, content) VALUES (?, ?, ?)"
+    );
+    const metaStmt = db.prepare(
+      "INSERT OR REPLACE INTO search_meta(filepath, mtime, indexed_at) VALUES (?, ?, ?)"
+    );
+    const checkMeta = db.prepare("SELECT mtime FROM search_meta WHERE filepath = ?");
+    const deleteFile = db.prepare("DELETE FROM search_index WHERE filepath = ?");
+    const transaction = db.transaction(() => {
+      for (const filePath of filesToIndex) {
+        const fullPath = join6(projectRoot, filePath);
+        if (!existsSync6(fullPath)) continue;
+        try {
+          const stat = statSync2(fullPath);
+          const existing = checkMeta.get(filePath);
+          if (existing && existing.mtime >= stat.mtimeMs) {
+            continue;
+          }
+          deleteFile.run(filePath);
+          const content = readFileSync7(fullPath, "utf-8");
+          const lines = content.split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line && line.trim().length > 0) {
+              insertStmt.run(filePath, i + 1, line);
+              totalLines++;
+            }
+          }
+          metaStmt.run(filePath, stat.mtimeMs, Date.now());
+          filesIndexed++;
+        } catch {
+        }
+      }
+    });
+    transaction();
+    return {
+      filesIndexed,
+      totalLines,
+      duration: Date.now() - startTime
+    };
+  }
+  async function search(query, opts = {}) {
+    if (!db) throw new Error("Search engine not initialized. Call init() first.");
+    const maxResults = opts.maxResults || 10;
+    const results = [];
+    const seen = /* @__PURE__ */ new Set();
+    try {
+      const ftsQuery = query.replace(/['"*(){}[\]^~\\:]/g, " ").trim().split(/\s+/).filter((w) => w.length > 0).map((w) => `content:${w}`).join(" ");
+      if (ftsQuery.length > 0) {
+        let sql = `
+          SELECT filepath, line_number, content, rank
+          FROM search_index
+          WHERE search_index MATCH ?
+        `;
+        const params = [ftsQuery];
+        if (opts.fileGlob) {
+          const likePattern = opts.fileGlob.replace(/\*/g, "%").replace(/\?/g, "_");
+          sql += " AND filepath LIKE ?";
+          params.push(likePattern);
+        }
+        sql += " ORDER BY rank LIMIT ?";
+        params.push(maxResults * 2);
+        const rows = db.prepare(sql).all(...params);
+        for (const row of rows) {
+          const key = `${row.filepath}:${row.line_number}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            const score = Math.min(1, Math.max(0, 1 + row.rank / 10));
+            const context = [];
+            if (opts.includeContext) {
+              const contextRows = db.prepare(
+                `SELECT content FROM search_index WHERE filepath = ? AND CAST(line_number AS INTEGER) BETWEEN ? AND ? ORDER BY CAST(line_number AS INTEGER)`
+              ).all(row.filepath, row.line_number - 2, row.line_number + 2);
+              context.push(...contextRows.map((r) => r.content));
+            }
+            results.push({
+              filePath: row.filepath,
+              lineNumber: row.line_number,
+              content: row.content,
+              score,
+              context,
+              engram_score: 0
+            });
+          }
+        }
+      }
+    } catch {
+    }
+    if (rgAvailable && opts.useRipgrep !== false) {
+      const rgResults = ripgrepSearch(query, projectRoot, opts);
+      for (const result of rgResults) {
+        const key = `${result.filePath}:${result.lineNumber}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          results.push(result);
+        }
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, maxResults);
+  }
+  async function refresh() {
+    if (!db) throw new Error("Search engine not initialized. Call init() first.");
+    db.exec("DELETE FROM search_index");
+    db.exec("DELETE FROM search_meta");
+    return index();
+  }
+  async function close() {
+    if (db) {
+      db.close();
+      db = null;
+    }
+  }
+  return {
+    init,
+    index,
+    search,
+    refresh,
+    close
+  };
+}
+var init_search_engine = __esm({
+  "src/core/search-engine.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli/commands/search.ts
+var search_exports = {};
+__export(search_exports, {
+  searchCommand: () => searchCommand
+});
+import { resolve as resolve5 } from "path";
+async function searchCommand(options) {
+  const projectRoot = resolve5(process.cwd());
+  const dbPath = resolve5(projectRoot, ".sparn", "search.db");
+  const engine = createSearchEngine(dbPath);
+  try {
+    await engine.init(projectRoot);
+    if (options.subcommand === "init" || options.subcommand === "refresh") {
+      const stats = options.subcommand === "refresh" ? await engine.refresh() : await engine.index();
+      const result = {
+        indexStats: stats,
+        message: `Indexed ${stats.filesIndexed} files (${stats.totalLines} lines) in ${stats.duration}ms`
+      };
+      if (options.json) {
+        result.json = JSON.stringify(stats, null, 2);
+      }
+      return result;
+    }
+    if (!options.query) {
+      return { message: 'No search query provided. Usage: sparn search "query"' };
+    }
+    const results = await engine.search(options.query, {
+      maxResults: options.maxResults || 10,
+      fileGlob: options.glob,
+      includeContext: true
+    });
+    const cmdResult = { results };
+    if (options.json) {
+      cmdResult.json = JSON.stringify(results, null, 2);
+    }
+    return cmdResult;
+  } finally {
+    await engine.close();
+  }
+}
+var init_search = __esm({
+  "src/cli/commands/search.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_search_engine();
+  }
+});
+
+// src/core/workflow-planner.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readdirSync as readdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
+import { join as join7 } from "path";
+function createWorkflowPlanner(projectRoot) {
+  const plansDir = join7(projectRoot, ".sparn", "plans");
+  if (!existsSync7(plansDir)) {
+    mkdirSync3(plansDir, { recursive: true });
+  }
+  function sanitizeId(id) {
+    return id.replace(/[/\\:.]/g, "").replace(/\.\./g, "");
+  }
+  function planPath(planId) {
+    const safeId = sanitizeId(planId);
+    if (!safeId) throw new Error("Invalid plan ID");
+    return join7(plansDir, `plan-${safeId}.json`);
+  }
+  async function createPlan(taskDescription, filesNeeded, searchQueries, steps, tokenBudget = { planning: 0, estimated_execution: 0, max_file_reads: 5 }) {
+    const id = randomUUID3().split("-")[0] || "plan";
+    const plan = {
+      id,
+      created_at: Date.now(),
+      task_description: taskDescription,
+      steps: steps.map((s) => ({ ...s, status: "pending" })),
+      token_budget: tokenBudget,
+      files_needed: filesNeeded,
+      search_queries: searchQueries,
+      status: "draft"
+    };
+    writeFileSync5(planPath(id), JSON.stringify(plan, null, 2), "utf-8");
+    return plan;
+  }
+  async function loadPlan(planId) {
+    const path2 = planPath(planId);
+    if (!existsSync7(path2)) return null;
+    try {
+      return JSON.parse(readFileSync8(path2, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  async function listPlans() {
+    if (!existsSync7(plansDir)) return [];
+    const files = readdirSync3(plansDir).filter((f) => f.startsWith("plan-") && f.endsWith(".json"));
+    const plans = [];
+    for (const file of files) {
+      try {
+        const plan = JSON.parse(readFileSync8(join7(plansDir, file), "utf-8"));
+        plans.push({
+          id: plan.id,
+          task: plan.task_description,
+          status: plan.status,
+          created: plan.created_at
+        });
+      } catch {
+      }
+    }
+    return plans.sort((a, b) => b.created - a.created);
+  }
+  async function updateStep(planId, stepOrder, status, result) {
+    const plan = await loadPlan(planId);
+    if (!plan) throw new Error(`Plan ${planId} not found`);
+    const step = plan.steps.find((s) => s.order === stepOrder);
+    if (!step) throw new Error(`Step ${stepOrder} not found in plan ${planId}`);
+    step.status = status;
+    if (result !== void 0) {
+      step.result = result;
+    }
+    writeFileSync5(planPath(planId), JSON.stringify(plan, null, 2), "utf-8");
+  }
+  async function startExec(planId) {
+    const plan = await loadPlan(planId);
+    if (!plan) throw new Error(`Plan ${planId} not found`);
+    plan.status = "executing";
+    writeFileSync5(planPath(planId), JSON.stringify(plan, null, 2), "utf-8");
+    return {
+      maxFileReads: plan.token_budget.max_file_reads,
+      tokenBudget: plan.token_budget.estimated_execution,
+      allowReplan: false
+    };
+  }
+  async function verify(planId) {
+    const plan = await loadPlan(planId);
+    if (!plan) throw new Error(`Plan ${planId} not found`);
+    let stepsCompleted = 0;
+    let stepsFailed = 0;
+    let stepsSkipped = 0;
+    let tokensUsed = 0;
+    const details = [];
+    for (const step of plan.steps) {
+      switch (step.status) {
+        case "completed":
+          stepsCompleted++;
+          tokensUsed += step.estimated_tokens;
+          break;
+        case "failed":
+          stepsFailed++;
+          break;
+        case "skipped":
+          stepsSkipped++;
+          break;
+        default:
+          break;
+      }
+      details.push({
+        step: step.order,
+        action: step.action,
+        target: step.target,
+        status: step.status
+      });
+    }
+    const totalSteps = plan.steps.length;
+    const success = stepsFailed === 0 && stepsCompleted === totalSteps;
+    const hasInProgress = plan.steps.some(
+      (s) => s.status === "pending" || s.status === "in_progress"
+    );
+    if (!hasInProgress) {
+      plan.status = success ? "completed" : "failed";
+      writeFileSync5(planPath(planId), JSON.stringify(plan, null, 2), "utf-8");
+    }
+    return {
+      planId,
+      stepsCompleted,
+      stepsFailed,
+      stepsSkipped,
+      totalSteps,
+      tokensBudgeted: plan.token_budget.estimated_execution,
+      tokensUsed,
+      success,
+      details
+    };
+  }
+  function getPlansDir() {
+    return plansDir;
+  }
+  return {
+    createPlan,
+    loadPlan,
+    listPlans,
+    updateStep,
+    startExec,
+    verify,
+    getPlansDir
+  };
+}
+var init_workflow_planner = __esm({
+  "src/core/workflow-planner.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli/commands/plan.ts
+var plan_exports = {};
+__export(plan_exports, {
+  planCommand: () => planCommand,
+  planListCommand: () => planListCommand
+});
+import { resolve as resolve6 } from "path";
+async function planCommand(options) {
+  const projectRoot = resolve6(process.cwd());
+  const planner = createWorkflowPlanner(projectRoot);
+  const steps = [];
+  let order = 1;
+  if (options.searches) {
+    for (const query of options.searches) {
+      steps.push({
+        order: order++,
+        action: "search",
+        target: query,
+        description: `Search for: ${query}`,
+        dependencies: [],
+        estimated_tokens: 500
+      });
+    }
+  }
+  if (options.files) {
+    for (const file of options.files) {
+      steps.push({
+        order: order++,
+        action: "read",
+        target: file,
+        description: `Read file: ${file}`,
+        dependencies: [],
+        estimated_tokens: 1e3
+      });
+    }
+  }
+  steps.push({
+    order: order++,
+    action: "verify",
+    target: "tests",
+    description: "Run tests to verify changes",
+    dependencies: steps.map((s) => s.order),
+    estimated_tokens: 200
+  });
+  const plan = await planner.createPlan(
+    options.task,
+    options.files || [],
+    options.searches || [],
+    steps,
+    {
+      planning: 0,
+      estimated_execution: steps.reduce((sum, s) => sum + s.estimated_tokens, 0),
+      max_file_reads: options.maxReads || 5
+    }
+  );
+  const result = {
+    plan,
+    message: `Plan ${plan.id} created with ${plan.steps.length} steps`
+  };
+  if (options.json) {
+    result.json = JSON.stringify(plan, null, 2);
+  }
+  return result;
+}
+async function planListCommand(options) {
+  const projectRoot = resolve6(process.cwd());
+  const planner = createWorkflowPlanner(projectRoot);
+  const plans = await planner.listPlans();
+  const result = { plans };
+  if (options.json) {
+    result.json = JSON.stringify(plans, null, 2);
+  }
+  return result;
+}
+var init_plan = __esm({
+  "src/cli/commands/plan.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_workflow_planner();
+  }
+});
+
+// src/cli/commands/exec.ts
+var exec_exports = {};
+__export(exec_exports, {
+  execCommand: () => execCommand
+});
+import { resolve as resolve7 } from "path";
+async function execCommand(options) {
+  const projectRoot = resolve7(process.cwd());
+  const planner = createWorkflowPlanner(projectRoot);
+  const plan = await planner.loadPlan(options.planId);
+  if (!plan) {
+    throw new Error(`Plan ${options.planId} not found`);
+  }
+  const constraints = await planner.startExec(options.planId);
+  const updatedPlan = await planner.loadPlan(options.planId) || plan;
+  const result = {
+    plan: updatedPlan,
+    constraints,
+    message: `Executing plan ${options.planId}: max ${constraints.maxFileReads} reads, ${constraints.tokenBudget} token budget`
+  };
+  if (options.json) {
+    result.json = JSON.stringify({ plan: updatedPlan, constraints }, null, 2);
+  }
+  return result;
+}
+var init_exec = __esm({
+  "src/cli/commands/exec.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_workflow_planner();
+  }
+});
+
+// src/cli/commands/verify.ts
+var verify_exports = {};
+__export(verify_exports, {
+  verifyCommand: () => verifyCommand
+});
+import { resolve as resolve8 } from "path";
+async function verifyCommand(options) {
+  const projectRoot = resolve8(process.cwd());
+  const planner = createWorkflowPlanner(projectRoot);
+  const plan = await planner.loadPlan(options.planId);
+  if (!plan) {
+    throw new Error(`Plan ${options.planId} not found`);
+  }
+  const verification = await planner.verify(options.planId);
+  const status = verification.success ? "PASSED" : "FAILED";
+  const message = `Plan ${options.planId} verification: ${status} (${verification.stepsCompleted}/${verification.totalSteps} steps completed)`;
+  const result = {
+    verification,
+    message
+  };
+  if (options.json) {
+    result.json = JSON.stringify(verification, null, 2);
+  }
+  return result;
+}
+var init_verify = __esm({
+  "src/cli/commands/verify.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_workflow_planner();
+  }
+});
+
+// src/core/docs-generator.ts
+import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "fs";
+import { extname as extname3, join as join8, relative as relative3 } from "path";
+function detectEntryPoints(projectRoot) {
+  const entries = [];
+  const candidates = [
+    { path: "src/index.ts", desc: "Library API" },
+    { path: "src/cli/index.ts", desc: "CLI entry point" },
+    { path: "src/daemon/index.ts", desc: "Daemon process" },
+    { path: "src/mcp/index.ts", desc: "MCP server" },
+    { path: "src/main.ts", desc: "Main entry" },
+    { path: "src/app.ts", desc: "App entry" },
+    { path: "src/server.ts", desc: "Server entry" },
+    { path: "index.ts", desc: "Root entry" },
+    { path: "index.js", desc: "Root entry" }
+  ];
+  for (const c of candidates) {
+    if (existsSync8(join8(projectRoot, c.path))) {
+      entries.push({ path: c.path, description: c.desc });
+    }
+  }
+  return entries;
+}
+function scanModules(dir, projectRoot, ignoreDirs = ["node_modules", "dist", ".git", ".sparn", "coverage"]) {
+  const modules = [];
+  try {
+    const entries = readdirSync4(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join8(dir, entry.name);
+      if (entry.isDirectory() && !ignoreDirs.includes(entry.name)) {
+        modules.push(...scanModules(fullPath, projectRoot, ignoreDirs));
+      } else if (entry.isFile() && [".ts", ".tsx", ".js", ".jsx"].includes(extname3(entry.name))) {
+        try {
+          const content = readFileSync9(fullPath, "utf-8");
+          modules.push({
+            path: relative3(projectRoot, fullPath).replace(/\\/g, "/"),
+            lines: content.split("\n").length
+          });
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return modules;
+}
+function readPackageJson(projectRoot) {
+  const pkgPath = join8(projectRoot, "package.json");
+  if (!existsSync8(pkgPath)) return null;
+  try {
+    return JSON.parse(readFileSync9(pkgPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function detectStack(projectRoot) {
+  const stack = [];
+  const pkg = readPackageJson(projectRoot);
+  if (!pkg) return stack;
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  if (allDeps["typescript"]) stack.push("TypeScript");
+  if (allDeps["vitest"]) stack.push("Vitest");
+  if (allDeps["@biomejs/biome"]) stack.push("Biome");
+  if (allDeps["eslint"]) stack.push("ESLint");
+  if (allDeps["prettier"]) stack.push("Prettier");
+  if (allDeps["react"]) stack.push("React");
+  if (allDeps["next"]) stack.push("Next.js");
+  if (allDeps["express"]) stack.push("Express");
+  if (allDeps["commander"]) stack.push("Commander.js CLI");
+  if (allDeps["better-sqlite3"]) stack.push("SQLite (better-sqlite3)");
+  if (allDeps["zod"]) stack.push("Zod validation");
+  return stack;
+}
+function createDocsGenerator(config) {
+  const { projectRoot, includeGraph = true } = config;
+  async function generate(graph) {
+    const lines = [];
+    const pkg = readPackageJson(projectRoot);
+    const projectName = pkg?.name || "Project";
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    lines.push(`# ${projectName} \u2014 Developer Guide`);
+    lines.push(`<!-- Auto-generated by Sparn v1.3.0 \u2014 ${now} -->`);
+    lines.push("");
+    const stack = detectStack(projectRoot);
+    if (stack.length > 0) {
+      lines.push(`**Stack**: ${stack.join(", ")}`);
+      lines.push("");
+    }
+    if (pkg?.scripts) {
+      lines.push("## Commands");
+      lines.push("");
+      const important = ["build", "dev", "test", "lint", "typecheck", "start"];
+      for (const cmd of important) {
+        if (pkg.scripts[cmd]) {
+          lines.push(`- \`npm run ${cmd}\` \u2014 \`${pkg.scripts[cmd]}\``);
+        }
+      }
+      lines.push("");
+    }
+    const entryPoints = detectEntryPoints(projectRoot);
+    if (entryPoints.length > 0) {
+      lines.push("## Entry Points");
+      lines.push("");
+      for (const ep of entryPoints) {
+        lines.push(`- \`${ep.path}\` \u2014 ${ep.description}`);
+      }
+      lines.push("");
+    }
+    const srcDir = join8(projectRoot, "src");
+    if (existsSync8(srcDir)) {
+      const modules = scanModules(srcDir, projectRoot);
+      const dirGroups = /* @__PURE__ */ new Map();
+      for (const mod of modules) {
+        const parts = mod.path.split("/");
+        const dir = parts.length > 2 ? parts.slice(0, 2).join("/") : parts[0] || "";
+        if (!dirGroups.has(dir)) {
+          dirGroups.set(dir, []);
+        }
+        dirGroups.get(dir)?.push({
+          file: parts[parts.length - 1] || mod.path,
+          lines: mod.lines
+        });
+      }
+      lines.push("## Structure");
+      lines.push("");
+      for (const [dir, files] of dirGroups) {
+        lines.push(`### ${dir}/ (${files.length} files)`);
+        const shown = files.slice(0, 8);
+        for (const f of shown) {
+          lines.push(`- \`${f.file}\` (${f.lines}L)`);
+        }
+        if (files.length > 8) {
+          lines.push(`- ... and ${files.length - 8} more`);
+        }
+        lines.push("");
+      }
+    }
+    if (includeGraph && graph) {
+      try {
+        const analysis = await graph.analyze();
+        lines.push("## Hot Dependencies (most imported)");
+        lines.push("");
+        for (const path2 of analysis.hotPaths.slice(0, 5)) {
+          const node = graph.getNodes().get(path2);
+          const callerCount = node?.callers.length || 0;
+          lines.push(`- \`${path2}\` (imported by ${callerCount} modules)`);
+        }
+        lines.push("");
+        if (analysis.orphans.length > 0) {
+          lines.push(
+            `**Orphaned files** (${analysis.orphans.length}): ${analysis.orphans.slice(0, 3).join(", ")}${analysis.orphans.length > 3 ? "..." : ""}`
+          );
+          lines.push("");
+        }
+        lines.push(
+          `**Total tokens**: ${analysis.totalTokens.toLocaleString()} | **Hot path tokens**: ${analysis.optimizedTokens.toLocaleString()}`
+        );
+        lines.push("");
+      } catch {
+      }
+    }
+    const sparnConfigPath = join8(projectRoot, ".sparn", "config.yaml");
+    if (existsSync8(sparnConfigPath)) {
+      lines.push("## Sparn Optimization");
+      lines.push("");
+      lines.push("Sparn is active in this project. Key features:");
+      lines.push("- Context optimization (60-70% token reduction)");
+      lines.push("- Use `sparn search` before reading files");
+      lines.push("- Use `sparn graph` to understand dependencies");
+      lines.push("- Use `sparn plan` for planning, `sparn exec` for execution");
+      lines.push("");
+    }
+    if (config.customSections) {
+      for (const section of config.customSections) {
+        lines.push(section);
+        lines.push("");
+      }
+    }
+    return lines.join("\n");
+  }
+  return { generate };
+}
+var init_docs_generator = __esm({
+  "src/core/docs-generator.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli/commands/docs.ts
+var docs_exports = {};
+__export(docs_exports, {
+  docsCommand: () => docsCommand
+});
+import { writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve9 } from "path";
+async function docsCommand(options) {
+  const projectRoot = resolve9(process.cwd());
+  const generator = createDocsGenerator({
+    projectRoot,
+    includeGraph: options.includeGraph !== false
+  });
+  let graph;
+  if (options.includeGraph !== false) {
+    graph = createDependencyGraph({ projectRoot });
+    await graph.build();
+  }
+  const content = await generator.generate(graph);
+  if (options.json) {
+    return {
+      content,
+      message: `CLAUDE.md generated (${content.split("\n").length} lines)`
+    };
+  }
+  const outputPath = options.output || resolve9(projectRoot, "CLAUDE.md");
+  writeFileSync6(outputPath, content, "utf-8");
+  return {
+    content,
+    outputPath,
+    message: `CLAUDE.md generated at ${outputPath} (${content.split("\n").length} lines)`
+  };
+}
+var init_docs = __esm({
+  "src/cli/commands/docs.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_dependency_graph();
+    init_docs_generator();
+  }
+});
+
+// src/core/debt-tracker.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import Database3 from "better-sqlite3";
+function createDebtTracker(dbPath) {
+  const db = new Database3(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS tech_debt (
+      id TEXT PRIMARY KEY NOT NULL,
+      description TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      repayment_date INTEGER NOT NULL,
+      severity TEXT NOT NULL CHECK(severity IN ('P0', 'P1', 'P2')),
+      token_cost INTEGER NOT NULL DEFAULT 0,
+      files_affected TEXT NOT NULL DEFAULT '[]',
+      status TEXT NOT NULL DEFAULT 'open' CHECK(status IN ('open', 'in_progress', 'resolved')),
+      resolution_tokens INTEGER,
+      resolved_at INTEGER
+    );
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_debt_status ON tech_debt(status);
+    CREATE INDEX IF NOT EXISTS idx_debt_severity ON tech_debt(severity);
+    CREATE INDEX IF NOT EXISTS idx_debt_repayment ON tech_debt(repayment_date);
+  `);
+  const insertStmt = db.prepare(`
+    INSERT INTO tech_debt (id, description, created_at, repayment_date, severity, token_cost, files_affected, status)
+    VALUES (?, ?, ?, ?, ?, ?, ?, 'open')
+  `);
+  const getStmt = db.prepare("SELECT * FROM tech_debt WHERE id = ?");
+  function rowToDebt(row) {
+    return {
+      id: row["id"],
+      description: row["description"],
+      created_at: row["created_at"],
+      repayment_date: row["repayment_date"],
+      severity: row["severity"],
+      token_cost: row["token_cost"],
+      files_affected: JSON.parse(row["files_affected"] || "[]"),
+      status: row["status"],
+      resolution_tokens: row["resolution_tokens"],
+      resolved_at: row["resolved_at"]
+    };
+  }
+  async function add(debt) {
+    const id = randomUUID4().split("-")[0] || "debt";
+    const created_at = Date.now();
+    insertStmt.run(
+      id,
+      debt.description,
+      created_at,
+      debt.repayment_date,
+      debt.severity,
+      debt.token_cost,
+      JSON.stringify(debt.files_affected)
+    );
+    return {
+      id,
+      created_at,
+      status: "open",
+      description: debt.description,
+      repayment_date: debt.repayment_date,
+      severity: debt.severity,
+      token_cost: debt.token_cost,
+      files_affected: debt.files_affected
+    };
+  }
+  async function list(filter = {}) {
+    let sql = "SELECT * FROM tech_debt WHERE 1=1";
+    const params = [];
+    if (filter.status) {
+      sql += " AND status = ?";
+      params.push(filter.status);
+    }
+    if (filter.severity) {
+      sql += " AND severity = ?";
+      params.push(filter.severity);
+    }
+    if (filter.overdue) {
+      sql += " AND repayment_date < ? AND status != ?";
+      params.push(Date.now());
+      params.push("resolved");
+    }
+    sql += " ORDER BY severity ASC, repayment_date ASC";
+    const rows = db.prepare(sql).all(...params);
+    return rows.map(rowToDebt);
+  }
+  async function get(id) {
+    const row = getStmt.get(id);
+    if (!row) return null;
+    return rowToDebt(row);
+  }
+  async function resolve12(id, resolutionTokens) {
+    const result = db.prepare(
+      "UPDATE tech_debt SET status = ?, resolution_tokens = ?, resolved_at = ? WHERE id = ?"
+    ).run("resolved", resolutionTokens ?? null, Date.now(), id);
+    if (result.changes === 0) {
+      throw new Error(`Debt not found: ${id}`);
+    }
+  }
+  async function start(id) {
+    const result = db.prepare("UPDATE tech_debt SET status = ? WHERE id = ?").run("in_progress", id);
+    if (result.changes === 0) {
+      throw new Error(`Debt not found: ${id}`);
+    }
+  }
+  async function remove(id) {
+    db.prepare("DELETE FROM tech_debt WHERE id = ?").run(id);
+  }
+  async function stats() {
+    const all = db.prepare("SELECT * FROM tech_debt").all();
+    const debts = all.map(rowToDebt);
+    const now = Date.now();
+    const open = debts.filter((d) => d.status === "open");
+    const inProgress = debts.filter((d) => d.status === "in_progress");
+    const resolved = debts.filter((d) => d.status === "resolved");
+    const overdue = debts.filter((d) => d.status !== "resolved" && d.repayment_date < now);
+    const totalTokenCost = debts.reduce((sum, d) => sum + d.token_cost, 0);
+    const resolvedTokenCost = resolved.reduce(
+      (sum, d) => sum + (d.resolution_tokens || d.token_cost),
+      0
+    );
+    const resolvedOnTime = resolved.filter(
+      (d) => d.resolved_at && d.resolved_at <= d.repayment_date
+    ).length;
+    const repaymentRate = resolved.length > 0 ? resolvedOnTime / resolved.length : 0;
+    return {
+      total: debts.length,
+      open: open.length,
+      in_progress: inProgress.length,
+      resolved: resolved.length,
+      overdue: overdue.length,
+      totalTokenCost,
+      resolvedTokenCost,
+      repaymentRate
+    };
+  }
+  async function getCritical() {
+    const rows = db.prepare(
+      "SELECT * FROM tech_debt WHERE severity = 'P0' AND status != 'resolved' ORDER BY repayment_date ASC"
+    ).all();
+    return rows.map(rowToDebt);
+  }
+  async function close() {
+    db.close();
+  }
+  return {
+    add,
+    list,
+    get,
+    resolve: resolve12,
+    start,
+    remove,
+    stats,
+    getCritical,
+    close
+  };
+}
+var init_debt_tracker = __esm({
+  "src/core/debt-tracker.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli/commands/debt.ts
+var debt_exports = {};
+__export(debt_exports, {
+  debtCommand: () => debtCommand
+});
+import { resolve as resolve10 } from "path";
+async function debtCommand(options) {
+  const projectRoot = resolve10(process.cwd());
+  const dbPath = resolve10(projectRoot, ".sparn", "memory.db");
+  const tracker = createDebtTracker(dbPath);
+  try {
+    switch (options.subcommand) {
+      case "add": {
+        if (!options.description) {
+          throw new Error("Description is required");
+        }
+        const severity = options.severity || "P1";
+        if (!["P0", "P1", "P2"].includes(severity)) {
+          throw new Error("Severity must be P0, P1, or P2");
+        }
+        let repaymentDate;
+        if (options.due) {
+          repaymentDate = new Date(options.due).getTime();
+          if (Number.isNaN(repaymentDate)) {
+            throw new Error(`Invalid date: ${options.due}`);
+          }
+        } else {
+          repaymentDate = Date.now() + 14 * 24 * 60 * 60 * 1e3;
+        }
+        const debt = await tracker.add({
+          description: options.description,
+          repayment_date: repaymentDate,
+          severity,
+          token_cost: options.tokenCost || 0,
+          files_affected: options.files || []
+        });
+        const result = {
+          debt,
+          message: `Debt ${debt.id} added (${severity}): ${options.description}`
+        };
+        if (options.json) {
+          result.json = JSON.stringify(debt, null, 2);
+        }
+        return result;
+      }
+      case "list": {
+        const debts = await tracker.list({
+          overdue: options.overdue
+        });
+        const result = {
+          debts,
+          message: `${debts.length} debt item(s)`
+        };
+        if (options.json) {
+          result.json = JSON.stringify(debts, null, 2);
+        }
+        return result;
+      }
+      case "resolve": {
+        if (!options.id) {
+          throw new Error("Debt ID is required");
+        }
+        await tracker.resolve(options.id, options.tokenCost);
+        return {
+          message: `Debt ${options.id} resolved`
+        };
+      }
+      case "start": {
+        if (!options.id) {
+          throw new Error("Debt ID is required");
+        }
+        await tracker.start(options.id);
+        return {
+          message: `Debt ${options.id} started`
+        };
+      }
+      case "stats": {
+        const stats = await tracker.stats();
+        const result = {
+          stats,
+          message: `${stats.total} total, ${stats.open} open, ${stats.overdue} overdue, ${(stats.repaymentRate * 100).toFixed(0)}% on-time rate`
+        };
+        if (options.json) {
+          result.json = JSON.stringify(stats, null, 2);
+        }
+        return result;
+      }
+      default:
+        throw new Error(`Unknown subcommand: ${options.subcommand}`);
+    }
+  } finally {
+    await tracker.close();
+  }
+}
+var init_debt = __esm({
+  "src/cli/commands/debt.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_debt_tracker();
+  }
+});
+
+// src/cli/dashboard/theme.ts
+var theme;
+var init_theme = __esm({
+  "src/cli/dashboard/theme.ts"() {
+    "use strict";
+    init_esm_shims();
+    theme = {
+      neuralCyan: "#00D4AA",
+      synapseViolet: "#7B61FF",
+      errorRed: "#FF6B6B",
+      brainPink: "#FF6B9D",
+      dimGray: "#555555",
+      white: "#FFFFFF"
+    };
+  }
+});
+
+// src/cli/dashboard/components/command-input.tsx
+import { Box, Text } from "ink";
+import TextInput from "ink-text-input";
+import { useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function CommandInput({
+  onSubmit,
+  isRunning,
+  runningCommand,
+  active
+}) {
+  const [value, setValue] = useState("");
+  const handleSubmit = (input2) => {
+    if (input2.trim().length === 0) return;
+    onSubmit(input2.trim());
+    setValue("");
+  };
+  if (isRunning) {
+    return /* @__PURE__ */ jsx(Box, { paddingX: 1, children: /* @__PURE__ */ jsxs(Text, { color: theme.synapseViolet, children: [
+      "Running ",
+      runningCommand || "command",
+      "..."
+    ] }) });
+  }
+  if (!active) {
+    return /* @__PURE__ */ jsx(Box, { paddingX: 1, children: /* @__PURE__ */ jsx(Text, { color: theme.dimGray, children: "Press : to enter command mode" }) });
+  }
+  return /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { color: theme.neuralCyan, children: [
+      "\u276F",
+      " "
+    ] }),
+    /* @__PURE__ */ jsx(
+      TextInput,
+      {
+        value,
+        onChange: setValue,
+        onSubmit: handleSubmit,
+        focus: active,
+        showCursor: true
+      }
+    ),
+    /* @__PURE__ */ jsx(Text, { color: theme.dimGray, children: " [Esc: monitor mode]" })
+  ] });
+}
+var init_command_input = __esm({
+  "src/cli/dashboard/components/command-input.tsx"() {
+    "use strict";
+    init_esm_shims();
+    init_theme();
+  }
+});
+
+// src/cli/dashboard/components/output-panel.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function OutputPanel({
+  lines,
+  scrollOffset,
+  focused,
+  maxVisibleLines = 8
+}) {
+  const borderColor = focused ? theme.neuralCyan : theme.dimGray;
+  if (lines.length === 0) {
+    return /* @__PURE__ */ jsxs2(
+      Box2,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor,
+        paddingX: 1,
+        width: "100%",
+        children: [
+          /* @__PURE__ */ jsx2(Text2, { bold: true, color: theme.dimGray, children: "Output" }),
+          /* @__PURE__ */ jsx2(Text2, { color: theme.dimGray, children: "Type : then a command. Try help for available commands." })
+        ]
+      }
+    );
+  }
+  const visible = lines.slice(scrollOffset, scrollOffset + maxVisibleLines);
+  const hasMore = lines.length > maxVisibleLines;
+  return /* @__PURE__ */ jsxs2(
+    Box2,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor,
+      paddingX: 1,
+      width: "100%",
+      children: [
+        /* @__PURE__ */ jsx2(Text2, { bold: true, color: theme.dimGray, children: "Output" }),
+        /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: visible.map((line, i) => /* @__PURE__ */ jsx2(Text2, { color: line.color, children: line.text }, `${scrollOffset + i}`)) }),
+        hasMore && /* @__PURE__ */ jsxs2(Text2, { color: theme.dimGray, children: [
+          "[",
+          scrollOffset + 1,
+          "-",
+          Math.min(scrollOffset + maxVisibleLines, lines.length),
+          "/",
+          lines.length,
+          "]",
+          focused ? " \u2191\u2193 scroll" : ""
+        ] })
+      ]
+    }
+  );
+}
+var init_output_panel = __esm({
+  "src/cli/dashboard/components/output-panel.tsx"() {
+    "use strict";
+    init_esm_shims();
+    init_theme();
+  }
+});
+
+// src/cli/dashboard/command-parser.ts
+function tokenize2(input2) {
+  const tokens = [];
+  let current = "";
+  let inQuote = null;
+  for (const ch of input2) {
+    if (inQuote) {
+      if (ch === inQuote) {
+        inQuote = null;
+      } else {
+        current += ch;
+      }
+    } else if (ch === '"' || ch === "'") {
+      inQuote = ch;
+    } else if (ch === " " || ch === "	") {
+      if (current.length > 0) {
+        tokens.push(current);
+        current = "";
+      }
+    } else {
+      current += ch;
+    }
+  }
+  if (current.length > 0) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+function parseCommand(input2) {
+  const trimmed = input2.trim();
+  if (trimmed.length === 0) return null;
+  const tokens = tokenize2(trimmed);
+  const first = tokens[0];
+  if (!first) return null;
+  const name = first.toLowerCase();
+  const positionals = [];
+  const flags = {};
+  let i = 1;
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (!token) {
+      i++;
+      continue;
+    }
+    if (token.startsWith("--")) {
+      const key = token.slice(2);
+      const next = tokens[i + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        flags[key] = next;
+        i += 2;
+      } else {
+        flags[key] = true;
+        i++;
+      }
+    } else if (token.startsWith("-") && token.length === 2) {
+      const key = token.slice(1);
+      const next = tokens[i + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        flags[key] = next;
+        i += 2;
+      } else {
+        flags[key] = true;
+        i++;
+      }
+    } else {
+      positionals.push(token);
+      i++;
+    }
+  }
+  return { name, positionals, flags };
+}
+var init_command_parser = __esm({
+  "src/cli/dashboard/command-parser.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli/dashboard/formatters.ts
+function formatOptimize(result) {
+  const pct = (result.reduction * 100).toFixed(1);
+  return [
+    { text: `\u2713 Optimization complete in ${result.durationMs}ms`, color: theme.neuralCyan },
+    {
+      text: `  Tokens: ${result.tokensBefore} \u2192 ${result.tokensAfter} (${pct}% reduction)`
+    },
+    {
+      text: `  Entries: processed=${result.entriesProcessed} kept=${result.entriesKept}`
+    },
+    ...result.outputFile ? [{ text: `  Output: ${result.outputFile}`, color: theme.dimGray }] : []
+  ];
+}
+function formatStats(result) {
+  if (result.resetConfirmed) {
+    return [{ text: "\u2713 Statistics reset", color: theme.neuralCyan }];
+  }
+  const avgPct = (result.averageReduction * 100).toFixed(1);
+  const lines = [
+    { text: "Optimization Statistics", color: theme.neuralCyan },
+    { text: `  Total commands: ${result.totalCommands}` },
+    { text: `  Tokens saved:   ${result.totalTokensSaved}` },
+    { text: `  Avg reduction:  ${avgPct}%` }
+  ];
+  if (result.graph) {
+    for (const line of result.graph.split("\n")) {
+      lines.push({ text: line, color: theme.dimGray });
+    }
+  }
+  return lines;
+}
+function formatConsolidate(result) {
+  const pct = (result.compressionRatio * 100).toFixed(1);
+  return [
+    { text: `\u2713 Consolidation complete in ${result.durationMs}ms`, color: theme.neuralCyan },
+    { text: `  Entries: ${result.entriesBefore} \u2192 ${result.entriesAfter}` },
+    { text: `  Decayed removed: ${result.decayedRemoved}` },
+    { text: `  Duplicates removed: ${result.duplicatesRemoved}` },
+    { text: `  Compression: ${pct}%` }
+  ];
+}
+function formatSearch(result) {
+  if (result.indexStats) {
+    const s = result.indexStats;
+    return [
+      {
+        text: `\u2713 Indexed ${s.filesIndexed} files (${s.totalLines} lines) in ${s.duration}ms`,
+        color: theme.neuralCyan
+      }
+    ];
+  }
+  if (!result.results || result.results.length === 0) {
+    return [{ text: result.message || "No results found", color: theme.dimGray }];
+  }
+  const lines = [
+    { text: `${result.results.length} result(s):`, color: theme.neuralCyan }
+  ];
+  for (const r of result.results) {
+    lines.push({
+      text: `  ${r.filePath}:${r.lineNumber} (score: ${r.score.toFixed(2)})`,
+      color: theme.synapseViolet
+    });
+    lines.push({ text: `    ${r.content.trim()}` });
+  }
+  return lines;
+}
+function formatGraph(result) {
+  const a = result.analysis;
+  const lines = [
+    { text: `Graph: ${result.nodeCount} nodes`, color: theme.neuralCyan },
+    { text: `  Tokens: ${a.totalTokens} (optimized: ${a.optimizedTokens})` }
+  ];
+  if (a.hotPaths.length > 0) {
+    lines.push({
+      text: `  Hot paths: ${a.hotPaths.slice(0, 5).join(", ")}`,
+      color: theme.brainPink
+    });
+  }
+  if (a.orphans.length > 0) {
+    lines.push({ text: `  Orphans: ${a.orphans.length}`, color: theme.dimGray });
+  }
+  return lines;
+}
+function formatPlan(result) {
+  return [{ text: `\u2713 ${result.message}`, color: theme.neuralCyan }];
+}
+function formatPlanList(result) {
+  if (result.plans.length === 0) {
+    return [{ text: "No plans found", color: theme.dimGray }];
+  }
+  const lines = [
+    { text: `${result.plans.length} plan(s):`, color: theme.neuralCyan }
+  ];
+  for (const p of result.plans) {
+    const statusColor = p.status === "completed" ? theme.neuralCyan : theme.synapseViolet;
+    lines.push({ text: `  ${p.id} [${p.status}] ${p.task}`, color: statusColor });
+  }
+  return lines;
+}
+function formatExec(result) {
+  return [
+    { text: `\u2713 ${result.message}`, color: theme.neuralCyan },
+    {
+      text: `  Max reads: ${result.constraints.maxFileReads}, Budget: ${result.constraints.tokenBudget} tokens`
+    }
+  ];
+}
+function formatVerify(result) {
+  const v = result.verification;
+  const icon = v.success ? "\u2713" : "\u2717";
+  const color = v.success ? theme.neuralCyan : theme.errorRed;
+  return [
+    { text: `${icon} ${result.message}`, color },
+    { text: `  Steps: ${v.stepsCompleted}/${v.totalSteps} completed` }
+  ];
+}
+function formatDocs(result) {
+  return [{ text: `\u2713 ${result.message}`, color: theme.neuralCyan }];
+}
+function formatDebt(result) {
+  if (result.stats) {
+    const s = result.stats;
+    return [
+      { text: "Debt Stats", color: theme.neuralCyan },
+      { text: `  Total: ${s.total}, Open: ${s.open}, Overdue: ${s.overdue}` },
+      { text: `  Repayment rate: ${(s.repaymentRate * 100).toFixed(0)}%` }
+    ];
+  }
+  if (result.debts) {
+    if (result.debts.length === 0) {
+      return [{ text: "No debt items", color: theme.dimGray }];
+    }
+    const lines = [
+      { text: `${result.debts.length} debt item(s):`, color: theme.neuralCyan }
+    ];
+    for (const d of result.debts) {
+      const sevColor = d.severity === "P0" ? theme.errorRed : d.severity === "P1" ? theme.synapseViolet : theme.dimGray;
+      const desc = d.description.length > 40 ? `${d.description.substring(0, 37)}...` : d.description;
+      lines.push({
+        text: `  [${d.severity}] ${d.id.slice(0, 8)} ${desc} (${d.status})`,
+        color: sevColor
+      });
+    }
+    return lines;
+  }
+  return [{ text: `\u2713 ${result.message}`, color: theme.neuralCyan }];
+}
+function formatError(err) {
+  return [{ text: `Error: ${err.message}`, color: theme.errorRed }];
+}
+function formatHelp() {
+  return [
+    { text: "Available commands:", color: theme.neuralCyan },
+    { text: "  optimize --input <text> [--input-file <path>] [--output-file <path>] [--dry-run]" },
+    { text: "  stats [--graph] [--reset --confirm-reset]" },
+    { text: "  consolidate" },
+    { text: "  search <query> [--glob <pattern>] [--max-results <n>]" },
+    { text: "  search init | search refresh" },
+    { text: "  graph [--entry <file>] [--depth <n>] [--focus <file>]" },
+    { text: "  plan <task> [--files <f1,f2>] [--searches <q1,q2>]" },
+    { text: "  plan list" },
+    { text: "  exec <planId>" },
+    { text: "  verify <planId>" },
+    { text: "  docs [--output <path>] [--no-graph]" },
+    { text: "  debt add <desc> [--severity P0|P1|P2] [--due <date>] [--token-cost <n>]" },
+    { text: "  debt list [--overdue]" },
+    { text: "  debt resolve <id> [--token-cost <n>]" },
+    { text: "  debt start <id>" },
+    { text: "  debt stats" },
+    { text: "  clear                              Clear output" },
+    { text: "  help                               Show this help" },
+    { text: "" },
+    { text: "Keybinds:", color: theme.neuralCyan },
+    { text: "  :       Enter command mode" },
+    { text: "  Escape  Exit command mode" },
+    { text: "  Tab     Cycle panel focus" },
+    { text: "  q       Quit (in monitor mode)" }
+  ];
+}
+var init_formatters = __esm({
+  "src/cli/dashboard/formatters.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_theme();
+  }
+});
+
+// src/cli/dashboard/hooks/use-command-executor.ts
+import { useCallback, useState as useState2 } from "react";
+function useCommandExecutor({
+  getMemory,
+  forceRefresh,
+  dbPath,
+  projectRoot
+}) {
+  const [outputLines, setOutputLines] = useState2([]);
+  const [isRunning, setIsRunning] = useState2(false);
+  const [runningCommand, setRunningCommand] = useState2();
+  const appendLines = useCallback((lines) => {
+    setOutputLines((prev) => {
+      const next = [...prev, ...lines];
+      return next.length > MAX_OUTPUT_LINES ? next.slice(-MAX_OUTPUT_LINES) : next;
+    });
+  }, []);
+  const clearOutput = useCallback(() => {
+    setOutputLines([]);
+  }, []);
+  const execute = useCallback(
+    (rawInput) => {
+      const parsed = parseCommand(rawInput);
+      if (!parsed) return;
+      if (parsed.name === "clear") {
+        clearOutput();
+        return;
+      }
+      if (parsed.name === "help") {
+        appendLines(formatHelp());
+        return;
+      }
+      setIsRunning(true);
+      setRunningCommand(parsed.name);
+      void (async () => {
+        try {
+          const lines = await executeCommand2(parsed.name, parsed.positionals, parsed.flags, {
+            getMemory,
+            dbPath,
+            projectRoot
+          });
+          appendLines(lines);
+          forceRefresh();
+        } catch (err) {
+          appendLines(formatError(err instanceof Error ? err : new Error(String(err))));
+        } finally {
+          setIsRunning(false);
+          setRunningCommand(void 0);
+        }
+      })();
+    },
+    [getMemory, forceRefresh, dbPath, projectRoot, appendLines, clearOutput]
+  );
+  return { execute, outputLines, isRunning, runningCommand, clearOutput };
+}
+async function executeCommand2(name, positionals, flags, ctx) {
+  switch (name) {
+    case "optimize": {
+      const memory = ctx.getMemory();
+      if (!memory) throw new Error("Memory not initialized");
+      const { optimizeCommand: optimizeCommand2 } = await Promise.resolve().then(() => (init_optimize(), optimize_exports));
+      const result = await optimizeCommand2({
+        memory,
+        input: typeof flags["input"] === "string" ? flags["input"] : void 0,
+        inputFile: typeof flags["input-file"] === "string" ? flags["input-file"] : void 0,
+        outputFile: typeof flags["output-file"] === "string" ? flags["output-file"] : void 0,
+        dryRun: flags["dry-run"] === true,
+        verbose: flags["verbose"] === true || flags["v"] === true
+      });
+      return formatOptimize(result);
+    }
+    case "stats": {
+      const memory = ctx.getMemory();
+      if (!memory) throw new Error("Memory not initialized");
+      const { statsCommand: statsCommand2 } = await Promise.resolve().then(() => (init_stats(), stats_exports));
+      const result = await statsCommand2({
+        memory,
+        graph: flags["graph"] === true || flags["g"] === true,
+        reset: flags["reset"] === true,
+        confirmReset: flags["confirm-reset"] === true
+      });
+      return formatStats(result);
+    }
+    case "consolidate": {
+      const memory = ctx.getMemory();
+      if (!memory) throw new Error("Memory not initialized");
+      const { consolidateCommand: consolidateCommand2 } = await Promise.resolve().then(() => (init_consolidate(), consolidate_exports));
+      const result = await consolidateCommand2({ memory });
+      return formatConsolidate(result);
+    }
+    case "search": {
+      const { searchCommand: searchCommand2 } = await Promise.resolve().then(() => (init_search(), search_exports));
+      const subcommand = positionals[0] === "init" || positionals[0] === "refresh" ? positionals[0] : void 0;
+      const query = subcommand ? void 0 : positionals.join(" ") || void 0;
+      const result = await searchCommand2({
+        query,
+        subcommand,
+        glob: typeof flags["glob"] === "string" ? flags["glob"] : void 0,
+        maxResults: typeof flags["max-results"] === "string" ? Number.parseInt(flags["max-results"], 10) : void 0
+      });
+      return formatSearch(result);
+    }
+    case "graph": {
+      const { graphCommand: graphCommand2 } = await Promise.resolve().then(() => (init_graph(), graph_exports));
+      const result = await graphCommand2({
+        entry: typeof flags["entry"] === "string" ? flags["entry"] : void 0,
+        depth: typeof flags["depth"] === "string" ? Number.parseInt(flags["depth"], 10) : void 0,
+        focus: typeof flags["focus"] === "string" ? flags["focus"] : void 0
+      });
+      return formatGraph(result);
+    }
+    case "plan": {
+      if (positionals[0] === "list") {
+        const { planListCommand: planListCommand2 } = await Promise.resolve().then(() => (init_plan(), plan_exports));
+        const result2 = await planListCommand2({});
+        return formatPlanList(result2);
+      }
+      const { planCommand: planCommand2 } = await Promise.resolve().then(() => (init_plan(), plan_exports));
+      const task = positionals.join(" ");
+      if (!task) throw new Error("Task description required: plan <task>");
+      const files = typeof flags["files"] === "string" ? flags["files"].split(",") : void 0;
+      const searches = typeof flags["searches"] === "string" ? flags["searches"].split(",") : void 0;
+      const result = await planCommand2({ task, files, searches });
+      return formatPlan(result);
+    }
+    case "exec": {
+      const planId = positionals[0];
+      if (!planId) throw new Error("Plan ID required: exec <planId>");
+      const { execCommand: execCommand2 } = await Promise.resolve().then(() => (init_exec(), exec_exports));
+      const result = await execCommand2({ planId });
+      return formatExec(result);
+    }
+    case "verify": {
+      const planId = positionals[0];
+      if (!planId) throw new Error("Plan ID required: verify <planId>");
+      const { verifyCommand: verifyCommand2 } = await Promise.resolve().then(() => (init_verify(), verify_exports));
+      const result = await verifyCommand2({ planId });
+      return formatVerify(result);
+    }
+    case "docs": {
+      const { docsCommand: docsCommand2 } = await Promise.resolve().then(() => (init_docs(), docs_exports));
+      const result = await docsCommand2({
+        output: typeof flags["output"] === "string" ? flags["output"] : void 0,
+        includeGraph: flags["no-graph"] !== true
+      });
+      return formatDocs(result);
+    }
+    case "debt": {
+      const subcommand = positionals[0];
+      if (!subcommand || !["add", "list", "resolve", "stats", "start"].includes(subcommand)) {
+        throw new Error("Subcommand required: debt add|list|resolve|start|stats");
+      }
+      const { debtCommand: debtCommand2 } = await Promise.resolve().then(() => (init_debt(), debt_exports));
+      const result = await debtCommand2({
+        subcommand,
+        description: subcommand === "add" ? positionals.slice(1).join(" ") || void 0 : void 0,
+        severity: typeof flags["severity"] === "string" ? flags["severity"] : void 0,
+        due: typeof flags["due"] === "string" ? flags["due"] : void 0,
+        tokenCost: typeof flags["token-cost"] === "string" ? Number.parseInt(flags["token-cost"], 10) : void 0,
+        id: subcommand === "resolve" || subcommand === "start" ? positionals[1] : void 0,
+        overdue: flags["overdue"] === true
+      });
+      return formatDebt(result);
+    }
+    default:
+      throw new Error(`Unknown command: ${name}. Type help for available commands.`);
+  }
+}
+var MAX_OUTPUT_LINES;
+var init_use_command_executor = __esm({
+  "src/cli/dashboard/hooks/use-command-executor.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_command_parser();
+    init_formatters();
+    MAX_OUTPUT_LINES = 200;
+  }
+});
+
+// src/cli/dashboard/hooks/use-data.ts
+import { statSync as statSync3 } from "fs";
+import { useCallback as useCallback2, useEffect, useRef, useState as useState3 } from "react";
+function useDashboardData(dbPath, projectRoot, refreshInterval = 2e3) {
+  const [data, setData] = useState3(EMPTY_STATE);
+  const memoryRef = useRef(null);
+  const mountedRef = useRef(true);
+  const dbPathRef = useRef(dbPath);
+  dbPathRef.current = dbPath;
+  const getMemory = useCallback2(() => memoryRef.current, []);
+  const doRefreshFast = useCallback2(async () => {
+    const memory = memoryRef.current;
+    if (!memory) return;
+    await refreshFast(memory, dbPathRef.current, projectRoot, mountedRef, setData);
+  }, [projectRoot]);
+  const forceRefresh = useCallback2(() => {
+    void doRefreshFast();
+  }, [doRefreshFast]);
+  useEffect(() => {
+    let timer = null;
+    async function init() {
+      try {
+        const memory = await createKVMemory(dbPath);
+        if (!mountedRef.current) {
+          await memory.close();
+          return;
+        }
+        memoryRef.current = memory;
+        await refreshFast(memory, dbPath, projectRoot, mountedRef, setData);
+        await refreshGraph(projectRoot, mountedRef, setData);
+        timer = setInterval(() => {
+          if (memoryRef.current) {
+            void refreshFast(memoryRef.current, dbPath, projectRoot, mountedRef, setData);
+          }
+        }, refreshInterval);
+      } catch (err) {
+        if (mountedRef.current) {
+          setData((prev) => ({
+            ...prev,
+            loading: false,
+            error: err instanceof Error ? err.message : String(err)
+          }));
+        }
+      }
+    }
+    void init();
+    return () => {
+      mountedRef.current = false;
+      if (timer) clearInterval(timer);
+      if (memoryRef.current) {
+        void memoryRef.current.close();
+        memoryRef.current = null;
+      }
+    };
+  }, [dbPath, projectRoot, refreshInterval]);
+  return { ...data, getMemory, forceRefresh };
+}
+async function refreshFast(memory, path2, projectRoot, mountedRef, setData) {
+  try {
+    const [stats, ids, activeEntries, readyEntries, silentEntries] = await Promise.all([
+      memory.getOptimizationStats(),
+      memory.list(),
+      memory.query({ state: "active" }),
+      memory.query({ state: "ready" }),
+      memory.query({ state: "silent" })
+    ]);
+    let debts = [];
+    let debtStats = null;
+    try {
+      const tracker = createDebtTracker(path2);
+      debts = await tracker.list();
+      debtStats = await tracker.stats();
+      await tracker.close();
+    } catch {
+    }
+    let daemon = null;
+    try {
+      const { createDaemonCommand: createDaemonCommand2 } = await Promise.resolve().then(() => (init_daemon_process(), daemon_process_exports));
+      const { readFileSync: readFileSync11 } = await import("fs");
+      const { resolve: resolve12 } = await import("path");
+      const { load: parseYAML3 } = await import("js-yaml");
+      const configPath = resolve12(projectRoot, ".sparn/config.yaml");
+      const configContent = readFileSync11(configPath, "utf-8");
+      const config = parseYAML3(configContent);
+      daemon = await createDaemonCommand2().status(config);
+    } catch {
+    }
+    let dbSizeBytes = 0;
+    try {
+      dbSizeBytes = statSync3(path2).size;
+    } catch {
+    }
+    if (mountedRef.current) {
+      setData((prev) => ({
+        ...prev,
+        optimizationStats: stats,
+        totalEntries: ids.length,
+        stateDistribution: {
+          active: activeEntries.length,
+          ready: readyEntries.length,
+          silent: silentEntries.length
+        },
+        debts,
+        debtStats,
+        daemon,
+        dbSizeBytes,
+        loading: false,
+        error: null,
+        lastRefresh: /* @__PURE__ */ new Date()
+      }));
+    }
+  } catch (err) {
+    if (mountedRef.current) {
+      setData((prev) => ({
+        ...prev,
+        loading: false,
+        error: err instanceof Error ? err.message : String(err)
+      }));
+    }
+  }
+}
+async function refreshGraph(projectRoot, mountedRef, setData) {
+  try {
+    const graph = createDependencyGraph({ projectRoot });
+    const analysis = await graph.analyze();
+    const nodes = graph.getNodes();
+    if (mountedRef.current) {
+      setData((prev) => ({
+        ...prev,
+        graphAnalysis: analysis,
+        graphNodes: nodes
+      }));
+    }
+  } catch {
+  }
+}
+var NOOP, EMPTY_STATE;
+var init_use_data = __esm({
+  "src/cli/dashboard/hooks/use-data.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_debt_tracker();
+    init_dependency_graph();
+    init_kv_memory();
+    NOOP = () => {
+    };
+    EMPTY_STATE = {
+      optimizationStats: [],
+      totalEntries: 0,
+      stateDistribution: { active: 0, ready: 0, silent: 0 },
+      debts: [],
+      debtStats: null,
+      graphAnalysis: null,
+      graphNodes: /* @__PURE__ */ new Map(),
+      daemon: null,
+      dbSizeBytes: 0,
+      loading: true,
+      error: null,
+      lastRefresh: /* @__PURE__ */ new Date(),
+      getMemory: () => null,
+      forceRefresh: NOOP
+    };
+  }
+});
+
+// src/cli/dashboard/panels/debt-tracker.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function severityColor(severity) {
+  switch (severity) {
+    case "P0":
+      return theme.errorRed;
+    case "P1":
+      return theme.synapseViolet;
+    default:
+      return theme.dimGray;
+  }
+}
+function formatDate(ts) {
+  const d = new Date(ts);
+  return `${d.getMonth() + 1}/${d.getDate()}`;
+}
+function DebtTrackerPanel({
+  debts,
+  debtStats,
+  focused,
+  scrollOffset
+}) {
+  const borderColor = focused ? theme.neuralCyan : theme.dimGray;
+  const now = Date.now();
+  const openDebts = debts.filter((d) => d.status !== "resolved");
+  const visibleDebts = openDebts.slice(scrollOffset, scrollOffset + 8);
+  return /* @__PURE__ */ jsxs3(
+    Box3,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor,
+      paddingX: 1,
+      width: "50%",
+      flexGrow: 1,
+      children: [
+        /* @__PURE__ */ jsx3(Text3, { bold: true, color: theme.errorRed, children: "Tech Debt" }),
+        /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+          visibleDebts.length === 0 && /* @__PURE__ */ jsx3(Text3, { color: theme.dimGray, children: "No open debts" }),
+          visibleDebts.map((d) => {
+            const isOverdue = d.repayment_date < now && d.status !== "resolved";
+            const color = severityColor(d.severity);
+            const desc = d.description.length > 30 ? `${d.description.substring(0, 27)}...` : d.description;
+            return /* @__PURE__ */ jsxs3(Text3, { children: [
+              /* @__PURE__ */ jsxs3(Text3, { color, children: [
+                "[",
+                d.severity,
+                "]"
+              ] }),
+              " ",
+              desc,
+              " ",
+              /* @__PURE__ */ jsxs3(Text3, { color: theme.dimGray, children: [
+                "(due: ",
+                formatDate(d.repayment_date),
+                ")"
+              ] }),
+              isOverdue && /* @__PURE__ */ jsx3(Text3, { color: theme.errorRed, children: " OVERDUE" })
+            ] }, d.id);
+          }),
+          openDebts.length > 8 && /* @__PURE__ */ jsxs3(Text3, { color: theme.dimGray, children: [
+            "[",
+            scrollOffset + 1,
+            "-",
+            Math.min(scrollOffset + 8, openDebts.length),
+            "/",
+            openDebts.length,
+            "]",
+            focused ? " \u2191\u2193 scroll" : ""
+          ] })
+        ] }),
+        debtStats && /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsxs3(Text3, { color: theme.dimGray, children: [
+          "Open:",
+          debtStats.open,
+          " InProg:",
+          debtStats.in_progress,
+          " Resolved:",
+          debtStats.resolved,
+          " ",
+          "Overdue:",
+          debtStats.overdue
+        ] }) })
+      ]
+    }
+  );
+}
+var init_debt_tracker2 = __esm({
+  "src/cli/dashboard/panels/debt-tracker.tsx"() {
+    "use strict";
+    init_esm_shims();
+    init_theme();
+  }
+});
+
+// src/cli/dashboard/panels/graph-view.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function formatTokens(n) {
+  if (n >= 1e3) return `${(n / 1e3).toFixed(0)}K`;
+  return String(n);
+}
+function basename(filePath) {
+  const parts = filePath.replace(/\\/g, "/").split("/");
+  return parts[parts.length - 1] || filePath;
+}
+function buildTreeLines(nodes) {
+  const lines = [];
+  const sorted = [...nodes.values()].filter((n) => n.callers.length > 0).sort((a, b) => b.callers.length - a.callers.length).slice(0, 8);
+  for (const node of sorted) {
+    const name = basename(node.filePath);
+    const tok = formatTokens(node.tokenEstimate);
+    lines.push({
+      text: `${name} (${node.callers.length} callers, ${tok}tok)`,
+      color: theme.neuralCyan
+    });
+    const callerNames = node.callers.slice(0, 3).map(basename);
+    const remaining = node.callers.length - callerNames.length;
+    for (let i = 0; i < callerNames.length; i++) {
+      const isLast = i === callerNames.length - 1 && remaining === 0;
+      const prefix = isLast ? " \u2514\u2500\u2500 " : " \u251C\u2500\u2500 ";
+      lines.push({
+        text: `${prefix}${callerNames[i]}`,
+        color: theme.dimGray
+      });
+    }
+    if (remaining > 0) {
+      lines.push({
+        text: ` \u2514\u2500\u2500 ... ${remaining} more`,
+        color: theme.dimGray
+      });
+    }
+  }
+  return lines;
+}
+function GraphViewPanel({
+  analysis,
+  nodes,
+  focused,
+  scrollOffset
+}) {
+  const borderColor = focused ? theme.neuralCyan : theme.dimGray;
+  if (!analysis) {
+    return /* @__PURE__ */ jsxs4(
+      Box4,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor,
+        paddingX: 1,
+        width: "50%",
+        flexGrow: 1,
+        children: [
+          /* @__PURE__ */ jsx4(Text4, { bold: true, color: theme.synapseViolet, children: "Dependency Graph" }),
+          /* @__PURE__ */ jsx4(Text4, { color: theme.dimGray, children: "Loading graph..." })
+        ]
+      }
+    );
+  }
+  const lines = buildTreeLines(nodes);
+  const visibleLines = lines.slice(scrollOffset, scrollOffset + 12);
+  return /* @__PURE__ */ jsxs4(
+    Box4,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor,
+      paddingX: 1,
+      width: "50%",
+      flexGrow: 1,
+      children: [
+        /* @__PURE__ */ jsx4(Text4, { bold: true, color: theme.synapseViolet, children: "Dependency Graph" }),
+        /* @__PURE__ */ jsxs4(Text4, { color: theme.dimGray, children: [
+          analysis.entryPoints.length,
+          " entries | ",
+          analysis.orphans.length,
+          " orphans |",
+          " ",
+          formatTokens(analysis.totalTokens),
+          "tok"
+        ] }),
+        /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginTop: 1, children: [
+          visibleLines.map((line) => /* @__PURE__ */ jsx4(Text4, { color: line.color, children: line.text }, line.text)),
+          lines.length > 12 && /* @__PURE__ */ jsxs4(Text4, { color: theme.dimGray, children: [
+            "[",
+            scrollOffset + 1,
+            "-",
+            Math.min(scrollOffset + 12, lines.length),
+            "/",
+            lines.length,
+            "]",
+            focused ? " \u2191\u2193 scroll" : ""
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+var init_graph_view = __esm({
+  "src/cli/dashboard/panels/graph-view.tsx"() {
+    "use strict";
+    init_esm_shims();
+    init_theme();
+  }
+});
+
+// src/cli/dashboard/panels/memory-status.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function formatSize(bytes) {
+  if (bytes >= 1048576) return `${(bytes / 1048576).toFixed(1)} MB`;
+  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${bytes} B`;
+}
+function formatTokens2(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return String(n);
+}
+function MemoryStatusPanel({
+  totalEntries,
+  dbSizeBytes,
+  stateDistribution,
+  daemon,
+  focused
+}) {
+  const borderColor = focused ? theme.neuralCyan : theme.dimGray;
+  const daemonRunning = daemon?.running ?? false;
+  const daemonPid = daemon?.pid;
+  const sessions = daemon?.sessionsWatched;
+  const tokensSaved = daemon?.tokensSaved;
+  return /* @__PURE__ */ jsxs5(
+    Box5,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor,
+      paddingX: 1,
+      width: "50%",
+      flexGrow: 1,
+      children: [
+        /* @__PURE__ */ jsx5(Text5, { bold: true, color: theme.brainPink, children: "Memory / Daemon" }),
+        /* @__PURE__ */ jsxs5(Text5, { children: [
+          "Entries: ",
+          /* @__PURE__ */ jsx5(Text5, { color: theme.white, children: totalEntries }),
+          " | Size:",
+          " ",
+          /* @__PURE__ */ jsx5(Text5, { color: theme.white, children: formatSize(dbSizeBytes) })
+        ] }),
+        /* @__PURE__ */ jsxs5(Text5, { children: [
+          "Active: ",
+          /* @__PURE__ */ jsx5(Text5, { color: theme.neuralCyan, children: stateDistribution.active }),
+          " Ready:",
+          " ",
+          /* @__PURE__ */ jsx5(Text5, { color: theme.synapseViolet, children: stateDistribution.ready }),
+          " Silent:",
+          " ",
+          /* @__PURE__ */ jsx5(Text5, { color: theme.dimGray, children: stateDistribution.silent })
+        ] }),
+        /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: daemonRunning ? /* @__PURE__ */ jsxs5(Text5, { children: [
+          "Daemon: ",
+          /* @__PURE__ */ jsxs5(Text5, { color: theme.neuralCyan, children: [
+            "\u25CF",
+            " Running"
+          ] }),
+          daemonPid != null ? ` (PID ${daemonPid})` : ""
+        ] }) : /* @__PURE__ */ jsxs5(Text5, { children: [
+          "Daemon: ",
+          /* @__PURE__ */ jsxs5(Text5, { color: theme.errorRed, children: [
+            "\u25CF",
+            " Stopped"
+          ] })
+        ] }) }),
+        daemonRunning && /* @__PURE__ */ jsxs5(Text5, { children: [
+          "Sessions: ",
+          /* @__PURE__ */ jsx5(Text5, { color: theme.white, children: sessions ?? 0 }),
+          " | Saved:",
+          " ",
+          /* @__PURE__ */ jsx5(Text5, { color: theme.white, children: formatTokens2(tokensSaved ?? 0) })
+        ] })
+      ]
+    }
+  );
+}
+var init_memory_status = __esm({
+  "src/cli/dashboard/panels/memory-status.tsx"() {
+    "use strict";
+    init_esm_shims();
+    init_theme();
+  }
+});
+
+// src/cli/dashboard/panels/optimization.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function formatTime(ts) {
+  const d = new Date(ts);
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+function formatTokens3(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return String(n);
+}
+function makeBar(pct, width) {
+  const filled = Math.round(pct / 100 * width);
+  return "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+}
+function OptimizationPanel({ stats, focused }) {
+  const totalOpts = stats.length;
+  const totalSaved = stats.reduce((s, r) => s + (r.tokens_before - r.tokens_after), 0);
+  let avgReduction = 0;
+  if (totalOpts > 0) {
+    const totalBefore = stats.reduce((s, r) => s + r.tokens_before, 0);
+    avgReduction = totalBefore > 0 ? (totalBefore - (totalBefore - totalSaved)) / totalBefore * 100 : 0;
+  }
+  const recent = stats.slice(-5).reverse();
+  const borderColor = focused ? theme.neuralCyan : theme.dimGray;
+  return /* @__PURE__ */ jsxs6(
+    Box6,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor,
+      paddingX: 1,
+      width: "50%",
+      flexGrow: 1,
+      children: [
+        /* @__PURE__ */ jsx6(Text6, { bold: true, color: theme.neuralCyan, children: "Optimization Stats" }),
+        /* @__PURE__ */ jsxs6(Text6, { children: [
+          "Total: ",
+          /* @__PURE__ */ jsx6(Text6, { color: theme.white, children: totalOpts }),
+          " optimizations"
+        ] }),
+        /* @__PURE__ */ jsxs6(Text6, { children: [
+          "Saved: ",
+          /* @__PURE__ */ jsx6(Text6, { color: theme.white, children: formatTokens3(totalSaved) }),
+          " tokens"
+        ] }),
+        /* @__PURE__ */ jsxs6(Text6, { children: [
+          "Avg: ",
+          /* @__PURE__ */ jsxs6(Text6, { color: theme.white, children: [
+            avgReduction.toFixed(1),
+            "%"
+          ] }),
+          " ",
+          /* @__PURE__ */ jsx6(Text6, { color: theme.neuralCyan, children: makeBar(avgReduction, 10) })
+        ] }),
+        recent.length > 0 && /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginTop: 1, children: [
+          /* @__PURE__ */ jsx6(Text6, { color: theme.dimGray, children: "Recent:" }),
+          recent.map((r) => {
+            const pct = r.tokens_before > 0 ? ((r.tokens_before - r.tokens_after) / r.tokens_before * 100).toFixed(0) : "0";
+            return /* @__PURE__ */ jsxs6(Text6, { children: [
+              "  ",
+              formatTime(r.timestamp),
+              " | ",
+              formatTokens3(r.tokens_before),
+              "\u2192",
+              formatTokens3(r.tokens_after),
+              " | ",
+              pct,
+              "%"
+            ] }, r.id);
+          })
+        ] })
+      ]
+    }
+  );
+}
+var init_optimization = __esm({
+  "src/cli/dashboard/panels/optimization.tsx"() {
+    "use strict";
+    init_esm_shims();
+    init_theme();
+  }
+});
+
+// src/cli/dashboard/app.tsx
+var app_exports = {};
+__export(app_exports, {
+  renderDashboard: () => renderDashboard
+});
+import { Box as Box7, render, Text as Text7, useApp, useInput } from "ink";
+import { useEffect as useEffect2, useState as useState4 } from "react";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+function Dashboard({ dbPath, projectRoot, refreshInterval }) {
+  const { exit } = useApp();
+  const data = useDashboardData(dbPath, projectRoot, refreshInterval);
+  const [mode, setMode] = useState4("monitor");
+  const [focusIndex, setFocusIndex] = useState4(0);
+  const [graphScroll, setGraphScroll] = useState4(0);
+  const [debtScroll, setDebtScroll] = useState4(0);
+  const [outputScroll, setOutputScroll] = useState4(0);
+  const focusedPanel = PANELS[focusIndex] ?? "optimization";
+  const executor = useCommandExecutor({
+    getMemory: data.getMemory,
+    forceRefresh: data.forceRefresh,
+    dbPath,
+    projectRoot
+  });
+  useInput(
+    (input2, key) => {
+      if (mode === "command") {
+        if (key.escape) {
+          setMode("monitor");
+        }
+        return;
+      }
+      if (input2 === "q") {
+        exit();
+        return;
+      }
+      if (input2 === ":") {
+        setMode("command");
+        return;
+      }
+      if (key.tab) {
+        setFocusIndex((prev) => (prev + 1) % PANELS.length);
+        return;
+      }
+      if (key.upArrow) {
+        if (focusedPanel === "graph") setGraphScroll((prev) => Math.max(0, prev - 1));
+        if (focusedPanel === "debt") setDebtScroll((prev) => Math.max(0, prev - 1));
+        if (focusedPanel === "output") setOutputScroll((prev) => Math.max(0, prev - 1));
+      }
+      if (key.downArrow) {
+        if (focusedPanel === "graph") setGraphScroll((prev) => prev + 1);
+        if (focusedPanel === "debt") setDebtScroll((prev) => prev + 1);
+        if (focusedPanel === "output") setOutputScroll((prev) => prev + 1);
+      }
+    },
+    { isActive: mode === "monitor" || mode === "command" }
+  );
+  const outputMaxVisible = 8;
+  useEffect2(() => {
+    setOutputScroll(Math.max(0, executor.outputLines.length - outputMaxVisible));
+  }, [executor.outputLines.length]);
+  if (data.loading) {
+    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx7(Text7, { color: theme.neuralCyan, children: "Sparn Dashboard" }),
+      /* @__PURE__ */ jsx7(Text7, { color: theme.dimGray, children: "Loading data..." })
+    ] });
+  }
+  if (data.error) {
+    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx7(Text7, { color: theme.neuralCyan, children: "Sparn Dashboard" }),
+      /* @__PURE__ */ jsxs7(Text7, { color: theme.errorRed, children: [
+        "Error: ",
+        data.error
+      ] }),
+      /* @__PURE__ */ jsx7(Text7, { color: theme.dimGray, children: "Press q to quit" })
+    ] });
+  }
+  const timeStr = data.lastRefresh.toLocaleTimeString();
+  const modeHint = mode === "command" ? "Esc:monitor Enter:run" : "q:quit Tab:focus \u2191\u2193:scroll ::cmd";
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs7(Box7, { justifyContent: "space-between", paddingX: 1, children: [
+      /* @__PURE__ */ jsx7(Text7, { bold: true, color: theme.neuralCyan, children: "Sparn Dashboard" }),
+      /* @__PURE__ */ jsxs7(Text7, { color: theme.dimGray, children: [
+        modeHint,
+        " | ",
+        timeStr
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs7(Box7, { children: [
+      /* @__PURE__ */ jsx7(
+        OptimizationPanel,
+        {
+          stats: data.optimizationStats,
+          focused: focusedPanel === "optimization"
+        }
+      ),
+      /* @__PURE__ */ jsx7(
+        GraphViewPanel,
+        {
+          analysis: data.graphAnalysis,
+          nodes: data.graphNodes,
+          focused: focusedPanel === "graph",
+          scrollOffset: graphScroll
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs7(Box7, { children: [
+      /* @__PURE__ */ jsx7(
+        MemoryStatusPanel,
+        {
+          totalEntries: data.totalEntries,
+          dbSizeBytes: data.dbSizeBytes,
+          stateDistribution: data.stateDistribution,
+          daemon: data.daemon,
+          focused: focusedPanel === "memory"
+        }
+      ),
+      /* @__PURE__ */ jsx7(
+        DebtTrackerPanel,
+        {
+          debts: data.debts,
+          debtStats: data.debtStats,
+          focused: focusedPanel === "debt",
+          scrollOffset: debtScroll
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx7(
+      OutputPanel,
+      {
+        lines: executor.outputLines,
+        scrollOffset: outputScroll,
+        focused: focusedPanel === "output"
+      }
+    ),
+    /* @__PURE__ */ jsx7(
+      CommandInput,
+      {
+        onSubmit: executor.execute,
+        isRunning: executor.isRunning,
+        runningCommand: executor.runningCommand,
+        active: mode === "command"
+      }
+    )
+  ] });
+}
+function renderDashboard(options) {
+  render(
+    /* @__PURE__ */ jsx7(
+      Dashboard,
+      {
+        dbPath: options.dbPath,
+        projectRoot: options.projectRoot,
+        refreshInterval: options.refreshInterval ?? 2e3
+      }
+    )
+  );
+}
+var PANELS;
+var init_app = __esm({
+  "src/cli/dashboard/app.tsx"() {
+    "use strict";
+    init_esm_shims();
+    init_command_input();
+    init_output_panel();
+    init_use_command_executor();
+    init_use_data();
+    init_debt_tracker2();
+    init_graph_view();
+    init_memory_status();
+    init_optimization();
+    init_theme();
+    PANELS = ["optimization", "graph", "memory", "debt", "output"];
+  }
+});
+
+// src/cli/index.ts
+init_esm_shims();
+import { spawn as spawn3 } from "child_process";
+import { readFileSync as readFileSync10 } from "fs";
+import { dirname as dirname5, join as join9, resolve as resolve11 } from "path";
+import { fileURLToPath as fileURLToPath6 } from "url";
+import { Command } from "commander";
+import { load as loadYAML } from "js-yaml";
+
+// src/utils/audio.ts
+init_esm_shims();
+import { execFileSync } from "child_process";
+import { existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var AUDIO_DIR = join(dirname(fileURLToPath2(import.meta.url)), "../../audio");
+var DISABLED = process.env["SPARN_AUDIO"] === "false";
+function playSound(filename) {
+  if (DISABLED) return;
+  const filepath = resolve(AUDIO_DIR, filename);
+  if (!existsSync(filepath)) return;
+  try {
+    if (process.platform === "win32") {
+      const escaped = filepath.replace(/'/g, "''");
+      execFileSync(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          `(New-Object Media.SoundPlayer '${escaped}').PlaySync()`
+        ],
+        { windowsHide: true, timeout: 5e3, stdio: "ignore" }
+      );
+    } else if (process.platform === "darwin") {
+      execFileSync("afplay", [filepath], { timeout: 5e3, stdio: "ignore" });
+    } else {
+      try {
+        execFileSync("aplay", ["-q", filepath], { timeout: 5e3, stdio: "ignore" });
+      } catch {
+        try {
+          execFileSync("paplay", [filepath], { timeout: 5e3, stdio: "ignore" });
+        } catch {
+          execFileSync("play", ["-q", filepath], { timeout: 5e3, stdio: "ignore" });
+        }
+      }
+    }
+  } catch {
+  }
+}
+function playStartup() {
+  playSound("startup.wav");
+}
+function playCommand() {
+  playSound("command.wav");
+}
+function playComplete() {
+  playSound("complete.wav");
+}
+function playEnd() {
+  playSound("end.wav");
+}
+
+// src/cli/index.ts
+init_tokenizer();
+init_banner();
+function getVersion2() {
+  try {
+    const __filename2 = fileURLToPath6(import.meta.url);
+    const __dirname2 = dirname5(__filename2);
+    const pkg = JSON.parse(readFileSync10(join9(__dirname2, "../../package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    return "1.4.0";
+  }
+}
+var VERSION2 = getVersion2();
+try {
+  const configPath = resolve11(process.cwd(), ".sparn/config.yaml");
+  const configContent = readFileSync10(configPath, "utf-8");
+  const config = loadYAML(configContent);
+  if (config?.realtime?.preciseTokenCounting) {
+    setPreciseTokenCounting(true);
+  }
+} catch {
+}
+async function handleError(error, context) {
+  const { errorRed: errorRed2, synapseViolet: synapseViolet2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  const errorMsg = error instanceof Error ? error.message : String(error);
+  const stack = error instanceof Error ? error.stack : void 0;
+  console.error(errorRed2("\n\u2717 Error:"), errorMsg);
+  if (context) {
+    console.error(errorRed2("Context:"), context);
+  }
+  if (errorMsg.includes("SQLITE") || errorMsg.includes("database")) {
+    console.error(synapseViolet2("\n\u{1F4A1} Database issue detected:"));
+    console.error("  Try running: rm -rf .sparn/ && sparn init");
+    console.error("  This will reinitialize your Sparn database.\n");
+  }
+  if (errorMsg.includes("EACCES") || errorMsg.includes("permission")) {
+    console.error(synapseViolet2("\n\u{1F4A1} Permission issue detected:"));
+    console.error("  Check file permissions in .sparn/ directory");
+    console.error("  Try: chmod -R u+rw .sparn/\n");
+  }
+  if (errorMsg.includes("ENOENT") || errorMsg.includes("no such file")) {
+    console.error(synapseViolet2("\n\u{1F4A1} File not found:"));
+    console.error("  Make sure you have run: sparn init");
+    console.error("  Or check that the specified file exists.\n");
+  }
+  if (errorMsg.includes("out of memory") || errorMsg.includes("heap")) {
+    console.error(synapseViolet2("\n\u{1F4A1} Memory issue detected:"));
+    console.error("  Try processing smaller chunks of context");
+    console.error("  Or increase Node.js memory: NODE_OPTIONS=--max-old-space-size=4096\n");
+  }
+  if (process.env["SPARN_DEBUG"] === "true" && stack) {
+    console.error(errorRed2("\nStack trace:"));
+    console.error(stack);
+  } else {
+    console.error("  Run with SPARN_DEBUG=true for stack trace\n");
+  }
+  process.exit(1);
+}
+process.on("unhandledRejection", (reason) => {
+  void handleError(reason, "Unhandled promise rejection");
+});
+process.on("uncaughtException", (error) => {
+  void handleError(error, "Uncaught exception");
+});
+var program = new Command();
+program.name("sparn").description("Context optimization for AI coding agents").version(VERSION2, "-v, --version", "Output the current version").helpOption("-h, --help", "Display help for command").enablePositionalOptions();
+playStartup();
+program.hook("preAction", () => {
+  playCommand();
+});
+program.hook("postAction", () => {
+  playComplete();
+});
+process.on("exit", () => {
+  playEnd();
+});
+process.once("SIGINT", () => {
+  process.exit(0);
+});
+program.command("init").description("Initialize Sparn in the current project").option("-f, --force", "Force overwrite if .sparn/ already exists").addHelpText(
+  "after",
+  `
+Examples:
+  $ sparn init                  # Initialize in current directory
+  $ sparn init --force          # Overwrite existing .sparn/ directory
+
+Files Created:
+  .sparn/config.yaml            # Configuration with optimization parameters
+  .sparn/memory.db              # SQLite database for context storage
+
+Next Steps:
+  After initialization, use 'sparn optimize' to start optimizing context.
+`
+).action(async (options) => {
+  const { initCommand: initCommand2, displayInitSuccess: displayInitSuccess2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+  const { createInitSpinner: createInitSpinner2 } = await Promise.resolve().then(() => (init_progress(), progress_exports));
+  const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  const spinner = createInitSpinner2("\u{1F9E0} Initializing Sparn...");
+  try {
+    spinner.start();
+    spinner.text = "\u{1F4C1} Creating .sparn/ directory...";
+    const result = await initCommand2({ force: options.force });
+    spinner.succeed(neuralCyan2("Sparn initialized successfully!"));
     displayInitSuccess2(result);
   } catch (error) {
     spinner.fail(errorRed2("Initialization failed"));
@@ -2563,7 +5633,7 @@ Next Steps:
     process.exit(1);
   }
 });
-program.command("optimize").description("Optimize context memory using neuroscience principles").option("-i, --input <file>", "Input file path").option("-o, --output <file>", "Output file path").option("--dry-run", "Run without saving to memory").option("--verbose", "Show detailed per-entry scores").addHelpText(
+program.command("optimize").description("Optimize context memory").option("-i, --input <file>", "Input file path").option("-o, --output <file>", "Output file path").option("--dry-run", "Run without saving to memory").option("--verbose", "Show detailed per-entry scores").addHelpText(
   "after",
   `
 Examples:
@@ -2573,11 +5643,11 @@ Examples:
   $ sparn optimize -i context.txt --verbose           # Show entry scores
 
 How It Works:
-  1. Sparse Coding: Keeps only 2-5% most relevant context
-  2. Engram Theory: Applies decay to old memories
-  3. Multi-State Synapses: Classifies as silent/ready/active
-  4. BTSP: Locks critical events (errors, stack traces)
-  5. Sleep Replay: Consolidates and compresses
+  1. Relevance Filtering: Keeps only 2-5% most relevant context
+  2. Time-Based Decay: Fades old entries unless reinforced
+  3. Entry Classification: Classifies as silent/ready/active
+  4. Critical Event Detection: Locks errors and stack traces
+  5. Periodic Consolidation: Merges duplicates and cleans up
 
 Typical Results:
   \u2022 60-90% token reduction
@@ -2593,7 +5663,7 @@ Typical Results:
   try {
     spinner.start();
     let input2;
-    if (!options.input && process.stdin.isTTY === false) {
+    if (!options.input && !process.stdin.isTTY) {
       spinner.text = "\u{1F4D6} Reading context from stdin...";
       const chunks = [];
       for await (const chunk of process.stdin) {
@@ -2604,39 +5674,42 @@ Typical Results:
       spinner.text = `\u{1F4D6} Reading context from ${options.input}...`;
     }
     spinner.text = "\u{1F4BE} Loading memory database...";
-    const dbPath = resolve2(process.cwd(), ".sparn/memory.db");
+    const dbPath = resolve11(process.cwd(), ".sparn/memory.db");
     const memory = await createKVMemory2(dbPath);
-    spinner.text = "\u26A1 Applying neuroscience principles...";
-    const result = await optimizeCommand2({
-      input: input2,
-      inputFile: options.input,
-      outputFile: options.output,
-      memory,
-      dryRun: options.dryRun || false,
-      verbose: options.verbose || false
-    });
-    spinner.succeed(neuralCyan2(`Optimization complete in ${result.durationMs}ms!`));
-    showTokenSavings2(result.tokensBefore, result.tokensAfter, result.reduction);
-    console.log(synapseViolet2("  Entry Distribution:"));
-    console.log(`    \u2022 Processed: ${result.entriesProcessed}`);
-    console.log(`    \u2022 Kept: ${result.entriesKept}`);
-    console.log(`    \u2022 Active: ${result.stateDistribution.active}`);
-    console.log(`    \u2022 Ready: ${result.stateDistribution.ready}`);
-    console.log(`    \u2022 Silent: ${result.stateDistribution.silent}
+    try {
+      spinner.text = "\u26A1 Optimizing context...";
+      const result = await optimizeCommand2({
+        input: input2,
+        inputFile: options.input,
+        outputFile: options.output,
+        memory,
+        dryRun: options.dryRun || false,
+        verbose: options.verbose || false
+      });
+      spinner.succeed(neuralCyan2(`Optimization complete in ${result.durationMs}ms!`));
+      showTokenSavings2(result.tokensBefore, result.tokensAfter, result.reduction);
+      console.log(synapseViolet2("  Entry Distribution:"));
+      console.log(`    \u2022 Processed: ${result.entriesProcessed}`);
+      console.log(`    \u2022 Kept: ${result.entriesKept}`);
+      console.log(`    \u2022 Active: ${result.stateDistribution.active}`);
+      console.log(`    \u2022 Ready: ${result.stateDistribution.ready}`);
+      console.log(`    \u2022 Silent: ${result.stateDistribution.silent}
 `);
-    if (options.verbose && result.details) {
-      console.log(neuralCyan2("  \u{1F4CB} Entry Details:"));
-      for (const detail of result.details) {
-        console.log(
-          `    ${detail.id.substring(0, 8)}: score=${detail.score.toFixed(2)}, state=${detail.state}, tokens=${detail.tokens}`
-        );
+      if (options.verbose && result.details) {
+        console.log(neuralCyan2("  \u{1F4CB} Entry Details:"));
+        for (const detail of result.details) {
+          console.log(
+            `    ${detail.id.substring(0, 8)}: score=${detail.score.toFixed(2)}, state=${detail.state}, tokens=${detail.tokens}`
+          );
+        }
+        console.log();
       }
-      console.log();
-    }
-    if (!options.output) {
-      console.log(result.output);
+      if (!options.output) {
+        console.log(result.output);
+      }
+    } finally {
+      await memory.close();
     }
-    await memory.close();
   } catch (error) {
     spinner.fail(errorRed2("Optimization failed"));
     console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
@@ -2668,7 +5741,7 @@ Tracked Metrics:
   try {
     if (spinner) spinner.start();
     if (spinner) spinner.text = "\u{1F4BE} Loading optimization history...";
-    const dbPath = resolve2(process.cwd(), ".sparn/memory.db");
+    const dbPath = resolve11(process.cwd(), ".sparn/memory.db");
     const memory = await createKVMemory2(dbPath);
     let confirmReset = false;
     if (options.reset) {
@@ -2676,37 +5749,40 @@ Tracked Metrics:
       console.log(synapseViolet2("Warning: This will clear all optimization statistics."));
       confirmReset = true;
     }
-    if (spinner) spinner.text = "\u{1F4C8} Calculating statistics...";
-    const result = await statsCommand2({
-      memory,
-      graph: options.graph || false,
-      reset: options.reset || false,
-      confirmReset,
-      json: options.json || false
-    });
-    if (spinner) spinner.succeed(neuralCyan2("Statistics ready!"));
-    if (options.json) {
-      console.log(result.json);
-    } else if (options.reset && result.resetConfirmed) {
-      console.log(neuralCyan2("\n\u2713 Statistics cleared\n"));
-    } else {
-      console.log(neuralCyan2("\n\u{1F4CA} Optimization Statistics\n"));
-      console.log(`  Total optimizations: ${result.totalCommands}`);
-      console.log(`  Total tokens saved: ${result.totalTokensSaved.toLocaleString()}`);
-      console.log(`  Average reduction: ${(result.averageReduction * 100).toFixed(1)}%`);
-      if (options.graph && result.graph) {
-        console.log(result.graph);
+    try {
+      if (spinner) spinner.text = "\u{1F4C8} Calculating statistics...";
+      const result = await statsCommand2({
+        memory,
+        graph: options.graph || false,
+        reset: options.reset || false,
+        confirmReset,
+        json: options.json || false
+      });
+      if (spinner) spinner.succeed(neuralCyan2("Statistics ready!"));
+      if (options.json) {
+        console.log(result.json);
+      } else if (options.reset && result.resetConfirmed) {
+        console.log(neuralCyan2("\n\u2713 Statistics cleared\n"));
+      } else {
+        console.log(neuralCyan2("\n\u{1F4CA} Optimization Statistics\n"));
+        console.log(`  Total optimizations: ${result.totalCommands}`);
+        console.log(`  Total tokens saved: ${result.totalTokensSaved.toLocaleString()}`);
+        console.log(`  Average reduction: ${(result.averageReduction * 100).toFixed(1)}%`);
+        if (options.graph && result.graph) {
+          console.log(result.graph);
+        }
+        console.log();
       }
-      console.log();
+    } finally {
+      await memory.close();
     }
-    await memory.close();
   } catch (error) {
     if (spinner) spinner.fail(errorRed2("Statistics failed"));
     console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
 });
-program.command("relay <command> [args...]").description("Proxy a CLI command through optimization").option("--silent", "Suppress token savings summary").addHelpText(
+program.command("relay <command> [args...]").description("Proxy a CLI command through optimization").passThroughOptions().option("--silent", "Suppress token savings summary").addHelpText(
   "after",
   `
 Examples:
@@ -2728,22 +5804,27 @@ The relay command passes the exit code from the wrapped command.
   const { relayCommand: relayCommand2 } = await Promise.resolve().then(() => (init_relay(), relay_exports));
   const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
   try {
-    const dbPath = resolve2(process.cwd(), ".sparn/memory.db");
+    const dbPath = resolve11(process.cwd(), ".sparn/memory.db");
     const memory = await createKVMemory2(dbPath);
-    const result = await relayCommand2({
-      command,
-      args: args || [],
-      memory,
-      silent: options.silent || false
-    });
-    console.log(result.optimizedOutput);
-    if (result.summary) {
-      console.error(neuralCyan2(`
+    let exitCode = 1;
+    try {
+      const result = await relayCommand2({
+        command,
+        args: args || [],
+        memory,
+        silent: options.silent || false
+      });
+      console.log(result.optimizedOutput);
+      if (result.summary) {
+        console.error(neuralCyan2(`
 ${result.summary}
 `));
+      }
+      exitCode = result.exitCode;
+    } finally {
+      await memory.close();
     }
-    await memory.close();
-    process.exit(result.exitCode);
+    process.exit(exitCode);
   } catch (error) {
     console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
     process.exit(1);
@@ -2781,24 +5862,27 @@ Typical Results:
   try {
     spinner.start();
     spinner.text = "\u{1F4BE} Loading memory database...";
-    const dbPath = resolve2(process.cwd(), ".sparn/memory.db");
+    const dbPath = resolve11(process.cwd(), ".sparn/memory.db");
     const memory = await createKVMemory2(dbPath);
-    spinner.text = "\u{1F50D} Identifying decayed entries...";
-    const result = await consolidateCommand2({ memory });
-    spinner.succeed(neuralCyan2(`Consolidation complete in ${result.durationMs}ms!`));
-    showConsolidationSummary2(
-      result.entriesBefore,
-      result.entriesAfter,
-      result.decayedRemoved,
-      result.duplicatesRemoved,
-      result.durationMs
-    );
-    if (result.vacuumCompleted) {
-      console.log(synapseViolet2("  \u2713 Database VACUUM completed\n"));
-    } else {
-      console.log(errorRed2("  \u2717 Database VACUUM failed\n"));
+    try {
+      spinner.text = "\u{1F50D} Identifying decayed entries...";
+      const result = await consolidateCommand2({ memory });
+      spinner.succeed(neuralCyan2(`Consolidation complete in ${result.durationMs}ms!`));
+      showConsolidationSummary2(
+        result.entriesBefore,
+        result.entriesAfter,
+        result.decayedRemoved,
+        result.duplicatesRemoved,
+        result.durationMs
+      );
+      if (result.vacuumCompleted) {
+        console.log(synapseViolet2("  \u2713 Database VACUUM completed\n"));
+      } else {
+        console.log(errorRed2("  \u2717 Database VACUUM failed\n"));
+      }
+    } finally {
+      await memory.close();
     }
-    await memory.close();
   } catch (error) {
     spinner.fail(errorRed2("Consolidation failed"));
     console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
@@ -2815,8 +5899,8 @@ Examples:
   $ sparn config --json                 # View full config as JSON
 
 Configuration Keys:
-  pruning.threshold                     # Sparse coding threshold (2-5%)
-  decay.halfLife                        # Engram decay half-life (hours)
+  pruning.threshold                     # Relevance threshold (2-5%)
+  decay.halfLife                        # Decay half-life (hours)
   decay.minScore                        # Minimum decay score (0.0-1.0)
   states.activeThreshold                # Active state threshold
   states.readyThreshold                 # Ready state threshold
@@ -2829,7 +5913,7 @@ The config file is located at .sparn/config.yaml
   const { configCommand: configCommand2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
   const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
   try {
-    const configPath = resolve2(process.cwd(), ".sparn/config.yaml");
+    const configPath = resolve11(process.cwd(), ".sparn/config.yaml");
     const result = await configCommand2({
       configPath,
       subcommand,
@@ -2842,11 +5926,14 @@ The config file is located at .sparn/config.yaml
       process.exit(1);
     }
     if (result.editorPath && !options.json) {
-      const editor = process.env["EDITOR"] || "vim";
+      const editorEnv = process.env["EDITOR"] || "vim";
+      const editorParts = editorEnv.split(/\s+/);
+      const editorCmd = editorParts[0] || "vim";
+      const editorArgs = [...editorParts.slice(1), result.editorPath];
       console.log(neuralCyan2(`
-\u{1F4DD} Opening config in ${editor}...
+\u{1F4DD} Opening config in ${editorCmd}...
 `));
-      const child = spawn2(editor, [result.editorPath], {
+      const child = spawn3(editorCmd, editorArgs, {
         stdio: "inherit"
       });
       child.on("close", (code) => {
@@ -2888,8 +5975,8 @@ optimizes contexts when they exceed the configured threshold.
   const { createDaemonCommand: createDaemonCommand2 } = await Promise.resolve().then(() => (init_daemon_process(), daemon_process_exports));
   const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
   try {
-    const configPath = resolve2(process.cwd(), ".sparn/config.yaml");
-    const configYAML = readFileSync6(configPath, "utf-8");
+    const configPath = resolve11(process.cwd(), ".sparn/config.yaml");
+    const configYAML = readFileSync10(configPath, "utf-8");
     const config = parseYAML3(configYAML);
     const daemon = createDaemonCommand2();
     switch (subcommand) {
@@ -2984,6 +6071,7 @@ and compress verbose tool results after execution.
         console.log("\nHook paths:");
         console.log(`  pre-prompt: ${result.hookPaths.prePrompt}`);
         console.log(`  post-tool-result: ${result.hookPaths.postToolResult}`);
+        console.log(`  stop-docs-refresh: ${result.hookPaths.stopDocsRefresh}`);
       }
       console.log();
     } else {
@@ -3022,19 +6110,284 @@ and configuring Sparn without memorizing CLI flags.
   const { interactiveCommand: interactiveCommand2 } = await Promise.resolve().then(() => (init_interactive(), interactive_exports));
   const { errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
   try {
-    const dbPath = resolve2(process.cwd(), ".sparn/memory.db");
+    const dbPath = resolve11(process.cwd(), ".sparn/memory.db");
     const memory = await createKVMemory2(dbPath);
-    const configPath = resolve2(process.cwd(), ".sparn/config.yaml");
-    await interactiveCommand2({
-      memory,
-      configPath
+    try {
+      const configPath = resolve11(process.cwd(), ".sparn/config.yaml");
+      await interactiveCommand2({
+        memory,
+        configPath
+      });
+    } finally {
+      await memory.close();
+    }
+  } catch (error) {
+    console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("graph").description("Analyze dependency graph of the project").option("--entry <file>", "Start from a specific entry point").option("--depth <n>", "Limit traversal depth", (v) => Number.parseInt(v, 10)).option("--focus <pattern>", "Focus on modules matching pattern").option("--json", "Output as JSON").action(async (options) => {
+  const { graphCommand: graphCommand2 } = await Promise.resolve().then(() => (init_graph(), graph_exports));
+  const { neuralCyan: neuralCyan2, synapseViolet: synapseViolet2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  try {
+    const result = await graphCommand2({
+      entry: options.entry,
+      depth: options.depth,
+      focus: options.focus,
+      json: options.json
+    });
+    if (options.json) {
+      console.log(result.json);
+    } else {
+      console.log(neuralCyan2("\n\u{1F4CA} Dependency Graph Analysis\n"));
+      console.log(`  Files analyzed: ${result.nodeCount}`);
+      console.log(`  Entry points: ${result.analysis.entryPoints.length}`);
+      console.log(`  Orphaned files: ${result.analysis.orphans.length}`);
+      console.log(`  Total tokens: ${result.analysis.totalTokens.toLocaleString()}`);
+      if (result.analysis.hotPaths.length > 0) {
+        console.log(synapseViolet2("\n  Hot paths (most imported):"));
+        for (const path2 of result.analysis.hotPaths.slice(0, 5)) {
+          console.log(`    ${path2}`);
+        }
+      }
+      if (result.analysis.entryPoints.length > 0) {
+        console.log(synapseViolet2("\n  Entry points:"));
+        for (const path2 of result.analysis.entryPoints.slice(0, 5)) {
+          console.log(`    ${path2}`);
+        }
+      }
+      console.log();
+    }
+  } catch (error) {
+    console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("search [query]").description("Search codebase using FTS5 + ripgrep").option("--glob <pattern>", "Filter by file glob pattern").option("--max <n>", "Max results (default: 10)", (v) => Number.parseInt(v, 10)).option("--json", "Output as JSON").action(async (query, options) => {
+  const { searchCommand: searchCommand2 } = await Promise.resolve().then(() => (init_search(), search_exports));
+  const { neuralCyan: neuralCyan2, synapseViolet: synapseViolet2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  try {
+    let subcommand;
+    if (query === "init") subcommand = "init";
+    if (query === "refresh") subcommand = "refresh";
+    const result = await searchCommand2({
+      query: subcommand ? void 0 : query,
+      subcommand,
+      glob: options.glob,
+      maxResults: options.max,
+      json: options.json
+    });
+    if (options.json && result.json) {
+      console.log(result.json);
+    } else if (result.message) {
+      console.log(neuralCyan2(`
+\u2713 ${result.message}
+`));
+    }
+    if (result.results && !options.json) {
+      console.log(neuralCyan2(`
+\u{1F50D} ${result.results.length} results
+`));
+      for (const r of result.results) {
+        console.log(synapseViolet2(`  ${r.filePath}:${r.lineNumber}`));
+        console.log(`    ${r.content.trim()}`);
+        console.log();
+      }
+    }
+  } catch (error) {
+    console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("plan <task>").description("Create an execution plan for a task").option("--files <files...>", "Files needed for the task").option("--searches <queries...>", "Search queries to run").option("--max-reads <n>", "Max file reads (default: 5)", (v) => Number.parseInt(v, 10)).option("--json", "Output as JSON").action(async (task, options) => {
+  const { planCommand: planCommand2 } = await Promise.resolve().then(() => (init_plan(), plan_exports));
+  const { neuralCyan: neuralCyan2, synapseViolet: synapseViolet2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  try {
+    if (task === "list") {
+      const { planListCommand: planListCommand2 } = await Promise.resolve().then(() => (init_plan(), plan_exports));
+      const result2 = await planListCommand2({ json: options.json });
+      if (options.json) {
+        console.log(result2.json);
+      } else {
+        console.log(neuralCyan2("\n\u{1F4CB} Plans\n"));
+        for (const p of result2.plans) {
+          console.log(`  ${p.id} [${p.status}] ${p.task}`);
+        }
+        if (result2.plans.length === 0) console.log("  No plans found");
+        console.log();
+      }
+      return;
+    }
+    const result = await planCommand2({
+      task,
+      files: options.files,
+      searches: options.searches,
+      maxReads: options.maxReads,
+      json: options.json
+    });
+    if (options.json) {
+      console.log(result.json);
+    } else {
+      console.log(neuralCyan2(`
+\u2713 ${result.message}`));
+      console.log(synapseViolet2("\n  Steps:"));
+      for (const step of result.plan.steps) {
+        console.log(`    ${step.order}. [${step.action}] ${step.target} \u2014 ${step.description}`);
+      }
+      console.log();
+    }
+  } catch (error) {
+    console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("exec <planId>").description("Execute a plan with constraints").option("--json", "Output as JSON").action(async (planId, options) => {
+  const { execCommand: execCommand2 } = await Promise.resolve().then(() => (init_exec(), exec_exports));
+  const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  try {
+    const result = await execCommand2({ planId, json: options.json });
+    if (options.json) {
+      console.log(result.json);
+    } else {
+      console.log(neuralCyan2(`
+\u2713 ${result.message}
+`));
+    }
+  } catch (error) {
+    console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("verify <planId>").description("Verify plan completion").option("--json", "Output as JSON").action(async (planId, options) => {
+  const { verifyCommand: verifyCommand2 } = await Promise.resolve().then(() => (init_verify(), verify_exports));
+  const { neuralCyan: neuralCyan2, synapseViolet: synapseViolet2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  try {
+    const result = await verifyCommand2({ planId, json: options.json });
+    if (options.json) {
+      console.log(result.json);
+    } else {
+      console.log(neuralCyan2(`
+${result.message}`));
+      console.log(synapseViolet2("\n  Steps:"));
+      for (const d of result.verification.details) {
+        const icon = d.status === "completed" ? "\u2713" : d.status === "failed" ? "\u2717" : "\u25CB";
+        console.log(`    ${icon} ${d.step}. [${d.action}] ${d.target} \u2014 ${d.status}`);
+      }
+      console.log();
+    }
+  } catch (error) {
+    console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("docs").description("Auto-generate CLAUDE.md for the project").option("-o, --output <file>", "Output file path (default: CLAUDE.md)").option("--no-graph", "Skip dependency graph analysis").option("--json", "Output content as JSON").action(async (options) => {
+  const { docsCommand: docsCommand2 } = await Promise.resolve().then(() => (init_docs(), docs_exports));
+  const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  try {
+    const result = await docsCommand2({
+      output: options.output,
+      includeGraph: options.graph !== false,
+      json: options.json
+    });
+    if (options.json) {
+      console.log(JSON.stringify({ content: result.content }, null, 2));
+    } else {
+      console.log(neuralCyan2(`
+\u2713 ${result.message}
+`));
+    }
+  } catch (error) {
+    console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("debt <subcommand> [description]").description("Track technical debt").option("--severity <level>", "Severity: P0, P1, P2 (default: P1)").option("--due <date>", "Repayment date (YYYY-MM-DD)").option("--files <files...>", "Affected files").option("--tokens <n>", "Token cost estimate", (v) => Number.parseInt(v, 10)).option("--id <id>", "Debt ID (for resolve/start)").option("--overdue", "Show only overdue debts").option("--json", "Output as JSON").action(async (subcommand, description, options) => {
+  const { debtCommand: debtCommand2 } = await Promise.resolve().then(() => (init_debt(), debt_exports));
+  const { neuralCyan: neuralCyan2, synapseViolet: synapseViolet2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  try {
+    const result = await debtCommand2({
+      subcommand,
+      description,
+      severity: options.severity,
+      due: options.due,
+      files: options.files,
+      tokenCost: options.tokens,
+      id: options.id || description,
+      overdue: options.overdue,
+      json: options.json
     });
-    await memory.close();
+    if (options.json && result.json) {
+      console.log(result.json);
+    } else {
+      console.log(neuralCyan2(`
+\u2713 ${result.message}`));
+      if (result.debts) {
+        for (const d of result.debts) {
+          const due = new Date(d.repayment_date).toLocaleDateString();
+          const overdue = d.repayment_date < Date.now() && d.status !== "resolved" ? " [OVERDUE]" : "";
+          console.log(
+            synapseViolet2(
+              `  ${d.id} [${d.severity}] ${d.status}${overdue} \u2014 ${d.description} (due: ${due})`
+            )
+          );
+        }
+      }
+      if (result.stats) {
+        console.log(
+          `  Open: ${result.stats.open} | In Progress: ${result.stats.in_progress} | Resolved: ${result.stats.resolved}`
+        );
+        console.log(
+          `  Overdue: ${result.stats.overdue} | Repayment rate: ${(result.stats.repaymentRate * 100).toFixed(0)}%`
+        );
+      }
+      console.log();
+    }
   } catch (error) {
     console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
 });
+program.command("dashboard").alias("dash").description("Launch interactive TUI dashboard").option(
+  "--refresh <ms>",
+  "Refresh interval in milliseconds",
+  (v) => Number.parseInt(v, 10)
+).action(async (options) => {
+  const { renderDashboard: renderDashboard2 } = await Promise.resolve().then(() => (init_app(), app_exports));
+  const dbPath = resolve11(process.cwd(), ".sparn/memory.db");
+  const projectRoot = process.cwd();
+  renderDashboard2({
+    dbPath,
+    projectRoot,
+    refreshInterval: options.refresh ?? 2e3
+  });
+});
+program.command("status").description("Quick project status overview").action(async () => {
+  const { neuralCyan: neuralCyan2, synapseViolet: synapseViolet2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  console.log(neuralCyan2(`
+\u{1F9E0} Sparn v${VERSION2} Status
+`));
+  const { existsSync: exists } = await import("fs");
+  const sparnDir = resolve11(process.cwd(), ".sparn");
+  const initialized = exists(sparnDir);
+  console.log(`  Initialized: ${initialized ? "\u2713" : "\u2717 (run sparn init)"}`);
+  if (initialized) {
+    const dbPath = resolve11(sparnDir, "memory.db");
+    console.log(`  Database: ${exists(dbPath) ? "\u2713" : "\u2717"}`);
+    const searchDb = resolve11(sparnDir, "search.db");
+    console.log(`  Search index: ${exists(searchDb) ? "\u2713" : "\u2717 (run sparn search init)"}`);
+    const plansDir = resolve11(sparnDir, "plans");
+    if (exists(plansDir)) {
+      const { readdirSync: readDir } = await import("fs");
+      const plans = readDir(plansDir).filter((f) => f.endsWith(".json"));
+      console.log(`  Plans: ${plans.length}`);
+    }
+    const pidFile = resolve11(sparnDir, "daemon.pid");
+    console.log(`  Daemon: ${exists(pidFile) ? "\u2713 running" : "\u2717 stopped"}`);
+  }
+  console.log(
+    synapseViolet2("\n  Commands: graph | search | plan | exec | verify | docs | debt\n")
+  );
+});
 program.on("option:version", () => {
   console.log(getBanner(VERSION2));
   process.exit(0);