// Go 伪代码理解
for turn := 0; turn < maxTurns; turn++ {
    response := callLLMAPI(context, history)
    
    if response.HasToolCalls() {
        results := executeTools(response.ToolCalls)
        history.Append(results)
        continue  // 继续下一轮
    }
    
    return response.Text  // 结束
}

┌─────────────────────────────────────────────────────────┐
│                    CLI Layer (Ink UI)                    │
│  gemini.tsx → AppContainer → App → Components           │
└────────────────────┬────────────────────────────────────┘
                     │
┌────────────────────▼────────────────────────────────────┐
│                   Core Agent Layer                       │
│  GeminiClient ─→ Turn ─→ GeminiChat ─→ ContentGenerator │
│       ↓              ↓                                   │
│  LoopDetector  CoreToolScheduler                         │
└────────────────────┬────────────────────────────────────┘
                     │
┌────────────────────▼────────────────────────────────────┐
│               Tools & Services Layer                     │
│  ToolRegistry  │  FileSystem  │  IDE  │  MCP  │ Agents  │
│  ReadFile      │  Git         │ VSCode│ Server│ A2A     │
│  Shell         │  Discovery   │ Zed   │Client │SubAgent │
└─────────────────────────────────────────────────────────┘
                     │
┌────────────────────▼────────────────────────────────────┐
│              Cross-Cutting Concerns                      │
│  Hooks  │ Policy  │ Telemetry │ Context │ Compression   │
└─────────────────────────────────────────────────────────┘

async *sendMessageStream(
  request: PartListUnion,
  signal: AbortSignal,
  prompt_id: string,
  turns: number = 100,  // 最多100轮
): AsyncGenerator<ServerGeminiStreamEvent, Turn>

// 1. 触发 BeforeAgent Hook
await this.hookEventHandler.fire('BeforeAgent', ...)

// 2. Agent Loop (最多100轮)
while (turnCount < maxTurns) {
  // 2.1 检测循环(防止死循环)
  this.loopDetectionService.checkForLoop(request)
  
  // 2.2 压缩历史(如果超过token限制)
  if (needsCompression) {
    await this.chatCompressionService.compress()
  }
  
  // 2.3 注入IDE上下文(如VSCode光标位置)
  if (ideContextEnabled) {
    ideContext = await this.ideContextService.getContext()
  }
  
  // 2.4 创建Turn执行单轮对话
  const turn = new Turn(this.geminiChat, ...)
  const turnGenerator = turn.run(request, signal)
  
  // 2.5 流式输出事件
  for await (const event of turnGenerator) {
    yield event  // Content/ToolCall/Error等事件
  }
  
  // 2.6 检查是否需要继续
  if (turn.nextSpeaker !== 'model') {
    break  // 用户需要响应,或已完成
  }
  
  turnCount++
}

// 3. 触发 AfterAgent Hook
await this.hookEventHandler.fire('AfterAgent', ...)

type GeminiClient struct {
    chat              *GeminiChat
    loopDetector      *LoopDetectionService
    compressionSvc    *ChatCompressionService
    hookEventHandler  *HookEventHandler
}

func (c *GeminiClient) SendMessageStream(
    ctx context.Context, 
    request Request,
) <-chan Event {
    eventCh := make(chan Event)
    
    go func() {
        defer close(eventCh)
        
        // BeforeAgent Hook
        c.hookEventHandler.Fire("BeforeAgent", request)
        
        for turn := 0; turn < maxTurns; turn++ {
            // 检测循环
            if err := c.loopDetector.Check(request); err != nil {
                eventCh <- ErrorEvent{err}
                return
            }
            
            // 压缩历史
            if c.needsCompression() {
                c.compressionSvc.Compress(ctx)
            }
            
            // 执行单轮
            turnEvents := c.executeTurn(ctx, request)
            for event := range turnEvents {
                eventCh <- event
            }
            
            // 检查是否继续
            if !shouldContinue {
                break
            }
        }
        
        // AfterAgent Hook
        c.hookEventHandler.Fire("AfterAgent", nil)
    }()
    
    return eventCh
}

async *run(
  request: PartListUnion,
  signal: AbortSignal,
): AsyncGenerator<TurnEvent, void>

// 1. 调用 GeminiChat 获取模型响应
const chatGenerator = this.geminiChat.sendMessageStream(request, signal)

for await (const chunk of chatGenerator) {
  if (chunk.type === 'text') {
    yield { type: 'Content', content: chunk.text }
  }
  
  if (chunk.type === 'functionCall') {
    // 2. 收集所有工具调用
    toolCalls.push(chunk.functionCall)
  }
  
  if (chunk.type === 'thought') {
    yield { type: 'Thought', content: chunk.thought }
  }
}

// 3. 批量执行工具
if (toolCalls.length > 0) {
  const scheduler = new CoreToolScheduler(...)
  const results = await scheduler.scheduleBatch(toolCalls, signal)
  
  // 4. 返回工具结果给模型
  yield* results  // ToolCallRequest/Response 事件
}

// 5. 检查 next_speaker
this.nextSpeaker = response.nextSpeaker || 'user'

type Turn struct {
    chat      *GeminiChat
    scheduler *CoreToolScheduler
}

func (t *Turn) Run(ctx context.Context, req Request) <-chan TurnEvent {
    eventCh := make(chan TurnEvent)
    
    go func() {
        defer close(eventCh)
        
        // 1. 调用模型API
        response := t.chat.SendMessage(ctx, req)
        
        // 2. 流式输出文本
        for chunk := range response.Stream {
            eventCh <- ContentEvent{chunk.Text}
        }
        
        // 3. 执行工具
        if len(response.ToolCalls) > 0 {
            results := t.scheduler.ExecuteBatch(ctx, response.ToolCalls)
            for result := range results {
                eventCh <- ToolCallEvent{result}
            }
        }
    }()
    
    return eventCh
}

async *sendMessageStream(
  request: PartListUnion,
  signal: AbortSignal,
): AsyncGenerator<GeminiChatChunk>

// 1. 触发 BeforeModel Hook(可修改请求)
await this.fireBeforeModelHook(request)

// 2. 调用 Gemini API
const generator = await this.contentGenerator.generateContentStream({
  contents: this.history,  // 历史记录
  tools: this.toolRegistry.getToolDeclarations(),  // 工具声明
  systemInstruction: this.systemPrompt,
}, promptId)

// 3. 流式处理响应
for await (const chunk of generator) {
  if (chunk.candidates[0]?.content?.parts) {
    for (const part of chunk.candidates[0].content.parts) {
      if (part.text) {
        yield { type: 'text', text: part.text }
      }
      if (part.functionCall) {
        yield { type: 'functionCall', functionCall: part.functionCall }
      }
      if (part.thought) {
        yield { type: 'thought', thought: part.thought }
      }
    }
  }
}

// 4. 触发 AfterModel Hook
await this.fireAfterModelHook(response)

// 5. 更新历史
this.history.push({ role: 'model', parts: response.parts })

type GeminiChat struct {
    history       []Message
    contentGen    ContentGenerator
    toolRegistry  *ToolRegistry
    hookHandler   *HookEventHandler
}

type Message struct {
    Role  string  // "user" or "model"
    Parts []Part
}

func (g *GeminiChat) SendMessageStream(
    ctx context.Context, 
    req Request,
) <-chan Chunk {
    chunkCh := make(chan Chunk)
    
    go func() {
        defer close(chunkCh)
        
        // 1. 触发 BeforeModel Hook
        g.hookHandler.Fire("BeforeModel", req)
        
        // 2. 调用API
        apiReq := &genai.GenerateContentRequest{
            Contents: g.history,
            Tools:    g.toolRegistry.GetDeclarations(),
        }
        stream := g.contentGen.GenerateContentStream(ctx, apiReq)
        
        // 3. 流式处理
        for {
            chunk, err := stream.Recv()
            if err == io.EOF {
                break
            }
            
            for _, part := range chunk.Parts {
                switch part.Type {
                case "text":
                    chunkCh <- TextChunk{part.Text}
                case "functionCall":
                    chunkCh <- FunctionCallChunk{part.FunctionCall}
                }
            }
        }
        
        // 4. 更新历史
        g.history = append(g.history, Message{
            Role:  "model",
            Parts: response.Parts,
        })
    }()
    
    return chunkCh
}

// 工具定义(声明式)
class ReadFileTool extends BaseDeclarativeTool {
  name = 'read_file'
  description = 'Read contents of a file'
  
  // JSON Schema参数定义
  parameters = {
    type: 'object',
    properties: {
      file_path: { type: 'string', description: 'Path to file' },
      offset: { type: 'number', description: 'Start line' },
      limit: { type: 'number', description: 'Number of lines' },
    },
    required: ['file_path'],
  }
  
  // 构建可执行实例
  build(params: ReadFileToolParams): ToolInvocation {
    return new ReadFileToolInvocation(this.config, params)
  }
}

// 工具调用(命令式)
class ReadFileToolInvocation extends BaseToolInvocation {
  async execute(signal: AbortSignal): Promise<ToolResult> {
    // 实际执行逻辑
    const content = await fs.readFile(this.params.file_path, 'utf-8')
    return {
      llmContent: { text: content },  // 返回给LLM
      returnDisplay: 'File read successfully',  // 用户界面显示
    }
  }
  
  // 是否需要用户确认
  shouldConfirmExecute(): boolean {
    return false  // 读文件不需要确认
  }
}

// 工具接口
type Tool interface {
    Name() string
    Description() string
    Parameters() *jsonschema.Schema
    Build(params map[string]any) ToolInvocation
}

type ToolInvocation interface {
    Execute(ctx context.Context) (ToolResult, error)
    ShouldConfirm() bool
    GetDescription() string
}

// 具体实现
type ReadFileTool struct {
    config *Config
}

func (t *ReadFileTool) Name() string {
    return "read_file"
}

func (t *ReadFileTool) Description() string {
    return "Read contents of a file"
}

func (t *ReadFileTool) Parameters() *jsonschema.Schema {
    return &jsonschema.Schema{
        Type: "object",
        Properties: map[string]*jsonschema.Schema{
            "file_path": {Type: "string", Description: "Path to file"},
            "offset":    {Type: "number", Description: "Start line"},
            "limit":     {Type: "number", Description: "Number of lines"},
        },
        Required: []string{"file_path"},
    }
}

func (t *ReadFileTool) Build(params map[string]any) ToolInvocation {
    return &ReadFileInvocation{
        config:   t.config,
        filePath: params["file_path"].(string),
        offset:   int(params["offset"].(float64)),
    }
}

type ReadFileInvocation struct {
    config   *Config
    filePath string
    offset   int
}

func (i *ReadFileInvocation) Execute(ctx context.Context) (ToolResult, error) {
    content, err := os.ReadFile(i.filePath)
    if err != nil {
        return ToolResult{}, err
    }
    
    return ToolResult{
        LLMContent:    string(content),
        ReturnDisplay: "File read successfully",
    }, nil
}

func (i *ReadFileInvocation) ShouldConfirm() bool {
    return false
}

validating → scheduled → executing → success
                ↓            ↓           ↓
           waiting      cancelled    error

async scheduleBatch(
  toolCalls: FunctionCall[],
  signal: AbortSignal,
): Promise<ToolCallResponse[]>

// 1. 验证阶段(Validating)
for (const toolCall of toolCalls) {
  yield {
    type: 'ToolCallRequest',
    status: 'validating',
    id: toolCall.id,
    name: toolCall.name,
  }
  
  // 验证参数
  const tool = this.toolRegistry.getTool(toolCall.name)
  const invocation = tool.build(toolCall.args)
  
  // 2. 调度阶段(Scheduled)
  yield {
    type: 'ToolCallRequest',
    status: 'scheduled',
    id: toolCall.id,
  }
}

// 3. 并发执行(Executing)
const results = await Promise.all(
  invocations.map(async (invocation) => {
    // 检查是否需要确认
    if (await invocation.shouldConfirmExecute(signal)) {
      yield { type: 'ToolCallRequest', status: 'waiting', ... }
      
      // 等待用户确认
      const outcome = await waitForConfirmation()
      if (outcome === 'reject') {
        return { status: 'cancelled' }
      }
    }
    
    yield { type: 'ToolCallRequest', status: 'executing', ... }
    
    // 执行工具(带Hook)
    const result = await executeToolWithHooks(
      invocation,
      signal,
      this.config,
      this.messageBus,
    )
    
    yield {
      type: 'ToolCallResponse',
      status: 'success',
      result: result,
    }
    
    return result
  }),
)

return results

type CoreToolScheduler struct {
    toolRegistry *ToolRegistry
    messageBus   *MessageBus
    config       *Config
}

type ToolCallState string

const (
    StateValidating ToolCallState = "validating"
    StateScheduled  ToolCallState = "scheduled"
    StateWaiting    ToolCallState = "waiting"
    StateExecuting  ToolCallState = "executing"
    StateSuccess    ToolCallState = "success"
    StateError      ToolCallState = "error"
)

func (s *CoreToolScheduler) ScheduleBatch(
    ctx context.Context,
    toolCalls []FunctionCall,
) <-chan ToolCallEvent {
    eventCh := make(chan ToolCallEvent, 100)
    
    go func() {
        defer close(eventCh)
        
        // 1. 验证阶段
        invocations := make([]ToolInvocation, 0, len(toolCalls))
        for _, call := range toolCalls {
            eventCh <- ToolCallEvent{State: StateValidating, ID: call.ID}
            
            tool := s.toolRegistry.GetTool(call.Name)
            inv := tool.Build(call.Args)
            invocations = append(invocations, inv)
            
            eventCh <- ToolCallEvent{State: StateScheduled, ID: call.ID}
        }
        
        // 2. 并发执行
        var wg sync.WaitGroup
        for _, inv := range invocations {
            wg.Add(1)
            go func(inv ToolInvocation) {
                defer wg.Done()
                
                // 检查确认
                if inv.ShouldConfirm() {
                    eventCh <- ToolCallEvent{State: StateWaiting}
                    outcome := s.waitForConfirmation(ctx)
                    if outcome == "reject" {
                        return
                    }
                }
                
                // 执行
                eventCh <- ToolCallEvent{State: StateExecuting}
                result, err := inv.Execute(ctx)
                if err != nil {
                    eventCh <- ToolCallEvent{State: StateError, Error: err}
                    return
                }
                
                eventCh <- ToolCallEvent{State: StateSuccess, Result: result}
            }(inv)
        }
        
        wg.Wait()
    }()
    
    return eventCh
}

// Hook类型
type HookType = 
  | 'BeforeAgent'   // Agent开始前
  | 'AfterAgent'    // Agent结束后
  | 'BeforeModel'   // 调用API前
  | 'AfterModel'    // API返回后
  | 'BeforeTool'    // 工具执行前
  | 'AfterTool'     // 工具执行后
  | 'ToolNotification'  // 工具请求时

// Hook定义
interface Hook {
  name: string
  type: HookType
  execute(context: HookContext): Promise<HookResult>
}

// 使用示例
class LoggingHook implements Hook {
  type = 'BeforeTool'
  
  async execute(context: HookContext): Promise<HookResult> {
    console.log(`Tool: ${context.toolName}, Args: ${context.args}`)
    return { proceed: true }  // 继续执行
  }
}

// 触发Hook
await hookEventHandler.fire('BeforeTool', {
  toolName: 'read_file',
  args: { file_path: 'test.txt' },
})

type HookType string

const (
    BeforeAgent HookType = "BeforeAgent"
    BeforeTool  HookType = "BeforeTool"
    AfterTool   HookType = "AfterTool"
)

type Hook interface {
    Type() HookType
    Execute(ctx context.Context, data HookContext) (HookResult, error)
}

type HookEventHandler struct {
    hooks map[HookType][]Hook
}

func (h *HookEventHandler) Fire(
    ctx context.Context, 
    hookType HookType, 
    data HookContext,
) error {
    for _, hook := range h.hooks[hookType] {
        result, err := hook.Execute(ctx, data)
        if err != nil {
            return err
        }
        if !result.Proceed {
            return errors.New("hook rejected execution")
        }
    }
    return nil
}

// 使用示例 - 中间件模式
func executeToolWithHooks(
    ctx context.Context,
    inv ToolInvocation,
    hooks *HookEventHandler,
) (ToolResult, error) {
    // Before Hook
    if err := hooks.Fire(ctx, BeforeTool, HookContext{
        ToolName: inv.Name(),
    }); err != nil {
        return ToolResult{}, err
    }
    
    // 执行工具
    result, err := inv.Execute(ctx)
    
    // After Hook
    hooks.Fire(ctx, AfterTool, HookContext{
        ToolName: inv.Name(),
        Result:   result,
    })
    
    return result, err
}

// 默认配置常量
const DEFAULT_COMPRESSION_TOKEN_THRESHOLD = 0.5;  // 达到模型限制的50%时触发
const COMPRESSION_PRESERVE_THRESHOLD = 0.3;        // 保留最近30%的历史

// 触发判断
if (originalTokenCount >= threshold * tokenLimit(model)) {
  // 触发压缩
}

async compress(
  chat: GeminiChat,
  promptId: string,
  force: boolean,  // 是否强制压缩
  model: string,
  config: Config,
  hasFailedCompressionAttempt: boolean,  // 是否之前失败过
): Promise<{ newHistory: Content[] | null; info: ChatCompressionInfo }>

// 第1步: 前置检查
const curatedHistory = chat.getHistory(true);  // 获取精选历史

// 如果历史为空 或 之前失败过且非强制，直接返回
if (curatedHistory.length === 0 || (hasFailedCompressionAttempt && !force)) {
  return { newHistory: null, info: { compressionStatus: NOOP } };
}

// 第2步: 触发 PreCompress Hook
await firePreCompressHook(messageBus, force ? Manual : Auto);

// 第3步: 检查是否需要压缩
const originalTokenCount = chat.getLastPromptTokenCount();
if (!force && originalTokenCount < threshold * tokenLimit(model)) {
  return { newHistory: null, info: { compressionStatus: NOOP } };
}

// 第4步: 计算分割点（保留最近30%的历史）
const splitPoint = findCompressSplitPoint(
  curatedHistory,
  1 - COMPRESSION_PRESERVE_THRESHOLD,  // 0.7，即压缩70%
);

const historyToCompress = curatedHistory.slice(0, splitPoint);
const historyToKeep = curatedHistory.slice(splitPoint);

// 第5步: 调用LLM生成压缩摘要
const summaryResponse = await config.getBaseLlmClient().generateContent({
  modelConfigKey: { model: 'chat-compression-2.5-pro' },
  contents: [
    ...historyToCompress,
    {
      role: 'user',
      parts: [{
        text: 'First, reason in your scratchpad. Then, generate the <state_snapshot>.'
      }]
    }
  ],
  systemInstruction: { text: getCompressionPrompt() },  // 专门的压缩提示词
});
const summary = getResponseText(summaryResponse) ?? '';

// 第6步: 构建新历史
const extraHistory: Content[] = [
  {
    role: 'user',
    parts: [{ text: summary }],  // 压缩后的摘要
  },
  {
    role: 'model',
    parts: [{ text: 'Got it. Thanks for the additional context!' }],
  },
  ...historyToKeep,  // 保留的最近历史
];

// 第7步: 计算新的Token数量
const fullNewHistory = await getInitialChatHistory(config, extraHistory);
const newTokenCount = await calculateRequestTokenCount(
  fullNewHistory.flatMap((c) => c.parts || []),
  config.getContentGenerator(),
  model,
);

// 第8步: 验证压缩效果
if (newTokenCount > originalTokenCount) {
  // 压缩失败：Token反而增加了！
  return {
    newHistory: null,
    info: {
      compressionStatus: COMPRESSION_FAILED_INFLATED_TOKEN_COUNT,
      originalTokenCount,
      newTokenCount,
    }
  };
} else {
  // 压缩成功
  return {
    newHistory: extraHistory,
    info: {
      compressionStatus: COMPRESSED,
      originalTokenCount,
      newTokenCount,
    }
  };
}

function findCompressSplitPoint(
  contents: Content[],
  fraction: number,  // 要压缩的比例（0.7 = 70%）
): number {
  const charCounts = contents.map(c => JSON.stringify(c).length);
  const totalCharCount = charCounts.reduce((a, b) => a + b, 0);
  const targetCharCount = totalCharCount * fraction;

  let lastSplitPoint = 0;
  let cumulativeCharCount = 0;
  
  for (let i = 0; i < contents.length; i++) {
    const content = contents[i];
    
    // 只能在用户消息处分割（且不能是工具响应）
    if (
      content.role === 'user' &&
      !content.parts?.some(part => !!part.functionResponse)
    ) {
      if (cumulativeCharCount >= targetCharCount) {
        return i;  // 找到合适的分割点
      }
      lastSplitPoint = i;
    }
    
    cumulativeCharCount += charCounts[i];
  }

  // 检查是否可以压缩全部历史
  const lastContent = contents[contents.length - 1];
  if (
    lastContent?.role === 'model' &&
    !lastContent?.parts?.some(part => part.functionCall)
  ) {
    return contents.length;  // 可以压缩所有
  }

  return lastSplitPoint;  // 返回最后一个有效分割点
}

You are the component that summarizes internal chat history into a given structure.

When the conversation history grows too large, you will be invoked to distill 
the entire history into a concise, structured XML snapshot. This snapshot is 
CRITICAL, as it will become the agent's *only* memory of the past. The agent 
will resume its work based solely on this snapshot. All crucial details, plans, 
errors, and user directives MUST be preserved.

First, you will think through the entire history in a private <scratchpad>. 
Review the user's overall goal, the agent's actions, tool outputs, file 
modifications, and any unresolved questions. Identify every piece of information 
that is essential for future actions.

After your reasoning is complete, generate the final <state_snapshot> XML object. 
Be incredibly dense with information. Omit any irrelevant conversational filler.

The structure MUST be as follows:

<state_snapshot>
    <overall_goal>
        <!-- A single, concise sentence describing the user's high-level objective. -->
        <!-- Example: "Refactor the authentication service to use a new JWT library." -->
    </overall_goal>

    <key_knowledge>
        <!-- Crucial facts, conventions, and constraints the agent must remember. -->
        <!-- Example:
         - Build Command: `npm run build`
         - Testing: Tests are run with `npm test`. Test files must end in `.test.ts`.
         - API Endpoint: The primary API endpoint is `https://api.example.com/v2`.
        -->
    </key_knowledge>

    <file_system_state>
        <!-- List files that have been created, read, modified, or deleted. -->
        <!-- Example:
         - CWD: `/home/user/project/src`
         - READ: `package.json` - Confirmed 'axios' is a dependency.
         - MODIFIED: `services/auth.ts` - Replaced 'jsonwebtoken' with 'jose'.
         - CREATED: `tests/new-feature.test.ts` - Initial test structure.
        -->
    </file_system_state>

    <recent_actions>
        <!-- A summary of the last few significant agent actions and their outcomes. -->
        <!-- Example:
         - Ran `grep 'old_function'` which returned 3 results in 2 files.
         - Ran `npm run test`, which failed due to a snapshot mismatch.
         - Ran `ls -F static/` and discovered image assets are stored as `.webp`.
        -->
    </recent_actions>

    <current_plan>
        <!-- The agent's step-by-step plan. Mark completed steps. -->
        <!-- Example:
         1. [DONE] Identify all files using the deprecated 'UserAPI'.
         2. [IN PROGRESS] Refactor `src/components/UserProfile.tsx`.
         3. [TODO] Refactor the remaining files.
         4. [TODO] Update tests to reflect the API change.
        -->
    </current_plan>
</state_snapshot>

<scratchpad>
  这里是 LLM 的"内心独白"
  - 分析问题
  - 整理信息
  - 推理逻辑
  - 自我质疑
  （这部分内容会被丢弃，不会进入最终输出）
</scratchpad>

<state_snapshot>
  这里是最终的结构化输出
  （这部分才是真正需要的结果）
</state_snapshot>

parts: [
  {
    text: 'First, reason in your scratchpad. Then, generate the <state_snapshot>.',
  },
]

First, you will think through the entire history in a private <scratchpad>. 
Review the user's overall goal, the agent's actions, tool outputs, file 
modifications, and any unresolved questions. Identify every piece of information 
that is essential for future actions.

1. LLM 收到压缩任务
   ↓
2. 在 <scratchpad> 中思考：
   - "用户的总体目标是什么？"
   - "关键的技术栈信息有哪些？"
   - "哪些文件被修改了？为什么？"
   - "当前卡在哪一步？"
   - "什么信息是必须保留的？"
   ↓
3. 思考完成后，生成 <state_snapshot>
   - 只包含提炼后的关键信息
   - 结构化、密集、无废话

<scratchpad>
让我回顾整个对话历史...

用户的目标：在现有 React 项目中添加登录功能

关键信息：
- 项目使用 React 18.2 + TypeScript 5.0
- 测试命令是 npm test
- API 地址是 https://api.example.com

文件操作：
- 读取了 package.json (确认依赖)
- 创建了 Login.tsx (登录组件)
- 修改了 App.tsx (添加路由)
- 创建了 auth.test.ts (测试)

最近动作：
- 运行了 npm test，12个测试通过
- 发现需要添加 JWT 存储
- 用户要求添加受保护路由

当前计划：
- ✅ 创建登录组件 (已完成)
- ✅ 添加路由 (已完成)
- ⏸️ JWT 存储 (待做)
- ⏸️ 受保护路由 (待做)

必须保留的信息已梳理清楚，现在生成最终摘要...
</scratchpad>

<state_snapshot>
  <overall_goal>在 React 项目中实现完整的登录认证系统</overall_goal>
  
  <key_knowledge>
    - React 18.2, TypeScript 5.0
    - Test command: npm test
    - API: https://api.example.com
  </key_knowledge>
  
  <file_system_state>
    - CWD: /home/user/project/src
    - READ: package.json - Confirmed 'react-router-dom' available
    - CREATED: components/Login.tsx - Basic login form with validation
    - MODIFIED: App.tsx - Added routing logic
    - CREATED: tests/auth.test.ts - 12 tests passing
  </file_system_state>
  
  <recent_actions>
    - Created Login component with email/password validation
    - Added React Router v6 integration
    - Ran tests: 12/12 passing
  </recent_actions>
  
  <current_plan>
    1. [DONE] Create Login component
    2. [DONE] Add routing
    3. [TODO] Implement JWT storage in localStorage
    4. [TODO] Add protected route wrapper component
  </current_plan>
</state_snapshot>

## Scratchpad Management
**This is your most critical function. Your scratchpad is your memory and your plan.**
1. **Initialization:** On your very first turn, you **MUST** create the `<scratchpad>` section.
2. **Constant Updates:** After **every** `<OBSERVATION>`, you **MUST** update the scratchpad.
   * Mark checklist items as complete: `[x]`.
   * Add new checklist items as you trace the architecture.
   * **Explicitly log questions in `Questions to Resolve`**
   * Record `Key Findings` with file paths and notes
   * Update `Irrelevant Paths to Ignore` to avoid re-investigating dead ends.
3. **Thinking on Paper:** The scratchpad must show your reasoning process

enum CompressionStatus {
  COMPRESSED = 1,                           // 压缩成功
  COMPRESSION_FAILED_INFLATED_TOKEN_COUNT,  // 失败：Token反增
  NOOP,                                     // 无需压缩
}

interface ChatCompressionInfo {
  originalTokenCount: number;
  newTokenCount: number;
  compressionStatus: CompressionStatus;
}

class GeminiClient {
  private hasFailedCompressionAttempt = false;  // 失败标记
  
  async tryCompressChat(
    prompt_id: string,
    force: boolean = false,
  ): Promise<ChatCompressionInfo> {
    const { newHistory, info } = await this.compressionService.compress(
      this.getChat(),
      prompt_id,
      force,
      model,
      this.config,
      this.hasFailedCompressionAttempt,
    );

    if (info.compressionStatus === COMPRESSION_FAILED_INFLATED_TOKEN_COUNT) {
      // 记录失败（除非是强制压缩）
      this.hasFailedCompressionAttempt = !force;
    } else if (info.compressionStatus === COMPRESSED) {
      if (newHistory) {
        // 替换聊天历史
        this.chat = await this.startChat(newHistory);
        this.updateTelemetryTokenCount();
        this.forceFullIdeContext = true;  // 强制重新发送IDE上下文
      }
    }

    return info;
  }
}

[
  { "role": "user", "parts": [{"text": "Read package.json"}] },
  { "role": "model", "parts": [{"functionCall": {...}}] },
  { "role": "tool", "parts": [{"functionResponse": {"content": "..."}}] },
  { "role": "model", "parts": [{"text": "I see you have React 18..."}] },
  { "role": "user", "parts": [{"text": "Add a new component"}] },
  { "role": "model", "parts": [{"functionCall": {...}}] },
  // ... 大量历史 ...
  { "role": "user", "parts": [{"text": "Run tests"}] },
  { "role": "model", "parts": [{"text": "Let me run the tests..."}] }
]

[
  {
    "role": "user",
    "parts": [{
      "text": "<state_snapshot>\n  <overall_goal>Add authentication to React app</overall_goal>\n  <key_knowledge>\n    - React 18.2, TypeScript 5.0\n    - Test with: npm test\n    - API: https://api.example.com\n  </key_knowledge>\n  <file_system_state>\n    - READ: package.json, src/App.tsx\n    - CREATED: src/components/Login.tsx\n    - MODIFIED: src/index.tsx - Added routing\n  </file_system_state>\n  <recent_actions>\n    - Created Login component with form validation\n    - Added React Router v6\n    - Tests passing (12/12)\n  </recent_actions>\n  <current_plan>\n    1. [DONE] Create Login component\n    2. [DONE] Add routing\n    3. [TODO] Implement JWT storage\n    4. [TODO] Add protected routes\n  </current_plan>\n</state_snapshot>"
    }]
  },
  {
    "role": "model",
    "parts": [{"text": "Got it. Thanks for the additional context!"}]
  },
  // 保留最近30%的原始历史
  { "role": "user", "parts": [{"text": "Run tests"}] },
  { "role": "model", "parts": [{"text": "Let me run the tests..."}] }
]

// ❌ 如果没有 "Got it"
[
  { role: 'user', parts: [{ text: '<state_snapshot>...' }] },  // 摘要
  { role: 'user', parts: [{ text: 'Run tests' }] },           // 连续两个user！违反格式
]

// ✅ 有了 "Got it"
[
  { role: 'user', parts: [{ text: '<state_snapshot>...' }] },        // 摘要
  { role: 'model', parts: [{ text: 'Got it. Thanks...' }] },        // model回应
  { role: 'user', parts: [{ text: 'Run tests' }] },                 // user继续
]

User: "Here's what happened before: <state_snapshot>..."
Model: "Got it. Thanks for the additional context!"  ← 表示理解了上下文
User: "Now run the tests..."
Model: "Sure, let me run the tests..."

function extractCuratedHistory(comprehensiveHistory: Content[]): Content[] {
  while (i < length) {
    if (comprehensiveHistory[i].role === 'user') {
      curatedHistory.push(comprehensiveHistory[i]);  // user消息直接加入
      i++;
    } else {
      // model消息需要成对出现并验证有效性
      const modelOutput: Content[] = [];
      while (i < length && comprehensiveHistory[i].role === 'model') {
        modelOutput.push(comprehensiveHistory[i]);
        // 验证model消息的有效性
        i++;
      }
      if (isValid) {
        curatedHistory.push(...modelOutput);
      }
    }
  }
}

// ❌ 没有确认，语义不清晰
[
  { role: 'user', parts: [{ text: '<state_snapshot>包含了bug信息</state_snapshot>' }] },
  { role: 'user', parts: [{ text: 'Fix the bug' }] }  // LLM可能困惑：这是新话题还是延续？
]

// ✅ 有确认，语义明确
[
  { role: 'user', parts: [{ text: '<state_snapshot>包含了bug信息</state_snapshot>' }] },
  { role: 'model', parts: [{ text: 'Got it. Thanks for the additional context!' }] },
  { role: 'user', parts: [{ text: 'Fix the bug' }] }  // LLM清楚：之前的摘要已确认，现在执行任务
]

// 原始历史
curatedHistory = [消息1, 消息2, ..., 消息1000]

// 计算分割点（压缩70%）
splitPoint = 700
historyToCompress = [消息1 ~ 消息700]    // 前70%压缩
historyToKeep = [消息701 ~ 消息1000]      // 后30%保留

// 调用LLM压缩
summary_1 = compress(消息1 ~ 消息700)

// 新历史结构
newHistory = [
  { role: 'user', parts: [{ text: summary_1 }] },        // 压缩摘要
  { role: 'model', parts: [{ text: 'Got it...' }] },    // 确认消息
  消息701, 消息702, ..., 消息1000                         // 保留的历史
]

// 当前历史（包含上次的摘要！）
curatedHistory = [
  { role: 'user', parts: [{ text: summary_1 }] },        // 上次的摘要
  { role: 'model', parts: [{ text: 'Got it...' }] },
  消息701, 消息702, ..., 消息1500                         // 后续所有对话
]

// 计算分割点（压缩70%）
splitPoint = 560  // 约70%的位置
historyToCompress = [
  summary_1,                                             // 包含上次摘要！
  确认消息,
  消息701 ~ 消息1140
]
historyToKeep = [消息1141 ~ 消息1500]                    // 后30%保留

// 再次调用LLM压缩（将摘要+历史一起压缩）
summary_2 = compress([summary_1, 确认消息, 消息701 ~ 消息1140])

// 新历史结构
newHistory = [
  { role: 'user', parts: [{ text: summary_2 }] },        // 新的压缩摘要
  { role: 'model', parts: [{ text: 'Got it...' }] },
  消息1141, 消息1142, ..., 消息1500                       // 保留的历史
]

// 获取的是完整的当前历史
const historyToCompress = curatedHistory.slice(0, splitPoint);
const historyToKeep = curatedHistory.slice(splitPoint);

// Agent Loop 开始前检查
const compressionInfo = await this.tryCompressChat(prompt_id, false);

if (compressionInfo.compressionStatus === CompressionStatus.COMPRESSED) {
  // 发送压缩事件给UI
  yield {
    type: GeminiEventType.ChatCompressed,
    value: compressionInfo,
  };
}

const orderedPrompts = [
  'preamble',              // 序言：Agent 角色定义
  'coreMandates',          // 核心规则：编码约定、库使用、风格等
  'primaryWorkflows',      // 主要工作流：软件工程任务、新应用开发
  'operationalGuidelines', // 操作指南：Shell优化、语气风格、安全规则
  'sandbox',               // 沙盒信息：运行环境限制
  'git',                   // Git规则：提交规范、命令使用
  'finalReminder',         // 最终提醒：核心职能总结
]

You are <interactive/non-interactive> CLI agent specializing in software 
engineering tasks. Your primary goal is to help users safely and efficiently, 
adhering strictly to the following instructions and utilizing your available tools.

# Core Mandates

- **Conventions:** 严格遵守项目现有约定
- **Libraries/Frameworks:** 永远不要假设库可用，必须验证
- **Style & Structure:** 模仿现有代码风格和架构模式
- **Idiomatic Changes:** 确保修改自然融入代码
- **Comments:** 谨慎添加注释，只解释"为什么"
- **Proactiveness:** 主动添加测试确保质量
- **Confirm Ambiguity:** (交互模式) 模糊请求时先确认
- **Handle Ambiguity:** (非交互模式) 不超出请求范围
- **Explaining Changes:** 完成修改后不提供总结(除非被问)
- **Do Not revert changes:** 不要回退更改(除非出错或被要求)
- **Do not call tools in silence:** (Gemini 3) 调用工具前简短说明
- **Continue the work:** (非交互模式) 尽力完成，不问用户

1. **Understand:** 
   - 思考用户请求和代码库上下文
   - 使用 grep/glob/read_file 工具理解结构和约定
   - 并行调用多个工具

2. **Plan:** 
   - 基于理解构建连贯计划
   - 与用户分享简明计划
   - 包含迭代开发和单元测试

3. **Implement:** 
   - 使用 edit/write/shell 等工具
   - 严格遵守项目约定

4. **Verify (Tests):** 
   - 使用项目测试流程验证
   - 从 README/package.json 识别测试命令
   - 永远不要假设标准测试命令

5. **Verify (Standards):** 
   - ⚠️ 非常重要：运行项目的 build/lint/typecheck 命令
   - 确保代码质量和规范

6. **Finalize:** 
   - 验证通过后任务完成
   - 不删除或回退任何更改(包括测试文件)

1. **Understand & Strategize:** 
   - 复杂重构/系统分析时，**首要行动**是委托给 CodebaseInvestigatorAgent
   - 简单搜索直接用 grep/glob
2. **Plan:** 
   - 如果使用了 CodebaseInvestigator，**必须**将其输出作为计划基础

**Goal:** 自主实现视觉吸引、功能完整的原型

1. **Understand Requirements:** 
   - 分析核心功能、UX、视觉、平台、约束
   - (交互模式) 缺少关键信息时提问

2. **Propose Plan:** 
   - 提供清晰的高级总结，包括：
     * 应用类型和核心目的
     * 关键技术栈
     * 主要功能和交互方式
     * 视觉设计和 UX 方法
     * 占位资源策略
   - 默认技术选择：
     * 前端: React/Angular + Bootstrap + Material Design
     * 后端: Node.js/Express 或 Python/FastAPI
     * 全栈: Next.js 或 Django/Flask + React
     * CLI: Python 或 Go
     * 移动: Compose Multiplatform 或 Flutter
     * 3D游戏: Three.js
     * 2D游戏: HTML/CSS/JavaScript

3. **User Approval:** (交互模式) 获取用户批准
   **Implementation:** (非交互模式) 直接开始

4. **Implementation:** 
   - 自主实现每个功能和设计元素
   - 使用 shell 脚手架 (npm init, create-react-app)
   - 主动创建/获取占位资源(图像、图标、精灵、3D模型)
   - 如果能生成简单资源(纯色方块、立方体)就生成
   - 标明占位符类型和替换建议

5. **Verify:** 
   - 对照原始请求和计划审查
   - 修复bug、偏差和占位符
   - 确保样式、交互、原型质量
   - ⚠️ 最重要：构建应用并确保无编译错误

6. **Solicit Feedback:** (交互模式) 提供启动说明并请求反馈

## Shell tool output token efficiency:

⚠️ 避免过度 Token 消耗的关键指南

- 优先使用减少输出的命令标志
- 最小化工具输出 Token，同时保留必要信息
- 预期输出多时使用 quiet/silent 标志
- 权衡输出详细度和信息需求
- 长输出重定向到临时文件: command > <temp_dir>/out.log 2> <temp_dir>/err.log
- 命令运行后用 grep/tail/head 检查临时文件
- 完成后删除临时文件

- **Concise & Direct:** 专业、直接、简洁的 CLI 风格
- **Minimal Output:** 每次回复尽量少于 3 行文本(工具调用/代码生成除外)
- **Clarity over Brevity:** 必要时优先清晰度
- **No Chitchat:** (Gemini 2.x) 避免闲聊、开场白、结束语
- **Formatting:** 使用 GitHub-flavored Markdown，等宽字体渲染
- **Tools vs. Text:** 工具用于操作，文本只用于沟通
- **Handling Inability:** 无法完成时简短说明(1-2句)，提供替代方案

- **Explain Critical Commands:** 
  修改文件系统/代码库/系统状态的命令前，必须简要说明目的和影响
  优先用户理解和安全
  不需要请求权限(用户会看到确认对话框)

- **Security First:** 
  应用安全最佳实践
  永远不要引入暴露/记录/提交密钥的代码

- **Parallelism:** 独立工具调用并行执行
- **Command Execution:** 使用 shell 工具执行命令，记住安全规则
- **Background Processes:** 
  * (交互模式) 不太可能自行停止的命令用 &，不确定时问用户
  * (非交互模式) 不太可能自行停止的命令用 &
- **Interactive Commands:** 
  * (交互模式) 优先非交互命令，但有些命令只能交互(ssh/vim)
    执行交互命令时告知用户可按 ctrl+f 聚焦 shell 输入
  * (非交互模式) 只执行非交互命令
- **Remembering Facts:** 
  使用 memory 工具记住用户相关事实/偏好
  仅用于用户特定信息，不用于项目上下文
  (交互模式) 不确定时可以问"Should I remember that for you?"
- **Respect User Confirmations:** 
  用户取消工具调用时尊重选择，不再尝试
  仅当用户后续明确请求时才能再次调用
  用户取消时假设善意，询问是否有替代方案

- **Help Command:** 用户可用 /help 显示帮助
- **Feedback:** 报告bug或反馈用 /bug 命令

# macOS Seatbelt
你在 macOS Seatbelt 下运行，项目目录外和系统临时目录外的文件访问受限，
主机资源(如端口)访问受限。

遇到可能由 Seatbelt 导致的失败(如 'Operation not permitted')时：
- 向用户报告错误
- 解释为什么可能是 Seatbelt 导致
- 说明用户可能需要调整 Seatbelt 配置

# Sandbox
你在沙盒容器中运行，项目目录外和系统临时目录外的文件访问受限，
主机资源访问受限。

遇到可能由沙盒导致的失败时：
- 报告错误
- 解释为什么可能是沙盒导致
- 说明用户可能需要调整沙盒配置

# Outside of Sandbox
你直接在用户系统上运行，未使用沙盒容器。

对于特别可能修改项目目录外或系统临时目录外的关键命令：
- 解释命令时(按照 Explain Critical Commands 规则)
- 提醒用户考虑启用沙盒

# Git Repository

当前工作目录由 Git 仓库管理

**提交准备流程**：
1. 使用 shell 命令收集信息：
   - git status: 确保所有相关文件被追踪和暂存，必要时 git add
   - git diff HEAD: 查看所有更改(包括未暂存)
     * git diff --staged: 只查看暂存更改(部分提交或用户要求时)
   - git log -n 3: 查看最近提交消息，匹配风格(详细度、格式、签名行等)

2. 尽可能合并 shell 命令节省时间/步骤：
   git status && git diff HEAD && git log -n 3

3. 总是提出草稿提交消息，永远不要只是让用户提供完整消息

4. 提交消息清晰、简洁，更侧重"为什么"而不是"什么"

5. (交互模式) 保持用户知情，必要时询问澄清或确认

6. 每次提交后运行 git status 确认成功

7. 提交失败时，永远不要在未被要求时尝试绕过问题

8. 永远不要在未被明确要求时推送到远程仓库

# Final Reminder

你的核心功能是高效和安全的协助。
平衡极致简洁与关键的清晰度需求，尤其关于安全和潜在系统修改。
始终优先用户控制和项目约定。
永远不要假设文件内容；而是使用 read_file 确保不做广泛假设。
最后，你是一个 Agent - 请持续进行直到用户查询完全解决。

---

<用户记忆内容>

// 根据配置选择工作流变体
if (enableCodebaseInvestigator && enableWriteTodosTool) {
  orderedPrompts.push('primaryWorkflows_prefix_ci_todo');
} else if (enableCodebaseInvestigator) {
  orderedPrompts.push('primaryWorkflows_prefix_ci');
} else if (enableWriteTodosTool) {
  orderedPrompts.push('primaryWorkflows_todo');
} else {
  orderedPrompts.push('primaryWorkflows_prefix');
}

// 过滤被禁用的模块
const enabledPrompts = orderedPrompts.filter((key) => {
  const envVar = process.env[`GEMINI_PROMPT_${key.toUpperCase()}`];
  return envVar !== '0' && envVar !== 'false';
});

// 拼接最终 prompt
basePrompt = enabledPrompts.map((key) => promptConfig[key]).join('\n');

// 添加用户记忆
return `${basePrompt}${memorySuffix}`;

export GEMINI_SYSTEM_MD=true          # 使用 ~/.gemini/system.md
export GEMINI_SYSTEM_MD=/path/to/custom.md  # 使用自定义文件

export GEMINI_WRITE_SYSTEM_MD=true    # 写入 ~/.gemini/system.md
export GEMINI_WRITE_SYSTEM_MD=/path/to/output.md  # 写入自定义路径

export GEMINI_PROMPT_GIT=false         # 禁用 Git 规则
export GEMINI_PROMPT_SANDBOX=0         # 禁用沙盒信息

You are an interactive CLI agent specializing in software engineering tasks...

# Core Mandates
- Conventions: ...
- Libraries/Frameworks: ...
[... 其他核心规则 ...]

# Primary Workflows

## Software Engineering Tasks
1. **Understand & Strategize:** 
   - 复杂任务时委托给 CodebaseInvestigatorAgent
   - 简单搜索直接用 grep/glob
2. **Plan:** 
   - 基于 CodebaseInvestigator 输出构建计划
   - 使用 write_todos 工具追踪进度
[... 后续步骤 ...]

## New Applications
[... 应用开发流程 ...]

# Operational Guidelines
## Tone and Style
- Concise & Direct: ...
[... 其他操作指南 ...]

## Security and Safety Rules
[... 安全规则 ...]

## Tool Usage
[... 工具使用规则 ...]

# Git Repository
- 当前工作目录由 Git 仓库管理
[... Git 规则 ...]

# Final Reminder
你的核心功能是高效和安全的协助...

---

用户偏好: 使用 4 空格缩进，优先 TypeScript
最近项目: ~/work/myproject