@ulrichc1/sparn 1.2.1 → 1.4.0

package/dist/cli/dashboard.js

@@ -0,0 +1,3932 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+function hashContent(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+var init_hash = __esm({
+  "src/utils/hash.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/core/btsp-embedder.ts
+import { randomUUID } from "crypto";
+function createBTSPEmbedder(config) {
+  const BTSP_PATTERNS = [
+    // Error patterns
+    /\b(error|exception|failure|fatal|critical|panic)\b/i,
+    /\b(TypeError|ReferenceError|SyntaxError|RangeError|URIError)\b/,
+    /\bENOENT|EACCES|ECONNREFUSED|ETIMEDOUT\b/,
+    // Stack trace patterns
+    /^\s+at\s+.*\(.*:\d+:\d+\)/m,
+    // JavaScript stack trace
+    /^\s+at\s+.*\.[a-zA-Z]+:\d+/m,
+    // Python/Ruby stack trace
+    // Git diff new files
+    /^new file mode \d+$/m,
+    /^--- \/dev\/null$/m,
+    // Merge conflict markers
+    /^<<<<<<< /m,
+    /^=======/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));
+  }
+  function createBTSPEntry(content, tags = [], metadata = {}) {
+    return {
+      id: randomUUID(),
+      content,
+      hash: hashContent(content),
+      timestamp: Date.now(),
+      score: 1,
+      // Maximum initial score
+      ttl: 365 * 24 * 3600,
+      // 1 year in seconds (long retention)
+      state: "active",
+      // Always active
+      accessCount: 0,
+      tags: [...tags, "btsp"],
+      metadata,
+      isBTSP: true
+    };
+  }
+  return {
+    detectBTSP,
+    createBTSPEntry
+  };
+}
+var init_btsp_embedder = __esm({
+  "src/core/btsp-embedder.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_hash();
+  }
+});
+
+// src/core/confidence-states.ts
+function createConfidenceStates(config) {
+  const { activeThreshold, readyThreshold } = config;
+  function calculateState(entry) {
+    if (entry.isBTSP) {
+      return "active";
+    }
+    if (entry.score >= activeThreshold) {
+      return "active";
+    }
+    if (entry.score >= readyThreshold) {
+      return "ready";
+    }
+    return "silent";
+  }
+  function transition(entry) {
+    const newState = calculateState(entry);
+    return {
+      ...entry,
+      state: newState
+    };
+  }
+  function getDistribution(entries) {
+    const distribution = {
+      silent: 0,
+      ready: 0,
+      active: 0,
+      total: entries.length
+    };
+    for (const entry of entries) {
+      const state = calculateState(entry);
+      distribution[state]++;
+    }
+    return distribution;
+  }
+  return {
+    calculateState,
+    transition,
+    getDistribution
+  };
+}
+var init_confidence_states = __esm({
+  "src/core/confidence-states.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// 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;
+    const ratio = ageInSeconds / ttlInSeconds;
+    const decay = 1 - Math.exp(-ratio);
+    return Math.max(0, Math.min(1, decay));
+  }
+  function calculateScore(entry, currentTime = Date.now()) {
+    const ageInMilliseconds = currentTime - entry.timestamp;
+    const ageInSeconds = Math.max(0, ageInMilliseconds / 1e3);
+    const decay = calculateDecay(ageInSeconds, entry.ttl);
+    let score = entry.score * (1 - decay);
+    if (entry.accessCount > 0) {
+      const accessBonus = Math.log(entry.accessCount + 1) * 0.1;
+      score = Math.min(1, score + accessBonus);
+    }
+    if (entry.isBTSP) {
+      score = Math.max(score, 0.9);
+    }
+    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) {
+    return {
+      ...entry,
+      ttl: defaultTTL * 3600,
+      // Convert hours to seconds
+      timestamp: Date.now()
+    };
+  }
+  return {
+    calculateScore,
+    refreshTTL,
+    calculateDecay
+  };
+}
+var init_engram_scorer = __esm({
+  "src/core/engram-scorer.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/utils/tfidf.ts
+function tokenize2(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 = tokenize2(entry.content);
+    const uniqueTerms = new Set(tokens);
+    for (const term of uniqueTerms) {
+      documentFrequency.set(term, (documentFrequency.get(term) || 0) + 1);
+    }
+  }
+  return {
+    documentFrequency,
+    totalDocuments: entries.length
+  };
+}
+function scoreTFIDF(entry, index) {
+  const tokens = tokenize2(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();
+  }
+});
+
+// src/utils/tokenizer.ts
+import { encode } from "gpt-tokenizer";
+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/core/sparse-pruner.ts
+function createSparsePruner(config) {
+  const { threshold } = config;
+  function scoreEntry(entry, allEntries) {
+    return scoreTFIDF(entry, createTFIDFIndex(allEntries));
+  }
+  function prune(entries) {
+    if (entries.length === 0) {
+      return {
+        kept: [],
+        removed: [],
+        originalTokens: 0,
+        prunedTokens: 0
+      };
+    }
+    const originalTokens = entries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    const tfidfIndex = createTFIDFIndex(entries);
+    const scored = entries.map((entry) => ({
+      entry,
+      score: scoreTFIDF(entry, tfidfIndex)
+    }));
+    scored.sort((a, b) => b.score - a.score);
+    const keepCount = Math.max(1, Math.ceil(entries.length * (threshold / 100)));
+    const kept = scored.slice(0, keepCount).map((s) => s.entry);
+    const removed = scored.slice(keepCount).map((s) => s.entry);
+    const prunedTokens = kept.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    return {
+      kept,
+      removed,
+      originalTokens,
+      prunedTokens
+    };
+  }
+  return {
+    prune,
+    scoreEntry
+  };
+}
+var init_sparse_pruner = __esm({
+  "src/core/sparse-pruner.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_tfidf();
+    init_tokenizer();
+  }
+});
+
+// src/adapters/generic.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function createGenericAdapter(memory, config) {
+  const pruner = createSparsePruner(config.pruning);
+  const scorer = createEngramScorer(config.decay);
+  const states = createConfidenceStates(config.states);
+  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 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,
+      score: scorer.calculateScore(entry)
+    }));
+    const statedEntries = scoredEntries.map((entry) => states.transition(entry));
+    const pruneResult = pruner.prune(statedEntries);
+    const optimizedEntries = pruneResult.kept.filter(
+      (e) => e.state === "active" || e.state === "ready"
+    );
+    const tokensAfter = optimizedEntries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    const optimizedContext = optimizedEntries.map((e) => e.content).join("\n");
+    if (!options.dryRun) {
+      for (const entry of optimizedEntries) {
+        await memory.put(entry);
+      }
+      await memory.recordOptimization({
+        timestamp: Date.now(),
+        tokens_before: tokensBefore,
+        tokens_after: tokensAfter,
+        entries_pruned: entries.length - optimizedEntries.length,
+        duration_ms: Date.now() - startTime
+      });
+    }
+    const distribution = states.getDistribution(optimizedEntries);
+    const result = {
+      optimizedContext,
+      tokensBefore,
+      tokensAfter,
+      reduction: tokensBefore > 0 ? (tokensBefore - tokensAfter) / tokensBefore : 0,
+      entriesProcessed: entries.length,
+      entriesKept: optimizedEntries.length,
+      stateDistribution: distribution,
+      durationMs: Date.now() - startTime
+    };
+    if (options.verbose) {
+      result.details = optimizedEntries.map((e) => ({
+        id: e.id,
+        score: e.score,
+        state: e.state,
+        isBTSP: e.isBTSP,
+        tokens: estimateTokens(e.content)
+      }));
+    }
+    return result;
+  }
+  return {
+    optimize
+  };
+}
+var init_generic = __esm({
+  "src/adapters/generic.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_btsp_embedder();
+    init_confidence_states();
+    init_engram_scorer();
+    init_sparse_pruner();
+    init_hash();
+    init_tokenizer();
+  }
+});
+
+// src/types/config.ts
+var DEFAULT_CONFIG;
+var init_config = __esm({
+  "src/types/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    DEFAULT_CONFIG = {
+      pruning: {
+        threshold: 5,
+        aggressiveness: 50
+      },
+      decay: {
+        defaultTTL: 24,
+        decayThreshold: 0.95
+      },
+      states: {
+        activeThreshold: 0.7,
+        readyThreshold: 0.3
+      },
+      agent: "generic",
+      ui: {
+        colors: true,
+        sounds: false,
+        verbose: false
+      },
+      autoConsolidate: null,
+      realtime: {
+        tokenBudget: 4e4,
+        autoOptimizeThreshold: 6e4,
+        watchPatterns: ["**/*.jsonl"],
+        pidFile: ".sparn/daemon.pid",
+        logFile: ".sparn/daemon.log",
+        debounceMs: 5e3,
+        incremental: true,
+        windowSize: 500,
+        consolidationInterval: null
+      }
+    };
+  }
+});
+
+// src/cli/commands/optimize.ts
+var optimize_exports = {};
+__export(optimize_exports, {
+  optimizeCommand: () => optimizeCommand
+});
+import { readFile, writeFile } from "fs/promises";
+async function optimizeCommand(options) {
+  const { memory, dryRun = false, verbose = false } = options;
+  let input;
+  if (options.inputFile) {
+    input = await readFile(options.inputFile, "utf-8");
+  } else if (options.input) {
+    input = options.input;
+  } else {
+    throw new Error("No input provided. Use --input or --input-file");
+  }
+  const adapter = createGenericAdapter(memory, DEFAULT_CONFIG);
+  const result = await adapter.optimize(input, { dryRun, verbose });
+  if (options.outputFile) {
+    await writeFile(options.outputFile, result.optimizedContext, "utf-8");
+  }
+  return {
+    ...result,
+    output: result.optimizedContext,
+    outputFile: options.outputFile
+  };
+}
+var init_optimize = __esm({
+  "src/cli/commands/optimize.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_generic();
+    init_config();
+  }
+});
+
+// src/cli/commands/stats.ts
+var stats_exports = {};
+__export(stats_exports, {
+  statsCommand: () => statsCommand
+});
+async function statsCommand(options) {
+  const { memory, graph, reset, confirmReset, json } = options;
+  if (reset) {
+    if (confirmReset) {
+      await memory.clearOptimizationStats();
+      return {
+        totalCommands: 0,
+        totalTokensSaved: 0,
+        averageReduction: 0,
+        resetConfirmed: true
+      };
+    }
+  }
+  const stats = await memory.getOptimizationStats();
+  const totalCommands = stats.length;
+  const totalTokensSaved = stats.reduce((sum, s) => sum + (s.tokens_before - s.tokens_after), 0);
+  const averageReduction = totalCommands > 0 ? stats.reduce((sum, s) => {
+    const reduction = s.tokens_before > 0 ? (s.tokens_before - s.tokens_after) / s.tokens_before : 0;
+    return sum + reduction;
+  }, 0) / totalCommands : 0;
+  const result = {
+    totalCommands,
+    totalTokensSaved,
+    averageReduction
+  };
+  if (graph && totalCommands > 0) {
+    result.graph = generateBarChart(stats);
+  }
+  if (json) {
+    result.json = JSON.stringify(
+      {
+        totalCommands,
+        totalTokensSaved,
+        averageReduction: Math.round(averageReduction * 1e3) / 10,
+        // Convert to percentage
+        optimizations: stats.map((s) => ({
+          timestamp: s.timestamp,
+          tokensBefore: s.tokens_before,
+          tokensAfter: s.tokens_after,
+          entriesPruned: s.entries_pruned,
+          durationMs: s.duration_ms,
+          reduction: Math.round((s.tokens_before - s.tokens_after) / s.tokens_before * 1e3) / 10
+        }))
+      },
+      null,
+      2
+    );
+  }
+  return result;
+}
+function generateBarChart(stats) {
+  const maxBars = 20;
+  const recentStats = stats.slice(0, maxBars);
+  const lines = [];
+  lines.push("\nOptimization History (most recent first):\n");
+  const maxReduction = Math.max(...recentStats.map((s) => s.tokens_before - s.tokens_after));
+  for (let i = 0; i < recentStats.length; i++) {
+    const s = recentStats[i];
+    if (!s) continue;
+    const reduction = s.tokens_before - s.tokens_after;
+    const reductionPct = s.tokens_before > 0 ? reduction / s.tokens_before * 100 : 0;
+    const barLength = Math.round(reduction / maxReduction * 40);
+    const bar = "\u2588".repeat(barLength);
+    const date = new Date(s.timestamp);
+    const timeStr = date.toLocaleTimeString();
+    lines.push(`${timeStr} \u2502 ${bar} ${reductionPct.toFixed(1)}%`);
+  }
+  return lines.join("\n");
+}
+var init_stats = __esm({
+  "src/cli/commands/stats.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/core/sleep-compressor.ts
+function createSleepCompressor() {
+  const scorer = createEngramScorer({ defaultTTL: 24, decayThreshold: 0.95 });
+  function consolidate(entries) {
+    const startTime = Date.now();
+    const originalCount = entries.length;
+    const now = Date.now();
+    const nonDecayed = entries.filter((entry) => {
+      const ageInSeconds = (now - entry.timestamp) / 1e3;
+      const decay = scorer.calculateDecay(ageInSeconds, entry.ttl);
+      return decay < 0.95;
+    });
+    const decayedRemoved = originalCount - nonDecayed.length;
+    const duplicateGroups = findDuplicates(nonDecayed);
+    const merged = mergeDuplicates(duplicateGroups);
+    const duplicateIds = new Set(duplicateGroups.flatMap((g) => g.entries.map((e) => e.id)));
+    const nonDuplicates = nonDecayed.filter((e) => !duplicateIds.has(e.id));
+    const kept = [...merged, ...nonDuplicates];
+    const removed = entries.filter((e) => !kept.some((k) => k.id === e.id));
+    const duplicatesRemoved = duplicateGroups.reduce((sum, g) => sum + (g.entries.length - 1), 0);
+    return {
+      kept,
+      removed,
+      entriesBefore: originalCount,
+      entriesAfter: kept.length,
+      decayedRemoved,
+      duplicatesRemoved,
+      compressionRatio: originalCount > 0 ? kept.length / originalCount : 0,
+      durationMs: Date.now() - startTime
+    };
+  }
+  function findDuplicates(entries) {
+    const groups = [];
+    const processed = /* @__PURE__ */ new Set();
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (!entry || processed.has(entry.id)) continue;
+      const duplicates = entries.filter((e, idx) => idx !== i && e.hash === entry.hash);
+      if (duplicates.length > 0) {
+        const group = {
+          entries: [entry, ...duplicates],
+          similarity: 1
+          // Exact match
+        };
+        groups.push(group);
+        processed.add(entry.id);
+        for (const dup of duplicates) {
+          processed.add(dup.id);
+        }
+      }
+    }
+    for (let i = 0; i < entries.length; i++) {
+      const entryI = entries[i];
+      if (!entryI || processed.has(entryI.id)) continue;
+      for (let j = i + 1; j < entries.length; j++) {
+        const entryJ = entries[j];
+        if (!entryJ || processed.has(entryJ.id)) continue;
+        const similarity = cosineSimilarity(entryI.content, entryJ.content);
+        if (similarity >= 0.85) {
+          const group = {
+            entries: [entryI, entryJ],
+            similarity
+          };
+          groups.push(group);
+          processed.add(entryI.id);
+          processed.add(entryJ.id);
+          break;
+        }
+      }
+    }
+    return groups;
+  }
+  function mergeDuplicates(groups) {
+    const merged = [];
+    for (const group of groups) {
+      const sorted = [...group.entries].sort((a, b) => b.score - a.score);
+      const best = sorted[0];
+      if (!best) continue;
+      const totalAccessCount = group.entries.reduce((sum, e) => sum + e.accessCount, 0);
+      const allTags = new Set(group.entries.flatMap((e) => e.tags));
+      merged.push({
+        ...best,
+        accessCount: totalAccessCount,
+        tags: Array.from(allTags)
+      });
+    }
+    return merged;
+  }
+  function cosineSimilarity(text1, text2) {
+    const words1 = tokenize2(text1);
+    const words2 = tokenize2(text2);
+    const vec1 = {};
+    const vec2 = {};
+    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;
+    for (const word of vocab) {
+      const count1 = vec1[word] ?? 0;
+      const count2 = vec2[word] ?? 0;
+      dotProduct += count1 * count2;
+      mag1 += count1 * count1;
+      mag2 += count2 * count2;
+    }
+    mag1 = Math.sqrt(mag1);
+    mag2 = Math.sqrt(mag2);
+    if (mag1 === 0 || mag2 === 0) return 0;
+    return dotProduct / (mag1 * mag2);
+  }
+  return {
+    consolidate,
+    findDuplicates,
+    mergeDuplicates
+  };
+}
+var init_sleep_compressor = __esm({
+  "src/core/sleep-compressor.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_tfidf();
+    init_engram_scorer();
+  }
+});
+
+// src/cli/commands/consolidate.ts
+var consolidate_exports = {};
+__export(consolidate_exports, {
+  consolidateCommand: () => consolidateCommand
+});
+async function consolidateCommand(options) {
+  const { memory } = options;
+  const allIds = await memory.list();
+  const allEntries = await Promise.all(
+    allIds.map(async (id) => {
+      const entry = await memory.get(id);
+      return entry;
+    })
+  );
+  const entries = allEntries.filter((e) => e !== null);
+  const compressor = createSleepCompressor();
+  const result = compressor.consolidate(entries);
+  for (const removed of result.removed) {
+    await memory.delete(removed.id);
+  }
+  for (const kept of result.kept) {
+    await memory.put(kept);
+  }
+  await memory.compact();
+  return {
+    entriesBefore: result.entriesBefore,
+    entriesAfter: result.entriesAfter,
+    decayedRemoved: result.decayedRemoved,
+    duplicatesRemoved: result.duplicatesRemoved,
+    compressionRatio: result.compressionRatio,
+    durationMs: result.durationMs,
+    vacuumCompleted: true
+  };
+}
+var init_consolidate = __esm({
+  "src/cli/commands/consolidate.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sleep_compressor();
+  }
+});
+
+// src/core/search-engine.ts
+import { execFileSync, execSync } from "child_process";
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { extname, join, relative } from "path";
+import Database from "better-sqlite3";
+function hasRipgrep() {
+  try {
+    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 = execFileSync("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 = relative(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 = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!ignoreDirs.includes(entry.name)) {
+          files.push(...collectIndexableFiles(fullPath, projectRoot, ignoreDirs, exts));
+        }
+      } else if (entry.isFile() && exts.includes(extname(entry.name))) {
+        try {
+          const stat = statSync(fullPath);
+          if (stat.size < 100 * 1024) {
+            files.push(relative(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 Database(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 = join(projectRoot, filePath);
+        if (!existsSync(fullPath)) continue;
+        try {
+          const stat = statSync(fullPath);
+          const existing = checkMeta.get(filePath);
+          if (existing && existing.mtime >= stat.mtimeMs) {
+            continue;
+          }
+          deleteFile.run(filePath);
+          const content = readFileSync(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 } from "path";
+async function searchCommand(options) {
+  const projectRoot = resolve(process.cwd());
+  const dbPath = resolve(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/dependency-graph.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+import { extname as extname2, join as join2, relative as relative2, resolve as resolve2 } 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 = join2(projectRoot, fromFile, "..");
+  const candidates = [
+    ...extensions.map((ext) => resolve2(baseDir, `${cleanImport}${ext}`)),
+    ...extensions.map((ext) => resolve2(baseDir, cleanImport, `index${ext}`))
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(candidate)) {
+      return relative2(projectRoot, candidate).replace(/\\/g, "/");
+    }
+  }
+  return null;
+}
+function collectFiles(dir, projectRoot, extensions, ignoreDirs) {
+  const files = [];
+  try {
+    const entries = readdirSync2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join2(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!ignoreDirs.includes(entry.name)) {
+          files.push(...collectFiles(fullPath, projectRoot, extensions, ignoreDirs));
+        }
+      } else if (entry.isFile() && extensions.includes(extname2(entry.name))) {
+        files.push(relative2(projectRoot, fullPath).replace(/\\/g, "/"));
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+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 = join2(projectRoot, filePath);
+      try {
+        const content = readFileSync2(fullPath, "utf-8");
+        const stat = statSync2(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;
+  }
+  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
+    };
+  }
+  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;
+  }
+  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];
+  }
+  function getNodes() {
+    return nodes;
+  }
+  return {
+    build,
+    analyze,
+    focus,
+    getFilesFromEntry,
+    getNodes
+  };
+}
+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
+    ];
+  }
+});
+
+// src/cli/commands/graph.ts
+var graph_exports = {};
+__export(graph_exports, {
+  graphCommand: () => graphCommand
+});
+import { resolve as resolve3 } from "path";
+async function graphCommand(options) {
+  const projectRoot = resolve3(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();
+  }
+});
+
+// src/core/workflow-planner.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { existsSync as existsSync3, mkdirSync, readdirSync as readdirSync3, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { join as join3 } from "path";
+function createWorkflowPlanner(projectRoot) {
+  const plansDir = join3(projectRoot, ".sparn", "plans");
+  if (!existsSync3(plansDir)) {
+    mkdirSync(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 join3(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"
+    };
+    writeFileSync(planPath(id), JSON.stringify(plan, null, 2), "utf-8");
+    return plan;
+  }
+  async function loadPlan(planId) {
+    const path2 = planPath(planId);
+    if (!existsSync3(path2)) return null;
+    try {
+      return JSON.parse(readFileSync3(path2, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  async function listPlans() {
+    if (!existsSync3(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(readFileSync3(join3(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;
+    }
+    writeFileSync(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";
+    writeFileSync(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";
+      writeFileSync(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 resolve4 } from "path";
+async function planCommand(options) {
+  const projectRoot = resolve4(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 = resolve4(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 resolve5 } from "path";
+async function execCommand(options) {
+  const projectRoot = resolve5(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 resolve6 } from "path";
+async function verifyCommand(options) {
+  const projectRoot = resolve6(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 existsSync4, readdirSync as readdirSync4, readFileSync as readFileSync4 } from "fs";
+import { extname as extname3, join as join4, 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 (existsSync4(join4(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 = join4(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 = readFileSync4(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 = join4(projectRoot, "package.json");
+  if (!existsSync4(pkgPath)) return null;
+  try {
+    return JSON.parse(readFileSync4(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 = join4(projectRoot, "src");
+    if (existsSync4(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 = join4(projectRoot, ".sparn", "config.yaml");
+    if (existsSync4(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 writeFileSync2 } from "fs";
+import { resolve as resolve7 } from "path";
+async function docsCommand(options) {
+  const projectRoot = resolve7(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 || resolve7(projectRoot, "CLAUDE.md");
+  writeFileSync2(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 Database2 from "better-sqlite3";
+function createDebtTracker(dbPath) {
+  const db = new Database2(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 resolve9(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: resolve9,
+    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 resolve8 } from "path";
+async function debtCommand(options) {
+  const projectRoot = resolve8(process.cwd());
+  const dbPath = resolve8(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/daemon/daemon-process.ts
+var daemon_process_exports = {};
+__export(daemon_process_exports, {
+  createDaemonCommand: () => createDaemonCommand
+});
+import { spawn } from "child_process";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync5, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { dirname, join as join5 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function createDaemonCommand() {
+  function isDaemonRunning(pidFile) {
+    if (!existsSync6(pidFile)) {
+      return { running: false };
+    }
+    try {
+      const pidStr = readFileSync5(pidFile, "utf-8").trim();
+      const pid = Number.parseInt(pidStr, 10);
+      if (Number.isNaN(pid)) {
+        return { running: false };
+      }
+      try {
+        process.kill(pid, 0);
+        return { running: true, pid };
+      } catch {
+        unlinkSync(pidFile);
+        return { running: false };
+      }
+    } catch {
+      return { running: false };
+    }
+  }
+  function writePidFile(pidFile, pid) {
+    const dir = dirname(pidFile);
+    if (!existsSync6(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    writeFileSync3(pidFile, String(pid), "utf-8");
+  }
+  function removePidFile(pidFile) {
+    if (existsSync6(pidFile)) {
+      unlinkSync(pidFile);
+    }
+  }
+  async function start(config) {
+    const { pidFile, logFile } = config.realtime;
+    const status2 = isDaemonRunning(pidFile);
+    if (status2.running) {
+      return {
+        success: false,
+        pid: status2.pid,
+        message: `Daemon already running (PID ${status2.pid})`,
+        error: "Already running"
+      };
+    }
+    try {
+      const __filename2 = fileURLToPath2(import.meta.url);
+      const __dirname2 = dirname(__filename2);
+      const daemonPath = join5(__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 = join5(dirname(pidFile), "daemon-config.json");
+        writeFileSync3(configFile, JSON.stringify({ config, pidFile, logFile }), "utf-8");
+        const launcherFile = join5(dirname(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");
+        writeFileSync3(launcherFile, launcherCode, "utf-8");
+        const ps = spawn(
+          "powershell.exe",
+          [
+            "-NoProfile",
+            "-WindowStyle",
+            "Hidden",
+            "-Command",
+            `Start-Process -FilePath '${process.execPath}' -ArgumentList '${launcherFile}' -WindowStyle Hidden`
+          ],
+          { stdio: "ignore", windowsHide: true }
+        );
+        ps.unref();
+        await new Promise((resolve9) => setTimeout(resolve9, 2e3));
+        if (existsSync6(pidFile)) {
+          const pid = Number.parseInt(readFileSync5(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 = spawn(process.execPath, [daemonPath], {
+        detached: true,
+        stdio: "ignore",
+        env: childEnv
+      });
+      child.unref();
+      if (child.pid) {
+        writePidFile(pidFile, child.pid);
+        return {
+          success: true,
+          pid: child.pid,
+          message: `Daemon started (PID ${child.pid})`
+        };
+      }
+      return {
+        success: false,
+        message: "Failed to start daemon (no PID)",
+        error: "No PID"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: "Failed to start daemon",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async function stop(config) {
+    const { pidFile } = config.realtime;
+    const status2 = isDaemonRunning(pidFile);
+    if (!status2.running || !status2.pid) {
+      return {
+        success: true,
+        message: "Daemon not running"
+      };
+    }
+    try {
+      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((resolve9) => setTimeout(resolve9, interval));
+          waited += interval;
+        } catch {
+          removePidFile(pidFile);
+          return {
+            success: true,
+            message: `Daemon stopped (PID ${status2.pid})`
+          };
+        }
+      }
+      try {
+        if (!isWindows) {
+          process.kill(status2.pid, "SIGKILL");
+        }
+        removePidFile(pidFile);
+        return {
+          success: true,
+          message: `Daemon force killed (PID ${status2.pid})`
+        };
+      } catch {
+        removePidFile(pidFile);
+        return {
+          success: true,
+          message: `Daemon stopped (PID ${status2.pid})`
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        message: "Failed to stop daemon",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async function status(config) {
+    const { pidFile } = config.realtime;
+    const daemonStatus = isDaemonRunning(pidFile);
+    if (!daemonStatus.running || !daemonStatus.pid) {
+      return {
+        running: false,
+        message: "Daemon not running"
+      };
+    }
+    return {
+      running: true,
+      pid: daemonStatus.pid,
+      message: `Daemon running (PID ${daemonStatus.pid})`
+    };
+  }
+  return {
+    start,
+    stop,
+    status
+  };
+}
+var init_daemon_process = __esm({
+  "src/daemon/daemon-process.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli/dashboard/app.tsx
+init_esm_shims();
+import { Box as Box7, render, Text as Text7, useApp, useInput } from "ink";
+import { useEffect as useEffect2, useState as useState4 } from "react";
+
+// src/cli/dashboard/components/command-input.tsx
+init_esm_shims();
+import { Box, Text } from "ink";
+import TextInput from "ink-text-input";
+import { useState } from "react";
+
+// src/cli/dashboard/theme.ts
+init_esm_shims();
+var theme = {
+  neuralCyan: "#00D4AA",
+  synapseViolet: "#7B61FF",
+  errorRed: "#FF6B6B",
+  brainPink: "#FF6B9D",
+  dimGray: "#555555",
+  white: "#FFFFFF"
+};
+
+// src/cli/dashboard/components/command-input.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function CommandInput({
+  onSubmit,
+  isRunning,
+  runningCommand,
+  active
+}) {
+  const [value, setValue] = useState("");
+  const handleSubmit = (input) => {
+    if (input.trim().length === 0) return;
+    onSubmit(input.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]" })
+  ] });
+}
+
+// src/cli/dashboard/components/output-panel.tsx
+init_esm_shims();
+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" : ""
+        ] })
+      ]
+    }
+  );
+}
+
+// src/cli/dashboard/hooks/use-command-executor.ts
+init_esm_shims();
+import { useCallback, useState as useState2 } from "react";
+
+// src/cli/dashboard/command-parser.ts
+init_esm_shims();
+function tokenize(input) {
+  const tokens = [];
+  let current = "";
+  let inQuote = null;
+  for (const ch of input) {
+    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(input) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) return null;
+  const tokens = tokenize(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 };
+}
+
+// src/cli/dashboard/formatters.ts
+init_esm_shims();
+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)" }
+  ];
+}
+
+// src/cli/dashboard/hooks/use-command-executor.ts
+var MAX_OUTPUT_LINES = 200;
+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 executeCommand(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 executeCommand(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.`);
+  }
+}
+
+// src/cli/dashboard/hooks/use-data.ts
+init_esm_shims();
+init_debt_tracker();
+init_dependency_graph();
+import { statSync as statSync3 } from "fs";
+import { useCallback as useCallback2, useEffect, useRef, useState as useState3 } from "react";
+
+// src/core/kv-memory.ts
+init_esm_shims();
+import { copyFileSync, existsSync as existsSync5 } from "fs";
+import Database3 from "better-sqlite3";
+function createBackup(dbPath) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${dbPath}.backup-${timestamp}`;
+  try {
+    copyFileSync(dbPath, backupPath);
+    console.log(`\u2713 Database backed up to: ${backupPath}`);
+    return backupPath;
+  } catch (error) {
+    console.error(`Warning: Could not create backup: ${error}`);
+    return "";
+  }
+}
+async function createKVMemory(dbPath) {
+  let db;
+  try {
+    db = new Database3(dbPath);
+    const integrityCheck = db.pragma("quick_check", { simple: true });
+    if (integrityCheck !== "ok") {
+      console.error("\u26A0 Database corruption detected!");
+      db.close();
+      if (existsSync5(dbPath)) {
+        const backupPath = createBackup(dbPath);
+        if (backupPath) {
+          console.log(`Backup created at: ${backupPath}`);
+        }
+      }
+      console.log("Attempting database recovery...");
+      db = new Database3(dbPath);
+    }
+  } catch (error) {
+    console.error("\u26A0 Database error detected:", error);
+    if (existsSync5(dbPath)) {
+      createBackup(dbPath);
+      console.log("Creating new database...");
+    }
+    db = new Database3(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,
+      hash TEXT UNIQUE NOT NULL,
+      timestamp INTEGER NOT NULL,
+      score REAL NOT NULL DEFAULT 0.0 CHECK(score >= 0.0 AND score <= 1.0),
+      ttl INTEGER NOT NULL CHECK(ttl >= 0),
+      state TEXT NOT NULL CHECK(state IN ('silent', 'ready', 'active')),
+      accessCount INTEGER NOT NULL DEFAULT 0 CHECK(accessCount >= 0),
+      isBTSP INTEGER NOT NULL DEFAULT 0 CHECK(isBTSP IN (0, 1)),
+      created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now'))
+    );
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS entries_value (
+      id TEXT PRIMARY KEY NOT NULL,
+      content TEXT NOT NULL,
+      tags TEXT,
+      metadata TEXT,
+      FOREIGN KEY (id) REFERENCES entries_index(id) ON DELETE CASCADE
+    );
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS optimization_stats (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
+      tokens_before INTEGER NOT NULL,
+      tokens_after INTEGER NOT NULL,
+      entries_pruned INTEGER NOT NULL,
+      duration_ms INTEGER NOT NULL
+    );
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_entries_state ON entries_index(state);
+    CREATE INDEX IF NOT EXISTS idx_entries_score ON entries_index(score DESC);
+    CREATE INDEX IF NOT EXISTS idx_entries_hash ON entries_index(hash);
+    CREATE INDEX IF NOT EXISTS idx_entries_timestamp ON entries_index(timestamp DESC);
+    CREATE INDEX IF NOT EXISTS idx_stats_timestamp ON optimization_stats(timestamp DESC);
+  `);
+  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)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const putValueStmt = db.prepare(`
+    INSERT OR REPLACE INTO entries_value
+    (id, content, tags, metadata)
+    VALUES (?, ?, ?, ?)
+  `);
+  const getStmt = db.prepare(`
+    SELECT
+      i.id, i.hash, i.timestamp, i.score, i.ttl, i.state, i.accessCount, i.isBTSP,
+      v.content, v.tags, v.metadata
+    FROM entries_index i
+    JOIN entries_value v ON i.id = v.id
+    WHERE i.id = ?
+  `);
+  const deleteIndexStmt = db.prepare("DELETE FROM entries_index WHERE id = ?");
+  const deleteValueStmt = db.prepare("DELETE FROM entries_value WHERE id = ?");
+  return {
+    async put(entry) {
+      const transaction = db.transaction(() => {
+        putIndexStmt.run(
+          entry.id,
+          entry.hash,
+          entry.timestamp,
+          entry.score,
+          entry.ttl,
+          entry.state,
+          entry.accessCount,
+          entry.isBTSP ? 1 : 0
+        );
+        putValueStmt.run(
+          entry.id,
+          entry.content,
+          JSON.stringify(entry.tags),
+          JSON.stringify(entry.metadata)
+        );
+      });
+      transaction();
+    },
+    async get(id) {
+      const row = getStmt.get(id);
+      if (!row) {
+        return null;
+      }
+      const r = row;
+      return {
+        id: r.id,
+        content: r.content,
+        hash: r.hash,
+        timestamp: r.timestamp,
+        score: r.score,
+        ttl: r.ttl,
+        state: r.state,
+        accessCount: r.accessCount,
+        tags: r.tags ? JSON.parse(r.tags) : [],
+        metadata: r.metadata ? JSON.parse(r.metadata) : {},
+        isBTSP: r.isBTSP === 1
+      };
+    },
+    async query(filters) {
+      let sql = `
+        SELECT
+          i.id, i.hash, i.timestamp, i.score, i.ttl, i.state, i.accessCount, i.isBTSP,
+          v.content, v.tags, v.metadata
+        FROM entries_index i
+        JOIN entries_value v ON i.id = v.id
+        WHERE 1=1
+      `;
+      const params = [];
+      if (filters.state) {
+        sql += " AND i.state = ?";
+        params.push(filters.state);
+      }
+      if (filters.minScore !== void 0) {
+        sql += " AND i.score >= ?";
+        params.push(filters.minScore);
+      }
+      if (filters.maxScore !== void 0) {
+        sql += " AND i.score <= ?";
+        params.push(filters.maxScore);
+      }
+      if (filters.isBTSP !== void 0) {
+        sql += " AND i.isBTSP = ?";
+        params.push(filters.isBTSP ? 1 : 0);
+      }
+      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);
+        }
+      }
+      const stmt = db.prepare(sql);
+      const rows = stmt.all(...params);
+      return rows.map((row) => {
+        const r = row;
+        return {
+          id: r.id,
+          content: r.content,
+          hash: r.hash,
+          timestamp: r.timestamp,
+          score: r.score,
+          ttl: r.ttl,
+          state: r.state,
+          accessCount: r.accessCount,
+          tags: r.tags ? JSON.parse(r.tags) : [],
+          metadata: r.metadata ? JSON.parse(r.metadata) : {},
+          isBTSP: r.isBTSP === 1
+        };
+      });
+    },
+    async delete(id) {
+      const transaction = db.transaction(() => {
+        deleteIndexStmt.run(id);
+        deleteValueStmt.run(id);
+      });
+      transaction();
+    },
+    async list() {
+      const stmt = db.prepare("SELECT id FROM entries_index");
+      const rows = stmt.all();
+      return rows.map((r) => r.id);
+    },
+    async compact() {
+      const before = db.prepare("SELECT COUNT(*) as count FROM entries_index").get();
+      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;
+    },
+    async close() {
+      db.close();
+    },
+    async recordOptimization(stats) {
+      const stmt = db.prepare(`
+        INSERT INTO optimization_stats (timestamp, tokens_before, tokens_after, entries_pruned, duration_ms)
+        VALUES (?, ?, ?, ?, ?)
+      `);
+      stmt.run(
+        stats.timestamp,
+        stats.tokens_before,
+        stats.tokens_after,
+        stats.entries_pruned,
+        stats.duration_ms
+      );
+      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(`
+        SELECT id, timestamp, tokens_before, tokens_after, entries_pruned, duration_ms
+        FROM optimization_stats
+        ORDER BY timestamp DESC
+      `);
+      const rows = stmt.all();
+      return rows;
+    },
+    async clearOptimizationStats() {
+      db.exec("DELETE FROM optimization_stats");
+    },
+    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 [];
+      }
+    }
+  };
+}
+
+// src/cli/dashboard/hooks/use-data.ts
+var NOOP = () => {
+};
+var 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
+};
+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: readFileSync6 } = await import("fs");
+      const { resolve: resolve9 } = await import("path");
+      const { load: parseYAML } = await import("js-yaml");
+      const configPath = resolve9(projectRoot, ".sparn/config.yaml");
+      const configContent = readFileSync6(configPath, "utf-8");
+      const config = parseYAML(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 {
+  }
+}
+
+// src/cli/dashboard/panels/debt-tracker.tsx
+init_esm_shims();
+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
+        ] }) })
+      ]
+    }
+  );
+}
+
+// src/cli/dashboard/panels/graph-view.tsx
+init_esm_shims();
+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" : ""
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/cli/dashboard/panels/memory-status.tsx
+init_esm_shims();
+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) })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/cli/dashboard/panels/optimization.tsx
+init_esm_shims();
+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);
+          })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/cli/dashboard/app.tsx
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var PANELS = ["optimization", "graph", "memory", "debt", "output"];
+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(
+    (input, key) => {
+      if (mode === "command") {
+        if (key.escape) {
+          setMode("monitor");
+        }
+        return;
+      }
+      if (input === "q") {
+        exit();
+        return;
+      }
+      if (input === ":") {
+        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
+      }
+    )
+  );
+}
+export {
+  renderDashboard
+};
+//# sourceMappingURL=dashboard.js.map