vault backup: 2026-06-09 23:15:17

claude-code-best/docs/introduction/architecture-overview.md

@@ -1,18 +1,21 @@
 ---
-title: "架构全景 - Claude Code 五层架构详解"
-description: "从交互层到基础设施层，详解 Claude Code 的五层架构设计。基于 src/main.tsx、src/QueryEngine.ts、src/query.ts、src/tools.ts、src/services/api/claude.ts 的源码级数据流分析。"
-keywords: ["Claude Code 架构", "五层架构", "QueryEngine", "Agentic Loop", "数据流"]
+tags: [claude-code, architecture, five-layer, agentic-loop, data-flow, source-analysis]
+create time: 2026-06-09 22:30
 ---
 
-{/* 本章目标：一张图讲清楚整体架构，为后续章节建立坐标系 */}
+# 架构全景 - Claude Code 五层架构详解
 
-## 五层架构
+## 概述
+
+从交互层到基础设施层，Claude Code 分为五个清晰的架构层次。本文基于源码级数据流分析，建立对整体系统的坐标系。
+
+## 正文
+
+### 五层架构
 
 Claude Code 从上到下分为五个层次，每一层职责清晰、边界分明：
 
-<Frame caption="Claude Code 五层架构">
-  <img src="/docs/images/architecture-layers.png" alt="Claude Code 五层架构图" />
-</Frame>
+![Claude Code 五层架构图](/docs/images/architecture-layers.png)
 
 | 层次 | 职责 | 入口源码 | 关键词 |
 |------|------|---------|--------|
@@ -22,21 +25,20 @@ Claude Code 从上到下分为五个层次，每一层职责清晰、边界分
 | **工具层** | AI 的"双手"——读写文件、执行命令 | `src/tools.ts` → `src/Tool.ts` | Tool 接口、MCP |
 | **通信层** | 与 Claude API 的流式通信 | `src/services/api/claude.ts` | Streaming、Provider |
 
-## 一条主数据流的源码追踪
+### 一条主数据流的源码追踪
 
-<Frame caption="核心数据流">
-  <img src="/docs/images/data-flow.png" alt="Claude Code 核心数据流" />
-</Frame>
+![Claude Code 核心数据流](/docs/images/data-flow.png)
 
 整个系统的运转可以浓缩为一条核心数据流，以下是每一步对应的源码路径：
 
-### 1. 用户输入 → REPL
+#### 1. 用户输入 → REPL
 
 `src/screens/REPL.tsx` 是基于 React/Ink 的终端 UI 组件。用户输入经 `processUserInput()`（`src/utils/processUserInput/processUserInput.ts`）处理，支持斜杠命令、文件附件、图片等。
 
-### 2. QueryEngine 编排
+#### 2. QueryEngine 编排
 
 `src/QueryEngine.ts` 是 REPL 与 `query()` 之间的中间层，管理：
+
 - **会话状态**：消息数组、工具权限上下文（`ToolPermissionContext`）、文件历史快照
 - **成本追踪**：`accumulateUsage()` / `getTotalCost()` 累计 token 用量
 - **Transcript 持久化**：`recordTranscript()` 将对话序列化到磁盘，支持 `--resume`
@@ -44,40 +46,39 @@ Claude Code 从上到下分为五个层次，每一层职责清晰、边界分
 
 关键方法：`queryEngine.query()` 构造 `QueryParams`，调用 `query()` 异步生成器。
 
-### 3. Agentic Loop（`src/query.ts`）
+#### 3. Agentic Loop（`src/query.ts`）
 
 `query()` 是一个 `AsyncGenerator`，`while(true)` 循环的每次迭代包含：
 
-```
-① 上下文预处理管道：
-   applyToolResultBudget → snipCompact → microcompact → contextCollapse → autocompact
-
-② 流式 API 调用：
-   deps.callModel() → AsyncGenerator<StreamEvent | Message>
-   收集 assistantMessages[]、toolUseBlocks[]
-
-③ 工具执行：
-   StreamingToolExecutor（并行） 或 runTools（串行）
-   → toolResults[]
-
-④ 终止/继续判定：
-   needsFollowUp ? continue : return { reason }
+```mermaid
+flowchart TD
+    A["上下文预处理管道"] -->|"applyToolResultBudget → snipCompact → microcompact → contextCollapse → autocompact"| B["流式 API 调用"]
+    B -->|"deps.callModel() → AsyncGenerator StreamEvent"| C["收集 assistantMessages 和 toolUseBlocks"]
+    C --> D{"工具执行"}
+    D -->|"并行 StreamingToolExecutor"| E["toolResults"]
+    D -->|"串行 runTools"| E
+    E --> F{"终止/继续判定"}
+    F -->|"needsFollowUp = true"| A
+    F -->|"needsFollowUp = false"| G["返回 reason"]
 ```
 
-完整的状态机通过 `State` 类型（`src/query.ts:207`）在迭代间传递，包含 10 个字段（messages、autoCompactTracking、maxOutputTokensRecoveryCount 等）。
+> [!info] 状态传递
+> 完整的状态机通过 `State` 类型（`src/query.ts:207`）在迭代间传递，包含 10 个字段（messages、autoCompactTracking、maxOutputTokensRecoveryCount 等）。
 
-### 4. 工具层（`src/tools.ts` → `src/Tool.ts`）
+#### 4. 工具层（`src/tools.ts` → `src/Tool.ts`）
 
 `getAllBaseTools()`（`src/tools.ts:195`）组装 50+ 工具列表，经过 `filterToolsByDenyRules()` 权限过滤后传给 API。
 
 每个工具实现 `Tool<Input, Output, Progress>` 接口（`src/Tool.ts:368`），核心方法链：
+
 ```
 validateInput() → canUseTool()（UI 层）→ checkPermissions() → call() → ToolResult
 ```
 
-### 5. 通信层（`src/services/api/claude.ts`）
+#### 5. 通信层（`src/services/api/claude.ts`）
 
 API 客户端支持 7 种 Provider：
+
 - **Anthropic Direct (firstParty)**：默认
 - **AWS Bedrock**：`ANTHROPIC_BEDROCK_BASE_URL`
 - **Google Vertex**：`ANTHROPIC_VERTEX_PROJECT_ID`
@@ -88,24 +89,25 @@ API 客户端支持 7 种 Provider：
 
 `deps.callModel()` 发起流式请求，返回 `BetaRawMessageStreamEvent` 事件流。支持 Prompt Cache（`cache_control`）、thinking blocks、multi-turn tool use。
 
-## 四个核心设计原则
+### 四个核心设计原则
 
-<AccordionGroup>
-  <Accordion title="流式优先 (Streaming-first)">
-    所有 API 通信都是流式的——`deps.callModel()` 返回 AsyncGenerator，用户看到 AI "逐字打出"回答。StreamingToolExecutor 在流式过程中就开始并行执行工具，不等流结束。模型降级（Fallback）时，已收集的 assistantMessages 被标记为 tombstone 并清空，重试整个流式请求。
-  </Accordion>
-  <Accordion title="工具即能力 (Tool as Capability)">
-    每个工具是 `Tool<Input, Output, Progress>` 结构化类型，通过 `buildTool()` 工厂创建。`getTools()` 在每次 API 调用时组装（非全局缓存），因为 `isEnabled()` 可能随运行时状态变化。MCP 工具通过 `mcpInfo` 字段标记来源，支持 server 级别的 blanket deny。
-  </Accordion>
-  <Accordion title="权限即边界 (Permission as Boundary)">
-    每次工具调用经过 `validateInput() → checkPermissions()` 双重检查。权限规则从 5 个来源汇聚（session → project → user → managed → default），支持工具名、命令模式、路径前缀等匹配方式。Plan Mode 通过 `prepareContextForPlanMode()` 切换为只读模式，退出时自动恢复。
-  </Accordion>
-  <Accordion title="上下文即记忆 (Context as Memory)">
-    System Prompt 由 `fetchSystemPromptParts()` 动态组装，包含 CLAUDE.md、git 状态、日期、MCP 服务器列表。Auto-compact 在每轮迭代前评估 token 阈值，超出时触发压缩。压缩后的摘要通过 `buildPostCompactMessages()` 替换原始消息，`taskBudgetRemaining` 跨压缩边界累计。
-  </Accordion>
-</AccordionGroup>
+#### 流式优先 (Streaming-first)
 
-## 入口与引导
+所有 API 通信都是流式的——`deps.callModel()` 返回 AsyncGenerator，用户看到 AI "逐字打出"回答。StreamingToolExecutor 在流式过程中就开始并行执行工具，不等流结束。模型降级（Fallback）时，已收集的 assistantMessages 被标记为 tombstone 并清空，重试整个流式请求。
+
+#### 工具即能力 (Tool as Capability)
+
+每个工具是 `Tool<Input, Output, Progress>` 结构化类型，通过 `buildTool()` 工厂创建。`getTools()` 在每次 API 调用时组装（非全局缓存），因为 `isEnabled()` 可能随运行时状态变化。MCP 工具通过 `mcpInfo` 字段标记来源，支持 server 级别的 blanket deny。
+
+#### 权限即边界 (Permission as Boundary)
+
+每次工具调用经过 `validateInput() → checkPermissions()` 双重检查。权限规则从 5 个来源汇聚（session → project → user → managed → default），支持工具名、命令模式、路径前缀等匹配方式。Plan Mode 通过 `prepareContextForPlanMode()` 切换为只读模式，退出时自动恢复。
+
+#### 上下文即记忆 (Context as Memory)
+
+System Prompt 由 `fetchSystemPromptParts()` 动态组装，包含 CLAUDE.md、git 状态、日期、MCP 服务器列表。Auto-compact 在每轮迭代前评估 token 阈值，超出时触发压缩。压缩后的摘要通过 `buildPostCompactMessages()` 替换原始消息，`taskBudgetRemaining` 跨压缩边界累计。
+
+### 入口与引导
 
 | 入口 | 文件 | 说明 |
 |------|------|------|
@@ -113,3 +115,8 @@ API 客户端支持 7 种 Provider：
 | 命令定义 | `src/main.tsx` | Commander.js 解析参数，初始化 auth/analytics/policy |
 | 一次性初始化 | `src/entrypoints/init.ts` | 遥测配置、信任对话框 |
 | 管道模式 | `src/main.tsx` `-p` flag | `echo "say hello" \| bun run dev -p` |
+
+## 关联笔记
+
+- [[what-is-claude-code]]
+- [[why-this-whitepaper]]

claude-code-best/docs/introduction/what-is-claude-code.md

@@ -1,15 +1,17 @@
 ---
-title: "什么是 Claude Code - Terminal Native Agentic Coding System"
-description: "Claude Code 是运行在终端中的 agentic coding system，直接在你的项目目录中读代码、改文件、跑命令、调试程序。了解它的技术定位、架构差异和核心能力。"
-keywords: ["Claude Code", "AI 编程助手", "Agentic Coding", "终端 AI", "CLI AI"]
-og:image: "https://ccb.agent-aura.top/docs/images/og-cover.png"
+tags: [claude-code, agentic-coding, architecture, CLI, terminal]
+create time: 2026-06-09 22:30
 ---
 
-## 一句话定义
+# 什么是 Claude Code
 
-Claude Code 是一个**运行在本地终端中的 agentic coding system**。它不是给建议的聊天机器人——它直接在你的项目目录中读代码、改文件、跑命令、调试程序，拥有完整的 shell 能力。
+## 概述
 
-## 技术定位：terminal-native agentic system
+Claude Code 是一个运行在本地终端中的 agentic coding system。它不给建议，而是直接在你的项目目录中读代码、改文件、跑命令、调试程序——拥有完整的 shell 能力。
+
+## 正文
+
+### 技术定位：terminal-native agentic system
 
 理解 Claude Code 的关键在于三个词：
 
@@ -28,55 +30,44 @@ Claude Code 是一个**运行在本地终端中的 agentic coding system**。它
 | Aider | CLI chat → git patch | 本地进程 | 文件操作为主 |
 | ChatGPT / Claude.ai | Cloud chat + artifacts | 浏览器/云端 | 沙箱容器 |
 
-核心差异：Claude Code 拥有**完整的 shell 访问权**——这意味着它可以做任何你在终端里能做的事，但也需要对应的安全机制来约束这个能力。
+> [!info] 核心差异
+> Claude Code 拥有**完整的 shell 访问权**——这意味着它可以做任何你在终端里能做的事，但也需要对应的安全机制来约束这个能力。
 
-## 端到端示例：从输入到输出
+### 端到端示例：从输入到输出
 
 当你在终端中输入 `bun run dev 有个 TypeScript 报错，帮我修一下` 时，系统发生了什么？
 
-```
-┌─────────────────────────────────────────────────────────┐
-│ 1. 入口层 (cli.tsx → main.tsx)                          │
-│    feature() = false, MACRO 注入, 启动 Commander.js CLI  │
-├─────────────────────────────────────────────────────────┤
-│ 2. 交互层 (REPL.tsx — React/Ink)                        │
-│    PromptInput 捕获用户输入 → UserMessage 加入会话       │
-├─────────────────────────────────────────────────────────┤
-│ 3. 编排层 (QueryEngine.ts)                               │
-│    管理 turn 生命周期、token 预算、compaction 触发       │
-├─────────────────────────────────────────────────────────┤
-│ 4. 核心循环 (query.ts — Agentic Loop)                    │
-│    组装上下文 → 调 API → 收流式响应 → 解析工具调用      │
-│    → 权限检查 → 执行工具 → 结果回传 → 再次调 API → 循环 │
-├─────────────────────────────────────────────────────────┤
-│ 5. 工具执行 (BashTool.call / FileEditTool.call / ...)    │
-│    实际执行: 读文件、运行命令、搜索代码...               │
-├─────────────────────────────────────────────────────────┤
-│ 6. 通信层 (claude.ts → Anthropic API)                    │
-│    流式 HTTP, 支持 Bedrock/Vertex/Foundry 等 7 种 provider      │
-└─────────────────────────────────────────────────────────┘
+```mermaid
+flowchart TD
+    A["入口层 cli.tsx → main.tsx"] -->|"feature() = false, MACRO 注入, 启动 Commander.js CLI"| B["交互层 REPL.tsx — React/Ink"]
+    B -->|"PromptInput 捕获用户输入 → UserMessage 加入会话"| C["编排层 QueryEngine.ts"]
+    C -->|"管理 turn 生命周期, token 预算, compaction 触发"| D["核心循环 query.ts — Agentic Loop"]
+    D -->|"组装上下文 → 调 API → 收流式响应 → 解析工具调用"| E["工具执行 BashTool / FileEditTool / ..."]
+    E -->|"执行结果回传 → 再次调 API → 循环"| D
+    D -->|"流式 HTTP, 支持 7 种 provider"| F["通信层 claude.ts → Anthropic API"]
 ```
 
 具体到这个报错修复场景，一次典型的 agentic loop 可能包含多轮工具调用：
 
 | Turn | AI 决策 | 工具调用 | 结果 |
 |------|---------|----------|------|
-| 1 | 先看报错信息 | `Bash("bun run dev 2>&1 | head -30")` | TypeScript 错误输出 |
+| 1 | 先看报错信息 | `Bash("bun run dev 2>&1 \| head -30")` | TypeScript 错误输出 |
 | 2 | 定位到文件 | `Read("src/utils/foo.ts")` | 源代码内容 |
 | 3 | 搜索相关类型定义 | `Grep("interface Foo", "src/")` | 类型定义位置 |
 | 4 | 修复代码 | `FileEdit(old, new)` | 代码已修改 |
-| 5 | 验证修复 | `Bash("bun run dev 2>&1 | head -10")` | 编译通过 |
+| 5 | 验证修复 | `Bash("bun run dev 2>&1 \| head -10")` | 编译通过 |
 
-每一步都是 AI 自主决策的——它决定用哪个工具、传什么参数、何时停止。这就是 "agentic" 的含义。
+> [!question] 思考
+> 每一步都是 AI 自主决策的——它决定用哪个工具、传什么参数、何时停止。这就是 "agentic" 的含义。如果你来设计这个循环，你会在哪些环节加入"人类审批"？
 
-## 它不是什么
+### 它不是什么
 
 - **不是 IDE 插件**：没有图形界面，不依赖 VS Code 或任何 IDE
 - **不是 API wrapper**：它有自己的工具系统、权限模型、上下文工程、会话管理
 - **不是聊天机器人**：输出不是纯文本，而是实际的文件修改、命令执行
 - **不是无脑执行器**：每个敏感操作都有权限检查和用户确认环节
 
-## 启动入口解剖
+### 启动入口解剖
 
 真正的代码入口是 `src/entrypoints/cli.tsx`，它做了三件关键的事：
 
@@ -99,7 +90,7 @@ globalThis.INTERFACE_TYPE = "stdio";   // 标准 I/O 交互
 3. 加载工具列表（`getTools()`）
 4. 启动 REPL（`launchRepl()`）或管道模式（`-p`）
 
-## 为什么选择终端
+### 为什么选择终端
 
 终端不是限制，而是选择。它带来了独特的能力：
 
@@ -108,4 +99,10 @@ globalThis.INTERFACE_TYPE = "stdio";   // 标准 I/O 交互
 - **可组合性**：管道模式（`echo "..." | claude -p`）允许嵌入 CI/CD 和自动化流程
 - **低延迟**：没有 Electron 开销，React/Ink 渲染的 TUI 响应极快
 
-代价是用户需要适应命令行界面——但也正因如此，它吸引的是需要**真正掌控开发环境**的开发者。
+> [!tip] 代价与收获
+> 用户需要适应命令行界面——但也正因如此，它吸引的是需要**真正掌控开发环境**的开发者。
+
+## 关联笔记
+
+- [[architecture-overview]]
+- [[why-this-whitepaper]]

claude-code-best/docs/introduction/why-this-whitepaper.md

@@ -1,28 +1,30 @@
 ---
-title: "为什么写这份白皮书 - Claude Code 逆向工程分析"
-description: "对 Anthropic 官方 Claude Code CLI 的逆向工程分析白皮书。通过反编译 TypeScript 单文件 bundle，深入解析运行时行为与源码结构。"
-keywords: ["Claude Code", "逆向工程", "白皮书", "反编译", "TypeScript"]
+tags: [claude-code, reverse-engineering, whitepaper, architecture, security, context-engineering]
+create time: 2026-06-09 22:30
 ---
 
-## 这份白皮书是什么
+# 为什么写这份白皮书
+
+## 概述
+
+本文是对 Anthropic 官方 Claude Code CLI 的逆向工程分析。通过反编译 TypeScript 单文件 bundle，深入解析其运行时行为与源码结构，解构一个生产级 agentic system 的设计决策。
+
+## 正文
+
+### 这份白皮书是什么
 
 这是对 Anthropic 官方发布的 **Claude Code CLI** 的**逆向工程分析**。
 
 源码经过反编译处理（TypeScript 单文件 bundle 逆向），保留了核心功能模块，但包含大量 `unknown`/`never`/`{}` 类型错误——这些不影响 Bun 运行时执行，但意味着我们的分析基于运行时行为 + 残留源码结构，而非原始源码。
 
-**这不是：**
-- 官方文档或使用教程
-- API 参考手册
-- Claude Code 的功能推销
+> [!warning] 边界声明
+> **这不是**官方文档、使用教程或 API 参考手册，也不是 Claude Code 的功能推销。
+>
+> **这是一个**生产级 agentic system 的架构解构——每个设计决策背后的"为什么"，以及可复用的工程模式：agentic loop、工具抽象、上下文工程、安全纵深防御。
 
-**这是：**
-- 一个生产级 agentic system 的架构解构
-- 每个设计决策背后的"为什么"
-- 可复用的工程模式：agentic loop、工具抽象、上下文工程、安全纵深防御
+### 逆向过程中最精妙的设计决策
 
-## 逆向过程中最精妙的设计决策
-
-### 1. Agentic Loop 的自愈能力
+#### 1. Agentic Loop 的自愈能力
 
 `src/query.ts` 实现的核心循环不是简单的"发请求→收响应"。它是一个**自愈的状态机**：
 
@@ -31,9 +33,10 @@ keywords: ["Claude Code", "逆向工程", "白皮书", "反编译", "TypeScript"
 - 对话过长触发 compaction → 压缩历史后无缝继续
 - 用户中断 → 生成 `UserInterruptionMessage` 让 AI 理解发生了什么
 
-这不是"if-else 堆叠"，而是让 AI 自己根据上下文决定下一步——即使发生了意外。
+> [!tip] 设计洞察
+> 这不是"if-else 堆叠"，而是让 AI 自己根据上下文决定下一步——即使发生了意外。自愈的本质是把异常处理的决策权交给了 AI 本身。
 
-### 2. 上下文工程的分层策略
+#### 2. 上下文工程的分层策略
 
 AI 没有真正的"记忆"，Claude Code 通过精心分层营造了这个幻觉：
 
@@ -47,16 +50,17 @@ AI 没有真正的"记忆"，Claude Code 通过精心分层营造了这个幻觉
 
 `src/context.ts` 组装 System Prompt 时的策略是：**不变内容在前、变化内容在后**——这利用了 API 的缓存机制，前缀不变时可以复用缓存 token。
 
-### 3. 工具系统的权限双轨制
+#### 3. 工具系统的权限双轨制
 
 `packages/builtin-tools/src/tools/BashTool/shouldUseSandbox.ts` 展示了一个精巧的双重安全模型：
 
 - **应用层**：权限规则决定"能不能执行"（白名单/黑名单/用户确认）
 - **OS 层**：沙箱决定"执行时能做什么"（文件系统/网络/进程隔离）
 
-两层的信任假设不同：应用层信任用户配置，OS 层不信任任何东西。即使 AI 绕过了应用层权限（理论上不可能，但纵深防御），OS 层沙箱仍然限制实际危害。
+> [!warning] 纵深防御
+> 两层的信任假设不同：应用层信任用户配置，OS 层不信任任何东西。即使 AI 绕过了应用层权限（理论上不可能，但纵深防御），OS 层沙箱仍然限制实际危害。
 
-### 4. Feature Flag 的全局开关
+#### 4. Feature Flag 的全局开关
 
 `src/entrypoints/cli.tsx` 中一行代码决定了整个系统的行为：
 
@@ -68,7 +72,7 @@ const feature = (_name: string) => false;
 
 这是一个**渐进式发布架构**：同一个代码库，通过 feature flag 控制功能可见性，而不需要维护多个分支。
 
-### 5. Compaction 的分档策略
+#### 5. Compaction 的分档策略
 
 `src/services/compact/` 实现了三种压缩策略：
 
@@ -76,46 +80,47 @@ const feature = (_name: string) => false;
 - **Auto-compact**：对话 token 接近上限时，自动压缩历史
 - **Reactive-compact**：API 返回 token 超限错误时，紧急压缩后重试
 
-这不是简单的"砍掉旧消息"——而是用 AI 自身来总结之前的对话，保留语义信息。压缩后插入一条 `TombstoneMessage` 标记边界。
+> [!tip] 语义保留
+> 这不是简单的"砍掉旧消息"——而是用 AI 自身来总结之前的对话，保留语义信息。压缩后插入一条 `TombstoneMessage` 标记边界。
 
-## 阅读路线图
+### 阅读路线图
 
 推荐的阅读顺序，每章解决一个核心问题：
 
-```
-什么是 Claude Code (你在读的)          ← 建立直觉
-    │
-    ├── 架构全景                       ← 五层架构 + 数据流
-    │
-    ├── 安全体系                       ← 信任与控制
-    │   ├── 权限模型                   ← 应用层安全
-    │   ├── 沙箱机制                   ← OS 层安全
-    │   └── Plan Mode                  ← 用户主导模式
-    │
-    ├── 对话引擎                       ← AI 如何思考
-    │   ├── Agentic Loop               ← 核心循环
-    │   ├── 流式响应                   ← 实时通信
-    │   └── 多轮对话                   ← 上下文管理
-    │
-    ├── 上下文工程                     ← 记忆与预算
-    │   ├── System Prompt              ← 上下文组装
-    │   ├── Token 预算                 ← 预算管理
-    │   └── 项目记忆                   ← 跨会话持久化
-    │
-    ├── 工具系统                       ← AI 的双手
-    │   ├── 工具概览                   ← 统一接口
-    │   ├── Shell 执行                 ← Bash 工具
-    │   └── 搜索与导航                 ← Glob/Grep
-    │
-    └── Agent 与扩展                   ← 能力扩展
-        ├── 子 Agent                   ← 并行任务
-        ├── 自定义 Agent               ← 用户定义
-        └── MCP 协议                   ← 外部工具接入
+```mermaid
+flowchart TD
+    A["什么是 Claude Code"] -->|"建立直觉"| B["架构全景"]
+    B -->|"五层架构 + 数据流"| C["安全体系"]
+    C --> D["信任与控制"]
+    D --> D1["权限模型 — 应用层安全"]
+    D --> D2["沙箱机制 — OS 层安全"]
+    D --> D3["Plan Mode — 用户主导模式"]
+    B --> E["对话引擎"]
+    E --> E1["Agentic Loop — 核心循环"]
+    E --> E2["流式响应 — 实时通信"]
+    E --> E3["多轮对话 — 上下文管理"]
+    B --> F["上下文工程"]
+    F --> F1["System Prompt — 上下文组装"]
+    F --> F2["Token 预算 — 预算管理"]
+    F --> F3["项目记忆 — 跨会话持久化"]
+    B --> G["工具系统"]
+    G --> G1["工具概览 — 统一接口"]
+    G --> G2["Shell 执行 — Bash 工具"]
+    G --> G3["搜索与导航 — Glob/Grep"]
+    B --> H["Agent 与扩展"]
+    H --> H1["子 Agent — 并行任务"]
+    H --> H2["自定义 Agent — 用户定义"]
+    H --> H3["MCP 协议 — 外部工具接入"]
 ```
 
-## 适合谁读
+### 适合谁读
 
 - **AI Agent 开发者**：想理解生产级 agentic system 的架构模式
 - **安全工程师**：对 AI 操作真实环境时的信任模型感兴趣
 - **工具构建者**：正在构建类似的 coding assistant 或 CLI 工具
 - **好奇心驱动的开发者**：想知道"AI 编程助手到底怎么工作的"
+
+## 关联笔记
+
+- [[what-is-claude-code]]
+- [[architecture-overview]]