docs/
├── en/                                        # English
│   ├── [01-telemetry-and-privacy.md]          # Telemetry & Privacy — what's collected, why you can't opt out
│   ├── [02-hidden-features-and-codenames.md]  # Codenames (Capybara/Tengu/Numbat), feature flags, internal vs external
│   ├── [03-undercover-mode.md]                # Undercover Mode — hiding AI authorship in open-source repos
│   ├── [04-remote-control-and-killswitches.md]# Remote Control — managed settings, killswitches, model overrides
│   └── [05-future-roadmap.md]                 # Future Roadmap — Numbat, KAIROS, voice mode, unreleased tools
│
├── ja/                                        # 日本語
│   ├── [01-テレメトリとプライバシー.md]
│   ├── [02-隠し機能とコードネーム.md]
│   ├── [03-アンダーカバーモード.md]
│   ├── [04-リモート制御とキルスイッチ.md]
│   └── [05-今後のロードマップ.md]
│
├── ko/                                        # 한국어
│   ├── [01-텔레메트리와-프라이버시.md]
│   ├── [02-숨겨진-기능과-코드네임.md]
│   ├── [03-언더커버-모드.md]
│   ├── [04-원격-제어와-킬스위치.md]
│   └── [05-향후-로드맵.md]
│
└── zh/                                        # 中文
    ├── [01-遥测与隐私分析.md]
    ├── [02-隐藏功能与模型代号.md]
    ├── [03-卧底模式分析.md]
    ├── [04-远程控制与紧急开关.md]
    └── [05-未来路线图.md]

  Monodépôt interne Anthropic              Package npm publié
  ──────────────────────────               ─────────────────────
  feature('DAEMON') → true    ──build──→   feature('DAEMON') → false
  ↓                                         ↓
  daemon/main.js  ← INCLUS     ──bundle─→  daemon/main.js  ← SUPPRIMÉ (DCE)
  tools/REPLTool  ← INCLUS     ──bundle─→  tools/REPLTool  ← SUPPRIMÉ (DCE)
  proactive/      ← INCLUS     ──bundle─→  (référencé mais absent de src/)

Copyright (c) Anthropic. Tous droits réservés.

Tout le code source de ce dépôt est la propriété intellectuelle d'Anthropic et Claude.
Ce dépôt est fourni strictement à des fins de recherche technique et éducatives.
Toute utilisation commerciale est strictement interdite.

Si vous êtes le titulaire des droits d'auteur et estimez que ce dépôt enfreint vos droits,
veuillez contacter le propriétaire du dépôt pour une suppression immédiate.

                    LA BOUCLE CENTRALE
                    ==================

    Utilisateur --> messages[] --> API Claude --> réponse
                                                |
                                      stop_reason == "tool_use" ?
                                     /                           \
                                   oui                            non
                                    |                              |
                              exécuter outils                retourner texte
                              ajouter tool_result
                              reboucler ──────────────────> messages[]


    C'est la boucle agent minimale. Claude Code enveloppe cette boucle
    avec un système de contrôle de niveau production : permissions, streaming,
    concurrence, compaction, sous-agents, persistance et MCP.

src/
├── main.tsx                 # Bootstrap du REPL, 4 683 lignes
├── QueryEngine.ts           # Moteur de cycle de vie pour requêtes SDK/headless
├── query.ts                 # Boucle agent principale (785 Ko, fichier le plus volumineux)
├── Tool.ts                  # Interface Tool + fabrique buildTool
├── Task.ts                  # Types de tâches, IDs, base d'état
├── tools.ts                 # Registre d'outils, préréglages, filtrage
├── commands.ts              # Définitions des commandes slash
├── context.ts               # Contexte de l'entrée utilisateur
├── cost-tracker.ts          # Cumul des coûts API
├── setup.ts                 # Flux de configuration initiale
│
├── bridge/                  # Bridge Claude Desktop / distant
│   ├── bridgeMain.ts        #   Gestionnaire de cycle de vie des sessions
│   ├── bridgeApi.ts         #   Client HTTP
│   ├── bridgeConfig.ts      #   Configuration de connexion
│   ├── bridgeMessaging.ts   #   Relais de messages
│   ├── sessionRunner.ts     #   Lancement de processus
│   ├── jwtUtils.ts          #   Rafraîchissement JWT
│   ├── workSecret.ts        #   Jetons d'authentification
│   └── capacityWake.ts      #   Réveil basé sur la capacité
│
├── cli/                     # Infrastructure CLI
│   ├── handlers/            #   Gestionnaires de commandes
│   └── transports/          #   Transports E/S (stdio, structuré)
│
├── commands/                # ~80 commandes slash
│   ├── agents/              #   Gestion des agents
│   ├── compact/             #   Compaction du contexte
│   ├── config/              #   Gestion des paramètres
│   ├── help/                #   Affichage de l'aide
│   ├── login/               #   Authentification
│   ├── mcp/                 #   Gestion des serveurs MCP
│   ├── memory/              #   Système de mémoire
│   ├── plan/                #   Mode planification
│   ├── resume/              #   Reprise de session
│   ├── review/              #   Revue de code
│   └── ...                  #   70+ commandes supplémentaires
│
├── components/              # Interface terminal React/Ink
│   ├── design-system/       #   Primitives UI réutilisables
│   ├── messages/            #   Rendu des messages
│   ├── permissions/         #   Boîtes de dialogue de permissions
│   ├── PromptInput/         #   Champ de saisie + suggestions
│   ├── LogoV2/              #   Branding + écran d'accueil
│   ├── Settings/            #   Panneaux de paramètres
│   ├── Spinner.tsx          #   Indicateurs de chargement
│   └── ...                  #   40+ groupes de composants
│
├── entrypoints/             # Points d'entrée de l'application
│   ├── cli.tsx              #   Principale CLI (version, aide, démon)
│   ├── sdk/                 #   SDK Agent (types, sessions)
│   └── mcp.ts               #   Point d'entrée serveur MCP
│
├── hooks/                   # Hooks React
│   ├── useCanUseTool.tsx    #   Vérification des permissions
│   ├── useReplBridge.tsx    #   Connexion au bridge
│   ├── notifs/              #   Hooks de notification
│   └── toolPermission/      #   Gestionnaires de permissions d'outils
│
├── services/                # Couche logique métier
│   ├── api/                 #   Client API Claude
│   │   ├── claude.ts        #     Appels API en streaming
│   │   ├── errors.ts        #     Catégorisation des erreurs
│   │   └── withRetry.ts     #     Logique de nouvelle tentative
│   ├── analytics/           #   Télémétrie + GrowthBook
│   ├── compact/             #   Compression du contexte
│   ├── mcp/                 #   Gestion des connexions MCP
│   ├── tools/               #   Moteur d'exécution des outils
│   │   ├── StreamingToolExecutor.ts  # Exécuteur d'outils en parallèle
│   │   └── toolOrchestration.ts      # Orchestration par lots
│   ├── plugins/             #   Chargeur de plugins
│   └── settingsSync/        #   Synchronisation des paramètres entre appareils
│
├── state/                   # État de l'application
│   ├── AppStateStore.ts     #   Définition du store
│   └── AppState.tsx         #   Fournisseur React + hooks
│
├── tasks/                   # Implémentations des tâches
│   ├── LocalShellTask/      #   Exécution de commandes Bash
│   ├── LocalAgentTask/      #   Exécution de sous-agents
│   ├── RemoteAgentTask/     #   Agent distant via bridge
│   ├── InProcessTeammateTask/ # Coéquipier en cours de processus
│   └── DreamTask/           #   Réflexion en arrière-plan
│
├── tools/                   # 40+ implémentations d'outils
│   ├── AgentTool/           #   Lancement de sous-agents + fork
│   ├── BashTool/            #   Exécution de commandes shell
│   ├── FileReadTool/        #   Lecture de fichiers (PDF, image, etc.)
│   ├── FileEditTool/        #   Édition par remplacement de chaîne
│   ├── FileWriteTool/       #   Création complète de fichiers
│   ├── GlobTool/            #   Recherche de fichiers par motif
│   ├── GrepTool/            #   Recherche de contenu (ripgrep)
│   ├── WebFetchTool/        #   Récupération HTTP
│   ├── WebSearchTool/       #   Recherche web
│   ├── MCPTool/             #   Wrapper d'outil MCP
│   ├── SkillTool/           #   Invocation de compétences
│   ├── AskUserQuestionTool/ #   Interaction utilisateur
│   └── ...                  #   30+ outils supplémentaires
│
├── types/                   # Définitions de types
│   ├── message.ts           #   Unions discriminantes de messages
│   ├── permissions.ts       #   Types de permissions
│   ├── tools.ts             #   Types de progression des outils
│   └── ids.ts               #   Types d'ID marqués (branded)
│
├── utils/                   # Utilitaires (répertoire le plus volumineux)
│   ├── permissions/         #   Moteur de règles de permissions
│   ├── messages/            #   Formatage des messages
│   ├── model/               #   Logique de sélection du modèle
│   ├── settings/            #   Gestion des paramètres
│   ├── sandbox/             #   Adaptateur de runtime sandbox
│   ├── hooks/               #   Exécution des hooks
│   ├── memory/              #   Utilitaires du système de mémoire
│   ├── git/                 #   Opérations Git
│   ├── github/              #   API GitHub
│   ├── bash/                #   Helpers d'exécution Bash
│   ├── swarm/               #   Essaim multi-agents
│   ├── telemetry/           #   Rapports de télémétrie
│   └── ...                  #   30+ groupes d'utilitaires supplémentaires
│
└── vendor/                  # Stubs de modules natifs
    ├── audio-capture-src/   #   Capture audio
    ├── image-processor-src/ #   Traitement d'images
    ├── modifiers-napi-src/  #   Modificateurs natifs
    └── url-handler-src/     #   Gestion des URLs

┌─────────────────────────────────────────────────────────────────────┐
│                        COUCHE D'ENTRÉE                              │
│  cli.tsx ──> main.tsx ──> REPL.tsx (interactif)                    │
│                     └──> QueryEngine.ts (headless/SDK)              │
└──────────────────────────────┬──────────────────────────────────────┘
                               │
                               ▼
┌─────────────────────────────────────────────────────────────────────┐
│                       MOTEUR DE REQUÊTE                             │
│  submitMessage(prompt) ──> AsyncGenerator<SDKMessage>               │
│    │                                                                │
│    ├── fetchSystemPromptParts()    ──> assembler le prompt système  │
│    ├── processUserInput()          ──> gérer les /commandes         │
│    ├── query()                     ──> boucle agent principale      │
│    │     ├── StreamingToolExecutor ──> exécution parallèle d'outils │
│    │     ├── autoCompact()         ──> compression du contexte      │
│    │     └── runTools()            ──> orchestration des outils     │
│    └── yield SDKMessage            ──> diffuser au consommateur     │
└──────────────────────────────┬──────────────────────────────────────┘
                               │
              ┌────────────────┼────────────────┐
              ▼                ▼                 ▼
┌──────────────────┐ ┌─────────────────┐ ┌──────────────────┐
│  SYSTÈME D'OUTILS│ │ COUCHE SERVICES │ │  COUCHE D'ÉTAT   │
│                  │ │                 │ │                  │
│ Interface Tool   │ │ api/claude.ts   │ │ AppState Store   │
│  ├─ call()       │ │  Client API     │ │  ├─ permissions  │
│  ├─ validate()   │ │ compact/        │ │  ├─ fileHistory  │
│  ├─ checkPerms() │ │  auto-compact   │ │  ├─ agents       │
│  ├─ render()     │ │ mcp/            │ │  └─ fastMode     │
│  └─ prompt()     │ │  protocole MCP  │ │                  │
│                  │ │ analytics/      │ │ Contexte React   │
│ 40+ Intégrés :   │ │  télémétrie     │ │  ├─ useAppState  │
│  ├─ BashTool     │ │ tools/          │ │  └─ useSetState  │
│  ├─ FileRead     │ │  exécuteur      │ │                  │
│  ├─ FileEdit     │ │ plugins/        │ └──────────────────┘
│  ├─ Glob/Grep    │ │  chargeur       │
│  ├─ AgentTool    │ │ settingsSync/   │
│  ├─ WebFetch     │ │  multi-appareils│
│  └─ MCPTool      │ │ oauth/          │
│                  │ │  flux d'auth    │
└──────────────────┘ └─────────────────┘
              │                │
              ▼                ▼
┌──────────────────┐ ┌─────────────────┐
│ SYSTÈME DE TÂCHES│ │  COUCHE BRIDGE  │
│                  │ │                 │
│ Types de tâches :│ │ bridgeMain.ts   │
│  ├─ local_bash   │ │  gest. sessions │
│  ├─ local_agent  │ │ bridgeApi.ts    │
│  ├─ remote_agent │ │  client HTTP    │
│  ├─ in_process   │ │ workSecret.ts   │
│  ├─ dream        │ │  jetons auth    │
│  └─ workflow     │ │ sessionRunner   │
│                  │ │  spawn process  │
│ ID: préfixe+8chr │ └─────────────────┘
│  b=bash a=agent  │
│  r=remote t=team │
└──────────────────┘

 ENTRÉE UTILISATEUR (prompt / commande slash)
     │
     ▼
 processUserInput()                ← analyser /commandes, construire UserMessage
     │
     ▼
 fetchSystemPromptParts()          ← outils → sections du prompt, mémoire CLAUDE.md
     │
     ▼
 recordTranscript()                ← persister le message utilisateur sur disque (JSONL)
     │
     ▼
 ┌─→ normalizeMessagesForAPI()     ← supprimer les champs UI, compacter si nécessaire
 │   │
 │   ▼
 │   API Claude (streaming)        ← POST /v1/messages avec outils + prompt système
 │   │
 │   ▼
 │   événements de stream          ← message_start → content_block_delta → message_stop
 │   │
 │   ├─ bloc texte ─────────────→ transmettre au consommateur (SDK / REPL)
 │   │
 │   └─ bloc tool_use ?
 │       │
 │       ▼
 │   StreamingToolExecutor         ← partitionner : sûr-concurrent vs série
 │       │
 │       ▼
 │   canUseTool()                  ← vérif. permissions (hooks + règles + invite UI)
 │       │
 │       ├─ REFUS ───────────────→ ajouter tool_result(erreur), continuer la boucle
 │       │
 │       └─ AUTORISATION
 │           │
 │           ▼
 │       tool.call()               ← exécuter l'outil (Bash, Read, Edit, etc.)
 │           │
 │           ▼
 │       ajouter tool_result       ← pousser dans messages[], recordTranscript()
 │           │
 └─────────┘                      ← reboucler vers l'appel API
     │
     ▼ (stop_reason != "tool_use")
 émettre le message de résultat    ← texte final, usage, coût, session_id

                    INTERFACE TOOL
                    ==============

    buildTool(definition) ──> Tool<Input, Output, Progress>

    Chaque outil implémente :
    ┌────────────────────────────────────────────────────────┐
    │  CYCLE DE VIE                                          │
    │  ├── validateInput()      → rejeter les args invalides │
    │  ├── checkPermissions()   → authz spécifique à l'outil │
    │  └── call()               → exécuter et retourner      │
    │                                                        │
    │  CAPACITÉS                                             │
    │  ├── isEnabled()          → vérification feature flag  │
    │  ├── isConcurrencySafe()  → peut s'exécuter en //? │
    │  ├── isReadOnly()         → sans effets de bord ?      │
    │  ├── isDestructive()      → opérations irréversibles ? │
    │  └── interruptBehavior()  → annuler ou bloquer ?       │
    │                                                        │
    │  RENDU (React/Ink)                                     │
    │  ├── renderToolUseMessage()     → affichage des entrées│
    │  ├── renderToolResultMessage()  → affichage des sorties│
    │  ├── renderToolUseProgressMessage() → spinner/statut  │
    │  └── renderGroupedToolUse()     → groupes d'outils //  │
    │                                                        │
    │  CÔTÉ IA                                               │
    │  ├── prompt()             → description outil pour LLM │
    │  ├── description()        → description dynamique      │
    │  └── mapToolResultToAPI() → formater la réponse API    │
    └────────────────────────────────────────────────────────┘

    OPÉRATIONS FICHIERS      RECHERCHE & DÉCOUVERTE    EXÉCUTION
    ═══════════════════       ══════════════════════    ══════════
    FileReadTool              GlobTool                  BashTool
    FileEditTool              GrepTool                  PowerShellTool
    FileWriteTool             ToolSearchTool
    NotebookEditTool                                    INTERACTION
                                                        ═══════════
    WEB & RÉSEAU             AGENT / TÂCHE             AskUserQuestionTool
    ════════════════         ══════════════════        BriefTool
    WebFetchTool              AgentTool
    WebSearchTool             SendMessageTool           PLANIFICATION & WORKFLOW
                              TeamCreateTool            ════════════════════════
    PROTOCOLE MCP             TeamDeleteTool            EnterPlanModeTool
    ══════════════            TaskCreateTool            ExitPlanModeTool
    MCPTool                   TaskGetTool               EnterWorktreeTool
    ListMcpResourcesTool      TaskUpdateTool            ExitWorktreeTool
    ReadMcpResourceTool       TaskListTool              TodoWriteTool
                              TaskStopTool
                              TaskOutputTool            SYSTÈME
                                                        ════════
                              COMPÉTENCES & EXTENSIONS  ConfigTool
                              ═════════════════════════ SkillTool
                              SkillTool                 ScheduleCronTool
                              LSPTool                   SleepTool
                                                        TungstenTool

    DEMANDE D'APPEL D'OUTIL
          │
          ▼
    ┌─ validateInput() ──────────────────────────────────┐
    │  rejeter les entrées invalides avant toute vérif.  │
    └────────────────────┬───────────────────────────────┘
                         │
                         ▼
    ┌─ Hooks PreToolUse ─────────────────────────────────┐
    │  commandes shell définies par l'utilisateur        │
    │  peuvent : approuver, refuser, ou modifier l'entrée│
    └────────────────────┬───────────────────────────────┘
                         │
                         ▼
    ┌─ Règles de permissions ─────────────────────────── ┐
    │  alwaysAllowRules : correspondance → auto-approuver│
    │  alwaysDenyRules  : correspondance → refuser       │
    │  alwaysAskRules   : correspondance → demander      │
    │  Sources : paramètres, args CLI, décisions session │
    └────────────────────┬───────────────────────────────┘
                         │
                    pas de règle ?
                         │
                         ▼
    ┌─ Invite interactive ───────────────────────────────┐
    │  L'utilisateur voit le nom de l'outil + l'entrée   │
    │  Options : Autoriser une fois / Toujours / Refuser │
    └────────────────────┬───────────────────────────────┘
                         │
                         ▼
    ┌─ checkPermissions() ───────────────────────────────┐
    │  Logique spécifique à l'outil (ex. sandboxing)     │
    └────────────────────┬───────────────────────────────┘
                         │
                    APPROUVÉ → tool.call()

                        AGENT PRINCIPAL
                        ===============
                            │
            ┌───────────────┼───────────────┐
            ▼               ▼               ▼
     ┌──────────────┐ ┌──────────┐ ┌──────────────┐
     │  AGENT FORK  │ │ AGENT    │ │ COÉQUIPIER   │
     │              │ │ DISTANT  │ │ EN-PROCESSUS │
     │ Fork process │ │ Bridge   │ │ Même process │
     │ Cache partagé│ │ session  │ │ Contexte async│
     │ msgs[] neufs │ │ Isolé    │ │ État partagé │
     └──────────────┘ └──────────┘ └──────────────┘

    MODES DE LANCEMENT :
    ├─ default    → en-processus, conversation partagée
    ├─ fork       → processus enfant, messages[] neufs, cache fichiers partagé
    ├─ worktree   → worktree git isolé + fork
    └─ remote     → bridge vers Claude Code Remote / conteneur

    COMMUNICATION :
    ├─ SendMessageTool     → messages agent-à-agent
    ├─ TaskCreate/Update   → tableau de tâches partagé
    └─ TeamCreate/Delete   → gestion du cycle de vie d'équipe

    MODE ESSAIM (contrôlé par feature flag) :
    ┌─────────────────────────────────────────────┐
    │  Agent coordinateur                         │
    │    ├── Coéquipier A ──> revendique Tâche 1  │
    │    ├── Coéquipier B ──> revendique Tâche 2  │
    │    └── Coéquipier C ──> revendique Tâche 3  │
    │                                             │
    │  Partagé : tableau de tâches, boîte de réception│
    │  Isolé : messages[], cache fichiers, cwd    │
    └─────────────────────────────────────────────┘

    BUDGET DE FENÊTRE DE CONTEXTE
    ═════════════════════════════

    ┌─────────────────────────────────────────────────────┐
    │  Prompt système (outils, permissions, CLAUDE.md)    │
    │  ══════════════════════════════════════════════      │
    │                                                     │
    │  Historique de conversation                         │
    │  ┌─────────────────────────────────────────────┐    │
    │  │ [résumé compacté des anciens messages]       │    │
    │  │ ═══════════════════════════════════════════  │    │
    │  │ [marqueur compact_boundary]                  │    │
    │  │ ─────────────────────────────────────────── │    │
    │  │ [messages récents — fidélité complète]       │    │
    │  │ user → assistant → tool_use → tool_result   │    │
    │  └─────────────────────────────────────────────┘    │
    │                                                     │
    │  Tour actuel (user + réponse assistant)             │
    └─────────────────────────────────────────────────────┘

    TROIS STRATÉGIES DE COMPRESSION :
    ├─ autoCompact     → déclenché quand le nombre de tokens dépasse le seuil
    │                     résume les anciens messages via un appel API compact
    ├─ snipCompact     → supprime les messages zombie et marqueurs obsolètes
    │                     (feature flag HISTORY_SNIP)
    └─ contextCollapse → restructure le contexte pour plus d'efficacité
                         (feature flag CONTEXT_COLLAPSE)

    ┌─────────────────────────────────────────────────────────┐
    │              ARCHITECTURE MCP                            │
    │                                                         │
    │  MCPConnectionManager.tsx                               │
    │    ├── Découverte de serveurs (config de settings.json) │
    │    │     ├── stdio  → lancer un processus enfant        │
    │    │     ├── sse    → HTTP EventSource                  │
    │    │     ├── http   → HTTP streamable                   │
    │    │     ├── ws     → WebSocket                         │
    │    │     └── sdk    → transport en-processus            │
    │    │                                                    │
    │    ├── Cycle de vie du client                           │
    │    │     ├── connecter → initialiser → lister les outils│
    │    │     ├── appels d'outils via wrapper MCPTool         │
    │    │     └── déconnecter / reconnecter avec backoff     │
    │    │                                                    │
    │    ├── Authentification                                 │
    │    │     ├── Flux OAuth 2.0 (McpOAuthConfig)            │
    │    │     ├── Accès Cross-App (XAA / SEP-990)            │
    │    │     └── Clé API via headers                        │
    │    │                                                    │
    │    └── Enregistrement des outils                        │
    │          ├── Convention de nommage mcp__<serveur>__<outil>│
    │          ├── Schéma dynamique depuis le serveur MCP     │
    │          ├── Transmission des permissions Claude Code   │
    │          └── Listing des ressources (ListMcpResourcesTool)│
    │                                                         │
    └─────────────────────────────────────────────────────────┘

    Claude Desktop / Web / Cowork          Claude Code CLI
    ══════════════════════════            ═════════════════

    ┌───────────────────┐                 ┌──────────────────┐
    │  Client Bridge    │  ←─ HTTP ──→   │  bridgeMain.ts   │
    │  (App Desktop)    │                 │                  │
    └───────────────────┘                 │  Gestionnaire    │
                                          │  de sessions     │
    PROTOCOLE :                           │  ├── spawn CLI   │
    ├─ Auth JWT                           │  ├── poll statut │
    ├─ Échange work secret                │  ├── relais msgs │
    ├─ Cycle de vie session               │  └── capacityWake│
    │  ├── créer                          │                  │
    │  ├── exécuter                       │  Backoff :       │
    │  └─ arrêter                         │  ├─ conn: 2s→2m  │
    └─ Planificateur de rafraîch. token   │  └─ gen: 500ms→30s│
                                          └──────────────────┘

    STOCKAGE DE SESSION
    ══════════════════

    ~/.claude/projects/<hash>/sessions/
    └── <session-id>.jsonl           ← journal en ajout seulement
        ├── {"type":"user",...}
        ├── {"type":"assistant",...}
        ├── {"type":"progress",...}
        └── {"type":"system","subtype":"compact_boundary",...}

    FLUX DE REPRISE :
    getLastSessionLog() ──> analyser JSONL ──> reconstruire messages[]
         │
         ├── --continue     → dernière session dans le cwd
         ├── --resume <id>  → session spécifique
         └── --fork-session → nouvel ID, copie de l'historique

    STRATÉGIE DE PERSISTANCE :
    ├─ Messages utilisateur  → écriture en attente (bloquant, pour récupération crash)
    ├─ Messages assistant    → fire-and-forget (file avec préservation de l'ordre)
    ├─ Progress              → écriture inline (déduplication à la prochaine requête)
    └─ Flush                 → à l'émission du résultat / flush anticipé cowork

    DEAD CODE ELIMINATION (intrinsèque à la compilation Bun)
    ══════════════════════════════════════════════════════════

    feature('NOM_FLAG')  ──→  true  → inclus dans le bundle
                          ──→  false → supprimé du bundle

    FLAGS (observés dans le source) :
    ├─ COORDINATOR_MODE      → coordinateur multi-agents
    ├─ HISTORY_SNIP          → élagage agressif de l'historique
    ├─ CONTEXT_COLLAPSE      → restructuration du contexte
    ├─ DAEMON                → workers démon en arrière-plan
    ├─ AGENT_TRIGGERS        → déclencheurs cron/distants
    ├─ AGENT_TRIGGERS_REMOTE → support de déclencheurs distants
    ├─ MONITOR_TOOL          → outil de surveillance MCP
    ├─ WEB_BROWSER_TOOL      → automatisation du navigateur
    ├─ VOICE_MODE            → entrée/sortie vocale
    ├─ TEMPLATES             → classificateur de tâches
    ├─ EXPERIMENTAL_SKILL_SEARCH → découverte de compétences
    ├─ KAIROS                → notifications push, envoi de fichiers
    ├─ PROACTIVE             → outil sleep, comportement proactif
    ├─ OVERFLOW_TEST_TOOL    → outil de test
    ├─ TERMINAL_PANEL        → capture de terminal
    ├─ WORKFLOW_SCRIPTS      → outil de workflow
    ├─ CHICAGO_MCP           → computer use MCP
    ├─ DUMP_SYSTEM_PROMPT    → extraction de prompt (ant uniquement)
    ├─ UDS_INBOX             → découverte de pairs
    ├─ ABLATION_BASELINE     → ablation d'expérience
    └─ UPGRADE_NOTICE        → notifications de mise à jour

    CONTRÔLES RUNTIME :
    ├─ process.env.USER_TYPE === 'ant'  → fonctionnalités internes Anthropic
    └─ Feature flags GrowthBook         → expériences A/B à l'exécution

    ┌──────────────────────────────────────────────────────────┐
    │                  AppState Store                           │
    │                                                          │
    │  AppState {                                              │
    │    toolPermissionContext: {                              │
    │      mode: PermissionMode,          ← default/plan/etc  │
    │      additionalWorkingDirectories,                       │
    │      alwaysAllowRules,              ← auto-approuver     │
    │      alwaysDenyRules,               ← auto-refuser       │
    │      alwaysAskRules,                ← toujours demander  │
    │      isBypassPermissionsModeAvailable                    │
    │    },                                                    │
    │    fileHistory: FileHistoryState,   ← snapshots undo     │
    │    attribution: AttributionState,   ← suivi des commits  │
    │    verbose: boolean,                                     │
    │    mainLoopModel: string,           ← modèle actif       │
    │    fastMode: FastModeState,                              │
    │    speculation: SpeculationState                         │
    │  }                                                       │
    │                                                          │
    │  Intégration React :                                     │
    │  ├── AppStateProvider   → crée le store via createContext│
    │  ├── useAppState(sel)   → souscriptions par sélecteur   │
    │  └── useSetAppState()   → updater style immer           │
    └──────────────────────────────────────────────────────────┘

    s01  LA BOUCLE             "Une boucle & Bash suffisent"
         query.ts : la boucle while-true qui appelle l'API Claude,
         vérifie stop_reason, exécute les outils, ajoute les résultats.

    s02  DISPATCH D'OUTILS     "Ajouter un outil = ajouter un gestionnaire"
         Tool.ts + tools.ts : chaque outil s'enregistre dans la table
         de dispatch. La boucle reste identique. La fabrique buildTool()
         fournit des valeurs par défaut sécurisées.

    s03  PLANIFICATION         "Un agent sans plan dérive"
         EnterPlanModeTool/ExitPlanModeTool + TodoWriteTool :
         lister les étapes d'abord, puis exécuter. Double le taux d'achèvement.

    s04  SOUS-AGENTS           "Décomposer les grandes tâches ; contexte propre"
         AgentTool + forkSubagent.ts : chaque enfant reçoit des messages[]
         neufs, gardant la conversation principale propre.

    s05  CONNAISSANCE À LA DEMANDE "Charger les connaissances quand nécessaire"
         SkillTool + memdir/ : injecter via tool_result, pas le prompt système.
         Fichiers CLAUDE.md chargés paresseusement par répertoire.

    s06  COMPRESSION DU CONTEXTE "Le contexte se remplit ; faire de la place"
         services/compact/ : stratégie en trois couches :
         autoCompact (résumer) + snipCompact (élaguer) + contextCollapse

    s07  TÂCHES PERSISTANTES   "Grands objectifs → petites tâches → disque"
         TaskCreate/Update/Get/List : graphe de tâches basé sur fichiers avec
         suivi de statut, dépendances et persistance.

    s08  TÂCHES EN ARRIÈRE-PLAN "Ops lentes en arrière-plan ; l'agent continue"
         DreamTask + LocalShellTask : threads démons exécutent les commandes,
         injectent des notifications à la complétion.

    s09  ÉQUIPES D'AGENTS      "Trop grand pour un seul → déléguer aux coéquipiers"
         TeamCreate/Delete + InProcessTeammateTask : coéquipiers persistants
         avec boîtes aux lettres asynchrones.

    s10  PROTOCOLES D'ÉQUIPE   "Règles de communication partagées"
         SendMessageTool : un schéma requête-réponse pilote
         toutes les négociations entre agents.

    s11  AGENTS AUTONOMES      "Les coéquipiers scannent et revendiquent eux-mêmes"
         coordinator/coordinatorMode.ts : cycle inactif + auto-revendication,
         pas besoin que le coordinateur assigne chaque tâche.

    s12  ISOLATION PAR WORKTREE "Chacun travaille dans son propre répertoire"
         EnterWorktreeTool/ExitWorktreeTool : les tâches gèrent les objectifs,
         les worktrees gèrent les répertoires, liés par ID.

~/.claude/projects/<canonical-git-root>/<slug>/memory/
    MEMORY.md          ← Index d'entrée (max 200 lignes / 25 Ko)
    topic1.md          ← Fichier de mémoire thématique
    topic2.md
    subdir/
        context.md

~/.claude/plugins/repos/{source}/{plugin-id}/
    plugin-manifest.json     ← Manifeste du plugin
    hooks/hooks.json         ← Définitions de hooks
    tools/                   ← Outils supplémentaires (MCP)
    skills/                  ← Compétences / commandes