Claude Code上下文管理深度解析：200K→1M窗口下的无限对话引擎

// types/message.js 中定义的消息类型（从 utils/messages.ts 的 import 推断）
type UserMessage = {
  type: 'user'
  message: { role: 'user'; content: string | ContentBlockParam[] }
  isMeta?: true           // 系统元消息，不显示给用户
  isCompactSummary?: true // 压缩摘要消息
  isVirtual?: true        // 虚拟消息，不发送到 API
  toolUseResult?: unknown  // 工具结果数据
  uuid: UUID
  timestamp: string
}

type AssistantMessage = {
  type: 'assistant'
  message: { role: 'assistant'; content: ContentBlock[]; usage: Usage }
  isApiErrorMessage?: boolean
  apiError?: string
  uuid: UUID
  timestamp: string
}

type SystemMessage = {
  type: 'system'
  subtype: 'compact_boundary' | 'microcompact_boundary' | ...
  content: string
}

type AttachmentMessage = {
  type: 'attachment'
  attachment: Attachment // 文件变更、计划、技能等
}

// utils/messages.ts
export function normalizeMessagesForAPI(
  messages: Message[], tools: Tools = [],
): (UserMessage | AssistantMessage)[] {
  const availableToolNames = new Set(tools.map(t => t.name))
  // 1. 重排附件消息（向上冒泡直到遇到 tool_result 或 assistant 消息）
  // 2. 过滤虚拟消息（isVirtual = true）
  // 3. 处理 tool_use/tool_result 配对完整性
  // 4. 合并相同 message.id 的消息（并行工具调用的拆分记录）
  // 5. 过滤 system / progress 类型消息（API 不接受）
}

export function createCompactBoundaryMessage(
  trigger: 'manual' | 'auto',
  preTokens: number,
  lastPreCompactMessageUuid?: UUID,
): SystemCompactBoundaryMessage {
  return {
    type: 'system',
    subtype: 'compact_boundary',
    content: 'Conversation compacted',
    compactMetadata: { trigger, preTokens, userContext, messagesSummarized },
  }
}

export function getMessagesAfterCompactBoundary(messages) {
  const boundaryIndex = findLastCompactBoundaryIndex(messages)
  return boundaryIndex === -1 ? messages : messages.slice(boundaryIndex)
}

// utils/context.ts
export const MODEL_CONTEXT_WINDOW_DEFAULT = 200_000

export function getContextWindowForModel(model: string, betas?: string[]): number {
  // 优先级：
  // 1. 环境变量覆盖 (CLAUDE_CODE_MAX_CONTEXT_TOKENS, ant-only)
  // 2. [1m] 后缀 → 1,000,000
  // 3. 模型能力查询 (max_input_tokens)
  // 4. beta 头检查 (CONTEXT_1M_BETA_HEADER)
  // 5. 默认 200,000
}

// utils/tokens.ts
export function tokenCountWithEstimation(messages: readonly Message[]): number {
  // 从后往前找到最后一个有 API usage 数据的助手消息
  let i = messages.length - 1
  while (i >= 0) {
    const usage = getTokenUsage(messages[i])
    if (usage) {
      // 关键：处理并行工具调用的拆分消息（相同 message.id）
      // 向前找到第一个相同 id 的消息，确保所有交错的 tool_result 都被估算
      const responseId = getAssistantMessageId(messages[i])
      if (responseId) {
        let j = i - 1
        while (j >= 0) {
          if (getAssistantMessageId(messages[j]) === responseId) i = j
          else if (getAssistantMessageId(messages[j]) !== undefined) break
          j--
        }
      }
      return getTokenCountFromUsage(usage) +
        roughTokenCountEstimationForMessages(messages.slice(i + 1))
    }
    i--
  }
  return roughTokenCountEstimationForMessages(messages)
}

// services/tokenEstimation.ts
export function roughTokenCountEstimation(content: string, bytesPerToken = 4): number {
  return Math.round(content.length / bytesPerToken)
}

// JSON 更密集，每 2 个字符约 1 个 token
export function bytesPerTokenForFileType(fileExtension: string): number {
  switch (fileExtension) {
    case 'json': case 'jsonl': case 'jsonc': return 2
    default: return 4
  }
}

export async function countMessagesTokensWithAPI(messages, tools): Promise<number | null> {
  // 使用 anthropic.beta.messages.countTokens API
  // 支持 Bedrock 和 Vertex 后端
}

export function calculateContextPercentages(currentUsage, contextWindowSize) {
  const totalInputTokens =
    currentUsage.input_tokens +
    currentUsage.cache_creation_input_tokens +
    currentUsage.cache_read_input_tokens
  const usedPercentage = Math.round((totalInputTokens / contextWindowSize) * 100)
  return { used: clampedUsed, remaining: 100 - clampedUsed }
}

// context.ts
export const getSystemContext = memoize(async () => ({
  gitStatus,      // git 状态快照（会话级别缓存）
  cacheBreaker,   // 缓存破坏注入（调试用）
}))

export const getUserContext = memoize(async () => ({
  claudeMd,       // CLAUDE.md 记忆文件内容
  currentDate,    // 当前日期
}))

// utils/api.ts
// 系统上下文 → 追加到系统提示词末尾
export function appendSystemContext(systemPrompt, context) {
  return [...systemPrompt, Object.entries(context).map(...)].filter(Boolean)
}

// 用户上下文 → 作为首条用户消息注入
export function prependUserContext(messages, context) {
  return [
    createUserMessage({
      content: `<system-reminder>..${context}..</system-reminder>`,
      isMeta: true,  // 不显示给用户
    }),
    ...messages,
  ]
}

// constants/systemPromptSections.ts
// 缓存型：计算一次，整个会话不变
export function systemPromptSection(name: string, compute: ComputeFn)

// 危险型：每轮重新计算，会破坏提示缓存
export function DANGEROUS_uncachedSystemPromptSection(name, compute, reason)

// constants/prompts.ts
export async function getSystemPrompt(tools, model, ...): Promise<string[]> {
  return [
    // --- 静态内容（可跨 org 全局缓存）---
    getSimpleIntroSection(outputStyleConfig),     // 身份定义
    getSimpleSystemSection(),                     // 系统规则
    getSimpleDoingTasksSection(),                 // 任务指令
    getActionsSection(),                          // 操作规范
    getUsingYourToolsSection(enabledTools),        // 工具使用指南
    getSimpleToneAndStyleSection(),               // 语调风格
    getOutputEfficiencySection(),                  // 输出效率

    // === 边界标记 ===
    ...(shouldUseGlobalCacheScope() ? [SYSTEM_PROMPT_DYNAMIC_BOUNDARY] : []),

    // --- 动态内容（每会话变化）---
    ...resolvedDynamicSections,  // memory, env_info, language, MCP 等
  ].filter(s => s !== null)
}

// utils/systemPrompt.ts
export function buildEffectiveSystemPrompt({...}) {
  // 优先级: override > coordinator > agent > custom > default
  // appendSystemPrompt 总是追加在最后
  if (overrideSystemPrompt) return asSystemPrompt([overrideSystemPrompt])
  if (coordinatorMode) return getCoordinatorSystemPrompt()
  if (agentSystemPrompt) return [agentSystemPrompt]
  if (customSystemPrompt) return [customSystemPrompt]
  return defaultSystemPrompt
}

// query.ts
if (feature('HISTORY_SNIP')) {
  const snipResult = snipModule.snipCompactIfNeeded(messagesForQuery)
  messagesForQuery = snipResult.messages
  snipTokensFreed = snipResult.tokensFreed
}

// services/compact/microCompact.ts
const COMPACTABLE_TOOLS = new Set([
  'Read', 'Bash', 'Grep', 'Glob', 'WebSearch', 'WebFetch', 'Edit', 'Write'
])

// 路径 1: 缓存微压缩（cache_edits API）
// 不修改本地消息内容，通过 API 的 cache_edits 删除旧工具结果
// 关键优势：不破坏缓存前缀
async function cachedMicrocompactPath(messages, querySource) {
  const toolsToDelete = mod.getToolResultsToDelete(state)
  if (toolsToDelete.length > 0) {
    pendingCacheEdits = mod.createCacheEditsBlock(state, toolsToDelete)
    return { messages, compactionInfo: { pendingCacheEdits: {...} } }
  }
}

// 路径 2: 基于时间的微压缩
// 当空闲超过阈值时，缓存已冷，直接清空旧工具结果
function maybeTimeBasedMicrocompact(messages, querySource) {
  const gapMinutes = (Date.now() - lastAssistant.timestamp) / 60_000
  if (gapMinutes >= config.gapThresholdMinutes) {
    // 保留最近 N 个，清空其余
    // 替换为 '[Old tool result content cleared]'
  }
}

// query.ts
if (feature('CONTEXT_COLLAPSE') && contextCollapse) {
  const collapseResult = await contextCollapse.applyCollapsesIfNeeded(
    messagesForQuery, toolUseContext, querySource,
  )
  messagesForQuery = collapseResult.messages
}

// services/compact/sessionMemoryCompact.ts
export const DEFAULT_SM_COMPACT_CONFIG = {
  minTokens: 10_000,          // 最少保留 10K token 的原始消息
  minTextBlockMessages: 5,     // 最少保留 5 条文本消息
  maxTokens: 40_000,          // 最多保留 40K token
}

export async function trySessionMemoryCompaction(messages, agentId?, autoCompactThreshold?) {
  // 1. 检查 session memory 文件是否存在且非空
  const sessionMemory = await getSessionMemoryContent()
  if (!sessionMemory || await isSessionMemoryEmpty(sessionMemory)) return null

  // 2. 计算保留消息的起始索引
  const startIndex = calculateMessagesToKeepIndex(messages, lastSummarizedIndex)

  // 3. 确保不拆分 tool_use/tool_result 对
  adjustIndexToPreserveAPIInvariants(messages, startIndex)

  // 4. 用 session memory 内容替代传统 LLM 摘要
  return createCompactionResultFromSessionMemory(
    messages, sessionMemory, messagesToKeep, hookResults, ...
  )
}

// services/compact/compact.ts
export async function compactConversation(messages, context, ...): Promise<CompactionResult> {
  // 1. 执行 PreCompact hooks
  const hookResult = await executePreCompactHooks(...)

  // 2. 构建压缩提示词（9 个结构化部分）
  const compactPrompt = getCompactPrompt(customInstructions)

  // 3. 使用 forked agent 生成摘要（共享主线程的 prompt cache）
  summaryResponse = await streamCompactSummary({...})

  // 4. 处理 prompt-too-long 重试（截断最旧消息，最多 3 次）
  if (summary?.startsWith(PROMPT_TOO_LONG_ERROR_MESSAGE)) {
    const truncated = truncateHeadForPTLRetry(messagesToSummarize, summaryResponse)
  }

  // 5. 清除文件状态缓存
  context.readFileState.clear()

  // 6. 恢复最近读取的文件（最多 5 个，50K token 预算）
  const fileAttachments = await createPostCompactFileAttachments(
    preCompactReadFileState, context, POST_COMPACT_MAX_FILES_TO_RESTORE
  )

  // 7. 重新注入计划、技能、工具信息
  // 8. 执行 SessionStart hooks 和 PostCompact hooks
  // 9. 返回 CompactionResult
}

// query.ts
if ((isWithheld413 || isWithheldMedia) && reactiveCompact) {
  const compacted = await reactiveCompact.tryReactiveCompact({
    hasAttempted: hasAttemptedReactiveCompact,
    messages: messagesForQuery,
    cacheSafeParams: {...},
  })
  if (compacted) {
    const postCompactMessages = buildPostCompactMessages(compacted)
    // 用压缩后的消息替换并重试
    state = { messages: postCompactMessages, ... }
    continue
  }
}

// services/compact/postCompactCleanup.ts
export function runPostCompactCleanup(querySource?: QuerySource): void {
  resetMicrocompactState()        // 重置微压缩状态
  resetContextCollapse()          // 重置上下文折叠（仅主线程）
  getUserContext.cache.clear()    // 清除用户上下文缓存
  resetGetMemoryFilesCache()      // 重置记忆文件缓存
  clearSystemPromptSections()     // 清除系统提示词分区缓存
  clearClassifierApprovals()      // 清除分类器审批
  clearSessionMessagesCache()     // 清除会话消息缓存
}

// utils/api.ts
export function splitSysPromptPrefix(systemPrompt, options?) {
  // 三种模式：
  // 1. MCP 工具存在 → org 级缓存（避免 MCP 指令变化破坏全局缓存）
  // 2. 全局缓存 + 边界标记 → 静态=global, 动态=无缓存
  // 3. 默认 → org 级缓存
  //
  // 返回 SystemPromptBlock[] 带有 cacheScope: 'global' | 'org' | null
}

cache_control: {
  type: 'ephemeral',
  scope: 'global' | 'org',   // global 跨组织共享，org 组织内共享
  ttl: '5m' | '1h'           // 缓存生存时间
}

// compact.ts
const result = await runForkedAgent({
  promptMessages: [summaryRequest],
  cacheSafeParams,          // 传入主线程的 system/tools/context
  canUseTool: createCompactCanUseTool(),
  querySource: 'compact',
  forkLabel: 'compact',
  maxTurns: 1,
  skipCacheWrite: true,
})

// services/api/promptCacheBreakDetection.ts

// Phase 1: 记录提示状态（pre-call）
export function recordPromptState(snapshot: PromptStateSnapshot) {
  // 追踪: systemHash, toolsHash, cacheControlHash,
  //       model, fastMode, betas, effortValue, extraBodyHash
  //       perToolHashes (精确到每个工具的 schema)
}

// Phase 2: 检查响应中的缓存破坏（post-call）
export async function checkResponseForCacheBreak(
  querySource, cacheReadTokens, cacheCreationTokens, messages, ...
) {
  // 检测条件: cache_read_tokens 下降 > 5% 且绝对值 > 2K
  // 排除: TTL 过期 / cacheDeletion / compaction
  // 输出: 详细的变化分析 + diff 文件
}

// 压缩后重置基线
export function notifyCompaction(querySource, agentId?) {
  state.prevCacheReadTokens = null  // 下次不比较
}

// 微压缩后标记
export function notifyCacheDeletion(querySource, agentId?) {
  state.cacheDeletionsPending = true  // 下次跳过检查
}

// services/SessionMemory/sessionMemory.ts
export function shouldExtractMemory(messages: Message[]): boolean {
  // 初始化阈值：达到一定 token 数后开始
  if (!hasMetInitializationThreshold(currentTokenCount)) return false

  // 更新阈值：token 增长 + 工具调用次数双重门控
  const hasMetTokenThreshold = hasMetUpdateThreshold(currentTokenCount)
  const hasMetToolCallThreshold =
    toolCallsSinceLastUpdate >= getToolCallsBetweenUpdates()

  // 在自然对话间歇时触发（最后一轮没有工具调用）
  return (hasMetTokenThreshold && hasMetToolCallThreshold) ||
         (hasMetTokenThreshold && !hasToolCallsInLastTurn)
}

export function initSessionMemory(): void {
  if (!isAutoCompactEnabled()) return
  // 注册为 post-sampling hook
  registerPostSamplingHook(extractSessionMemory)
}

const extractSessionMemory = sequential(async function(context) {
  // 1. 只在主 REPL 线程运行
  if (querySource !== 'repl_main_thread') return

  // 2. 创建/读取 session memory 文件
  const { memoryPath, currentMemory } = await setupSessionMemoryFile(setupContext)

  // 3. 使用 forked agent 运行提取（共享主线程的 prompt cache）
  await runForkedAgent({
    promptMessages: [createUserMessage({ content: userPrompt })],
    cacheSafeParams: createCacheSafeParams(context),
    canUseTool: createMemoryFileCanUseTool(memoryPath),
    querySource: 'session_memory',
    forkLabel: 'session_memory',
  })

  // 4. 记录 lastSummarizedMessageId（用于 SM-compact 确定边界）
  updateLastSummarizedMessageIdIfSafe(messages)
})

// query.ts
async function* queryLoop(params) {
  while (true) {
    let messagesForQuery = [...getMessagesAfterCompactBoundary(messages)]

    // ① 工具结果预算控制
    messagesForQuery = await applyToolResultBudget(messagesForQuery, ...)

    // ② Snip Compact（裁剪最老历史）
    const snipResult = snipModule.snipCompactIfNeeded(messagesForQuery)
    snipTokensFreed = snipResult.tokensFreed

    // ③ MicroCompact（清理旧工具结果）
    const microcompactResult = await deps.microcompact(messagesForQuery, ...)

    // ④ Context Collapse（折叠上下文视图）
    const collapseResult = await contextCollapse.applyCollapsesIfNeeded(...)

    // ⑤ 系统提示词组装
    const fullSystemPrompt = appendSystemContext(systemPrompt, systemContext)

    // ⑥ Auto Compact（SM 压缩 → 传统压缩回退）
    const { compactionResult } = await deps.autocompact(messagesForQuery, ...)

    // ⑦ Blocking Limit 检查
    const { isAtBlockingLimit } = calculateTokenWarningState(
      tokenCountWithEstimation(messagesForQuery) - snipTokensFreed, model
    )

    // ⑧ API 调用（带 prompt cache）
    for await (const message of deps.callModel({
      messages: prependUserContext(messagesForQuery, userContext),
      systemPrompt: fullSystemPrompt,
      ...
    })) {
      // 处理流式响应、tool_use 块、错误恢复...
    }

    // ⑨ 工具执行
    for await (const update of toolUpdates) { ... }

    // ⑩ 附件注入（文件变更、技能发现、记忆预取）
    for await (const attachment of getAttachmentMessages(...)) { ... }

    // ⑪ 循环继续
    state = { messages: [...messagesForQuery, ...assistantMessages, ...toolResults], ... }
  }
}

// services/compact/autoCompact.ts
export function calculateTokenWarningState(tokenUsage, model) {
  const effectiveWindow = getEffectiveContextWindowSize(model)
  // = contextWindow - min(maxOutputTokens, 20K)

  const autoCompactThreshold = effectiveWindow - 13_000   // ~93%
  const warningThreshold = autoCompactThreshold - 20_000
  const errorThreshold = autoCompactThreshold - 20_000
  const blockingLimit = effectiveWindow - 3_000           // ~98%

  return {
    isAboveWarningThreshold,       // UI 显示黄色警告
    isAboveErrorThreshold,         // UI 显示红色警告
    isAboveAutoCompactThreshold,   // 触发自动压缩
    isAtBlockingLimit,             // 阻止 API 调用
  }
}

const MAX_CONSECUTIVE_AUTOCOMPACT_FAILURES = 3

if (tracking?.consecutiveFailures >= MAX_CONSECUTIVE_AUTOCOMPACT_FAILURES) {
  return { wasCompacted: false }  // 停止重试
}

export function stripImagesFromMessages(messages: Message[]): Message[] {
  // image → [image]
  // document → [document]
  // 包括嵌套在 tool_result 中的图片
}

// utils/messages.ts 第 1989-2370 行
export function normalizeMessagesForAPI(messages, tools) {
  // === 步骤 1: 附件重排序 + 虚拟消息过滤 ===
  const reorderedMessages = reorderAttachmentsForAPI(messages)
    .filter(m => !(m.isVirtual))  // 过滤 display-only 消息

  // === 步骤 2: 构建错误→剥离映射 ===
  // PDF/image 过大错误后，从前一个 isMeta 消息中清理对应的 document/image 块
  const stripTargets = new Map<string, Set<string>>()
  // 向后扫描匹配 API 错误与其触发的用户消息

  // === 步骤 3: 类型过滤 ===
  // 只保留: user / assistant / attachment / system(local_command)
  // 过滤: progress / system(非 local_command) / 合成 API 错误

  // === 步骤 4: 逐消息类型处理 ===
  .forEach(message => {
    case 'user':
      // - 剥离 tool_reference 块（tool search 未启用时）
      // - 清理触发错误的 document/image 块
      // 关键: 连续 user 消息合并（Bedrock 兼容性要求）
      if (lastMessage?.type === 'user') {
        result[i] = mergeUserMessages(lastMessage, normalizedMessage)
      }

    case 'assistant':
      // - normalizeToolInputForAPI 标准化工具输入
      // - 规范化工具名（alias → canonical）
      // 关键: 向后扫描合并同 message.id 的 assistant（并行工具调用拆分记录）
      for (let i = result.length - 1; i >= 0; i--) {
        if (msg.message.id === normalizedMessage.message.id) {
          result[i] = mergeAssistantMessages(msg, normalizedMessage)
          return
        }
      }

    case 'attachment':
      // 转为 user 消息，合并到前一个 user
  })

  // === 步骤 5-7: 后处理管道 ===
  const relocated = relocateToolReferenceSiblings(result)          // tool_reference 重定位
  const filtered = filterOrphanedThinkingOnlyMessages(relocated)   // 清理孤立 thinking
  const cleaned = filterTrailingThinkingFromLastAssistant(filtered) // 尾部 thinking
  const nonEmpty = ensureNonEmptyAssistantContent(cleaned)         // 确保非空
  const smooshed = smooshSystemReminderSiblings(nonEmpty)          // SR 合并
  const sanitized = sanitizeErrorToolResultContent(smooshed)       // 错误内容清理
  validateImagesForAPI(sanitized)                                   // 验证图片大小
  return sanitized
}

// utils/toolResultStorage.ts 第 769-909 行
export async function enforceToolResultBudget(messages, state, skipToolNames) {
  // 按 API 级别用户消息分组（模拟 normalizeMessagesForAPI 的合并逻辑）
  const candidatesByMessage = collectCandidatesByMessage(messages)
  const limit = getPerMessageBudgetLimit()

  for (const candidates of candidatesByMessage) {
    // 三路分区：
    // - mustReapply: 之前已替换 → 重新应用缓存的替换（零 I/O，字节相同）
    // - frozen: 之前已看到但未替换 → 永远不替换（保护 prompt cache 前缀）
    // - fresh: 新的 → 可能需要替换
    const { mustReapply, frozen, fresh } = partitionByPriorDecision(candidates, state)

    mustReapply.forEach(c => replacementMap.set(c.toolUseId, c.replacement))

    if (fresh.length === 0) continue  // 之前处理过的消息

    // 跳过 maxResultSizeChars=Infinity 的工具（如 Read）
    const eligible = fresh.filter(c => !shouldSkip(c.toolUseId))

    // 如果 frozen + fresh 总大小超过预算，按大小降序选择最大的进行替换
    const selected = frozenSize + freshSize > limit
      ? selectFreshToReplace(eligible, frozenSize, limit)
      : []

    // 非替换候选同步标记为已看到（保持缓存稳定）
    // 替换候选在 await 后原子化标记
  }

  // 并发持久化到磁盘
  const freshReplacements = await Promise.all(
    toPersist.map(async c => [c, await buildReplacement(c)] as const)
  )
}

// services/compact/compact.ts 第 1136-1396 行
async function streamCompactSummary({messages, summaryRequest, cacheSafeParams, ...}) {
  // === 路径 1: Forked Agent（缓存共享）===
  // 关键约束: 不设置 maxOutputTokens！
  // 因为 fork 通过发送完全相同的 cache-key 参数复用主线程的缓存前缀。
  // 设置 maxOutputTokens 会通过 Math.min(budget, maxOutputTokens-1)
  // 改变 thinking config → 缓存键不匹配 → 缓存失效。
  if (promptCacheSharingEnabled) {
    try {
      const result = await runForkedAgent({
        promptMessages: [summaryRequest],
        cacheSafeParams,       // 包含主线程的 system/tools/context
        querySource: 'compact',
        maxTurns: 1,           // 只生成一轮
        skipCacheWrite: true,  // 不写入缓存（会被压缩后的内容替代）
      })
      if (assistantMsg && !assistantMsg.isApiErrorMessage) {
        return assistantMsg  // 成功：缓存命中
      }
      // 失败：降级到流式路径
    } catch (error) {
      // 异常：降级到流式路径
    }
  }

  // === 路径 2: 独立流式 API 调用（回退）===
  // 这里可以安全设置 maxOutputTokensOverride（不共享缓存）
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    const streamingGen = queryModelWithStreaming({
      systemPrompt: asSystemPrompt(['You are a helpful AI assistant...']),
      thinkingConfig: { type: 'disabled' },  // 压缩不需要 thinking
      tools: [FileReadTool, ...optionalToolSearch],
      options: {
        maxOutputTokensOverride: Math.min(COMPACT_MAX_OUTPUT_TOKENS, ...),
      },
    })
    // ... 消费流式响应 ...
    if (!response && attempt < maxAttempts) {
      await sleep(getRetryDelay(attempt))  // 退避重试
    }
  }
}

// services/SessionMemory/sessionMemory.ts 第 134-181 行
export function shouldExtractMemory(messages) {
  const currentTokenCount = tokenCountWithEstimation(messages)

  // 门控 1: 初始化阈值（只触发一次）
  if (!isSessionMemoryInitialized()) {
    if (!hasMetInitializationThreshold(currentTokenCount)) return false
    markSessionMemoryInitialized()
  }

  // 门控 2: 更新间隔阈值
  // 两个条件必须同时满足：token 增长 AND 工具调用次数
  const hasMetTokenThreshold = hasMetUpdateThreshold(currentTokenCount)
  const hasMetToolCallThreshold =
    toolCallsSinceLastUpdate >= getToolCallsBetweenUpdates()

  // 门控 3: 自然间歇检测
  // 最后一轮没有工具调用 = 对话的自然暂停点
  const hasToolCallsInLastTurn = hasToolCallsInLastAssistantTurn(messages)

  // 组合逻辑:
  // A: token阈值 + 工具调用阈值 → 强制提取
  // B: token阈值 + 无工具调用 → 在自然间歇时提取
  // 重要: token 阈值始终必须满足（防止过于频繁的提取）
  return (hasMetTokenThreshold && hasMetToolCallThreshold) ||
         (hasMetTokenThreshold && !hasToolCallsInLastTurn)
}

# Session Title          → 5-10 词的信息密集标题
# Current State          → 当前正在做什么、待完成任务、下一步
# Task specification     → 用户要求构建什么
# Files and Functions    → 重要文件及其内容
# Workflow               → 常用命令及其执行顺序
# Errors & Corrections   → 错误和修复方法
# Codebase and System Documentation → 系统组件及其关系
# Learnings              → 有效/无效的方法
# Key results            → 用户要求的具体输出
# Worklog                → 逐步操作日志