@agentunion/kite 1.4.0 → 1.6.0

package/docs/Kite/346/241/206/346/236/266/350/256/276/350/256/241/04-/346/250/241/345/235/227/350/247/204/350/214/203.md

@@ -0,0 +1,263 @@
+# 4. 模块规范
+
+## 4.1 统一模块结构
+
+系统中所有组件都是模块，包括内核、模型服务、任务系统、Agent。每个模块遵循统一的目录结构：
+
+```
+{module_name}/
+├── entry.py              ← 入口文件（统一命名）
+├── module.md             ← 模块描述（frontmatter + 说明文档）
+├── tools/                ← 模块自有工具
+│   └── {tool_name}/
+│       ├── tool.md       ← 工具定义（frontmatter + 使用说明）
+│       └── handler.py    ← 必须实现 execute() 和 check_permission()
+├── skills/               ← 模块安装的技能
+│   └── {skill_name}/
+│       ├── skill.md      ← 技能定义（frontmatter + 使用说明）
+│       └── ...
+├── permissions/          ← 本模块上下文中的工具/技能权限规则
+│   └── {tool_or_skill_name}.json
+└── ...                   ← 模块自有代码
+```
+
+## 4.2 module.md 格式
+
+```markdown
+---
+name: example_module
+display_name: "示例模块"
+version: "1.0"
+type: channel | infrastructure | kernel | service | agent
+state: enabled    # enabled（自动启动）| manual（手动启停）| disabled（禁用，需 owner 解锁）
+runtime: python   # python | node | binary — 决定 Launcher 用什么命令启动模块
+entry: entry.py   # 入口文件名，相对于模块目录
+preferred_port: 0 # 0 = OS 分配；非零 = 优先尝试此端口
+depends_on:       # 可选，启动依赖（Launcher 按拓扑序保证依赖先就绪）
+  - event_hub
+  - kernel
+
+events:
+  - example.event.type1
+  - example.event.type2
+
+subscriptions:
+  - channel.message.*
+  - session.started
+
+launch:                     # 可选，自定义启动参数（不填则完全保持默认行为）
+  cmd: ["python3.11", "-u", "main.py", "--mode", "prod"]  # 覆盖 runtime+entry
+  env:                      # 额外环境变量（合并到基础 env 之上）
+    MY_VAR: "value"
+  cwd: "./subdir"           # 工作目录（相对于 module_dir）
+  boot_stdin: false         # 是否通过 stdin 传 boot_info（默认 true）
+  timeout: 60               # 等待 module.ready 的秒数（默认 30）
+---
+
+# 示例模块
+
+模块的详细说明文档。LLM 可以通过阅读本文档了解模块的功能和使用方法。
+
+## 功能说明
+
+...
+
+## 使用示例
+
+...
+
+## 注意事项
+
+...
+```
+
+## 4.3 entry.py 启动协议
+
+Launcher 通过 stdin 管道向模块传入 JSON 消息。模块启动时读取即可：
+
+```
+第 1 行: {"token": "tok_abc..."}
+第 2 行: {"kite": "kernel_port", "kernel_port": 52340}
+```
+
+**标准启动流程（先订阅，再注册）：**
+
+1. 读取 stdin 拿到 `token` 和 `kernel_port`
+2. 连接 Kernel WebSocket（`ws://127.0.0.1:{kernel_port}/ws?token={token}&id={module_id}`）
+3. RPC `event.subscribe` — 订阅关心的事件（**先做**）
+4. RPC `registry.register` — 注册模块信息，声明已订阅的事件（**后做**，注册是报告，不能报告还没做的事）
+5. RPC `event.publish` — 发布 `module.ready` 事件（**必须**）
+6. 进入主循环（监听事件、处理 RPC 请求）
+7. 退出时 RPC `registry.deregister`
+
+**`module.ready` 事件：**
+
+模块完成初始化并注册到 Kernel 后，**必须**通过 Kernel 发布 `module.ready` 事件。这是所有模块必须支持的标准事件，Launcher 以收到此事件作为"启动成功"的判定标准：
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": "uuid",
+  "method": "event.publish",
+  "params": {
+    "event_id": "uuid",
+    "event": "module.ready",
+    "data": {
+      "module_id": "conversation",
+      "graceful_shutdown": true
+    }
+  }
+}
+```
+
+**Launcher 侧行为：**
+
+1. 发布 `module.starting` 事件（通知其他模块）
+2. 启动子进程
+3. 等待 `module.ready` 事件（超时秒数由 `launch.timeout` 配置，默认 30s）
+4. 收到 ready → 发布 `module.started` 事件，控制台输出日志
+5. 超时未收到 → 打印 WARNING，仍视为已启动（降级处理）
+
+**启动依赖：**
+
+模块可在 `module.md` 中通过 `depends_on` 字段声明启动依赖。Launcher 按拓扑序启动，确保依赖模块的 `module.ready` 已收到后再启动当前模块。Kernel 的启动顺序由 Launcher 硬编码保证，不需要声明 `depends_on`。
+
+**模块注册内容：**
+
+模块启动后通过 RPC `registry.register` 提交完整注册信息。工具、Hook、事件均使用**字典结构**（名称做 key），便于 lookup 通过点号路径直接命中：
+
+```json
+{
+  "module_id": "conversation",
+  "module_type": "agent",
+  "name": "对话 Agent",
+  "version": "1.0.0",
+  "graceful_shutdown": true,
+
+  "tools": {
+    "read_file": {
+      "endpoint": "/tools/read_file",
+      "description": "读取文件内容",
+      "parameters": {"path": "string"}
+    },
+    "write_file": {
+      "endpoint": "/tools/write_file",
+      "description": "写入文件",
+      "parameters": {"path": "string", "content": "string"}
+    }
+  },
+
+  "hooks": {
+    "before_llm_call": {
+      "endpoint": "/hooks/before_llm_call",
+      "priority": 10
+    },
+    "session_end": {
+      "endpoint": "/hooks/session_end",
+      "priority": 5
+    }
+  },
+
+  "events_publish": {
+    "agent.response.generated": {}
+  },
+
+  "events_subscribe": {
+    "channel.message.received": {},
+    "session.ended": {}
+  },
+
+  "metadata": {}
+}
+```
+
+Kernel 根据这些信息提供服务发现、能力索引、hook 链查询。
+
+**RPC 方法注册（tools.rpc）：**
+
+模块通过 `tools.rpc` 字段注册自己提供的 RPC 方法，供其他模块通过 `registry.lookup` 查询并调用。
+
+**数据结构要求：**
+- 必须使用**嵌套字典结构**，不能使用点号分隔的扁平字典
+- 字典的 key 是路径片段，value 是下一层字典或最终的方法描述
+- 这样 `registry.lookup` 才能通过点号路径（如 `tools.rpc.module.config.get`）匹配到方法
+
+**标准示例：**
+```json
+"tools": {
+  "rpc": {
+    "module": {
+      "config": {
+        "get": {"method": "get_settings", "description": "获取配置"},
+        "update": {"method": "update_settings", "description": "更新配置"},
+        "reset": {"method": "reset_settings", "description": "恢复默认配置"}
+      },
+      "health": {"method": "health_check", "description": "健康检查"},
+      "status": {"method": "get_status", "description": "状态查询"}
+    }
+  }
+}
+```
+
+**查询方式：**
+```python
+# 前端或其他模块通过 registry.lookup 查询
+result = await kernel_client.call("registry.lookup", {
+    "field": "tools.rpc.module.config.get",
+    "module": "backup"
+})
+# 返回: {"results": [{"module": "backup", "field": "tools.rpc.module.config.get", "value": {...}}]}
+
+# 然后调用实际方法（方法名格式：module_id.method）
+await kernel_client.call("backup.get_settings", {})
+```
+
+**验证机制：**
+
+Kernel 的 `registry.register` 会自动检查注册数据结构：
+- 如果 `tools`、`hooks`、`events_publish` 等字段包含点号 key（如 `"module.config.get"`），会抛出 `ValueError` 并提示正确格式
+- 必须使用嵌套字典结构，不能使用扁平的点号分隔 key
+
+## 4.4 模块职责
+
+模块的主要任务：
+- **注册事件** — 声明自己会产生哪些事件
+- **订阅事件** — 声明自己关心哪些事件
+- **产生事件** — 发生事情时向事件中心发送事件
+- **处理事件** — 收到订阅的事件后执行相应逻辑
+
+## 4.5 Agent 模块 Hook 调用规范
+
+Agent 模块在关键流程节点上，必须按规范调用 hook。Hook 分两种类型，对应框架已有的两种基础设施：
+
+- **void hook** — 通过事件中心发送事件，不等回复。用于通知、日志、统计。
+- **modifying hook** — 调用注册中心中注册的 hook 接口，等待返回值。返回值可修改数据流或阻断流程。
+
+其他模块（辅助 Agent、服务等）启动后，到注册中心注册自己提供的 hook 处理接口。Agent 模块在对应节点调用时，由注册中心返回 hook 链中所有注册者的处理结果。
+
+**Hook 调用点：**
+
+| 流程节点 | 类型 | 机制 | 说明 |
+|---------|------|------|------|
+| 收到消息 | void | 发事件 | 通知其他模块有消息进来 |
+| LLM 调用前 | modifying | 调接口 | 获取上下文注入、模型覆盖等 |
+| LLM 调用后 | void | 发事件 | 通知结果，供日志/统计 |
+| 工具调用前 | modifying | 调接口 | 权限检查、参数修改、阻断 |
+| 工具调用后 | void | 发事件 | 通知结果 |
+| 发送消息前 | modifying | 调接口 | 内容修改、取消发送 |
+| 发送消息后 | void | 发事件 | 通知已发送 |
+| 会话开始 | modifying | 调接口 | 获取初始上下文注入 |
+| 会话结束 | void | 发事件 | 触发总结、身份检查等后处理 |
+| 上下文压缩前 | modifying | 调接口 | 自定义压缩策略 |
+| 上下文压缩后 | void | 发事件 | 记录压缩结果 |
+
+**Hook 链执行规则：**
+- 同一个 hook 点可以有多个注册者，按 priority 顺序调用
+- modifying hook：前一个的返回值传给下一个（链式处理）
+- 任何一个返回 `block: true`，流程中断
+- 单个 hook 超时或失败不影响其他 hook（错误隔离）
+
+**典型应用场景：**
+- 上下文压缩：辅助模块注册 `before_llm_call` hook，检查 token 数，超阈值时返回压缩后的上下文
+- 模型选择：服务模块注册 `before_llm_call` hook，根据 peer/channel/消息类型返回 `model_override`
+- 会话总结：辅助模块订阅 `session.ended` 事件（void），异步执行总结和身份检查

package/docs/Kite/346/241/206/346/236/266/350/256/276/350/256/241/05-/346/240/270/345/277/203/346/265/201/347/250/213-/346/226/260/347/211/210.md

@@ -0,0 +1,267 @@
+# 5. 核心流程（新版 - Kernel 统一架构）
+
+## 5.1 系统启动流程
+
+### 5.1.1 Token 生成与分发机制
+
+```mermaid
+sequenceDiagram
+    participant L as Launcher
+    participant K as Kernel
+    participant M as 其他模块
+
+    Note over L,K: Phase 1: Kernel 启动与 Token 生成
+    L->>K: 启动 Kernel 进程（无参数）
+    K->>K: 生成 launcher_token
+    K->>K: 绑定端口
+    K-->>L: stdout: {"kite":"port", "port":N, "token":"launcher_token"}
+
+    Note over L,K: Phase 2: Launcher 连接与模块扫描
+    L->>L: 保存 launcher_token
+    L->>K: WebSocket 连接（携带 launcher_token）
+    L->>K: RPC: event.subscribe([">"])
+    L->>K: RPC: registry.register({module_id:"launcher"})
+    K->>K: Launcher 注册成功
+    K-->>L: 发布 module.ready (source: kernel)
+
+    L->>L: 扫描所有模块
+    L->>K: RPC: kernel.generate_tokens({modules:["mod1","mod2",...]})
+    K->>K: 生成所有模块的 token
+    K-->>L: 返回 {tokens: {"mod1":"tok1", "mod2":"tok2"}}
+
+    Note over L,M: Phase 3: 启动其他模块
+    L->>M: 启动模块进程
+    L->>M: stdin: {"token":"mod_token", "kernel_port":N}
+    M->>K: WebSocket 连接（携带 mod_token）
+    M->>K: RPC: event.subscribe([...])
+    M->>K: RPC: registry.register({module_id:"mod"})
+    M->>K: RPC: event.publish("module.ready")
+    K-->>L: 转发 module.ready
+```
+
+### 5.1.2 完整启动时序
+
+```mermaid
+sequenceDiagram
+    participant L as Launcher
+    participant K as Kernel
+    participant W as Watchdog
+    participant B as Backup
+    participant MS as Model Service
+    participant Web as Web Admin
+
+    Note over L,K: 1. Kernel 启动
+    L->>K: 启动进程
+    K->>K: 生成 launcher_token
+    K->>K: 绑定端口
+    K-->>L: stdout: port + token
+
+    Note over L,K: 2. Launcher 连接
+    L->>K: WS 连接 (token)
+    L->>K: event.subscribe([">"])
+    L->>K: registry.register(launcher)
+    K-->>L: module.ready (kernel)
+
+    Note over L,K: 3. 生成模块 Token
+    L->>L: 扫描模块
+    L->>K: kernel.generate_tokens
+    K-->>L: 返回所有 token
+
+    Note over L,W: 4. 启动 Watchdog
+    L->>W: 启动 + stdin(token, port)
+    W->>K: WS 连接
+    W->>K: event.subscribe
+    W->>K: registry.register
+    W->>K: event.publish(ready)
+    K-->>L: 转发 ready
+
+    Note over L,B: 5. 启动 Backup
+    L->>B: 启动 + stdin(token, port)
+    B->>K: WS 连接
+    B->>K: event.subscribe
+    B->>K: registry.register
+    B->>K: event.publish(ready)
+    K-->>L: 转发 ready
+
+    Note over L,MS: 6. 启动 Model Service
+    L->>MS: 启动 + stdin(token, port)
+    MS->>K: WS 连接
+    MS->>K: event.subscribe
+    MS->>K: registry.register
+    MS->>K: event.publish(ready)
+    K-->>L: 转发 ready
+
+    Note over L,Web: 7. 启动 Web Admin
+    L->>Web: 启动 + stdin(token, port)
+    Web->>K: WS 连接
+    Web->>K: event.subscribe
+    Web->>K: registry.register
+    Web->>K: event.publish(ready)
+    K-->>L: 转发 ready
+
+    Note over L: 8. 系统就绪
+```
+
+### 5.1.3 模块标准启动流程
+
+```mermaid
+flowchart TD
+    Start([模块进程启动]) --> ReadStdin[从 stdin 读取 token + kernel_port]
+    ReadStdin --> Connect[连接 Kernel WebSocket<br/>携带 token 验证]
+    Connect --> Subscribe[RPC: event.subscribe<br/>订阅需要的事件]
+    Subscribe --> Register[RPC: registry.register<br/>注册自身信息]
+    Register --> Ready[RPC: event.publish<br/>发布 module.ready]
+    Ready --> Running([进入运行循环])
+
+    style Subscribe fill:#e1f5ff
+    style Register fill:#fff4e1
+    style Ready fill:#e8f5e9
+```
+
+## 5.2 Token 流转机制
+
+### 5.2.1 设计原则
+
+**谁需要 token 谁生成 token**
+
+- Kernel 需要验证所有连接，所以 Kernel 生成所有 token
+- Launcher 的 token：Kernel 通过 stdout 直接传递
+- 其他模块的 token：Kernel 生成后通过 RPC 返回给 Launcher，Launcher 再通过 stdin 传递给模块
+
+### 5.2.2 Token 类型
+
+| Token 类型 | 生成者 | 传递路径 | 用途 |
+|-----------|--------|---------|------|
+| launcher_token | Kernel | Kernel stdout → Launcher | Launcher 连接 Kernel 验证 |
+| module_token | Kernel | Kernel RPC → Launcher stdin → 模块 | 模块连接 Kernel 验证 |
+
+### 5.2.3 Token 生成流程
+
+```mermaid
+flowchart LR
+    K[Kernel] -->|stdout| L[Launcher]
+    L -->|RPC: generate_tokens| K
+    K -->|返回 tokens| L
+    L -->|stdin| M1[模块1]
+    L -->|stdin| M2[模块2]
+    L -->|stdin| M3[模块3]
+
+    style K fill:#ffebee
+    style L fill:#e3f2fd
+    style M1 fill:#f3e5f5
+    style M2 fill:#f3e5f5
+    style M3 fill:#f3e5f5
+```
+
+## 5.3 订阅与注册顺序
+
+### 5.3.1 设计原则
+
+**先订阅，再注册**
+
+- 订阅（event.subscribe）：实际操作，告诉事件中心"请给我发这些事件"
+- 注册（registry.register）：声明报告，告诉注册中心"我订阅了这些事件"
+- 注册是报告，不能报告还没做的事
+
+### 5.3.2 标准顺序
+
+```mermaid
+sequenceDiagram
+    participant M as 模块
+    participant K as Kernel
+
+    M->>K: 1. event.subscribe<br/>实际订阅事件
+    Note over M,K: 订阅完成，可以接收事件
+
+    M->>K: 2. registry.register<br/>声明 events_subscribe
+    Note over M,K: 注册完成，报告已订阅
+
+    M->>K: 3. event.publish<br/>发布 module.ready
+    Note over M,K: 模块就绪
+```
+
+### 5.3.3 错误示例
+
+```mermaid
+sequenceDiagram
+    participant M as 模块
+    participant K as Kernel
+
+    M->>K: ❌ 1. registry.register<br/>声明 events_subscribe
+    Note over M,K: 错误：报告了还没做的事
+
+    M->>K: 2. event.subscribe<br/>实际订阅事件
+    Note over M,K: 订阅完成
+```
+
+## 5.4 事件驱动流程（通用）
+
+```mermaid
+sequenceDiagram
+    participant MA as 模块 A
+    participant K as Kernel
+    participant MB as 模块 B
+    participant MC as 模块 C
+
+    MA->>K: RPC: event.publish<br/>{event_id, event, data}
+    K->>K: 查询订阅关系<br/>检查去重表
+    K-->>MB: 转发事件 (JSON-RPC 通知)
+    K-->>MC: 转发事件 (JSON-RPC 通知)
+
+    MB->>MB: 处理事件
+    MC->>MC: 处理事件
+
+    Note over MB: 可能产生新事件<br/>可能调用工具
+```
+
+## 5.5 模块生命周期状态
+
+```mermaid
+stateDiagram-v2
+    [*] --> Starting: Launcher 启动进程
+    Starting --> Connecting: 读取 stdin (token + port)
+    Connecting --> Subscribing: WebSocket 连接成功
+    Subscribing --> Registering: event.subscribe 完成
+    Registering --> Ready: registry.register 完成
+    Ready --> Running: event.publish(module.ready)
+    Running --> Stopping: 收到 shutdown 信号
+    Stopping --> [*]: 进程退出
+
+    Running --> Running: 处理事件/RPC
+```
+
+## 5.6 启动完成判定
+
+**启动完成条件：**
+
+所有要启动的模块，状态要么是 `ready`（收到了 module.ready），要么是 `exiting`（进程已退出）
+
+```mermaid
+flowchart TD
+    Start([Launcher 启动所有模块]) --> Check{检查所有模块状态}
+    Check -->|有模块 pending| Wait[等待 module.ready]
+    Wait --> Check
+    Check -->|全部 ready 或 exiting| Done([启动完成])
+
+    style Done fill:#e8f5e9
+```
+
+## 5.7 与旧架构的差异
+
+### 主要变化
+
+| 方面 | 旧架构 (Registry + Event Hub) | 新架构 (Kernel 统一) |
+|------|------------------------------|---------------------|
+| **Token 生成** | Launcher 生成所有 token | Kernel 生成所有 token |
+| **Token 传递** | Launcher → 模块 (stdin) | Kernel → Launcher (stdout/RPC) → 模块 (stdin) |
+| **架构** | Registry + Event Hub 分离 | 合并为 Kernel |
+| **端点数量** | 2 个（Registry HTTP + Event Hub WS） | 1 个（Kernel WS） |
+| **订阅顺序** | 未明确强调 | 明确要求先订阅再注册 |
+| **Ready 机制** | Registry 延迟发送 ready | Kernel 在 Launcher 注册后发送 |
+
+### 设计理念
+
+1. **谁需要 token 谁生成**：Kernel 需要验证所有连接，所以由 Kernel 生成
+2. **先订阅再注册**：注册是报告，不能报告还没做的事
+3. **统一架构**：Registry + Event Hub 合并，简化通信路径
+4. **解耦设计**：虽然合并在一个进程，但注册中心和事件中心仍保持代码解耦

package/docs/Kite/346/241/206/346/236/266/350/256/276/350/256/241/05-/346/240/270/345/277/203/346/265/201/347/250/213.md

@@ -0,0 +1,149 @@
+# 5. 核心流程
+
+## 5.1 系统启动流程
+
+```
+main.py → Launcher (launcher/)
+  │
+  ├─① 生成所有模块专属 token
+  │     → 启动 Kernel 子进程，通过 stdin 传入 boot_info token 和 tokens 映射表
+  │     → Kernel 绑定端口，通过 stdout 回传端口，就绪
+  │     → Launcher 连接 Kernel WebSocket，订阅所有事件
+  │     → Launcher 通过 RPC 向 Kernel 注册自身
+  │
+  └─② 扫描 launcher/、kernel/ 和 extensions/ 下所有模块的 module.md
+        → 过滤出 config_state: enabled 的模块
+        → manual / disabled 状态的模块跳过
+        → 并行启动所有 enabled 模块
+        → 通过 stdin 向每个模块传入 {"token": "..."} 和 kernel_port
+        │
+        ├─ Model Service (extensions/services/model_service/)
+        │    → 连接 Kernel WebSocket
+        │    → 通过 RPC 向 Kernel 注册
+        │    → 注册 LLM 配置
+        │    → 发布 module.ready 事件
+        │
+        ├─ Task System (extensions/services/task_system/)
+        │    → 连接 Kernel WebSocket
+        │    → 通过 RPC 向 Kernel 注册
+        │    → 注册任务管理接口和工具
+        │    → 订阅 session.ended 等事件
+        │    → 发布 module.ready 事件
+        │
+        ├─ Web Admin (extensions/services/web/)
+        │    → 连接 Kernel WebSocket
+        │    → 通过 RPC 向 Kernel 注册
+        │    → 发现各模块接口 → 提供管理界面
+        │    → 发布 module.ready 事件
+        │
+        └─ 各 Channel / Agent (extensions/channels/*, extensions/agents/*)
+             → 连接 Kernel WebSocket
+             → 通过 RPC 向 Kernel 注册
+             → 订阅事件
+             → 发布 module.ready 事件
+```
+
+## 5.2 事件驱动流程（通用）
+
+```
+模块 A 产生事件
+  │
+  ├─① 通过 Kernel WebSocket 发送 JSON-RPC 请求
+  │     → method: "event.publish"
+  │     → params: {event_id, event, data}
+  │
+  ├─② Kernel 查询订阅关系
+  │     → 找到订阅了该事件的模块列表
+  │     → 检查去重表（event_id）
+  │
+  ├─③ Kernel 转发事件
+  │     → 通过 WebSocket 发送 JSON-RPC 通知给订阅者
+  │
+  └─④ 订阅者收到事件
+        → 执行相应处理逻辑
+        → 可能产生新事件
+        → 可能调用工具
+```
+
+## 5.3 工具调用流程
+
+```
+LLM 输出 tool_call（工具名 + args）
+  │
+  ├─① Agent 模块工具调用层拦截
+  │     → 通过 Kernel RPC 查询工具地址（registry.lookup）
+  │     → 使用 Kernel 传入的 permission_context 构造 context
+  │
+  ├─② 通过 Kernel RPC 调用工具提供者
+  │     → method: "{tool_provider_module}.{tool_name}"
+  │     → params: {args, context}
+  │
+  └─③ 工具提供者处理
+        → 独立验证 owner 身份（读取 agent 身份 profile.md 中的 owners 列表）
+        → 调用 handler 的 check_permission(args, context)
+        → 返回 None → 调用 execute(args, context) → 返回结果
+        → 返回拒绝原因 → 直接返回，不调用 execute()
+```
+
+## 5.4 会话生命周期
+
+```
+事件触发（如 channel.message.received）
+  │
+  ├─① Kernel 收到事件
+  │     → 判断是否需要创建会话
+  │     → 查询身份信息
+  │     → 判断工作模式（托管/授权）
+  │
+  ├─② [托管模式] 启动 dispatcher Agent
+  │     → LLM 决策：接受 / 拒绝 / 转发 / 其他
+  │
+  ├─③ [决定接受] 创建会话
+  │     → 生成会话 ID
+  │     → 记录参与者、渠道、方向
+  │     → 发送事件: session.started
+  │
+  ├─④ 启动 conversation Agent
+  │     → 加载提示词（方向 + 来源 + 身份档案）
+  │     → 进入对话循环
+  │     → 可按需启动 intent / retrieval Agent
+  │
+  ├─⑤ 会话结束
+  │     → 发送事件: session.ended
+  │     → 启动 post Agent
+  │     → 生成总结
+  │     → 评估结果
+  │     → 可能创建后续任务
+  │
+  └─⑥ 任务创建（如需）
+        → 调用工具: create_task
+        → Task System 接收任务
+```
+
+## 5.5 任务执行流程
+
+```
+任务创建
+  │
+  ├─① Task System 收到任务
+  │     → 保存到任务队列
+  │     → 发送事件: task.created
+  │
+  ├─② Kernel 收到 task.created 事件
+  │     → 启动 planner Agent（如需）
+  │     → 规划执行步骤
+  │
+  ├─③ 执行任务
+  │     → 可能创建会话
+  │     → 可能调用工具
+  │     → 可能产生事件
+  │
+  ├─④ 任务完成
+  │     → Agent 调用工具: submit_task
+  │     → Task System 更新状态
+  │     → 发送事件: task.completed
+  │
+  └─⑤ 后续处理
+        → post Agent 评估结果
+        → 可能创建新任务
+```