2.1 CLI 引导流程：入口点、参数解析与模式选择

源码版本：v2.1.88（SourceMap 还原）
对应章节：《Claude Code 架构解密》第2章（p.38-46）
核心源码：entrypoints/cli.tsx（302行）、main.tsx（3900+行）、entrypoints/init.ts、bootstrap/state.ts、setup.ts、replLauncher.tsx

---

导语：一个 CLI 工具为什么需要复杂的启动设计？

传统 CLI 工具的启动是一条线性管线：解析参数 → 加载配置 → 执行逻辑 → 打印输出 → 退出。但 Claude Code 不是一个传统 CLI——它是一个成熟的 AI Agent 系统，面临四大挑战：

挑战	原书描述	源码佐证
模式爆炸	十余种运行模式共享同一个入口二进制	cli.tsx 中 12+ 个 fast-path 分支
信任边界	项目级配置文件可能被篡改	init.ts 信任前/信任后两阶段
循环依赖	200+ 模块引用全局状态	bootstrap/state.ts DAG 叶子约束
冷启动性能	claude --version 必须 <5ms	cli.tsx L1 零依赖快速路径

原书将解决方案概括为"分层路由器"和"四组件接力"。现在有了源码，让我们逐行验证这些设计决策。

---

一、四层启动路由器：entrypoints/cli.tsx

1.1 源码结构总览

cli.tsx 是真正的入口文件——npm 包的 bin 字段指向它，void main() 在文件末尾被调用。整个文件只有 302 行，但它决定了 Claude Code 的全部启动路径。

用户输入: $ claude [args]
         ↓
    entrypoints/cli.tsx  ← 启动路由器（Bootstrap Router）
         ↓
  ┌──────┬──────┬──────┬──────────┐
  │  L0  │  L1  │  L2  │   L3     │
  │环境  │零依赖│功能  │完整CLI   │
  │预处理│快速  │分流  │启动      │
  └──────┴──────┴──────┴──────────┘

1.2 L0：环境预处理（顶层 side-effect）

原书提到 L0 “在任何业务逻辑之前处理运行时环境的修复和配置”。源码中，这些操作以顶层副作用的形式出现在所有 import 之前：

// cli.tsx 第1-26行 —— 顶层 side-effect，在所有 import 之前执行

// 1. corepack 自动固定修复
process.env.COREPACK_ENABLE_AUTO_PIN = '0';

// 2. CCR 环境堆内存调整（容器有 16GB）
if (process.env.CLAUDE_CODE_REMOTE === 'true') {
  const existing = process.env.NODE_OPTIONS || '';
  process.env.NODE_OPTIONS = existing 
    ? `${existing} --max-old-space-size=8192` 
    : '--max-old-space-size=8192';
}

// 3. 消融基线（Ant-only，feature flag DCE）
if (feature('ABLATION_BASELINE') && process.env.CLAUDE_CODE_ABLATION_BASELINE) {
  for (const k of ['CLAUDE_CODE_SIMPLE', 'CLAUDE_CODE_DISABLE_THINKING', ...]) {
    process.env[k] ??= '1';
  }
}

源码洞察：L0 的三个操作都是零依赖的——只修改 process.env，不 import 任何模块。这是"零成本"承诺的代码级保证。

1.3 L1：零依赖快速路径——--version

原书描述：“直接读取 package.json 中的版本号并输出，不触碰任何模块。预期耗时约 5 毫秒。”

// cli.tsx 第33-42行
async function main(): Promise<void> {
  const args = process.argv.slice(2);

  // Fast-path for --version/-v: zero module loading needed
  if (args.length === 1 && (args[0] === '--version' || args[0] === '-v' || args[0] === '-V')) {
    // MACRO.VERSION 是构建时内联的常量
    console.log(`${MACRO.VERSION} (Claude Code)`);
    return;  // 直接退出，不加载任何模块
  }

源码验证：

• ✅ args.length === 1：严格匹配，claude --version --debug 不会走快速路径
• ✅ MACRO.VERSION：构建时内联，不需要读取 package.json 文件
• ✅ return 后没有任何模块加载——零 import

原书说"5毫秒"，源码证实了这一点：没有 enableConfigs()，没有 profileCheckpoint()，没有 await import()，只有一个 console.log。

1.4 L2：功能分流——12 条 fast-path

原书列出了 MCP/Bridge/Daemon/BG/Templates 等分支，并说"每个分支通过 await import(...) 动态导入，互不干扰"。源码揭示了完整的 12 条 fast-path：

#	触发条件	动态导入的模块	特有前置检查
1	--dump-system-prompt	constants/prompts.js	Ant-only (feature flag DCE)
2	--claude-in-chrome-mcp	claudeInChrome/mcpServer.js	无
3	--chrome-native-host	claudeInChrome/chromeNativeHost.js	无
4	--computer-use-mcp	computerUse/mcpServer.js	Ant-only (CHICAGO_MCP)
5	--daemon-worker	daemon/workerRegistry.js	Ant-only (DAEMON)
6	remote-control/rc/bridge	bridge/bridgeMain.js	OAuth 认证 + GrowthBook gate + 版本检查 + 策略限制
7	daemon	daemon/main.js	Ant-only (DAEMON)
8	ps/logs/attach/kill/--bg	cli/bg.js	Ant-only (BG_SESSIONS)
9	new/list/reply	cli/handlers/templateJobs.js	Ant-only (TEMPLATES)
10	environment-runner	environment-runner/main.js	Ant-only (BYOC)
11	self-hosted-runner	self-hosted-runner/main.js	Ant-only
12	--worktree --tmux	utils/worktree.js	isWorktreeModeEnabled() 检查

以 Bridge 模式为例，源码展示了原书提到的"特有前置检查"：

// cli.tsx 第112-161行 —— Bridge fast-path
if (feature('BRIDGE_MODE') && (args[0] === 'remote-control' || ...)) {
  profileCheckpoint('cli_bridge_path');
  
  // 前置检查 1: 启用配置系统
  const { enableConfigs } = await import('../utils/config.js');
  enableConfigs();
  
  // 前置检查 2: Bridge 可用性检查（GrowthBook gate）
  const { getBridgeDisabledReason, checkBridgeMinVersion } = await import('../bridge/bridgeEnabled.js');
  
  // 前置检查 3: OAuth 认证（必须在 GrowthBook 检查之前）
  const { getClaudeAIOAuthTokens } = await import('../utils/auth.js');
  if (!getClaudeAIOAuthTokens()?.accessToken) {
    exitWithError(BRIDGE_LOGIN_ERROR);
  }
  
  // 前置检查 4: 策略限制
  const { waitForPolicyLimitsToLoad, isPolicyAllowed } = await import('../services/policyLimits/index.js');
  await waitForPolicyLimitsToLoad();
  if (!isPolicyAllowed('allow_remote_control')) {
    exitWithError("Error: Remote Control is disabled by your organization's policy.");
  }
  
  await bridgeMain(args.slice(1));
  return;
}

源码洞察：原书说"每个功能分支的前置条件各不相同"——源码证实 Bridge 分支有 4 层前置检查（配置 → GrowthBook → OAuth → 策略），这正是手动路由优于框架声明式注册的原因。

1.5 L3：完整 CLI 启动

所有 fast-path 都不匹配时，才加载完整的 main.tsx：

// cli.tsx 第287-299行
const { startCapturingEarlyInput } = await import('../utils/earlyInput.js');
startCapturingEarlyInput();
profileCheckpoint('cli_before_main_import');
const { main: cliMain } = await import('../main.js');  // 动态导入 main.tsx
profileCheckpoint('cli_after_main_import');
await cliMain();
profileCheckpoint('cli_after_main_complete');

注意：startCapturingEarlyInput() 在 main.tsx 加载之前启动——这是因为 main.tsx 有 ~135ms 的 import 开销，在此期间用户的键盘输入不应丢失。

1.6 构建时 Feature Flag：死代码消除

原书提到 feature() 函数"在构建时内联为布尔常量"。源码中大量使用：

// cli.tsx 中所有 Ant-only 的 fast-path 都被 feature() 包裹
if (feature('DAEMON') && args[0] === 'daemon') { ... }       // 外部构建中完全消除
if (feature('BRIDGE_MODE') && args[0] === 'bridge') { ... }  // 外部构建中完全消除
if (feature('BG_SESSIONS') && args[0] === 'ps') { ... }      // 外部构建中完全消除

源码中有一个有趣的细节——"external" === 'ant' 永远为 false，说明当前还原的是外部构建版本：

// main.tsx 第3816行
if ("external" === 'ant') {  // 永远为 false —— 所有 Ant-only 选项被编译器消除
  program.addOption(new Option('--delegate-permissions', '[ANT-ONLY]...'));
}

---

二、main.tsx：命令编排器

2.1 四组件接力模型

原书将启动链概括为四组件接力：

cli.tsx → main.tsx → init.ts → bootstrap/state.ts
路由器    编排器     初始化中枢  状态锚点

main.tsx 的核心职责是：构建 Commander.js 命令树 → preAction 初始化 → action 执行业务。

2.2 模块级 side-effect：启动性能的关键

main.tsx 文件开头的注释揭示了一个关键的启动优化策略：

// main.tsx 第1-20行
// These side-effects must run before all other imports:
// 1. profileCheckpoint marks entry before heavy module evaluation begins
// 2. startMdmRawRead fires MDM subprocesses (plutil/reg query) so they run in
//    parallel with the remaining ~135ms of imports below
// 3. startKeychainPrefetch fires both macOS keychain reads (OAuth + legacy API
//    key) in parallel — otherwise reads them sequentially (~65ms on every macOS startup)

profileCheckpoint('main_tsx_entry');
startMdmRawRead();         // MDM 子进程并行启动
startKeychainPrefetch();   // Keychain 读取并行启动

源码洞察：这不是普通的 import 顺序——而是故意将耗时的 I/O 操作提前到模块加载阶段，让它们与 ~135ms 的 import 阶段并行执行。这是"重叠 I/O 与 CPU"优化原则的精确应用。

2.3 Commander 命令树构建

run() 函数（第884行）构建了完整的 Commander 命令树：

async function run(): Promise<CommanderCommand> {
  const program = new CommanderCommand()
    .configureHelp(createSortedHelpConfig())
    .enablePositionalOptions();
  
  // preAction hook：在执行任何命令前先完成初始化
  program.hook('preAction', async thisCommand => {
    profileCheckpoint('preAction_start');
    
    // 1. 等待模块加载阶段启动的异步操作完成
    await Promise.all([ensureMdmSettingsLoaded(), ensureKeychainPrefetchCompleted()]);
    
    // 2. 执行初始化中枢
    await init();
    
    // 3. 设置进程标题
    process.title = 'claude';
    
    // 4. 挂载日志 sink
    const { initSinks } = await import('./utils/sinks.js');
    initSinks();
    
    // 5. 处理 --plugin-dir
    const pluginDir = thisCommand.getOptionValue('pluginDir');
    if (Array.isArray(pluginDir) && pluginDir.length > 0) {
      setInlinePlugins(pluginDir);
    }
    
    // 6. 运行迁移
    runMigrations();
    
    // 7. 加载远程管理设置和策略限制（非阻塞）
    void loadRemoteManagedSettings();
    void loadPolicyLimits();
  });
  
  program
    .name('claude')
    .description('Claude Code - starts an interactive session by default, use -p/--print for non-interactive output')
    .argument('[prompt]', 'Your prompt', String)
    // ... 50+ 个 .option() 调用 ...
    .action(async (prompt, options) => { ... });

原书 vs 源码对比：

原书描述	源码实际情况
“preAction hook 触发 init()”	✅ 第907行 program.hook('preAction', ...)
“action handler 执行业务逻辑”	✅ 第1006行 .action(async (prompt, options) => { ... })
“预期耗时 100-200 毫秒”	⚠️ 源码显示 preAction 有 7 个步骤，仅 init() 就涉及大量子系统

2.4 命令行参数全景

源码中 program 对象注册了 50+ 个选项，远超原书概括的"十余种模式"。按功能分类：

交互模式控制：

.option('-p, --print', 'Print response and exit (useful for pipes)')
.option('--bare', 'Minimal mode: skip hooks, LSP, plugin sync, attribution...')
.option('--output-format <format>', '...choices(["text", "json", "stream-json"])')
.option('--input-format <format>', '...')

会话管理：

.option('-c, --continue', 'Continue the most recent conversation')
.option('-r, --resume [value]', 'Resume a conversation by session ID')
.option('--fork-session', 'When resuming, create a fork...')
.option('--session-id <uuid>', 'Use a specific session ID')
.option('--no-session-persistence', 'Disable session persistence')

模型与权限：

.option('--model <model>', 'Model for the current session')
.option('--effort <level>', 'Effort level (low, medium, high, max)')
.option('--permission-mode <mode>', 'Permission mode to use')
.option('--allowedTools, --allowed-tools <tools...>', '...')
.option('--disallowedTools, --disallowed-tools <tools...>', '...')

System Prompt 自定义：

.addOption(new Option('--system-prompt <prompt>', '...'))
.addOption(new Option('--system-prompt-file <file>', '...'))
.addOption(new Option('--append-system-prompt <prompt>', '...'))
.addOption(new Option('--append-system-prompt-file <file>', '...'))

扩展与集成：

.option('--mcp-config <configs...>', 'Load MCP servers from JSON files')
.option('--add-dir <directories...>', 'Additional directories')
.option('--ide', 'Automatically connect to IDE')
.option('--plugin-dir <path>', 'Load plugins from a directory')
.option('--agents <json>', 'JSON object defining custom agents')

Feature Flag 控制的 Ant-only 选项（外部构建中被 DCE 消除）：

if (feature('PROACTIVE') || feature('KAIROS')) {
  program.addOption(new Option('--proactive', 'Start in proactive autonomous mode'));
}
if (feature('KAIROS')) {
  program.addOption(new Option('--assistant', 'Force assistant mode').hideHelp());
}
if (feature('KAIROS') || feature('KAIROS_CHANNELS')) {
  program.addOption(new Option('--channels <servers...>', '...').hideHelp());
}

---

三、模式选择：交互式 vs 非交互式

3.1 模式判别的时机

原书提到"交互式 REPL 和完整命令行模式"是 L3 的主要场景。源码揭示了模式判别的精确位置——在 main() 函数开头、init() 之前：

// main.tsx 第797-812行
// Check for -p/--print and --init-only flags early to set isInteractiveSession 
// before init() — telemetry initialization calls auth functions that need this flag
const cliArgs = process.argv.slice(2);
const hasPrintFlag = cliArgs.includes('-p') || cliArgs.includes('--print');
const hasInitOnlyFlag = cliArgs.includes('--init-only');
const hasSdkUrl = cliArgs.some(arg => arg.startsWith('--sdk-url'));
const isNonInteractive = hasPrintFlag || hasInitOnlyFlag || hasSdkUrl || !process.stdout.isTTY;

if (isNonInteractive) {
  stopCapturingEarlyInput();  // 非交互模式不需要捕获早期输入
}

const isInteractive = !isNonInteractive;
setIsInteractive(isInteractive);  // 写入全局状态

源码洞察：模式判别有四个条件，缺一不可：

1. -p / --print 标志
2. --init-only 标志
3. --sdk-url 标志
4. !process.stdout.isTTY——管道/重定向时自动切换到非交互模式

第 4 条是隐式模式切换——echo "hello" | claude 会自动进入 print 模式，无需 -p 标志。

3.2 Client Type 判定

除了交互/非交互的二分法，源码还有更细粒度的 client type 判定：

// main.tsx 第818-833行
const clientType = (() => {
  if (isEnvTruthy(process.env.GITHUB_ACTIONS)) return 'github-action';
  if (process.env.CLAUDE_CODE_ENTRYPOINT === 'sdk-ts') return 'sdk-typescript';
  if (process.env.CLAUDE_CODE_ENTRYPOINT === 'sdk-py') return 'sdk-python';
  if (process.env.CLAUDE_CODE_ENTRYPOINT === 'sdk-cli') return 'sdk-cli';
  if (process.env.CLAUDE_CODE_ENTRYPOINT === 'claude-vscode') return 'claude-vscode';
  if (process.env.CLAUDE_CODE_ENTRYPOINT === 'local-agent') return 'local-agent';
  if (process.env.CLAUDE_CODE_ENTRYPOINT === 'claude-desktop') return 'claude-desktop';
  
  const hasSessionIngressToken = process.env.CLAUDE_CODE_SESSION_ACCESS_TOKEN 
    || process.env.CLAUDE_CODE_WEBSOCKET_AUTH_FILE_DESCRIPTOR;
  if (process.env.CLAUDE_CODE_ENTRYPOINT === 'remote' || hasSessionIngressToken) {
    return 'remote';
  }
  return 'cli';  // 默认
})();

Client type 影响认证行为——preferThirdPartyAuthentication() 函数在 bootstrap/state.ts 中使用它：

// bootstrap/state.ts 第1234-1237行
export function preferThirdPartyAuthentication(): boolean {
  // IDE 扩展应该表现为 1P 认证
  return getIsNonInteractiveSession() && STATE.clientType !== 'claude-vscode'
}

3.3 URI 深链处理

main() 函数在模式判别之前还有一段 URI 深链处理逻辑——处理 cc:// 和 cc+unix:// 协议：

// main.tsx 第612-642行
if (feature('DIRECT_CONNECT')) {
  const rawCliArgs = process.argv.slice(2);
  const ccIdx = rawCliArgs.findIndex(a => a.startsWith('cc://') || a.startsWith('cc+unix://'));
  if (ccIdx !== -1 && _pendingConnect) {
    const ccUrl = rawCliArgs[ccIdx]!;
    const { parseConnectUrl } = await import('./server/parseConnectUrl.js');
    const parsed = parseConnectUrl(ccUrl);
    
    if (rawCliArgs.includes('-p') || rawCliArgs.includes('--print')) {
      // Headless: 重写为内部 `open` 子命令
      process.argv = [process.argv[0]!, process.argv[1]!, 'open', ccUrl, ...stripped];
    } else {
      // Interactive: 剥离 cc:// URL，运行主命令
      _pendingConnect.url = parsed.serverUrl;
      _pendingConnect.authToken = parsed.authToken;
      process.argv = [process.argv[0]!, process.argv[1]!, ...stripped];
    }
  }
}

源码洞察：这是 OS 协议处理器触发的入口——当用户在浏览器中点击 cc://... 链接时，操作系统会启动 Claude Code 并传入 URI。源码将其重写为正常的命令行参数，使主命令处理逻辑可以统一处理。

3.4 SSH 远程模式参数提取

main() 函数还有一段 SSH 参数预提取逻辑，展示了"参数重写"模式的精妙：

// main.tsx 第706-780行
if (feature('SSH_REMOTE') && _pendingSSH) {
  const rawCliArgs = process.argv.slice(2);
  if (rawCliArgs[0] === 'ssh') {
    // 提取 SSH 特有的标志，在检查 host 之前
    const localIdx = rawCliArgs.indexOf('--local');
    if (localIdx !== -1) {
      _pendingSSH.local = true;
      rawCliArgs.splice(localIdx, 1);
    }
    
    // 提取 --permission-mode（支持两种语法）
    const pmIdx = rawCliArgs.indexOf('--permission-mode');
    if (pmIdx !== -1 && rawCliArgs[pmIdx + 1] && !rawCliArgs[pmIdx + 1]!.startsWith('-')) {
      _pendingSSH.permissionMode = rawCliArgs[pmIdx + 1];
      rawCliArgs.splice(pmIdx, 2);
    }
    const pmEqIdx = rawCliArgs.findIndex(a => a.startsWith('--permission-mode='));
    if (pmEqIdx !== -1) {
      _pendingSSH.permissionMode = rawCliArgs[pmEqIdx]!.split('=')[1];
      rawCliArgs.splice(pmEqIdx, 1);
    }
    
    // 转发 --continue/--resume/--model 到远程 CLI
    const extractFlag = (flag: string, opts: { hasValue?: boolean; as?: string } = {}) => { ... };
    extractFlag('-c', { as: '--continue' });
    extractFlag('--continue');
    extractFlag('--resume', { hasValue: true });
    extractFlag('--model', { hasValue: true });
  }
}

设计意图：claude ssh --permission-mode auto host /tmp 和 claude ssh host /tmp --permission-mode auto 是等价的——通过预提取所有 SSH 标志，然后检查剩余位置参数，实现了 POSIX 风格的"标志在位置参数前后均可"语义。

---

四、init.ts：初始化中枢

4.1 memoize 单例模式

原书提到"用 memoize 包装整个初始化函数"。源码证实：

// init.ts 第57行
import memoize from 'lodash-es/memoize.js'

export const init = memoize(async (): Promise<void> => {
  const initStartTime = Date.now()
  logForDiagnosticsNoPII('info', 'init_started')
  profileCheckpoint('init_function_start')
  
  // 配置验证 → 安全环境变量 → CA证书 → 优雅关闭 → ...
  enableConfigs()
  applySafeConfigEnvironmentVariables()
  applyExtraCACertsFromConfig()
  setupGracefulShutdown()
  // ...
})

源码验证：memoize 确保即使 preAction hook 被多次触发（如子命令链），init() 只执行一次。但原书也提到了"代价"——对于遥测等可选子系统，额外的 telemetryInitialized 标志与 memoize 并存：

// init.ts 第55行
let telemetryInitialized = false  // 独立于 memoize 的重试标志

4.2 信任分层的代码实现

原书将 init 分为"信任前"和"信任后"两个阶段。源码中的分界线是 applySafeConfigEnvironmentVariables() vs 完整配置加载：

// init.ts 第62-84行 —— 信任前阶段
enableConfigs()                              // 启用配置系统
applySafeConfigEnvironmentVariables()        // 只应用安全环境变量（来自 OS/全局配置）
applyExtraCACertsFromConfig()                // CA 证书（必须在 TLS 首次握手前）
setupGracefulShutdown()                      // 优雅关闭注册
// ... OAuth、JetBrains 检测等 fire-and-forget 异步操作 ...

// 信任后阶段（在 showSetupScreens() 信任对话框之后，在 main.tsx action handler 中）
// 应用项目级环境变量、完整配置加载、遥测初始化等

关键时序约束：源码注释明确指出 CA 证书必须在 Bun 的 BoringSSL 缓存之前配置：

// Apply NODE_EXTRA_CA_CERTS from settings.json to process.env early,
// before any TLS connections. Bun caches the TLS cert store at boot
// via BoringSSL, so this must happen before the first TLS handshake.
applyExtraCACertsFromConfig()

4.3 API 预连接

// init.ts 第153-159行
// Preconnect to the Anthropic API — overlap TCP+TLS handshake
// (~100-200ms) with the ~100ms of action-handler work before the API request.
preconnectAnthropicApi()

原书提到预连接会跳过代理/mTLS/Unix Socket/云提供商环境——源码注释证实了这一逻辑的存在（实现在 utils/apiPreconnect.js 中）。

---

五、bootstrap/state.ts：全局状态锚点

5.1 DAG 叶子约束

原书强调 state.ts 是"模块依赖图的叶子节点——不导入任何业务模块"。源码中的 import 列表证实了这一点——只导入类型和工具函数：

// bootstrap/state.ts 第1-29行
import type { BetaMessageStreamParams } from '@anthropic-ai/sdk/...'  // 仅类型
import type { Attributes, Meter, MetricOptions } from '@opentelemetry/api'  // 仅类型
import type { logs } from '@opentelemetry/api-logs'  // 仅类型
import { realpathSync } from 'fs'  // Node.js 内置
import sumBy from 'lodash-es/sumBy.js'  // 第三方工具
import { cwd } from 'process'  // Node.js 内置
import type { HookEvent, ModelUsage } from 'src/entrypoints/agentSdkTypes.js'  // 仅类型
import { randomUUID } from 'src/utils/crypto.js'  // 工具函数（有 eslint-disable 注释）
import { resetSettingsCache } from 'src/utils/settings/settingsCache.js'  // 工具函数
import { createSignal } from 'src/utils/signal.js'  // 工具函数

源码洞察：对 crypto.js 的导入有一条特殊的 eslint-disable 注释：

// Indirection for browser-sdk build. Pure leaf re-export of node:crypto —
// zero circular-dep risk. Path-alias import bypasses bootstrap-isolation
// (rule only checks ./ and / prefixes); explicit disable documents intent.
// eslint-disable-next-line custom-rules/bootstrap-isolation
import { randomUUID } from 'src/utils/crypto.js'

这说明 bootstrap-isolation ESLint 规则检查 ./ 和 / 前缀的导入，而 src/ 前缀的导入需要显式 disable——这是一个有趣的安全网设计。

5.2 State 字段的分类学

原书将 60+ 字段按领域分类。源码中的 State 类型定义（第45-257行）证实了这一分类，且实际字段数量已增长到 80+ 个（随着功能迭代持续膨胀）：

领域	典型字段	源码行号
会话身份	sessionId, parentSessionId, originalCwd, projectRoot	46-50
成本统计	totalCostUSD, modelUsage, totalAPIDuration	51-67
模型配置	mainLoopModelOverride, initialMainLoopModel, sdkBetas	68-69
Beta 锁存	afkModeHeaderLatched, fastModeHeaderLatched, cacheEditingHeaderLatched	228-236
交互状态	isInteractive, kairosActive, strictToolResultPairing	71-78
遥测句柄	meter, loggerProvider, meterProvider, tracerProvider	90-109
功能开关	sessionBypassPermissionsMode, scheduledTasksEnabled	133-137
缓存	planSlugCache, systemPromptSectionCache, cachedClaudeMdContent	169, 203, 123
多代理	sessionCreatedTeams, agentColorMap, invokedSkills	149, 111, 178

源码中三处醒目的注释反映了全局状态膨胀的工程焦虑：

// 第31行
// DO NOT ADD MORE STATE HERE - BE JUDICIOUS WITH GLOBAL STATE

// 第259行
// ALSO HERE - THINK THRICE BEFORE MODIFYING

// 第428行
// AND ESPECIALLY HERE

5.3 会话切换的原子性

源码中有一个原书未提及的精妙设计——switchSession() 函数的原子性保证：

// bootstrap/state.ts 第468-479行
/**
 * Atomically switch the active session. `sessionId` and `sessionProjectDir`
 * always change together — there is no separate setter for either, so they
 * cannot drift out of sync (CC-34).
 */
export function switchSession(
  sessionId: SessionId,
  projectDir: string | null = null,
): void {
  STATE.planSlugCache.delete(STATE.sessionId)
  STATE.sessionId = sessionId
  STATE.sessionProjectDir = projectDir
  sessionSwitched.emit(sessionId)  // 通知订阅者
}

设计意图：sessionId 和 sessionProjectDir 必须同时变更——通过提供唯一的 setter，从 API 层面杜绝了两者不同步的可能（标注为 CC-34，说明这是一个从 bug 修复中提炼的约束）。

---

六、启动流程全链路：从 void main() 到 launchRepl()

将源码中的所有检查点串联起来，完整的启动链路如下：

void main()  (cli.tsx:302)
    │
    ├─ L0: process.env.COREPACK_ENABLE_AUTO_PIN = '0'
    │      process.env.NODE_OPTIONS += '--max-old-space-size=8192' (CCR)
    │
    ├─ L1: args.includes('--version') → console.log(VERSION) → return
    │      [零模块加载，~5ms]
    │
    ├─ L2: args[0] === 'bridge' → enableConfigs() → OAuth → bridgeMain() → return
    │      args[0] === 'mcp' → ... → return
    │      [按需动态导入，~20-50ms]
    │
    ├─ L3: await import('../main.js')
    │      [~135ms import + 并行 MDM/Keychain 预取]
    │
    │  └─ cliMain()  (main.tsx:585)
    │      │
    │      ├─ process.env.NoDefaultCurrentDirectoryInExePath = '1' (Windows 安全)
    │      ├─ initializeWarningHandler()
    │      ├─ process.on('SIGINT', ...) / process.on('exit', ...)
    │      │
    │      ├─ URI 深链处理 (cc:// → 参数重写)
    │      ├─ SSH 参数预提取
    │      ├─ 模式判别: hasPrintFlag || !process.stdout.isTTY → isNonInteractive
    │      ├─ Client Type 判定: cli / sdk-typescript / claude-vscode / remote / ...
    │      │
    │      └─ run()  (main.tsx:884)
    │          │
    │          ├─ new CommanderCommand().configureHelp(...)
    │          ├─ program.hook('preAction', async () => {
    │          │     await ensureMdmSettingsLoaded()     // 等待 MDM 预取
    │          │     await ensureKeychainPrefetchCompleted()  // 等待 Keychain 预取
    │          │     await init()                        // 初始化中枢
    │          │     initSinks()                         // 日志 sink
    │          │     setInlinePlugins()                  // --plugin-dir
    │          │     runMigrations()                     // 数据迁移
    │          │     void loadRemoteManagedSettings()    // 远程设置（非阻塞）
    │          │     void loadPolicyLimits()             // 策略限制（非阻塞）
    │          │  })
    │          │
    │          ├─ program.name('claude').option(...).option(...)  // 50+ 选项
    │          ├─ program.action(async (prompt, options) => {
    │          │     // --bare 模式设置
    │          │     // 信任对话框 showSetupScreens()
    │          │     // setup() → setCwd, worktree, hooks 快照
    │          │     // launchRepl(root, appProps, replProps, renderAndRun)
    │          │  })
    │          │
    │          └─ program.parseAsync(process.argv)
    │
    └─ [REPL 运行中...]

---

七、核心设计模式提炼

模式 1：分层路由器（Layered Router）

问题：十余种运行模式共享一个入口，每种模式的前置条件不同。

方案：四层架构（L0 环境预处理 → L1 零依赖快速路径 → L2 功能分流 → L3 完整启动），每层对应不同的资源加载深度。

源码体现：cli.tsx 的 302 行代码实现了完整的四层路由。L1 的 --version 路径零模块加载；L2 的 12 条 fast-path 各自独立动态导入；L3 才加载 3900+ 行的 main.tsx。

适用条件：系统有多个运行模式，且各模式的前置条件差异大，无法用声明式注册统一表达。

模式 2：构建时 Feature Flag（Build-time DCE）

问题：内部版本和外部版本功能集不同，运行时环境变量控制会导致代码仍然存在于构建产物中。

方案：feature() 函数在构建时内联为布尔常量，编译器完全消除 false 分支。

源码体现：feature('DAEMON')、feature('BRIDGE_MODE')、feature('KAIROS') 等。"external" === 'ant' 永远为 false，说明还原版本是外部构建。

Trade-off：同一份源码在不同构建中行为不同，测试矩阵变大。

模式 3：Side-effect 重叠（I/O Parallelization at Import Time）

问题：main.tsx 有 ~135ms 的 import 开销，期间 CPU 空闲。

方案：在 import 语句之前启动耗时的 I/O 操作（MDM 子进程、Keychain 读取），让它们与 import 阶段并行。

源码体现：main.tsx 第1-20行，startMdmRawRead() 和 startKeychainPrefetch() 在所有 import 之前执行。

模式 4：preAction Hook 单点初始化

问题：Commander 的每个子命令都可能需要初始化，但初始化应只执行一次。

方案：program.hook('preAction', ...) + memoize(init) 双重保证。

源码体现：main.tsx 第907行注册 preAction hook，init.ts 第57行用 memoize 包装。

模式 5：DAG 叶子约束（Leaf Node Constraint）

问题：全局状态被 200+ 模块引用，如果它反向依赖任何业务模块，会形成循环依赖。

方案：自定义 ESLint 规则 bootstrap-isolation 强制 bootstrap 目录只导入类型和工具函数。

源码体现：state.ts 的 import 列表全是 import type 或 Node.js 内置模块。对 crypto.js 的导入有显式 eslint-disable 注释，说明规则的严格性和逃生 hatch 的设计。

模式 6：原子会话切换（Atomic Session Switch）

问题：sessionId 和 sessionProjectDir 必须同时变更，分开设置可能导致不一致。

方案：提供唯一的 switchSession() setter，不暴露单独的 setSessionId() 或 setSessionProjectDir()。

源码体现：bootstrap/state.ts 第468行，注释标注 CC-34（从 bug 修复中提炼）。

---

八、源码与原书的差异与补充

维度	原书描述	源码实际情况	差异分析
State 字段数	“60多个字段”	80+ 个字段（持续膨胀）	原书基于较早版本，功能迭代导致字段增长
Fast-path 数量	“十余种运行模式”	12 条 fast-path（含 Ant-only）	基本一致，但 Ant-only 路径在外部构建中被 DCE
--version 实现	“读取 package.json”	MACRO.VERSION 构建时内联	源码更优化——不需要文件 I/O
preAction 步骤	“触发 init()”	7 个步骤（MDM 等待 → init → sink → plugin → migration → 远程设置）	原书简化了，源码更复杂
信任分界线	“信任前/信任后”	applySafeConfigEnvironmentVariables() 是分界线	源码精确到函数级
CLI 选项数量	未明确	50+ 个 .option() 调用	原书聚焦架构，未列举全部选项

---

九、验证清单

以下结论可通过源码直接验证：

• L1 零依赖：cli.tsx:37-41 — --version 路径只有 console.log，无任何 import
• L2 动态导入：cli.tsx:112-161 — Bridge 分支用 await import() 加载 6 个模块
• Feature Flag DCE：main.tsx:3816 — "external" === 'ant' 永远为 false
• Side-effect 重叠：main.tsx:1-20 — startMdmRawRead() 在 import 之前
• preAction + memoize：main.tsx:907 + init.ts:57 — 双重初始化保护
• DAG 叶子约束：state.ts:1-29 — 全部是 import type 或内置模块
• DO NOT ADD MORE STATE：state.ts:31 — 注释确实存在
• CA 证书时序：init.ts:79 — applyExtraCACertsFromConfig() 在网络配置之前
• API 预连接：init.ts:159 — preconnectAnthropicApi() 在初始化末尾
• 原子会话切换：state.ts:468 — switchSession() 是唯一 setter

---

下期预告

下一篇 2.2 init.ts 初始化中枢 将深入 entrypoints/init.ts 的完整实现，重点解析：

• memoize 单例的失败处理与 telemetryInitialized 双轨机制
• 信任对话框的触发时机与"信任前/信任后"的精确代码分界
• applySafeConfigEnvironmentVariables() vs applyConfigEnvironmentVariables() 的安全边界
• fire-and-forget 异步操作的失败降级策略
• setupGracefulShutdown() 如何在初始化阶段就注册退出清理

从"路由器"走进"初始化中枢"——启动流程的复杂度才刚刚开始。