ccjk 4.0.0-beta.1 → 4.0.0-beta.2

package/dist/chunks/claude-wrapper.mjs

@@ -1,462 +1,3657 @@
 import process__default from 'node:process';
+import { existsSync, createReadStream, readFileSync, statSync, watch, mkdirSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { join, dirname, normalize } from 'pathe';
 import { exec } from 'tinyexec';
-import { i18n, initI18n } from './index2.mjs';
-import { findRealCommandPath, findCommandPath } from './platform.mjs';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import 'node:url';
-import 'i18next';
-import 'i18next-fs-backend';
-import 'pathe';
-
-function detectShellType() {
-  const shell = process__default.env.SHELL || "";
-  if (shell.includes("bash")) {
-    return "bash";
-  }
-  if (shell.includes("zsh")) {
-    return "zsh";
-  }
-  if (shell.includes("fish")) {
-    return "fish";
-  }
-  return "unknown";
+import { EventEmitter } from 'node:events';
+import { readFile, mkdir, writeFile, readdir, rename, unlink, stat } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import Anthropic from '@anthropic-ai/sdk';
+import { createInterface } from 'node:readline';
+
+const DEFAULT_CONFIG = {
+  toolResultThreshold: 500,
+  // 超过 500 tokens 的工具结果会被省略
+  preserveErrors: true,
+  preserveKeyInfo: true,
+  keyTools: ["Read", "Grep", "Glob", "Bash", "WebFetch"],
+  placeholderTemplate: "<Tool result omitted to save tokens. The assistant's response below contains the key findings.>"
+};
+function estimateTokens$1(text) {
+  return Math.ceil(text.length / 4);
 }
-function getShellRcFile(shellType) {
-  const home = os.homedir();
-  switch (shellType) {
-    case "bash":
-      if (fs.existsSync(path.join(home, ".bashrc"))) {
-        return path.join(home, ".bashrc");
-      }
-      return path.join(home, ".bash_profile");
-    case "zsh":
-      return path.join(home, ".zshrc");
-    case "fish":
-      return path.join(home, ".config", "fish", "config.fish");
+function extractKeyInfo(toolName, result) {
+  const lines = result.split("\n").filter((l) => l.trim());
+  switch (toolName) {
+    case "Read": {
+      const pathMatch = result.match(/Reading file: (.+)/);
+      const lineCount = lines.length;
+      return pathMatch ? `[Read ${pathMatch[1]}, ${lineCount} lines]` : `[Read file, ${lineCount} lines]`;
+    }
+    case "Grep": {
+      const matchCount = lines.length;
+      return `[Grep found ${matchCount} matches]`;
+    }
+    case "Glob": {
+      const fileCount = lines.length;
+      return `[Glob found ${fileCount} files]`;
+    }
+    case "Bash": {
+      const exitMatch = result.match(/exit code (\d+)/);
+      const exitCode = exitMatch ? exitMatch[1] : "0";
+      return `[Bash completed, exit code ${exitCode}]`;
+    }
+    case "WebFetch": {
+      const urlMatch = result.match(/https?:\/\/\S+/);
+      return urlMatch ? `[WebFetch from ${urlMatch[0].substring(0, 50)}...]` : "[WebFetch completed]";
+    }
     default:
-      return null;
+      return `[${toolName} completed]`;
   }
 }
-function generateHookScript(shellType) {
-  const ccjkPath = process__default.argv[1];
-  switch (shellType) {
-    case "bash":
-    case "zsh":
-      return `
-# CCJK Context Compression Hook - DO NOT EDIT THIS BLOCK
-# This hook enables transparent context compression for claude commands
-# Native slash commands (/plugin, /doctor, etc.) are passed through directly
-claude() {
-  # Find the real claude command path (bypass this function)
-  local real_claude
-  # Use which -a to find all occurrences and filter out this function
-  real_claude=$(which -a claude 2>/dev/null | grep -v "^claude () {" | grep "^/" | head -n 1)
-
-  # If first arg starts with '/', it's a native slash command - pass through directly
-  # Examples: /plugin, /doctor, /config, /permissions, /allowed-tools, etc.
-  if [[ "$1" == /* ]]; then
-    if [ -n "$real_claude" ]; then
-      "$real_claude" "$@"
-    else
-      # Fallback to direct execution if path not found
-      command claude "$@"
-    fi
-    return $?
-  fi
-
-  # Check for recursion - if already in wrapper, call real claude directly
-  if [ -n "$CCJK_WRAPPER_ACTIVE" ]; then
-    if [ -n "$real_claude" ]; then
-      "$real_claude" "$@"
-    else
-      command claude "$@"
-    fi
-    return $?
-  fi
-
-  export CCJK_WRAPPER_ACTIVE=1
-  ${ccjkPath} claude "$@"
-  local exit_code=$?
-  unset CCJK_WRAPPER_ACTIVE
-  return $exit_code
+class MiroThinkerCompressor {
+  config;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /**
+   * 压缩对话历史
+   *
+   * @param messages - 原始对话消息
+   * @returns 压缩后的对话
+   */
+  compress(messages) {
+    let originalTokens = 0;
+    let compressedTokens = 0;
+    let omittedToolResults = 0;
+    const compressedMessages = [];
+    for (let i = 0; i < messages.length; i++) {
+      const msg = messages[i];
+      const msgTokens = estimateTokens$1(msg.content);
+      originalTokens += msgTokens;
+      if (msg.role === "tool_result") {
+        const shouldCompress = this.shouldCompressToolResult(msg, msgTokens);
+        if (shouldCompress) {
+          const compressedContent = this.compressToolResult(msg);
+          const compressedMsg = {
+            ...msg,
+            content: compressedContent,
+            originalTokens: msgTokens,
+            compressed: true
+          };
+          compressedMessages.push(compressedMsg);
+          compressedTokens += estimateTokens$1(compressedContent);
+          omittedToolResults++;
+        } else {
+          compressedMessages.push({ ...msg, originalTokens: msgTokens });
+          compressedTokens += msgTokens;
+        }
+      } else {
+        compressedMessages.push({ ...msg, originalTokens: msgTokens });
+        compressedTokens += msgTokens;
+      }
+    }
+    return {
+      messages: compressedMessages,
+      originalTokens,
+      compressedTokens,
+      compressionRatio: originalTokens > 0 ? compressedTokens / originalTokens : 1,
+      omittedToolResults
+    };
+  }
+  /**
+   * 判断是否应该压缩工具结果
+   */
+  shouldCompressToolResult(msg, tokens) {
+    if (tokens < this.config.toolResultThreshold) {
+      return false;
+    }
+    if (this.config.preserveErrors && this.isErrorResult(msg.content)) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 检查是否是错误结果
+   */
+  isErrorResult(content) {
+    const errorPatterns = [
+      /error/i,
+      /failed/i,
+      /exception/i,
+      /not found/i,
+      /permission denied/i
+    ];
+    return errorPatterns.some((p) => p.test(content));
+  }
+  /**
+   * 压缩工具结果
+   */
+  compressToolResult(msg) {
+    const parts = [];
+    parts.push(this.config.placeholderTemplate);
+    if (this.config.preserveKeyInfo && msg.toolName) {
+      const keyInfo = extractKeyInfo(msg.toolName, msg.content);
+      parts.push(keyInfo);
+    }
+    return parts.join("\n");
+  }
+  /**
+   * 从 FC 摘要生成压缩消息
+   */
+  compressFromFCSummaries(summaries) {
+    return summaries.map((summary) => ({
+      role: "tool_result",
+      content: `<Tool result omitted> ${summary.summary}`,
+      toolCallId: summary.fcId,
+      toolName: summary.fcName,
+      originalTokens: summary.tokens,
+      compressed: true
+    }));
+  }
+  /**
+   * 生成摘要提示词
+   *
+   * 用于指导 AI 理解压缩后的上下文
+   */
+  generateSummaryPrompt() {
+    return `
+\u3010\u4E0A\u4E0B\u6587\u538B\u7F29\u8BF4\u660E - MiroThinker \u7B56\u7565\u3011
+
+\u672C\u5BF9\u8BDD\u5386\u53F2\u5DF2\u5E94\u7528"\u53BB\u8089\u7559\u9AA8"\u538B\u7F29\u7B56\u7565\uFF1A
+- "\u8089"\uFF08\u539F\u59CB\u6570\u636E\uFF09\uFF1A\u5DE5\u5177\u8FD4\u56DE\u7684\u539F\u59CB\u5185\u5BB9\u5DF2\u7701\u7565\uFF0C\u7528\u5360\u4F4D\u7B26\u66FF\u4EE3
+- "\u9AA8"\uFF08\u4FE1\u606F\u5207\u7247\uFF09\uFF1AAI \u7684\u601D\u8003\u548C\u7ED3\u8BBA\u5B8C\u6574\u4FDD\u7559
+
+\u539F\u7406\uFF1AAI \u7684\u56DE\u590D\u5DF2\u7ECF\u662F\u5BF9\u539F\u59CB\u6570\u636E\u7684\u9AD8\u4FDD\u771F\u63D0\u70BC\u3002
+\u5F53\u4F60\u770B\u5230 "<Tool result omitted>" \u65F6\uFF0C\u8BF7\u53C2\u8003\u7D27\u968F\u5176\u540E\u7684 Assistant \u56DE\u590D\uFF0C
+\u90A3\u91CC\u5305\u542B\u4E86\u5DE5\u5177\u7ED3\u679C\u7684\u5173\u952E\u53D1\u73B0\u548C\u7ED3\u8BBA\u3002
+
+\u3010\u6458\u8981\u8981\u6C42\u3011
+1. \u4FDD\u7559\u6240\u6709\u5173\u952E\u51B3\u7B56\u548C\u91CD\u8981\u7ED3\u8BBA\uFF08\u8FD9\u662F"\u9AA8"\uFF09
+2. \u4FDD\u7559\u9879\u76EE\u80CC\u666F\u548C\u5F53\u524D\u4EFB\u52A1
+3. \u4FDD\u7559 AI \u7684\u601D\u8003\u94FE\u548C\u63A8\u7406\u8FC7\u7A0B
+4. \u4E0D\u9700\u8981\u6062\u590D\u88AB\u7701\u7565\u7684\u539F\u59CB\u6570\u636E
+`.trim();
+  }
+  /**
+   * 更新配置
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * 获取当前配置
+   */
+  getConfig() {
+    return { ...this.config };
+  }
 }
-# END CCJK Context Compression Hook
+
+class AutoSummarizeManager extends EventEmitter {
+  contextManager;
+  compressor;
+  options;
+  lastSummarizeTime = 0;
+  pendingSummarize = false;
+  summarizeCount = 0;
+  constructor(contextManager, options = {}) {
+    super();
+    this.contextManager = contextManager;
+    this.compressor = new MiroThinkerCompressor({
+      toolResultThreshold: 500,
+      preserveErrors: true,
+      preserveKeyInfo: true
+    });
+    this.options = {
+      enabled: options.enabled ?? true,
+      minInterval: options.minInterval ?? 6e5,
+      // 10 minutes default
+      tokenThreshold: options.tokenThreshold ?? 1e5,
+      // 100K tokens
+      strategy: options.strategy ?? "miro-thinker",
+      compressionTarget: options.compressionTarget ?? 0.7,
+      // 70% compression target
+      debug: options.debug ?? false
+    };
+  }
+  /**
+   * Check if auto-summarization should trigger
+   */
+  shouldSummarize(currentTokens) {
+    if (!this.options.enabled) {
+      this.log("Auto-summarize disabled");
+      return false;
+    }
+    if (this.pendingSummarize) {
+      this.log("Summarization already in progress");
+      return false;
+    }
+    const now = Date.now();
+    const timeSinceLastSummarize = now - this.lastSummarizeTime;
+    if (timeSinceLastSummarize < this.options.minInterval) {
+      const remainingTime = Math.round((this.options.minInterval - timeSinceLastSummarize) / 1e3);
+      this.log(`Rate limited: ${remainingTime}s remaining (${timeSinceLastSummarize}ms / ${this.options.minInterval}ms)`);
+      this.emit("summarize:rate_limited", {
+        timeSinceLastSummarize,
+        remainingTime,
+        minInterval: this.options.minInterval
+      });
+      return false;
+    }
+    if (currentTokens < this.options.tokenThreshold) {
+      this.log(`Threshold not met: ${currentTokens} / ${this.options.tokenThreshold} tokens`);
+      this.emit("summarize:threshold_not_met", {
+        currentTokens,
+        threshold: this.options.tokenThreshold
+      });
+      return false;
+    }
+    this.log(`Should summarize: ${currentTokens} tokens, ${Math.round(timeSinceLastSummarize / 1e3)}s since last`);
+    return true;
+  }
+  /**
+   * Perform auto-summarization
+   */
+  async summarize() {
+    if (!this.options.enabled) {
+      return {
+        performed: false,
+        reason: "disabled",
+        summary: this.createEmptySummary()
+      };
+    }
+    if (this.pendingSummarize) {
+      this.log("Summarization already in progress, skipping");
+      return {
+        performed: false,
+        reason: "rate_limited",
+        summary: this.createEmptySummary()
+      };
+    }
+    this.pendingSummarize = true;
+    this.emit("summarize:started");
+    try {
+      this.log("\u{1F916} Auto-summarize triggered...");
+      const messages = await this.contextManager.getMessages();
+      const conversationMessages = messages.map((msg) => ({
+        role: msg.role === "system" ? "assistant" : msg.role,
+        content: msg.content,
+        originalTokens: msg.metadata?.tokens,
+        compressed: false
+      }));
+      const compressed = this.compressor.compress(conversationMessages);
+      const summaryContent = compressed.messages.filter((m) => m.role === "assistant").map((m) => m.content).join("\n\n---\n\n");
+      const summary = {
+        content: summaryContent,
+        originalTokens: compressed.originalTokens,
+        compressedTokens: compressed.compressedTokens,
+        compressionRatio: compressed.compressionRatio,
+        fcCount: 0,
+        // Not tracking function calls in auto-summarize
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      await this.contextManager.storeSummary(summary);
+      this.lastSummarizeTime = Date.now();
+      this.summarizeCount++;
+      this.log(`\u2705 Auto-summarize complete: ${summary.originalTokens} \u2192 ${summary.compressedTokens} tokens (${Math.round(summary.compressionRatio * 100)}% compression)`);
+      this.emit("summarize:completed", summary);
+      return {
+        performed: true,
+        summary
+      };
+    } catch (error) {
+      this.log(`\u274C Auto-summarize error: ${error}`);
+      this.emit("summarize:error", error);
+      return {
+        performed: false,
+        reason: "error",
+        summary: this.createEmptySummary()
+      };
+    } finally {
+      this.pendingSummarize = false;
+    }
+  }
+  /**
+   * Check if summarization is allowed (not rate limited)
+   */
+  canSummarize() {
+    if (!this.options.enabled)
+      return false;
+    if (this.pendingSummarize)
+      return false;
+    const now = Date.now();
+    const timeSinceLastSummarize = now - this.lastSummarizeTime;
+    return timeSinceLastSummarize >= this.options.minInterval;
+  }
+  /**
+   * Get time until next summarization allowed (ms)
+   */
+  getTimeUntilNextSummarize() {
+    const now = Date.now();
+    const timeSinceLastSummarize = now - this.lastSummarizeTime;
+    const remaining = this.options.minInterval - timeSinceLastSummarize;
+    return Math.max(0, remaining);
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    const now = Date.now();
+    const timeSinceLastSummarize = now - this.lastSummarizeTime;
+    return {
+      enabled: this.options.enabled,
+      lastSummarizeTime: this.lastSummarizeTime,
+      timeSinceLastSummarize,
+      canSummarize: this.canSummarize(),
+      timeUntilNextSummarize: this.getTimeUntilNextSummarize(),
+      minInterval: this.options.minInterval,
+      tokenThreshold: this.options.tokenThreshold,
+      summarizeCount: this.summarizeCount,
+      isPending: this.pendingSummarize
+    };
+  }
+  /**
+   * Enable auto-summarization
+   */
+  enable() {
+    this.options.enabled = true;
+    this.log("Auto-summarize enabled");
+  }
+  /**
+   * Disable auto-summarization
+   */
+  disable() {
+    this.options.enabled = false;
+    this.log("Auto-summarize disabled");
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(options) {
+    if (options.enabled !== void 0)
+      this.options.enabled = options.enabled;
+    if (options.minInterval !== void 0)
+      this.options.minInterval = options.minInterval;
+    if (options.tokenThreshold !== void 0)
+      this.options.tokenThreshold = options.tokenThreshold;
+    if (options.strategy !== void 0)
+      this.options.strategy = options.strategy;
+    if (options.compressionTarget !== void 0)
+      this.options.compressionTarget = options.compressionTarget;
+    if (options.debug !== void 0)
+      this.options.debug = options.debug;
+    this.log("Configuration updated");
+  }
+  /**
+   * Force reset rate limiting (for testing or manual override)
+   */
+  resetRateLimit() {
+    this.lastSummarizeTime = 0;
+    this.log("Rate limit reset");
+  }
+  /**
+   * Reset all statistics
+   */
+  resetStats() {
+    this.lastSummarizeTime = 0;
+    this.summarizeCount = 0;
+    this.pendingSummarize = false;
+    this.log("Statistics reset");
+  }
+  /**
+   * Create empty summary for error cases
+   */
+  createEmptySummary() {
+    return {
+      content: "",
+      originalTokens: 0,
+      compressedTokens: 0,
+      compressionRatio: 0,
+      fcCount: 0,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Debug logging
+   */
+  log(message) {
+    if (this.options.debug) {
+      console.log(`[AutoSummarizeManager] ${message}`);
+    }
+  }
+}
+
+const DEFAULT_CONTEXT_CONFIG = {
+  enabled: true,
+  autoSummarize: true,
+  contextThreshold: 1e5,
+  // 100K tokens
+  maxContextTokens: 15e4,
+  // 150K tokens
+  summaryModel: "haiku",
+  cloudSync: {
+    enabled: false,
+    apiKey: void 0,
+    endpoint: void 0
+  },
+  cleanup: {
+    maxSessionAge: 30,
+    // 30 days
+    maxStorageSize: 500,
+    // 500 MB
+    autoCleanup: true
+  },
+  storage: {
+    baseDir: join(homedir(), ".ccjk", "context"),
+    sessionsDir: "sessions",
+    syncQueueDir: "sync-queue"
+  },
+  // Phase 1: New configuration options
+  threadBased: {
+    enabled: false,
+    // Opt-in feature
+    maxThreadTokens: 5e3,
+    autoCloseOnThreshold: true,
+    preserveThreadChain: true
+  },
+  planAcceptance: {
+    enabled: false,
+    // Opt-in feature
+    autoCompress: true,
+    clearContext: true,
+    injectSummary: true,
+    minInterval: 6e5
+    // 10 minutes
+  },
+  autoSummarizeEnhanced: {
+    enabled: false,
+    // Opt-in feature
+    minInterval: 6e5,
+    // 10 minutes
+    tokenThreshold: 1e5,
+    // 100K tokens
+    strategy: "miro-thinker",
+    compressionTarget: 0.7
+    // 70% compression target
+  }
+};
+class ConfigManager {
+  config;
+  configPath;
+  loaded = false;
+  constructor(configPath) {
+    this.configPath = configPath || join(homedir(), ".ccjk", "context", "config.json");
+    this.config = { ...DEFAULT_CONTEXT_CONFIG };
+  }
+  /**
+   * Load configuration from disk
+   * Creates default config if not exists
+   */
+  async load() {
+    try {
+      if (existsSync(this.configPath)) {
+        const content = await readFile(this.configPath, "utf-8");
+        const loadedConfig = JSON.parse(content);
+        this.config = this.mergeWithDefaults(loadedConfig);
+      } else {
+        await this.save();
+      }
+      this.loaded = true;
+      return this.config;
+    } catch (error) {
+      throw new Error(`Failed to load context config: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * Save configuration to disk
+   */
+  async save() {
+    try {
+      const dir = dirname(this.configPath);
+      if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+      }
+      const content = JSON.stringify(this.config, null, 2);
+      await writeFile(this.configPath, content, "utf-8");
+    } catch (error) {
+      throw new Error(`Failed to save context config: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * Get current configuration
+   * Loads from disk if not already loaded
+   */
+  async get() {
+    if (!this.loaded) {
+      await this.load();
+    }
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   * Merges partial updates with existing config
+   */
+  async update(updates) {
+    if (!this.loaded) {
+      await this.load();
+    }
+    this.config = this.deepMerge(this.config, updates);
+    this.validate(this.config);
+    await this.save();
+    return { ...this.config };
+  }
+  /**
+   * Reset configuration to defaults
+   */
+  async reset() {
+    this.config = { ...DEFAULT_CONTEXT_CONFIG };
+    await this.save();
+    return { ...this.config };
+  }
+  /**
+   * Get specific configuration value
+   */
+  async getValue(key) {
+    if (!this.loaded) {
+      await this.load();
+    }
+    return this.config[key];
+  }
+  /**
+   * Set specific configuration value
+   */
+  async setValue(key, value) {
+    if (!this.loaded) {
+      await this.load();
+    }
+    this.config[key] = value;
+    this.validate(this.config);
+    await this.save();
+  }
+  /**
+   * Check if context system is enabled
+   */
+  async isEnabled() {
+    return this.getValue("enabled");
+  }
+  /**
+   * Enable or disable context system
+   */
+  async setEnabled(enabled) {
+    await this.setValue("enabled", enabled);
+  }
+  /**
+   * Get storage paths
+   */
+  async getStoragePaths() {
+    const config = await this.get();
+    const { baseDir, sessionsDir, syncQueueDir } = config.storage;
+    return {
+      baseDir,
+      sessionsDir,
+      syncQueueDir,
+      absoluteSessionsDir: join(baseDir, sessionsDir),
+      absoluteSyncQueueDir: join(baseDir, syncQueueDir)
+    };
+  }
+  /**
+   * Validate configuration
+   * Throws error if invalid
+   */
+  validate(config) {
+    if (config.contextThreshold <= 0) {
+      throw new Error("contextThreshold must be positive");
+    }
+    if (config.maxContextTokens <= 0) {
+      throw new Error("maxContextTokens must be positive");
+    }
+    if (config.contextThreshold >= config.maxContextTokens) {
+      throw new Error("contextThreshold must be less than maxContextTokens");
+    }
+    if (config.cleanup.maxSessionAge <= 0) {
+      throw new Error("cleanup.maxSessionAge must be positive");
+    }
+    if (config.cleanup.maxStorageSize <= 0) {
+      throw new Error("cleanup.maxStorageSize must be positive");
+    }
+    if (config.cloudSync.enabled) {
+      if (!config.cloudSync.apiKey || config.cloudSync.apiKey.trim() === "") {
+        throw new Error("cloudSync.apiKey is required when cloudSync is enabled");
+      }
+      if (!config.cloudSync.endpoint || config.cloudSync.endpoint.trim() === "") {
+        throw new Error("cloudSync.endpoint is required when cloudSync is enabled");
+      }
+    }
+    if (!config.storage.baseDir) {
+      throw new Error("storage.baseDir is required");
+    }
+  }
+  /**
+   * Merge partial config with defaults
+   */
+  mergeWithDefaults(partial) {
+    return this.deepMerge(DEFAULT_CONTEXT_CONFIG, partial);
+  }
+  /**
+   * Deep merge two objects
+   */
+  deepMerge(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+      const sourceValue = source[key];
+      const targetValue = result[key];
+      if (sourceValue === void 0) {
+        continue;
+      }
+      if (typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+        result[key] = this.deepMerge(targetValue, sourceValue);
+      } else {
+        result[key] = sourceValue;
+      }
+    }
+    return result;
+  }
+}
+
+class PlanAcceptanceManager extends EventEmitter {
+  contextManager;
+  threadManager;
+  compressor;
+  options;
+  lastSummarizeTime = 0;
+  constructor(contextManager, options = {}) {
+    super();
+    this.contextManager = contextManager;
+    this.compressor = new MiroThinkerCompressor({
+      toolResultThreshold: 500,
+      preserveErrors: true,
+      preserveKeyInfo: true
+    });
+    this.options = {
+      minSummarizeInterval: options.minSummarizeInterval ?? 6e5,
+      // 10 minutes
+      autoCompress: options.autoCompress ?? true,
+      clearContext: options.clearContext ?? true,
+      injectSummary: options.injectSummary ?? true,
+      debug: options.debug ?? false
+    };
+  }
+  /**
+   * Set thread manager for thread-aware compression
+   */
+  setThreadManager(threadManager) {
+    this.threadManager = threadManager;
+  }
+  /**
+   * Handle plan acceptance event
+   */
+  async onPlanAccepted(plan) {
+    this.log("\u{1F4CB} Plan accepted, preparing context refresh...");
+    this.emit("plan:accepted", plan);
+    const now = Date.now();
+    const timeSinceLastSummarize = now - this.lastSummarizeTime;
+    if (timeSinceLastSummarize < this.options.minSummarizeInterval) {
+      const remainingTime = Math.round((this.options.minSummarizeInterval - timeSinceLastSummarize) / 1e3);
+      this.log(`\u23F3 Rate limited: ${remainingTime}s remaining until next summarization allowed`);
+      this.emit("plan:rate_limited", {
+        timeSinceLastSummarize,
+        remainingTime
+      });
+      if (this.options.clearContext) {
+        await this.clearContextWithoutSummarize(plan);
+      }
+      return;
+    }
+    if (this.options.autoCompress) {
+      this.log("\u{1F5DC}\uFE0F  Compressing context (MiroThinker strategy)...");
+      this.emit("plan:compression_started");
+      const summary = await this.compressCurrentContext();
+      this.log(`\u2705 Compression complete: ${summary.originalTokens} \u2192 ${summary.compressedTokens} tokens (${Math.round(summary.compressionRatio * 100)}% compression)`);
+      this.emit("plan:compression_completed", summary);
+      this.log("\u{1F4BE} Storing summary...");
+      await this.storeSummary(summary);
+      if (this.options.clearContext) {
+        this.log("\u{1F9F9} Clearing context for fresh start...");
+        await this.clearContext();
+        this.emit("plan:context_cleared");
+      }
+      if (this.options.injectSummary) {
+        this.log("\u{1F4DD} Injecting plan and summary into fresh context...");
+        await this.injectPlanContext(plan, summary);
+        this.emit("plan:summary_injected", { plan, summary });
+      }
+      this.lastSummarizeTime = now;
+      this.log("\u2705 Context refreshed successfully!");
+    } else {
+      if (this.options.clearContext) {
+        await this.clearContext();
+      }
+      await this.injectPlanContext(plan);
+    }
+  }
+  /**
+   * Compress current context using MiroThinker
+   */
+  async compressCurrentContext() {
+    const messages = await this.contextManager.getMessages();
+    const conversationMessages = messages.map((msg) => ({
+      role: msg.role === "system" ? "assistant" : msg.role,
+      content: msg.content,
+      originalTokens: msg.metadata?.tokens,
+      compressed: false
+    }));
+    const compressed = this.compressor.compress(conversationMessages);
+    const summaryContent = compressed.messages.filter((m) => m.role === "assistant").map((m) => m.content).join("\n\n---\n\n");
+    return {
+      content: summaryContent,
+      originalTokens: compressed.originalTokens,
+      compressedTokens: compressed.compressedTokens,
+      compressionRatio: compressed.compressionRatio,
+      timestamp: Date.now(),
+      strategy: "miro-thinker"
+    };
+  }
+  /**
+   * Store summary in context manager storage
+   */
+  async storeSummary(summary) {
+    await this.contextManager.storeSummary({
+      content: summary.content,
+      originalTokens: summary.originalTokens,
+      compressedTokens: summary.compressedTokens,
+      compressionRatio: summary.compressionRatio,
+      fcCount: 0,
+      // Not applicable for plan acceptance
+      timestamp: new Date(summary.timestamp)
+    });
+  }
+  /**
+   * Clear context (integrates with Claude Code's native clearing)
+   */
+  async clearContext() {
+    await this.contextManager.reset();
+    if (this.threadManager) {
+      const currentThread = this.threadManager.getCurrentThread();
+      if (currentThread && currentThread.status === "active") {
+        await this.threadManager.closeThread();
+      }
+    }
+  }
+  /**
+   * Clear context without summarization (when rate limited)
+   */
+  async clearContextWithoutSummarize(plan) {
+    this.log("\u{1F9F9} Clearing context without summarization (rate limited)...");
+    await this.clearContext();
+    await this.injectPlanContext(plan);
+    this.log("\u2705 Context cleared and plan injected (no compression)");
+  }
+  /**
+   * Inject plan + summary into fresh context
+   */
+  async injectPlanContext(plan, summary) {
+    let contextPrompt = `# \u{1F4CB} Accepted Plan
+
+${plan.content}
+
+---
+
 `;
-    case "fish":
-      return `
-# CCJK Context Compression Hook - DO NOT EDIT THIS BLOCK
-# This hook enables transparent context compression for claude commands
-# Native slash commands are handled by CCJK plugin system
-function claude
-  # Find the real claude command path
-  set real_claude (command -v claude 2>/dev/null)
-
-  # Handle /plugin command - use CCJK's plugin marketplace
-  if test "$argv[1]" = "/plugin"
-    set -e argv[1]  # Remove /plugin
-    ${ccjkPath} plugin $argv
-    return $status
-  end
-
-  # Other native slash commands (/doctor, /config, etc.) - pass through directly
-  if string match -q '/*' -- $argv[1]
-    $real_claude $argv
-    return $status
-  end
-
-  # Check for recursion - if already in wrapper, call real claude directly
-  if set -q CCJK_WRAPPER_ACTIVE
-    $real_claude $argv
-    return $status
-  end
-
-  set -x CCJK_WRAPPER_ACTIVE 1
-  ${ccjkPath} claude $argv
-  set exit_code $status
-  set -e CCJK_WRAPPER_ACTIVE
-  return $exit_code
-end
-# END CCJK Context Compression Hook
+    if (summary) {
+      contextPrompt += `# \u{1F9E0} Previous Context Summary (Compressed)
+
+${summary.content}
+
+---
+
 `;
-    default:
-      return "";
+      contextPrompt += `**Compression Stats**: ${summary.originalTokens} tokens \u2192 ${summary.compressedTokens} tokens (${Math.round(summary.compressionRatio * 100)}% compression)
+
+`;
+      contextPrompt += `**Strategy**: MiroThinker "\u53BB\u8089\u7559\u9AA8" (Keep AI thoughts, remove raw data)
+
+---
+
+`;
+    }
+    contextPrompt += `**Note**: You now have a fresh context window. The above summary contains key insights from the previous conversation. Let's execute this plan with full attention and focus.
+`;
+    await this.contextManager.addMessage({
+      role: "system",
+      content: contextPrompt,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Check if summarization is allowed (not rate limited)
+   */
+  canSummarize() {
+    const now = Date.now();
+    const timeSinceLastSummarize = now - this.lastSummarizeTime;
+    return timeSinceLastSummarize >= this.options.minSummarizeInterval;
+  }
+  /**
+   * Get time until next summarization allowed
+   */
+  getTimeUntilNextSummarize() {
+    const now = Date.now();
+    const timeSinceLastSummarize = now - this.lastSummarizeTime;
+    const remaining = this.options.minSummarizeInterval - timeSinceLastSummarize;
+    return Math.max(0, remaining);
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    const now = Date.now();
+    const timeSinceLastSummarize = now - this.lastSummarizeTime;
+    return {
+      lastSummarizeTime: this.lastSummarizeTime,
+      timeSinceLastSummarize,
+      canSummarize: this.canSummarize(),
+      timeUntilNextSummarize: this.getTimeUntilNextSummarize(),
+      minInterval: this.options.minSummarizeInterval
+    };
+  }
+  /**
+   * Force reset rate limiting (for testing or manual override)
+   */
+  resetRateLimit() {
+    this.lastSummarizeTime = 0;
+    this.log("Rate limit reset");
+  }
+  /**
+   * Debug logging
+   */
+  log(message) {
+    if (this.options.debug) {
+      console.log(`[PlanAcceptanceManager] ${message}`);
+    }
+  }
+}
+
+const DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  initialDelay: 1e3,
+  maxDelay: 1e4,
+  backoffMultiplier: 2
+};
+class AnthropicApiClient {
+  client;
+  config;
+  constructor(config = {}) {
+    this.client = new Anthropic({
+      apiKey: config.apiKey || process__default.env.ANTHROPIC_API_KEY
+    });
+    this.config = {
+      apiKey: config.apiKey || process__default.env.ANTHROPIC_API_KEY || "",
+      model: config.model || "claude-3-5-haiku-20241022",
+      maxTokens: config.maxTokens || 1024,
+      temperature: config.temperature || 0.3,
+      retry: { ...DEFAULT_RETRY_CONFIG, ...config.retry }
+    };
+  }
+  /**
+   * Send message to Claude with retry logic
+   */
+  async sendMessage(prompt, options = {}) {
+    const model = options.model || this.config.model;
+    const maxTokens = options.maxTokens || this.config.maxTokens;
+    const temperature = options.temperature || this.config.temperature;
+    return this.withRetry(async () => {
+      const response = await this.client.messages.create({
+        model,
+        max_tokens: maxTokens,
+        temperature,
+        messages: [
+          {
+            role: "user",
+            content: prompt
+          }
+        ]
+      });
+      const content = response.content[0];
+      if (content.type === "text") {
+        return content.text;
+      }
+      throw new Error("Unexpected response type from Claude API");
+    });
+  }
+  /**
+   * Execute function with exponential backoff retry
+   */
+  async withRetry(fn, attempt = 1) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (attempt >= this.config.retry.maxRetries) {
+        throw error;
+      }
+      if (!this.isRetryableError(error)) {
+        throw error;
+      }
+      const delay = Math.min(
+        this.config.retry.initialDelay * this.config.retry.backoffMultiplier ** (attempt - 1),
+        this.config.retry.maxDelay
+      );
+      await this.sleep(delay);
+      return this.withRetry(fn, attempt + 1);
+    }
+  }
+  /**
+   * Check if error is retryable
+   */
+  isRetryableError(error) {
+    if (error.code === "ECONNRESET" || error.code === "ETIMEDOUT") {
+      return true;
+    }
+    if (error.status === 429) {
+      return true;
+    }
+    if (error.status >= 500 && error.status < 600) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Sleep for specified milliseconds
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Update client configuration
+   */
+  updateConfig(config) {
+    if (config.apiKey) {
+      this.client = new Anthropic({ apiKey: config.apiKey });
+      this.config.apiKey = config.apiKey;
+    }
+    if (config.model)
+      this.config.model = config.model;
+    if (config.maxTokens)
+      this.config.maxTokens = config.maxTokens;
+    if (config.temperature)
+      this.config.temperature = config.temperature;
+    if (config.retry)
+      this.config.retry = { ...this.config.retry, ...config.retry };
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+}
+function createApiClient(config) {
+  return new AnthropicApiClient(config);
+}
+
+function estimateTokens(text) {
+  const estimation = estimateTokensDetailed(text);
+  return estimation.total;
+}
+function estimateTokensDetailed(text) {
+  const chineseChars = (text.match(/[\u4E00-\u9FA5]/g) || []).length;
+  const otherChars = text.length - chineseChars;
+  const chineseTokens = Math.ceil(chineseChars / 1.5);
+  const otherTokens = Math.ceil(otherChars / 4);
+  const total = chineseTokens + otherTokens;
+  return {
+    total,
+    chineseChars,
+    otherChars
+  };
+}
+function calculateContextUsage(currentTokens, maxTokens) {
+  return currentTokens / maxTokens * 100;
+}
+function isThresholdExceeded(currentTokens, maxTokens, threshold) {
+  const usage = calculateContextUsage(currentTokens, maxTokens);
+  return usage >= threshold * 100;
+}
+function getRemainingTokens(currentTokens, maxTokens) {
+  return Math.max(0, maxTokens - currentTokens);
+}
+
+const SUMMARIZE_PROMPT = `You are a context compression assistant. Summarize the following function call result concisely.
+
+Function: {fc_name}
+Arguments: {fc_args}
+Result: {fc_result}
+
+Provide a one-line summary (max 100 chars) capturing:
+1. What action was performed
+2. Key outcome or finding
+3. Any important details for future reference
+
+Summary:`;
+class Summarizer {
+  apiClient;
+  config;
+  queue = [];
+  processing = false;
+  constructor(config = {}) {
+    this.config = {
+      model: config.model || "haiku",
+      apiKey: config.apiKey || process__default.env.ANTHROPIC_API_KEY || "",
+      batchSize: config.batchSize || 5,
+      maxConcurrent: config.maxConcurrent || 3
+    };
+    const modelName = this.config.model === "haiku" ? "claude-3-5-haiku-20241022" : void 0;
+    this.apiClient = createApiClient({
+      apiKey: this.config.apiKey,
+      model: modelName,
+      maxTokens: 150,
+      // Short summaries
+      temperature: 0.3
+      // Consistent output
+    });
+  }
+  /**
+   * Summarize a single function call
+   */
+  async summarize(request) {
+    try {
+      const prompt = this.buildPrompt(request);
+      const summary = await this.apiClient.sendMessage(prompt);
+      const cleanedSummary = this.cleanSummary(summary);
+      const tokens = estimateTokens(cleanedSummary);
+      return {
+        fcId: request.fcId,
+        fcName: request.fcName,
+        summary: cleanedSummary,
+        tokens,
+        timestamp: /* @__PURE__ */ new Date()
+      };
+    } catch {
+      return this.createFallbackSummary(request);
+    }
+  }
+  /**
+   * Add request to queue for batch processing
+   */
+  async queueSummarization(request) {
+    this.queue.push(request);
+    if (!this.processing) {
+      this.processBatch();
+    }
+  }
+  /**
+   * Process batch of summarization requests
+   */
+  async processBatch() {
+    if (this.processing || this.queue.length === 0) {
+      return;
+    }
+    this.processing = true;
+    try {
+      while (this.queue.length > 0) {
+        const batch = this.queue.splice(0, this.config.batchSize);
+        await this.processConcurrent(batch);
+      }
+    } finally {
+      this.processing = false;
+    }
+  }
+  /**
+   * Process requests concurrently with limit
+   */
+  async processConcurrent(requests) {
+    const results = [];
+    const chunks = this.chunkArray(requests, this.config.maxConcurrent);
+    for (const chunk of chunks) {
+      const promises = chunk.map((req) => this.summarize(req));
+      const chunkResults = await Promise.all(promises);
+      results.push(...chunkResults);
+    }
+    return results;
+  }
+  /**
+   * Summarize multiple function calls
+   */
+  async summarizeBatch(requests) {
+    const summaries = await this.processConcurrent(requests);
+    return summaries.map((summary) => ({
+      fcId: summary.fcId,
+      summary: summary.summary,
+      tokens: summary.tokens
+    }));
+  }
+  /**
+   * Build summarization prompt
+   */
+  buildPrompt(request) {
+    const argsStr = JSON.stringify(request.fcArgs, null, 2);
+    const resultStr = this.truncateResult(request.fcResult);
+    return SUMMARIZE_PROMPT.replace("{fc_name}", request.fcName).replace("{fc_args}", argsStr).replace("{fc_result}", resultStr);
+  }
+  /**
+   * Truncate result to reasonable length
+   */
+  truncateResult(result, maxLength = 2e3) {
+    if (result.length <= maxLength) {
+      return result;
+    }
+    return `${result.substring(0, maxLength)}... [truncated]`;
+  }
+  /**
+   * Clean up summary text
+   */
+  cleanSummary(summary) {
+    let cleaned = summary.trim();
+    cleaned = cleaned.replace(/^Summary:\s*/i, "");
+    if (cleaned.length > 100) {
+      cleaned = `${cleaned.substring(0, 97)}...`;
+    }
+    return cleaned;
+  }
+  /**
+   * Create fallback summary when API fails
+   */
+  createFallbackSummary(request) {
+    const summary = `${request.fcName} executed`;
+    const tokens = estimateTokens(summary);
+    return {
+      fcId: request.fcId,
+      fcName: request.fcName,
+      summary,
+      tokens,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Chunk array into smaller arrays
+   */
+  chunkArray(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    if (config.model)
+      this.config.model = config.model;
+    if (config.apiKey)
+      this.config.apiKey = config.apiKey;
+    if (config.batchSize)
+      this.config.batchSize = config.batchSize;
+    if (config.maxConcurrent)
+      this.config.maxConcurrent = config.maxConcurrent;
+    if (config.apiKey || config.model) {
+      const modelName = this.config.model === "haiku" ? "claude-3-5-haiku-20241022" : void 0;
+      this.apiClient.updateConfig({
+        apiKey: this.config.apiKey,
+        model: modelName
+      });
+    }
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Get queue length
+   */
+  getQueueLength() {
+    return this.queue.length;
+  }
+  /**
+   * Check if processing
+   */
+  isProcessing() {
+    return this.processing;
+  }
+}
+function createSummarizer(config) {
+  return new Summarizer(config);
+}
+
+const DEFAULT_SESSION_CONFIG = {
+  contextThreshold: 0.8,
+  // 80%
+  maxContextTokens: 2e5,
+  summaryModel: "haiku",
+  autoSummarize: true
+};
+class SessionManager extends EventEmitter {
+  currentSession = null;
+  config;
+  summarizer;
+  sessionHistory = [];
+  constructor(config = {}) {
+    super();
+    this.config = { ...DEFAULT_SESSION_CONFIG, ...config };
+    this.summarizer = createSummarizer({
+      model: this.config.summaryModel
+    });
+  }
+  /**
+   * Create new session
+   */
+  createSession(projectPath) {
+    if (this.currentSession) {
+      this.completeSession();
+    }
+    const projectHash = this.generateProjectHash(projectPath);
+    const session = {
+      id: this.generateSessionId(),
+      projectPath,
+      projectHash,
+      startTime: /* @__PURE__ */ new Date(),
+      status: "active",
+      tokenCount: 0,
+      fcCount: 0,
+      summaries: []
+    };
+    this.currentSession = session;
+    this.emitEvent("session_created", session.id, { session });
+    return session;
+  }
+  /**
+   * Get current session
+   */
+  getCurrentSession() {
+    return this.currentSession;
+  }
+  /**
+   * Add function call summary to current session
+   */
+  async addFunctionCall(fcName, fcArgs, fcResult) {
+    if (!this.currentSession) {
+      throw new Error("No active session");
+    }
+    const fcId = this.generateFcId(fcName, fcArgs);
+    let summary = null;
+    if (this.config.autoSummarize) {
+      summary = await this.summarizer.summarize({
+        fcId,
+        fcName,
+        fcArgs,
+        fcResult
+      });
+      this.currentSession.summaries.push(summary);
+      this.currentSession.tokenCount += summary.tokens;
+    } else {
+      const tokens = estimateTokens(fcResult);
+      this.currentSession.tokenCount += tokens;
+    }
+    this.currentSession.fcCount++;
+    this.checkThresholds();
+    if (summary) {
+      this.emitEvent("fc_summarized", this.currentSession.id, { summary });
+    }
+    return summary;
+  }
+  /**
+   * Check context thresholds
+   */
+  checkThresholds() {
+    if (!this.currentSession)
+      return;
+    const level = this.getThresholdLevel();
+    if (level === "warning") {
+      this.emitEvent("threshold_warning", this.currentSession.id, {
+        usage: this.getContextUsage(),
+        remaining: this.getRemainingTokens()
+      });
+    } else if (level === "critical") {
+      this.emitEvent("threshold_critical", this.currentSession.id, {
+        usage: this.getContextUsage(),
+        remaining: this.getRemainingTokens(),
+        sessionSummary: this.generateSessionSummary()
+      });
+    }
+  }
+  /**
+   * Get threshold level
+   */
+  getThresholdLevel() {
+    if (!this.currentSession)
+      return "normal";
+    const usage = this.getContextUsage();
+    if (usage >= this.config.contextThreshold * 100) {
+      return "critical";
+    }
+    if (usage >= (this.config.contextThreshold - 0.1) * 100) {
+      return "warning";
+    }
+    return "normal";
+  }
+  /**
+   * Get context usage percentage
+   */
+  getContextUsage() {
+    if (!this.currentSession)
+      return 0;
+    return calculateContextUsage(
+      this.currentSession.tokenCount,
+      this.config.maxContextTokens
+    );
+  }
+  /**
+   * Get remaining tokens
+   */
+  getRemainingTokens() {
+    if (!this.currentSession)
+      return this.config.maxContextTokens;
+    return getRemainingTokens(
+      this.currentSession.tokenCount,
+      this.config.maxContextTokens
+    );
+  }
+  /**
+   * Check if threshold is exceeded
+   */
+  isThresholdExceeded() {
+    if (!this.currentSession)
+      return false;
+    return isThresholdExceeded(
+      this.currentSession.tokenCount,
+      this.config.maxContextTokens,
+      this.config.contextThreshold
+    );
+  }
+  /**
+   * Generate session summary for continuation
+   */
+  generateSessionSummary() {
+    if (!this.currentSession) {
+      return "No active session";
+    }
+    const session = this.currentSession;
+    const lines = [];
+    lines.push("# Session Summary");
+    lines.push("");
+    lines.push(`Project: ${session.projectPath}`);
+    lines.push(`Session ID: ${session.id}`);
+    lines.push(`Duration: ${this.getSessionDuration()}`);
+    lines.push(`Function Calls: ${session.fcCount}`);
+    lines.push(`Token Usage: ${session.tokenCount} / ${this.config.maxContextTokens} (${this.getContextUsage().toFixed(1)}%)`);
+    lines.push("");
+    if (session.summaries.length > 0) {
+      lines.push("## Function Call Summaries");
+      lines.push("");
+      for (const summary of session.summaries) {
+        lines.push(`- **${summary.fcName}**: ${summary.summary}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Get session duration
+   */
+  getSessionDuration() {
+    if (!this.currentSession)
+      return "0s";
+    const start = this.currentSession.startTime.getTime();
+    const end = this.currentSession.endTime?.getTime() || Date.now();
+    const duration = Math.floor((end - start) / 1e3);
+    if (duration < 60)
+      return `${duration}s`;
+    if (duration < 3600)
+      return `${Math.floor(duration / 60)}m ${duration % 60}s`;
+    const hours = Math.floor(duration / 3600);
+    const minutes = Math.floor(duration % 3600 / 60);
+    return `${hours}h ${minutes}m`;
+  }
+  /**
+   * Complete current session
+   */
+  completeSession() {
+    if (!this.currentSession)
+      return null;
+    this.currentSession.status = "completed";
+    this.currentSession.endTime = /* @__PURE__ */ new Date();
+    this.sessionHistory.push(this.currentSession);
+    this.emitEvent("session_completed", this.currentSession.id, {
+      session: this.currentSession,
+      summary: this.generateSessionSummary()
+    });
+    const completedSession = this.currentSession;
+    this.currentSession = null;
+    return completedSession;
+  }
+  /**
+   * Archive session
+   */
+  archiveSession(sessionId) {
+    const session = this.sessionHistory.find((s) => s.id === sessionId);
+    if (!session)
+      return false;
+    session.status = "archived";
+    this.emitEvent("session_archived", sessionId, { session });
+    return true;
+  }
+  /**
+   * Get session by ID
+   */
+  getSession(sessionId) {
+    if (this.currentSession?.id === sessionId) {
+      return this.currentSession;
+    }
+    return this.sessionHistory.find((s) => s.id === sessionId) || null;
+  }
+  /**
+   * Get all sessions
+   */
+  getAllSessions() {
+    const sessions = [...this.sessionHistory];
+    if (this.currentSession) {
+      sessions.push(this.currentSession);
+    }
+    return sessions;
+  }
+  /**
+   * Get sessions by project
+   */
+  getSessionsByProject(projectPath) {
+    const projectHash = this.generateProjectHash(projectPath);
+    return this.getAllSessions().filter((s) => s.projectHash === projectHash);
+  }
+  /**
+   * Clear session history
+   */
+  clearHistory() {
+    this.sessionHistory = [];
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+    if (config.summaryModel) {
+      this.summarizer.updateConfig({ model: config.summaryModel });
+    }
+  }
+  /**
+   * Get configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Generate session ID
+   */
+  generateSessionId() {
+    return `session_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+  /**
+   * Generate project hash
+   */
+  generateProjectHash(projectPath) {
+    return createHash("md5").update(projectPath).digest("hex").substring(0, 8);
+  }
+  /**
+   * Generate function call ID
+   */
+  generateFcId(fcName, fcArgs) {
+    const data = `${fcName}_${JSON.stringify(fcArgs)}_${Date.now()}`;
+    return createHash("md5").update(data).digest("hex").substring(0, 12);
+  }
+  /**
+   * Emit session event
+   */
+  emitEvent(type, sessionId, data) {
+    const event = {
+      type,
+      sessionId,
+      timestamp: /* @__PURE__ */ new Date(),
+      data
+    };
+    this.emit("session_event", event);
+    this.emit(type, event);
+  }
+  /**
+   * Get summarizer instance
+   */
+  getSummarizer() {
+    return this.summarizer;
+  }
+}
+
+async function generateProjectHash(projectPath) {
+  let normalizedPath = normalize(projectPath);
+  normalizedPath = normalizedPath.replace(/[/\\]+$/, "");
+  const gitInfo = await getGitInfo(normalizedPath);
+  const hashInput = [
+    normalizedPath,
+    gitInfo.remote || "",
+    gitInfo.branch || ""
+  ].join("|");
+  const hash = createHash("sha256").update(hashInput).digest("hex").substring(0, 16);
+  return {
+    path: normalizedPath,
+    gitRemote: gitInfo.remote,
+    gitBranch: gitInfo.branch,
+    hash
+  };
+}
+async function getGitInfo(projectPath) {
+  try {
+    const gitDir = join(projectPath, ".git");
+    if (!existsSync(gitDir)) {
+      return {};
+    }
+    let remote;
+    try {
+      const remoteResult = await exec("git", ["remote", "get-url", "origin"], {
+        nodeOptions: { cwd: projectPath }
+      });
+      remote = remoteResult.stdout?.trim();
+    } catch {
+    }
+    let branch;
+    try {
+      const branchResult = await exec("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+        nodeOptions: { cwd: projectPath }
+      });
+      branch = branchResult.stdout?.trim();
+    } catch {
+    }
+    return { remote, branch };
+  } catch {
+    return {};
+  }
+}
+class ProjectHashCache {
+  cache = /* @__PURE__ */ new Map();
+  cacheTimeout = 5 * 60 * 1e3;
+  // 5 minutes
+  timestamps = /* @__PURE__ */ new Map();
+  /**
+   * Get or generate project identity
+   *
+   * @param projectPath - Project directory path
+   * @param forceRefresh - Force cache refresh
+   * @returns Project identity
+   */
+  async get(projectPath, forceRefresh = false) {
+    let normalizedPath = normalize(projectPath);
+    normalizedPath = normalizedPath.replace(/[/\\]+$/, "");
+    const now = Date.now();
+    const timestamp = this.timestamps.get(normalizedPath);
+    if (!forceRefresh && timestamp && now - timestamp < this.cacheTimeout) {
+      const cached = this.cache.get(normalizedPath);
+      if (cached) {
+        return cached;
+      }
+    }
+    const identity = await generateProjectHash(normalizedPath);
+    this.cache.set(normalizedPath, identity);
+    this.timestamps.set(normalizedPath, now);
+    return identity;
+  }
+  /**
+   * Clear cache for specific project or all projects
+   *
+   * @param projectPath - Optional project path to clear
+   */
+  clear(projectPath) {
+    if (projectPath) {
+      let normalizedPath = normalize(projectPath);
+      normalizedPath = normalizedPath.replace(/[/\\]+$/, "");
+      this.cache.delete(normalizedPath);
+      this.timestamps.delete(normalizedPath);
+    } else {
+      this.cache.clear();
+      this.timestamps.clear();
+    }
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    const timestamps = Array.from(this.timestamps.values());
+    return {
+      size: this.cache.size,
+      oldestEntry: timestamps.length > 0 ? Math.min(...timestamps) : void 0
+    };
+  }
+}
+const projectHashCache = new ProjectHashCache();
+async function getProjectIdentity(projectPath, forceRefresh = false) {
+  return projectHashCache.get(projectPath, forceRefresh);
+}
+
+class StorageManager {
+  baseDir;
+  sessionsDir;
+  initialized = false;
+  constructor(baseDir) {
+    this.baseDir = baseDir || join(homedir(), ".ccjk", "context");
+    this.sessionsDir = join(this.baseDir, "sessions");
+  }
+  /**
+   * Initialize storage directories
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    await mkdir(this.baseDir, { recursive: true });
+    await mkdir(this.sessionsDir, { recursive: true });
+    this.initialized = true;
+  }
+  /**
+   * Create a new session
+   *
+   * @param projectPath - Absolute path to project directory
+   * @param description - Optional session description
+   * @returns Created session
+   */
+  async createSession(projectPath, description) {
+    await this.initialize();
+    const identity = await getProjectIdentity(projectPath);
+    const sessionId = this.generateSessionId();
+    const projectDir = join(this.sessionsDir, identity.hash);
+    const sessionDir = join(projectDir, sessionId);
+    await mkdir(sessionDir, { recursive: true });
+    const meta = {
+      id: sessionId,
+      projectPath: identity.path,
+      projectHash: identity.hash,
+      startTime: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "active",
+      tokenCount: 0,
+      summaryTokens: 0,
+      fcCount: 0,
+      version: this.getCcjkVersion(),
+      description,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const metaPath = join(sessionDir, "meta.json");
+    await this.writeJsonAtomic(metaPath, meta);
+    const fcLogPath = join(sessionDir, "fc-log.jsonl");
+    await writeFile(fcLogPath, "", "utf-8");
+    await this.setCurrentSession(identity.hash, sessionId);
+    const session = {
+      meta,
+      path: sessionDir,
+      fcLogPath,
+      summaryPath: join(sessionDir, "summary.md")
+    };
+    return session;
+  }
+  /**
+   * Get session by ID
+   *
+   * @param sessionId - Session identifier
+   * @param projectHash - Optional project hash for faster lookup
+   * @returns Session or null if not found
+   */
+  async getSession(sessionId, projectHash) {
+    await this.initialize();
+    try {
+      let sessionDir;
+      if (projectHash) {
+        sessionDir = join(this.sessionsDir, projectHash, sessionId);
+      } else {
+        const projectDirs = await readdir(this.sessionsDir);
+        for (const dir of projectDirs) {
+          const candidateDir = join(this.sessionsDir, dir, sessionId);
+          if (existsSync(candidateDir)) {
+            sessionDir = candidateDir;
+            break;
+          }
+        }
+        if (!sessionDir) {
+          return null;
+        }
+      }
+      if (!existsSync(sessionDir)) {
+        return null;
+      }
+      const metaPath = join(sessionDir, "meta.json");
+      const meta = await this.readJson(metaPath);
+      if (!meta) {
+        return null;
+      }
+      return {
+        meta,
+        path: sessionDir,
+        fcLogPath: join(sessionDir, "fc-log.jsonl"),
+        summaryPath: join(sessionDir, "summary.md")
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Update session metadata
+   *
+   * @param session - Session with updated metadata
+   */
+  async updateSession(session) {
+    await this.initialize();
+    session.meta.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    const metaPath = join(session.path, "meta.json");
+    await this.writeJsonAtomic(metaPath, session.meta);
+  }
+  /**
+   * Complete a session
+   *
+   * @param sessionId - Session identifier
+   * @param projectHash - Optional project hash
+   */
+  async completeSession(sessionId, projectHash) {
+    const session = await this.getSession(sessionId, projectHash);
+    if (!session) {
+      return false;
+    }
+    session.meta.status = "completed";
+    session.meta.endTime = (/* @__PURE__ */ new Date()).toISOString();
+    await this.updateSession(session);
+    return true;
+  }
+  /**
+   * Archive a session
+   *
+   * @param sessionId - Session identifier
+   * @param projectHash - Optional project hash
+   */
+  async archiveSession(sessionId, projectHash) {
+    const session = await this.getSession(sessionId, projectHash);
+    if (!session) {
+      return false;
+    }
+    session.meta.status = "archived";
+    await this.updateSession(session);
+    return true;
+  }
+  /**
+   * List sessions with optional filtering
+   *
+   * @param options - Query options
+   * @returns Array of session metadata
+   */
+  async listSessions(options) {
+    await this.initialize();
+    const sessions = [];
+    try {
+      const projectDirs = options?.projectHash ? [options.projectHash] : await readdir(this.sessionsDir);
+      for (const projectDir of projectDirs) {
+        const projectPath = join(this.sessionsDir, projectDir);
+        if (!existsSync(projectPath)) {
+          continue;
+        }
+        const sessionDirs = await readdir(projectPath);
+        for (const sessionDir of sessionDirs) {
+          if (sessionDir === "current.json") {
+            continue;
+          }
+          const metaPath = join(projectPath, sessionDir, "meta.json");
+          if (!existsSync(metaPath)) {
+            continue;
+          }
+          const meta = await this.readJson(metaPath);
+          if (!meta) {
+            continue;
+          }
+          if (options?.status && meta.status !== options.status) {
+            continue;
+          }
+          sessions.push(meta);
+        }
+      }
+      if (options?.sortBy) {
+        const sortKey = options.sortBy;
+        const order = options.sortOrder || "desc";
+        sessions.sort((a, b) => {
+          const aVal = a[sortKey];
+          const bVal = b[sortKey];
+          if (typeof aVal === "string" && typeof bVal === "string") {
+            return order === "asc" ? aVal.localeCompare(bVal) : bVal.localeCompare(aVal);
+          }
+          if (typeof aVal === "number" && typeof bVal === "number") {
+            return order === "asc" ? aVal - bVal : bVal - aVal;
+          }
+          return 0;
+        });
+      }
+      if (options?.limit && options.limit > 0) {
+        return sessions.slice(0, options.limit);
+      }
+      return sessions;
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Append function call log entry
+   *
+   * @param sessionId - Session identifier
+   * @param entry - FC log entry
+   * @param projectHash - Optional project hash
+   */
+  async appendFCLog(sessionId, entry, projectHash) {
+    await this.initialize();
+    const session = await this.getSession(sessionId, projectHash);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const line = `${JSON.stringify(entry)}
+`;
+    await writeFile(session.fcLogPath, line, { flag: "a", encoding: "utf-8" });
+    session.meta.fcCount++;
+    session.meta.tokenCount += entry.tokens;
+    await this.updateSession(session);
+  }
+  /**
+   * Get function call logs as async generator
+   * Efficiently streams large log files
+   *
+   * @param sessionId - Session identifier
+   * @param options - Query options
+   * @param projectHash - Optional project hash
+   */
+  async *getFCLogs(sessionId, options, projectHash) {
+    await this.initialize();
+    const session = await this.getSession(sessionId, projectHash);
+    if (!session || !existsSync(session.fcLogPath)) {
+      return;
+    }
+    const fileStream = createReadStream(session.fcLogPath, { encoding: "utf-8" });
+    const rl = createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+    let count = 0;
+    for await (const line of rl) {
+      if (!line.trim()) {
+        continue;
+      }
+      try {
+        const entry = JSON.parse(line);
+        if (options?.startTime && entry.ts < options.startTime) {
+          continue;
+        }
+        if (options?.endTime && entry.ts > options.endTime) {
+          continue;
+        }
+        if (options?.functionName && entry.fc !== options.functionName) {
+          continue;
+        }
+        if (options?.status && entry.status !== options.status) {
+          continue;
+        }
+        yield entry;
+        count++;
+        if (options?.limit && count >= options.limit) {
+          break;
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  /**
+   * Get all FC logs as array
+   * Use getFCLogs() generator for large files
+   *
+   * @param sessionId - Session identifier
+   * @param options - Query options
+   * @param projectHash - Optional project hash
+   */
+  async getFCLogsArray(sessionId, options, projectHash) {
+    const logs = [];
+    for await (const entry of this.getFCLogs(sessionId, options, projectHash)) {
+      logs.push(entry);
+    }
+    return logs;
+  }
+  /**
+   * Save session summary
+   *
+   * @param sessionId - Session identifier
+   * @param summary - Markdown summary content
+   * @param projectHash - Optional project hash
+   */
+  async saveSummary(sessionId, summary, projectHash) {
+    await this.initialize();
+    const session = await this.getSession(sessionId, projectHash);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    await this.writeFileAtomic(session.summaryPath, summary);
+  }
+  /**
+   * Get session summary
+   *
+   * @param sessionId - Session identifier
+   * @param projectHash - Optional project hash
+   * @returns Summary content or null if not found
+   */
+  async getSummary(sessionId, projectHash) {
+    await this.initialize();
+    const session = await this.getSession(sessionId, projectHash);
+    if (!session || !existsSync(session.summaryPath)) {
+      return null;
+    }
+    try {
+      return await readFile(session.summaryPath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get current session for a project
+   *
+   * @param projectHash - Project hash identifier
+   * @returns Current session or null
+   */
+  async getCurrentSession(projectHash) {
+    await this.initialize();
+    const pointerPath = join(this.sessionsDir, projectHash, "current.json");
+    if (!existsSync(pointerPath)) {
+      return null;
+    }
+    try {
+      const pointer = await this.readJson(pointerPath);
+      if (!pointer) {
+        return null;
+      }
+      return this.getSession(pointer.sessionId, projectHash);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Set current session for a project
+   *
+   * @param projectHash - Project hash identifier
+   * @param sessionId - Session identifier
+   */
+  async setCurrentSession(projectHash, sessionId) {
+    await this.initialize();
+    const projectDir = join(this.sessionsDir, projectHash);
+    await mkdir(projectDir, { recursive: true });
+    const pointer = {
+      sessionId,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const pointerPath = join(projectDir, "current.json");
+    await this.writeJsonAtomic(pointerPath, pointer);
+  }
+  /**
+   * Delete a session
+   *
+   * @param sessionId - Session identifier
+   * @param projectHash - Optional project hash
+   * @returns True if deleted successfully
+   */
+  async deleteSession(sessionId, projectHash) {
+    await this.initialize();
+    const session = await this.getSession(sessionId, projectHash);
+    if (!session) {
+      return false;
+    }
+    try {
+      await this.deleteDirectory(session.path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Clean up old sessions
+   *
+   * @param maxAge - Maximum age in milliseconds
+   * @returns Cleanup result
+   */
+  async cleanOldSessions(maxAge) {
+    await this.initialize();
+    const startTime = Date.now();
+    const cutoffTime = new Date(Date.now() - maxAge).toISOString();
+    const allSessions = await this.listSessions();
+    const removedSessionIds = [];
+    let bytesFreed = 0;
+    for (const meta of allSessions) {
+      if (meta.status === "active") {
+        continue;
+      }
+      const sessionTime = meta.endTime || meta.lastUpdated;
+      if (sessionTime >= cutoffTime) {
+        continue;
+      }
+      const session = await this.getSession(meta.id, meta.projectHash);
+      if (session) {
+        const size = await this.getDirectorySize(session.path);
+        bytesFreed += size;
+        const deleted = await this.deleteSession(meta.id, meta.projectHash);
+        if (deleted) {
+          removedSessionIds.push(meta.id);
+        }
+      }
+    }
+    return {
+      sessionsRemoved: removedSessionIds.length,
+      bytesFreed,
+      removedSessionIds,
+      duration: Date.now() - startTime
+    };
+  }
+  /**
+   * Get storage statistics
+   */
+  async getStorageStats() {
+    await this.initialize();
+    const allSessions = await this.listSessions();
+    const stats = {
+      totalSessions: allSessions.length,
+      activeSessions: 0,
+      completedSessions: 0,
+      archivedSessions: 0,
+      totalSize: 0,
+      totalTokens: 0,
+      totalFCs: 0,
+      pendingSyncItems: 0
+    };
+    let oldestTime;
+    let newestTime;
+    for (const meta of allSessions) {
+      if (meta.status === "active")
+        stats.activeSessions++;
+      else if (meta.status === "completed")
+        stats.completedSessions++;
+      else if (meta.status === "archived")
+        stats.archivedSessions++;
+      stats.totalTokens += meta.tokenCount;
+      stats.totalFCs += meta.fcCount;
+      if (!oldestTime || meta.startTime < oldestTime) {
+        oldestTime = meta.startTime;
+      }
+      if (!newestTime || meta.startTime > newestTime) {
+        newestTime = meta.startTime;
+      }
+    }
+    stats.oldestSession = oldestTime;
+    stats.newestSession = newestTime;
+    try {
+      stats.totalSize = await this.getDirectorySize(this.baseDir);
+    } catch {
+      stats.totalSize = 0;
+    }
+    return stats;
+  }
+  /**
+   * Write JSON file atomically
+   * Writes to temp file first, then renames
+   */
+  async writeJsonAtomic(filePath, data) {
+    const content = JSON.stringify(data, null, 2);
+    await this.writeFileAtomic(filePath, content);
+  }
+  /**
+   * Write file atomically
+   * Writes to temp file first, then renames
+   */
+  async writeFileAtomic(filePath, content) {
+    const dir = dirname(filePath);
+    const tempPath = join(tmpdir(), `ccjk-${Date.now()}-${Math.random().toString(36).substring(2)}.tmp`);
+    try {
+      await writeFile(tempPath, content, "utf-8");
+      await mkdir(dir, { recursive: true });
+      await rename(tempPath, filePath);
+    } catch (error) {
+      try {
+        await unlink(tempPath);
+      } catch {
+      }
+      throw error;
+    }
+  }
+  /**
+   * Read JSON file safely
+   */
+  async readJson(filePath) {
+    try {
+      const content = await readFile(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Generate unique session ID
+   */
+  generateSessionId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 8);
+    return `session-${timestamp}-${random}`;
+  }
+  /**
+   * Get CCJK version
+   */
+  getCcjkVersion() {
+    try {
+      const pkgPath = join(__dirname, "../../../package.json");
+      if (existsSync(pkgPath)) {
+        const pkgContent = readFileSync(pkgPath, "utf-8");
+        const pkg = JSON.parse(pkgContent);
+        return pkg.version || "unknown";
+      }
+    } catch {
+    }
+    return "unknown";
+  }
+  /**
+   * Get directory size recursively
+   */
+  async getDirectorySize(dirPath) {
+    let totalSize = 0;
+    try {
+      const entries = await readdir(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+          totalSize += await this.getDirectorySize(fullPath);
+        } else if (entry.isFile()) {
+          const stats = await stat(fullPath);
+          totalSize += stats.size;
+        }
+      }
+    } catch {
+    }
+    return totalSize;
+  }
+  /**
+   * Delete directory recursively
+   */
+  async deleteDirectory(dirPath) {
+    if (!existsSync(dirPath)) {
+      return;
+    }
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        await this.deleteDirectory(fullPath);
+      } else {
+        await unlink(fullPath);
+      }
+    }
+    const fsp = await import('node:fs/promises');
+    await fsp.rm(dirPath, { recursive: true });
   }
 }
-function isHookInstalled(rcFile) {
-  if (!fs.existsSync(rcFile)) {
-    return false;
+
+class ThreadManager extends EventEmitter {
+  threads = /* @__PURE__ */ new Map();
+  currentThread = null;
+  compressor;
+  options;
+  constructor(options = {}) {
+    super();
+    this.options = {
+      defaultMaxTokens: options.defaultMaxTokens ?? 5e3,
+      autoClose: options.autoClose ?? true,
+      compressionStrategy: options.compressionStrategy ?? "miro-thinker",
+      debug: options.debug ?? false
+    };
+    this.compressor = new MiroThinkerCompressor({
+      toolResultThreshold: 500,
+      preserveErrors: true,
+      preserveKeyInfo: true
+    });
   }
-  const content = fs.readFileSync(rcFile, "utf-8");
-  return content.includes("# CCJK Context Compression Hook");
-}
-async function installShellHook(shellType) {
-  const detectedShell = shellType || detectShellType();
-  if (detectedShell === "unknown") {
-    return {
-      success: false,
-      shellType: detectedShell,
-      rcFile: "",
-      message: "Unknown shell type",
-      error: "Could not detect shell type. Please specify manually."
+  /**
+   * Create a new thread
+   */
+  createThread(config) {
+    if (this.currentThread && this.options.autoClose) {
+      if (this.shouldCloseThread()) {
+        this.log("Auto-closing previous thread before creating new one");
+      }
+    }
+    const thread = {
+      id: this.generateThreadId(),
+      parentId: config.parentId || this.currentThread?.id,
+      topic: config.topic,
+      messages: [],
+      status: "active",
+      createdAt: Date.now(),
+      tokenCount: 0,
+      maxTokens: config.maxTokens ?? this.options.defaultMaxTokens,
+      metadata: config.metadata
     };
+    this.threads.set(thread.id, thread);
+    this.currentThread = thread;
+    this.log(`Thread created: ${thread.id} (${thread.topic})`);
+    this.emit("thread:created", thread);
+    return thread;
   }
-  const rcFile = getShellRcFile(detectedShell);
-  if (!rcFile) {
-    return {
-      success: false,
-      shellType: detectedShell,
-      rcFile: "",
-      message: "RC file not found",
-      error: `Could not find RC file for ${detectedShell}`
+  /**
+   * Get current active thread
+   */
+  getCurrentThread() {
+    return this.currentThread;
+  }
+  /**
+   * Get thread by ID
+   */
+  getThread(id) {
+    return this.threads.get(id);
+  }
+  /**
+   * Get all threads
+   */
+  getAllThreads() {
+    return Array.from(this.threads.values());
+  }
+  /**
+   * Add message to current thread
+   */
+  addMessage(message) {
+    if (!this.currentThread) {
+      throw new Error("No active thread. Create a thread first.");
+    }
+    if (this.currentThread.status !== "active") {
+      throw new Error(`Cannot add message to ${this.currentThread.status} thread`);
+    }
+    const tokens = estimateTokens(message.content);
+    const fullMessage = {
+      ...message,
+      timestamp: Date.now(),
+      tokens
     };
+    this.currentThread.messages.push(fullMessage);
+    this.currentThread.tokenCount += tokens;
+    this.log(`Message added: ${tokens} tokens (total: ${this.currentThread.tokenCount}/${this.currentThread.maxTokens})`);
+    this.emit("thread:message_added", { thread: this.currentThread, message: fullMessage });
+    if (this.shouldCloseThread()) {
+      this.log("Thread threshold reached");
+      this.emit("thread:threshold_reached", this.currentThread);
+      if (this.options.autoClose) {
+        this.log("Auto-closing thread due to threshold");
+        this.closeThread().catch((err) => {
+          this.log(`Error auto-closing thread: ${err}`);
+        });
+      }
+    }
+  }
+  /**
+   * Check if current thread should be closed
+   */
+  shouldCloseThread() {
+    if (!this.currentThread)
+      return false;
+    if (this.currentThread.status !== "active")
+      return false;
+    return this.currentThread.tokenCount >= this.currentThread.maxTokens;
+  }
+  /**
+   * Close current thread and compress
+   */
+  async closeThread() {
+    if (!this.currentThread) {
+      throw new Error("No active thread to close");
+    }
+    if (this.currentThread.status !== "active") {
+      throw new Error(`Thread is already ${this.currentThread.status}`);
+    }
+    this.log(`Closing thread: ${this.currentThread.id}`);
+    const summary = await this.compressThread(this.currentThread);
+    this.currentThread.status = "completed";
+    this.currentThread.completedAt = Date.now();
+    this.currentThread.summary = summary;
+    this.log(`Thread closed and compressed: ${summary.compressionRatio.toFixed(2)}x compression`);
+    this.emit("thread:closed", this.currentThread);
+    this.emit("thread:compressed", { thread: this.currentThread, summary });
+    return summary;
   }
-  if (isHookInstalled(rcFile)) {
+  /**
+   * Compress thread using MiroThinker strategy
+   */
+  async compressThread(thread) {
+    const messages = thread.messages.map((msg) => ({
+      role: msg.role === "system" ? "assistant" : msg.role,
+      content: msg.content,
+      originalTokens: msg.tokens,
+      compressed: false
+    }));
+    const compressed = this.compressor.compress(messages);
+    const summaryContent = compressed.messages.filter((m) => m.role === "assistant").map((m) => m.content).join("\n\n---\n\n");
     return {
-      success: true,
-      shellType: detectedShell,
-      rcFile,
-      message: "Shell hook is already installed"
+      content: summaryContent,
+      originalTokens: compressed.originalTokens,
+      compressedTokens: compressed.compressedTokens,
+      compressionRatio: compressed.compressionRatio,
+      timestamp: Date.now()
     };
   }
-  const hookScript = generateHookScript(detectedShell);
-  try {
-    if (!fs.existsSync(rcFile)) {
-      const dir = path.dirname(rcFile);
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
+  /**
+   * Get thread chain (current thread + all ancestors)
+   */
+  getThreadChain(threadId) {
+    const chain = [];
+    let thread = threadId ? this.threads.get(threadId) : this.currentThread;
+    while (thread) {
+      chain.unshift(thread);
+      thread = thread.parentId ? this.threads.get(thread.parentId) : void 0;
+    }
+    return chain;
+  }
+  /**
+   * Get combined context from thread chain
+   * Returns compressed summaries from ancestor threads + current thread messages
+   */
+  getCombinedContext(includeCurrentMessages = true) {
+    const chain = this.getThreadChain();
+    const parts = [];
+    for (let i = 0; i < chain.length - 1; i++) {
+      const thread = chain[i];
+      if (thread.summary) {
+        parts.push(`## Thread ${i + 1}: ${thread.topic}
+
+${thread.summary.content}`);
       }
-      fs.writeFileSync(rcFile, "", "utf-8");
     }
-    fs.appendFileSync(rcFile, `
-${hookScript}
-`, "utf-8");
-    return {
-      success: true,
-      shellType: detectedShell,
-      rcFile,
-      message: "Shell hook installed successfully"
-    };
-  } catch (error) {
+    if (includeCurrentMessages && this.currentThread) {
+      const currentMessages = this.currentThread.messages.map((m) => `**${m.role}**: ${m.content}`).join("\n\n");
+      parts.push(`## Current Thread: ${this.currentThread.topic}
+
+${currentMessages}`);
+    }
+    return parts.join("\n\n---\n\n");
+  }
+  /**
+   * Archive old threads
+   */
+  archiveThread(threadId) {
+    const thread = this.threads.get(threadId);
+    if (!thread) {
+      throw new Error(`Thread not found: ${threadId}`);
+    }
+    if (thread.status === "active") {
+      throw new Error("Cannot archive active thread. Close it first.");
+    }
+    thread.status = "archived";
+    this.log(`Thread archived: ${threadId}`);
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    const threads = Array.from(this.threads.values());
+    const completedWithSummary = threads.filter((t) => t.summary);
     return {
-      success: false,
-      shellType: detectedShell,
-      rcFile,
-      message: "Failed to install shell hook",
-      error: error instanceof Error ? error.message : String(error)
+      totalThreads: threads.length,
+      activeThreads: threads.filter((t) => t.status === "active").length,
+      completedThreads: threads.filter((t) => t.status === "completed").length,
+      archivedThreads: threads.filter((t) => t.status === "archived").length,
+      totalTokens: threads.reduce((sum, t) => sum + t.tokenCount, 0),
+      averageCompressionRatio: completedWithSummary.length > 0 ? completedWithSummary.reduce((sum, t) => sum + (t.summary?.compressionRatio || 0), 0) / completedWithSummary.length : 0
     };
   }
+  /**
+   * Generate unique thread ID
+   */
+  generateThreadId() {
+    return `thread_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+  /**
+   * Debug logging
+   */
+  log(message) {
+    if (this.options.debug) {
+      console.log(`[ThreadManager] ${message}`);
+    }
+  }
 }
-async function uninstallShellHook(shellType) {
-  const detectedShell = shellType || detectShellType();
-  if (detectedShell === "unknown") {
-    return {
-      success: false,
-      shellType: detectedShell,
-      rcFile: "",
-      message: "Unknown shell type",
-      error: "Could not detect shell type. Please specify manually."
+
+class ContextManager extends EventEmitter {
+  sessionManager;
+  summarizer;
+  configManager;
+  storageManager;
+  // New managers for Phase 1
+  threadManager;
+  planAcceptanceManager;
+  autoSummarizeManager;
+  options;
+  initialized = false;
+  currentStorageSession = null;
+  messageHistory = [];
+  totalMessages = 0;
+  lastCompressionTime = null;
+  compressedTokens = 0;
+  /**
+   * Create a new Context Manager instance
+   *
+   * @param options - Configuration options
+   */
+  constructor(options = {}) {
+    super();
+    this.options = {
+      configPath: options.configPath,
+      autoCompress: options.autoCompress ?? true,
+      compressionThreshold: options.compressionThreshold ?? 0.8,
+      maxHistoryLength: options.maxHistoryLength ?? 100,
+      storageBaseDir: options.storageBaseDir,
+      debug: options.debug ?? false
     };
+    this.configManager = new ConfigManager(this.options.configPath);
+    this.storageManager = new StorageManager(this.options.storageBaseDir);
+    this.sessionManager = new SessionManager();
+    this.summarizer = new Summarizer();
+    this.setupEventForwarding();
   }
-  const rcFile = getShellRcFile(detectedShell);
-  if (!rcFile) {
-    return {
-      success: false,
-      shellType: detectedShell,
-      rcFile: "",
-      message: "RC file not found",
-      error: `Could not find RC file for ${detectedShell}`
-    };
+  /**
+   * Initialize all subsystems
+   * Must be called before using the manager
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    try {
+      this.debug("Initializing Context Manager...");
+      const config = await this.configManager.load();
+      this.debug("Configuration loaded:", config);
+      await this.storageManager.initialize();
+      this.debug("Storage initialized");
+      this.sessionManager.updateConfig({
+        contextThreshold: config.contextThreshold / config.maxContextTokens,
+        maxContextTokens: config.maxContextTokens,
+        summaryModel: config.summaryModel,
+        autoSummarize: config.autoSummarize
+      });
+      this.summarizer.updateConfig({
+        model: config.summaryModel
+      });
+      this.initialized = true;
+      this.debug("Context Manager initialized successfully");
+    } catch (error) {
+      const errorMsg = `Failed to initialize Context Manager: ${error instanceof Error ? error.message : String(error)}`;
+      this.emit("error", new Error(errorMsg));
+      throw new Error(errorMsg);
+    }
   }
-  if (!fs.existsSync(rcFile)) {
-    return {
-      success: true,
-      shellType: detectedShell,
-      rcFile,
-      message: "Shell hook is not installed"
-    };
+  /**
+   * Start a new session or resume existing session
+   *
+   * @param projectPath - Absolute path to project directory
+   * @returns Session information
+   */
+  async startSession(projectPath) {
+    this.ensureInitialized();
+    try {
+      const nodeProcess = await import('node:process');
+      const path = projectPath || nodeProcess.cwd();
+      this.debug(`Starting session for project: ${path}`);
+      const sessionManagerSession = this.sessionManager.createSession(path);
+      this.currentStorageSession = await this.storageManager.createSession(
+        path,
+        "Context compression session"
+      );
+      this.messageHistory = [];
+      this.emit("session:start", {
+        sessionId: sessionManagerSession.id,
+        projectPath: path
+      });
+      this.debug(`Session started: ${sessionManagerSession.id}`);
+      return sessionManagerSession;
+    } catch (error) {
+      const errorMsg = `Failed to start session: ${error instanceof Error ? error.message : String(error)}`;
+      this.emit("error", new Error(errorMsg));
+      throw new Error(errorMsg);
+    }
+  }
+  /**
+   * Add a message to the current session
+   *
+   * @param message - Message to add
+   */
+  async addMessage(message) {
+    this.ensureInitialized();
+    const currentSession = this.sessionManager.getCurrentSession();
+    if (!currentSession) {
+      throw new Error("No active session. Call startSession() first.");
+    }
+    try {
+      const timestampedMessage = {
+        ...message,
+        timestamp: message.timestamp || Date.now()
+      };
+      this.messageHistory.push(timestampedMessage);
+      this.totalMessages++;
+      const tokens = estimateTokens(message.content);
+      if (message.metadata?.isFunctionCall) {
+        await this.sessionManager.addFunctionCall(
+          message.metadata.functionName,
+          message.metadata.arguments,
+          message.content
+        );
+      }
+      this.emit("message:added", {
+        sessionId: currentSession.id,
+        message: timestampedMessage,
+        tokens
+      });
+      if (this.options.autoCompress && this.shouldCompress()) {
+        this.debug("Auto-compression threshold reached");
+        await this.compress();
+      }
+      if (this.messageHistory.length > this.options.maxHistoryLength) {
+        const removed = this.messageHistory.splice(
+          0,
+          this.messageHistory.length - this.options.maxHistoryLength
+        );
+        this.debug(`Trimmed ${removed.length} messages from history`);
+      }
+    } catch (error) {
+      const errorMsg = `Failed to add message: ${error instanceof Error ? error.message : String(error)}`;
+      this.emit("error", new Error(errorMsg));
+      throw new Error(errorMsg);
+    }
+  }
+  /**
+   * Check if compression should be triggered
+   *
+   * @returns True if compression is recommended
+   */
+  shouldCompress() {
+    this.ensureInitialized();
+    const currentSession = this.sessionManager.getCurrentSession();
+    if (!currentSession) {
+      return false;
+    }
+    const isExceeded = this.sessionManager.isThresholdExceeded();
+    if (isExceeded) {
+      this.emit("threshold:reached", {
+        sessionId: currentSession.id,
+        usage: this.sessionManager.getContextUsage(),
+        remaining: this.sessionManager.getRemainingTokens()
+      });
+    }
+    return isExceeded;
+  }
+  /**
+   * Execute compression on current session
+   *
+   * @returns Summary of compression
+   */
+  async compress() {
+    this.ensureInitialized();
+    const currentSession = this.sessionManager.getCurrentSession();
+    if (!currentSession) {
+      throw new Error("No active session to compress");
+    }
+    try {
+      this.debug("Starting compression...");
+      this.emit("compression:start", {
+        sessionId: currentSession.id,
+        tokenCount: currentSession.tokenCount
+      });
+      const summaryContent = this.sessionManager.generateSessionSummary();
+      const originalTokens = currentSession.tokenCount;
+      const compressedTokens = estimateTokens(summaryContent);
+      const compressionRatio = compressedTokens / originalTokens;
+      if (this.currentStorageSession) {
+        await this.storageManager.saveSummary(
+          this.currentStorageSession.meta.id,
+          summaryContent,
+          this.currentStorageSession.meta.projectHash
+        );
+      }
+      this.compressedTokens += originalTokens - compressedTokens;
+      this.lastCompressionTime = Date.now();
+      const summary = {
+        content: summaryContent,
+        originalTokens,
+        compressedTokens,
+        compressionRatio,
+        fcCount: currentSession.fcCount,
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      this.emit("compression:complete", {
+        sessionId: currentSession.id,
+        summary
+      });
+      this.debug(`Compression complete. Ratio: ${(compressionRatio * 100).toFixed(1)}%`);
+      return summary;
+    } catch (error) {
+      const errorMsg = `Failed to compress context: ${error instanceof Error ? error.message : String(error)}`;
+      this.emit("error", new Error(errorMsg));
+      throw new Error(errorMsg);
+    }
+  }
+  /**
+   * Get optimized context for new conversation
+   * Returns compressed summary if available, otherwise full context
+   *
+   * @returns Optimized context string
+   */
+  async getOptimizedContext() {
+    this.ensureInitialized();
+    const currentSession = this.sessionManager.getCurrentSession();
+    if (!currentSession) {
+      return "";
+    }
+    try {
+      if (this.currentStorageSession) {
+        const summary = await this.storageManager.getSummary(
+          this.currentStorageSession.meta.id,
+          this.currentStorageSession.meta.projectHash
+        );
+        if (summary) {
+          this.debug("Using saved summary for context");
+          return summary;
+        }
+      }
+      this.debug("Generating fresh summary for context");
+      return this.sessionManager.generateSessionSummary();
+    } catch (error) {
+      this.debug(`Failed to get optimized context: ${error}`);
+      return this.sessionManager.generateSessionSummary();
+    }
   }
-  if (!isHookInstalled(rcFile)) {
+  /**
+   * Get current statistics
+   *
+   * @returns Context statistics
+   */
+  getStats() {
+    this.ensureInitialized();
+    const currentSession = this.sessionManager.getCurrentSession();
+    const allSessions = this.sessionManager.getAllSessions();
     return {
-      success: true,
-      shellType: detectedShell,
-      rcFile,
-      message: "Shell hook is not installed"
+      currentTokens: currentSession?.tokenCount || 0,
+      compressedTokens: this.compressedTokens,
+      compressionRatio: currentSession ? this.compressedTokens / (currentSession.tokenCount + this.compressedTokens) : 0,
+      sessionCount: allSessions.length,
+      totalMessages: this.totalMessages,
+      lastCompression: this.lastCompressionTime,
+      thresholdLevel: this.sessionManager.getThresholdLevel(),
+      contextUsage: this.sessionManager.getContextUsage()
     };
   }
-  try {
-    const content = fs.readFileSync(rcFile, "utf-8");
-    const hookPattern = /\n*# CCJK Context Compression Hook[\s\S]*?# END CCJK Context Compression Hook\n*/g;
-    const newContent = content.replace(hookPattern, "\n");
-    fs.writeFileSync(rcFile, newContent, "utf-8");
-    return {
-      success: true,
-      shellType: detectedShell,
-      rcFile,
-      message: "Shell hook uninstalled successfully"
+  /**
+   * End current session
+   *
+   * @returns Completed session or null
+   */
+  async endSession() {
+    this.ensureInitialized();
+    const currentSession = this.sessionManager.getCurrentSession();
+    if (!currentSession) {
+      return null;
+    }
+    try {
+      this.debug(`Ending session: ${currentSession.id}`);
+      const completedSession = this.sessionManager.completeSession();
+      if (this.currentStorageSession) {
+        await this.storageManager.completeSession(
+          this.currentStorageSession.meta.id,
+          this.currentStorageSession.meta.projectHash
+        );
+      }
+      this.emit("session:end", {
+        sessionId: currentSession.id,
+        summary: this.sessionManager.generateSessionSummary()
+      });
+      this.currentStorageSession = null;
+      this.debug("Session ended successfully");
+      return completedSession;
+    } catch (error) {
+      const errorMsg = `Failed to end session: ${error instanceof Error ? error.message : String(error)}`;
+      this.emit("error", new Error(errorMsg));
+      throw new Error(errorMsg);
+    }
+  }
+  /**
+   * Get all sessions for a project
+   *
+   * @param projectPath - Project path
+   * @returns Array of session metadata
+   */
+  async getProjectSessions(projectPath) {
+    this.ensureInitialized();
+    try {
+      const sessions = await this.storageManager.listSessions({ projectHash: void 0 });
+      return sessions.filter((s) => s.projectPath === projectPath);
+    } catch (error) {
+      this.debug(`Failed to get project sessions: ${error}`);
+      return [];
+    }
+  }
+  /**
+   * Clean up old sessions
+   *
+   * @param maxAgeDays - Maximum age in days
+   * @returns Cleanup result
+   */
+  async cleanupOldSessions(maxAgeDays = 30) {
+    this.ensureInitialized();
+    try {
+      const maxAge = maxAgeDays * 24 * 60 * 60 * 1e3;
+      const result = await this.storageManager.cleanOldSessions(maxAge);
+      this.debug(`Cleaned up ${result.sessionsRemoved} sessions, freed ${result.bytesFreed} bytes`);
+      return {
+        sessionsRemoved: result.sessionsRemoved,
+        bytesFreed: result.bytesFreed
+      };
+    } catch (error) {
+      this.debug(`Failed to cleanup sessions: ${error}`);
+      return { sessionsRemoved: 0, bytesFreed: 0 };
+    }
+  }
+  /**
+   * Update configuration
+   *
+   * @param updates - Partial configuration updates
+   */
+  async updateConfig(updates) {
+    this.ensureInitialized();
+    try {
+      Object.assign(this.options, updates);
+      if (updates.compressionThreshold !== void 0) {
+        const config = await this.configManager.get();
+        await this.configManager.update({
+          contextThreshold: updates.compressionThreshold * config.maxContextTokens
+        });
+      }
+      this.debug("Configuration updated");
+    } catch (error) {
+      const errorMsg = `Failed to update config: ${error instanceof Error ? error.message : String(error)}`;
+      this.emit("error", new Error(errorMsg));
+      throw new Error(errorMsg);
+    }
+  }
+  /**
+   * Clean up resources
+   * Should be called when shutting down
+   */
+  async cleanup() {
+    try {
+      this.debug("Cleaning up Context Manager...");
+      const currentSession = this.sessionManager.getCurrentSession();
+      if (currentSession) {
+        await this.endSession();
+      }
+      this.messageHistory = [];
+      this.removeAllListeners();
+      this.initialized = false;
+      this.debug("Context Manager cleaned up");
+    } catch (error) {
+      this.debug(`Cleanup error: ${error}`);
+    }
+  }
+  /**
+   * Setup event forwarding from session manager
+   */
+  setupEventForwarding() {
+    this.sessionManager.on("session_event", (event) => {
+      this.debug(`Session event: ${event.type}`);
+      const eventMap = {
+        session_created: "session:start",
+        session_completed: "session:end",
+        threshold_warning: "threshold:reached",
+        threshold_critical: "threshold:reached",
+        fc_summarized: null,
+        // Internal event, don't forward
+        session_archived: null
+        // Internal event, don't forward
+      };
+      const contextEvent = eventMap[event.type];
+      if (contextEvent) {
+        this.emit(contextEvent, event.data);
+      }
+    });
+  }
+  /**
+   * Ensure manager is initialized
+   * @throws Error if not initialized
+   */
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new Error("Context Manager not initialized. Call initialize() first.");
+    }
+  }
+  /**
+   * Debug logging helper
+   */
+  debug(...args) {
+    if (this.options.debug) {
+      console.log("[ContextManager]", ...args);
+    }
+  }
+  /**
+   * Get current session (for testing/debugging)
+   */
+  getCurrentSession() {
+    return this.sessionManager.getCurrentSession();
+  }
+  /**
+   * Get storage manager (for advanced usage)
+   */
+  getStorageManager() {
+    return this.storageManager;
+  }
+  /**
+   * Get session manager (for advanced usage)
+   */
+  getSessionManager() {
+    return this.sessionManager;
+  }
+  /**
+   * Get summarizer (for advanced usage)
+   */
+  getSummarizer() {
+    return this.summarizer;
+  }
+  /**
+   * Get config manager (for advanced usage)
+   */
+  getConfigManager() {
+    return this.configManager;
+  }
+  // ============================================================
+  // Phase 1: New Manager Integration Methods
+  // ============================================================
+  /**
+   * Enable thread-based interaction mode
+   *
+   * @param options - Thread manager options
+   * @returns Thread manager instance
+   */
+  enableThreadMode(options) {
+    if (this.threadManager) {
+      this.debug("Thread mode already enabled");
+      return this.threadManager;
+    }
+    this.threadManager = new ThreadManager({
+      ...options,
+      debug: options?.debug ?? this.options.debug
+    });
+    this.threadManager.on("thread:created", (thread) => {
+      this.emit("thread:created", thread);
+    });
+    this.threadManager.on("thread:closed", (thread) => {
+      this.emit("thread:closed", thread);
+    });
+    this.threadManager.on("thread:compressed", (data) => {
+      this.emit("thread:compressed", data);
+    });
+    this.debug("Thread mode enabled");
+    return this.threadManager;
+  }
+  /**
+   * Enable plan acceptance integration
+   *
+   * @param options - Plan acceptance options
+   * @returns Plan acceptance manager instance
+   */
+  enablePlanAcceptance(options) {
+    if (this.planAcceptanceManager) {
+      this.debug("Plan acceptance already enabled");
+      return this.planAcceptanceManager;
+    }
+    this.planAcceptanceManager = new PlanAcceptanceManager(this, {
+      ...options,
+      debug: options?.debug ?? this.options.debug
+    });
+    if (this.threadManager) {
+      this.planAcceptanceManager.setThreadManager(this.threadManager);
+    }
+    this.planAcceptanceManager.on("plan:accepted", (plan) => {
+      this.emit("plan:accepted", plan);
+    });
+    this.planAcceptanceManager.on("plan:compression_completed", (summary) => {
+      this.emit("plan:compression_completed", summary);
+    });
+    this.planAcceptanceManager.on("plan:rate_limited", (data) => {
+      this.emit("plan:rate_limited", data);
+    });
+    this.debug("Plan acceptance enabled");
+    return this.planAcceptanceManager;
+  }
+  /**
+   * Enable auto-summarization
+   *
+   * @param options - Auto-summarize options
+   * @returns Auto-summarize manager instance
+   */
+  enableAutoSummarize(options) {
+    if (this.autoSummarizeManager) {
+      this.debug("Auto-summarize already enabled");
+      return this.autoSummarizeManager;
+    }
+    this.autoSummarizeManager = new AutoSummarizeManager(this, {
+      ...options,
+      debug: options?.debug ?? this.options.debug
+    });
+    this.autoSummarizeManager.on("summarize:completed", (summary) => {
+      this.emit("summarize:completed", summary);
+    });
+    this.autoSummarizeManager.on("summarize:rate_limited", (data) => {
+      this.emit("summarize:rate_limited", data);
+    });
+    this.debug("Auto-summarize enabled");
+    return this.autoSummarizeManager;
+  }
+  /**
+   * Get thread manager instance
+   */
+  getThreadManager() {
+    return this.threadManager;
+  }
+  /**
+   * Get plan acceptance manager instance
+   */
+  getPlanAcceptanceManager() {
+    return this.planAcceptanceManager;
+  }
+  /**
+   * Get auto-summarize manager instance
+   */
+  getAutoSummarizeManager() {
+    return this.autoSummarizeManager;
+  }
+  /**
+   * Handle plan acceptance (convenience method)
+   *
+   * @param plan - Plan to accept
+   */
+  async acceptPlan(plan) {
+    if (!this.planAcceptanceManager) {
+      throw new Error("Plan acceptance not enabled. Call enablePlanAcceptance() first.");
+    }
+    await this.planAcceptanceManager.onPlanAccepted(plan);
+  }
+  /**
+   * Get all messages in current session
+   *
+   * @returns Array of messages
+   */
+  async getMessages() {
+    return [...this.messageHistory];
+  }
+  /**
+   * Store a summary
+   *
+   * @param summary - Summary to store
+   */
+  async storeSummary(summary) {
+    if (!this.currentStorageSession) {
+      throw new Error("No active session. Call startSession() first.");
+    }
+    await this.storageManager.saveSummary(
+      this.currentStorageSession.meta.id,
+      summary.content
+    );
+    this.debug("Summary stored");
+  }
+  /**
+   * Reset context manager state
+   * Clears message history and resets counters
+   */
+  async reset() {
+    this.messageHistory = [];
+    this.totalMessages = 0;
+    this.lastCompressionTime = null;
+    this.compressedTokens = 0;
+    if (this.threadManager) {
+      const currentThread = this.threadManager.getCurrentThread();
+      if (currentThread && currentThread.status === "active") {
+        await this.threadManager.closeThread();
+      }
+    }
+    this.debug("Context manager reset");
+  }
+}
+function createContextManager(options) {
+  return new ContextManager(options);
+}
+
+class ClaudeHistoryMonitor {
+  historyFile;
+  watcher = null;
+  contextManager;
+  lastPosition = 0;
+  options;
+  isRunning = false;
+  pollingTimer = null;
+  constructor(contextManager, options = {}) {
+    this.historyFile = join(homedir(), ".claude", "history.jsonl");
+    this.contextManager = contextManager;
+    this.options = {
+      debug: options.debug ?? false,
+      pollingInterval: options.pollingInterval ?? 1e3
     };
-  } catch (error) {
+  }
+  /**
+   * Start monitoring
+   */
+  start() {
+    if (this.isRunning) {
+      this.log("Already running");
+      return;
+    }
+    if (!existsSync(this.historyFile)) {
+      this.log(`History file not found: ${this.historyFile}`);
+      this.log("Will start monitoring when file is created");
+    } else {
+      this.lastPosition = statSync(this.historyFile).size;
+      this.log(`Starting from position: ${this.lastPosition}`);
+    }
+    try {
+      this.watcher = watch(this.historyFile, async (event) => {
+        if (event === "change") {
+          await this.processNewEntries();
+        }
+      });
+      this.log("Using fs.watch for monitoring");
+    } catch (error) {
+      this.log("fs.watch failed, falling back to polling");
+      this.startPolling();
+    }
+    this.isRunning = true;
+    this.log("\u{1F4CA} Claude History Monitor started");
+  }
+  /**
+   * Start polling (fallback method)
+   */
+  startPolling() {
+    this.pollingTimer = setInterval(async () => {
+      await this.processNewEntries();
+    }, this.options.pollingInterval);
+  }
+  /**
+   * Process new entries in history file
+   */
+  async processNewEntries() {
+    try {
+      if (!existsSync(this.historyFile)) {
+        return;
+      }
+      const currentSize = statSync(this.historyFile).size;
+      if (currentSize <= this.lastPosition) {
+        return;
+      }
+      if (currentSize < this.lastPosition) {
+        this.log("File was truncated, resetting position");
+        this.lastPosition = 0;
+      }
+      const newContent = await this.readNewContent(this.lastPosition, currentSize);
+      this.lastPosition = currentSize;
+      const lines = newContent.split("\n").filter((line) => line.trim());
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          await this.processHistoryEntry(entry);
+        } catch (error) {
+          this.log(`Failed to parse entry: ${error}`);
+        }
+      }
+    } catch (error) {
+      this.log(`Error processing entries: ${error}`);
+    }
+  }
+  /**
+   * Read new content from file
+   */
+  async readNewContent(start, end) {
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      const stream = createReadStream(this.historyFile, {
+        start,
+        end: end - 1,
+        encoding: "utf-8"
+      });
+      stream.on("data", (chunk) => {
+        chunks.push(Buffer.from(chunk));
+      });
+      stream.on("end", () => {
+        resolve(Buffer.concat(chunks).toString("utf-8"));
+      });
+      stream.on("error", reject);
+    });
+  }
+  /**
+   * Process a single history entry
+   */
+  async processHistoryEntry(entry) {
+    this.log(`Processing entry: ${entry.display.substring(0, 50)}...`);
+    await this.contextManager.addMessage({
+      role: "user",
+      content: entry.display || "",
+      timestamp: entry.timestamp,
+      metadata: {
+        sessionId: entry.sessionId,
+        project: entry.project,
+        pastedContents: entry.pastedContents
+      }
+    });
+    const autoSummarize = this.contextManager.getAutoSummarizeManager();
+    if (autoSummarize) {
+      const stats = await this.contextManager.getStats();
+      if (autoSummarize.shouldSummarize(stats.currentTokens)) {
+        this.log(`\u{1F916} Triggering auto-summarization (${stats.currentTokens} tokens)`);
+        const result = await autoSummarize.summarize();
+        if (result.performed) {
+          this.log(`\u2705 Compressed: ${result.summary.originalTokens} \u2192 ${result.summary.compressedTokens} tokens`);
+        } else {
+          this.log(`\u23F3 Summarization skipped: ${result.reason}`);
+        }
+      }
+    }
+  }
+  /**
+   * Stop monitoring
+   */
+  stop() {
+    if (!this.isRunning) {
+      return;
+    }
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    if (this.pollingTimer) {
+      clearInterval(this.pollingTimer);
+      this.pollingTimer = null;
+    }
+    this.isRunning = false;
+    this.log("\u{1F4CA} Claude History Monitor stopped");
+  }
+  /**
+   * Get current status
+   */
+  getStatus() {
     return {
-      success: false,
-      shellType: detectedShell,
-      rcFile,
-      message: "Failed to uninstall shell hook",
-      error: error instanceof Error ? error.message : String(error)
+      isRunning: this.isRunning,
+      lastPosition: this.lastPosition,
+      historyFile: this.historyFile
     };
   }
-}
-function getShellHookConfig(shellType) {
-  const detectedShell = shellType || detectShellType();
-  if (detectedShell === "unknown") {
-    return null;
-  }
-  const rcFile = getShellRcFile(detectedShell);
-  if (!rcFile) {
-    return null;
+  /**
+   * Debug logging
+   */
+  log(message) {
+    if (this.options.debug) {
+      console.log(`[ClaudeHistoryMonitor] ${message}`);
+    }
   }
-  const hookScript = generateHookScript(detectedShell);
-  return {
-    shellType: detectedShell,
-    hookScript,
-    rcFile
-  };
 }
 
-const PASSTHROUGH_ARGS = /* @__PURE__ */ new Set([
-  "--help",
-  "-h",
-  "--version",
-  "-v",
-  "--mcp-list",
-  "--mcp-debug",
-  "update",
-  "config"
-]);
-function shouldPassthrough(args) {
-  if (args.length === 0)
-    return false;
-  if (args[0]?.startsWith("/")) {
-    return true;
+class ClaudePlansMonitor {
+  plansDir;
+  watcher = null;
+  planAcceptanceManager;
+  options;
+  isRunning = false;
+  processedPlans = /* @__PURE__ */ new Set();
+  constructor(planAcceptanceManager, options = {}) {
+    this.plansDir = join(homedir(), ".claude", "plans");
+    this.planAcceptanceManager = planAcceptanceManager;
+    this.options = {
+      debug: options.debug ?? false,
+      readDelay: options.readDelay ?? 100
+    };
   }
-  return args.some((arg) => PASSTHROUGH_ARGS.has(arg));
-}
-async function claudeWrapper(args, options = {}) {
-  const { debug = false, noWrap = false } = options;
-  if (!i18n.isInitialized) {
-    await initI18n();
-  }
-  const claudePath = await findRealCommandPath("claude");
-  if (!claudePath) {
-    console.error(i18n.t("context:claudeNotFound"));
-    console.error(i18n.t("context:claudeNotFoundHint"));
-    process__default.exit(1);
+  /**
+   * Start monitoring
+   */
+  start() {
+    if (this.isRunning) {
+      this.log("Already running");
+      return;
+    }
+    if (!existsSync(this.plansDir)) {
+      mkdirSync(this.plansDir, { recursive: true });
+      this.log(`Created plans directory: ${this.plansDir}`);
+    }
+    try {
+      this.watcher = watch(this.plansDir, async (event, filename) => {
+        if (filename && filename.endsWith(".md")) {
+          await this.handlePlanFile(event, filename);
+        }
+      });
+      this.isRunning = true;
+      this.log("\u{1F4CB} Claude Plans Monitor started");
+    } catch (error) {
+      this.log(`Failed to start monitoring: ${error}`);
+      throw error;
+    }
   }
-  if (debug) {
-    console.log(`[DEBUG] Claude path: ${claudePath}`);
-    console.log(`[DEBUG] Args: ${JSON.stringify(args)}`);
-    console.log(`[DEBUG] No wrap: ${noWrap}`);
-    console.log(`[DEBUG] Passthrough: ${shouldPassthrough(args)}`);
+  /**
+   * Handle plan file event
+   */
+  async handlePlanFile(event, filename) {
+    if (event !== "rename") {
+      return;
+    }
+    const planPath = join(this.plansDir, filename);
+    if (!existsSync(planPath)) {
+      return;
+    }
+    if (this.processedPlans.has(filename)) {
+      return;
+    }
+    this.log(`New plan detected: ${filename}`);
+    this.processedPlans.add(filename);
+    await new Promise((resolve) => setTimeout(resolve, this.options.readDelay));
+    try {
+      await this.onPlanAccepted(filename, planPath);
+    } catch (error) {
+      this.log(`Error processing plan: ${error}`);
+      this.processedPlans.delete(filename);
+    }
   }
-  if (noWrap || shouldPassthrough(args)) {
-    if (debug) {
-      console.log("[DEBUG] Using direct passthrough mode");
+  /**
+   * Handle plan acceptance
+   */
+  async onPlanAccepted(filename, planPath) {
+    this.log(`Reading plan: ${planPath}`);
+    const content = await readFile(planPath, "utf-8");
+    const plan = {
+      id: filename.replace(".md", ""),
+      content,
+      metadata: {
+        title: this.extractTitle(content),
+        createdAt: Date.now(),
+        filename,
+        path: planPath
+      }
+    };
+    this.log(`\u{1F4CB} Plan accepted: ${plan.metadata?.title || "Untitled"}`);
+    try {
+      await this.planAcceptanceManager.onPlanAccepted(plan);
+      this.log(`\u2705 Plan acceptance workflow completed`);
+    } catch (error) {
+      this.log(`\u274C Plan acceptance workflow failed: ${error}`);
+      throw error;
     }
-    await execClaudeDirect(claudePath, args);
-    return;
   }
-  await execClaudeDirect(claudePath, args);
-}
-async function execClaudeDirect(claudePath, args) {
-  try {
-    const result = await exec(claudePath, args, {
-      nodeOptions: {
-        stdio: "inherit"
+  /**
+   * Extract title from markdown content
+   */
+  extractTitle(content) {
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const h1Match = line.match(/^#\s/);
+      if (h1Match) {
+        return line.replace(/^#\s+/, "").trim();
       }
-    });
-    process__default.exit(result.exitCode ?? 0);
-  } catch (error) {
-    if (error && typeof error === "object" && "signal" in error) {
-      const signal = error.signal;
-      const signalCodes = {
-        SIGINT: 130,
-        // 128 + 2
-        SIGTERM: 143,
-        // 128 + 15
-        SIGQUIT: 131
-        // 128 + 3
-      };
-      process__default.exit(signalCodes[signal] || 1);
     }
-    console.error(i18n.t("context:wrapperError"), error);
-    process__default.exit(1);
+    for (const line of lines) {
+      const h2Match = line.match(/^##\s/);
+      if (h2Match) {
+        return line.replace(/^##\s+/, "").trim();
+      }
+    }
+    const nonEmptyLines = lines.filter((line) => line.trim());
+    if (nonEmptyLines.length > 0) {
+      return nonEmptyLines[0].substring(0, 50).trim();
+    }
+    return "Untitled Plan";
+  }
+  /**
+   * Stop monitoring
+   */
+  stop() {
+    if (!this.isRunning) {
+      return;
+    }
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    this.isRunning = false;
+    this.log("\u{1F4CB} Claude Plans Monitor stopped");
+  }
+  /**
+   * Get current status
+   */
+  getStatus() {
+    return {
+      isRunning: this.isRunning,
+      plansDir: this.plansDir,
+      processedPlansCount: this.processedPlans.size
+    };
+  }
+  /**
+   * Clear processed plans cache
+   */
+  clearCache() {
+    this.processedPlans.clear();
+    this.log("Cleared processed plans cache");
+  }
+  /**
+   * Debug logging
+   */
+  log(message) {
+    if (this.options.debug) {
+      console.log(`[ClaudePlansMonitor] ${message}`);
+    }
   }
 }
-async function contextCommand(action, args, options = {}) {
-  const { verbose = false } = options;
-  if (!i18n.isInitialized) {
-    await initI18n();
+
+class EnhancedClaudeWrapper {
+  contextManager;
+  historyMonitor = null;
+  plansMonitor = null;
+  options;
+  initialized = false;
+  constructor(options = {}) {
+    this.options = {
+      debug: options.debug ?? false,
+      enableThreadMode: options.enableThreadMode ?? true,
+      enablePlanAcceptance: options.enablePlanAcceptance ?? true,
+      enableAutoSummarize: options.enableAutoSummarize ?? true
+    };
+    this.contextManager = createContextManager({
+      debug: this.options.debug
+    });
   }
-  try {
-    if (action === "hook") {
-      const hookAction = args[0];
-      switch (hookAction) {
-        case "install":
-          await installHook(verbose);
+  /**
+   * Initialize wrapper
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    this.log("\u{1F680} Initializing CCJK Enhanced Wrapper...");
+    await this.contextManager.initialize();
+    if (this.options.enableThreadMode) {
+      this.contextManager.enableThreadMode({
+        defaultMaxTokens: 5e3,
+        autoClose: true,
+        debug: this.options.debug
+      });
+      this.log("\u2705 Thread mode enabled");
+    }
+    if (this.options.enablePlanAcceptance) {
+      const planManager = this.contextManager.enablePlanAcceptance({
+        minSummarizeInterval: 6e5,
+        // 10 minutes
+        autoCompress: true,
+        clearContext: true,
+        injectSummary: true,
+        debug: this.options.debug
+      });
+      this.plansMonitor = new ClaudePlansMonitor(planManager, {
+        debug: this.options.debug
+      });
+      this.plansMonitor.start();
+      this.log("\u2705 Plan acceptance enabled");
+    }
+    if (this.options.enableAutoSummarize) {
+      this.contextManager.enableAutoSummarize({
+        enabled: true,
+        minInterval: 6e5,
+        // 10 minutes
+        tokenThreshold: 1e5,
+        // 100K tokens
+        strategy: "miro-thinker",
+        debug: this.options.debug
+      });
+      this.log("\u2705 Auto-summarize enabled");
+    }
+    this.historyMonitor = new ClaudeHistoryMonitor(this.contextManager, {
+      debug: this.options.debug
+    });
+    this.historyMonitor.start();
+    this.log("\u2705 History monitor started");
+    this.initialized = true;
+    this.log("\u2705 CCJK Enhanced Wrapper initialized");
+  }
+  /**
+   * Execute Claude command
+   */
+  async execute(args) {
+    if (!this.initialized) {
+      throw new Error("Wrapper not initialized. Call initialize() first.");
+    }
+    if (args[0] === "context") {
+      return this.handleContextCommand(args.slice(1));
+    }
+    try {
+      const claudePath = await this.findClaudeCLI();
+      this.log(`Executing: ${claudePath} ${args.join(" ")}`);
+      const result = await exec(claudePath, args, {
+        nodeOptions: {
+          stdio: "inherit"
+          // Pass through stdin/stdout/stderr
+        }
+      });
+      return result.exitCode || 0;
+    } catch (error) {
+      console.error("\u274C Error executing Claude CLI:", error);
+      return 1;
+    }
+  }
+  /**
+   * Handle context management commands
+   */
+  async handleContextCommand(args) {
+    const command = args[0];
+    try {
+      switch (command) {
+        case "stats":
+          await this.showStats();
           break;
-        case "uninstall":
-          await uninstallHook(verbose);
+        case "compress":
+          await this.manualCompress();
+          break;
+        case "reset":
+          await this.contextManager.reset();
+          console.log("\u2705 Context reset");
           break;
         case "status":
-          await showStatus(verbose);
+          await this.showStatus();
           break;
-        default:
-          showHelp();
+        case "help":
+          this.showHelp();
           break;
+        default:
+          console.log(`\u274C Unknown context command: ${command}`);
+          console.log('Run "claude context help" for available commands');
+          return 1;
       }
-      return;
+      return 0;
+    } catch (error) {
+      console.error(`\u274C Error executing context command: ${error}`);
+      return 1;
     }
-    switch (action) {
-      case "status":
-        await showStatus(verbose);
-        break;
-      case "install":
-        await installHook(verbose);
-        break;
-      case "uninstall":
-        await uninstallHook(verbose);
-        break;
-      case "help":
-      default:
-        showHelp();
-        break;
+  }
+  /**
+   * Show context statistics
+   */
+  async showStats() {
+    const stats = await this.contextManager.getStats();
+    const threadManager = this.contextManager.getThreadManager();
+    const autoSummarize = this.contextManager.getAutoSummarizeManager();
+    const planManager = this.contextManager.getPlanAcceptanceManager();
+    console.log("\n\u{1F4CA} CCJK Context Statistics\n");
+    console.log("=".repeat(50));
+    console.log("\n\u{1F4C8} Context Usage:");
+    console.log(`  Current Tokens: ${stats.currentTokens.toLocaleString()}`);
+    console.log(`  Compressed Tokens: ${stats.compressedTokens.toLocaleString()}`);
+    console.log(`  Compression Ratio: ${(stats.compressionRatio * 100).toFixed(1)}%`);
+    console.log(`  Total Messages: ${stats.totalMessages}`);
+    console.log(`  Context Usage: ${(stats.contextUsage * 100).toFixed(1)}%`);
+    if (threadManager) {
+      const threadStats = threadManager.getStats();
+      console.log("\n\u{1F9F5} Thread Management:");
+      console.log(`  Total Threads: ${threadStats.totalThreads}`);
+      console.log(`  Active Threads: ${threadStats.activeThreads}`);
+      console.log(`  Completed Threads: ${threadStats.completedThreads}`);
+      console.log(`  Avg Compression: ${(threadStats.averageCompressionRatio * 100).toFixed(1)}%`);
     }
-  } catch (error) {
-    console.error(i18n.t("context:commandError"), error);
-    process__default.exit(1);
+    if (autoSummarize) {
+      const autoStats = autoSummarize.getStats();
+      console.log("\n\u{1F916} Auto-Summarize:");
+      console.log(`  Status: ${autoStats.enabled ? "\u2705 Enabled" : "\u274C Disabled"}`);
+      console.log(`  Can Summarize: ${autoStats.canSummarize ? "Yes" : "No"}`);
+      console.log(`  Summarize Count: ${autoStats.summarizeCount}`);
+      if (!autoStats.canSummarize && autoStats.timeUntilNextSummarize > 0) {
+        const minutes = Math.floor(autoStats.timeUntilNextSummarize / 6e4);
+        const seconds = Math.floor(autoStats.timeUntilNextSummarize % 6e4 / 1e3);
+        console.log(`  Time Until Next: ${minutes}m ${seconds}s`);
+      }
+    }
+    if (planManager) {
+      const planStats = planManager.getStats();
+      console.log("\n\u{1F4CB} Plan Acceptance:");
+      console.log(`  Can Summarize: ${planStats.canSummarize ? "Yes" : "No"}`);
+      if (!planStats.canSummarize && planStats.timeUntilNextSummarize > 0) {
+        const minutes = Math.floor(planStats.timeUntilNextSummarize / 6e4);
+        const seconds = Math.floor(planStats.timeUntilNextSummarize % 6e4 / 1e3);
+        console.log(`  Time Until Next: ${minutes}m ${seconds}s`);
+      }
+    }
+    console.log(`
+${"=".repeat(50)}
+`);
   }
-}
-async function showStatus(verbose) {
-  const shellType = detectShellType();
-  const rcFile = getShellRcFile(shellType);
-  const installed = rcFile ? isHookInstalled(rcFile) : false;
-  const claudePath = await findCommandPath("claude");
-  console.log(`
-${i18n.t("context:statusTitle")}`);
-  console.log("\u2500".repeat(50));
-  console.log(`${i18n.t("context:shellType")}: ${shellType}`);
-  console.log(`${i18n.t("context:rcFile")}: ${rcFile || "N/A"}`);
-  console.log(`${i18n.t("context:hookStatus")}: ${installed ? i18n.t("context:installed") : i18n.t("context:notInstalled")}`);
-  if (verbose) {
-    console.log(`Claude Path: ${claudePath || "Not found"}`);
-    if (shellType !== "unknown") {
-      const config = getShellHookConfig(shellType);
-      if (config) {
-        console.log("\nHook Script:");
-        console.log(config.hookScript);
-      }
-    }
-  }
-  console.log();
-  if (!installed) {
-    console.log(i18n.t("context:installHint"));
-    console.log(`  ccjk context install
+  /**
+   * Show system status
+   */
+  async showStatus() {
+    console.log("\n\u{1F50D} CCJK System Status\n");
+    console.log("=".repeat(50));
+    if (this.historyMonitor) {
+      const historyStatus = this.historyMonitor.getStatus();
+      console.log("\n\u{1F4CA} History Monitor:");
+      console.log(`  Status: ${historyStatus.isRunning ? "\u2705 Running" : "\u274C Stopped"}`);
+      console.log(`  File: ${historyStatus.historyFile}`);
+      console.log(`  Position: ${historyStatus.lastPosition} bytes`);
+    }
+    if (this.plansMonitor) {
+      const plansStatus = this.plansMonitor.getStatus();
+      console.log("\n\u{1F4CB} Plans Monitor:");
+      console.log(`  Status: ${plansStatus.isRunning ? "\u2705 Running" : "\u274C Stopped"}`);
+      console.log(`  Directory: ${plansStatus.plansDir}`);
+      console.log(`  Processed Plans: ${plansStatus.processedPlansCount}`);
+    }
+    console.log(`
+${"=".repeat(50)}
 `);
-  } else {
-    console.log(i18n.t("context:hookActive"));
   }
-}
-async function installHook(_verbose) {
-  console.log(i18n.t("context:installingHook"));
-  const result = await installShellHook();
-  if (result.success) {
-    console.log(`\u2705 ${i18n.t("context:shellHookInstalled", { rcFile: result.rcFile })}`);
-    console.log();
-    console.log(i18n.t("context:restartShell"));
-    console.log(`  source ${result.rcFile}`);
-    console.log();
-  } else {
-    console.error(`\u274C ${i18n.t("context:shellHookInstallFailed")}`);
-    if (result.error) {
-      console.error(`   ${result.error}`);
+  /**
+   * Manual compression
+   */
+  async manualCompress() {
+    const autoSummarize = this.contextManager.getAutoSummarizeManager();
+    if (!autoSummarize) {
+      console.log("\u274C Auto-summarize not enabled");
+      return;
+    }
+    console.log("\u{1F5DC}\uFE0F  Compressing context...");
+    const result = await autoSummarize.summarize();
+    if (result.performed) {
+      console.log(`\u2705 Compressed: ${result.summary.originalTokens.toLocaleString()} \u2192 ${result.summary.compressedTokens.toLocaleString()} tokens`);
+      console.log(`   Ratio: ${(result.summary.compressionRatio * 100).toFixed(1)}%`);
+    } else {
+      console.log(`\u23F3 Skipped: ${result.reason}`);
+      if (result.timeUntilNext) {
+        const minutes = Math.floor(result.timeUntilNext / 6e4);
+        const seconds = Math.floor(result.timeUntilNext % 6e4 / 1e3);
+        console.log(`   Time until next: ${minutes}m ${seconds}s`);
+      }
     }
-    process__default.exit(1);
   }
-}
-async function uninstallHook(_verbose) {
-  console.log(i18n.t("context:uninstallingHook"));
-  const result = await uninstallShellHook();
-  if (result.success) {
-    console.log(`\u2705 ${i18n.t("context:shellHookUninstalled", { rcFile: result.rcFile })}`);
-    console.log();
-    console.log(i18n.t("context:restartShell"));
-    console.log(`  source ${result.rcFile}`);
+  /**
+   * Show help
+   */
+  showHelp() {
+    console.log("\n\u{1F4D6} CCJK Context Management Commands\n");
+    console.log("Usage: claude context <command>\n");
+    console.log("Commands:");
+    console.log("  stats      Show context statistics");
+    console.log("  status     Show system status");
+    console.log("  compress   Manually trigger compression");
+    console.log("  reset      Reset context manager");
+    console.log("  help       Show this help message");
     console.log();
-  } else {
-    console.error(`\u274C ${i18n.t("context:shellHookUninstallFailed")}`);
-    if (result.error) {
-      console.error(`   ${result.error}`);
+  }
+  /**
+   * Find Claude CLI path
+   */
+  async findClaudeCLI() {
+    const paths = [
+      "/usr/local/bin/claude",
+      "/opt/homebrew/bin/claude",
+      join(homedir(), ".local/bin/claude")
+    ];
+    for (const path of paths) {
+      if (existsSync(path)) {
+        return path;
+      }
     }
+    try {
+      const result = await exec("which claude");
+      const path = result.stdout.trim();
+      if (path) {
+        return path;
+      }
+    } catch {
+    }
+    throw new Error("Claude CLI not found. Please install Claude Code CLI first.");
+  }
+  /**
+   * Cleanup
+   */
+  async cleanup() {
+    this.log("\u{1F9F9} Cleaning up...");
+    if (this.historyMonitor) {
+      this.historyMonitor.stop();
+    }
+    if (this.plansMonitor) {
+      this.plansMonitor.stop();
+    }
+    await this.contextManager.cleanup();
+    this.initialized = false;
+    this.log("\u2705 Cleanup complete");
+  }
+  /**
+   * Debug logging
+   */
+  log(message) {
+    if (this.options.debug) {
+      console.log(`[EnhancedClaudeWrapper] ${message}`);
+    }
+  }
+}
+
+async function claudeWrapperCommand(args) {
+  const wrapper = new EnhancedClaudeWrapper({
+    debug: process__default.env.CCJK_DEBUG === "true"
+  });
+  try {
+    await wrapper.initialize();
+    const exitCode = await wrapper.execute(args);
+    await wrapper.cleanup();
+    process__default.exit(exitCode);
+  } catch (error) {
+    console.error("\u274C Error:", error instanceof Error ? error.message : error);
+    await wrapper.cleanup();
     process__default.exit(1);
   }
 }
-function showHelp() {
-  console.log(`
-${i18n.t("context:helpTitle")}`);
-  console.log("\u2500".repeat(50));
-  console.log(`
-${i18n.t("context:helpUsage")}`);
-  console.log(`
-${i18n.t("context:helpActions")}`);
-  console.log(`  status      - ${i18n.t("context:helpStatusDesc")}`);
-  console.log(`  install     - ${i18n.t("context:helpInstallDesc")}`);
-  console.log(`  uninstall   - ${i18n.t("context:helpUninstallDesc")}`);
-  console.log(`
-${i18n.t("context:helpExamples")}`);
-  console.log("  ccjk context status");
-  console.log("  ccjk context install");
-  console.log("  ccjk context uninstall");
-  console.log();
+async function claudeWrapper(args) {
+  const wrapper = new EnhancedClaudeWrapper({
+    debug: process__default.env.CCJK_DEBUG === "true"
+  });
+  try {
+    await wrapper.initialize();
+    const exitCode = await wrapper.execute(args);
+    await wrapper.cleanup();
+    process__default.exit(exitCode);
+  } catch (error) {
+    console.error("\u274C Error:", error instanceof Error ? error.message : error);
+    await wrapper.cleanup();
+    process__default.exit(1);
+  }
 }
 
-export { claudeWrapper, contextCommand };
+export { claudeWrapper, claudeWrapperCommand };