Build something like this?

Root hub

Inside Claude Code - The Claude Code Ecosystem

11 open-source Anthropic repos around Claude Code, mapped from their public code: learn, build, extend, show up anywhere, and a compiler Claude wrote. Unofficial, not affiliated with Anthropic.

5 layers17 insightsby Supportv4Published Nov 11, 2026

About this system

The Claude Code ecosystem, left to right

This map covers 11 public repositories in the anthropics GitHub org and how they connect. It was drawn from their public code. It is an unofficial community map and is not affiliated with Anthropic.

  • Learn. Claude Cookbooks, Claude Quickstarts and the Claude Agent SDK Demos teach building on the Claude API and the Agent SDK.
  • Build. The Claude Code CLI is the hub. The Claude Agent SDK for Python drives it from code, with the CLI bundled.
  • Extend. Official Claude Code Plugins, Community Claude Code Plugins and Claude for Legal publish plugins that install into Claude Code.
  • Show up anywhere. The Claude Code GitHub Action runs Claude Code on pull requests and issues. Claude Desktop Buddy is ESP32 firmware that pairs with the Claude desktop app over Bluetooth LE and approves permission prompts from your desk.
  • Built by Claude. Claude's C Compiler is a Rust C compiler whose README says Claude Opus 4.6 wrote its code and docs. The dashed link to the model is build time only.

Outside the groups are the developer, GitHub, the Claude desktop app and the Anthropic API that every repo ultimately calls. Each repo box opens its own board, mapped from that repo's code.

The map

The map · Spine

Architecture

What's on this map
  • Anthropic API · anthropic
  • Agent SDK demos · custom app
  • Agent SDK (Python) · library app
  • Claude C Compiler · cli app
  • Claude Code · cli app
  • Claude Code Action · integration app
  • Claude for Legal · custom app
  • Community plugins · custom app
  • Official plugins · frontend app
  • Quickstarts · custom app
  • Cookbooks · custom app
  • Core runtime · platform foundation
  • Developer · actor
  • GitHub · github
  • Learning resources · bounded context
  • Plugin marketplaces · bounded context

The map · Layers

Layers5

What's on each layer

Agent SDK (Python)

Python SDK for Claude Code: a library that drives the Claude Code CLI as a subprocess, plus the tooling that builds and ships it. Container-grade L0 with 2 drill-downs (the SDK package and its examples).

  • Anthropic API · anthropic
  • GitHub Actions Workflows · infrastructure component
  • Claude Code CLI · cli tool
  • Developer & CI Helper Scripts · cli tool
  • Build, Release & CI Tooling · developer tooling
  • Examples · module
  • GitHub · github
  • MCP Python SDK · library package
  • PyPI · external integration
  • Wheel Build & Version Scripts · cli tool
  • Repo Claude Code Setup · domain group
  • Maintainer Slash Commands · agent command
  • Python Application Developer · actor
  • Slack · slack
  • Claude Agent SDK (Python package) · library package
  • Test Agent · ai agent
  • Verify Skill · agent skill
  • Workflow Hardening Guards · agent guardrail

Examples

Runnable example scripts demonstrating Claude Agent SDK features. Grain: terminal (plan fits, no drill-downs), one node per example script.

  • Agents · module
  • Agents & Extensibility · domain group
  • Filesystem Agents · module
  • Getting Started & Options · domain group
  • Hooks · module
  • Hooks & Permissions · domain group
  • Max Budget USD · module
  • MCP Calculator · module
  • Include Partial Messages · module
  • Plugin Example · module
  • Claude Agent SDK (Python package) · boundary port
  • Postgres Session Store · adapter component
  • Quick Start · module
  • Redis Session Store · adapter component
  • S3 Session Store · adapter component
  • Session Stores · domain group
  • Session Stores Package · module
  • Setting Sources · module
  • Stderr Callback · module
  • Streaming · domain group
  • Streaming Mode · module
  • Streaming Mode (IPython) · module
  • Streaming Mode (Trio) · module
  • System Prompt · module
  • Tool Permission Callback · module
  • Tools Option · module

Claude Agent SDK (Python package)

Python SDK package: public client/query API, runtime core over the Claude Code CLI, MCP bridge and session management. Grain: terminal (plan fits, no drill-downs).

  • ClaudeSDKClient · facade component
  • Control Protocol Query · engine component
  • Errors · schema model
  • Internal Client · engine component
  • MCP Compat · adapter component
  • MCP Integration · domain group
  • Message Parser · adapter component
  • Public API · domain group
  • query() · facade component
  • SDK MCP Bridge · adapter component
  • Package Exports · library package
  • Session Import · service component
  • Session Management · domain group
  • Session Mutations · service component
  • Session Resume · service component
  • Sessions · service component
  • Session Store · repository component
  • Session Store Conformance · developer tooling
  • Session Summary · service component
  • Subprocess CLI Transport · adapter component
  • Task Compat · adapter component
  • Transcript Mirror Batcher · service component
  • Types · schema model
  • Version Info · module

Claude C Compiler

CCC (Claude's C Compiler) is a from-scratch C compiler written in Rust that ships five target-selecting binaries (x86-64, i686, AArch64, RISC-V 64) and produces ELF executables with its own preprocessor, parser, SSA IR, optimizer, code generators, assemblers and linkers. System context: one opaque drill-down (the compiler crate) surrounded by the host toolchain artifacts it reads and the Linux runtime its output targets — container-grade with 1 drill-down.

  • Bundled Intrinsic Headers · library package
  • C Developers & Build Systems · actor
  • C Runtime Libraries · library package
  • GCC Fallback Toolchain · cli tool
  • Linux System C Headers · external integration
  • Linux Target Runtime · environment
  • CCC Compiler · cli tool

CCC Compiler

Rust compiler source: driver, frontend, IR, codegen, backend and shared common code. Grain: container-grade, six opaque drill-downs carry the compiler phases and the board holds only the driver and shared utilities.

  • Per-Arch Binaries · cli tool
  • Backend (assemblers, linkers, peephole) · module
  • Codegen and Optimization · module
  • Common Support · library package
  • Constant Evaluation · library package
  • Compiler Driver · cli tool
  • Frontend · module
  • IR Lowering · module
  • Linker Common and ELF · module
  • x86 Peephole Passes · module
  • Type System · library package

Backend (assemblers, linkers, peephole)

Compiler backend: shared codegen framework plus four architecture backends (x86, i686, ARM, RISC-V). Grain: terminal - the plan fits the band and the four arch backends are the plan's child units.

  • ARM Backend · module
  • Backend Core · module
  • i686 Backend · module
  • Numeric Labels · library package
  • Peephole Common · library package
  • Codegen and Optimization · boundary port
  • Linker Common and ELF · boundary port
  • RISC-V Backend · module
  • x86 Backend · module

ARM Backend

AArch64 backend: native assembler, linker and codegen peephole pass. Grain: terminal (no child units; component grain although the plan read over-band).

  • Assembler Driver · module
  • Assembly Parser · engine component
  • Assembler · domain group
  • ARM Codegen Module · module
  • Dynamic Executable Emitter · engine component
  • Shared Library Emitter · engine component
  • Static Executable Emitter · engine component
  • Instruction Encoder Core · engine component
  • FP and NEON Encoders · engine component
  • Integer, Branch and System Encoders · engine component
  • Load/Store Encoder · engine component
  • Linker Driver and Inputs · module
  • Output Emitters · domain group
  • Linker · domain group
  • Link Layout and Relocation · domain group
  • Peephole Optimizer · engine component
  • PLT/GOT Builder · engine component
  • Peephole Common · boundary port
  • Relocation Applier · engine component

i686 Backend

i686 backend slice: built-in ELF linker, assembler instruction encoder and peephole codegen. Grain: terminal; the plan proposed no drill-downs, band slightly exceeded by small file-level components.

  • Codegen Entry · facade component
  • Peephole Optimizer · engine component
  • Encoder Core · engine component
  • GP Integer Encoder · engine component
  • Register Tables · module
  • SSE Encoder · engine component
  • System Encoder · engine component
  • x87 Encoder · engine component
  • Assembler Encoder · domain group
  • Linker · domain group
  • Link Driver · facade component
  • Dynamic Symbols · engine component
  • ELF Emitter · engine component
  • Input Loader · adapter component
  • ELF Parser · adapter component
  • Relocation Processor · engine component
  • Section Merger · engine component
  • Shared Library Linker · engine component
  • Peephole Common · boundary port
  • x86 Backend · boundary port

RISC-V Backend

RISC-V 64 backend: instruction encoder, native ELF linker and codegen peephole pass. Grain: terminal (no child units or drill-downs; component grain although the plan read over-band).

  • Codegen · domain group
  • Codegen Module Root · module
  • Atomics Encoding · engine component
  • Base ISA Encoding · engine component
  • Compressed Encoding · engine component
  • Encoder Core · engine component
  • Floating-Point Encoding · engine component
  • Instruction Encoder · domain group
  • Pseudo-Instruction Expansion · engine component
  • System Encoding · engine component
  • Vector Encoding · engine component
  • ELF Linker · domain group
  • Input Loader · service component
  • Link Orchestrator · facade component
  • Linker Module Root · module
  • Relocation Applier · service component
  • Section Merger · service component
  • Symbol Resolver · service component
  • Linker Shared Types · library package
  • Peephole Optimizer · engine component
  • Peephole Common · boundary port

x86 Backend

x86-64 backend: code generator, built-in assembler (parser plus instruction encoders) and linker. Grain: terminal - the plan proposes no drill-downs; component grain is correct despite file count exceeding band.

  • Assembly Parser · engine component
  • Assembler Driver · engine component
  • Built-in Assembler · domain group
  • x86 Code Generator · engine component
  • AVX Encoder · engine component
  • Encoder Core · engine component
  • General-Purpose Integer Encoder · engine component
  • Instruction Encoder · domain group
  • Encoder Dispatch · engine component
  • Register Tables · engine component
  • SSE Encoder · engine component
  • System Instruction Encoder · engine component
  • x87 and Misc Encoder · engine component
  • Executable Emitter · engine component
  • Shared Object Emitter · engine component
  • Built-in Linker · domain group
  • Link Driver · engine component
  • Linker Entry · engine component
  • PLT and GOT Builder · engine component
  • Linker Types · engine component
  • Peephole Types · class interface
  • Peephole Common · boundary port

Codegen and Optimization

Codegen stage of the C compiler: SSA IR, optimization passes and per-architecture backends, plus shared helpers and crate root. Grain: terminal (plan fits the band, no drill-downs proposed); the three big subsystems are opaque child boards.

  • Backends · module
  • Shared Utilities · library package
  • Crate Root · library package
  • IR · module
  • Optimization Passes · module
  • Backend (assemblers, linkers, peephole) · boundary port
  • Common Support · boundary port
  • Constant Evaluation · boundary port
  • Frontend · boundary port
  • IR Lowering · boundary port
  • Linker Common and ELF · boundary port
  • Type System · boundary port

Backends

Compiler backend: per-architecture (x86-64, i686, AArch64, RISC-V) code generators over shared infrastructure. Grain: container-grade (plan over-band), architecture codegen directories are opaque drill-downs.

  • ARM Codegen · module
  • Backend Generation Driver · facade component
  • i686 Codegen Ops · engine component
  • Shared Utilities · boundary port
  • Crate Root · boundary port
  • IR · boundary port
  • RISC-V Codegen Ops · engine component
  • Shared Backend Core · module
  • Stack Slot Coalescing · engine component
  • X86 Codegen · module

ARM Codegen

AArch64 code generator: ArmCodegen core plus per-area instruction emission files (ALU, memory, atomics, calls support, inline asm, NEON). Grain: terminal, plan fits the band with no drill-downs; one flat set of component-grade nodes, the core file being the hub.

  • ALU Operations · engine component
  • Atomic Operations · engine component
  • Comparison Operations · engine component
  • Core Operations · domain group
  • ArmCodegen Core · engine component
  • Frame and ABI · domain group
  • Global Addresses · engine component
  • 128-bit Integer Ops · engine component
  • Inline Assembly · engine component
  • NEON and F128 Intrinsics · engine component
  • Memory Operations · engine component
  • Backend Generation Driver · boundary port
  • Shared Backend Core · boundary port
  • Prologue and Frame · engine component
  • Return Operations · engine component
  • Specialised Emission · domain group
  • Variadic Support · engine component

Shared Backend Core

Rust code generation backends of the C compiler: shared lowering framework, register allocation and stack layout, and per-architecture emitters (x86-64, i686, AArch64, RISC-V). Grain: over-band plan at the L4 depth cap, so files are grouped with containers and per-architecture directories are single nodes (no further drill-downs).

  • AArch64 Backend · module
  • Backend Common · module
  • Backend Traits · class interface
  • Call ABI · module
  • Casts and Soft-float · module
  • Codegen State · module
  • i686 Backend · module
  • Inline Asm Core · module
  • Liveness Analysis · engine component
  • ARM Codegen · boundary port
  • Backend Generation Driver · boundary port
  • Stack Slot Coalescing · boundary port
  • X86 Codegen · boundary port
  • Register Allocation and Stack Layout · domain group
  • Register Allocator · engine component
  • RISC-V Backend · module
  • Shared Backend Framework · domain group
  • Stack Layout · engine component
  • Target Architecture Backends · domain group
  • x86-64 Backend · module
  • x86 Common · module

X86 Codegen

x86-64 code generator: per-topic impl blocks on X86Codegen lowering IR to assembly. Grain: terminal (plan fits, no drill-downs), one node per file.

  • ALU Ops · engine component
  • Atomics · engine component
  • Cast Ops · engine component
  • Comparison and Select · engine component
  • Emit Core (X86Codegen) · engine component
  • Float Ops · engine component
  • Frame and ABI · domain group
  • Global Addresses · engine component
  • i128 Ops · engine component
  • Inline Asm Templates · adapter component
  • Intrinsics · engine component
  • Intrinsics and Inline Asm · domain group
  • Memory Ops · engine component
  • Memory and Addresses · domain group
  • Operation Lowering · domain group
  • Backend Generation Driver · boundary port
  • Shared Backend Core · boundary port
  • Prologue and Epilogue · engine component
  • Return Values · engine component
  • Variadic Args · engine component

IR

IR core: SSA data model, SSA construction passes, and lowering extension files. Grain: terminal, the plan fits the band with no drill-downs.

  • Atomic Builtin Lowering · service component
  • Bit Intrinsic Lowering · service component
  • Call Lowering · service component
  • CFG and Dominator Analysis · engine component
  • FP Classification Lowering · service component
  • Function Build State · service component
  • Instruction Set · schema model
  • Intrinsic Operations · schema model
  • IR Definitions · domain group
  • IR Module · schema model
  • IR Operations · schema model
  • IR Re-exports · module
  • Lowering Extensions · domain group
  • Alloca Promotion · engine component
  • Phi Elimination · engine component
  • Backends · boundary port
  • Shared Utilities · boundary port
  • SSA Construction · domain group
  • Switch Lowering · service component

Optimization Passes

IR optimization passes run in a fixpoint pipeline. Grain: terminal, the plan fits the band with no drill-downs.

  • Control Flow and Dead Code · domain group
  • CFG Simplify · engine component
  • Constant Fold · engine component
  • Copy Propagation · engine component
  • Dead Code Elimination · engine component
  • Dead Statics · engine component
  • Division by Constant · engine component
  • GVN · engine component
  • If Conversion · engine component
  • Inliner · engine component
  • Interprocedural · domain group
  • IPCP · engine component
  • IV Strength Reduction · engine component
  • LICM · engine component
  • Loop Analysis · service component
  • Loop Optimizations · domain group
  • Narrowing · engine component
  • Pass Pipeline · module
  • Shared Utilities · boundary port
  • IR · boundary port
  • Resolve Asm · engine component
  • Scalar Simplification · domain group
  • Instruction Simplify · engine component

Frontend

C compiler frontend: preprocessor, lexer/parser and semantic analysis. Grain: terminal, component-grade nodes with no drill-downs.

  • AST · schema model
  • Conditional Evaluation · engine component
  • Constant Evaluator · engine component
  • Declaration Parser · service component
  • Expression Parser · service component
  • Frontend Module · module
  • Includes and Pragmas · service component
  • Lexer · engine component
  • Lexer and Parser · domain group
  • Macro Definitions · service component
  • Parser Core · engine component
  • Codegen and Optimization · boundary port
  • Common Support · boundary port
  • Constant Evaluation · boundary port
  • Type System · boundary port
  • Preprocessor Pipeline · engine component
  • Sema Builtins · service component
  • Semantic Analysis · domain group
  • Semantic Analyzer · engine component
  • Statement Parser · service component
  • Text Processing · service component
  • Type Checker · service component
  • Type Context · store component
  • Type Parser · service component

IR Lowering

IR definitions and the AST-to-IR lowering pipeline. Grain: terminal; component-grade nodes, the plan found one cohesive cluster and no child units.

  • Complex Numbers · engine component
  • Const Eval · engine component
  • Global Address Eval · engine component
  • Constant Evaluation · domain group
  • Builtins · engine component
  • Expression Core · engine component
  • Expression Lowering · domain group
  • Operators and Assignment · engine component
  • Sizeof · engine component
  • Function Lowering · engine component
  • Global Declarations · engine component
  • Compound Global Init · engine component
  • Global Init Core · engine component
  • Global Lowering · domain group
  • IR Constants · module
  • IR Module · module
  • Local Initializers · engine component
  • Lowerer · engine component
  • Definitions · module
  • Lowering Driver · domain group
  • Lvalues · engine component
  • Pointer Analysis · engine component
  • Backend (assemblers, linkers, peephole) · boundary port
  • Codegen and Optimization · boundary port
  • Common Support · boundary port
  • Constant Evaluation · boundary port
  • Frontend · boundary port
  • Type System · boundary port
  • Reference Collection · engine component
  • Statement Lowering · domain group
  • Inline Asm · engine component
  • Control Flow · engine component
  • Statements · engine component
  • Struct Layout · engine component
  • Type Lowering · domain group
  • Types · engine component

Linker Common and ELF

ELF/assembler/linker shared infrastructure under src/backend: the shared ELF library, assembler frontend helpers and per-architecture writer/linker glue around the linker_common library. Grain: terminal, since the plan proposes no drill-downs beyond the one planned child and the board holds component-grade nodes.

  • Per-Architecture Linker Glue · domain group
  • ARM Assembler ELF Writer · adapter component
  • Assembler Frontend Support · module
  • Assembler ELF Output · domain group
  • ELF Core Library · library package
  • ELF Writer Common · engine component
  • i686 Assembler · adapter component
  • i686 Linker Symbols and Types · module
  • Linker Common · module
  • Backend (assemblers, linkers, peephole) · boundary port
  • RISC-V Assembler · module
  • RISC-V Linker Emit · module
  • x86 and ARM Linker ELF Glue · adapter component
  • x86 Assembler ELF Writer · adapter component

Linker Common

Shared ELF64 linker infrastructure used by the x86, ARM and RISC-V backends: parsing, archives, symbols, section merging, dynamic linking, gc and emission helpers. Grain: terminal - the plan fits the band with no drill-downs, so nodes are component-grade.

  • Archive Loader · engine component
  • Dynamic Linking Support · engine component
  • Dynamic String and Hash Tables · service component
  • EH Frame Header Builder · engine component
  • ELF64 Types · schema model
  • ELF Writer Helpers · service component
  • Section Garbage Collection · engine component
  • Input Loading · domain group
  • Linker Argument Parser · service component
  • Linker Common Facade · facade component
  • Object Parser · engine component
  • Output Emission · domain group
  • ELF Core Library · boundary port
  • Section Merger · engine component
  • Shared Library Parser · engine component
  • Symbols and Layout · domain group
  • Symbol Tables · service component
  • Undefined Symbol Check · service component

x86 Peephole Passes

x86-64 assembly-text peephole optimizer: an orchestrator plus individual optimization passes. Grain: terminal (plan fits, no drill-downs), one node per pass file.

  • Callee-Save Elimination · engine component
  • Compare-Branch Fusion · engine component
  • Copy Propagation · engine component
  • Dataflow Cleanup Passes · domain group
  • Dead Code Elimination · engine component
  • Frame Cleanup Passes · domain group
  • Frame Compaction · engine component
  • Local Patterns · engine component
  • Loop Trampoline Elimination · engine component
  • Memory Operand Folding · engine component
  • Pass Helpers · module
  • Pass Orchestrator · engine component
  • Pattern Rewrite Passes · domain group
  • Peephole Module Entry · module
  • Backend (assemblers, linkers, peephole) · boundary port
  • Push/Pop Elimination · engine component
  • Store Forwarding · engine component
  • Tail Call Optimization · engine component

Claude Code

The public Claude Code repository: the source of the built-in mods, the bundled plugin marketplace, the issue automation that runs the repo, and reference gateway and managed-settings deployments. Container-grade with 1 drill-down (Mods).

  • Anthropic API · anthropic
  • Amazon Bedrock · aws bedrock
  • Bundled Plugin Marketplace · domain group
  • Claude Code (host engine) · ai agent
  • Devcontainer & Firewall · environment
  • Developer / Operator · actor
  • Feature Dev · plugin
  • Claude Apps Gateway Examples · infrastructure component
  • Google Vertex AI (Agent Platform) · gcp vertex ai
  • GitHub · github
  • GitHub Actions Workflows · job worker
  • Git & Review Workflow Plugins · plugin
  • Hook Examples · agent hook
  • Hookify · plugin
  • Issue Automation Scripts · job worker
  • Managed Settings Examples · environment
  • Built-in Mods · plugin
  • Plugin Dev Toolkit · plugin
  • PR Review Toolkit · plugin
  • Reference Configurations & Deployments · domain group
  • Repo Slash Commands · agent command
  • Repository Automation & Dev Environment · domain group
  • Agent SDK & Model Migration Plugins · plugin
  • Security Guidance · plugin
  • Output Style & Design Plugins · plugin

Built-in Mods

Mods of Claude Code: agents-md, sec-default, diff and telemetry hook bundles. Grain: terminal-ish at this scope, own mods inline with the three plan child units carried as opaque drill-downs.

  • AGENTS.md Mod · plugin
  • Columns · plugin
  • Hooks · plugin
  • Default Security Mod · plugin
  • Telemetry Hooks · plugin

Columns

Diff pane hooks for the columns mod: git backend, state, recording and views. Grain: terminal; the plan reads under-band with one cluster and no drill-downs, so component grain is correct.

  • Backend Contract · service component
  • Body and Dialog Views · domain group
  • Detail and Section Views · domain group
  • Git Backend · domain group
  • Git Fetching and Argv · adapter component
  • Git Output Parsing · engine component
  • Git Probes · service component
  • Diff Tiers · engine component
  • Shared Helpers · module
  • Hook Registration · facade component
  • Limits and Names · domain group
  • Column Limits · module
  • Size and Timing Limits · module
  • Names and Texts · module
  • Pane Logic · domain group
  • Pane State · store component
  • Hooks · boundary port
  • Change Recording · handler component
  • Turn Diffs · engine component
  • Body View · ui component
  • Detail View · ui component
  • Dialog and Entries Views · ui component
  • Layout View · layout component
  • Sections View · ui component

Hooks

Hooks of the diff mod: classification, pane state and turn/record hooks, with git and views as drill-downs. Grain: terminal-ish component grain with two opaque child drill-downs (plan fits band at 15 predicted).

  • Ask · hook component
  • Backend · module
  • Classify · engine component
  • Git · module
  • Host · hook component
  • Pane Hooks · domain group
  • Pane State · hook component
  • Pane Toggle · hook component
  • Record · hook component
  • Todos · hook component
  • Turn and Record Hooks · domain group
  • Turns · schema model
  • Views · module

Git

Type definitions of the diff mod's git hook: diff results, git execution, branch base, dating and untracked scoping. Grain: terminal, the 29 files are type modules grouped into five concern nodes with no drill-downs warranted.

  • Branch Base Types · schema model
  • Dating and Walk Types · schema model
  • Diff Data Model · schema model
  • Git Execution Types · schema model
  • Untracked Types · schema model

Views

Type contracts of the diff pane's views: body layout, file detail, list rows, the kit handed to each drawing, pane actions and seat. Grain: terminal (plan fits the band, no drill-downs proposed), component grain. Types are kept as schema_model deliberately: every file is a pure type declaration, not a UI component.

  • Body Types · schema model
  • Detail Types · schema model
  • Kit Types · schema model
  • Message Pane · schema model
  • Pane Actions · schema model
  • Pane Seat · schema model
  • Section Types · schema model

Telemetry Hooks

Hook plugin that gates telemetry.* calls, validates entries, gathers session context, batches rows and sends them to an ingest endpoint. Grain: container-grade by band (over-band plan) but the plan proposes no drill-downs; most files are one-function modules, so nodes are directory-level responsibility areas.

  • Analytics Switch · service component
  • Batching and Retry · service component
  • Context Assembly · service component
  • Environment Fields · service component
  • Identity · service component
  • Machine and OS · service component
  • Process Probe · adapter component
  • Remote Hash · service component
  • Terminal, Shell and VCS · service component
  • Deployment Detection · service component
  • Entry Validation · service component
  • Hook Registration · handler component
  • Runtime Inputs · schema model
  • Session Context · domain group
  • Call Gate · handler component
  • Telemetry Sender · engine component

Claude Code Action

System context for the Claude Code GitHub Action: the action itself, the standalone base action it executes Claude through, the repo's own CI and Claude-powered automation, and the external platforms they talk to. Container-grade with 1 drill-down (the action's src tree).

  • Agent Approval Check · agent guardrail
  • Anthropic API · anthropic
  • Claude Code Base Action · library package
  • CI Workflows · infrastructure component
  • Claude Agent SDK / Claude Code CLI · cli tool
  • Bedrock / Vertex AI / Foundry · external integration
  • Guarded Shell Scripts · cli tool
  • GitHub · github
  • GitHub User · actor
  • PR Stamp Sweep Workflow · agent orchestrator
  • Repo Automation · developer tooling
  • Repo Slash Commands · agent command
  • Review Subagents · ai agent
  • Claude Code Action · service
  • Workflow Hardening Check · agent guardrail

Claude Code Action

Inside the Claude Code Action: entrypoints, mode lifecycle, prompt construction, access control, GitHub operations and the MCP servers it gives Claude. Terminal: no drill-downs.

  • Access Control · security zone
  • Actor and Permission Checks · agent guardrail
  • Agent Mode · service component
  • Branch Operations · service component
  • Sensitive Config Restore · agent guardrail
  • Content Sanitizer · agent guardrail
  • Context Formatter · engine component
  • Entrypoints · domain group
  • Git Auth and Signing · adapter component
  • GitHub Actions Server · mcp server
  • GitHub Client · adapter component
  • GitHub Comment Server · mcp server
  • GitHub Context · schema model
  • GitHub Data Fetcher · repository component
  • GitHub File Ops Server · mcp server
  • GitHub Inline Comment Server · mcp server
  • GitHub Operations · domain group
  • GitHub Token Setup · adapter component
  • Comment Image Downloader · adapter component
  • MCP Config Installer · service component
  • MCP Servers · domain group
  • Mode Detector · engine component
  • Modes · bounded context
  • Claude Code Base Action · boundary port
  • Post-run Reporting · handler component
  • Prepare Step · handler component
  • Prompt Builder · engine component
  • Prompt Construction · domain group
  • Run Orchestrator · agent orchestrator
  • Tag Mode · service component
  • Tracking Comment · service component
  • Trigger Check · engine component

Official plugins

Anthropic's official Claude Code plugin marketplace: the marketplace.json catalog, first-party plugins, partner MCP integrations, chat-channel MCP servers, and the CI that validates and bumps listed plugins. Container-grade System Context with 1 drill-down (plugins).

  • macOS Messages · plugin
  • Channel Plugins · domain group
  • Claude Code · ai agent
  • claude-plugins-community Actions · plugin
  • Discord · plugin
  • Discord Channel · mcp server
  • External PR Scope Guard · agent guardrail
  • Fakechat Channel · mcp server
  • Frontmatter Validator · cli tool
  • GitHub · github
  • iMessage Channel · mcp server
  • Marketplace Catalog · data store
  • Marketplace CI · developer tooling
  • MCP Integration Plugins · plugin
  • First-party Plugins · plugin
  • Plugin Validation Workflows · cli tool
  • Plugin SHA Bumper · job worker
  • Telegram Bot API · plugin
  • Telegram Channel · mcp server
  • Vendor MCP Servers · mcp server

First-party Plugins

Catalogue of independent Claude Code plugins, one node per plugin; five plugins drill down. Grain: container-grade (each plugin is a container-level unit; the plan's over-band verdict reflects component-level counts inside plugins, which stay behind the 5 child boards or inside single plugin nodes).

  • Agent SDK Dev · plugin
  • Artifacts, Design & Reports · domain group
  • Authoring & Extension Tooling · domain group
  • Claude Code Setup · plugin
  • CLAUDE.md Management · plugin
  • Claude Security · plugin
  • Code Modernization · plugin
  • Code Review · plugin
  • Code Simplifier · plugin
  • Commit Commands · plugin
  • CWC Makers · plugin
  • Example Plugin · plugin
  • Feature Dev · plugin
  • Frontend Design · plugin
  • Git Workflow & Loops · domain group
  • Hardware & Integrations · domain group
  • Hookify · plugin
  • Math Reasoning · domain group
  • Math Olympiad · plugin
  • Math Proof · plugin
  • MCP Server Dev · plugin
  • MCP Tunnels · plugin
  • Code Modernization Suite · domain group
  • Playground · plugin
  • Plugin Dev · plugin
  • Project Artifact · plugin
  • PR Review Toolkit · plugin
  • Ralph Loop · plugin
  • Reader · plugin
  • Receipts · plugin
  • Review, Quality & Security · domain group
  • Security Guidance · plugin
  • Session Report · plugin
  • Skill Creator · plugin

Claude Security

Claude Security plugin: orchestrator, skill, scan workflow, nine scan and patch agents, hooks, and the scripts drill-down. Grain: terminal (plan fits the band, no drill-downs proposed; scripts is the only planned child board).

  • Security Lead · agent orchestrator
  • Front-Desk Skill · agent skill
  • Explore · ai agent
  • Plugin Hooks · agent hook
  • Patch Agents · domain group
  • Patch Generator · ai agent
  • Patch Verifier · ai agent
  • Scan Agents · domain group
  • Scan Inventory · ai agent
  • Scan Loader · ai agent
  • Scan Redactor · ai agent
  • Scan Researcher · ai agent
  • Scan Verifier · ai agent
  • Scan Workflow · agent orchestrator
  • Scripts · module

Scripts

Python stdlib scripts for the claude-security plugin: four entry-point CLIs (scan meta, result recording, report rendering, patch artifacts) over a shared lib of finding, SARIF, CWE and path utilities. Grain: terminal (budget fits, no drill-downs proposed), component grain.

  • Chain State · module
  • Console Output · module
  • CWE Catalog · module
  • Entry-point Scripts · domain group
  • Finding Model · module
  • Findings and Products · domain group
  • Patch Artifacts · cli tool
  • Path Utilities · module
  • Plugin Constants · module
  • Render Report · cli tool
  • Revision Range · module
  • Run Support · domain group
  • SARIF Encoder · module
  • Save Result · cli tool
  • Secret Redaction · module
  • Source Locator · module
  • Strict JSON · module
  • Write Scan Meta · cli tool

Code Modernization

Code Modernization plugin: slash commands, specialist subagents, multi-agent workflows and Python evidence/report scripts for legacy modernization. Grain: container-grade for the commands drill-down (the only child board); the over-band plan reading came from the 36-file directory fallback, and the remaining own nodes are component-grain.

  • Architecture Critic · agent skill
  • Business Rules Extractor · agent skill
  • Commands · agent command
  • Extract Rules Workflow · agent orchestrator
  • Harden Scan Workflow · agent orchestrator
  • Legacy Analyst · agent skill
  • Portfolio Assess Workflow · agent orchestrator
  • Proof Evidence Scripts · module
  • Reimagine Scaffold Workflow · agent orchestrator
  • Reporting Scripts · module
  • Rule Tooling Scripts · module
  • Scaffolder · agent skill
  • Security Auditor · agent skill
  • Specialist Agents · domain group
  • Test Engineer · agent skill
  • Uplift Deltas Workflow · agent orchestrator
  • Uplift Migrate Workflow · agent orchestrator
  • Uplift Migrator · agent skill
  • Version Delta Analyst · agent skill
  • Workflows · domain group

Commands

The 13 slash-command prompts that drive each modernization phase, from the start-here front door through assess, map, rules, brief, build, verify. Grain: terminal, the plan fits the band with no drill-downs proposed. Edges are the recommended sequencing between commands; modernize is the bootstrap entry at board root. (Terminal grain: budgetVerdict fits, no drill-downs.)

  • Build · domain group
  • Discover and Plan · domain group
  • Modernize (Start Here) · agent command
  • Assess · agent command
  • Brief · agent command
  • Extract Rules · agent command
  • Harden · agent command
  • Map · agent command
  • Preflight · agent command
  • Reimagine · agent command
  • Review Rules · agent command
  • Status · agent command
  • Transform · agent command
  • Uplift · agent command
  • Verify · agent command
  • Prove and Track · domain group

Hookify

Hookify plugin: markdown-defined rules enforced by Python hook entrypoints, plus authoring commands, agent and skill. Grain: terminal, the plan fits the band with no drill-downs.

  • Rule Config Loader · service component
  • /hookify:configure Command · agent command
  • Conversation Analyzer · ai agent
  • /hookify:help Command · agent command
  • /hookify Command · agent command
  • Hook Runtime · domain group
  • /hookify:list Command · agent command
  • PostToolUse Hook · agent hook
  • PreToolUse Hook · agent hook
  • Rule Authoring · domain group
  • Rule Engine · engine component
  • Stop Hook · agent hook
  • UserPromptSubmit Hook · agent hook
  • Writing Rules Skill · agent skill

Plugin Dev

Plugin Dev: toolkit plugin with skills, agents and a guided command for building Claude Code plugins. Grain: terminal (plan fits the L2 band, no drill-downs proposed). The create-plugin command is a board-root singleton, the workflow entry point.

  • Agent Creator · ai agent
  • Agent Development · agent skill
  • Authoring Skills · domain group
  • Command Development · agent skill
  • Create Plugin Command · agent command
  • Hook Development · agent skill
  • MCP Integration · agent skill
  • Plugin Settings · agent skill
  • Plugin Structure · agent skill
  • Plugin Validator · ai agent
  • Review and Generation Agents · domain group
  • Skill Development · agent skill
  • Skill Reviewer · ai agent

Reader

Hooks of the code-modernization plugin: read-only parsers of modernization artifacts, estate treemap, rule review deck and live pane views. Grain: terminal, since the plan fits the band with no drill-downs.

  • Artifact Readers · domain group
  • Brief Reader · adapter component
  • Deck View · ui component
  • Estate Discovery · engine component
  • Estate Map · domain group
  • Estate Model · engine component
  • Estate Tiles · engine component
  • Fleet Registry · store component
  • Hook Registration · facade component
  • Hook Runtime · domain group
  • Live Pane Views · domain group
  • Modernized Reader · adapter component
  • Pane View · ui component
  • Progress Snapshot · facade component
  • Review Deck · engine component
  • Rule Review · domain group
  • Rules Reader · adapter component
  • Session State · store component
  • Shared Helpers · library package
  • Topology Reader · adapter component
  • Treemap Layout · engine component
  • Uplift Reader · adapter component
  • Verification Reader · adapter component
  • X-Ray Context · handler component

What to notice

Inbound · Signals

Insights11 analyses

17Insights
1Critical
risk6opportunity1strength7observation3
  • +12 more
Read all 17

Optional SessionStore methods raise instead of being absent, so a change in Types reaches 13 modules

risk · critical · verified

Types defines the SessionStore protocol, whose optional methods have default bodies that raise NotImplementedError. Support is detected by checking whether the adapter's class overrides the default (_store_implements), and continue_conversation is refused up front when list_sessions is not overridden. That contract lives in types.py, which 13 of 23 modules on the board depend on, only 3 directly: Control Protocol Query, Session Store and ClaudeSDKClient.

Impact: Changing which SessionStore methods are required, or what their defaults do, silently changes the override check that session validation and resume rely on.

Treat the raising defaults in SessionStore as the definition of 'optional'. Add a new optional method as a raising default, and cover it in session_store_validation so unsupported combinations fail before the subprocess starts.

  1. Types
  2. Control Protocol Query
  3. ClaudeSDKClient
  4. Session Store
  5. ClaudeSDKClient

The Lowerer is one struct spread over 38 files and 29,700 lines with no unit tests

risk · high · verified

A single Lowerer type has impl blocks in 38 of the 43 files under src/ir/lowering, about 29,700 lines and roughly 680 functions, sharing 27 fields of mutable state (globals, function metadata, type caches, sema maps). The repo's own cleanup backlog lists it as item 7, and global_init.rs is flagged for 16 levels of nesting. None of these files contains a #[test].

Impact: Any change to lowering can touch shared state used by expression, statement, global-initializer and type code at once, and regressions surface only when a whole C program is compiled.

Recommendation (large effort): Carve the Lowerer into owned sub-components with narrow interfaces (type mapping, global initializers, expression lowering) that take explicit context instead of &mut self, and add focused unit tests for each, beginning with types.rs and global_init*.rs whose inputs are pure data.

  1. IR Lowering
  2. Lowerer
  3. Operators and Assignment
  4. Compound Global Init
  5. Types

Day 1: start with marketplace.json, the contract everything else serves

observation · high · verified

The Marketplace Catalog is the most connected part of the system. Claude Code installs from it, it lists every first-party, channel and integration plugin by source path or pinned git SHA, and three of the four CI jobs read or rewrite it. Reading .claude-plugin/marketplace.json first explains why the rest of the repo exists.

Look at one local entry (./plugins/...), one external entry (git-subdir with ref and sha), and the renames map. Those three shapes cover how every plugin reaches users.

  1. Marketplace Catalog
  2. First-party Plugins
  3. Channel Plugins
  4. MCP Integration Plugins

Every SDK module imports its exceptions from one file, _errors.py

risk · high · verified

The exception hierarchy in _errors.py (ClaudeSDKError, CLIConnectionError, CLINotFoundError, ProcessError, ResultError, CLIJSONDecodeError, MessageParseError) is imported directly by the CLI transport, ClaudeSDKClient, the control protocol query, the message parser and the package entry point. None has a fallback. A breaking change to this file reaches all five, and through the transport it reaches the internal client that drives one-shot queries.

Impact: Renaming or reshaping an exception breaks the public exports and every place that catches or raises it, so callers lose their error handling at once.

Recommendation (small effort): Treat _errors.py as a frozen public contract: add new exception classes as subclasses and keep existing names and constructor arguments stable. Cover the hierarchy with a test that imports every name the package entry point re-exports.

  1. Errors
  2. Subprocess CLI Transport
  3. Internal Client
  4. ClaudeSDKClient
  5. Control Protocol Query
  6. Message Parser
  7. Package Exports

Partner MCP plugins launch unpinned packages on every user's machine

risk · high · verified

Several integration plugins start their server from a moving target: Playwright runs npx @playwright/mcp@latest, Firebase runs npx firebase-tools@latest, and Serena runs uvx from the default branch of github.com/oraios/serena. Only Terraform pins a version (Docker image 0.4.0). Whatever those registries or that branch serve next is what users execute, with the session's file and tool access.

Impact: A compromised upstream release or branch would run arbitrary code for every user of these plugins, unreviewed by this repo's CI.

Recommendation (small effort): Pin each launcher to an exact version (or a commit for uvx git sources) in its .mcp.json, and let the SHA-bump job move the pins so upgrades pass through scan and validation.

  1. MCP Integration Plugins
  2. Vendor MCP Servers

PR-controlled agent config is restored from the base branch before Claude starts

strength · medium · verified

On pull requests run.ts calls restoreConfigFromBase, which replaces .claude, .mcp.json, .claude.json, CLAUDE.md, CLAUDE.local.md, .gitmodules, .ripgreprc and .husky with the base branch versions. A PR therefore cannot add hooks, MCP servers or instructions to the agent that reviews it.

SENSITIVE_PATHS in src/github/operations/restore-config.ts must grow whenever Claude Code starts reading a new file from the working directory at startup.

  1. Run Orchestrator
  2. Sensitive Config Restore

Control-protocol failures escape the SDK exception hierarchy

risk · medium · verified

Control Protocol Query and SDK MCP Bridge raise plain Exception at 13 sites: control request timeouts, CLI error responses, missing callbacks, unsupported subtypes and closed MCP sessions (query.py:404, 591-751, 1145; sdk_mcp_bridge.py:76-370). The Errors module defines ClaudeSDKError and typed subclasses, but none is used here.

Impact: Callers who catch ClaudeSDKError around interrupt(), set_model() or get_mcp_status() miss these failures and must string-match messages, which makes every wording change a breaking change.

Recommendation (small effort): Add ControlRequestError and ControlRequestTimeoutError subclasses of ClaudeSDKError (the timeout also subclassing TimeoutError) and raise them from _send_control_request and the bridge.

  1. Control Protocol Query
  2. Errors

Both public entry points share one control-protocol engine

observation · medium · verified

query() reaches Control Protocol Query through the Internal Client and ClaudeSDKClient uses it directly; the engine in turn depends on the transport, Message Parser, SDK MCP Bridge, Transcript Mirror Batcher, Task Compat, Errors and Types. Its run-end logic (session state, in-flight task ledger, a 10-minute ceiling) decides when stdin closes for both.

Impact: A change to when stdin closes, or to how a control request is answered, alters hooks, permissions and in-process MCP tools for every SDK user at once.

The engine is well commented with issue references (#1088, #1190), and test_run_end_subprocess.py exercises the run-end paths against a subprocess; keep changes here behind those tests.

  1. Control Protocol Query
  2. Internal Client
  3. query()
  4. ClaudeSDKClient
  5. SDK MCP Bridge

The triage and dedupe agents are boxed in identity, tools and network

strength · medium · verified

Both Claude jobs authenticate with a short-lived token from workload identity federation instead of a stored key, hold only issues: write, run in auto permission mode with Write, Edit, WebFetch and WebSearch disallowed, call GitHub only through the wrapper scripts, and run on a runner whose egress is limited to an explicit host list.

Impact: A compromised run can at most mislabel or comment on the one issue that triggered it.

This is a strong template for any further agent in this repo: per-job token, script-mediated writes, explicit egress list and per-script call caps.

  1. GitHub Actions Workflows
  2. Anthropic API
  3. Issue Automation Scripts

Label decisions by the triage agent leave no reason a maintainer can see

risk · medium · verified

The triage prompt forbids comments, so when Claude adds invalid, needs-info or duplicate the issue shows only a label from github-actions. The reasoning exists only in the Actions run log, which expires, and the only metric sent out is a dedupe count to Statsig.

Impact: Wrong labels that later auto-close issues are hard to audit or trace back to the input that caused them.

Recommendation (small effort): Write a one-line reason per label to the job summary and a structured log event (issue, label, reason, model, run id) so decisions can be reviewed in bulk.

  1. Repo Slash Commands
  2. Issue Automation Scripts

Spend and run length are bounded at the transport

strength · low · verified

max_budget_usd, task_budget and max_turns are passed to the CLI as flags, and Control Protocol Query bounds how long stdin stays open between turns with a 10-minute ceiling (CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS), so a background agent that never reports idle cannot hold a session open indefinitely.

These limits are enforced by the CLI, so they hold even when the embedding code forgets to stop iterating. The SDK does not check them itself.

  1. Subprocess CLI Transport
  2. Control Protocol Query

The subprocess transport carries five responsibilities in one file

opportunity · low · verified

subprocess_cli.py is 1,228 lines combining CLI discovery across platforms, Windows path and batch-script security, options-to-argv building, process lifecycle with shielded terminate and kill escalation, and NDJSON line framing. The framing and lifecycle parts are carefully tested (test_subprocess_buffering.py, test_close_cancellation.py), but every change goes through the same module.

Recommendation (medium effort): Split it into cli_discovery, command_builder and process modules behind the existing SubprocessCLITransport class; the framer and command builder are pure and easy to test on their own.

Command-line construction is hardened against argument injection

strength · low · verified

The transport passes resume, session_id, resume_session_at and resume_drops_turn as --flag=value so a dash-leading value cannot become a new flag, applies the same rule to extra_args, refuses .bat/.cmd CLIs on Windows (the BatBadBut class, CVE-2024-27980), rejects cmd.exe metacharacters in session values, and validates skill names before formatting them into --allowedTools rules.

Session titles and IDs are often taken from end users, so these guards are what keeps a hostile resume value from rewriting the CLI's permission flags. New options that take untrusted strings should use the same equals form.

Every agent-driven closure has a human override before it happens

strength · low · verified

Duplicate comments say the issue closes in 3 days, and auto-close-duplicates skips any issue whose author reacted thumbs-down. The sweep skips lifecycle closures when a human commented after the label, triage removes stale and autoclose on new human comments, and remove-autoclose-label clears autoclose on any comment.

Impact: Authors can stop a wrong closure with one reaction or comment.

The escape hatch depends on the author noticing within 3 to 7 days; it does not cover issues whose author has gone quiet.

  1. GitHub
  2. GitHub Actions Workflows
  3. Issue Automation Scripts

Skip for now: config-only integrations, CI plumbing and single-file plugins

observation · low · verified

Newcomers can safely ignore the MCP Integration Plugins (each is a few lines of .mcp.json), the shared community actions and the vendor servers, which live outside this repo. Of the 27 first-party plugins, 22 are prompt-only command or skill bundles with no code paths worth tracing.

Return to these only when touching that specific plugin or integration; none of them affects how the others work.

  1. MCP Integration Plugins
  2. Vendor MCP Servers

External-PR workflows never execute contributor code

strength · low · verified

Both pull_request_target workflows check out only the base repository and read the head marketplace.json as data through the GitHub API. External-pr-scope.js trusts the source repo rather than the submitter: a PR is in scope only if it adds entries pinned to a commit in a repo that already backs a live entry.

This avoids the classic pull_request_target pitfall of checking out and running head code with a write token. Keep that invariant explicit in review, since one added checkout of the PR ref would undo it.

  1. External PR Scope Guard
  2. Marketplace Catalog

Channel servers keep bot tokens owner-only and refuse injected pairing requests

strength · low · verified

The Telegram server writes its .env and access.json with mode 0600 inside a 0700 state directory, defaults new chats to pairing mode, and instructs the session never to approve pairings or edit the allowlist because a channel message asked. Senders not on the allowlist are dropped before their text reaches the session.

Access changes happen only through the access skill run in the user's terminal, which keeps chat input from widening its own privileges.

In the code

Database 1 · Endpoints 4 · AuthZ 17 · Clients 13

Inbound · From code

Database

1table

No primary key
0
Partitioned
0
Deprecated
0
Tables per schema
  • public1

Tables

Inbound · From code

Endpoints

4endpoints

Public
4
Deprecated
0
Rate-limited
0
By method
  • GET2
  • POST1
  • WEBSOCKET1

Endpoints

Inbound · From code

AuthZ

17roles

1 role grants nothing

Permissions
26
Policies
6
Resource types
15

Needs a look

Permissions per role
  • User tier (plugins a person installs)8
  • Append tier (organization, innermost)2
  • AWS gateway task role2
  • GCP gateway service account2
  • Prepend tier (organization, outermost)2

+12 more

Inbound · From code

Clients

13clients

HTTP
13
gRPC
0
Calls
63
Calls by target
  • api.github.com45
  • api.telegram.org9
  • api.anthropic.com8
  • pypi.org1
  • discord.com0

Clients

+9 more