@ulrichc1/sparn 1.0.1 → 1.1.0

package/dist/cli/index.cjs

@@ -372,7 +372,17 @@ var init_config = __esm({
         sounds: false,
         verbose: false
       },
-      autoConsolidate: null
+      autoConsolidate: null,
+      realtime: {
+        tokenBudget: 5e4,
+        autoOptimizeThreshold: 8e4,
+        watchPatterns: ["**/*.jsonl"],
+        pidFile: ".sparn/daemon.pid",
+        logFile: ".sparn/daemon.log",
+        debounceMs: 5e3,
+        incremental: true,
+        windowSize: 500
+      }
     };
   }
 });
@@ -389,8 +399,8 @@ function getVersion() {
     return pkg.version;
   } catch {
     const __filename2 = (0, import_node_url.fileURLToPath)(importMetaUrl);
-    const __dirname = (0, import_node_path.dirname)(__filename2);
-    const pkg = JSON.parse((0, import_node_fs2.readFileSync)((0, import_node_path.join)(__dirname, "../../package.json"), "utf-8"));
+    const __dirname2 = (0, import_node_path.dirname)(__filename2);
+    const pkg = JSON.parse((0, import_node_fs2.readFileSync)((0, import_node_path.join)(__dirname2, "../../package.json"), "utf-8"));
     return pkg.version;
   }
 }
@@ -1485,27 +1495,515 @@ var init_config2 = __esm({
         validate: (v) => v === null || typeof v === "number" && v > 0,
         errorMessage: "autoConsolidate must be a positive number (hours) or null",
         parse: (v) => v === "null" ? null : Number.parseFloat(v)
+      },
+      "realtime.tokenBudget": {
+        path: ["realtime", "tokenBudget"],
+        validate: (v) => typeof v === "number" && v > 0,
+        errorMessage: "tokenBudget must be a positive number",
+        parse: (v) => Number.parseInt(v, 10)
+      },
+      "realtime.autoOptimizeThreshold": {
+        path: ["realtime", "autoOptimizeThreshold"],
+        validate: (v) => typeof v === "number" && v > 0,
+        errorMessage: "autoOptimizeThreshold must be a positive number",
+        parse: (v) => Number.parseInt(v, 10)
+      },
+      "realtime.watchPatterns": {
+        path: ["realtime", "watchPatterns"],
+        validate: (v) => Array.isArray(v) && v.every((p) => typeof p === "string"),
+        errorMessage: "watchPatterns must be an array of strings",
+        parse: (v) => v.split(",").map((p) => p.trim())
+      },
+      "realtime.pidFile": {
+        path: ["realtime", "pidFile"],
+        validate: (v) => typeof v === "string" && v.length > 0,
+        errorMessage: "pidFile must be a non-empty string",
+        parse: (v) => v
+      },
+      "realtime.logFile": {
+        path: ["realtime", "logFile"],
+        validate: (v) => typeof v === "string" && v.length > 0,
+        errorMessage: "logFile must be a non-empty string",
+        parse: (v) => v
+      },
+      "realtime.debounceMs": {
+        path: ["realtime", "debounceMs"],
+        validate: (v) => typeof v === "number" && v >= 0,
+        errorMessage: "debounceMs must be a non-negative number",
+        parse: (v) => Number.parseInt(v, 10)
+      },
+      "realtime.incremental": {
+        path: ["realtime", "incremental"],
+        validate: (v) => typeof v === "boolean",
+        errorMessage: "incremental must be true or false",
+        parse: (v) => v === "true"
+      },
+      "realtime.windowSize": {
+        path: ["realtime", "windowSize"],
+        validate: (v) => typeof v === "number" && v > 0,
+        errorMessage: "windowSize must be a positive number",
+        parse: (v) => Number.parseInt(v, 10)
+      }
+    };
+  }
+});
+
+// src/core/metrics.ts
+function createMetricsCollector() {
+  const optimizations = [];
+  let daemonMetrics = {
+    startTime: Date.now(),
+    sessionsWatched: 0,
+    totalOptimizations: 0,
+    totalTokensSaved: 0,
+    averageLatency: 0,
+    memoryUsage: 0
+  };
+  let cacheHits = 0;
+  let cacheMisses = 0;
+  function recordOptimization(metric) {
+    optimizations.push(metric);
+    daemonMetrics.totalOptimizations++;
+    daemonMetrics.totalTokensSaved += metric.tokensBefore - metric.tokensAfter;
+    if (metric.cacheHitRate > 0) {
+      const hits = Math.round(metric.entriesProcessed * metric.cacheHitRate);
+      cacheHits += hits;
+      cacheMisses += metric.entriesProcessed - hits;
+    }
+    daemonMetrics.averageLatency = (daemonMetrics.averageLatency * (daemonMetrics.totalOptimizations - 1) + metric.duration) / daemonMetrics.totalOptimizations;
+    if (optimizations.length > 1e3) {
+      optimizations.shift();
+    }
+  }
+  function updateDaemon(metric) {
+    daemonMetrics = {
+      ...daemonMetrics,
+      ...metric
+    };
+  }
+  function calculatePercentile(values, percentile) {
+    if (values.length === 0) return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = Math.ceil(percentile / 100 * sorted.length) - 1;
+    return sorted[index] || 0;
+  }
+  function getSnapshot() {
+    const totalRuns = optimizations.length;
+    const totalDuration = optimizations.reduce((sum, m) => sum + m.duration, 0);
+    const totalTokensSaved = optimizations.reduce(
+      (sum, m) => sum + (m.tokensBefore - m.tokensAfter),
+      0
+    );
+    const totalTokensBefore = optimizations.reduce((sum, m) => sum + m.tokensBefore, 0);
+    const averageReduction = totalTokensBefore > 0 ? totalTokensSaved / totalTokensBefore : 0;
+    const durations = optimizations.map((m) => m.duration);
+    const totalCacheQueries = cacheHits + cacheMisses;
+    const hitRate = totalCacheQueries > 0 ? cacheHits / totalCacheQueries : 0;
+    return {
+      timestamp: Date.now(),
+      optimization: {
+        totalRuns,
+        totalDuration,
+        totalTokensSaved,
+        averageReduction,
+        p50Latency: calculatePercentile(durations, 50),
+        p95Latency: calculatePercentile(durations, 95),
+        p99Latency: calculatePercentile(durations, 99)
+      },
+      cache: {
+        hitRate,
+        totalHits: cacheHits,
+        totalMisses: cacheMisses,
+        size: optimizations.reduce((sum, m) => sum + m.entriesKept, 0)
+      },
+      daemon: {
+        uptime: Date.now() - daemonMetrics.startTime,
+        sessionsWatched: daemonMetrics.sessionsWatched,
+        memoryUsage: daemonMetrics.memoryUsage
+      }
+    };
+  }
+  function exportMetrics() {
+    return JSON.stringify(getSnapshot(), null, 2);
+  }
+  function reset() {
+    optimizations.length = 0;
+    cacheHits = 0;
+    cacheMisses = 0;
+    daemonMetrics = {
+      startTime: Date.now(),
+      sessionsWatched: 0,
+      totalOptimizations: 0,
+      totalTokensSaved: 0,
+      averageLatency: 0,
+      memoryUsage: 0
+    };
+  }
+  return {
+    recordOptimization,
+    updateDaemon,
+    getSnapshot,
+    export: exportMetrics,
+    reset
+  };
+}
+function getMetrics() {
+  if (!globalMetrics) {
+    globalMetrics = createMetricsCollector();
+  }
+  return globalMetrics;
+}
+var globalMetrics;
+var init_metrics = __esm({
+  "src/core/metrics.ts"() {
+    "use strict";
+    init_cjs_shims();
+    globalMetrics = null;
+  }
+});
+
+// src/daemon/daemon-process.ts
+var daemon_process_exports = {};
+__export(daemon_process_exports, {
+  createDaemonCommand: () => createDaemonCommand
+});
+function createDaemonCommand() {
+  function isDaemonRunning(pidFile) {
+    if (!(0, import_node_fs4.existsSync)(pidFile)) {
+      return { running: false };
+    }
+    try {
+      const pidStr = (0, import_node_fs4.readFileSync)(pidFile, "utf-8").trim();
+      const pid = Number.parseInt(pidStr, 10);
+      if (Number.isNaN(pid)) {
+        return { running: false };
+      }
+      try {
+        process.kill(pid, 0);
+        return { running: true, pid };
+      } catch {
+        (0, import_node_fs4.unlinkSync)(pidFile);
+        return { running: false };
       }
+    } catch {
+      return { running: false };
+    }
+  }
+  function writePidFile(pidFile, pid) {
+    const dir = (0, import_node_path2.dirname)(pidFile);
+    if (!(0, import_node_fs4.existsSync)(dir)) {
+      (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+    }
+    (0, import_node_fs4.writeFileSync)(pidFile, String(pid), "utf-8");
+  }
+  function removePidFile(pidFile) {
+    if ((0, import_node_fs4.existsSync)(pidFile)) {
+      (0, import_node_fs4.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 daemonPath = (0, import_node_path2.join)(__dirname, "index.js");
+      const child = (0, import_node_child_process2.fork)(daemonPath, [], {
+        detached: true,
+        stdio: "ignore",
+        env: {
+          ...process.env,
+          SPARN_CONFIG: JSON.stringify(config),
+          SPARN_PID_FILE: pidFile,
+          SPARN_LOG_FILE: logFile
+        }
+      });
+      child.unref();
+      if (child.pid) {
+        writePidFile(pidFile, child.pid);
+        return {
+          success: true,
+          pid: child.pid,
+          message: `Daemon started (PID ${child.pid})`
+        };
+      }
+      return {
+        success: false,
+        message: "Failed to start daemon (no PID)",
+        error: "No PID"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: "Failed to start daemon",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async function stop(config) {
+    const { pidFile } = config.realtime;
+    const status2 = isDaemonRunning(pidFile);
+    if (!status2.running || !status2.pid) {
+      return {
+        success: true,
+        message: "Daemon not running"
+      };
+    }
+    try {
+      process.kill(status2.pid, "SIGTERM");
+      const maxWait = 5e3;
+      const interval = 100;
+      let waited = 0;
+      while (waited < maxWait) {
+        try {
+          process.kill(status2.pid, 0);
+          await new Promise((resolve2) => setTimeout(resolve2, interval));
+          waited += interval;
+        } catch {
+          removePidFile(pidFile);
+          return {
+            success: true,
+            message: `Daemon stopped (PID ${status2.pid})`
+          };
+        }
+      }
+      try {
+        process.kill(status2.pid, "SIGKILL");
+        removePidFile(pidFile);
+        return {
+          success: true,
+          message: `Daemon force killed (PID ${status2.pid})`
+        };
+      } catch {
+        removePidFile(pidFile);
+        return {
+          success: true,
+          message: `Daemon stopped (PID ${status2.pid})`
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        message: "Failed to stop daemon",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async function status(config) {
+    const { pidFile } = config.realtime;
+    const daemonStatus = isDaemonRunning(pidFile);
+    if (!daemonStatus.running || !daemonStatus.pid) {
+      return {
+        running: false,
+        message: "Daemon not running"
+      };
+    }
+    const metrics = getMetrics().getSnapshot();
+    return {
+      running: true,
+      pid: daemonStatus.pid,
+      uptime: metrics.daemon.uptime,
+      sessionsWatched: metrics.daemon.sessionsWatched,
+      tokensSaved: metrics.optimization.totalTokensSaved,
+      message: `Daemon running (PID ${daemonStatus.pid})`
     };
   }
+  return {
+    start,
+    stop,
+    status
+  };
+}
+var import_node_child_process2, import_node_fs4, import_node_path2;
+var init_daemon_process = __esm({
+  "src/daemon/daemon-process.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_child_process2 = require("child_process");
+    import_node_fs4 = require("fs");
+    import_node_path2 = require("path");
+    init_metrics();
+  }
+});
+
+// src/cli/commands/hooks.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  hooksCommand: () => hooksCommand
+});
+async function hooksCommand(options) {
+  const { subcommand, global } = options;
+  const settingsPath = global ? (0, import_node_path3.join)((0, import_node_os.homedir)(), ".claude", "settings.json") : (0, import_node_path3.join)(process.cwd(), ".claude", "settings.json");
+  const hooksDir = (0, import_node_path3.join)((0, import_node_path3.dirname)((0, import_node_path3.dirname)((0, import_node_path3.dirname)(__dirname))), "dist", "hooks");
+  const prePromptPath = (0, import_node_path3.join)(hooksDir, "pre-prompt.js");
+  const postToolResultPath = (0, import_node_path3.join)(hooksDir, "post-tool-result.js");
+  switch (subcommand) {
+    case "install":
+      return await installHooks(settingsPath, prePromptPath, postToolResultPath, global);
+    case "uninstall":
+      return await uninstallHooks(settingsPath, global);
+    case "status":
+      return await hooksStatus(settingsPath, global);
+    default:
+      return {
+        success: false,
+        message: `Unknown subcommand: ${subcommand}`,
+        error: "Invalid subcommand"
+      };
+  }
+}
+async function installHooks(settingsPath, prePromptPath, postToolResultPath, global) {
+  try {
+    if (!(0, import_node_fs5.existsSync)(prePromptPath)) {
+      return {
+        success: false,
+        message: `Hook script not found: ${prePromptPath}`,
+        error: "Hook scripts not built. Run `npm run build` first."
+      };
+    }
+    if (!(0, import_node_fs5.existsSync)(postToolResultPath)) {
+      return {
+        success: false,
+        message: `Hook script not found: ${postToolResultPath}`,
+        error: "Hook scripts not built. Run `npm run build` first."
+      };
+    }
+    let settings = {};
+    if ((0, import_node_fs5.existsSync)(settingsPath)) {
+      const settingsJson = (0, import_node_fs5.readFileSync)(settingsPath, "utf-8");
+      settings = JSON.parse(settingsJson);
+    } else {
+      const claudeDir = (0, import_node_path3.dirname)(settingsPath);
+      if (!(0, import_node_fs5.existsSync)(claudeDir)) {
+        (0, import_node_fs5.mkdirSync)(claudeDir, { recursive: true });
+      }
+    }
+    settings["hooks"] = {
+      ...typeof settings["hooks"] === "object" && settings["hooks"] !== null ? settings["hooks"] : {},
+      "pre-prompt": `node ${prePromptPath}`,
+      "post-tool-result": `node ${postToolResultPath}`
+    };
+    (0, import_node_fs5.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+    return {
+      success: true,
+      message: global ? "Hooks installed globally (all projects)" : "Hooks installed for current project",
+      installed: true,
+      hookPaths: {
+        prePrompt: prePromptPath,
+        postToolResult: postToolResultPath
+      }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: "Failed to install hooks",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function uninstallHooks(settingsPath, global) {
+  try {
+    if (!(0, import_node_fs5.existsSync)(settingsPath)) {
+      return {
+        success: true,
+        message: "No hooks installed (settings.json not found)",
+        installed: false
+      };
+    }
+    const settingsJson = (0, import_node_fs5.readFileSync)(settingsPath, "utf-8");
+    const settings = JSON.parse(settingsJson);
+    if (settings["hooks"] && typeof settings["hooks"] === "object" && settings["hooks"] !== null) {
+      const hooks = settings["hooks"];
+      delete hooks["pre-prompt"];
+      delete hooks["post-tool-result"];
+      if (Object.keys(hooks).length === 0) {
+        delete settings["hooks"];
+      }
+    }
+    (0, import_node_fs5.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+    return {
+      success: true,
+      message: global ? "Hooks uninstalled globally" : "Hooks uninstalled from current project",
+      installed: false
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: "Failed to uninstall hooks",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function hooksStatus(settingsPath, global) {
+  try {
+    if (!(0, import_node_fs5.existsSync)(settingsPath)) {
+      return {
+        success: true,
+        message: global ? "No global hooks installed (settings.json not found)" : "No project hooks installed (settings.json not found)",
+        installed: false
+      };
+    }
+    const settingsJson = (0, import_node_fs5.readFileSync)(settingsPath, "utf-8");
+    const settings = JSON.parse(settingsJson);
+    const hasHooks = settings["hooks"] && typeof settings["hooks"] === "object" && settings["hooks"] !== null && "pre-prompt" in settings["hooks"] && "post-tool-result" in settings["hooks"];
+    if (!hasHooks) {
+      return {
+        success: true,
+        message: global ? "No global hooks installed" : "No project hooks installed",
+        installed: false
+      };
+    }
+    const hooks = settings["hooks"];
+    return {
+      success: true,
+      message: global ? "Global hooks active" : "Project hooks active",
+      installed: true,
+      hookPaths: {
+        prePrompt: hooks["pre-prompt"] || "",
+        postToolResult: hooks["post-tool-result"] || ""
+      }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: "Failed to check hooks status",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+var import_node_fs5, import_node_os, import_node_path3;
+var init_hooks = __esm({
+  "src/cli/commands/hooks.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_fs5 = require("fs");
+    import_node_os = require("os");
+    import_node_path3 = require("path");
+  }
 });
 
 // src/cli/index.ts
 init_cjs_shims();
-var import_node_child_process2 = require("child_process");
-var import_node_fs4 = require("fs");
-var import_node_path2 = require("path");
+var import_node_child_process3 = require("child_process");
+var import_node_fs6 = require("fs");
+var import_node_path4 = require("path");
 var import_node_url2 = require("url");
 var import_commander = require("commander");
 init_banner();
 function getVersion2() {
   try {
-    const pkg = JSON.parse((0, import_node_fs4.readFileSync)((0, import_node_path2.join)(process.cwd(), "package.json"), "utf-8"));
+    const pkg = JSON.parse((0, import_node_fs6.readFileSync)((0, import_node_path4.join)(process.cwd(), "package.json"), "utf-8"));
     return pkg.version;
   } catch {
     const __filename2 = (0, import_node_url2.fileURLToPath)(importMetaUrl);
-    const __dirname = (0, import_node_path2.dirname)(__filename2);
-    const pkg = JSON.parse((0, import_node_fs4.readFileSync)((0, import_node_path2.join)(__dirname, "../../package.json"), "utf-8"));
+    const __dirname2 = (0, import_node_path4.dirname)(__filename2);
+    const pkg = JSON.parse((0, import_node_fs6.readFileSync)((0, import_node_path4.join)(__dirname2, "../../package.json"), "utf-8"));
     return pkg.version;
   }
 }
@@ -1626,7 +2124,7 @@ Typical Results:
       spinner.text = `\u{1F4D6} Reading context from ${options.input}...`;
     }
     spinner.text = "\u{1F4BE} Loading memory database...";
-    const dbPath = (0, import_node_path2.resolve)(process.cwd(), ".sparn/memory.db");
+    const dbPath = (0, import_node_path4.resolve)(process.cwd(), ".sparn/memory.db");
     const memory = await createKVMemory2(dbPath);
     spinner.text = "\u26A1 Applying neuroscience principles...";
     const result = await optimizeCommand2({
@@ -1690,7 +2188,7 @@ Tracked Metrics:
   try {
     if (spinner) spinner.start();
     if (spinner) spinner.text = "\u{1F4BE} Loading optimization history...";
-    const dbPath = (0, import_node_path2.resolve)(process.cwd(), ".sparn/memory.db");
+    const dbPath = (0, import_node_path4.resolve)(process.cwd(), ".sparn/memory.db");
     const memory = await createKVMemory2(dbPath);
     let confirmReset = false;
     if (options.reset) {
@@ -1750,7 +2248,7 @@ The relay command passes the exit code from the wrapped command.
   const { relayCommand: relayCommand2 } = await Promise.resolve().then(() => (init_relay(), relay_exports));
   const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
   try {
-    const dbPath = (0, import_node_path2.resolve)(process.cwd(), ".sparn/memory.db");
+    const dbPath = (0, import_node_path4.resolve)(process.cwd(), ".sparn/memory.db");
     const memory = await createKVMemory2(dbPath);
     const result = await relayCommand2({
       command,
@@ -1803,7 +2301,7 @@ Typical Results:
   try {
     spinner.start();
     spinner.text = "\u{1F4BE} Loading memory database...";
-    const dbPath = (0, import_node_path2.resolve)(process.cwd(), ".sparn/memory.db");
+    const dbPath = (0, import_node_path4.resolve)(process.cwd(), ".sparn/memory.db");
     const memory = await createKVMemory2(dbPath);
     spinner.text = "\u{1F50D} Identifying decayed entries...";
     const result = await consolidateCommand2({ memory });
@@ -1851,7 +2349,7 @@ The config file is located at .sparn/config.yaml
   const { configCommand: configCommand2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
   const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
   try {
-    const configPath = (0, import_node_path2.resolve)(process.cwd(), ".sparn/config.yaml");
+    const configPath = (0, import_node_path4.resolve)(process.cwd(), ".sparn/config.yaml");
     const result = await configCommand2({
       configPath,
       subcommand,
@@ -1868,7 +2366,7 @@ The config file is located at .sparn/config.yaml
       console.log(neuralCyan2(`
 \u{1F4DD} Opening config in ${editor}...
 `));
-      const child = (0, import_node_child_process2.spawn)(editor, [result.editorPath], {
+      const child = (0, import_node_child_process3.spawn)(editor, [result.editorPath], {
         stdio: "inherit"
       });
       child.on("close", (code) => {
@@ -1889,6 +2387,139 @@ The config file is located at .sparn/config.yaml
     process.exit(1);
   }
 });
+program.command("daemon <subcommand>").description("Manage real-time optimization daemon").addHelpText(
+  "after",
+  `
+Subcommands:
+  start                                 # Start daemon
+  stop                                  # Stop daemon
+  status                                # Check daemon status
+
+Examples:
+  $ sparn daemon start                  # Start watching Claude Code sessions
+  $ sparn daemon stop                   # Stop daemon
+  $ sparn daemon status                 # Check if daemon is running
+
+The daemon watches ~/.claude/projects/**/*.jsonl and automatically
+optimizes contexts when they exceed the configured threshold.
+`
+).action(async (subcommand) => {
+  const { load: parseYAML2 } = await import("js-yaml");
+  const { createDaemonCommand: createDaemonCommand2 } = await Promise.resolve().then(() => (init_daemon_process(), daemon_process_exports));
+  const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  try {
+    const configPath = (0, import_node_path4.resolve)(process.cwd(), ".sparn/config.yaml");
+    const configYAML = (0, import_node_fs6.readFileSync)(configPath, "utf-8");
+    const config = parseYAML2(configYAML);
+    const daemon = createDaemonCommand2();
+    switch (subcommand) {
+      case "start": {
+        const result = await daemon.start(config);
+        if (result.success) {
+          console.log(neuralCyan2(`
+\u2713 ${result.message}
+`));
+        } else {
+          console.error(errorRed2(`
+\u2717 ${result.message}
+`));
+          process.exit(1);
+        }
+        break;
+      }
+      case "stop": {
+        const result = await daemon.stop(config);
+        if (result.success) {
+          console.log(neuralCyan2(`
+\u2713 ${result.message}
+`));
+        } else {
+          console.error(errorRed2(`
+\u2717 ${result.message}
+`));
+          process.exit(1);
+        }
+        break;
+      }
+      case "status": {
+        const result = await daemon.status(config);
+        if (result.running) {
+          console.log(neuralCyan2(`
+\u2713 ${result.message}`));
+          if (result.sessionsWatched !== void 0) {
+            console.log(`  Sessions watched: ${result.sessionsWatched}`);
+          }
+          if (result.tokensSaved !== void 0) {
+            console.log(`  Tokens saved: ${result.tokensSaved.toLocaleString()}`);
+          }
+          console.log();
+        } else {
+          console.log(errorRed2(`
+\u2717 ${result.message}
+`));
+        }
+        break;
+      }
+      default:
+        console.error(errorRed2(`
+Unknown subcommand: ${subcommand}
+`));
+        console.error("Valid subcommands: start, stop, status\n");
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("hooks <subcommand>").description("Manage Claude Code hook integration").option("--global", "Install hooks globally (for all projects)").addHelpText(
+  "after",
+  `
+Subcommands:
+  install                               # Install hooks
+  uninstall                             # Uninstall hooks
+  status                                # Check hook status
+
+Examples:
+  $ sparn hooks install                 # Install hooks for current project
+  $ sparn hooks install --global        # Install hooks globally
+  $ sparn hooks uninstall               # Uninstall hooks
+  $ sparn hooks status                  # Check if hooks are active
+
+Hooks automatically optimize context before each Claude Code prompt
+and compress verbose tool results after execution.
+`
+).action(async (subcommand, options) => {
+  const { hooksCommand: hooksCommand2 } = await Promise.resolve().then(() => (init_hooks(), hooks_exports));
+  const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  try {
+    const result = await hooksCommand2({
+      subcommand,
+      global: options.global || false
+    });
+    if (result.success) {
+      console.log(neuralCyan2(`
+\u2713 ${result.message}`));
+      if (result.hookPaths) {
+        console.log("\nHook paths:");
+        console.log(`  pre-prompt: ${result.hookPaths.prePrompt}`);
+        console.log(`  post-tool-result: ${result.hookPaths.postToolResult}`);
+      }
+      console.log();
+    } else {
+      console.error(errorRed2(`
+\u2717 ${result.message}`));
+      if (result.error) {
+        console.error(`  ${result.error}`);
+      }
+      console.log();
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
 program.on("option:version", () => {
   console.log(getBanner(VERSION2));
   process.exit(0);