private async performGrepSearch(options: { /* ... */ }): Promise<GrepMatch[]> {
  try {
    // --- 策略1: git grep (最高优先级) ---
    const isGit = isGitRepository(absolutePath);
    const gitAvailable = isGit && (await this.isCommandAvailable('git'));
    if (gitAvailable) {
      // 构造 'git grep' 命令参数
      // 执行 'git grep' 子进程
      // 如果成功，解析输出并返回
      // 如果失败，打印调试信息，然后继续尝试下一个策略
    }

    // --- 策略2: 系统grep (第二优先级) ---
    const grepAvailable = await this.isCommandAvailable('grep');
    if (grepAvailable) {
      // 构造 'grep' 命令参数 (包含 --exclude-dir 等)
      // 执行 'grep' 子进程
      // 如果成功，解析输出并返回
      // 如果失败，打印调试信息，然后继续尝试下一个策略
    }

    // --- 策略3: 纯JavaScript回退方案 (最终保障) ---
    console.debug('GrepLogic: Falling back to JavaScript grep implementation.');
    // 使用 'glob' 库查找所有符合条件的文件
    // 遍历文件列表
    // 异步读取每个文件内容
    // 逐行用正则表达式匹配
    // 如果匹配，构建 GrepMatch 对象并存入结果数组
    // 返回最终结果
  } catch (error: unknown) {
    // ...
    throw error; // 向上抛出错误
  }
}

async execute(signal: AbortSignal): Promise<ToolResult> {
    try {
      const workspaceContext = this.config.getWorkspaceContext();
      const workspaceDirectories = workspaceContext.getDirectories();

      // 如果提供了特定路径，解析并检查是否在工作空间内
      let searchDirectories: readonly string[];
      if (this.params.path) {
        const searchDirAbsolute = path.resolve(
          this.config.getTargetDir(),
          this.params.path,
        );
        if (!workspaceContext.isPathWithinWorkspace(searchDirAbsolute)) {
          const rawError = `Error: Path "${this.params.path}" is not within any workspace directory`;
          return {
            llmContent: rawError,
            returnDisplay: `Path is not within workspace`,
            error: {
              message: rawError,
              type: ToolErrorType.PATH_NOT_IN_WORKSPACE,
            },
          };
        }

  searchDirectories = [searchDirAbsolute];
      } else {
        // 搜索所有工作空间目录
        searchDirectories = workspaceDirectories;
      }
  // 获取集中式文件发现服务
  const fileDiscovery = this.config.getFileService();

  // 从所有搜索目录收集条目
  const allEntries: GlobPath[] = [];
  for (const searchDir of searchDirectories) {
    let pattern = this.params.pattern;
    const fullPath = path.join(searchDir, pattern);
    if (fs.existsSync(fullPath)) {
      pattern = escape(pattern);
    }

// 三层搜索回退机制
1. git grep --untracked -n -E --ignore-case pattern
2. grep -r -n -H -E pattern .  
3. JavaScript glob + RegExp 遍历

const memoryToolSchemaData: FunctionDeclaration = {

  name: 'save_memory',

  description:

    'Saves a specific piece of information or fact to your long-term memory. Use this when the user explicitly asks you to remember something, or when they state a clear, concise fact that seems important to retain for future interactions.',

  parametersJsonSchema: {

    type: 'object',

    properties: {

      fact: {

        type: 'string',

        description:

          'The specific fact or piece of information to remember. Should be a clear, self-contained statement.',

      },

    },

    required: ['fact'],

  },

};

  async createTask(

    taskId: string,

    contextId: string,

    agentSettingsInput?: AgentSettings,

    eventBus?: ExecutionEventBus,

  ): Promise<TaskWrapper> {

    const agentSettings = agentSettingsInput || ({} as AgentSettings);

    const config = await this.getConfig(agentSettings, taskId);

    const runtimeTask = await Task.create(taskId, contextId, config, eventBus);

    await runtimeTask.geminiClient.initialize();

  

    const wrapper = new TaskWrapper(runtimeTask, agentSettings);

    this.tasks.set(taskId, wrapper);

    logger.info(`New task ${taskId} created.`);

    return wrapper;

  }

// Task工具对象结构 (p_2)
p_2 = {
    name: "Task",
    async call({ prompt }, context, globalConfig, parentMessage) {
        // ...
        if (config.parallelTasksCount > 1) {
            // 多Agent并发执行模式
            const agentTasks = Array(config.parallelTasksCount)
                .fill(`${prompt}\n\nProvide a thorough and complete analysis.`)
                .map((taskPrompt, index) => I2A(taskPrompt, index, executionContext, parentMessage, globalConfig));
        } 
        // ...
    }
}

/**
 * Task工具实现
 * 基于逆向分析的分层多Agent架构
 * 支持I2A SubAgent实例化和UH1并发调度
 */

import { BaseTool } from '../base';
import { AgentCore } from '../../core/agent-core';
import { gW5ConcurrencyManager } from '../../core/concurrency-manager';
import type { ToolResult, ToolExecutionContext } from '../../types/tool';
import type { AgentConfig, AgentContext, Message } from '../../types/agent';

interface TaskToolParams {
  description: string; // 3-5个词的任务描述
  prompt: string;      // 完整的任务提示
}

interface SubAgentResult {
  agentIndex: number;
  content: any[];
  toolUseCount: number;
  tokens: number;
  usage: any;
  exitPlanModeInput?: any;
}

/**
 * Task工具 - 基于逆向分析的完整多Agent实现
 * 支持SubAgent创建、并发执行和结果聚合
 */
export class TaskTool extends BaseTool {
  name = 'Task';
  description = 'Launch a new task using SubAgent architecture';
  category = 'task';
  subAgentCapable = true;

  schema = {
    type: 'object',
    properties: {
      description: {
        type: 'string',
        description: 'A short (3-5 word) description of the task'
      },
      prompt: {
        type: 'string',
        description: 'The task for the agent to perform'
      }
    },
    required: ['description', 'prompt']
  };

  private concurrencyManager: gW5ConcurrencyManager;

  constructor() {
    super();
    this.concurrencyManager = new gW5ConcurrencyManager();
  }

  // 并发安全性 - Task工具支持并发
  isConcurrencySafe(): boolean {
    return true;
  }

  // 只读性质
  isReadOnly(): boolean {
    return true;
  }

  /**
   * 执行Task工具 - 基于逆向分析的p_2对象实现
   */
  async* executeTask(
    params: TaskToolParams,
    context: ToolExecutionContext
  ): AsyncGenerator<ToolResult> {
    const startTime = Date.now();
    const config = this.getGlobalConfiguration();
    
    // 创建SubAgent执行上下文
    const executionContext = this.createSubAgentContext(context);
    
    if (config.parallelTasksCount > 1) {
      // 多Agent并发执行模式
      yield* this.executeParallelAgents(params, executionContext, config);
    } else {
      // 单Agent执行模式
      yield* this.executeSingleAgent(params, executionContext);
    }
  }

  async execute(params: TaskToolParams, context: ToolExecutionContext): Promise<ToolResult> {
    const results: any[] = [];
    
    for await (const result of this.executeTask(params, context)) {
      results.push(result);
    }

    return results[results.length - 1] || {
      toolCallId: '',
      success: false,
      error: 'No results generated',
      duration: 0
    };
  }

  /**
   * 并发执行多个Agents - 基于逆向分析的并发机制
   */
  private async* executeParallelAgents(
    params: TaskToolParams,
    context: SubAgentExecutionContext,
    config: GlobalConfiguration
  ): AsyncGenerator<ToolResult> {
    let totalToolUseCount = 0;
    let totalTokens = 0;
    
    // 创建多个相同的Agent任务
    const agentTasks = Array(config.parallelTasksCount)
      .fill(`${params.prompt}\n\nProvide a thorough and complete analysis.`)
      .map((prompt, index) => this.I2A_launchSubAgent(prompt, index, context));
    
    const agentResults: SubAgentResult[] = [];
    
    // 并发执行所有Agent任务 - 基于UH1并发调度器
    yield* this.UH1_concurrentExecutor(agentTasks, 10, (result) => {
      if (result.type === "progress") {
        return result;
      } else if (result.type === "result") {
        agentResults.push(result.data);
        totalToolUseCount += result.data.toolUseCount;
        totalTokens += result.data.tokens;
        return {
          toolCallId: '',
          success: true,
          data: { type: 'agent_completed', agentIndex: result.data.agentIndex },
          duration: 0
        };
      }
      return null;
    });
    
    // 检查是否被中断
    if (context.abortSignal?.aborted) {
      throw new Error('Task execution was aborted');
    }
    
    // 使用合成器合并结果 - 基于KN5函数
    const synthesisPrompt = this.KN5_synthesizeResults(params.prompt, agentResults);
    const synthesisAgent = this.I2A_launchSubAgent(synthesisPrompt, 0, context, { isSynthesis: true });
    
    let synthesisResult: SubAgentResult | null = null;
    for await (const result of synthesisAgent) {
      if (result.type === "progress") {
        totalToolUseCount++;
        yield {
          toolCallId: '',
          success: true,
          data: { type: 'synthesis_progress' },
          duration: 0
        };
      } else if (result.type === "result") {
        synthesisResult = result.data;
        totalTokens += synthesisResult.tokens;
      }
    }
    
    if (!synthesisResult) {
      throw new Error("Synthesis agent did not return a result");
    }
    
    // 检查退出计划模式
    const exitPlanInput = agentResults.find(r => r.exitPlanModeInput)?.exitPlanModeInput;
    
    yield {
      toolCallId: '',
      success: true,
      data: {
        content: synthesisResult.content,
        totalDurationMs: Date.now() - Date.now(),
        totalTokens: totalTokens,
        totalToolUseCount: totalToolUseCount,
        usage: synthesisResult.usage,
        wasInterrupted: false,
        exitPlanModeInput: exitPlanInput
      },
      duration: Date.now() - Date.now()
    };
  }

  /**
   * 单Agent执行模式
   */
  private async* executeSingleAgent(
    params: TaskToolParams,
    context: SubAgentExecutionContext
  ): AsyncGenerator<ToolResult> {
    const agentExecution = this.I2A_launchSubAgent(params.prompt, 0, context);
    let toolUseCount = 0;
    let agentResult: SubAgentResult | null = null;
    
    for await (const result of agentExecution) {
      if (result.type === "progress") {
        yield {
          toolCallId: '',
          success: true,
          data: { type: 'agent_progress' },
          duration: 0
        };
      } else if (result.type === "result") {
        agentResult = result.data;
        toolUseCount = agentResult.toolUseCount;
      }
    }
    
    if (!agentResult) {
      throw new Error("Agent did not return a result");
    }
    
    yield {
      toolCallId: '',
      success: true,
      data: {
        content: agentResult.content,
        totalDurationMs: Date.now() - Date.now(),
        totalTokens: agentResult.tokens,
        totalToolUseCount: toolUseCount,
        usage: agentResult.usage,
        wasInterrupted: false,
        exitPlanModeInput: agentResult.exitPlanModeInput
      },
      duration: 0
    };
  }

  /**
   * I2A SubAgent启动器 - 基于逆向分析的精确实现
   */
  private async* I2A_launchSubAgent(
    taskPrompt: string,
    agentIndex: number,
    context: SubAgentExecutionContext,
    options: { isSynthesis?: boolean } = {}
  ): AsyncGenerator<{ type: string; data: any }> {
    const { isSynthesis = false } = options;
    
    // 生成唯一的Agent ID - 基于VN5函数
    const agentId = this.generateUniqueAgentId();
    
    // 创建初始消息
    const initialMessages: Message[] = [{
      id: Date.now().toString(),
      role: 'user',
      content: taskPrompt,
      timestamp: Date.now()
    }];
    
    // 创建SubAgent配置
    const subAgentConfig: AgentConfig = {
      model: context.model,
      fallbackModel: context.fallbackModel,
      enableSteering: false, // SubAgent不支持实时Steering
      concurrencyLimit: 5,   // SubAgent降低并发限制
      planMode: false
    };
    
    // 创建隔离的SubAgent上下文
    const subAgentContext: AgentContext = {
      sessionId: agentId,
      workingDirectory: context.workingDirectory,
      environment: context.environment,
      fileStates: { ...context.fileStates }, // 继承但隔离文件状态
      parentAgent: context.sessionId
    };
    
    // 启动SubAgent
    const subAgent = new AgentCore(subAgentConfig, subAgentContext);
    
    let messageHistory: Message[] = [];
    let toolUseCount = 0;
    let exitPlanInput: any = undefined;
    
    try {
      // 执行Agent主循环
      for await (const agentResponse of subAgent.executeMainLoop(initialMessages)) {
        // 过滤和处理Agent响应
        if (agentResponse.success && agentResponse.data) {
          messageHistory.push(agentResponse.data as Message);
          
          // 统计工具使用
          if (agentResponse.data.type === 'tool_completed') {
            toolUseCount++;
          }
          
          // 检查退出计划模式
          if (agentResponse.data.type === 'exit_plan_mode' && agentResponse.data.input) {
            exitPlanInput = { plan: agentResponse.data.input.plan };
          }
          
          // 生成进度事件
          yield {
            type: "progress",
            data: {
              agentIndex: isSynthesis ? `synthesis_${agentIndex}` : `agent_${agentIndex}`,
              message: agentResponse.data,
              type: "agent_progress"
            }
          };
        }
      }
      
      // 获取最后一条消息
      const lastMessage = messageHistory[messageHistory.length - 1];
      
      if (!lastMessage || lastMessage.role !== 'assistant') {
        throw new Error(isSynthesis 
          ? "Synthesis: Last message was not an assistant message" 
          : `Agent ${agentIndex + 1}: Last message was not an assistant message`
        );
      }
      
      // 计算token使用量
      const totalTokens = this.calculateTokenUsage(lastMessage);
      
      // 提取文本内容
      const textContent = this.extractTextContent(lastMessage);
      
      // 返回最终结果
      yield {
        type: "result",
        data: {
          agentIndex: agentIndex,
          content: textContent,
          toolUseCount: toolUseCount,
          tokens: totalTokens,
          usage: { input_tokens: totalTokens * 0.7, output_tokens: totalTokens * 0.3 },
          exitPlanModeInput: exitPlanInput
        }
      };
      
    } catch (error) {
      yield {
        type: "error",
        data: {
          agentIndex,
          error: error instanceof Error ? error.message : String(error)
        }
      };
    }
  }

  /**
   * UH1并发执行调度器 - 基于逆向分析的精确实现
   */
  private async* UH1_concurrentExecutor<T>(
    generators: Array<AsyncGenerator<T>>,
    maxConcurrency: number,
    transformer: (item: T) => any
  ): AsyncGenerator<any> {
    const remainingGenerators = [...generators];
    const activePromises = new Set<Promise<any>>();
    
    // 包装生成器，添加Promise追踪
    const wrapGenerator = (generator: AsyncGenerator<T>) => {
      return generator.next().then(({ done, value }) => ({
        done,
        value,
        generator,
        promise: null as any
      }));
    };
    
    // 启动初始的并发任务
    while (activePromises.size < maxConcurrency && remainingGenerators.length > 0) {
      const generator = remainingGenerators.shift()!;
      const promise = wrapGenerator(generator);
      activePromises.add(promise);
    }
    
    // 并发执行循环
    while (activePromises.size > 0) {
      // 等待任何一个生成器产生结果
      const { done, value, generator } = await Promise.race(activePromises);
      
      // 移除已完成的Promise
      activePromises.delete(Promise.resolve({ done, value, generator, promise: null }));
      
      if (!done) {
        // 生成器还有更多数据，继续执行
        const newPromise = wrapGenerator(generator);
        activePromises.add(newPromise);
        
        if (value !== undefined) {
          const transformed = transformer(value);
          if (transformed) yield transformed;
        }
      } else if (remainingGenerators.length > 0) {
        // 当前生成器完成，启动新的生成器
        const nextGenerator = remainingGenerators.shift()!;
        const newPromise = wrapGenerator(nextGenerator);
        activePromises.add(newPromise);
      }
    }
  }

  /**
   * KN5结果合成器 - 基于逆向分析的实现
   */
  private KN5_synthesizeResults(originalTask: string, agentResults: SubAgentResult[]): string {
    // 按Agent索引排序结果
    const sortedResults = agentResults.sort((a, b) => a.agentIndex - b.agentIndex);
    
    // 提取每个Agent的文本内容
    const agentResponses = sortedResults.map((result, index) => {
      const textContent = result.content
        .filter((content: any) => content.type === "text")
        .map((content: any) => content.text)
        .join("\n\n");
      
      return `== AGENT ${index + 1} RESPONSE ==\n${textContent}`;
    }).join("\n\n");
    
    // 生成合成提示
    return `Original task: ${originalTask}

I've assigned multiple agents to tackle this task. Each agent has analyzed the problem and provided their findings.

${agentResponses}

Based on all the information provided by these agents, synthesize a comprehensive and cohesive response that:
1. Combines the key insights from all agents
2. Resolves any contradictions between agent findings
3. Presents a unified solution that addresses the original task
4. Includes all important details and code examples from the individual responses
5. Is well-structured and complete

Your synthesis should be thorough but focused on the original task.`;
  }

  // 辅助方法

  private createSubAgentContext(context: ToolExecutionContext): SubAgentExecutionContext {
    return {
      sessionId: context.sessionId,
      workingDirectory: context.workingDirectory,
      environment: {},
      fileStates: context.fileStates,
      model: 'claude-3-5-sonnet',
      fallbackModel: 'claude-3-5-haiku',
      abortSignal: context.abortSignal
    };
  }

  private getGlobalConfiguration(): GlobalConfiguration {
    return {
      parallelTasksCount: 3, // 基于逆向分析的默认值
      maxConcurrentTools: 10
    };
  }

  private generateUniqueAgentId(): string {
    return `agent_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }

  private calculateTokenUsage(message: Message): number {
    // 简化的token计算
    const content = typeof message.content === 'string' ? message.content : JSON.stringify(message.content);
    return Math.ceil(content.length / 4);
  }

  private extractTextContent(message: Message): any[] {
    // 简化的文本内容提取
    return [{
      type: 'text',
      text: typeof message.content === 'string' ? message.content : JSON.stringify(message.content)
    }];
  }
}

// 类型定义
interface SubAgentExecutionContext {
  sessionId: string;
  workingDirectory: string;
  environment: Record<string, string>;
  fileStates: Record<string, any>;
  model: string;
  fallbackModel?: string;
  abortSignal?: AbortSignal;
}

interface GlobalConfiguration {
  parallelTasksCount: number;
  maxConcurrentTools: number;
}

# Unix管道的优雅
cat file.txt | grep "error" | sort | uniq -c | head -10

# 冯·诺依曼风格（有状态）
sum = 0
for i in array:
    sum = sum + i # 不断修改状态

# 函数式风格（无状态）
sum = reduce(add, array) # 纯函数组合

# 今天的需求：找出错误日志中的IP地址
cat app.log | grep ERROR | grep -oE '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+' | sort -u

# 明天的需求：统计每个IP的错误次数
cat app.log | grep ERROR | grep -oE '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+' | sort | uniq -c

# 后天的需求：找出错误最多的前10个IP
cat app.log | grep ERROR | grep -oE '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+' | sort | uniq -c