docs: fix architecture diagram — apcore is embedded, not a middle layer

apcore is not a separate layer between AI agents and apflow.
It's embedded inside apflow as the mechanism that makes orchestration
capabilities AI-perceivable (like CAN bus makes car systems perceivable
to FSD, not a layer between driver and car).

Updated: README architecture diagram, CLAUDE.md dependency description.

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

Author: tercel

CLAUDE.md

@@ -18,10 +18,10 @@ apflow is NOT an AI product. It is a deterministic, reliable orchestration engin
 - **app.py**: Bootstrap factory — `create_app()` initializes full stack
 - **cli.py**: Entry points — `apflow serve`, `apflow mcp`, `apflow info`
 
-### Key Dependencies
-- `apcore` — Schema-enforced AI-perceivable module standard
-- `apcore-mcp` — MCP server (AI agents discover and invoke orchestration)
-- `apcore-a2a` — A2A server (services invoke orchestration via HTTP)
+### Key Dependencies (embedded, not external layers)
+- `apcore` — Module standard embedded inside apflow (like CAN bus in a car)
+- `apcore-mcp` — Protocol adapter: exposes modules as MCP tools
+- `apcore-a2a` — Protocol adapter: exposes modules as A2A skills
 - `apcore-cli` — CLI generation (humans operate orchestration)
 
 ## Core Principles

README.md

@@ -117,18 +117,38 @@ Every orchestration capability is automatically exposed as an apcore Module:
 ## Architecture
 
 ```
-AI Agents (bring your own — Claude, Gemini, LangGraph, any)
-    ↓ invoke via MCP / A2A / CLI
-apcore (Module Standard — makes everything AI-perceivable)
+AI Agents / Services / Humans
+    ↓ discover & invoke
     ↓
-apflow (This project — deterministic orchestration engine)
-  ├─ Task Orchestration (dependency graphs, priority, parallel)
-  ├─ Durable Execution (checkpoint, retry, circuit breaker)
-  ├─ Cost Governance (budget, policy, downgrade)
-  ├─ Distributed Runtime (leader election, leasing)
-  └─ Storage (SQLite / PostgreSQL)
+┌──────────────────────────────────────────────┐
+│  apflow — AI-Perceivable Distributed         │
+│           Orchestration Engine                │
+│                                              │
+│  ┌── Protocol Exposure (apcore) ───────────┐ │
+│  │ apcore-mcp · apcore-a2a · apcore-cli    │ │
+│  │              ↕                          │ │
+│  │       apcore Registry (Modules)         │ │
+│  └──────────────┬──────────────────────────┘ │
+│                 │                             │
+│  ┌──────────────▼──────────────────────────┐ │
+│  │  Orchestration Core                     │ │
+│  │  TaskManager · TaskCreator · Scheduler  │ │
+│  │  Dependency Graphs · Priority · DAG     │ │
+│  ├─────────────────────────────────────────┤ │
+│  │  Durability    │  Governance            │ │
+│  │  Checkpoint    │  Budget · Policy       │ │
+│  │  Retry         │  Model Downgrade       │ │
+│  │  Circuit Break │  Usage Reporting       │ │
+│  ├─────────────────────────────────────────┤ │
+│  │  Infrastructure                         │ │
+│  │  SQLite/PostgreSQL · Distributed Runtime│ │
+│  │  ConfigManager · Adapters               │ │
+│  └─────────────────────────────────────────┘ │
+└──────────────────────────────────────────────┘
 ```
 
+apcore is not a separate layer — it's embedded inside apflow as the mechanism that makes orchestration capabilities AI-perceivable (like a CAN bus makes car systems perceivable to FSD).
+
 ## Built-in Executors
 
 | Executor | Purpose |