// Fast Path: 零模块加载路径
if (process.argv.includes('--version')) {
  // ✓ 不加载任何 REPL 模块
  // ✓ 不初始化 AI 客户端
  // ✓ 不加载工具系统
    console.log(getVersion());
    process.exit(0);
}

// 其他 Fast Path 命令:
// --help, --auth, config, setup, doctor,
// update, compress-context, etc.

// Slow Path: 完整 REPL 启动
await import('./repl');  // 动态加载

// Query 状态机的核心循环
async function* executeQuery(prompt: string) {
  const state = QueryState.IDLE;

  while (true) {
    switch (state) {
      case QueryState.IDLE:
        state = QueryState.THINKING;
        break;

      case QueryState.THINKING:
        // 调用 AI API
        response = await anthropic.messages.create(params);
        state = QueryState.STREAMING;
        break;

      case QueryState.STREAMING:
        // 流式输出响应
        for await (const chunk of response) {
          yield chunk;
        }
        state = QueryState.TOOL_EXECUTION;
        break;

      case QueryState.TOOL_EXECUTION:
        // 执行工具调用
        if (stopReason === 'tool_use') {
          toolResults = await executeTools(toolCalls);
          state = QueryState.THINKING;
        } else {
          state = QueryState.COMPLETE;
        }
        break;

      case QueryState.COMPLETE:
        return;
    }
  }
}

// 第一层: Tool 重试
async function executeToolWithRetry(
  tool: Tool,
  maxRetries = 3
): Promise<ToolResult> {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await tool.execute();
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      await sleep(Math.pow(2, i) * 1000);  // 指数退避
    }
  }
}

// 第二层: Query 重启
async function retryQuery(
  query: Query,
  context: Context
): Promise<QueryResult> {
  // 保存失败前的上下文
  const snapshot = context.snapshot();

  try {
    return await executeQuery(query);
  } catch (error) {
    // 恢复上下文并重试
    context.restore(snapshot);
    return await executeQuery(query);
  }
}

// 第三层: REPL 恢复
function recoverREPL(error: Error) {
  console.error('致命错误，正在恢复 REPL...');
  // 清理状态
  // 重新初始化核心组件
  // 返回到 IDLE 状态
}

export async function* query(
  prompt: string,
  options: QueryOptions = {}
): AsyncGenerator<QueryEvent> {
  // ========== 初始化阶段 ==========
  const context = new QueryContext(options);
  const messages: Message[] = [
    { role: 'user', content: prompt }
  ];

  // ========== 核心循环 ==========
  while (true) {
    // 检查提前退出条件
    if (context.shouldStop) {
      yield { type: 'stop', reason: context.stopReason };
      break;
    }

    try {
      // 阶段 1: 调用 AI
      yield { type: 'thinking_start' };

      const response = await anthropic.messages.create({
        model: "claude-sonnet-4-6",
        messages,
        stream: true,
        max_tokens: 8192,
        tools: context.availableTools
      });

      // 阶段 2: 流式处理响应
      let fullContent = '';
      let toolCalls: ToolCall[] = [];

      for await (const chunk of response) {
        if (chunk.type === 'content_block_delta') {
          fullContent += chunk.delta.text;
          yield {
            type: 'content',
            text: chunk.delta.text
          };
        }

        if (chunk.type === 'content_block_stop') {
          yield { type: 'thinking_end' };
        }

        if (chunk.type === 'tool_use') {
          toolCalls.push(chunk.toolUse);
        }
      }

      // 阶段 3: 处理工具调用
      if (toolCalls.length > 0) {
        yield {
          type: 'tool_execution_start',
          count: toolCalls.length
        };

        const toolResults = await executeTools(
          toolCalls,
          context
        );

        // 将工具结果添加到消息历史
        messages.push({
          role: 'assistant',
          content: fullContent,
          tool_calls: toolCalls
        });

        messages.push({
          role: 'user',
          content: toolResults
        });

        // 继续循环，返回 THINKING 状态
        continue;
      }

      // 阶段 4: 完成
      yield {
        type: 'complete',
        content: fullContent
      };
      break;

    } catch (error) {
      // 错误处理
      const recovered = await context.handleError(error);
      if (!recovered) {
        yield {
          type: 'error',
          error: error.message
        };
        break;
      }
    }
  }
}

// 流式响应处理器
class StreamHandler {
  private renderer: StreamRenderer;
  private buffer: string[] = [];
  private flushInterval = 16;  // ~60fps

  async handleStream(
    stream: AsyncGenerator<QueryEvent>
  ): Promise<void> {
    const timer = setInterval(() => {
      this.flush();
    }, this.flushInterval);

    try {
      for await (const event of stream) {
        switch (event.type) {
          case 'content':
            // 累积到缓冲区
            this.buffer.push(event.text);
            break;

          case 'thinking_start':
            this.renderer.showThinking();
            break;

          case 'tool_execution_start':
            this.renderer.showToolExecution(
              event.count
            );
            break;

          case 'complete':
            this.flush();
            this.renderer.finalize(event.content);
            return;
        }
      }
    } finally {
      clearInterval(timer);
    }
  }

  private flush() {
    if (this.buffer.length === 0) return;

    const content = this.buffer.join('');
    this.renderer.append(content);
    this.buffer = [];
  }
}

// 优化 1: 并行工具执行
async function executeToolsParallel(
  toolCalls: ToolCall[]
): Promise<ToolResult[]> {
  // 识别独立工具
  const independentTools = findIndependentTools(toolCalls);
  const dependentTools = findDependentTools(toolCalls);

  // 并行执行独立工具
  const parallelResults = await Promise.all(
    independentTools.map(tool => tool.execute())
  );

  // 串行执行依赖工具
  const serialResults = [];
  for (const tool of dependentTools) {
    const result = await tool.execute();
    serialResults.push(result);
  }

  return [...parallelResults, ...serialResults];
}

// 优化 2: 上下文压缩
function compressContext(
  messages: Message[],
  maxTokens: number
): Message[] {
  const compressed: Message[] = [];
  let currentTokens = 0;

  // 从最新消息开始倒序遍历
  for (let i = messages.length - 1; i >= 0; i--) {
    const msg = messages[i];
    const tokens = estimateTokens(msg);

    if (currentTokens + tokens > maxTokens) {
      // 压缩旧消息
      const summary = summarizeMessage(msg);
      compressed.unshift(summary);
    } else {
      compressed.unshift(msg);
      currentTokens += tokens;
    }
  }

  return compressed;
}

// 优化 3: 提前退出机制
class QueryContext {
  private aborted = false;

  abort() {
    this.aborted = true;
  }

  shouldStop() {
    return this.aborted || this.stopReason;
  }
}

async function checkPermissions(
  tool: Tool,
  input: ToolInput,
  context: PermissionContext
): Promise<PermissionDecision> {

  // ========== Step 1: 模式检查 ==========
  const mode = context.getPermissionMode();
  if (mode === PermissionMode.BYPASS) {
    return { allowed: true, reason: 'bypass_mode' };
  }

  // ========== Step 2: 工具白名单 ==========
  if (isWhitelistedTool(tool)) {
    return { allowed: true, reason: 'whitelisted' };
  }

  // ========== Step 3: 缓存查询 ==========
  const cached = await cache.get(tool, input);
  if (cached) {
    return cached;
  }

  // ========== Step 4: 风险评估 ==========
  const risk = assessRisk(tool, input);

  // ========== Step 5: 低风险自动通过 ==========
  if (risk.level === RiskLevel.LOW) {
    return { allowed: true, reason: 'low_risk' };
  }

  // ========== Step 6: 高风险必须确认 ==========
  if (risk.level === RiskLevel.HIGH) {
    if (mode === PermissionMode.AUTO) {
      return { allowed: false, reason: 'high_risk_auto_mode' };
    }
  }

  // ========== Step 7: 中等风险检查模式 ==========
  if (risk.level === RiskLevel.MEDIUM) {
    if (mode === PermissionMode.AUTO) {
      return { allowed: true, reason: 'medium_risk_auto' };
    }
  }

  // ========== Step 8: 计划模式检查 ==========
  if (mode === PermissionMode.PLAN) {
    return {
      allowed: false,
      reason: 'plan_mode_readonly'
    };
  }

  // ========== Step 9: 用户确认检查 ==========
  if (mode === PermissionMode.CONFIRM) {
    const confirmed = await promptUser(tool, input, risk);
    if (!confirmed) {
      return { allowed: false, reason: 'user_denied' };
    }
  }

  // ========== Step 10: 不再询问模式 ==========
  if (mode === PermissionMode.DONT_ASK) {
    return { allowed: true, reason: 'dont_ask_mode' };
  }

  // ========== Step 11: 接受编辑模式 ==========
  if (mode === PermissionMode.ACCEPT_EDITS) {
    if (tool.isEditOperation()) {
      return { allowed: true, reason: 'accept_edits_mode' };
    }
  }

  // ========== Step 12: 冒泡模式 ==========
  if (mode === PermissionMode.BUBBLE) {
    return {
      allowed: true,
      requiresConfirmation: true,
      reason: 'bubble_mode'
    };
  }

  // ========== Step 13: 缓存决策 ==========
  const decision = { allowed: true, reason: 'default_allow' };
  await cache.set(tool, input, decision);
  return decision;
}

enum PermissionMode {
  // 默认：基于风险的智能决策
  DEFAULT = 'default',

  // 只读：拒绝所有修改
  PLAN = 'plan',

  // 自动接受编辑
  ACCEPT_EDITS = 'acceptEdits',

  // 完全跳过权限（危险）
  BYPASS_PERMISSIONS = 'bypassPermissions',

  // 不询问，自动允许
  DONT_ASK = 'dontAsk',

  // 自动模式（高风险拒绝）
  AUTO = 'auto',

  // 冒泡确认
  BUBBLE = 'bubble'
}

// 使用示例
const decision = await checkPermissions(
  tool,
  input,
  { mode: PermissionMode.PLAN }  // 只读模式
);

interface RiskAssessment {
  level: RiskLevel;
  factors: RiskFactor[];
  confidence: number;
}

function assessRisk(
  tool: Tool,
  input: ToolInput
): RiskAssessment {
  const factors: RiskFactor[] = [];
  let score = 0;

  // 因子1: 操作类型
  if (tool.isDestructive()) {
    factors.push({
      type: 'destructive_operation',
      weight: 0.4
    });
    score += 40;
  }

  // 因子2: 文件数量
  const fileCount = input.getFileCount();
  if (fileCount > 10) {
    factors.push({
      type: 'batch_operation',
      weight: 0.3
    });
    score += 30;
  }

  // 因子3: 路径敏感性
  if (input.affectsSystemPath()) {
    factors.push({
      type: 'system_path',
      weight: 0.5
    });
    score += 50;
  }

  // 因子4: 网络操作
  if (tool.isNetworkOperation()) {
    factors.push({
      type: 'network_access',
      weight: 0.3
    });
    score += 30;
  }

  // 计算风险等级
  let level: RiskLevel;
  if (score >= 70) level = RiskLevel.HIGH;
  else if (score >= 40) level = RiskLevel.MEDIUM;
  else level = RiskLevel.LOW;

  return {
    level,
    factors,
    confidence: calculateConfidence(factors)
  };
}

class PermissionCache {
  private cache = new Map<string, CachedDecision>();
  private ttl = 5 * 60 * 1000;  // 5分钟过期

  async get(
    tool: Tool,
    input: ToolInput
  ): Promise<CachedDecision | null> {
    const key = this.generateKey(tool, input);
    const cached = this.cache.get(key);

    if (!cached) return null;

    // 检查是否过期
    if (Date.now() - cached.timestamp > this.ttl) {
      this.cache.delete(key);
      return null;
    }

    // 检查上下文是否变化
    if (!this.isContextValid(cached, input)) {
      this.cache.delete(key);
      return null;
    }

    return cached;
  }

  async set(
    tool: Tool,
    input: ToolInput,
    decision: PermissionDecision
  ): Promise<void> {
    const key = this.generateKey(tool, input);

    this.cache.set(key, {
      decision,
      timestamp: Date.now(),
      contextHash: this.hashContext(input)
    });

    // 限制缓存大小
    if (this.cache.size > 1000) {
      this.evictOldest();
    }
  }

  private generateKey(tool: Tool, input: ToolInput): string {
    // 生成唯一的缓存键
    return hash({
      tool: tool.name,
      operation: input.operation,
      target: input.getTarget(),
      user: input.userId
    });
  }

  private isContextValid(
    cached: CachedDecision,
    input: ToolInput
  ): boolean {
    // 检查文件是否被修改
    if (input.hasFileChanged(cached.contextHash)) {
      return false;
    }

    // 检查权限模式是否变化
    if (input.mode !== cached.mode) {
      return false;
    }

    return true;
  }
}

interface SettingsCascade {
  mdm?: Settings;          // Layer 1: 最低优先级
  global?: Settings;       // Layer 2
  project?: Settings;      // Layer 3
  env?: Settings;          // Layer 4
  cli?: Settings;          // Layer 5: 最高优先级
}

class SettingsManager {
  private cascade: SettingsCascade;

  function getEffectiveSettings(): Settings {
    // 从低到高合并配置
    const merged: Settings = {
      // 从 MDM 开始（基础配置）
      ...this.cascade.mdm,

      // 全局配置覆盖 MDM
      ...this.cascade.global,

      // 项目配置覆盖全局
      ...this.cascade.project,

      // 环境变量覆盖项目配置
      ...this.cascade.env,

      // CLI 参数覆盖一切
      ...this.cascade.cli
    };

    // 特殊处理：数组类型配置
    return this.mergeArrays(merged);
  }

  private mergeArrays(settings: Settings): Settings {
    // 某些配置需要数组合并而非覆盖
    const result = { ...settings };

    // 示例：工具白名单需要累加
    result.toolWhitelist = [
      ...(settings.mdm?.toolWhitelist || []),
      ...(settings.global?.toolWhitelist || []),
      ...(settings.project?.toolWhitelist || []),
      ...(settings.env?.toolWhitelist || []),
      ...(settings.cli?.toolWhitelist || [])
    ];

    return result;
  }
}

// 使用示例
const settings = await Settings.load();
const effectiveSettings = settings.getEffective();
console.log(effectiveSettings.permissionMode);  // 最终值

class SettingsCache {
  // L1: 内存缓存
  private memoryCache = new Map<string, any>();
  private cacheTTL = 5000;  // 5秒

  // L2: 文件缓存
  private fileCachePath = '~/.claude/settings.cache.json';

  // L3: 默认值
  private defaults = loadDefaults();

  async get(key: string): Promise<any> {
    // ========== L1: 检查内存缓存 ==========
    const memCached = this.memoryCache.get(key);
    if (memCached && !this.isExpired(memCached)) {
      return memCached.value;
    }

    // ========== L2: 检查文件缓存 ==========
    const fileCached = await this.loadFromFileCache(key);
    if (fileCached) {
      // 回填内存缓存
      this.memoryCache.set(key, {
        value: fileCached,
        timestamp: Date.now()
      });
      return fileCached;
    }

    // ========== L3: 返回默认值 ==========
    return this.defaults[key];
  }

  async set(key: string, value: any): Promise<void> {
    // 写入所有层

    // L1: 更新内存
    this.memoryCache.set(key, {
      value,
      timestamp: Date.now()
    });

    // L2: 更新文件缓存
    await this.saveToFileCache(key, value);

    // L3: 更新实际配置文件
    await this.saveToSettingsFile(key, value);
  }

  // 文件监视器
  private setupFileWatcher() {
    const watcher = fs.watch(this.settingsPath, async () => {
      // 文件变化时清除内存缓存
      this.memoryCache.clear();

      // 重新加载配置
      await this.reload();

      // 触发配置变更事件
      this.emitter.emit('settings-changed');
    });
  }
}

interface MDMConfig {
  // 企业策略配置
  permissionMode?: PermissionMode;
  allowedDomains?: string[];
  dataRetentionDays?: number;
  auditLoggingEnabled?: boolean;

  // 安全策略
  disableDangerousTools?: boolean;
  requireEncryption?: boolean;
  allowedIPRanges?: string[];

  // 合规配置
  dataResidency?: string;  // 'eu', 'us', 'asia'
  complianceMode?: boolean;
}

class MDMManager {
  private configPath = '/Library/Managed Preferences/com.anthropic.claude-code.plist';

  async load(): Promise<MDMConfig | null> {
    try {
      // macOS MDM 配置路径
      const plist = await readPlist(this.configPath);

      return {
        permissionMode: plist.permissionMode,
        allowedDomains: plist.allowedDomains,
        dataRetentionDays: plist.dataRetentionDays || 30,
        auditLoggingEnabled: plist.auditLoggingEnabled || false,
        disableDangerousTools: plist.disableDangerousTools || false,
        requireEncryption: plist.requireEncryption || false,
        allowedIPRanges: plist.allowedIPRanges || [],
        dataResidency: plist.dataResidency || 'us',
        complianceMode: plist.complianceMode || false
      };
    } catch (error) {
      // 无 MDM 配置，返回 null
      return null;
    }
  }

  // 验证 MDM 配置合规性
  validateCompliance(config: MDMConfig): ComplianceReport {
    const violations: string[] = [];

    // 检查数据驻留
    if (config.dataResidency === 'eu') {
      // 确保 API 调用使用 EU 区域
      violations.push(...this.checkDataResidency());
    }

    // 检查加密要求
    if (config.requireEncryption) {
      violations.push(...this.checkEncryption());
    }

    return {
      compliant: violations.length === 0,
      violations,
      timestamp: Date.now()
    };
  }
}

// 使用示例
const mdm = await MDMManager.load();
if (mdm?.disableDangerousTools) {
  // 禁用 rm、git push --force 等危险工具
  ToolRegistry.disableDangerousTools();
}

class HotReloadManager {
  private watchers = new Map<string, FSWatcher>();
  private debounceTimers = new Map<string, NodeJS.Timeout>();

  watchFile(filePath: string, callback: () => void) {
    // 防抖：避免频繁触发
    const debouncedCallback = debounce(callback, 500);

    const watcher = fs.watch(filePath, async (eventType) => {
      if (eventType === 'change') {
        // 等待文件写入完成
        await sleep(100);

        // 重新加载配置
        const newConfig = await this.loadConfig(filePath);

        // 验证配置
        const validation = this.validateConfig(newConfig);
        if (!validation.valid) {
          console.error('配置验证失败:', validation.errors);
          return;
        }

        // 应用新配置
        await this.applyConfig(newConfig);

        // 触发回调
        debouncedCallback();

        // 通知所有订阅者
        this.emitter.emit('config-updated', newConfig);
      }
    });

    this.watchers.set(filePath, watcher);
  }

  // 监听多个配置文件
  watchAllConfigs() {
    // 全局配置
    this.watchFile(
      '~/.claude/settings.json',
      () => console.log('全局配置已更新')
    );

    // 项目配置
    this.watchFile(
      './.claude/settings.json',
      () => console.log('项目配置已更新')
    );

    // MDM 配置
    this.watchFile(
      '/Library/Managed Preferences/com.anthropic.claude-code.plist',
      () => console.log('MDM 配置已更新')
    );
  }

  // 清理监视器
  dispose() {
    this.watchers.forEach(watcher => watcher.close());
    this.watchers.clear();
  }
}

// 全局实例
const hotReload = new HotReloadManager();
hotReload.watchAllConfigs();

interface AgentToolConfig {
  name: string;
  description: string;
  agentType: AgentType;
  systemPrompt: string;
  parameters: ToolParameter[];
}

class AgentTool implements Tool {
  private config: AgentToolConfig;
  private agent: Agent;
  private cache: PromptCache;

  constructor(config: AgentToolConfig) {
    this.config = config;
    this.agent = this.createAgent();
    this.cache = PromptCache.getInstance();
  }

  // 工具元数据
  get name() { return this.config.name; }
  get description() { return this.config.description; }

  // 工具执行入口
  async execute(
    input: ToolInput,
    context: ToolContext
  ): Promise<ToolResult> {
    try {
      // 1. 构建完整的 Prompt
      const fullPrompt = this.buildPrompt(input);

      // 2. 检查 Prompt Cache
      const cached = await this.cache.get(fullPrompt);
      if (cached) {
        return {
          success: true,
          data: cached,
          cached: true
        };
      }

      // 3. 执行 Agent
      const result = await this.agent.execute(
        fullPrompt,
        context
      );

      // 4. 缓存结果
      await this.cache.set(fullPrompt, result);

      // 5. 返回结果
      return {
        success: true,
        data: result
      };

    } catch (error) {
      return {
        success: false,
        error: error.message
      };
    }
  }

  private createAgent(): Agent {
    switch (this.config.agentType) {
      case AgentType.FORK:
        return new ForkAgent(this.config);

      case AgentType.INLINE:
        return new InlineAgent(this.config);

      default:
        throw new Error(`Unknown agent type: ${this.config.agentType}`);
    }
  }

  private buildPrompt(input: ToolInput): string {
    return `
${this.config.systemPrompt}

用户请求:
${input.prompt}

上下文信息:
${JSON.stringify(input.context, null, 2)}
    `.trim();
  }
}

// 使用示例：注册 Code Review Agent
const codeReviewTool = new AgentTool({
  name: 'code_review',
  description: 'Review code changes and provide feedback',
  agentType: AgentType.FORK,
  systemPrompt: 'You are a code review expert...',
  parameters: [
    { name: 'diff', type: 'string', required: true },
    { name: 'baseBranch', type: 'string', required: false }
  ]
});

ToolRegistry.register(codeReviewTool);

class ForkAgent implements Agent {
  private childProcess: ChildProcess | null = null;
  private config: AgentConfig;

  async execute(
    prompt: string,
    parentContext: Context
  ): Promise<AgentResult> {

    // ========== 步骤1: 准备共享 Context ==========
    const sharedContext = this.prepareSharedContext(parentContext);

    // ========== 步骤2: Fork 子进程 ==========
    this.childProcess = fork(
      './agent-worker.js',
      [this.config.name],
      {
        silent: true,  // 不共享 stdio
        env: {
          ...process.env,
          CLAUDE_AGENT_MODE: 'fork',
          CLAUDE_AGENT_NAME: this.config.name
        }
      }
    );

    // ========== 步骤3: 发送任务和 Context ==========
    this.childProcess.send({
      type: 'execute',
      prompt,
      context: sharedContext,
      config: this.config
    });

    // ========== 步骤4: 等待结果 ==========
    return new Promise((resolve, reject) => {
      let result: AgentResult | null = null;

      // 接收子进程消息
      this.childProcess!.on('message', (msg) => {
        switch (msg.type) {
          case 'progress':
            // 转发进度更新
            parentContext.emitProgress(msg.progress);
            break;

          case 'result':
            result = msg.result;
            break;

          case 'error':
            reject(new Error(msg.error));
            break;
        }
      });

      // 监听进程退出
      this.childProcess!.on('exit', (code) => {
        if (code === 0) {
          resolve(result!);
        } else {
          reject(new Error(`Agent exited with code ${code}`));
        }
      });

      // 超时保护
      setTimeout(() => {
        this.childProcess!.kill('SIGTERM');
        reject(new Error('Agent execution timeout'));
      }, this.config.timeout || 30000);
    });
  }

  // 准备共享的 Context
  private prepareSharedContext(parentContext: Context): SharedContext {
    return {
      // 共享文件系统状态
      workingDirectory: parentContext.cwd,

      // 共享环境变量（过滤敏感信息）
      env: this.filterEnvVars(process.env),

      // 共享工具注册表（只读）
      toolRegistry: parentContext.toolRegistry.serialize(),

      // 共享 Prompt Cache（只读）
      promptCache: parentContext.promptCache.export(),

      // 不共享：AI 客户端、状态变量
      // 子进程需要创建自己的 AI 实例
    };
  }
}

// agent-worker.js (子进程入口)
if (process.env.CLAUDE_AGENT_MODE === 'fork') {
  process.on('message', async (msg) => {
    if (msg.type === 'execute') {
      const { prompt, context, config } = msg;

      // 创建独立的 AI 客户端
      const agent = new InlineAgent(config);

      try {
        // 执行任务
        const result = await agent.execute(prompt, context);

        // 发送结果回父进程
        process.send({ type: 'result', result });
      } catch (error) {
        process.send({ type: 'error', error: error.message });
      }

      // 退出子进程
      process.exit(0);
    }
  });
}

class PromptCache {
  private cache = new Map<string, CachedPrompt>();
  private redis?: Redis;
  private static instance: PromptCache;

  static getInstance(): PromptCache {
    if (!PromptCache.instance) {
      PromptCache.instance = new PromptCache();
    }
    return PromptCache.instance;
  }

  async get(prompt: string): Promise<Anthropic.Message | null> {
    const hash = this.hashPrompt(prompt);

    // L1: 内存缓存
    const memCached = this.cache.get(hash);
    if (memCached && !this.isExpired(memCached)) {
      return memCached.result;
    }

    // L2: Redis 缓存（跨进程共享）
    if (this.redis) {
      const redisCached = await this.redis.get(`prompt:${hash}`);
      if (redisCached) {
        const result = JSON.parse(redisCached);

        // 回填内存缓存
        this.cache.set(hash, {
          result,
          timestamp: Date.now()
        });

        return result;
      }
    }

    return null;
  }

  async set(prompt: string, result: Anthropic.Message): Promise<void> {
    const hash = this.hashPrompt(prompt);
    const cached: CachedPrompt = {
      result,
      timestamp: Date.now()
    };

    // L1: 内存缓存
    this.cache.set(hash, cached);

    // L2: Redis 缓存
    if (this.redis) {
      await this.redis.setex(
        `prompt:${hash}`,
        86400,  // 24小时
        JSON.stringify(result)
      );
    }
  }

  private hashPrompt(prompt: string): string {
    const normalized = prompt.trim().toLowerCase();
    return createHash('sha256')
      .update(normalized)
      .digest('hex');
  }

  // 为 Fork Agent 导出缓存
  async exportForFork(): Promise<Map<string, CachedPrompt>> {
    // Fork Agent 可以读取但不能写入主进程缓存
    return new Map(this.cache);
  }

  // 清理过期缓存
  private isExpired(cached: CachedPrompt): boolean {
    const age = Date.now() - cached.timestamp;
    return age > 86400000;  // 24小时
  }
}

// 在 AgentTool 中使用
const result = await this.cache.get(fullPrompt);
if (result) {
  console.log('✓ Prompt cache hit');
  return result;
}
// Cache miss，调用 AI
const aiResult = await anthropic.messages.create(...);
await this.cache.set(fullPrompt, aiResult);

// 内置 Agent 注册表
const builtinAgents = registerBuiltinAgents() {
  return [
    // 代码质量
    new AgentTool({
      name: 'review',
      agentType: AgentType.FORK,
      systemPrompt: 'You are a code review expert...'
    }),

    new AgentTool({
      name: 'codex',
      agentType: AgentType.FORK,
      systemPrompt: 'You are an independent code reviewer...'
    }),

    // 测试
    new AgentTool({
      name: 'qa',
      agentType: AgentType.FORK,
      systemPrompt: 'You are a QA testing expert...'
    }),

    new AgentTool({
      name: 'benchmark',
      agentType: AgentType.FORK,
      systemPrompt: 'You are a performance testing expert...'
    }),

    // 安全
    new AgentTool({
      name: 'cso',
      agentType: AgentType.FORK,
      systemPrompt: 'You are a security officer...'
    }),

    // 产品和架构
    new AgentTool({
      name: 'plan-ceo-review',
      agentType: AgentType.INLINE,
      systemPrompt: 'You are a CEO reviewing product plans...'
    }),

    new AgentTool({
      name: 'plan-eng-review',
      agentType: AgentType.INLINE,
      systemPrompt: 'You are an engineering manager...'
    }),

    // DevOps
    new AgentTool({
      name: 'ship',
      agentType: AgentType.INLINE,
      systemPrompt: 'You are a release automation expert...'
    })
  ];
};

// 注册所有内置 Agent
builtinAgents().forEach(agent => {
  ToolRegistry.register(agent);
});

console.log(`✓ Registered ${builtinAgents().length} builtin agents`);

// ========== Tool 接口核心定义 ==========
interface Tool {
  // 工具元数据
  readonly name: string;
  readonly description: string;
  readonly category: ToolCategory;
  readonly permissions: Permission[];

  // 输入输出 Schema (JSON Schema)
  readonly inputSchema: JSONSchema;
  readonly outputSchema?: JSONSchema;

  // ========== 生命周期方法 ==========

  // 1. 验证阶段：检查参数有效性
  validate(params: unknown): ValidationResult;

  // 2. 权限检查：验证用户权限
  checkPermissions(
    user: User,
    params: unknown
  ): PermissionCheck;

  // 3. 执行阶段：核心业务逻辑
  execute(
    params: unknown,
    context: ExecutionContext
  ): Promise<ToolResult>;

  // 4. 清理阶段：释放资源
  cleanup?() => Promise<void>;

  // ========== 可选钩子 ==========

  // 执行前钩子
  beforeExecute?(params: unknown) => Promise<unknown>;

  // 执行后钩子
  afterExecute?(result: ToolResult) => Promise<ToolResult>;

  // 错误处理钩子
  onError?(error: Error) => Promise<ToolResult | null>;
}

// ========== 工具类别枚举 ==========
enum ToolCategory {
  FILE = 'file',
  BASH = 'bash',
  SEARCH = 'search',
  GIT = 'git',
  MEMORY = 'memory',
  AGENT = 'agent',
  WEB = 'web'
}

// ========== 权限级别 ==========
enum Permission {
  READ_FILES = 'read:files',
  WRITE_FILES = 'write:files',
  EXECUTE_BASH = 'execute:bash',
  MODIFY_GIT = 'modify:git',
  NETWORK_ACCESS = 'network:access'
}

// ========== 工厂模式实现 ==========
function buildTool<TInput = unknown, TOutput = unknown>(config: {
  name: string;
  description: string;
  category: ToolCategory;
  inputSchema: JSONSchema<TInput>;
  outputSchema?: JSONSchema<TOutput>;
  permissions?: Permission[];
  execute: (params: TInput, context: ExecutionContext) => Promise<TOutput>;
  beforeExecute?: (params: TInput) => Promise<TInput>;
  afterExecute?: (result: TOutput) => Promise<TOutput>;
  onError?: (error: Error) => Promise<TOutput | null>;
  cleanup?: () => Promise<void>;
}): Tool {
  return {
    name: config.name,
    description: config.description,
    category: config.category,
    permissions: config.permissions || [],
    inputSchema: config.inputSchema,
    outputSchema: config.outputSchema,

        validate(params: unknown): ValidationResult {
      return validateJSONSchema(params, config.inputSchema);
    },

        checkPermissions(user: User, params: unknown): PermissionCheck {
      return config.permissions?.every(perm => user.hasPermission(perm))
        ? { granted: true }
        : { granted: false, reason: 'Missing permissions' };
    },

        async execute(params: unknown, context: ExecutionContext): Promise<ToolResult> {
      let processedParams = params;
      if (config.beforeExecute) {
        processedParams = await config.beforeExecute(processedParams as TInput);
      }

      let result: TOutput;
      try {
        result = await config.execute(processedParams as TInput, context);
      } catch (error) {
        if (config.onError) {
          const recovered = await config.onError(error as Error);
          if (recovered !== null) return { success: true, data: recovered };
        }
        throw error;
      }

      if (config.afterExecute) {
        result = await config.afterExecute(result);
      }

      return { success: true, data: result };
    },

    cleanup: config.cleanup
  };
}

// ========== 并行工具执行核心算法 ==========
class StreamingToolExecutor {
  async executeTools(
    toolCalls: ToolCall[]
  ): AsyncGenerator<ToolExecutionEvent> {
    // ========== 阶段 1: 依赖分析 ==========
    const dependencyGraph = await this.analyzeDependencies(toolCalls);
    const independentTools = dependencyGraph.getIndependentTools();
    const dependentTools = dependencyGraph.getDependentTools();

    // ========== 阶段 2: 并行执行独立工具 ==========
    if (independentTools.length > 0) {
      const parallelResults = await Promise.all(
        independentTools.map(tool => this.executeSingleTool(tool))
      );
    }

    // ========== 阶段 3: 串行执行依赖工具 ==========
    for (const toolBatch of dependentTools) {
      for (const toolCall of toolBatch) {
        await this.executeSingleTool(toolCall);
      }
    }
  }

  // ========== 依赖分析：拓扑排序 ==========
  private async analyzeDependencies(
    toolCalls: ToolCall[]
  ): Promise<DependencyGraph> {
    const graph = new DependencyGraph();

    // 检测资源冲突和数据依赖
    for (let i = 0; i < toolCalls.length; i++) {
      for (let j = i + 1; j < toolCalls.length; j++) {
        if (this.hasResourceConflict(toolCalls[i], toolCalls[j])) {
          graph.addDependency(toolCalls[i].id, toolCalls[j].id);
        }
      }
    }

    return graph.topologicalSort();
  }
}

// ========== 双上下文系统定义 ==========
interface SystemContext {
  // 系统环境信息
  readonly env: { os: string; shell: string; };
  readonly workingDirectory: { current: string; gitRoot?: string; };
  readonly gitState: GitState;
  readonly toolRegistry: ToolRegistry;
  readonly permissions: Permission[];
}

interface UserContext {
  readonly prompt: string;
  readonly messages: Message[];
  readonly memory: SessionMemory;
  readonly preferences: UserPreferences;
  readonly currentTask?: Task;
}

// ========== 并行 Git 状态获取 ==========
async function getGitStateParallel(cwd: string): Promise<GitState> {
  // 并行执行 5 个独立的 Git 命令
  const results = await Promise.all([
    execGit(['status', '--porcelain'], cwd),
    execGit(['rev-parse', '--abbrev-ref', 'HEAD'], cwd),
    execGit(['rev-parse', 'HEAD'], cwd),
    execGit(['remote', '-v'], cwd),
    execGit(['config', '--get', 'user.email'], cwd)
  ]);

  return {
    status: parseGitStatus(results[0]),
    branch: results[1].trim(),
    commit: results[2].trim(),
    remote: parseGitRemote(results[3]),
    userEmail: results[4].trim()
  };
}

// ========== Git Status 超截机制 ==========
function parseGitStatus(output: string): GitStatus {
  const MAX_FILES = 100;
  const lines = output.split('\n').slice(0, MAX_FILES);

  const status = { modified: [], added: [], deleted: [], untracked: [] };

  for (const line of lines) {
    const [statusCode, ...pathParts] = line.split(' ');
    const filePath = pathParts.join(' ');

    switch (statusCode) {
      case 'M': status.modified.push(filePath); break;
      case 'A': status.added.push(filePath); break;
      case 'D': status.deleted.push(filePath); break;
      case '??': status.untracked.push(filePath); break;
    }
  }

  return status;
}

// ========== Memory 类型定义 ==========
enum MemoryType {
  USER = 'user',          // 用户偏好
  PROJECT = 'project',    // 项目信息
  SESSION = 'session',    // 会话上下文
  TOOL = 'tool'           // 工具使用数据
}

interface Memory {
  id: string;
  type: MemoryType;
  content: string;
  metadata: {
    importance: number;        // 重要性评分 (0-1)
    frequency: number;
    tags: string[];
    confidence: number;
  };
  createdAt: number;
  lastAccessed: number;
}

// ========== 重要性阈值过滤 ==========
class SessionMemory {
  async addCandidateMemory(
    content: string,
    type: MemoryType
  ): Promise<boolean> {
    const importance = await this.calculateImportance(content, type);

    if (importance < this.config.importanceThreshold) {
      return false;  // 不够重要，不存储
    }

    this.memories.set(id, { content, type, metadata: { importance } });
    return true;
  }
}

// ========== Fork Agent 用于 Memory 提取 ==========
class MemoryExtractionAgent {
  async extractMemoriesFromConversation(
    messages: Message[]
  ): Promise<Memory[]> {
    const prompt = `
分析以下对话，提取值得记忆的信息。
- 用户偏好（代码风格、工具偏好）
- 项目信息（架构决策、代码约定）
- 会话上下文（当前任务）
- 工具使用模式

对话：
${messages}.map(m => m.content).join('\\n')
`;

    const response = await anthropic.messages.create({
      model: "claude-sonnet-4-6",
      messages: [{ role: 'user', content: prompt }],
      temperature: 0.3
    });

    const candidates = parseJSON(response.content[0].text);

    const memories: Memory[] = [];
    for (const candidate of candidates) {
      const added = await memory.addCandidateMemory(
        candidate.content,
        candidate.type
      );
      if (added) memories.push(candidate);
    }

    return memories;
  }
}

// 🎯 关键：定义 Static 和 Dynamic Prompt 的边界
const SYSTEM_PROMPT_DYNAMIC_BOUNDARY = '
═══════════════════════════════════════════════════════════════
STATIC PROMPT ABOVE - THIS LINE IS THE CACHE BOUNDARY
═══════════════════════════════════════════════════════════════
DYNAMIC PROMPT BELOW - NOT CACHED
═══════════════════════════════════════════════════════════════
'

// Static Prompt (可缓存部分)
const STATIC_SECTIONS = [
  '# System Instructions',
  '# Tool Definitions',
  '# Output Format Requirements',
  '# Safety Guidelines',
  // ... 其他不变内容
]

// Dynamic Prompt (实时构建部分)
function buildDynamicPrompt(context: RequestContext): string {
  const sections = []

  // 1. 当前工作目录
  sections.push(`## Current Directory: ${context.cwd}`)

  // 2. Git 状态
  if (context.isGit) {
    sections.push(`## Git Repository: ${context.gitBranch}`)
  }

  // 3. Memory 上下文
  if (context.memories.length > 0) {
    sections.push('## Relevant Memory:')
    sections.push(context.memories.join('\n'))
  }

  // 4. 启用的工具列表
  sections.push('## Available Tools:')
  sections.push(context.enabledTools.map(t => t.name).join(', '))

  return sections.join('\n\n')
}

// 📦 Section 管理器 - 模块化 Prompt 构建
interface PromptSection {
  id: string
  priority: number
  static: boolean
  build: (context: RequestContext) => string
}

class SectionManager {
  private sections: Map<string, PromptSection> = new Map()

  // 注册新的 Section
  register(section: PromptSection) {
    this.sections.set(section.id, section)
  }

  // 构建 Static Prompt
  buildStatic(): string {
    const staticSections = Array.from(this.sections.values())
      .filter(s => s.static)
      .sort((a, b) => a.priority - b.priority)
      .map(s => s.build({}))
      .join('\n\n')

    return staticSections + SYSTEM_PROMPT_DYNAMIC_BOUNDARY
  }

  // 构建 Dynamic Prompt
  buildDynamic(context: RequestContext): string {
    const dynamicSections = Array.from(this.sections.values())
      .filter(s => !s.static)
      .sort((a, b) => a.priority - b.priority)
      .map(s => s.build(context))
      .join('\n\n')

    return dynamicSections
  }
}

// 🎯 场景：用户发送 "帮我优化 src/utils/format.ts 中的 formatDate 函数"

// === 步骤 1: Query 循环接收 ===
// repl.ts - state machine
async function handleQuery(userQuery: string) {
  currentState = State.QUERY
  // 解析意图
  const intent = parseIntent(userQuery)
}

// === 步骤 2: 上下文构建 ===
// context.ts - dual context
const context = await buildContext({
  cwd: '/project',
  files: ['src/utils/format.ts'],
  memories: await memory.getRelevant(userQuery),
  gitStatus: await git.getStatus()
})

// === 步骤 3: Prompt 构建 ===
// prompts.ts - section manager
const prompt = sectionManager.buildFullPrompt({
  static: cachedStaticPrompt,  // 从缓存读取
  dynamic: [
    systemInstructions.build(context),
    fileContext.build('src/utils/format.ts'),
    toolDefinitions.build([ReadTool, EditTool])
  ]
})

// === 步骤 4: 工具并行执行 ===
// tool.ts - parallel execution
const results = await executeToolsInParallel([
  { tool: 'read', file: 'src/utils/format.ts' },
  { tool: 'grep', pattern: 'formatDate', path: 'src/utils/format.ts' }
])

// === 步骤 5: LLM 调用和结果处理 ===
const optimized = await claude.optimizeFunction(prompt, results)

// === 步骤 6: Memory 更新 ===
await memory.add({
  type: 'PROJECT',
  content: '用户优化了 formatDate 函数，关注性能和可读性',
  tags: ['optimization', 'format.ts']
})

// === 步骤 7: 返回结果 ===
currentState = State.REPL
return optimized

// 🎯 案例：添加一个新的 "SearchOnline" 工具

// === 步骤 1: 创建工具类 ===
export class SearchOnlineTool extends Tool {
  name = 'search_online'
  description = 'Search the web for current information'

  async execute(params: { query: string }) {
    return await searchOnline(params.query)
  }
}

// === 步骤 2: 创建 Prompt 定义 ===
export const SEARCH_ONLINE_SECTION = `
## Search Online Tool
Use this tool when you need to find current information.
`

// === 步骤 3: 注册到系统 ===
// 在 prompts.ts 中注册工具
const ALL_TOOLS = [
  { name: SEARCH_ONLINE_TOOL_NAME, section: SEARCH_ONLINE_SECTION }
]

// === 步骤 4: 添加权限控制 ===
export const TOOL_PERMISSIONS = {
  [SEARCH_ONLINE_TOOL_NAME]: {
    allowedInModes: ['standard', 'careful'],
    requiresConfirmation: false
  }
}

✅ 初级工程师
重点学习：模块 1-3（启动和核心循环）
目标：理解 CLI 工具的基本架构

⭐ 中级工程师
重点学习：模块 4-9（权限到 Memory）
目标：掌握复杂系统的设计和优化

🚀 高级工程师
重点学习：模块 13-14（Prompt 和实践）
目标：深入性能优化和架构设计

💡 进阶资源
• Claude API 文档：https://docs.anthropic.com
• 源码仓库：github.com/anthropics/claude-code
• 社区讨论：Claude Code Discord
• 最佳实践：ARCHITECTURE.md