Claude Code 2026 年 4 月质量事故深度复盘：三个 Bug 如何毁掉用户信任

// 预期行为：空闲超过 1 小时后，只清理一次
function handleResume(sessionId: string, idleTime: number) {
  if (idleTime > ONE_HOUR) {
    clearThinkingBlocks(sessionId); // 只执行一次 ✅
    resumeSession(sessionId);
  } else {
    resumeSession(sessionId);
  }
}

// 实际行为：由于 flag 未被正确清除，每次请求都清理
function handleResume(sessionId: string, idleTime: number) {
  if (shouldClearThinking(sessionId)) { // flag 一直为 true ❌
    clearThinkingBlocks(sessionId);
  }
  resumeSession(sessionId);
}

// 问题：shouldClearThinking 返回 true 后，
// 没有在清理后将 flag 重置为 false

"""
AI 编码 Agent 会话缓存管理器
演示正确的 thinking history 清理策略
"""
from dataclasses import dataclass, field
from datetime import datetime, timedelta
from typing import Optional


@dataclass
class SessionCache:
    """管理单个会话的 prompt 缓存状态"""
    session_id: str
    last_activity: datetime
    thinking_blocks: list = field(default_factory=list)
    cache_valid: bool = True
    clear_once: bool = False  # 标记：只在恢复时清理一次
    idle_threshold: timedelta = timedelta(hours=1)
    
    def is_idle(self, now: Optional[datetime] = None) -> bool:
        """检查会话是否空闲超过阈值"""
        now = now or datetime.now()
        return (now - self.last_activity) > self.idle_threshold
    
    def check_and_clear(self, now: Optional[datetime] = None) -> bool:
        """
        检查是否需要清理 thinking blocks
        
        正确实现：只在首次恢复时清理，之后不再清理
        这是 Anthropic Bug #2 的核心问题所在
        """
        now = now or datetime.now()
        
        if self.is_idle(now) and self.cache_valid:
            # 缓存已失效，标记为需要清理
            self.cache_valid = False
            self.clear_once = True
            return True
        
        if self.clear_once:
            # 执行一次性清理
            self.clear_thinking_history()
            self.clear_once = False  # ← 关键：清理后重置标记
            return True
        
        return False
    
    def clear_thinking_history(self):
        """清理 thinking history，保留基础上下文"""
        # 保留系统提示和用户原始问题
        # 只清除中间的工具调用和推理过程
        self.thinking_blocks = []
    
    def record_activity(self):
        """记录活动，重置空闲计时器"""
        self.last_activity = datetime.now()
    
    def add_thinking_block(self, content: str, tool_call: str = ""):
        """添加新的推理块"""
        self.thinking_blocks.append({
            "content": content,
            "tool_call": tool_call,
            "timestamp": datetime.now().isoformat(),
        })
    
    def build_api_payload(self) -> dict:
        """构建 API 请求的消息列表"""
        messages = []
        # 始终包含系统提示
        messages.append({"role": "system", "content": "You are a coding assistant..."})
        # 包含保留的基础上下文
        messages.append({"role": "user", "content": "Original task..."})
        # 包含 thinking history
        for block in self.thinking_blocks:
            messages.append({
                "role": "assistant",
                "content": block["content"],
                "tool_calls": [block["tool_call"]] if block["tool_call"] else [],
            })
        return {"messages": messages}

"""
单元测试：验证缓存清理只在首次恢复时触发
"""
import unittest
from datetime import datetime, timedelta
from session_cache_manager import SessionCache


class TestSessionCache(unittest.TestCase):
    
    def setUp(self):
        self.now = datetime(2026, 4, 25, 12, 0)
        self.session = SessionCache(
            session_id="test-001",
            last_activity=self.now - timedelta(hours=2),  # 已空闲 2 小时
        )
        # 添加一些 thinking blocks
        self.session.add_thinking_block("Thinking about the problem...", "")
        self.session.add_thinking_block("Running tool: grep...", "grep -r 'test'")
    
    def test_clear_only_once_on_resume(self):
        """Bug #2 的复现：清理应该只发生一次"""
        # 第一次检查：应该触发清理
        self.assertTrue(self.session.check_and_clear(self.now))
        self.assertEqual(len(self.session.thinking_blocks), 0)
        self.assertFalse(self.session.clear_once, 
            "清理后 clear_once 必须重置为 False")
        
        # 添加新的 thinking
        self.session.add_thinking_block("New thinking after resume", "")
        
        # 第二次检查：不应该再触发清理
        self.assertFalse(self.session.check_and_clear(self.now))
        self.assertEqual(len(self.session.thinking_blocks), 1,
            "第二次检查不应清理新增的 thinking")
    
    def test_no_clear_when_cache_valid(self):
        """缓存有效时不应清理"""
        fresh_session = SessionCache(
            session_id="fresh-001",
            last_activity=datetime.now(),  # 刚活跃
        )
        fresh_session.add_thinking_block("Recent thinking", "")
        
        self.assertFalse(fresh_session.check_and_clear())
        self.assertEqual(len(fresh_session.thinking_blocks), 1)
    
    def test_activity_resets_idle_timer(self):
        """活动应该重置空闲计时器"""
        self.session.record_activity()  # 现在标记为活跃
        self.session.cache_valid = True  # 重置缓存状态
        
        self.assertFalse(self.session.check_and_clear())
        self.assertTrue(self.session.cache_valid)


if __name__ == "__main__":
    unittest.main()

# 检查 Claude Code 版本
claude --version

# 确保版本 >= 2.1.116（修复版本）
# 如果版本低于此，立即更新：
npm update -g @anthropic-ai/claude-code

# 或者直接重新安装
npm install -g @anthropic-ai/claude-code@latest

"""
Claude Code 质量自检脚本
验证当前会话是否正常处理上下文
"""
import subprocess
import json


def check_claude_version():
    """检查 Claude Code 版本"""
    try:
        result = subprocess.run(
            ["claude", "--version"],
            capture_output=True,
            text=True,
            timeout=10,
        )
        version = result.stdout.strip()
        print(f"当前版本: {version}")
        
        # 解析版本号 (简化处理)
        parts = version.replace("v", "").split(".")
        if len(parts) >= 3:
            major, minor, patch = int(parts[0]), int(parts[1]), int(parts[2])
            if (major, minor, patch) >= (2, 1, 116):
                print("✅ 版本已包含所有修复")
                return True
            else:
                print("⚠️  版本过旧，建议更新到 >= 2.1.116")
                return False
        return True
    except FileNotFoundError:
        print("❌ Claude Code 未安装")
        return False
    except Exception as e:
        print(f"❌ 检查失败: {e}")
        return False


def test_context_retention():
    """
    测试上下文保持能力
    模拟之前触发 Bug #2 的场景
    """
    test_prompt = """
请执行以下多步骤任务：
1. 列出当前目录的所有 .py 文件
2. 统计每个文件的行数
3. 输出总结

注意：请确保在步骤 2 完成后，仍然记得步骤 1 的结果。
"""
    print("\n📋 建议手动测试：")
    print('1. 在 Claude Code 中粘贴上述 prompt')
    print("2. 等待执行完成")
    print("3. 验证 Claude 是否记得最初的任务要求")
    print("4. 如果 Claude 忘记了步骤 1 的结果，可能存在上下文管理问题")


if __name__ == "__main__":
    print("=== Claude Code 质量自检 ===\n")
    version_ok = check_claude_version()
    if version_ok:
        test_context_retention()
    else:
        print("\n请先更新 Claude Code 到最新版本。")