Modulo 1.1 Boot Sequence - Claude Code Deep Dive

1

🚀 Three-Layer Boot Architecture

O Claude Code utiliza uma arquitetura de boot em tres camadas, cada uma com responsabilidades claramente definidas:

Layer 1: CLI Entrypoint (`cli.tsx`)

Zero-cost fast paths, preparacao de ambiente e despacho de argumentos. Caminhos rapidos como --version e --daemon-worker saem imediatamente sem carregar o sistema completo.

Layer 2: Main Function (`main.tsx`)

Commander parsing, inicializacao, migracoes e validacao de permissoes. Aqui todos os imports estaticos sao carregados (~135ms de module eval).

Layer 3: Setup + REPL (`setup.ts` + `replLauncher.tsx`)

Wiring de sessao e renderizacao da UI de terminal baseada em React/Ink.

💡 Conceito-chave: Fast Paths

Fast paths sao caminhos de execucao que saem do processo antes de carregar qualquer modulo pesado. --version imprime e sai com process.exit(0). --daemon-worker executa runDaemonWorker(). remote-control/bridge desvia para bridgeMain(). Apenas quando nenhum fast path e acionado o sistema carrega main.tsx dinamicamente.

2

⚡ Key Startup Optimizations

MDM policy reads (via plutil) e keychain reads levam 20-65ms e sao lancados durante module evaluation para executar concorrentemente com a cadeia de imports. Esta paralelizacao previne que leituras sequenciais adicionem latencia ao caminho critico de startup.

📊 Dados de Performance

MDM/keychain reads: 20-65ms (disparados em paralelo)
Module evaluation completo: ~135ms
TCP warm-up para API: ~160ms
Primeiro render: ~190ms

Tres categorias de trabalho paralelo minimizam o time-to-first-render:

Paralelo no import time: startMdmRawRead() e startKeychainPrefetch() -- subprocessos MDM e leituras de keychain macOS
Apos init(): preconnectAnthropicApi() -- aquecimento de conexao TCP
Apos primeiro render: startDeferredPrefetches() -- contexto de usuario, tips, capabilities do modelo

💡 Dica Pratica

O padrao de "parallel subprocess investment" -- disparar subprocessos cedo, executar durante avaliacao JavaScript -- e replicavel em qualquer aplicacao CLI. Identifique operacoes de I/O que podem rodar em paralelo com o carregamento de modulos.

3

🔧 Setup Phase Sequence

A fase de setup impoe uma ordenacao critica em suas operacoes:

1. setCwd() executa antes de captureHooksConfigSnapshot() para garantir que os hooks de projeto corretos sejam carregados
2. O beacon tengu_started dispara imediatamente apos o sink de analytics conectar, criando um sinal precoce de "processo iniciado" para monitoramento de saude
3. initializeFileChangedWatcher() comeca a monitorar mudancas em arquivos do projeto
4. Background jobs sao disparados: initSessionMemory(), getCommands() prefetch, loadPluginHooks()

✅ Correto

setCwd() antes de captureHooksConfigSnapshot()
Analytics sink antes de tengu_started
Permission checks antes de launchRepl()

❌ Incorreto

Capturar hooks antes de definir CWD
Disparar analytics antes do sink conectar
Lancar REPL sem validar permissoes

4

🏎️ Bare Mode Optimization

O flag --bare (ou -p / --print) ativa o modo headless, removendo tudo que nao e essencial para cenarios scripted/SDK onde sensibilidade a latencia e maxima.

O que o bare mode remove:

✖ UDS messaging

✖ Teammate snapshots

✖ Session memory initialization

✖ Plugin hooks

✖ Deferred prefetches

✖ React/Ink rendering

💡 Conceito-chave: isBareMode()

Um unico flag controla todo o fast path headless. Em bare mode, stdout recebe apenas texto, trust e implicito, transcript e fire-and-forget e React nunca e importado. Esse e o caminho para integracao CI/CD e SDK.

5

🌍 Global State Management

bootstrap/state.ts mantem estado com escopo de sessao incluindo identidade, rastreamento de uso, flags de modo e telemetria. Este e o "Layer 1" do modelo de estado de duas camadas do Claude Code.

Latch Fields

Campos como afkModeHeaderLatched manteem headers de API estaveis para prevenir prompt cache busts durante mudancas de configuracao mid-session. Uma vez "latched", o valor nao muda ate o fim da sessao, garantindo que o hash do prompt permaneca estavel.

Camada	Arquivo	Proposito
Layer 1 - Global	`bootstrap/state.ts`	sessionId, cwd, projectRoot, totalCostUSD, token budget
Layer 2 - React	`state/AppStateStore.ts`	Messages, MCP clients, permissions, tasks, agents

6

⏱️ First Keystroke to First Token

Progressao completa do cold start ao streaming:

t=0ms

CLI entry

t=1ms

MDM e keychain reads disparam (paralelo)

t=136ms

Module eval completo

t=160ms

TCP warm-up para API

t=175ms

Setup screens (se primeiro run)

t=190ms

Primeiro render -- usuario ve o prompt

t=191ms

Deferred prefetches iniciam

t+50ms

Primeiro token chega apos usuario enviar

🗺️ Boot Pipeline Completo

flowchart TD
    A["Process starts - cli.tsx"] --> B["Set COREPACK_ENABLE_AUTO_PIN=0"]
    B --> C{"Fast-path check"}
    C -->|"--version"| V["Print version, exit"]
    C -->|"--daemon-worker"| D["runDaemonWorker"]
    C -->|"remote-control"| BR["bridgeMain"]
    C -->|"no fast-path"| E["Dynamic import main.tsx"]
    E --> F["main in main.tsx"]
    F --> G["startMdmRawRead + startKeychainPrefetch"]
    G --> H["Load static imports ~135ms"]
    H --> I["initializeWarningHandler"]
    I --> K["eagerLoadSettings + Commander.parse"]
    K --> M["init - applySafeConfigEnv"]
    M --> N["runMigrations"]
    N --> O["setup cwd, permissionMode"]
    O --> Q{"isBareMode?"}
    Q -->|"No"| R["startUdsMessaging"]
    Q -->|"Yes"| S["Skip UDS"]
    R --> T["setCwd + captureHooksConfig"]
    S --> T
    T --> BG["Background jobs"]
    BG --> REPL["launchRepl"]
    REPL --> DONE["First render"]

📋 Resumo do Modulo

✅ A arquitetura de boot em 3 camadas (CLI Entrypoint, Main Function, Setup+REPL) permite fast paths de custo zero para comandos simples

✅ Operacoes de I/O como MDM reads e keychain prefetch rodam em paralelo com module evaluation, prevenindo latencia sequencial

✅ A ordenacao critica do setup (setCwd antes de captureHooksConfigSnapshot) previne condicoes de corrida

✅ Bare mode remove tudo nao-essencial para cenarios headless/SDK com latencia minima

✅ O modelo de estado de duas camadas (bootstrap/state.ts + AppStateStore.ts) separa constantes de sessao de estado React

✅ Do keystroke ao primeiro token: ~190ms ate primeiro render, ~50ms adicionais ate streaming da resposta