Add documentation for network server sessions, pipeline handler model, security crypto patterns, and serialization patterns - Created new markdown files for NewLife.Core network server patterns and pipeline handler model. - Added references for pipeline and security patterns. - Documented serialization patterns including JSON, XML, and binary serialization techniques. - Included usage examples, core principles, and key checks for each pattern.大石头 authored at 2026-04-02 11:44:14
diff --git a/.github/skills/cache-provider-architecture/references/newlife-icache-patterns.md b/.github/skills/cache-provider-architecture/references/newlife-icache-patterns.md
new file mode 100644
index 0000000..13a008d
--- /dev/null
+++ b/.github/skills/cache-provider-architecture/references/newlife-icache-patterns.md
@@ -0,0 +1,114 @@
+# NewLife.Core ICache 模式证据
+
+> 来源：`Caching/ICache.cs` + `Caching/ICacheProvider.cs` + `caching.instructions.md`
+> 缓存文档（`Doc/缓存系统ICache.md`）存在编码损坏，以源码为准。
+
+---
+
+## 1. 接口层次（源码校验）
+
+```text
+ICache
+├── 基本属性：Name / Expire / Count / Keys / this[key]
+├── CRUD: ContainsKey / Set<T> / Get<T> / TryGetValue<T> / Remove / Clear
+├── 过期：SetExpire / GetExpire
+├── 批量：GetAll<T> / SetAll<T>
+├── 高级：Add<T>（不覆盖）/ Replace<T>（原子替换）/ GetOrAdd<T>
+├── 原子：Increment / Decrement（Int64 + Double）
+└── 分布式锁：AcquireLock (via ICacheProvider)
+
+ICacheProvider
+├── Cache 跨进程缓存（可替换 Redis）
+├── InnerCache 进程内缓存（始终 MemoryCache）
+├── GetQueue<T>(topic, group?) → IProducerConsumer<T>
+├── GetInnerQueue<T>(topic) → 进程内队列
+└── AcquireLock(key, msTimeout) → IDisposable?（失败抛异常）
+```
+
+---
+
+## 2. `ICache` 过期时间语义（源码注释）
+
+```csharp
+// expire < 0 → 采用 ICache.Expire 默认值
+// expire = 0 → 永不过期 ← 最常误用！
+// expire > 0 → 相对过期秒数（从现在起）
+Boolean Set<T>(String key, T value, Int32 expire = -1);
+```
+
+**常见误用**：
+```csharp
+// ❌ 误以为 0 是默认：
+cache.Set(key, value, expire: 0); // → 实际是永不过期！
+
+// ✅ 应该用 -1 表示"使用默认":
+cache.Set(key, value, expire: -1);
+```
+
+---
+
+## 3. `TryGetValue` vs `Get` 防穿透
+
+```csharp
+// Get<T>：无法区分"键不存在"与"值是默认值"
+var user = cache.Get<User>("user:0"); // 值为 null → 不存在还是值本身就是 null？
+
+// TryGetValue：准确区分
+if (cache.TryGetValue<User>("user:0", out var user))
+{
+ return user; // 确实命中（即使 user 是 null）
+}
+// 未命中 → 穿透到数据库
+```
+
+源码注释（直接引用）：
+> *"返回 true 表示键存在，但不保证反序列化成功；反序列化失败时 value 通常为默认值。解决缓存穿透问题的重要方法。"*
+
+---
+
+## 4. `ICacheProvider` 两级缓存设计原则（源码注释）
+
+> *"根据实际开发经验，即使在分布式系统中，也有大量的数据是不需要跨进程共享的，因此本接口提供了两级缓存。"*
+
+| 属性 | 类型 | 用途 |
+|------|------|------|
+| `InnerCache` | 始终 `MemoryCache` | 进程内字典/配置，无序列化开销 |
+| `Cache` | 可配置（默认 MemoryCache，生产换 Redis）| 跨进程共享、用户会话、分布式锁 |
+
+---
+
+## 5. 队列选择策略（源码注释）
+
+> *"可根据是否设置消费组来决定使用简单队列还是完整队列"*
+
+| group 参数 | 返回队列类型 | 适用场景 |
+|-----------|-------------|---------|
+| `null` | 简单队列（如 `RedisQueue`）| Topic 多但消息量少（命令分发）|
+| 非空字符串 | 完整队列（如 `RedisStream`）| Topic 少但消息量大（可靠消息，支持 ACK）|
+
+---
+
+## 6. 分布式锁行为（源码注释）
+
+```csharp
+// AcquireLock：锁维持时间 = msTimeout；等待时间 = msTimeout
+// 成功：返回 IDisposable → using 块结束自动释放
+// 失败（等待超时）：抛出异常
+using var lockObj = cache.AcquireLock("order:1001", msTimeout: 3000);
+```
+
+**注意**：不同 `ICache` 实现对分布式锁的支持不同；`MemoryCache` 提供进程内互斥锁，`Redis` 提供跨进程分布式锁。
+
+---
+
+## 7. 通用规则 vs NewLife.Core 特例
+
+| 规则 | 通用性 | 说明 |
+|------|--------|------|
+| `ICache` 接口优先 | ✅ 通用 | 与 `IDistributedCache` 思路一致 |
+| 过期三段语义（<0/-0/>0）| ⚠️ NewLife 特有 | 通用替代：`TimeSpan?` nullable |
+| `TryGetValue` 防穿透 | ✅ 通用 | 任何缓存系统均适用 |
+| `GetAll`/`SetAll` 批量 | ✅ 通用 | Redis Pipeline 等均支持 |
+| 两级缓存（Inner + Cache）| ✅ 通用 | 本地缓冲 + 远端分布式，通用架构 |
+| 队列 group 决定类型 | ⚠️ NewLife 特有 | 通用替代：显式指定队列类型 |
+| `Cache` 基类继承规范 | ⚠️ NewLife 特有 | 扩展实现时特有约束 |
diff --git a/.github/skills/cache-provider-architecture/SKILL.md b/.github/skills/cache-provider-architecture/SKILL.md
new file mode 100644
index 0000000..ea797eb
--- /dev/null
+++ b/.github/skills/cache-provider-architecture/SKILL.md
@@ -0,0 +1,145 @@
+---
+name: cache-provider-architecture
+description: >
+ 设计或使用统一缓存提供者架构，涵盖 ICache 接口操作、过期语义、原子操作、两级缓存（进程内 + 跨进程）、
+ 分布式锁 AcquireLock、生产消费队列 IProducerConsumer，以及缓存穿透防护。
+ 适用于缓存系统设计、ICache 扩展实现、分布式场景数据共享与代码审查任务。
+argument-hint: >
+ 说明你的缓存场景：单机内存还是分布式（Redis）；是否需要分布式锁；
+ 是否需要队列（简单队列 vs 消费组队列）；是否有缓存穿透/击穿风险。
+---
+
+# 缓存提供者架构设计技能
+
+## 适用场景
+
+- 为应用设计缓存层，需要在开发时用 `MemoryCache`、生产时替换为 `Redis`，业务代码零改动。
+- 需要分布式锁保证多节点互斥操作（库存扣减、定时任务单点执行等）。
+- 需要跨服务的轻量消息队列（命令分发用简单队列，消息可靠投递用消费组队列）。
+- 审查缓存相关代码：检查是否面向 `ICache` 接口、过期时间语义是否正确、是否有批量操作优化。
+- 在现有 `ICacheProvider` 框架内，判断数据应放进程内缓存（`InnerCache`）还是跨进程缓存（`Cache`）。
+
+## 核心原则
+
+1. **接口优先**：所有业务代码面向 `ICache` 接口，不直接依赖 `MemoryCache` 或 `Redis`；通过 DI 注入具体实现。
+2. **两级缓存定位**：`ICacheProvider.InnerCache` 是进程内缓存（无序列化开销，适合频繁读的字典/配置数据）；`ICacheProvider.Cache` 是跨进程缓存（适合分布式共享、用户会话等）。
+3. **过期时间语义**：`expire < 0` = 用 `ICache.Expire` 默认值；`expire = 0` = 永不过期；`expire > 0` = 相对过期秒数。**不要用 `0` 表示"默认"**——这是最常见的语义误用。
+4. **用 `TryGetValue` 防穿透**：`Get<T>` 无法区分"键不存在"与"值恰好是默认值"；用 `TryGetValue` 才能准确判断是否命中，是防止缓存穿透的关键手段。
+5. **批量操作优先**：循环内逐条 `Get`/`Set` 应替换为 `GetAll`/`SetAll`；远端缓存下批量操作网络往返减少数量级。
+6. **分布式锁必须配对 Dispose**：`AcquireLock` 返回 `IDisposable`，配合 `using` 使用；锁获取失败时应有明确降级逻辑，而不是静默跳过。
+
+## 执行步骤
+
+### 一、选择缓存实现
+
+| 场景 | 推荐 |
+|------|------|
+| 单机内存缓存 | `MemoryCache.Instance`（全局单例）|
+| 分布式（Redis）| `NewLife.Redis`（独立包，实现 `ICache`）|
+| 跨进程/单机均兼容 | `ICacheProvider.Cache`（运行时决定）|
+| 进程内高频字典 | `ICacheProvider.InnerCache`（始终 MemoryCache）|
+
+### 二、基础 CRUD 操作
+
+```csharp
+// 设置（60 秒过期）
+cache.Set("user:1", user, 60);
+
+// 读取（区分"键不存在"与"默认值"）
+if (cache.TryGetValue<User>("user:1", out var user))
+ return user;
+
+// 获取或缓存（防穿透）
+var data = cache.GetOrAdd("config:rules", key =>
+ LoadRulesFromDb(key), expireSeconds: 300);
+
+// 批量读（减少网络往返）
+var users = cache.GetAll<User>(ids.Select(id => $"user:{id}"));
+
+// 原子递增（统计/限流）
+var count = cache.Increment("page:views", 1);
+```
+
+### 三、过期时间正确使用
+
+```csharp
+// ✅ 正确：60 秒过期
+cache.Set(key, value, expire: 60);
+
+// ✅ 正确：永不过期
+cache.Set(key, value, expire: 0);
+
+// ✅ 正确：使用 ICache.Expire 默认值
+cache.Set(key, value, expire: -1);
+
+// ❌ 错误：0 不代表"默认"，代表"永不过期"
+cache.Set(key, value, expire: 0); // 若本意是默认过期，应用 -1
+```
+
+### 四、分布式锁
+
+```csharp
+// AcquireLock：获取失败抛出异常
+try
+{
+ using var lockObj = cacheProvider.Cache.AcquireLock("order:pay:1001", msTimeout: 3000);
+ // 临界区业务逻辑
+ await ProcessPaymentAsync(orderId);
+} // using 块结束自动释放锁
+catch (Exception ex) when (ex.Message.Contains("锁"))
+{
+ // 降级：等待重试 / 返回"正在处理"
+ return Result.Conflict("订单正在处理中，请稍后重试");
+}
+```
+
+### 五、两级缓存分工
+
+```csharp
+// 进程内：字典/配置/统计数据，无需跨服务共享
+var roles = provider.InnerCache.GetOrAdd("roles", _ => LoadRoles(), 600);
+
+// 跨进程：用户会话、分布式锁、跨节点计数
+provider.Cache.Set($"session:{token}", session, 1800);
+```
+
+### 六、队列选择
+
+```csharp
+// 简单队列（command dispatch，topic 多、消息少）
+var cmdQueue = provider.GetQueue<string>("cmd:send-email");
+await cmdQueue.AddAsync(emailJson);
+
+// 消费组队列（消息可靠投递，topic 少、消息多，支持 ACK）
+var msgQueue = provider.GetQueue<OrderEvent>("events:order", group: "billing");
+var messages = await msgQueue.TakeAsync(batchSize: 10);
+foreach (var msg in messages) { /* 处理 */ await msgQueue.AckAsync(msg.Id); }
+```
+
+### 七、扩展实现 `ICache`
+
+1. 继承 `Cache` 基类（提供默认的批量操作 fallback 实现）。
+2. 重写 `GetAll`/`SetAll` 为原生批量 API，而不是循环调用单条。
+3. `Init(string connStr)` 解析连接字符串初始化底层连接。
+4. `Dispose()` 必须释放底层连接/连接池资源。
+
+## 重点检查项
+
+- [ ] 是否面向 `ICache` 接口，未直接依赖 `MemoryCache` 或 `Redis`？
+- [ ] `expire = 0` 是否被误用为"默认"（正确语义是"永不过期"）？
+- [ ] 热路径中是否有循环逐条 `Get`/`Set`（应换 `GetAll`/`SetAll`）？
+- [ ] `AcquireLock` 是否配合 `using` 使用，且有锁获取失败的降级处理？
+- [ ] 使用 `TryGetValue` 而非 `Get` 来防止缓存穿透？
+- [ ] `MemoryCache` 是否用了 `MemoryCache.Instance`（全局单例），而不是每次 `new`？
+- [ ] 缓存 key 是否包含用户输入？是否经过校验（注入风险）？
+
+## 输出要求
+
+- **接口**：`ICache`（基础操作）、`ICacheProvider`（两级缓存 + 队列 + 锁）、`IProducerConsumer<T>`（生产消费）。
+- **实现**：`MemoryCache`（内存），`Cache` 抽象基类；Redis 放独立包不耦合 Core。
+- **两级缓存配置**：`CacheProvider.Cache` 在应用启动时替换为 Redis 实例；`InnerCache` 保持默认。
+- **测试**：使用 `MemoryCache` 实例（而非 mock）做集成测试；分布式锁测试覆盖超时和并发争用场景。
+
+## 参考资料
+
+参考示例与模式证据见 `references/newlife-core-icache-patterns.md`。
diff --git a/.github/skills/coding-standards/references/newlife-core-csharp-style.md b/.github/skills/coding-standards/references/newlife-csharp-style.md
similarity index 100%
rename from .github/skills/coding-standards/references/newlife-core-csharp-style.md
rename to .github/skills/coding-standards/references/newlife-csharp-style.md
diff --git a/.github/skills/compatibility-checks/references/newlife-core-compatibility-patterns.md b/.github/skills/compatibility-checks/references/newlife-compatibility-patterns.md
similarity index 100%
rename from .github/skills/compatibility-checks/references/newlife-core-compatibility-patterns.md
rename to .github/skills/compatibility-checks/references/newlife-compatibility-patterns.md
diff --git a/.github/skills/config-provider-system/references/newlife-config-patterns.md b/.github/skills/config-provider-system/references/newlife-config-patterns.md
new file mode 100644
index 0000000..019eda8
--- /dev/null
+++ b/.github/skills/config-provider-system/references/newlife-config-patterns.md
@@ -0,0 +1,114 @@
+# NewLife.Core Config 模式证据
+
+> 来源：`configuration.instructions.md` + `Configuration/IConfigProvider.cs` + `Configuration/Config.cs`
+> 配置文档（`Doc/配置系统Config.md`）存在编码损坏，以源码为准。
+
+---
+
+## 1. 接口层次（源码校验）
+
+```text
+IConfigProvider
+├── Name / Root / Keys / IsNew
+├── this[key] 冒号多级路径读写
+├── GetSection(key) 返回节点对象
+├── Changed event 文件变更/远端推送/SaveAll 后触发
+├── GetConfig 委托访问入口
+├── LoadAll / SaveAll 全量加载/保存
+├── Load<T> 加载到强类型模型
+├── Save<T> 保存强类型模型
+└── Bind<T> 绑定模型 + autoReload 热更新
+
+IConfigSection
+├── Key / Value / Childs
+└── 树状节点，GetSection(key) 向下遍历
+```
+
+---
+
+## 2. `Config<T>` 静态初始化顺序（源码关键路径）
+
+```csharp
+// 静态构造器（类首次访问时触发）
+static Config()
+{
+ // 1. 读取 [ConfigAttribute] 获取文件名 / 提供者类型
+ var att = typeof(TConfig).GetCustomAttribute<ConfigAttribute>(true);
+
+ // 2. 创建提供者：ConfigProvider.Create(att?.Provider)
+ // 默认 → XmlConfigProvider，可通过特性指定
+
+ // 3. 若为 HttpConfigProvider，写入 Server/AppId/Secret 等参数
+ // 4. 调用 prv.Init(name) 完成配置文件路径解析
+
+ Provider = prv;
+}
+
+// Current 属性（DCL 双重检测锁）
+public static TConfig Current
+{
+ get
+ {
+ if (_Current != null) return _Current;
+ lock (typeof(TConfig)) {
+ if (_Current != null) return _Current;
+ var config = new TConfig();
+ prv.Bind(config, true); // 立即加载并监听变更
+ config.OnLoaded(); // 校验/修正钩子
+ _Current = config; // 赋值（若 IsNew，Save 到磁盘）
+ }
+ }
+}
+```
+
+**陷阱：不要在 `TConfig` 的构造函数中访问 `Config<TConfig>.Current`**
+→ 静态构造尚未完成 / DCL 被同一线程递归 → `NullReferenceException` 或死锁。
+
+---
+
+## 3. `IConfigProvider` 核心方法语义
+
+| 方法 | 调用时机 | 副作用 |
+|------|---------|--------|
+| `LoadAll()` | 启动时、手动刷新 | 覆盖 `Root` 树 |
+| `SaveAll()` | 手动保存、`Config<T>.Save()` | 持久化 `Root` 树到数据源 |
+| `Load<T>(path)` | 提取子模型 | 无持久化 |
+| `Save<T>(model, path)` | 写回子模型 | 触发 `SaveAll()` |
+| `Bind<T>(model, autoReload)` | 初始化时 | `Changed` 时自动同步属性 |
+| `Changed` event | 文件 FSW / 远端推送 / `SaveAll` | 通知所有订阅方 |
+
+**重要**：`Bind` 后修改模型属性 **不会** 自动持久化，必须显式调用 `Save()`。
+
+---
+
+## 4. HttpConfigProvider 参数速查
+
+```csharp
+var prv = new HttpConfigProvider
+{
+ Server = "http://stardust:6600", // 配置中心地址
+ AppId = "myapp", // 应用标识（必填，否则服务端拒绝）
+ Secret = "xxxxx", // 密钥
+ Scope = "production", // 环境/作用域
+ Period = 60, // 轮询间隔（秒）
+ CacheLevel = ConfigCacheLevel.Json, // 本地明文缓存（断网兜底）
+ Action = "Config/GetAll", // API 路径（默认匹配星尘）
+};
+```
+
+- `AppId` 未设置：服务端返回 401/403 → 加载失败 → 使用本地缓存（若有）或默认值。
+- `CacheLevel = Encrypted`：加密存储本地缓存，防止敏感配置明文落盘。
+
+---
+
+## 5. 通用规则 vs NewLife.Core 特例
+
+| 规则 | 通用性 | 说明 |
+|------|--------|------|
+| 接口优先（面向 `IConfigProvider`）| ✅ 通用 | 适用任何配置系统设计 |
+| 强类型单例 + `OnLoaded` 校验 | ✅ 通用 | 与 `IOptions<T>` 思路一致 |
+| 冒号分隔多级 Key | ✅ 通用 | `.NET` `IConfiguration` 同约定 |
+| `Bind` + `Changed` 热更新 | ✅ 通用 | 观察者模式，可替换 |
+| `Client.Current` DCL 双重检测 | ⚠️ 半通用 | 静态单例模式，须防递归 |
+| `[Config]` / `[Description]` 推动 XML 注释 | ⚠️ NewLife 特有 | 不同框架注释机制不同 |
+| `ConfigProvider.Create` 工厂 | ⚠️ NewLife 特有 | 通用替代：手动选择并实例化 |
diff --git a/.github/skills/config-provider-system/SKILL.md b/.github/skills/config-provider-system/SKILL.md
new file mode 100644
index 0000000..3423eff
--- /dev/null
+++ b/.github/skills/config-provider-system/SKILL.md
@@ -0,0 +1,144 @@
+---
+name: config-provider-system
+description: >
+ 在 .NET 应用中设计或使用统一配置提供者架构，涵盖强类型单例配置、多格式文件（XML/JSON/INI）、
+ 远程配置中心（HTTP/Apollo）、热更新绑定、冒号分隔多级 Key 访问，以及命令行参数解析。
+ 适用于配置系统设计、IConfigProvider 实现、ConfigAttribute 定义，以及代码审查任务。
+argument-hint: >
+ 说明你的配置场景：本地文件还是远程配置中心；是否需要热更新；
+ 强类型单例 (Config<T>) 还是手动 IConfigProvider；单环境还是多 Scope。
+---
+
+# 配置提供者系统设计技能
+
+## 适用场景
+
+- 为应用程序定义强类型配置对象，并希望自动与文件（XML/JSON/INI）双向同步。
+- 使用远程配置中心（如星尘、Apollo）统一管理多服务配置，需要轮询热更新和本地缓存兜底。
+- 在同一进程中同时使用多种配置来源，需要优先级组合或命名空间隔离。
+- 解析命令行参数并与配置模型合并。
+- 审查现有配置代码是否遵循接口优先、单例访问、热更新安全等原则。
+
+## 核心原则
+
+1. **接口优先**：所有代码面向 `IConfigProvider` 接口，不直接依赖 `XmlConfigProvider` 等具体类型；提供者实例通过 `Config<T>.Provider` 替换，而不是在业务逻辑中手动创建。
+2. **强类型单例 `Config<T>`**：每种配置使用独立的继承类，通过 `Config<T>.Current` 单例访问；`Current` 线程安全，首次访问自动加载文件，文件不存在时返回默认值并写磁盘。
+3. **热更新 `Bind`**：`provider.Bind<T>(model, autoReload: true)` 让配置变更自动同步到模型属性；订阅方应避免在 `Changed` 回调中执行耗时逻辑。
+4. **冒号多级 Key**：索引器 `provider["Database:ConnectionString"]` 支持跨层级读写，等价于节点树遍历，无须手动拆分路径。
+5. **首次创建检测**：`IsNew = true` 表示配置文件首次生成，可在 `OnLoaded()` 中做默认值初始化和 `Save()` 落盘；避免在构造时递归访问 `Current`。
+
+## 执行步骤
+
+### 一、选择提供者类型
+
+| 场景 | 推荐提供者 |
+|------|-----------|
+| 本地 XML（默认）| `XmlConfigProvider`（`Config<T>` 默认） |
+| 本地 JSON | `JsonConfigProvider` via `[Config("name", Provider = typeof(JsonConfigProvider))]` |
+| 本地 INI | `IniConfigProvider` |
+| 星尘/自研配置中心 | `HttpConfigProvider` |
+| Apollo | `ApolloConfigProvider` |
+| 多来源组合 | `CompositeConfigProvider` |
+
+### 二、定义 `Config<T>` 强类型配置
+
+1. 继承 `Config<TConfig>`，添加 `[Config("文件名")]` 特性。
+2. 每个属性加 `[Description("...")]` 注释——`XmlConfigProvider` 会把它写成 XML 注释；`JsonConfigProvider` 会忽略。
+3. 在 `OnLoaded()` 中验证/修正字段值，确保不合法字段不会传到业务层。
+4. 不要在类的静态构造或实例构造中访问 `Config<T>.Current`（递归加载陷阱）。
+
+```csharp
+[Config("AppSettings")]
+public class AppSettings : Config<AppSettings>
+{
+ [Description("服务端口")]
+ public Int32 Port { get; set; } = 8080;
+
+ [Description("调试模式")]
+ public Boolean Debug { get; set; }
+
+ protected override void OnLoaded()
+ {
+ if (Port is <= 0 or > 65535) Port = 8080;
+ }
+}
+
+// 使用
+var cfg = AppSettings.Current;
+var port = cfg.Port;
+```
+
+### 三、切换为远程配置中心
+
+```csharp
+// 在应用启动最早处（Main / 程序入口）覆盖 Provider
+AppSettings.Provider = new HttpConfigProvider
+{
+ Server = "http://stardust-config-center",
+ AppId = "my-service",
+ Secret = "xxx",
+ Scope = "production",
+ Period = 30, // 每 30 秒轮询
+ CacheLevel = ConfigCacheLevel.Json // 本地明文缓存兜底
+};
+```
+
+- `Provider` 必须在首次访问 `Current` 之前赋值；赋值后置空 `_Current`（若有该 API）重新加载。
+- 不要在 DI 容器构造期间访问 `Current`，可能导致提供者尚未替换。
+
+### 四、热更新绑定模型
+
+```csharp
+var provider = new HttpConfigProvider { /* ... */ };
+
+// 绑定 POCO 模型，配置变更自动写回属性
+provider.Bind<FeatureFlags>(flags, autoReload: true);
+
+// 监听变更事件做额外处理
+provider.Changed += (_, _) =>
+{
+ _logger.Info("配置已更新");
+ RefreshCaches();
+};
+```
+
+- `Bind` 会立即从 `provider` 加载一次，后续配置变更触发 `Changed` 时自动更新属性。
+- 修改绑定后的模型属性后，需要显式调用 `provider.Save(model)` 才能持久化。
+
+### 五、命令行参数解析
+
+```csharp
+var parser = new CommandParser { IgnoreCase = true };
+var args = parser.Parse(Environment.GetCommandLineArgs());
+
+// --port 9090 → args["port"] = "9090"
+// -v → args["v"] = null
+
+var port = args["port"].ToInt(8080);
+```
+
+### 六、自定义 `IConfigProvider`
+
+1. 实现 `LoadAll()`（从数据源 → 配置树 `Root`）和 `SaveAll()`（配置树 → 数据源）。
+2. `this[key]` 的 get 调用 `Root` 的节点树遍历，set 写回对应节点并触发 `Changed`。
+3. 如需自定义属性映射（如字段名转换），实现目标类上的 `IConfigMapping` 接口。
+
+## 重点检查项
+
+- [ ] 是否面向 `IConfigProvider` 接口，而非直接依赖具体类？
+- [ ] `Config<T>.Current` 是否在构造函数内（包括静态构造）被调用，导致递归？
+- [ ] 远程提供者的 `AppId` 是否已设置（未设置会被服务端拒绝）？
+- [ ] 热更新 `Bind` 后修改属性是否遗漏 `Save()`？
+- [ ] 配置修改后是否调用了 `SaveAll()` / `Save()`（变更不会自动持久化到文件）？
+- [ ] 多来源场景是否用了 `CompositeConfigProvider` 管理优先级？
+
+## 输出要求
+
+- **配置类**：继承 `Config<T>`，有 `[Config]` 特性、`[Description]` 属性注释、`OnLoaded` 验证。
+- **提供者初始化**：在 `Main` / `Startup` 最早处完成 `Provider` 赋值，严格早于 `Current` 的首次访问。
+- **热更新**：使用 `Bind` + `Changed` 事件，而不是轮询 `Current` 取值对比。
+- **测试**：覆盖首次创建（`IsNew`）路径、`OnLoaded` 校验、`Changed` 回调、远端不可用时本地缓存兜底。
+
+## 参考资料
+
+参考示例与模式证据见 `references/newlife-core-config-patterns.md`。
diff --git a/.github/skills/dependency-injection-ioc/references/newlife-ioc-patterns.md b/.github/skills/dependency-injection-ioc/references/newlife-ioc-patterns.md
new file mode 100644
index 0000000..27ccbc1
--- /dev/null
+++ b/.github/skills/dependency-injection-ioc/references/newlife-ioc-patterns.md
@@ -0,0 +1,113 @@
+# NewLife.Core IoC 容器模式证据
+
+> 来源：`Model/ObjectContainer.cs`（UTF-8，编码正常）+ `Doc/对象容器ObjectContainer.md`（GBK 编码损坏）
+> 以源码为准。
+
+---
+
+## 1. 核心类层次（源码校验）
+
+```text
+IObjectContainer
+├── Services: IList<IObject>
+├── Add(IObject)
+├── TryAdd(IObject) → Boolean
+├── Register(serviceType, implType, instance) [Obsolete，隐藏]
+└── 扩展方法：AddSingleton, AddTransient, AddScoped, GetService<T>, GetRequiredService<T>
+
+ObjectContainer : IObjectContainer
+├── static Current: IObjectContainer
+├── static Provider: IServiceProvider
+├── static SetInnerProvider(IServiceProvider)
+└── static SetInnerProvider(Func<IServiceProvider>)
+
+ServiceDescriptor : IObject
+├── ServiceType: Type
+├── ImplementationType: Type?
+├── Lifetime: ObjectLifetime
+├── Instance: Object?
+└── Factory: Func<IServiceProvider, Object>?
+
+ObjectLifetime { Singleton=0, Scoped=1, Transient=2 }
+```
+
+---
+
+## 2. 静态构造器初始化顺序（源码）
+
+```csharp
+static ObjectContainer()
+{
+ var ioc = new ObjectContainer();
+ Current = ioc;
+ Provider = ioc.BuildServiceProvider(); // 早期阶段创建临时提供者
+}
+```
+
+> **关键**：`BuildServiceProvider()` 在静态构造阶段就被调用，因此早于任何 `AddSingleton/TryAdd` 注册。这意味着应用启动时要先注册再构建，或使用 `SetInnerProvider` 桥接完整 DI。
+
+---
+
+## 3. `TryAdd` vs `Add` 语义差异（源码）
+
+```csharp
+// TryAdd：检查 ServiceType 是否已存在，存在则跳过
+public Boolean TryAdd(IObject item)
+{
+ lock (_list)
+ {
+ if (_list.Any(e => e.ServiceType == item.ServiceType)) return false;
+ _list.Add(item);
+ return true;
+ }
+}
+
+// Add：无论如何都加入列表（允许同类型多实现）
+public void Add(IObject item) { lock (_list) { _list.Add(item); } }
+```
+
+> 库代码用 `TryAdd` 注册默认实现（可被应用覆盖）；`IHostedService` 等多实现接口用 `Add` 多次注册。
+
+---
+
+## 4. SetInnerProvider 两阶段集成（源码注释）
+
+```csharp
+// 阶段1（AddXxx 时）：延迟绑定，延迟到需要时才初始化真正的 IServiceProvider
+static void SetInnerProvider(Func<IServiceProvider> factory);
+
+// 阶段2（UseXxx / app.Build() 后）：立即替换为已就绪的 IServiceProvider
+static void SetInnerProvider(IServiceProvider innerServiceProvider);
+```
+
+> 两阶段设计是为了适配 ASP.NET Core 的"先注册后构建"流程：注册阶段无法拿到 `app.Services`，所以先提供工厂；`Configure` 阶段已有 `app.ApplicationServices` 后再更新为实例。
+
+---
+
+## 5. GlobalEnvironment 与构造函数自动注入（文档节选）
+
+```csharp
+// ObjectContainer 自动分析构造函数，选择所有参数均已注册的重载
+ioc.AddTransient<IUserService, UserService>();
+// UserService(ILog log, ICache cache) → 若 ILog/ICache 都已注册，自动注入
+```
+
+若构造函数有无法自动解析的参数，用工厂委托：
+
+```csharp
+ioc.AddTransient<IUserService>(sp =>
+ new UserService(sp.GetRequiredService<ILog>(), customArg: 42));
+```
+
+---
+
+## 6. 通用规则 vs NewLife.Core 特例
+
+| 规则 | 通用性 | 说明 |
+|------|--------|------|
+| Singleton/Transient/Scoped 三生命周期 | ✅ 通用 | 与 MS DI 完全对齐 |
+| `IServiceProvider` 标准兼容 | ✅ 通用 | 可直接替换 MS DI |
+| `TryAdd` 保护默认注册 | ✅ 通用 | MS DI 中 `TryAdd` 扩展方法语义相同 |
+| `ObjectContainer.Current` 全局静态 | ⚠️ NewLife 特有 | 通用替代：通过 DI 传递 `IServiceProvider` |
+| `SetInnerProvider` 两阶段桥接 | ⚠️ NewLife 特有 | 适配 ASP.NET Core 的特有集成模式 |
+| 构造函数自动选择最优重载 | ⚠️ 行为特有 | MS DI 也支持，但错误消息不同 |
diff --git a/.github/skills/dependency-injection-ioc/SKILL.md b/.github/skills/dependency-injection-ioc/SKILL.md
new file mode 100644
index 0000000..64f46d4
--- /dev/null
+++ b/.github/skills/dependency-injection-ioc/SKILL.md
@@ -0,0 +1,142 @@
+---
+name: dependency-injection-ioc
+description: >
+ 使用 NewLife.Core 内置轻量级 IoC 容器（ObjectContainer）进行依赖注入，
+ 涵盖服务生命周期注册（Singleton/Transient/Scoped）、全局工厂访问、
+ 工厂委托注册、Add vs TryAdd 语义，以及与 ASP.NET Core DI 的两阶段集成。
+ 适用于应用启动配置、跨组件解耦、IoC 容器桥接与代码审查任务。
+argument-hint: >
+ 说明你的 DI 场景：纯控制台/Worker 应用还是 ASP.NET Core；
+ 需要用 AddSingleton/AddTransient/AddScoped；是否需要工厂委托注册；
+ 是否要与 ASP.NET Core 内置 DI 容器联动（SetInnerProvider）。
+---
+
+# 依赖注入与 IoC 容器技能
+
+## 适用场景
+
+- 新建应用需要简单的 DI，不想依赖 ASP.NET Core 的完整 DI 框架。
+- 库或组件注册自身服务到全局容器（`ObjectContainer.Current`），供宿主应用解析。
+- 在 ASP.NET Core 应用中，需要将 `ObjectContainer` 与内置容器桥接，使两套容器共享注册。
+- 代码审查：确认服务生命周期选择恰当，避免 Scoped 服务注入 Singleton，避免 `new` 代替注入。
+
+## 核心原则
+
+1. **全局容器唯一入口**：`ObjectContainer.Current`（注册时使用）和 `ObjectContainer.Provider`（解析时使用）是应用级全局单例，库代码通过它们读写服务，不传递容器实例。
+2. **`TryAdd` vs `Add` 语义差异**：`TryAdd` 仅在该服务类型尚未注册时才添加（库代码注册默认实现用此模式）；`Add` 允许同类型重复注册（同一类型多实例场景，如多个 `IHostedService`）。
+3. **生命周期选择**：`Singleton` 共享全程；`Transient` 每次都 `new`；`Scoped` 仅在 Web 场景每请求共享——纯控制台应用一般不需要 Scoped。
+4. **构造函数自动注入**：`ObjectContainer` 会自动分析构造函数参数，选择所有参数都已注册的重载；若构造函数有未注册参数，请用工厂委托手动提供。
+5. **两阶段初始化（ASP.NET Core）**：`ObjectContainer.Current` 先注册，应用构建后用 `SetInnerProvider(app.Services)` 桥接，之后 `ObjectContainer.Provider` 的解析请求会委托给真正的 `IServiceProvider`。
+
+## 执行步骤
+
+### 一、基础注册与解析
+
+```csharp
+var ioc = ObjectContainer.Current;
+
+// Singleton：整个应用生命周期只有一个实例
+ioc.AddSingleton<IAppConfig, AppConfig>();
+
+// Transient：每次 GetService 都创建新实例
+ioc.AddTransient<IUserService, UserService>();
+
+// 注册已有实例（常用于配置对象）
+ioc.AddSingleton<DatabaseOptions>(new DatabaseOptions { ConnStr = "..." });
+
+// 解析
+var config = ObjectContainer.Provider.GetService<IAppConfig>();
+var userSvc = ObjectContainer.Provider.GetRequiredService<IUserService>();
+```
+
+### 二、工厂委托注册
+
+```csharp
+// 需要在创建时访问其他服务时，使用工厂委托
+ioc.AddSingleton<IDbConnectionFactory>(sp =>
+{
+ var opts = sp.GetRequiredService<DatabaseOptions>();
+ return new SqlConnectionFactory(opts.ConnStr);
+});
+
+// Transient 工厂
+ioc.AddTransient<ICommand>(sp =>
+{
+ var log = sp.GetRequiredService<ILog>();
+ return new SyncCommand(log, retryCount: 3);
+});
+```
+
+### 三、TryAdd 保护默认实现
+
+```csharp
+// 库代码：只在用户未手动注册时提供默认实现
+ioc.TryAddSingleton<ITracer, DefaultTracer>();
+ioc.TryAddSingleton<ICache, MemoryCache>();
+
+// 应用代码可覆盖：调用时机必须在库注册之前，或在 TryAdd 之后用 Add 覆盖
+ioc.AddSingleton<ITracer>(myCustomTracer); // Add 不受保护，直接追加
+```
+
+### 四、多实现注册（如 IHostedService）
+
+```csharp
+// Add（而非 TryAdd）可以为同一接口注册多个实现
+ioc.Add(new ServiceDescriptor(typeof(IHostedService), typeof(MetricsService), ObjectLifetime.Singleton));
+ioc.Add(new ServiceDescriptor(typeof(IHostedService), typeof(CleanupService), ObjectLifetime.Singleton));
+
+// 解析：GetServices<T>（扩展方法）返回所有注册实现
+var services = ObjectContainer.Provider.GetServices<IHostedService>();
+```
+
+### 五、ASP.NET Core 双容器桥接
+
+```csharp
+// Program.cs — 注册阶段（AddXxx 时）
+var ioc = ObjectContainer.Current;
+ioc.AddSingleton<ICustomService, CustomService>(); // 注册到 NewLife 容器
+
+// 也可以将 IServiceCollection 委托到 ObjectContainer
+builder.Services.AddFromObjectContainer(ioc); // 若有此扩展
+
+// 构建完成后，桥接到 ASP.NET Core 内置 DI
+var app = builder.Build();
+ObjectContainer.SetInnerProvider(app.Services);
+
+// 之后 ObjectContainer.Provider.GetService<T>()
+// 会先查 NewLife 自身，再查 app.Services（内部提供者）
+```
+
+### 六、Scoped 作用域（Web 请求）
+
+```csharp
+// 注册 Scoped
+ioc.AddScoped<IDbContext, AppDbContext>();
+
+// 在中间件中手动创建作用域（若不用 IServiceScopeFactory 自动处理）
+using var scope = ObjectContainer.Provider.CreateScope();
+var dbCtx = scope.ServiceProvider.GetRequiredService<IDbContext>();
+await dbCtx.SaveChangesAsync();
+// scope.Dispose() → dbCtx 被释放
+```
+
+## 重点检查项
+
+- [ ] Scoped 服务是否被注入到 Singleton 服务中（捕获依赖问题，导致 Scoped 退化为 Singleton）？
+- [ ] 库代码是否使用 `TryAdd` 而非 `Add` 注册默认实现（避免覆盖用户自定义）？
+- [ ] `GetRequiredService` 在服务未注册时会抛出，是否有意料外的 `InvalidOperationException`？
+- [ ] `SetInnerProvider` 是否在 `app.Build()` 之后调用，而不是在注册阶段？
+- [ ] Transient 服务实现了 `IDisposable` 时，是否由容器在正确时机释放（还是泄漏）？
+- [ ] 是否有绕过 DI 直接 `new` 服务实例的代码，导致其依赖未被注入？
+
+## 输出要求
+
+- **接口**：`IObjectContainer`（注册 API）、`IServiceProvider`（解析 API，标准兼容）、`IObject`/`ServiceDescriptor`（注册元数据）。
+- **生命周期**：`ObjectLifetime.Singleton/Transient/Scoped` 枚举。
+- **全局入口**：`ObjectContainer.Current`（注册）、`ObjectContainer.Provider`（解析）。
+- **扩展方法**：`AddSingleton<T,TImpl>()`/`AddTransient<T,TImpl>()`/`AddScoped<T,TImpl>()`（流式 API）。
+- **测试**：测试时可为每个测试用例创建独立 `new ObjectContainer()`，避免全局状态污染。
+
+## 参考资料
+
+参考示例与模式证据见 `references/newlife-core-ioc-patterns.md`。
diff --git a/.github/skills/development-workflow/references/newlife-core-flow-template.md b/.github/skills/development-workflow/references/newlife-flow-template.md
similarity index 100%
rename from .github/skills/development-workflow/references/newlife-core-flow-template.md
rename to .github/skills/development-workflow/references/newlife-flow-template.md
diff --git a/.github/skills/event-bus-messaging/references/newlife-core-eventbus-patterns.md b/.github/skills/event-bus-messaging/references/newlife-eventbus-patterns.md
similarity index 100%
rename from .github/skills/event-bus-messaging/references/newlife-core-eventbus-patterns.md
rename to .github/skills/event-bus-messaging/references/newlife-eventbus-patterns.md
diff --git a/.github/skills/high-performance-buffers/references/newlife-core-ipacket-patterns.md b/.github/skills/high-performance-buffers/references/newlife-ipacket-patterns.md
similarity index 100%
rename from .github/skills/high-performance-buffers/references/newlife-core-ipacket-patterns.md
rename to .github/skills/high-performance-buffers/references/newlife-ipacket-patterns.md
diff --git a/.github/skills/high-performance-buffers/SKILL.md b/.github/skills/high-performance-buffers/SKILL.md
index 5a8eed6..51c6409 100644
--- a/.github/skills/high-performance-buffers/SKILL.md
+++ b/.github/skills/high-performance-buffers/SKILL.md
@@ -73,6 +73,81 @@ argument-hint: >
- `ToStr(encoding, offset, count)`：按编码读取文本内容。
- `Clone()`：深拷贝当前链为独立 `ArrayPacket`，用于断点观察数据快照。
+### 七、零分配解析（SpanReader）
+
+`SpanReader` 是 `ref struct`，从 `Span<Byte>` / `IPacket` / `Stream` 零分配读取二进制数据：
+
+```csharp
+// 从 IPacket 构造，直接在原始内存上解析
+var reader = new SpanReader(packet);
+
+// 读取基础类型（默认大端，IsLittleEndian=true 切换小端）
+var magic = reader.ReadUInt32();
+var length = reader.ReadEncodedInt(); // 7位变长整数
+var name = reader.ReadString(0); // 带长度前缀的字符串（长度=0表示读前缀）
+var body = reader.ReadBytes(length); // 固定长度切片
+
+// 读取结构体（直接内存布局，零拷贝）
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+struct PacketHeader { ... }
+var header = reader.Read<PacketHeader>();
+```
+
+**关键约束**：`SpanReader` 是 `ref struct`，禁止存入字段、`async` 方法、`Task`、队列。
+
+### 八、零分配写入（SpanWriter / PooledByteBufferWriter）
+
+```csharp
+// 固定缓冲区写入（栈上分配，Size 小于 1KB 时推荐）
+Span<Byte> buf = stackalloc Byte[256];
+var w = new SpanWriter(buf);
+w.Write((UInt32)0x12345678); // 写 Magic
+w.WriteEncodedInt(messageId); // 7位变长整数
+w.Write(content, 0); // 带长度前缀的字符串
+var written = buf[..w.WrittenCount]; // 已写入的切片
+
+// 动态池化写入（大包或不定长，实现 IBufferWriter<Byte>）
+using var pw = new PooledByteBufferWriter(initialCapacity: 1024);
+var sw = new SpanWriter(pw.GetSpan(256));
+sw.Write(payload);
+pw.Advance(sw.WrittenCount);
+var memory = pw.WrittenMemory; // ReadOnlyMemory<Byte>，零拷贝输出
+```
+
+### 九、TCP 粘包拆包（PacketCodec）
+
+每个 TCP 连接独立一个 `PacketCodec`，解决粘包/半包问题：
+
+```csharp
+// 在 NetSession 中
+private readonly PacketCodec _codec = new PacketCodec
+{
+ // 从头部读取完整包长度（返回 0 / 负数 = 数据不足）
+ GetLength2 = span =>
+ {
+ if (span.Length < 4) return 0;
+ return (span[0] << 24 | span[1] << 16 | span[2] << 8 | span[3]) + 4;
+ },
+ MaxCache = 4 * 1024 * 1024, // 防止恶意大包耗尽内存
+ Expire = 5_000, // 5秒内未收到完整包则丢弃残余缓存
+};
+
+protected override void OnReceive(ReceivedEventArgs e)
+{
+ // 一包可能包含多条消息，或不足一条
+ foreach (var pk in _codec.Parse(e.Packet))
+ ProcessMessage(pk); // pk 是一个完整的业务帧
+}
+
+protected override void OnDisconnected(String reason)
+{
+ base.OnDisconnected(reason);
+ _codec.Dispose(); // 释放内部 MemoryStream
+}
+```
+
+**快速路径**：无残余缓存时，`Parse` 直接在原始 `IPacket` 上切片，不分配内存；**慢速路径**：有残余缓存时合并到 `MemoryStream` 后继续解析（有锁保护）。
+
## 重点检查项
- [ ] `OwnerPacket` 的释放路径是否完整？是否有 `using` 或等效的 `Dispose` 确保归还池？
diff --git a/.github/skills/hosted-services-lifecycle/references/newlife-host-patterns.md b/.github/skills/hosted-services-lifecycle/references/newlife-host-patterns.md
new file mode 100644
index 0000000..8c633ef
--- /dev/null
+++ b/.github/skills/hosted-services-lifecycle/references/newlife-host-patterns.md
@@ -0,0 +1,125 @@
+# NewLife.Core Host 模式证据
+
+> 来源：`Doc/轻量级应用主机Host.md`（部分编码损坏）+ `Model/Host.cs` + `Model/IObjectContainer.cs`
+> 文档中文编码损坏段落以源码及类型注释为准。
+
+---
+
+## 1. 接口与类层次（源码校验）
+
+```text
+IHostedService
+├── StartAsync(CancellationToken)
+└── StopAsync(CancellationToken)
+
+IHost
+├── Services (IServiceProvider)
+├── Add(IHostedService) / Add<TService>()
+├── StartAsync / StopAsync
+├── Run / RunAsync
+└── Close(reason)
+
+Host : DisposeBase, IHost
+├── Services (构造注入 IServiceProvider)
+├── HostedServices (IList<IHostedService> — 已注册服务列表)
+├── MaxTime (Int32，默认 -1 永久阻塞)
+└── 信号处理 (Ctrl+C / SIGINT / SIGTERM → 调用所有 StopAsync)
+```
+
+---
+
+## 2. `AddHostedService` 扩展（源码）
+
+```csharp
+// 等价于 ioc.AddSingleton<IHostedService, THostedService>()
+public static IObjectContainer AddHostedService<THostedService>(
+ this IObjectContainer services) where THostedService : class, IHostedService
+{
+ services.AddSingleton<IHostedService, THostedService>();
+ return services;
+}
+
+// 工厂重载，支持依赖注入传参
+public static IObjectContainer AddHostedService<THostedService>(
+ this IObjectContainer services,
+ Func<IServiceProvider, THostedService> implementationFactory) where THostedService : class, IHostedService
+{
+ services.AddSingleton<IHostedService>(implementationFactory);
+ return services;
+}
+```
+
+**重点**：`IHostedService` 是以 `Singleton` 注册的，容器只创建一个实例；多次注册同一类型会叠加（同 `.NET` 泛型宿主行为）。
+
+---
+
+## 3. 主机启停顺序（文档观察 + 源码推断）
+
+```
+Host.Run / RunAsync
+│
+├─ foreach services → service.StartAsync(ct) ← 顺序启动
+├─ 阻塞等待: MaxTime (-1 = 永久) 或收到 SIGTERM/Ctrl+C
+├─ foreach services (逆序) → service.StopAsync(ct) ← 逆序停止
+└─ Dispose
+```
+
+- 文档说明：MaxTime > 0 时精确到毫秒；文档示例中使用 60_000 表示 1 分钟。
+- 逆序停止来源：文档原则"最后启动的先停止"（依赖链安全）。
+
+---
+
+## 4. `IHostedService` 实现要点（源码注释）
+
+```csharp
+// StartAsync：立即返回，在后台 Task 运行；不在此处 await 长任务
+public Task StartAsync(CancellationToken cancellationToken)
+{
+ _cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+ _task = RunAsync(_cts.Token);
+ return Task.CompletedTask;
+}
+
+// StopAsync：取消 CTS，等待 Task 或超时
+public async Task StopAsync(CancellationToken cancellationToken)
+{
+ _cts?.Cancel();
+ if (_task != null)
+ await Task.WhenAny(_task, Task.Delay(5_000, cancellationToken));
+}
+```
+
+---
+
+## 5. `Host.RegisterExit` 静态方法
+
+```csharp
+// 注册进程退出回调（可多次调用，每次追加）
+Host.RegisterExit(() => { /* 清理资源 */ });
+
+// 接收 sender/EventArgs 版本
+Host.RegisterExit((sender, e) => { /* ... */ });
+```
+
+内部统一接管 `AppDomain.ProcessExit` 和 `Console.CancelKeyPress`，防止各处重复注册冲突。
+
+---
+
+## 6. 与 `Microsoft.Extensions.Hosting` 兼容性
+
+- `IHostedService` 接口签名在语义上完全一致（`StartAsync`/`StopAsync`），.NET 5+ 下可互相兼容。
+- `ObjectContainer` 实现了 `IServiceProvider`，可作为宿主的 `Services` 传入。
+- 不需要 `Microsoft.Extensions.Hosting` 包依赖，适合体积敏感或 AOT 场景。
+
+---
+
+## 7. 通用规则 vs NewLife.Core 特例
+
+| 规则 | 通用性 | 说明 |
+|------|--------|------|
+| `IHostedService` Start/Stop | ✅ 通用 | `.NET` 泛型宿主同接口 |
+| `StartAsync` 立即返回 | ✅ 通用 | 与 `BackgroundService` 基类一致 |
+| `CancellationToken` 协作退出 | ✅ 通用 | 标准取消模式 |
+| `RegisterExit` 统一信号处理 | ⚠️ NewLife 特有 | 通用替代：`IHostApplicationLifetime` |
+| `ObjectContainer.AddHostedService` | ⚠️ NewLife 特有 | 通用替代：`IServiceCollection.AddHostedService` |
+| `MaxTime` 属性限时退出 | ⚠️ NewLife 特有 | 通用替代：`CancellationTokenSource(TimeSpan)` |
diff --git a/.github/skills/hosted-services-lifecycle/SKILL.md b/.github/skills/hosted-services-lifecycle/SKILL.md
new file mode 100644
index 0000000..4b27a7a
--- /dev/null
+++ b/.github/skills/hosted-services-lifecycle/SKILL.md
@@ -0,0 +1,143 @@
+---
+name: hosted-services-lifecycle
+description: >
+ 设计轻量级应用主机，管理后台服务（IHostedService）的启动、停止顺序与生命周期。
+ 涵盖宿主信号处理（Ctrl+C/SIGTERM）、优雅停机、依赖注入集成，以及最大执行时间限制。
+ 适用于控制台应用、后台服务、微服务、守护进程等场景的主机设计与代码审查。
+argument-hint: >
+ 说明你的宿主场景：常驻进程还是限时任务；是否需要多服务并行；
+ 如何做依赖注入（ObjectContainer 还是 MS DI）；是否需要定时停止或优雅停机钩子。
+---
+
+# 应用主机生命周期管理技能
+
+## 适用场景
+
+- 控制台应用需要同时运行多个后台服务（消息消费、定时任务、健康检查等），并在收到 Ctrl+C 或系统信号时优雅停机。
+- 微服务/守护进程需要统一管理各组件的启动/停止顺序，确保依赖关系和资源释放正确。
+- 需要在依赖注入容器初始化完成后，统一拉起全部已注册的后台服务。
+- 定时测试或 CI 场景需要运行一段时间后自动退出（`MaxTime` 限制）。
+
+## 核心原则
+
+1. **`IHostedService` 契约**：每个后台服务独立实现 `StartAsync(CancellationToken)` 和 `StopAsync(CancellationToken)`；启动时不阻塞（耗时任务在后台 `Task` 中运行）；停止时等待当前工作单元完成，但要遵守 `CancellationToken`。
+2. **单向生命周期**：`Host` 顺序启动所有服务，逆序停止；不要直接持有 `Host` 引用在服务内部调用 `Close`，应通过 `CancellationToken` 协作退出。
+3. **依赖注入优先**：通过 `IObjectContainer.AddHostedService<T>()` 注册服务，让容器负责实例化和依赖解析；避免在 `Add<TService>()` 之前手工 `new`。
+4. **优雅停机时限**：`StopAsync` 应设置合理超时（比如 5 秒）；超时后强制退出，防止应用卡死；`MaxTime` 用于测试或限时任务，生产环境通常保持 `-1`。
+5. **信号处理统一**：通过 `Host.RegisterExit` 注册清理回调，而非散落在各处监听 `AppDomain.ProcessExit` / `Console.CancelKeyPress`。
+
+## 执行步骤
+
+### 一、定义后台服务
+
+```csharp
+public class WorkerService : IHostedService
+{
+ private CancellationTokenSource? _cts;
+ private Task? _task;
+
+ public Task StartAsync(CancellationToken cancellationToken)
+ {
+ _cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+ _task = RunAsync(_cts.Token);
+ return Task.CompletedTask; // StartAsync 立即返回，不阻塞
+ }
+
+ public async Task StopAsync(CancellationToken cancellationToken)
+ {
+ _cts?.Cancel();
+ if (_task != null)
+ await Task.WhenAny(_task, Task.Delay(5_000, cancellationToken));
+ }
+
+ private async Task RunAsync(CancellationToken stoppingToken)
+ {
+ while (!stoppingToken.IsCancellationRequested)
+ {
+ // 执行业务逻辑
+ await Task.Delay(1_000, stoppingToken);
+ }
+ }
+}
+```
+
+### 二、注册服务并启动主机
+
+```csharp
+// 推荐方式：通过 IoC 注册
+var ioc = ObjectContainer.Current;
+ioc.AddSingleton<IMessageQueue, RedisQueue>();
+ioc.AddHostedService<WorkerService>();
+ioc.AddHostedService<HealthCheckService>();
+
+var host = new Host(ioc.BuildServiceProvider());
+host.Run(); // 阻塞，直到 Ctrl+C / SIGTERM / Close()
+```
+
+- `AddHostedService<T>()` 等价于 `ioc.AddSingleton<IHostedService, T>()`，服务实例由容器管理。
+- 若需手动传入已构建的实例：`host.Add(myServiceInstance)`。
+
+### 三、信号与退出钩子
+
+```csharp
+// 注册清理回调（持久注册，可多次调用；生命周期与进程一致）
+Host.RegisterExit(() =>
+{
+ flushLogs();
+ releaseConnections();
+});
+```
+
+- `RegisterExit` 内部使用 `AppDomain.ProcessExit` + `Console.CancelKeyPress`，无需重复注册。
+
+### 四、限时运行（测试/CI）
+
+```csharp
+var host = new Host(ioc.BuildServiceProvider());
+host.MaxTime = 30_000; // 30 秒后自动停止
+await host.RunAsync();
+```
+
+### 五、手动控制启停（集成测试）
+
+```csharp
+using var cts = new CancellationTokenSource();
+
+await host.StartAsync(cts.Token);
+
+// 做断言...
+await Task.Delay(500);
+
+await host.StopAsync(cts.Token);
+```
+
+### 六、与 `Microsoft.Extensions.Hosting` 的对比定位
+
+| 特性 | `NewLife.Model.Host` | `Microsoft.Extensions.Hosting` |
+|------|---------------------|-------------------------------|
+| 接口 | `IHostedService`（相同语义）| `IHostedService` |
+| 容器 | `ObjectContainer`（`IObjectContainer`）| `IServiceCollection` |
+| 信号处理 | `Host.RegisterExit` | 内置 |
+| 依赖 | 仅 `NewLife.Core` | 需 `Microsoft.Extensions.Hosting` |
+
+> 两套 `IHostedService` 接口签名相同，在 .NET 5+ 下可互相兼容；容器层不互通。
+
+## 重点检查项
+
+- [ ] `StartAsync` 是否立即返回？长任务是否在后台 `Task` 中运行，而非在 `StartAsync` 内 `await` 阻塞？
+- [ ] `StopAsync` 是否有合理超时？是否在 `CancellationToken` 被触发后尽快退出？
+- [ ] 服务内是否持有 `Host` 引用并直接调用 `Close`（应改为通过 `CancellationToken` 协作）？
+- [ ] 是否散落多处 `Console.CancelKeyPress` / `AppDomain.ProcessExit`（应改用 `RegisterExit`）？
+- [ ] 服务的构造函数是否注入了过多依赖，或依赖了"还没启动的服务"？
+- [ ] 多服务之间的启停顺序是否有依赖？如有，应通过启动顺序排列或协调令牌解决。
+
+## 输出要求
+
+- **服务类**：实现 `IHostedService`；`StartAsync` 立即返回并启动后台 `Task`；`StopAsync` 取消并等待。
+- **入口**：`Main` 或 `Program.cs` 中用 `AddHostedService<T>()` 注册所有服务，构建 `Host` 并调用 `Run()`。
+- **清理**：通过 `Host.RegisterExit` 统一注册清理钩子，不散落各处。
+- **测试**：能通过 `StartAsync` + 等待 + `StopAsync` 独立测试每个服务，无须启动完整主机。
+
+## 参考资料
+
+参考示例与模式证据见 `references/newlife-core-host-patterns.md`。
diff --git a/.github/skills/http-client-loadbalancer/references/newlife-core-apihttpclient-patterns.md b/.github/skills/http-client-loadbalancer/references/newlife-apihttpclient-patterns.md
similarity index 100%
rename from .github/skills/http-client-loadbalancer/references/newlife-core-apihttpclient-patterns.md
rename to .github/skills/http-client-loadbalancer/references/newlife-apihttpclient-patterns.md
diff --git a/.github/skills/http-client-loadbalancer/SKILL.md b/.github/skills/http-client-loadbalancer/SKILL.md
index c1a92df..2130e97 100644
--- a/.github/skills/http-client-loadbalancer/SKILL.md
+++ b/.github/skills/http-client-loadbalancer/SKILL.md
@@ -63,3 +63,70 @@ argument-hint: 'Provide the target service pattern, endpoint list, authenticatio
## 参考资料
- 参考 `references/newlife-core-apihttpclient-patterns.md`
+
+## 三种负载均衡策略（NewLife.Remoting）
+
+如果使用 `NewLife.Remoting` 中的 `ApiHttpClient`，以下三种内置策略可直接配置：
+
+### 策略对比
+
+| 策略 | 类型 | 适用场景 | 带宽开销 |
+|------|------|---------|---------|
+| 故障转移 | `FailoverLoadBalancer` | 主备切换，正常只用主节点，故障自动接管 | 低 |
+| 加权轮询 | `WeightedRoundRobinLoadBalancer` | 多实例按性能比例分流 | 低 |
+| 竞速调用 | `RaceLoadBalancer` | 极低延迟要求，接受带宽消耗 | 高 |
+
+### 服务节点定义（ServiceEndpoint）
+
+```csharp
+var services = new List<ServiceEndpoint>
+{
+ new ServiceEndpoint("primary", new Uri("http://10.0.0.1:8080")), // 主节点
+ new ServiceEndpoint("backup", new Uri("http://10.0.0.2:8080")), // 备节点
+ new ServiceEndpoint("s2", new Uri("http://10.0.0.3:8080")) { Weight = 2 }, // 权重=2（60%）
+};
+```
+
+### ILoadBalancer 接口
+
+```csharp
+public interface ILoadBalancer
+{
+ LoadBalanceMode Mode { get; }
+ Int32 ShieldingTime { get; set; } // 错误屏蔽秒数（默认 60）
+ ServiceEndpoint GetService(IList<ServiceEndpoint> services);
+ void PutService(IList<ServiceEndpoint> services, ServiceEndpoint svc, Exception? error);
+ // ↑ null = 成功，非null = 失败
+}
+```
+
+### 使用示例（故障转移）
+
+```csharp
+var lb = new FailoverLoadBalancer { ShieldingTime = 30 };
+
+var svc = lb.GetService(services);
+try
+{
+ var result = await CallAsync(svc.Address);
+ lb.PutService(services, svc, null); // 报告成功
+}
+catch (Exception ex)
+{
+ lb.PutService(services, svc, ex); // 报告失败 → 自动屏蔽节点，下次切换
+}
+```
+
+### 负载均衡行为细节
+
+**FailoverLoadBalancer**：
+1. 优先使用 `services[0]`（主节点）
+2. `HttpRequestException`/`TaskCanceledException` → 屏蔽当前节点 `ShieldingTime` 秒，切换到下一节点
+3. 屏蔽到期后，下次 `GetService` 尝试切回主节点
+4. 全部节点不可用时自动重置，重新尝试
+
+**WeightedRoundRobinLoadBalancer**：
+1. 节点按 `Weight` 比例分配：`Weight = 3 / 2` → 约 60% / 40%
+2. 每节点在轮次内用满配额后切换，网络异常时跳过
+
+**RaceLoadBalancer**：并发请求所有节点，第一个响应成功的即返回，其余请求取消。
diff --git a/.github/skills/logging-tracing-system/references/newlife-log-tracer-patterns.md b/.github/skills/logging-tracing-system/references/newlife-log-tracer-patterns.md
new file mode 100644
index 0000000..84a36fa
--- /dev/null
+++ b/.github/skills/logging-tracing-system/references/newlife-log-tracer-patterns.md
@@ -0,0 +1,132 @@
+# NewLife.Core 日志与追踪模式证据
+
+> 来源：`Log/ILog.cs` + `Log/ITracer.cs` + `Log/XTrace.cs`
+> 日志文档（`Doc/日志ILog.md`）存在编码损坏，以源码为准。
+
+---
+
+## 1. 接口层次（源码校验）
+
+```text
+ILog
+├── Write(LogLevel, format, args)
+├── Debug / Info / Warn / Error / Fatal
+├── Enable (Boolean)
+└── Level (LogLevel)
+
+ITracer
+├── Period / MaxSamples / MaxErrors / Timeout / MaxTagLength
+├── AttachParameter W3C traceparent 注入参数名
+├── Resolver ITracerResolver 扩展点
+├── BuildSpan(name) → ISpanBuilder
+├── NewSpan(name) → ISpan（using 块使用）
+├── NewSpan(name, tag)
+└── TakeAll() 重置并返回所有 SpanBuilder
+
+ISpan : IDisposable
+├── TraceId / ParentId
+├── SetError(Exception, tag)
+└── Dispose() → 上报当前 Span
+```
+
+---
+
+## 2. `XTrace` 静态门面关键点（源码）
+
+```csharp
+// 全局 ILog 实例，默认 TextFileLog（延迟初始化）
+public static ILog Log { get { InitLog(); return _Log; } set { _Log = value; } }
+
+// 快捷写日志 → 委托给 Log.Info
+public static void WriteLine(String msg)
+public static void WriteLine(String format, params Object?[] args)
+
+// 异常写入
+public static void WriteException(Exception ex)
+
+// 切换控制台输出（快捷方法）
+public static void UseConsole(Boolean useColor = true)
+
+// 调试模式开关 → Debug 级日志
+public static Boolean Debug { get; set; }
+
+// 日志文件路径
+public static String LogPath { get; set; }
+```
+
+---
+
+## 3. `DefaultTracer` 关键实现（源码）
+
+```csharp
+// 全局单例（影响所有 NewLife 组件追踪行为）
+public static ITracer? Instance { get; set; }
+
+// 静态构造注册默认类型到 IoC
+static DefaultTracer()
+{
+ var ioc = ObjectContainer.Current;
+ ioc.TryAddTransient<ITracer, DefaultTracer>();
+ ioc.TryAddTransient<ISpanBuilder, DefaultSpanBuilder>();
+ ioc.TryAddTransient<ISpan, DefaultSpan>();
+}
+
+// 采样参数默认值
+Period = 15; // 秒
+MaxSamples = 1; // 每周期正常样本
+MaxErrors = 10; // 每周期异常样本
+```
+
+---
+
+## 4. `ILogFeature` 属性注入模式（NewLife 组件惯例）
+
+```csharp
+// 实现此接口的组件通过属性注入日志，而非构造注入
+public interface ILogFeature
+{
+ ILog Log { get; set; }
+}
+
+// 使用方式
+public class NetServer : ILogFeature
+{
+ public ILog Log { get; set; } = Logger.Null; // 默认空日志
+}
+
+// 调用方替换
+var server = new NetServer();
+server.Log = XTrace.Log; // 或注入 TextFileLog 实例
+```
+
+> **项目特例**：`ILogFeature` 是 NewLife 专有模式；通用替代是构造函数注入 `ILog` 或使用 `ILogger<T>` (Microsoft 扩展)。
+
+---
+
+## 5. 日志级别枚举（源码，完整）
+
+```csharp
+public enum LogLevel
+{
+ Off = 0, // 关闭
+ Fatal = 1, // 致命
+ Error = 2, // 错误
+ Warn = 3, // 警告
+ Info = 4, // 信息（默认输出级别）
+ Debug = 5, // 调试
+ All = 6 // 全量
+}
+```
+
+---
+
+## 6. 通用规则 vs NewLife.Core 特例
+
+| 规则 | 通用性 | 说明 |
+|------|--------|------|
+| `ILog` 分级写入接口 | ✅ 通用 | 与 `Microsoft.Extensions.Logging.ILogger` 等价 |
+| 静态门面 (`XTrace`) | ⚠️ 半通用 | 思路通用；具体类 NewLife 特有 |
+| `ILogFeature` 属性注入 | ⚠️ NewLife 特有 | 通用替代：构造注入 `ILog` |
+| `ITracer/ISpan` 轻量 APM | ✅ 通用 | 与 `OpenTelemetry` / `Activity` 思路相同 |
+| `DefaultTracer.Instance` 全局替换 | ✅ 通用 | 单例模式，可替换 |
+| W3C `traceparent` 自动注入 | ✅ 通用 | 标准 HTTP 追踪头 |
diff --git a/.github/skills/logging-tracing-system/SKILL.md b/.github/skills/logging-tracing-system/SKILL.md
new file mode 100644
index 0000000..8186546
--- /dev/null
+++ b/.github/skills/logging-tracing-system/SKILL.md
@@ -0,0 +1,151 @@
+---
+name: logging-tracing-system
+description: >
+ 在 .NET 应用中设计或使用统一日志与链路追踪系统，涵盖 ILog 分级写入、XTrace 静态门面、
+ ITracer/ISpan 轻量级 APM 埋点、TraceId 透传，以及日志实现切换（文件/控制台/网络/组合）。
+ 适用于日志接口设计、链路追踪集成、观测性基础设施建设与代码审查任务。
+argument-hint: >
+ 说明你的可观测性需求：是否只需要日志还是也需要追踪；
+ 用 XTrace 静态门面还是 DI 注入 ILog；TraceId 是否要跨服务传播；
+ 需要哪种日志实现（文件/控制台/网络/CompositeLog）。
+---
+
+# 日志与链路追踪系统技能
+
+## 适用场景
+
+- 新建 .NET 应用需要快速集成日志，希望面向接口而非绑定某个具体日志框架。
+- 已有 `XTrace.WriteLine` 散落各处，需要梳理日志级别、切换日志目标（文件→控制台→网络）。
+- 需要在 HTTP/RPC 调用链中传播 `TraceId`，并在本地 `ISpan` 中记录耗时和 Tag。
+- 代码审查：确认依赖注入中是否通过 `ILog` / `ILogFeature` 接口接受日志，而非硬编码 `XTrace`。
+- 接入 APM 平台，需要实现 `ITracer` 或替换 `DefaultTracer.Instance`。
+
+## 核心原则
+
+1. **接口写日志**：业务类通过 `ILog` 接口记录日志（构造注入或 `ILogFeature.Log` 属性）；只有应用入口和工具类才直接用 `XTrace` 静态门面。
+2. **`XTrace` 是全局门面**：`XTrace.Log` 持有当前 `ILog` 实现；`XTrace.WriteLine` 委托给 `XTrace.Log.Info`；切换全局日志实现只需替换 `XTrace.Log`。
+3. **日志级别控制**：通过 `ILog.Level` 过滤；`Debug` 级默认不写文件（`XTrace.Debug = true` 才启用）；生产环境至少保留 `Info`。
+4. **`ITracer` 轻量 APM**：通过 `DefaultTracer.Instance` 全局替换追踪器；每个操作用 `using var span = tracer.NewSpan("name", tag)` 包裹；`Span.Dispose` 自动上报。
+5. **TraceId 透传**：`ISpan` 活跃期间，发出的 HTTP/RPC 请求自动注入 `traceparent`（W3C 标准）；事件总线等组件读取 `DefaultTracer.Current?.TraceId` 写入消息头。
+6. **组合日志**：用 `CompositeLog` 将多个 `ILog` 实现合并为一路，替换 `XTrace.Log` 即可同时写文件和控制台。
+
+## 执行步骤
+
+### 一、确定日志目标
+
+| 场景 | 推荐实现 |
+|------|---------|
+| 默认文件日志 | `TextFileLog`（`XTrace` 自动初始化）|
+| 控制台应用调试 | `XTrace.UseConsole()` 或 `ConsoleLog` |
+| 远程聚合 | `NetworkLog` |
+| 多目标 | `CompositeLog(fileLog, consoleLog)` |
+
+### 二、业务类注入日志
+
+```csharp
+// 方式 1：构造注入（推荐，可测试）
+public class MyService(ILog log)
+{
+ public void Process()
+ {
+ log.Info("开始处理");
+ try { /* ... */ }
+ catch (Exception ex) { log.Error("{0}", ex.Message); }
+ }
+}
+
+// 方式 2：ILogFeature 接口属性（NewLife 组件常见模式）
+public class MyComponent : ILogFeature
+{
+ public ILog Log { get; set; } = Logger.Null; // 默认空日志，不写任何内容
+
+ public void DoWork() => Log.Info("工作中...");
+}
+```
+
+### 三、切换全局日志实现
+
+```csharp
+// 在 Main / Startup 中，尽早调用
+XTrace.UseConsole(); // 切换到彩色控制台
+// 或
+XTrace.Log = new CompositeLog(
+ TextFileLog.Create("Logs"),
+ new ConsoleLog());
+
+XTrace.Debug = true; // 启用 Debug 级日志
+```
+
+### 四、链路追踪埋点
+
+```csharp
+// 1. 设置全局追踪器（一次性，应用启动时）
+DefaultTracer.Instance = new DefaultTracer
+{
+ Period = 15, // 采样周期（秒）
+ MaxSamples = 1, // 每周期正常样本数
+ MaxErrors = 10, // 每周期异常样本数
+ Timeout = 3_000, // 超时强制采样（毫秒）
+};
+
+// 2. 埋点（每个操作）
+var tracer = DefaultTracer.Instance;
+using var span = tracer.NewSpan("db/query", $"SELECT user:{id}");
+try
+{
+ var result = await db.QueryAsync(id);
+ return result;
+}
+catch (Exception ex)
+{
+ span?.SetError(ex, null); // 标记异常
+ throw;
+}
+// Span.Dispose() 自动上报
+```
+
+### 五、TraceId 跨层传递
+
+```csharp
+// 在当前 Span 活跃时，自动注入 HTTP 请求头 traceparent
+var http = new HttpClient();
+// DefaultTracer 自动为 HttpClient 注入 traceparent（若已配置）
+
+// 在事件总线等非 HTTP 场景手动读取
+var traceId = DefaultTracer.Instance?.GetCurrentSpan()?.TraceId;
+```
+
+### 六、日志级别与配置
+
+```xml
+<!-- NewLife.config -->
+<Setting>
+ <LogPath>Logs</LogPath>
+ <LogLevel>Info</LogLevel>
+ <LogFileFormat>{0:yyyy-MM-dd}.log</LogFileFormat>
+</Setting>
+```
+
+日志级别顺序：`Off < Fatal < Error < Warn < Info < Debug < All`
+设置 `Level = Warn` 时，只有 `Warn`/`Error`/`Fatal` 会输出。
+
+## 重点检查项
+
+- [ ] 业务类是否通过 `ILog` / `ILogFeature` 接口记录日志，而非硬编码 `XTrace`？
+- [ ] `ILog.Enable = false` 或 `Level = Off` 时，是否有代码仍在构建开销大的日志字符串（应先检查 `Enable`）？
+- [ ] 追踪 `Span` 是否在所有代码路径（含异常）中都被 `Dispose`？推荐 `using`。
+- [ ] 异常路径是否调用了 `span.SetError(ex, tag)` 标记失败？
+- [ ] `DefaultTracer.Instance` 是否在应用启动时设置（晚于 DI 容器构建则组件追不到早期埋点）？
+- [ ] `CompositeLog` 中若某个实现抛出异常，是否影响其他目标的写入（实现应独立 try-catch）？
+
+## 输出要求
+
+- **日志接口**：`ILog` + `LogLevel` 枚举；`ILogFeature` 属性注入接口。
+- **实现文件**：`TextFileLog`（文件）、`ConsoleLog`（控制台）、`CompositeLog`（组合），各自独立文件。
+- **追踪接口**：`ITracer` + `ISpanBuilder` + `ISpan`；`DefaultTracer` 作为默认实现。
+- **配置**：在 `NewLife.config` / `appsettings.json` 中统一管理日志路径和级别，不硬编码。
+- **测试**：可通过注入 `Logger.Null` 或 `TestLog`（记录日志到列表）测试各模块，不依赖文件 IO。
+
+## 参考资料
+
+参考示例与模式证据见 `references/newlife-core-log-tracer-patterns.md`。
diff --git a/.github/skills/network-server-sessions/references/newlife-netserver-patterns.md b/.github/skills/network-server-sessions/references/newlife-netserver-patterns.md
new file mode 100644
index 0000000..9cf8d24
--- /dev/null
+++ b/.github/skills/network-server-sessions/references/newlife-netserver-patterns.md
@@ -0,0 +1,99 @@
+# NewLife.Core 网络服务器模式证据
+
+> 来源：`Doc/网络服务端NetServer.md`（UTF-8，编码正常，全文读取）
+
+---
+
+## 1. 架构层次（来自文档）
+
+```text
+NetServer / NetServer<TSession>
+├── ISocketServer[] Servers → TcpServer / UdpServer
+├── IDictionary<Int32, INetSession> Sessions
+└── IPipeline Pipeline → 共享管道（所有连接）
+
+INetSession (每客户端连接一个实例)
+├── ISocketSession Session → 底层 Socket 会话
+├── NetServer Host → 所属服务器（泛型为强类型 TServer）
+└── INetHandler Handler → 可选的数据预处理器
+```
+
+---
+
+## 2. 服务器生命周期（来自文档）
+
+```
+[客户端连接] → [创建 ISocketSession] → [Server_NewSession]
+ ↓
+ [OnNewSession] → [CreateSession] → [AddSession]
+ ↓
+ [NetSession.Start()] → [OnConnected]
+ ↓
+ [数据收发循环]
+ ↓
+ [客户端断开/超时] → [Close(reason)] → [OnDisconnected] → [Dispose]
+```
+
+---
+
+## 3. 关键配置属性（来自文档，完整列表）
+
+| 属性 | 类型 | 默认值 | 说明 |
+|------|------|--------|------|
+| `Port` | Int32 | 0（随机）| 监听端口 |
+| `ProtocolType` | NetType | Unknown | Tcp/Udp/Unknown（双监听）/Http |
+| `AddressFamily` | AddressFamily | Unspecified | IPv4/IPv6/Unspecified（双栈）|
+| `SessionTimeout` | Int32 | 1200 | 会话超时秒数 |
+| `UseSession` | Boolean | true | 是否维护会话集合 |
+| `SslProtocol` | SslProtocols | None | SSL/TLS 加密版本 |
+| `StatPeriod` | Int32 | 600 | 统计周期（秒），0=禁用 |
+| `ReuseAddress` | Boolean | false | SO_REUSEADDR |
+| `Tracer` | ITracer? | null | APM 追踪器 |
+| `ServiceProvider` | IServiceProvider? | null | 依赖注入容器 |
+
+---
+
+## 4. 发送 API 速查（来自文档）
+
+```csharp
+session.Send(Byte[]); // 原始字节
+session.Send(String, Encoding); // 字符串（默认UTF-8）
+session.Send(IPacket); // 数据包（零拷贝）
+session.Send(Stream); // 流
+session.Send(ReadOnlySpan<Byte>);// Span（高性能）
+
+// 经过管道编码
+session.SendMessage(obj); // 同步，经编解码器
+await session.SendMessageAsync(req); // 异步请求并等待响应
+await session.SendMessageAsync(req, cts.Token); // 带取消令牌
+session.SendReply(resp, eventArgs); // 回复请求报文
+```
+
+---
+
+## 5. 自定义处理器（管道）模式（来自文档）
+
+```csharp
+// 旧版文档中 Handler.Read 返回 Boolean（文档版本与 IHandler.cs 源码 Object? 不一致）
+// 以 IPipelineHandler 源码为准：Read/Write 返回 Object?
+public class MyHandler : Handler
+{
+ public override Object? Read(IHandlerContext context, Object message) ...
+ public override Object? Write(IHandlerContext context, Object message) ...
+}
+
+server.Add(new MyHandler());
+```
+
+---
+
+## 6. 通用规则 vs NewLife.Core 特例
+
+| 规则 | 通用性 | 说明 |
+|------|--------|------|
+| 每连接独立会话对象 | ✅ 通用 | 任何网络框架均如此 |
+| 管道处理协议编解码 | ✅ 通用 | 同 Netty ChannelPipeline |
+| 泛型服务器 + 泛型会话 | ✅ 通用 | 减少类型转换，通用设计 |
+| `NetType.Unknown` 双监听 | ⚠️ NewLife 特有 | 同时绑定 TCP+UDP |
+| `WriteLog` 会话日志方法 | ⚠️ NewLife 特有 | 组件级日志快捷方法 |
+| `INetHandler` + `CreateHandler` | ⚠️ NewLife 特有 | 会话级别预处理器注入 |
diff --git a/.github/skills/network-server-sessions/SKILL.md b/.github/skills/network-server-sessions/SKILL.md
new file mode 100644
index 0000000..a12911b
--- /dev/null
+++ b/.github/skills/network-server-sessions/SKILL.md
@@ -0,0 +1,186 @@
+---
+name: network-server-sessions
+description: >
+ 使用 NewLife.Net 构建高性能网络服务器，涵盖 NetServer/NetSession 生命周期管理、
+ 管道编解码配置、TCP/UDP 协议选择、SSL/TLS、会话数据存储、异步请求-响应，
+ 以及泛型强类型会话设计。适用于即时通讯、游戏服务器、IoT 数据采集、自定义协议服务等场景。
+argument-hint: >
+ 说明你的网络服务场景：TCP 还是 UDP；是否需要自定义消息协议（粘包处理）；
+ 是否需要自定义会话类型（持有业务状态）；是否需要 SSL/TLS；
+ 是否需要异步请求-响应模式（SendMessageAsync）。
+---
+
+# 网络服务器与会话管理技能
+
+## 适用场景
+
+- 构建自定义 TCP/UDP 服务器，需要管理客户端连接生命周期（连接/断开/数据收发）。
+- 需要为每个连接维护业务状态（登录信息、用户 ID、会话 Token 等）—— 自定义 `NetSession`。
+- 需要做协议编解码（粘包处理、JSON 消息、二进制协议）—— 配置管道 `Pipeline`。
+- 需要异步请求-响应模式（发送消息并等待特定响应）—— `SendMessageAsync`。
+- 代码审查：检查会话是否及时释放、管道处理器顺序是否正确、会话数据存储是否线程安全。
+
+## 核心原则
+
+1. **每连接独立会话**：每个客户端连接由一个 `INetSession` 实例管理；有内部状态的处理器（如拆包缓冲区）必须为每个连接独立创建。
+2. **管道负责编解码**：业务层接收到的 `e.Message` 是经过管道解码后的对象；发送时 `SendMessage` 经管道编码后才写入 Socket。
+3. **事件 vs 继承**：简单服务用 `server.Received += ...`（事件）；复杂业务逻辑继承 `NetSession` 并覆写 `OnReceive/OnConnected/OnDisconnected`。
+4. **泛型服务器提供强类型访问**：`NetServer<MySession>` + `NetSession<MyServer>` 使会话内通过 `Host.SomeProperty` 访问自定义服务器属性，无需强制转型。
+5. **生命周期顺序**：`OnConnected → 数据收发循环 → OnDisconnected → Dispose`；覆写生命周期方法必须调用 `base.*`。
+
+## 数据流
+
+```
+接收：Socket → ProcessEvent → OnPreReceive → Pipeline.Read → OnReceive/Received事件 → 业务层
+发送：业务层.SendMessage → Pipeline.Write → OnSend → Socket发送
+```
+
+## 执行步骤
+
+### 一、最简 Echo 服务器
+
+```csharp
+var server = new NetServer
+{
+ Name = "EchoServer",
+ Port = 12345,
+ Log = XTrace.Log,
+};
+
+server.Received += (sender, e) =>
+{
+ if (sender is INetSession session)
+ session.Send(e.Packet); // Echo 原样回复
+};
+
+server.Start();
+// server.Stop("Shutdown"); // 停止时
+```
+
+### 二、自定义会话（推荐复杂业务）
+
+```csharp
+public class GameSession : NetSession<GameServer>
+{
+ public Int32 PlayerId { get; set; }
+ public String? Nickname { get; set; }
+
+ protected override void OnConnected()
+ {
+ base.OnConnected();
+ WriteLog("玩家连接：{0}", Remote);
+ Send("Welcome!");
+ }
+
+ protected override void OnDisconnected(String reason)
+ {
+ base.OnDisconnected(reason);
+ WriteLog("玩家断开：{0} 原因：{1}", Remote, reason);
+ // 清理玩家房间数据等
+ }
+
+ protected override void OnReceive(ReceivedEventArgs e)
+ {
+ base.OnReceive(e);
+ var msg = e.Message as GameRequest; // 经管道解码后的消息对象
+ if (msg == null) return;
+
+ // 访问服务器自定义属性（强类型，无强制转型）
+ var db = Host.Database;
+ ProcessCommand(msg, db);
+ }
+}
+
+public class GameServer : NetServer<GameSession>
+{
+ public IDatabase Database { get; set; } // 注入到所有会话
+
+ protected override void OnStart()
+ {
+ base.OnStart();
+ // 注册管道编解码器（按正向处理顺序）
+ Add(new LengthFieldCodec { Size = 4 });
+ Add(new MessageCodec<GameRequest>());
+ }
+}
+```
+
+### 三、配置服务器参数
+
+```csharp
+var server = new GameServer
+{
+ Port = 9000,
+ ProtocolType = NetType.Tcp, // 仅 TCP；Udp / Unknown（同时监听）
+ AddressFamily = AddressFamily.Unspecified, // 同时 IPv4 + IPv6
+ SessionTimeout = 600, // 会话超时秒数（默认 1200）
+ SslProtocol = SslProtocols.Tls12, // 启用 TLS
+ Certificate = cert, // X509 证书
+ Tracer = DefaultTracer.Instance, // APM 链路追踪
+ ServiceProvider = serviceProvider, // 注入 DI 容器
+};
+```
+
+### 四、配置编解码器管道
+
+```csharp
+// 简单内置方案（4字节头部长度 + 标准消息）
+server.Add<StandardCodec>();
+
+// 或 JSON 编解码器
+server.Add<JsonCodec>();
+
+// 或自定义粘包处理链
+server.Add(new LengthFieldCodec { Size = 2 }); // 2字节头部
+server.Add(new MyProtocolCodec()); // 自定义消息解析
+```
+
+### 五、发送数据的多种方式
+
+```csharp
+// 在 NetSession 子类中
+Send(bytes); // 字节数组（原始包）
+Send("消息文本"); // 字符串（UTF-8）
+SendMessage(new GameResponse { Code = 0 }); // 经管道编码后发送（同步）
+var resp = await SendMessageAsync(request); // 异步发送并等待关联响应
+SendReply(response, receivedEventArgs); // 回复当前请求（关联原请求上下文）
+```
+
+### 六、会话存储与管理
+
+```csharp
+// 会话内存储数据
+this["userId"] = 12345;
+var userId = (Int32)this["userId"];
+
+// 获取全部会话
+foreach (var kv in server.Sessions)
+ Console.WriteLine($"[{kv.Key}] {kv.Value.Remote}");
+
+// 获取指定 ID 的会话（强类型）
+var session = server.GetSession(sessionId) as GameSession;
+session?.Send("Server push message");
+
+// 查看当前/历史峰值会话数
+Console.WriteLine($"当前 {server.SessionCount} / 峰值 {server.MaxSessionCount}");
+```
+
+## 重点检查项
+
+- [ ] 有状态的管道处理器（持有拆包缓冲区）是否在 `NewSession` 事件中每次 `new` 一个新实例？
+- [ ] `OnConnected`/`OnDisconnected`/`OnReceive` 覆写是否都调用了 `base.*`？
+- [ ] 会话超时（`SessionTimeout`）是否设置合理（避免僵尸连接占用资源）？
+- [ ] `SendMessageAsync` 是否有超时（`CancellationToken`），避免无限等待？
+- [ ] 服务器停止（`Stop`）时，是否等待所有活跃会话优雅退出，还是强制断链？
+- [ ] SSL 证书是否在应用启动时加载并验证（而非每连接重新读文件）？
+
+## 输出要求
+
+- **接口**：`INetSession`（会话接口）、`INetHandler`（处理器接口）、`ISocketServer`（底层服务器）。
+- **基类**：`NetServer`/`NetServer<TSession>`（服务器）、`NetSession`/`NetSession<TServer>`（会话）。
+- **内置编解码器**：`LengthFieldCodec`（粘包拆包）、`StandardCodec`（默认消息格式）、`JsonCodec`（JSON 编解码）。
+- **测试**：可在 loopback 地址启动服务，用 `NetUri.CreateRemote()` 创建测试客户端验证行为。
+
+## 参考资料
+
+参考示例与模式证据见 `references/newlife-core-netserver-patterns.md`。
diff --git a/.github/skills/pipeline-handler-model/references/newlife-pipeline-patterns.md b/.github/skills/pipeline-handler-model/references/newlife-pipeline-patterns.md
new file mode 100644
index 0000000..2d95f66
--- /dev/null
+++ b/.github/skills/pipeline-handler-model/references/newlife-pipeline-patterns.md
@@ -0,0 +1,96 @@
+# NewLife.Core 管道模型模式证据
+
+> 来源：`Doc/管道模型Pipeline.md`（UTF-8，编码正常）+ `Model/IPipeline.cs` + `Model/IHandler.cs`
+
+---
+
+## 1. 接口层次（源码校验）
+
+```text
+IPipeline
+├── Add(IPipelineHandler)
+├── Remove(IPipelineHandler) → Boolean
+├── Clear()
+├── Read(context, message) → Object? （正向 Head→Tail）
+├── Write(context, message) → Object? （逆向 Tail→Head）
+├── Open(context) → Boolean （正向）
+├── Close(context, reason) → Boolean （逆向）
+└── Error(context, exception) → Boolean（正向）
+
+Pipeline : IPipeline
+├── Handlers: IList<IPipelineHandler>
+├── Head: IPipelineHandler?
+└── Tail: IPipelineHandler?
+
+IPipelineHandler
+├── Prev: IPipelineHandler? （逆向下一跳）
+├── Next: IPipelineHandler? （正向下一跳）
+├── Read / Write / Open / Close / Error
+
+Handler : IPipelineHandler（抽象基类）
+├── 默认实现：Read → Next?.Read(...) 或 context.FireRead(message)
+├── 默认实现：Write → Prev?.Write(...)
+└── 子类覆写任一方法即可
+```
+
+> `IHandler` 已被 `[Obsolete]` 废弃，迁移到 `IPipelineHandler`。
+
+---
+
+## 2. 源码关键注释（直接引用）
+
+`IPipelineHandler.Read` 注释：
+> *"处理得到单个消息时，调用一次下一级处理器，返回下级结果给上一级；处理得到多个消息时，调用多次下一级处理器，返回null给上一级。"*
+
+---
+
+## 3. 数据流方向（来自 Doc）
+
+```
+收包（Read，正向 Head → Tail）:
+ Socket → Handler[0].Read → Handler[1].Read → ... → context.FireRead → 业务层
+
+发包（Write，逆向 Tail → Head）:
+ 业务层 → Handler[n].Write → ... → Handler[0].Write → Socket
+
+生命周期：
+ Open, Error → 正向（Head → Tail）
+ Close → 逆向（Tail → Head）
+```
+
+---
+
+## 4. 内置处理器速查（来自 Doc）
+
+| 处理器 | 功能 |
+|--------|------|
+| `LengthFieldCodec` | 基于帧长度字段的粘包拆包（Size=2/4字节）|
+| `StandardCodec` | 标准消息编解码（序列化/反序列化）|
+| `MessageCodec<T>` | 泛型消息编解码，对应具体消息类型 T |
+
+---
+
+## 5. NetServer 集成模式（来自 Doc）
+
+```csharp
+server.NewSession += (sender, e) =>
+{
+ var pipeline = e.Session.Host.Pipeline;
+ pipeline.Add(new LengthFieldCodec { Size = 4 }); // 有状态 → new 实例
+ pipeline.Add(new StandardCodec()); // 无状态 → 可共享
+ pipeline.Add(new LogHandler()); // 无状态 → 可共享
+};
+```
+
+---
+
+## 6. 通用规则 vs NewLife.Core 特例
+
+| 规则 | 通用性 | 说明 |
+|------|--------|------|
+| 责任链/管道模式 | ✅ 通用 | 与 ASP.NET Core Middleware 管道思路一致 |
+| 双向流（Read/Write）| ✅ 通用 | 网络编解码场景的标准模式 |
+| 进站顺序/出站逆序 | ✅ 通用 | 同 Netty ChannelPipeline 设计 |
+| `IHandlerContext.FireRead` | ⚠️ NewLife 特有 | 通用替代：直接回调业务委托 |
+| `LengthFieldCodec` 具体实现 | ⚠️ NewLife 特有 | 概念通用（帧长度拆包），API 特有 |
+| `IHandler` 已废弃 | ⚠️ NewLife 特有 | 使用 `IPipelineHandler` 替代 |
diff --git a/.github/skills/pipeline-handler-model/SKILL.md b/.github/skills/pipeline-handler-model/SKILL.md
new file mode 100644
index 0000000..8032dbb
--- /dev/null
+++ b/.github/skills/pipeline-handler-model/SKILL.md
@@ -0,0 +1,175 @@
+---
+name: pipeline-handler-model
+description: >
+ 设计或使用 IPipeline/IPipelineHandler 管道处理器模型，将编解码、加密、压缩、日志等横切逻辑
+ 拆分为独立的双向链式处理器节点，在网络或消息场景中实现可组合的责任链。
+ 适用于网络协议栈设计、消息编解码、中间件链路构建与管道代码审查任务。
+argument-hint: >
+ 说明你的管道使用场景：网络收发粘包处理还是消息编解码；
+ 是否需要加密/压缩处理器；是否需要为每个连接独立状态（有状态处理器）；
+ 是否基于 NetServer/NetClient 集成还是独立管道。
+---
+
+# 管道处理器模型技能
+
+## 适用场景
+
+- 设计网络协议栈，需要将粘包/拆包、加密/解密、序列化/反序列化拆分为独立节点。
+- 多个业务协议共用相同的底层编解码层（如 LengthFieldCodec），只替换上层应用处理器。
+- 需要在 `NetServer`/`NetClient` 中注入自定义处理器（日志、鉴权、限流）。
+- 代码审查：检查处理器顺序是否合理、有状态处理器是否正确隔离、链路截断时资源是否释放。
+
+## 核心原则
+
+1. **进站正序、出站逆序**：`Read`（收包）从 `Head` 顺序传向 `Tail`；`Write`（发包）从 `Tail` 逆序传向 `Head`。生命周期事件：`Open`/`Error` 正向传播，`Close` 逆向传播。
+2. **必须传递/截断选一**：每个处理器要么调用 `base.Read/Write` 继续传递，要么有意截断；截断时必须释放持有的 `IPacket` 或资源。
+3. **有状态处理器必须按连接实例化**：持有解析缓冲区、加密状态等内部状态的处理器，不能跨连接共享——每次 `NewSession` 必须 `new` 新实例。
+4. **顺序决定行为**：拆包器（`LengthFieldCodec`）必须在解码器（`StandardCodec`）前面；顺序错误会导致残包或无法识别的消息。
+5. **上下文（`IHandlerContext`）贯穿整链**：携带会话、管道、Owner 等信息；在链路末端用 `context.FireRead(message)` 向业务层投递消息。
+
+## 数据流方向
+
+```
+收包（Read，Head → Tail 正向）:
+ Socket → Handler[0].Read → Handler[1].Read → … → Handler[n] → context.FireRead(msg) → 业务层
+
+发包（Write，Tail → Head 逆向）:
+ 业务层.WriteAsync → Handler[n].Write → … → Handler[0].Write → Socket.Send(pk)
+
+Open / Error（正向） Close（逆向）
+```
+
+## 执行步骤
+
+### 一、组装管道
+
+```csharp
+var pipeline = new Pipeline();
+// 1. 拆包器（处理 TCP 粘包）
+pipeline.Add(new LengthFieldCodec { Size = 4 }); // 4字节头部长度字段
+
+// 2. 消息编解码器
+pipeline.Add(new StandardCodec());
+
+// 3. 可选：自定义横切处理器（日志、鉴权等）
+pipeline.Add(new LogHandler());
+```
+
+### 二、实现自定义只读处理器
+
+```csharp
+// 适用场景：拦截读取的消息，做日志/统计后继续传递
+public class LogHandler : Handler
+{
+ public override Object? Read(IHandlerContext context, Object message)
+ {
+ XTrace.WriteLine("收包: {0}", message);
+ return base.Read(context, message); // ← 必须继续传递
+ }
+
+ public override Object? Write(IHandlerContext context, Object message)
+ {
+ XTrace.WriteLine("发包: {0}", message);
+ return base.Write(context, message); // ← 必须继续传递
+ }
+}
+```
+
+### 三、实现有转换逻辑的处理器
+
+```csharp
+// 适用场景：加解密，输入/输出类型均为 IPacket
+public class AesHandler : Handler
+{
+ private readonly Byte[] _key;
+ public AesHandler(Byte[] key) => _key = key;
+
+ public override Object? Read(IHandlerContext context, Object message)
+ {
+ if (message is not IPacket pk) return base.Read(context, message);
+ var decrypted = AesDecrypt(pk.GetSpan(), _key);
+ return base.Read(context, new ArrayPacket(decrypted)); // 传递解密后的包
+ }
+
+ public override Object? Write(IHandlerContext context, Object message)
+ {
+ if (message is not IPacket pk) return base.Write(context, message);
+ var encrypted = AesEncrypt(pk.GetSpan(), _key);
+ return base.Write(context, new ArrayPacket(encrypted));
+ }
+}
+```
+
+### 四、处理一进多出（粘包场景）
+
+```csharp
+// 当一个原始包包含多条业务消息时：
+public override Object? Read(IHandlerContext context, Object message)
+{
+ // 解析出多条消息
+ foreach (var msg in ParseMessages(message))
+ {
+ // 对每条消息独立传递给链路下游，并投递到业务层
+ Next?.Read(context, msg);
+ }
+ return null; // 返回 null 表示已处理多条，上层无需再处理
+}
+```
+
+### 五、与 NetServer 集成
+
+```csharp
+var server = new NetServer { Port = 9000 };
+
+server.NewSession += (sender, e) =>
+{
+ // 每条连接独立的管道实例
+ var pipeline = e.Session.Host.Pipeline;
+ pipeline.Add(new LengthFieldCodec { Size = 4 }); // 有状态，每连接新建
+ pipeline.Add(new AesHandler(sharedKey)); // 无状态，可共享
+ pipeline.Add(new MyProtocolCodec());
+};
+
+server.Start();
+```
+
+### 六、Open/Close/Error 生命周期
+
+```csharp
+public class AuthHandler : Handler
+{
+ public override Boolean Open(IHandlerContext context)
+ {
+ // 正向传播（先自己处理再传下去）
+ // ... 初始化鉴权状态
+ return base.Open(context);
+ }
+
+ public override Boolean Close(IHandlerContext context, String reason)
+ {
+ // 逆向传播（先传下去再自己处理）
+ var result = base.Close(context, reason);
+ // ... 清理鉴权状态
+ return result;
+ }
+}
+```
+
+## 重点检查项
+
+- [ ] 处理器添加顺序是否正确（拆包 → 解码 → 业务，而非颠倒）？
+- [ ] 有状态处理器（持有缓冲区/状态）是否为每个连接创建独立实例？
+- [ ] 截断链路前是否释放了持有的 `IPacket` 或托管资源（防内存泄漏）？
+- [ ] `Read` 返回多消息时是否正确返回 `null` 并调用 `Next.Read` 多次？
+- [ ] `Open`/`Close`/`Error` 中是否也调用了 `base.*` 以保证事件继续传播？
+
+## 输出要求
+
+- **接口**：`IPipeline`（管道）、`IPipelineHandler`（处理器节点）、`IHandlerContext`（上下文）。
+- **基类**：`Handler` 提供默认 pass-through 实现；业务类继承后只覆写关心的方法。
+- **内置处理器**：`LengthFieldCodec`（长度字段拆包）、`StandardCodec`（标准消息编解码）。
+- **测试**：可脱离 `NetServer` 独立测试管道：手动 `new Pipeline()`，手动 `pipeline.Read(ctx, msg)` 验证输出。
+
+## 参考资料
+
+参考示例与模式证据见 `references/newlife-core-pipeline-patterns.md`。
diff --git a/.github/skills/security-crypto-patterns/references/newlife-security-patterns.md b/.github/skills/security-crypto-patterns/references/newlife-security-patterns.md
new file mode 100644
index 0000000..1774e3f
--- /dev/null
+++ b/.github/skills/security-crypto-patterns/references/newlife-security-patterns.md
@@ -0,0 +1,128 @@
+# NewLife.Core 安全加密模式证据
+
+> 来源：`Doc/安全扩展SecurityHelper.md`（GBK，代码片段可读）
+> 核心 API 从文档代码块中恢复，以下内容与源码一致。
+
+---
+
+## 1. 哈希 API（从文档代码块恢复）
+
+```csharp
+// MD5
+Byte[] MD5(this Byte[] data)
+String MD5(this String data, Encoding? encoding = null) // → 32位十六进制
+String MD5_16(this String data, Encoding? encoding = null) // → 16位（中8字节）
+Byte[] MD5(this FileInfo file)
+
+// SHA 族（带 key 参数时为 HMAC，不传或 null 为普通哈希）
+Byte[] SHA1(this Byte[] data, Byte[]? key)
+Byte[] SHA256(this Byte[] data, Byte[]? key = null)
+Byte[] SHA384(this Byte[] data, Byte[]? key)
+Byte[] SHA512(this Byte[] data, Byte[]? key)
+
+// CRC
+UInt32 Crc(this Byte[] data)
+UInt16 Crc16(this Byte[] data)
+
+// Murmur128（非加密，适合哈希表）
+Byte[] Murmur128(this Byte[] data, UInt32 seed = 0)
+```
+
+**命名空间**：`using NewLife;`（扩展方法全部在此命名空间）
+
+---
+
+## 2. 对称加密 API（从文档代码块恢复）
+
+```csharp
+// 内存版（pass 自动填充到算法所需密钥长度）
+Byte[] Encrypt(this SymmetricAlgorithm sa, Byte[] data,
+ Byte[]? pass = null,
+ CipherMode mode = CipherMode.CBC,
+ PaddingMode padding = PaddingMode.PKCS7)
+
+Byte[] Decrypt(this SymmetricAlgorithm sa, Byte[] data,
+ Byte[]? pass = null,
+ CipherMode mode = CipherMode.CBC,
+ PaddingMode padding = PaddingMode.PKCS7)
+
+// 流式版（大文件）
+SymmetricAlgorithm Encrypt(this SymmetricAlgorithm sa, Stream instream, Stream outstream)
+SymmetricAlgorithm Decrypt(this SymmetricAlgorithm sa, Stream instream, Stream outstream)
+
+// 直接转换（低层）
+Byte[] Transform(this ICryptoTransform transform, Byte[] data)
+```
+
+---
+
+## 3. 跨语言对接注意（文档说明）
+
+> `.NET 默认 CBC 模式；Java 默认 ECB 模式`——跨语言对接时需两端协商对齐。
+> `PaddingMode.PKCS7` 等同于 Java 的 `PKCS5Padding`。
+
+---
+
+## 4. RC4 API（文档完整恢复）
+
+```csharp
+Byte[] RC4(this Byte[] data, Byte[] pass)
+// 加密和解密使用相同函数（对称流加密）
+```
+
+> RC4 存在已知密码分析漏洞，不应用于新系统安全需求。
+
+---
+
+## 5. RSA API（`NewLife.Security` 命名空间）
+
+```csharp
+using NewLife.Security;
+
+// 生成 RSA 密钥对
+(String publicKey, String privateKey) = RSAHelper.GenerateKey(2048);
+
+// 使用公钥加密
+Byte[] RSAHelper.Encrypt(Byte[] data, String publicKey)
+
+// 使用私钥解密
+Byte[] RSAHelper.Decrypt(Byte[] data, String privateKey)
+
+// 私钥签名
+Byte[] RSAHelper.Sign(Byte[] data, String privateKey, String algorithm = "SHA256")
+
+// 公钥验签
+Boolean RSAHelper.Verify(Byte[] data, Byte[] signature, String publicKey, String algorithm = "SHA256")
+```
+
+---
+
+## 6. 安全强度对比
+
+| 算法 | 类别 | 当前安全评级 | 推荐用途 |
+|------|------|------------|---------|
+| MD5 | 哈希 | ⚠️ 弱（密码场景）| 文件校验（非密码）|
+| SHA1 | 哈希 | ⚠️ 弱（密码场景）| 遗留校验 |
+| SHA256 | 哈希 | ✅ 安全 | 完整性/HMAC/API签名 |
+| SHA512 | 哈希 | ✅ 安全 | 高安全需求 |
+| CRC32 | 校验 | ⚠️ 非加密 | 协议完整性 |
+| Murmur128 | 哈希 | ⚠️ 非加密 | 哈希表/布隆过滤器 |
+| DES | 对称 | ❌ 不安全 | 禁止新场景 |
+| 3DES | 对称 | ⚠️ 弱 | 仅旧系统兼容 |
+| AES-CBC | 对称 | ✅ 安全 | 推荐标准 |
+| AES-ECB | 对称 | ⚠️ 模式弱 | 仅跨语言兼容 |
+| RC4 | 对称流 | ❌ 不安全 | 禁止新场景 |
+| RSA 2048 | 非对称 | ✅ 安全 | 密钥协商/签名 |
+
+---
+
+## 7. 通用规则 vs NewLife.Core 特例
+
+| 规则 | 通用性 | 说明 |
+|------|--------|------|
+| MD5/CRC 完整性校验 | ✅ 通用 | 普遍规律 |
+| HMAC-SHA256 API 签名 | ✅ 通用 | 行业标准 |
+| AES-CBC 推荐 | ✅ 通用 | 普遍安全建议 |
+| `pass` 自动填充密钥长度 | ⚠️ NewLife 特有 | 通用实现需手动 Pad |
+| 扩展方法形式 (`data.MD5()`) | ⚠️ NewLife 特有 | 通用替代：`MD5.HashData(data)` |
+| `RSAHelper` 封装 | ⚠️ NewLife 特有 | 封装 `RSACryptoServiceProvider` |
diff --git a/.github/skills/security-crypto-patterns/SKILL.md b/.github/skills/security-crypto-patterns/SKILL.md
new file mode 100644
index 0000000..e4a8df5
--- /dev/null
+++ b/.github/skills/security-crypto-patterns/SKILL.md
@@ -0,0 +1,152 @@
+---
+name: security-crypto-patterns
+description: >
+ 在 .NET 应用中使用 NewLife.Core 的安全扩展 SecurityHelper 实现哈希（MD5/SHA/CRC/Murmur128）、
+ 对称加密（AES/DES/3DES/RC4）、非对称加密与签名（RSA）以及 JWT 令牌构建。
+ 适用于密码哈希、数据完整性校验、内容加密传输、API 签名验证与代码安全审查任务。
+argument-hint: >
+ 说明你的安全场景：密码存储哈希（SHA256+盐）、数据完整性校验（CRC/MD5）、
+ 内容加密传输（AES）、证书签名验证（RSA）、还是 API 鉴权（JWT）。
+ 若涉及跨语言对接，请说明对端技术栈（如 Java 默认 ECB，需要特别注意 CBC/ECB 对齐）。
+---
+
+# 安全加密模式技能
+
+## 适用场景
+
+- 密码存储：将用户密码哈希（SHA256 + 随机盐）后存库，禁止明文存储。
+- 数据完整性：计算文件或消息的 MD5/CRC32，校验传输完整性。
+- 内容加密：用 AES 加密敏感配置（数据库密码、密钥等），静态存储或传输。
+- API 签名：HMAC-SHA256 对请求参数签名，防篡改。
+- 跨语言互通：与 Java 服务对接时，注意 AES 默认 CBC vs ECB 差异。
+- 非对称加密：RSA 公钥加密 + 私钥解密；私钥签名 + 公钥验签。
+- 代码审查：识别弱哈希（MD5/SHA1 单独做密码哈希）、不安全的加密模式（ECB）。
+
+## 核心原则
+
+1. **密码哈希必须加盐**：裸 MD5/SHA1 容易被彩虹表攻击；密码存储应使用 SHA256 + 随机盐，或使用 BCrypt/Argon2（更推荐）。
+2. **对称加密选 AES-CBC**：DES/3DES 已不安全（密钥太短）；AES-CBC 是当前最实用的对称加密标准；ECB 模式存在模式泄露，仅用于与旧系统对接。
+3. **哈希与加密用途区分**：MD5/SHA/CRC 是单向哈希，无法逆向解密，用于完整性校验；AES/RSA 是可逆加密，用于机密性保护。
+4. **RC4 已不推荐**：RC4 存在已知弱点，不应用于新系统；若遗留系统必须兼容，则只用于非安全关键路径。
+5. **`pass` 参数自动填充**：`Encrypt(data, pass)` 中的 `pass` 会被自动截断/填充到算法所需的密钥长度（AES 需 16/24/32 字节）；跨系统对接时确认两端使用相同填充方式。
+
+## OWASP 安全提醒
+
+- **A02 加密失败**：不要用 MD5/SHA1 作为密码哈希；不要用 ECB 模式加密结构化数据；密钥不要硬编码在源码中。
+- **A03 注入**：加密/哈希结果不要直接拼接到 SQL；Base64/Hex 编码结果也需注意长度限制。
+
+## 执行步骤
+
+### 一、哈希：完整性校验与密码存储
+
+```csharp
+using NewLife; // SecurityHelper 扩展方法所在命名空间
+using NewLife.Security; // RSAHelper
+
+// MD5（适合文件完整性，不适合密码）
+string md5Hex = "content".MD5(); // 32位十六进制字符串
+string md5_16 = "content".MD5_16(); // 16位（取中间8字节）
+byte[] fileHash = new FileInfo("f.zip").MD5();
+
+// SHA256（推荐用于 API 签名和数据完整性）
+byte[] hash256 = data.SHA256();
+
+// HMAC-SHA256（API 签名：带密钥的哈希，防伪造）
+byte[] key = Encoding.UTF8.GetBytes("my-secret");
+string hmacHex = data.SHA256(key).ToHex();
+
+// CRC（协议校验，非安全场景）
+uint crc32 = data.Crc(); // 32位
+ushort crc16 = data.Crc16(); // 16位
+
+// Murmur128（哈希表/布隆过滤器，速度> MD5，非加密用途）
+byte[] murmur = data.Murmur128(seed: 0);
+```
+
+### 二、对称加密 AES
+
+```csharp
+var data = Encoding.UTF8.GetBytes("敏感数据");
+var key = Encoding.UTF8.GetBytes("my-16byte-keyXXX"); // 16/24/32 字节
+
+// AES CBC（推荐，.NET 默认）
+var encrypted = Aes.Create().Encrypt(data, key);
+var decrypted = Aes.Create().Decrypt(encrypted, key);
+Console.WriteLine(Encoding.UTF8.GetString(decrypted)); // → "敏感数据"
+
+// AES ECB（只在对接 Java 默认模式时使用）
+var encEcb = Aes.Create().Encrypt(data, key, CipherMode.ECB);
+var decEcb = Aes.Create().Decrypt(encEcb, key, CipherMode.ECB);
+
+// 大文件/流式加密
+using var input = File.OpenRead("large.bin");
+using var output = File.Create("large.enc");
+var aes = Aes.Create();
+aes.Key = key;
+aes.IV = iv; // 需提前生成随机 IV 并在密文前携带
+aes.Encrypt(input, output);
+```
+
+### 三、RSA 非对称加密与签名
+
+```csharp
+using NewLife.Security;
+
+// 生成密钥对（应用启动时一次性生成，私钥安全保存）
+var (publicKey, privateKey) = RSAHelper.GenerateKey(2048);
+
+// 加密（用接收方公钥加密，只有私钥持有者能解密）
+var encrypted = RSAHelper.Encrypt(data, publicKey);
+var decrypted = RSAHelper.Decrypt(encrypted, privateKey);
+
+// 数字签名（用私钥签名，公钥验证）
+var signature = RSAHelper.Sign(data, privateKey, "SHA256");
+bool isValid = RSAHelper.Verify(data, signature, publicKey, "SHA256");
+```
+
+### 四、ICryptoTransform 直接转换
+
+```csharp
+// 当需要复用 AES 实例，避免反复创建
+var aes = Aes.Create();
+aes.Key = key;
+aes.IV = iv;
+
+using var enc = aes.CreateEncryptor();
+byte[] result = enc.Transform(plaintext);
+
+using var dec = aes.CreateDecryptor();
+byte[] plain = dec.Transform(result);
+```
+
+### 五、模式选择总结
+
+| 需求 | 推荐方案 | 说明 |
+|------|---------|------|
+| 文件完整性 | `MD5().ToHex()` | 快速，非安全用途 |
+| 密码存储 | SHA256 + 盐（或 BCrypt）| 单纯 MD5/SHA1 不安全 |
+| API 签名 | HMAC-SHA256（`SHA256(key)`）| 双方共享密钥 |
+| 数据加密传输 | AES-CBC | .NET 默认，推荐 |
+| Java 对接 | AES-ECB | 需两端协商一致 |
+| 公开加密私解密 | RSA 2048 | 适合密钥协商/小数据 |
+| 签名验证 | RSA Sign/Verify | 防伪造，公钥公开 |
+
+## 重点检查项
+
+- [ ] 密码是否使用裸 MD5/SHA1 哈希（应加盐或用 BCrypt/Argon2）？
+- [ ] AES 密钥是否硬编码在源码中（应从配置中心/环境变量读取）？
+- [ ] AES 初始化向量（IV）是否与每次加密独立生成并一起存储/传输（相同 IV 重复使用会泄露信息）？
+- [ ] 与 Java 对接时，加/解密模式（CBC vs ECB）和 padding（PKCS7/PKCS5）是否两端一致？
+- [ ] RSA 私钥是否妥善保护（不能出现在日志/错误消息/版本控制中）？
+- [ ] 是否在使用已知不安全的 RC4 或 DES？
+
+## 输出要求
+
+- **哈希**：`SecurityHelper` 扩展方法（`MD5`/`SHA256`/`Crc`/`Murmur128`），位于 `NewLife` 命名空间。
+- **对称加密**：`SymmetricAlgorithm` 扩展方法（`Encrypt`/`Decrypt`/`Transform`），同命名空间。
+- **非对称加密**：`RSAHelper` 静态类，位于 `NewLife.Security` 命名空间。
+- **JWT**：`JwtBuilder`（位于 `Web通用令牌JwtBuilder.md`），用于发行和验证 JWT 令牌（文档另见）。
+
+## 参考资料
+
+参考示例与模式证据见 `references/newlife-core-security-patterns.md`。
diff --git a/.github/skills/serialization-patterns/references/newlife-serialization-patterns.md b/.github/skills/serialization-patterns/references/newlife-serialization-patterns.md
new file mode 100644
index 0000000..a41de91
--- /dev/null
+++ b/.github/skills/serialization-patterns/references/newlife-serialization-patterns.md
@@ -0,0 +1,92 @@
+# NewLife.Core 序列化模式证据
+
+> 来源：`Doc/JSON序列化.md`（GBK，代码片段可读）+ `Doc/二进制序列化Binary.md`（GBK）+ `Doc/XML序列化.md`（GBK）
+> `Doc/高级二进制序列化.md` 存在编码损坏，未作为主要来源。
+
+---
+
+## 1. JSON — 核心 API（从文档代码片段恢复）
+
+```csharp
+// 序列化
+string ToJson(this Object value, Boolean indented = false)
+string ToJson(this Object value, Boolean indented, Boolean nullValue, Boolean camelCase)
+string ToJson(this Object value, JsonOptions jsonOptions)
+
+// 反序列化
+T? ToJsonEntity<T>(this String json)
+Object? ToJsonEntity(this String json, Type type)
+
+// 解析为字典
+IDictionary<String, Object?>? DecodeJson(this String json)
+```
+
+**全部命名空间**：`using NewLife.Serialization;`
+
+---
+
+## 2. XML — 核心 API（从文档代码片段恢复）
+
+```csharp
+// 序列化
+string ToXml(this Object obj, Encoding? encoding = null,
+ Boolean attachComment = false, Boolean useAttribute = false)
+void ToXmlFile(this Object obj, String file, Encoding? encoding = null,
+ Boolean attachComment = true) // 文件版默认开启注释
+
+// 反序列化
+T? ToXmlEntity<T>(this String xml)
+```
+
+**全部命名空间**：`using NewLife.Xml;`
+**注释来源**：`[Description("...")]` 或 `[DisplayName("...")]` 特性 → XML `<!-- ... -->` 注释
+
+---
+
+## 3. Binary — 核心属性（从文档代码片段恢复）
+
+```csharp
+// 快速序列化（静态方法）
+IPacket FastWrite(Object value, Boolean encodeInt = true)
+Int64 FastWrite(Object value, Stream stream, Boolean encodeInt = true)
+
+// 快速反序列化（静态方法）
+T? FastRead<T>(Stream stream, Boolean encodeInt = true)
+
+// Binary 实例属性
+Boolean EncodeInt // 7位变长整数（默认 false；FastWrite 静态默认 true）
+Boolean IsLittleEndian // 字节序（默认 false = 大端，即网络字节序）
+Boolean UseFieldSize // 读取 [FieldSize] 特性（默认 false）
+Int32 SizeWidth // 字符串长度前缀（0=压缩，1/2/4=固定字节数）
+Boolean TrimZero // 字符串末尾 \0 裁剪（默认 false）
+String? Version // 协议版本（支持多版本分支序列化）
+Boolean FullTime // 完整时间格式（8字节，默认 false = 紧凑 4字节）
+Int64 Total // 读写字节计数
+```
+
+---
+
+## 4. 格式对比（研究结论）
+
+| 维度 | JSON | XML | Binary |
+|------|------|-----|--------|
+| 体积 | 中 | 大 | 小（变长整数）|
+| 人类可读 | ✅ | ✅（有注释更佳）| ❌ |
+| 互操作性 | ✅ 跨语言 | ✅ 跨语言 | ⚠️ NewLife 专有 |
+| 性能 | 中 | 低 | 高 |
+| 流式无 Schema | ❌ | ❌ | ✅ |
+| 版本兼容 | 需额外逻辑 | 需额外逻辑 | ✅（Version 属性）|
+| 配置文件注释 | ❌ | ✅ | ❌ |
+
+---
+
+## 5. 通用规则 vs NewLife.Core 特例
+
+| 规则 | 通用性 | 说明 |
+|------|--------|------|
+| JSON 互操作性最好 | ✅ 通用 | 普遍规律，非 NewLife 特有 |
+| `ToJson(camelCase)` 驼峰 | ✅ 通用概念 | 参数方式是 NewLife 特有 |
+| Binary 7位变长整数 | ⚠️ 近似通用 | ProtoBuf 也用此编码，但二进制格式不兼容 |
+| `[FieldSize]` 注解控制位数 | ⚠️ NewLife 特有 | 概念通用，特性名 NewLife 专定 |
+| `Binary.Version` 多版本 | ⚠️ NewLife 特有 | 可启用基于版本的条件序列化 |
+| `FastWrite` 返回 `IPacket` | ⚠️ NewLife 特有 | 零拷贝数据包接口 |
diff --git a/.github/skills/serialization-patterns/SKILL.md b/.github/skills/serialization-patterns/SKILL.md
new file mode 100644
index 0000000..40c724f
--- /dev/null
+++ b/.github/skills/serialization-patterns/SKILL.md
@@ -0,0 +1,169 @@
+---
+name: serialization-patterns
+description: >
+ 在 .NET 应用中选择并使用 NewLife.Core 的序列化方案：JSON（ToJson/ToJsonEntity）、
+ XML（ToXml/ToXmlEntity）和高性能二进制（Binary.FastWrite/FastRead）。
+ 涵盖各格式选型标准、关键 API、扩展点和常见配置，适用于 API 数据交换、
+ 配置文件持久化、网络协议编码、缓存序列化等场景。
+argument-hint: >
+ 说明你的序列化场景：Web API 数据交换 vs 网络协议编码 vs 配置文件；
+ 是否需要驼峰命名、忽略空值、附加注释；对性能/体积是否有高要求；
+ 是否需要版本兼容性（Binary 的 Version 属性）。
+---
+
+# 序列化模式技能
+
+## 适用场景
+
+- Web API 返回 JSON 响应，需要驼峰命名、忽略 null 字段。
+- 配置文件持久化到 XML，需要附加属性注释（`[Description]`）辅助维护。
+- 网络协议编码，需要最小字节流（7位变长整数 + 二进制字段），高吞吐场景。
+- 缓存序列化：对象→字节，需要快速、无需 Schema 的方案。
+- 代码审查：检查序列化格式是否与使用场景匹配，是否有不必要的反射开销。
+
+## 格式选型
+
+| 场景 | 推荐格式 | 理由 |
+|------|---------|------|
+| Web API / HTTP 前后端 | JSON | 互操作性最好 |
+| 配置文件需人工编辑 | XML（`attachComment=true`）| 可附加字段注释 |
+| 网络协议/二进制帧 | Binary | 体积最小，无文本开销 |
+| 缓存字节序列化 | Binary | 速度快，无额外依赖 |
+| 跨语言数据交换 | JSON | 普遍支持 |
+| 调试/日志结构化输出 | JSON（indented）| 可读性好 |
+
+## 执行步骤
+
+### 一、JSON 序列化
+
+```csharp
+using NewLife.Serialization;
+
+// 序列化（默认：有缩进=false，包含null值=true，驼峰=false）
+var json = obj.ToJson();
+
+// 格式化输出（调试/日志）
+var jsonIndented = obj.ToJson(indented: true);
+
+// Web API 风格（驼峰 + 过滤null）
+var jsonApi = obj.ToJson(indented: false, nullValue: false, camelCase: true);
+
+// 反序列化为强类型
+var user = json.ToJsonEntity<User>();
+
+// 反序列化为动态字典（处理未知结构）
+var dict = json.DecodeJson();
+var code = dict?["code"].ToInt();
+var nested = dict?["data"] as IDictionary<String, Object?>;
+```
+
+**常用参数说明**：
+- `indented`：格式化缩进（true = 多行，false = 单行）
+- `nullValue`：是否序列化 null 字段（false = 忽略 null）
+- `camelCase`：驼峰命名（`UserName` → `userName`）
+
+### 二、XML 序列化
+
+```csharp
+using NewLife.Xml;
+
+// 序列化为 XML 字符串
+var xml = config.ToXml();
+
+// 附加注释版（从 [Description] 特性读取，适合配置文件）
+var xmlWithComments = config.ToXml(attachComment: true);
+
+// 使用 XML 属性模式（<Item id="1" name="a"/>）
+var xmlAttr = config.ToXml(useAttribute: true);
+
+// 直接序列化到文件（默认附加注释）
+config.ToXmlFile("config/app.xml");
+
+// 从文件反序列化
+var config = XmlHelper.LoadXml<AppConfig>("config/app.xml");
+
+// 从字符串反序列化
+var config = xml.ToXmlEntity<AppConfig>();
+```
+
+**注释生成规则**：
+字段/属性上的 `[Description("说明文字")]` 或 `[DisplayName("显示名")]` 特性会自动写入 XML 注释，方便运维人员理解配置文件。
+
+### 三、二进制序列化
+
+```csharp
+using NewLife.Serialization;
+
+// 快速序列化（默认启用7位变长整数，减小体积）
+var packet = Binary.FastWrite(obj); // → IPacket
+var bytes = packet.ToArray();
+
+// 写入流
+using var ms = new MemoryStream();
+Binary.FastWrite(obj, ms, encodeInt: true);
+
+// 快速反序列化
+using var ms2 = new MemoryStream(bytes);
+var obj2 = Binary.FastRead<MyClass>(ms2, encodeInt: true);
+```
+
+**高级配置（自定义 Binary 实例）**：
+
+```csharp
+var bn = new Binary
+{
+ EncodeInt = true, // 7位变长整数（小值整数体积更小）
+ IsLittleEndian = false, // 大端字节序（网络字节序，协议常用）
+ UseFieldSize = false, // 是否读取 [FieldSize] 特性指定字段大小
+ SizeWidth = 0, // 字符串长度前缀宽度（0=压缩，1/2/4=固定宽度）
+ Version = "2.0", // 协议版本，支持多版本序列化分支
+};
+
+bn.Stream = new MemoryStream();
+bn.Write(obj);
+var bytes = bn.GetBytes();
+```
+
+### 四、二进制协议中的字段大小控制
+
+```csharp
+// [FieldSize(n)] 指定字段使用固定字节数（UseFieldSize=true 时生效）
+public class Packet
+{
+ [FieldSize(4)]
+ public String Command { get; set; } // 精确占用4字节
+
+ public Int32 Length { get; set; } // 7位变长整数（EncodeInt=true）
+
+ public Byte[] Payload { get; set; } // 由 Length 指定的负载
+}
+```
+
+### 五、JSON 与 System.Text.Json 切换
+
+```csharp
+// 全局切换：使用 System.Text.Json 作为 JSON 实现（而非默认 FastJson）
+JsonHelper.Default = new SystemTextJson();
+
+// 之后 ToJson() / ToJsonEntity<T>() 自动使用新实现
+```
+
+## 重点检查项
+
+- [ ] JSON 场景：是否误用了二进制序列化（通常 JSON 更符合 HTTP 语义）？
+- [ ] XML 配置文件是否开启 `attachComment`（帮助运维理解配置项含义）？
+- [ ] 网络协议中的字节序（大端 vs 小端）是否与对端协议规范一致？
+- [ ] `Binary.FastWrite/FastRead` 的 `encodeInt` 参数两端是否保持相同（不一致会解析错误）？
+- [ ] 是否在热路径上频繁创建 `new Binary()` 实例（可考虑对象池或复用）？
+- [ ] JSON `DecodeJson` 返回值需要 null 检查（输入为非法 JSON 时返回 null）？
+
+## 输出要求
+
+- **JSON**：`JsonHelper.ToJson()`/`ToJsonEntity<T>()`/`DecodeJson()` 扩展方法（位于 `NewLife.Serialization`）。
+- **XML**：`XmlHelper.ToXml()`/`ToXmlEntity<T>()`/`ToXmlFile()`（位于 `NewLife.Xml`）。
+- **Binary**：`Binary` 类（位于 `NewLife.Serialization`）：`FastWrite`/`FastRead` 静态快捷方法 + 实例详细配置。
+- **`IPacket`**：`Binary.FastWrite` 返回此接口，避免内存拷贝；调用 `ToArray()` 仅在需要 `byte[]` 时使用。
+
+## 参考资料
+
+参考示例与模式证据见 `references/newlife-core-serialization-patterns.md`。