经典 Actor Model:
  Actor A --[message]--> Actor Runtime --[dispatch]--> Actor B mailbox

Claude Code Team:
  Agent A --[writeToMailbox]--> 文件系统 --[500ms poll]--> Agent B 读取

┌──────────────────────────────────────────────────────────┐
│ runInProcessTeammate() -- 主循环                          │
│                                                          │
│  while (!aborted && !shouldExit) {                       │
│    ┌──────────────┐                                      │
│    │ runAgent()   │ <── 调用 query() API，执行工具       │
│    │ (Line 1175)  │     产出 Message 流                  │
│    └──────┬───────┘                                      │
│           │ 完成/中断                                    │
│           v                                              │
│    ┌──────────────────────┐                              │
│    │ sendIdleNotification │ <── 写入 Leader 信箱         │
│    │ (Line 1332-1347)     │                              │
│    └──────┬───────────────┘                              │
│           │                                              │
│           v                                              │
│    ┌──────────────────────────────┐                      │
│    │ waitForNextPromptOrShutdown  │ <── 500ms 轮询信箱   │
│    │ (Line 1354-1361)            │     + TaskList 检查   │
│    └──────┬───────────────────────┘                      │
│           │ 收到消息                                     │
│           v                                              │
│    ┌──────────────────────┐                              │
│    │ 格式化为 XML wrapper │ <── formatAsTeammateMessage  │
│    │ 作为新 prompt 注入   │                              │
│    └──────────────────────┘                              │
│    (回到循环顶部)                                        │
│                                                          │
└──────────────────────────────────────────────────────────┘

普通消息 ──── 纯文本（from/text/timestamp/read）
                │
结构化消息 ──┬─ idle_notification          空闲通知
             ├─ permission_request          工具权限请求
             ├─ permission_response         权限响应
             ├─ sandbox_permission_request  沙箱网络权限
             ├─ sandbox_permission_response 沙箱响应
             ├─ shutdown_request            关闭请求
             ├─ shutdown_approved           同意关闭
             ├─ shutdown_rejected           拒绝关闭
             ├─ plan_approval_request       计划审批请求
             ├─ plan_approval_response      计划审批响应
             ├─ team_permission_update      团队权限广播
             ├─ mode_set_request            模式变更请求
             └─ task_assignment             任务分配

startInProcessTeammate()           -- 入口，fire-and-forget
  └── runInProcessTeammate()       -- while 循环
        ├── runAgent()             -- 单次 LLM 交互循环
        │     └── query()          -- 调用 Claude API
        ├── sendIdleNotification() -- 通知 Leader
        └── waitForNextPrompt()    -- 轮询信箱

TeammateExecutor（统一接口）
  ├── InProcessBackend      -- 同进程，AsyncLocalStorage 隔离
  │     spawn() -> spawnInProcessTeammate() -> startInProcessTeammate()
  │
  └── PaneBackendExecutor（包装 PaneBackend）
        ├── TmuxBackend     -- tmux pane，独立进程
        └── ITermBackend    -- iTerm2 pane，独立进程

type TeammateExecutor = {
  readonly type: BackendType;
  isAvailable(): Promise<boolean>;
  spawn(config: TeammateSpawnConfig): Promise<TeammateSpawnResult>;
  sendMessage(agentId: string, message: TeammateMessage): Promise<void>;
  terminate(agentId: string, reason?: string): Promise<boolean>;
  kill(agentId: string): Promise<boolean>;
  isActive(agentId: string): Promise<boolean>;
};

isInProcessEnabled() 判定流程：
  ├── non-interactive session (-p 模式) → 强制 in-process
  ├── 配置为 'in-process' → true
  ├── 配置为 'tmux' → false
  └── 'auto' 模式：
       ├── 之前已 fallback 到 in-process → true
       ├── 在 tmux 里 → false (用 tmux pane)
       ├── 在 iTerm2 里 → false (用 iTerm2 pane)
       └── 其他 → true (默认 in-process)

1. AsyncLocalStorage    ← in-process teammates（同进程多 Agent）
   (teammateContext.ts:41)

2. dynamicTeamContext   ← tmux teammates（CLI 参数注入）
   (teammate.ts:44-51)

3. process.env          ← 环境变量（最后兜底）

路径 A（优先 -- Leader UI Bridge）：
  Worker 遇到 'ask' 权限
    → getLeaderToolUseConfirmQueue() 获取 Leader 的 UI 队列
    → 直接注入到 Leader 的 ToolUseConfirm 对话框
    → 用户在 Leader 终端操作
    → 回调 resolve Promise

路径 B（降级 -- Mailbox 轮询）：
  Worker 遇到 'ask' 权限
    → createPermissionRequest() 构建请求
    → sendPermissionRequestViaMailbox() 写入 Leader 信箱
    → registerPermissionCallback() 注册回调
    → setInterval(500ms) 轮询自己信箱
    → 收到 permission_response → processMailboxPermissionResponse()
    → 回调 resolve Promise

aion-teams/
├── core/                          # 可从 Claude Code 几乎直接搬运
│   ├── mailbox/
│   │   ├── FileMailbox.ts         # 基于 teammateMailbox.ts
│   │   ├── MemoryMailbox.ts       # 基于 mailbox.ts
│   │   └── types.ts               # TeammateMessage + 13种协议消息
│   ├── identity/
│   │   ├── TeammateContext.ts     # AsyncLocalStorage 身份管理
│   │   └── AgentId.ts             # name@team 格式
│   └── protocol/
│       ├── messages.ts            # 消息创建/解析（create*, is*）
│       └── constants.ts           # TEAM_LEAD_NAME 等
│
├── runtime/                       # 需要重写的核心
│   ├── Runner.ts                  # Agent 执行循环（替代 inProcessRunner）
│   ├── AgentLoop.ts               # LLM 调用抽象（替代 runAgent + query）
│   └── TaskManager.ts             # 任务列表管理
│
├── backends/                      # 可参考设计
│   ├── types.ts                   # TeammateExecutor 接口（直接用）
│   ├── InProcessBackend.ts        # 需适配 Aion 的状态管理
│   ├── TmuxBackend.ts             # 可直接用
│   └── registry.ts                # 后端检测和选择
│
├── permissions/                   # 需要适配
│   ├── PermissionBridge.ts        # Leader UI 桥接
│   └── PermissionSync.ts          # Mailbox 路径
│
└── tools/                         # LLM 工具定义
    ├── TeamCreate.ts
    ├── TeamDelete.ts
    └── SendMessage.ts

// AgentRuntime 接口 -- 替代 runAgent() + query()
interface AgentRuntime {
  run(config: {
    systemPrompt: string;
    messages: Message[];
    tools: ToolDefinition[];
    abortSignal: AbortSignal;
  }): AsyncGenerator<AgentMessage>;
}

// TeammateExecutor 接口 -- 直接从 Claude Code 搬运
interface TeammateExecutor {
  readonly type: BackendType;
  spawn(config: TeammateSpawnConfig): Promise<TeammateSpawnResult>;
  sendMessage(agentId: string, message: TeammateMessage): Promise<void>;
  terminate(agentId: string, reason?: string): Promise<boolean>;
  kill(agentId: string): Promise<boolean>;
  isActive(agentId: string): Promise<boolean>;
}

// Runner 接口 -- 替代 inProcessRunner 的 while 循环
interface TeammateRunner {
  start(config: RunnerConfig): Promise<RunnerResult>;
  // 内部: while -> runtime.run() -> idle -> poll mailbox -> wake
}

Phase 1（2-3 周）: 信箱 + 身份 + 协议
  直接移植 core/ 层，验证消息收发

Phase 2（3-4 周）: Runner + AgentRuntime
  实现 while 循环 + LLM 调用抽象
  对接 Aion 的 LLM API

Phase 3（2-3 周）: Backend + 工具
  InProcessBackend + TmuxBackend
  TeamCreate / SendMessage / TeamDelete

Phase 4（2 周）: 权限 + 健壮性
  Mailbox 权限路径
  重连 / 清理 / 错误处理

                    ┌─────────────────────────────────────────────────────┐
                    │                    User                             │
                    └──────────────────────┬──────────────────────────────┘
                                           │
                    ┌──────────────────────┴──────────────────────────────┐
                    │              Leader Agent (team-lead)               │
                    │  ┌──────────┐ ┌───────────┐ ┌────────────────────┐ │
                    │  │TeamCreate│ │SendMessage│ │   TeamDelete       │ │
                    │  │Tool      │ │Tool       │ │   Tool             │ │
                    │  └────┬─────┘ └─────┬─────┘ └──────┬─────────────┘ │
                    │       │             │              │               │
                    │  ┌────┴─────────────┴──────────────┴────────────┐  │
                    │  │            AppState (React)                   │  │
                    │  │  teamContext / tasks / toolPermissionContext  │  │
                    │  └────┬─────────────┬──────────────┬────────────┘  │
                    │       │             │              │               │
                    │  ┌────┴────┐  ┌─────┴─────┐  ┌────┴──────────┐   │
                    │  │Registry │  │Permission │  │ LeaderPerm    │   │
                    │  │(backend │  │Bridge     │  │ Bridge        │   │
                    │  │ select) │  │(mailbox)  │  │ (UI queue)    │   │
                    │  └────┬────┘  └───────────┘  └───────────────┘   │
                    └───────┼──────────────────────────────────────────┘
                            │
              ┌─────────────┼─────────────────┐
              │             │                 │
    ┌─────────┴────┐ ┌─────┴──────┐ ┌────────┴───────┐
    │ InProcess    │ │  Tmux      │ │  iTerm2        │
    │ Backend      │ │  Backend   │ │  Backend       │
    │              │ │            │ │                │
    │ spawn() ───────────────────── spawn()          │
    │ AsyncLocal   │ │  tmux pane │ │  it2 pane      │
    │ Storage      │ │  + claude  │ │  + claude      │
    │ isolation    │ │  binary    │ │  binary        │
    └──────┬───────┘ └─────┬──────┘ └────────┬───────┘
           │               │                 │
    ┌──────┴───────────────┴─────────────────┴───────┐
    │           File-Based Mailbox System             │
    │  ~/.claude/teams/{team}/inboxes/{name}.json     │
    │                                                 │
    │  writeToMailbox() ──── [lockfile] ──── readMailbox()
    │                                                 │
    │  13 message types:                              │
    │    text / idle / permission / shutdown / plan /  │
    │    sandbox / task / mode / team_update           │
    └─────────────────────────────────────────────────┘
           │                │                │
    ┌──────┴──────┐  ┌──────┴──────┐  ┌──────┴──────┐
    │ Teammate A  │  │ Teammate B  │  │ Teammate C  │
    │             │  │             │  │             │
    │ while loop: │  │ while loop: │  │ while loop: │
    │  runAgent() │  │  runAgent() │  │  runAgent() │
    │  idle/poll  │  │  idle/poll  │  │  idle/poll  │
    │  wake/run   │  │  wake/run   │  │  wake/run   │
    └─────────────┘  └─────────────┘  └─────────────┘