diff --git a/CHANGELOG.md b/CHANGELOG.md
index d1caec74c..dd7d378b7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -133,6 +133,10 @@
 * TcpConnectionProvider 单条 TCP 长连接改为按 endpoint 连接池（P0-A#3 / C239）：每 endpoint 独立成池（默认上限 4 条，构造参数可调），并发需求驱动懒建（顺序调用保持单连接复用，并发调用按需扩展），轮询分发；连接级故障仅精准移除该连接（`IConnectionProvider.Invalidate(Stream)`/`ITransportProtocolAdapter.Invalidate(Stream)` 增量接口），不再全量断连。顺带修复旧实现隐藏缺陷：全进程单连接槽位在多 endpoint 交替调用时每次断连重连
 * 连接死亡快速失败（P0-A#2#3 / C239）：接收泵退出时经新增 `IRequestResponseMatcher.TryFail` 立即以 IOException 失败该连接上全部挂起请求（等待方收到可重试的 ConnectionFailed 而非干等超时），连接级异常（IO/Socket）仅失效当前连接、其余异常保守全量失效；新增本地化键 `RemoteMessaging.Client.ConnectionClosed`
 * 新增 `RemoteMessageClientConcurrencyTests`（3 用例）：屏障式假服务端证明并发请求不再全局串行（旧实现必然全体超时）且扇出多连接；连接读后即断场景验证快速失败 + 池仅移除死亡连接后重建成功；双服务交替调用验证按 endpoint 连接复用（各 1 条连接，旧实现每次断连重连）
+
+### Documentation
+
+* 全仓禁用 `<inheritdoc />`（C301，GFX-1013）：55 个 `.cs` 文件 151 处 `/// <inheritdoc />`（含 2 处 `cref` 形态）替换为描述实现自身行为的完整双语 XML 文档注释（`<summary>` 中文、`<remarks>` 英文，`<param>` / `<returns>` / `<value>` / `<exception>` 用 `中文 / English`），覆盖 Capability 能力模块与 Options、Analyzers、Launcher 宿主适配、Templates 模板与测试替身；comment-hygiene 规范新增禁用条款。仅改 `///` 注释行，代码与行为零变更
 ## [1.13.7] - 2026-08-05
 
 ### Bug Fixes
diff --git a/Capability/GameFrameX.Capability.Online.Abstractions/Contracts/OnlineAdminApiAdapters.cs b/Capability/GameFrameX.Capability.Online.Abstractions/Contracts/OnlineAdminApiAdapters.cs
index c74d2edc0..d84e36526 100644
--- a/Capability/GameFrameX.Capability.Online.Abstractions/Contracts/OnlineAdminApiAdapters.cs
+++ b/Capability/GameFrameX.Capability.Online.Abstractions/Contracts/OnlineAdminApiAdapters.cs
@@ -130,7 +130,16 @@ internal static AdminApiErrorCode ToErrorCode(OnlineErrorCode code)
     /// </summary>
     private sealed class ScopeAdapter : IAdminApiScopeAdapter
     {
-        /// <inheritdoc />
+        /// <summary>
+        /// 从请求中读取声明的租户、应用、服务器三元素作用域；三者均可读取时组装为机制管道作用域并返回 true，否则输出 null 并返回 false。
+        /// </summary>
+        /// <remarks>
+        /// Reads the claimed tenant / app / server triple from the request; when all three are readable it builds an
+        /// <see cref="AdminApiClaimedScope"/> and returns true, otherwise outputs null and returns false.
+        /// </remarks>
+        /// <param name="request">管理 API 请求 / Admin API request</param>
+        /// <param name="claimedScope">读取成功时为声明作用域，失败时为 null / Claimed scope on success, null on failure</param>
+        /// <returns>是否成功读取声明作用域 / Whether the claimed scope was read successfully</returns>
         public bool TryReadClaimedScope(AdminApiRequest request, out AdminApiClaimedScope claimedScope)
         {
             if (request.TryReadClaimedScope(out var tenantId, out var appId, out var serverId))
@@ -143,7 +152,16 @@ public bool TryReadClaimedScope(AdminApiRequest request, out AdminApiClaimedScop
             return false;
         }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// 将声明作用域与授权作用域转换为 Online 作用域后交由 <see cref="OnlineScopeGuard"/> 比对；越权时返回映射后的机制管道错误码，通过时返回 null。
+        /// </summary>
+        /// <remarks>
+        /// Converts both scopes to Online scopes and compares them via <see cref="OnlineScopeGuard"/>; returns the mapped
+        /// pipeline error code when access is denied, or null when the claimed scope is within the authorized scope.
+        /// </remarks>
+        /// <param name="claimed">请求声明的作用域 / Scope claimed by the request</param>
+        /// <param name="authorized">调用方被授权的作用域 / Scope the caller is authorized for</param>
+        /// <returns>拒绝时的错误码；通过时为 null / Error code when denied; null when allowed</returns>
         public AdminApiErrorCode ValidateClaimed(AdminApiClaimedScope claimed, AdminApiClaimedScope authorized)
         {
             var denied = OnlineScopeGuard.Validate(ToOnlineScope(claimed), ToOnlineScope(authorized));
@@ -170,7 +188,18 @@ public IdempotencyAdapter(OnlineIdempotencyService idempotency)
             _idempotency = idempotency ?? throw new ArgumentNullException(nameof(idempotency));
         }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// 将作用域转换为 Online 作用域后委托 Online 幂等服务开始幂等登记，并把结果种类、可执行标志、错误码（无错误时为 null）与首次响应副本映射为机制管道幂等结果。
+        /// </summary>
+        /// <remarks>
+        /// Delegates to the Online idempotency service after converting the scope, then maps the outcome kind, can-execute
+        /// flag, error code (null when none) and a copy of the first response into the pipeline idempotency outcome.
+        /// </remarks>
+        /// <param name="scope">幂等记录所属作用域 / Scope owning the idempotency record</param>
+        /// <param name="idempotencyKey">幂等键 / Idempotency key</param>
+        /// <param name="canonicalRequestText">规范化请求文本，用于比对重放请求是否一致 / Canonical request text used to detect mismatched replays</param>
+        /// <param name="bindPlayer">是否将幂等记录绑定到玩家维度 / Whether the record is bound to the player dimension</param>
+        /// <returns>机制管道幂等登记结果 / Pipeline idempotency outcome</returns>
         public async Task<AdminIdempotencyOutcome> BeginAsync(AdminApiClaimedScope scope, string idempotencyKey, string canonicalRequestText, bool bindPlayer)
         {
             var outcome = await _idempotency.BeginAsync(ToOnlineScope(scope), idempotencyKey, canonicalRequestText, bindPlayer).ConfigureAwait(false);
@@ -178,13 +207,32 @@ public async Task<AdminIdempotencyOutcome> BeginAsync(AdminApiClaimedScope scope
             return new AdminIdempotencyOutcome(kind, outcome.CanExecute, outcome.ErrorCode == OnlineErrorCode.None ? null : ToErrorCode(outcome.ErrorCode), outcome.FirstResponse.ToArray());
         }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// 将作用域转换为 Online 作用域后委托 Online 幂等服务把幂等记录标记为完成并保存首次响应。
+        /// </summary>
+        /// <remarks>
+        /// Converts the scope and delegates to the Online idempotency service to mark the record completed and store the first response.
+        /// </remarks>
+        /// <param name="scope">幂等记录所属作用域 / Scope owning the idempotency record</param>
+        /// <param name="idempotencyKey">幂等键 / Idempotency key</param>
+        /// <param name="firstResponse">首次执行的响应内容 / Response produced by the first execution</param>
+        /// <param name="bindPlayer">是否将幂等记录绑定到玩家维度 / Whether the record is bound to the player dimension</param>
+        /// <returns>表示异步操作的任务 / Task representing the asynchronous operation</returns>
         public Task CompleteAsync(AdminApiClaimedScope scope, string idempotencyKey, byte[] firstResponse, bool bindPlayer)
         {
             return _idempotency.CompleteAsync(ToOnlineScope(scope), idempotencyKey, firstResponse, bindPlayer);
         }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// 将作用域转换为 Online 作用域后委托 Online 幂等服务把幂等记录标记为失败，以便后续请求重新执行。
+        /// </summary>
+        /// <remarks>
+        /// Converts the scope and delegates to the Online idempotency service to mark the record failed so later requests can execute again.
+        /// </remarks>
+        /// <param name="scope">幂等记录所属作用域 / Scope owning the idempotency record</param>
+        /// <param name="idempotencyKey">幂等键 / Idempotency key</param>
+        /// <param name="bindPlayer">是否将幂等记录绑定到玩家维度 / Whether the record is bound to the player dimension</param>
+        /// <returns>表示异步操作的任务 / Task representing the asynchronous operation</returns>
         public Task FailAsync(AdminApiClaimedScope scope, string idempotencyKey, bool bindPlayer)
         {
             return _idempotency.FailAsync(ToOnlineScope(scope), idempotencyKey, bindPlayer);
diff --git a/Capability/GameFrameX.Capability.Online.Assets/OnlineAssetsCapabilityModule.cs b/Capability/GameFrameX.Capability.Online.Assets/OnlineAssetsCapabilityModule.cs
index b272ed529..30d0b93a8 100644
--- a/Capability/GameFrameX.Capability.Online.Assets/OnlineAssetsCapabilityModule.cs
+++ b/Capability/GameFrameX.Capability.Online.Assets/OnlineAssetsCapabilityModule.cs
@@ -95,13 +95,27 @@ public sealed class OnlineAssetsCapabilityModule : ICapabilityModule, IAdminActi
     /// </summary>
     private IOnlineAuditReader _audit;
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取资产能力清单，固定返回静态实例 <see cref="ManifestInstance"/>。
+    /// </summary>
+    /// <remarks>
+    /// Gets the assets capability manifest; always returns the static <see cref="ManifestInstance"/>.
+    /// </remarks>
+    /// <value>资产能力清单 / Assets capability manifest</value>
     public CapabilityManifest Manifest
     {
         get { return ManifestInstance; }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 懒默认注册内存版资产存储与资产交易存储并解析实际生效实例，解析审计读面、幂等服务与事件发布器，构造资产查询服务与统一发放服务并注册回共享服务面。
+    /// </summary>
+    /// <remarks>
+    /// Registers in-memory asset and asset-transaction stores as lazy defaults (overridable by the host), resolves the
+    /// effective stores plus the audit reader, idempotency service and event publisher, then builds the
+    /// <see cref="OnlineAssetQueryService"/> and <see cref="OnlineGrantService"/> and registers them back into the shared services.
+    /// </remarks>
+    /// <param name="context">能力注册上下文 / Capability registration context</param>
     public void Register(CapabilityRegistrationContext context)
     {
         // 两 store：懒默认注册后经共享面取用（族 / 宿主 GameDb Override 自动胜出）。
@@ -120,19 +134,42 @@ public void Register(CapabilityRegistrationContext context)
         context.AddService(_grantService);
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 激活阶段无需处理：所有服务已在注册阶段构造完毕，本能力不持有需启动的后台任务或桥接，直接返回已完成任务。
+    /// </summary>
+    /// <remarks>
+    /// Nothing to do on activation: every service is built during registration and the capability owns no background work
+    /// or bridges to start, so a completed task is returned.
+    /// </remarks>
+    /// <param name="context">能力激活上下文 / Capability activation context</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>已完成的任务 / Completed task</returns>
     public Task ActivateAsync(CapabilityActivationContext context, CancellationToken cancellationToken)
     {
         return Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 停用阶段无需处理：激活时未启动任何资源，因此没有需要释放或撤销的内容，直接返回已完成任务。
+    /// </summary>
+    /// <remarks>
+    /// Nothing to do on deactivation: activation starts no resources, so there is nothing to release or revoke.
+    /// </remarks>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>已完成的任务 / Completed task</returns>
     public Task DeactivateAsync(CancellationToken cancellationToken)
     {
         return Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 使用注册阶段得到的发放服务、查询服务、审计读面与交易存储构造资产管理处理器，并登记发放、撤销、钱包账本、资产审计与交易详情等管理动作。
+    /// </summary>
+    /// <remarks>
+    /// Builds <see cref="OnlineAdminAssetHandlers"/> from the grant service, query service, audit reader and transaction store
+    /// resolved during registration, and registers the grant / revoke / wallet-ledger / asset-audit / transaction-detail admin actions.
+    /// </remarks>
+    /// <param name="registry">管理动作注册表 / Admin action registry</param>
     public void RegisterAdminActions(AdminActionRegistry registry)
     {
         new OnlineAdminAssetHandlers(_grantService, _assetQuery, _audit, _assetTransactionStore).Register(registry);
diff --git a/Capability/GameFrameX.Capability.Online.Competition/OnlineCompetitionCapabilityModule.cs b/Capability/GameFrameX.Capability.Online.Competition/OnlineCompetitionCapabilityModule.cs
index 0e27c8809..54587807c 100644
--- a/Capability/GameFrameX.Capability.Online.Competition/OnlineCompetitionCapabilityModule.cs
+++ b/Capability/GameFrameX.Capability.Online.Competition/OnlineCompetitionCapabilityModule.cs
@@ -96,13 +96,30 @@ public sealed class OnlineCompetitionCapabilityModule : ICapabilityModule, IAdmi
     /// </summary>
     private string _projectionBoardId;
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取竞技能力清单，固定返回静态实例 <see cref="ManifestInstance"/>。
+    /// </summary>
+    /// <remarks>
+    /// Gets the competition capability manifest; always returns the static <see cref="ManifestInstance"/>.
+    /// </remarks>
+    /// <value>竞技能力清单 / Competition capability manifest</value>
     public CapabilityManifest Manifest
     {
         get { return ManifestInstance; }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 读取竞技能力选项，懒默认注册内存版排行榜、赛季、锦标赛存储并解析生效实例，构造并注册排行榜服务与活动运营注册表；发放服务在场时再注册赛季服务与锦标赛服务；投影榜单标识非空白且对局结果存储在场时，注册 Match.Settled 排行榜投影器、订阅对局结算事件并添加投影重试的 tick 任务。
+    /// </summary>
+    /// <remarks>
+    /// Reads <see cref="OnlineCompetitionOptions"/>, registers in-memory leaderboard / season / tournament stores as lazy
+    /// defaults and resolves the effective instances, then builds and registers the leaderboard service and the live-ops
+    /// registry. Season and tournament services are registered only when the optional grant service is present. When the
+    /// projection board id is not blank and the match result store is present, it registers the Match.Settled leaderboard
+    /// projector, subscribes it to the match-settled event and adds the <c>leaderboard-projection-retry</c> tick job;
+    /// otherwise the projection is silently skipped.
+    /// </remarks>
+    /// <param name="context">能力注册上下文 / Capability registration context</param>
     public void Register(CapabilityRegistrationContext context)
     {
         var options = context.GetOptions<OnlineCompetitionOptions>();
@@ -147,7 +164,18 @@ public void Register(CapabilityRegistrationContext context)
         }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 投影榜单标识为空白时直接返回；否则以 Top 1 查询探测目标榜单，已存在则返回，返回资源不存在时按累加计分、降序排序创建该榜单。
+    /// </summary>
+    /// <remarks>
+    /// Returns immediately when the projection board id is blank. Otherwise probes the target board with a top-1 query;
+    /// if it already exists nothing else happens, and if the probe reports resource-not-found the board is created with
+    /// the sum score-update policy and descending sort order. Any other failure aborts activation so the host can roll back.
+    /// </remarks>
+    /// <param name="context">能力激活上下文，用于解析 Online 作用域 / Capability activation context used to resolve the Online scope</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>表示异步激活操作的任务 / Task representing the asynchronous activation</returns>
+    /// <exception cref="InvalidOperationException">探测返回资源不存在以外的失败码，或创建榜单失败 / The probe fails with a code other than resource-not-found, or creating the board fails</exception>
     public async Task ActivateAsync(CapabilityActivationContext context, CancellationToken cancellationToken)
     {
         if (string.IsNullOrWhiteSpace(_projectionBoardId))
@@ -182,13 +210,28 @@ public async Task ActivateAsync(CapabilityActivationContext context, Cancellatio
         }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 停用阶段无需处理：事件订阅与 tick 任务由宿主机制在注册时托管，激活仅预建榜单而不持有运行资源，直接返回已完成任务。
+    /// </summary>
+    /// <remarks>
+    /// Nothing to do on deactivation: the event subscription and tick job are declared to the host during registration,
+    /// and activation only pre-creates the board without holding runtime resources, so a completed task is returned.
+    /// </remarks>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>已完成的任务 / Completed task</returns>
     public Task DeactivateAsync(CancellationToken cancellationToken)
     {
         return Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 基于注册阶段构造的活动运营注册表登记活动运营管理动作，并基于排行榜服务登记排行榜查询管理动作。
+    /// </summary>
+    /// <remarks>
+    /// Registers the live-ops admin actions backed by the live-ops registry and the leaderboard query admin actions backed
+    /// by the leaderboard service, both built during registration.
+    /// </remarks>
+    /// <param name="registry">管理动作注册表 / Admin action registry</param>
     public void RegisterAdminActions(AdminActionRegistry registry)
     {
         OnlineAdminLiveOpsHandlers.RegisterLiveOps(registry, _liveOps);
diff --git a/Capability/GameFrameX.Capability.Online.Competition/OnlineCompetitionOptions.cs b/Capability/GameFrameX.Capability.Online.Competition/OnlineCompetitionOptions.cs
index 9911d224b..f548b97a9 100644
--- a/Capability/GameFrameX.Capability.Online.Competition/OnlineCompetitionOptions.cs
+++ b/Capability/GameFrameX.Capability.Online.Competition/OnlineCompetitionOptions.cs
@@ -49,7 +49,15 @@ public sealed class OnlineCompetitionOptions : ICapabilityOptions
     /// </summary>
     public OnlineLeaderboardProjectionOptions LeaderboardProjection { get; set; } = new OnlineLeaderboardProjectionOptions();
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 校验排行榜组件选项：单次提交最大分数、限流最大提交次数、限流窗口秒数、缓存有效期秒数与最大分页大小均须为正数；投影配置不做校验（空白榜单标识表示不投影）。
+    /// </summary>
+    /// <remarks>
+    /// Validates the leaderboard options: default maximum score per submission, rate-limit maximum submissions, rate-limit window
+    /// seconds, cache time-to-live seconds and maximum page size must all be positive. The projection settings are not validated because
+    /// a blank board id simply disables the projection. Failures are recorded on the validation collector.
+    /// </remarks>
+    /// <param name="validation">选项校验结果收集器 / Options validation collector</param>
     public void Validate(CapabilityOptionsValidation validation)
     {
         validation.RequirePositive("Leaderboard.DefaultMaxScorePerSubmission", Leaderboard.DefaultMaxScorePerSubmission);
diff --git a/Capability/GameFrameX.Capability.Online.Foundation/OnlineAuthorizedScopeProvider.cs b/Capability/GameFrameX.Capability.Online.Foundation/OnlineAuthorizedScopeProvider.cs
index 94afdebb5..321f9d66b 100644
--- a/Capability/GameFrameX.Capability.Online.Foundation/OnlineAuthorizedScopeProvider.cs
+++ b/Capability/GameFrameX.Capability.Online.Foundation/OnlineAuthorizedScopeProvider.cs
@@ -54,7 +54,13 @@ public OnlineAuthorizedScopeProvider(OnlineScope authorizedScope)
         _authorizedScope = authorizedScope ?? throw new ArgumentNullException(nameof(authorizedScope));
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取构造时注入的族基建预置授权作用域，只透出不构造。
+    /// </summary>
+    /// <remarks>
+    /// Gets the family-provisioned authorized scope injected at construction; the provider only exposes it and never builds a default.
+    /// </remarks>
+    /// <value>授权作用域，恒不为 null / Authorized scope, never null</value>
     public OnlineScope AuthorizedScope
     {
         get { return _authorizedScope; }
diff --git a/Capability/GameFrameX.Capability.Online.Foundation/OnlineFoundationCapabilityModule.cs b/Capability/GameFrameX.Capability.Online.Foundation/OnlineFoundationCapabilityModule.cs
index 89b8d3cd0..3032dd616 100644
--- a/Capability/GameFrameX.Capability.Online.Foundation/OnlineFoundationCapabilityModule.cs
+++ b/Capability/GameFrameX.Capability.Online.Foundation/OnlineFoundationCapabilityModule.cs
@@ -98,13 +98,29 @@ public sealed class OnlineFoundationCapabilityModule : ICapabilityModule, IAdmin
     /// </summary>
     private OnlinePresenceService _presence;
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取平台地基能力清单，固定返回静态实例 <see cref="ManifestInstance"/>。
+    /// </summary>
+    /// <remarks>
+    /// Gets the foundation capability manifest; always returns the static <see cref="ManifestInstance"/>.
+    /// </remarks>
+    /// <value>平台地基能力清单 / Foundation capability manifest</value>
     public CapabilityManifest Manifest
     {
         get { return ManifestInstance; }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 懒默认注册内存版身份、在线状态、会话存储并解析生效实例，构造并注册身份服务、会话生命周期管理器、会话令牌服务与在线状态服务，注册会话恢复契约实现及社交、队伍两个在线探针，并添加在线超时、令牌过期、重连窗口三个清扫 tick 任务。
+    /// </summary>
+    /// <remarks>
+    /// Registers in-memory identity, presence and session stores as lazy defaults and resolves the effective instances,
+    /// builds and registers the identity service, session manager, session token service and presence service, registers
+    /// the session reconnect contract implementation plus the social and party presence probes, and adds the
+    /// <c>presence-timeout-sweep</c>, <c>session-token-expiry-sweep</c> and <c>session-reconnect-window-sweep</c> tick jobs.
+    /// The presence sweep uses the tenant and app of the family-provisioned scope resolved here.
+    /// </remarks>
+    /// <param name="context">能力注册上下文 / Capability registration context</param>
     public void Register(CapabilityRegistrationContext context)
     {
         var eventPublisher = context.GetService<IOnlineEventPublisher>();
@@ -146,7 +162,17 @@ public void Register(CapabilityRegistrationContext context)
         context.AddTickJob("session-reconnect-window-sweep", ct => _sessions.SweepAsync(DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(), ct));
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 发布两个桥：以族基建预置的作用域构造并发布授权作用域提供器，以及发布注册阶段注册的会话恢复契约实现；随后返回已完成任务。
+    /// </summary>
+    /// <remarks>
+    /// Publishes two bridges: an <see cref="OnlineAuthorizedScopeProvider"/> wrapping the family-provisioned
+    /// <see cref="OnlineScope"/>, and the session reconnect contract implementation registered during registration.
+    /// The work is synchronous, so a completed task is returned.
+    /// </remarks>
+    /// <param name="context">能力激活上下文，提供服务解析与桥发布 / Capability activation context providing services and bridges</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>已完成的任务 / Completed task</returns>
     public Task ActivateAsync(CapabilityActivationContext context, CancellationToken cancellationToken)
     {
         // 授权作用域桥：透出族基建预置的 OnlineScope 三元组（全宿主唯一发布者；Hotfix 侧 TryAcquire 失败即显式 8002）。
@@ -157,13 +183,27 @@ public Task ActivateAsync(CapabilityActivationContext context, CancellationToken
         return Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 停用阶段无需处理：本模块不持有自有资源，清扫任务由宿主机制托管，激活时发布的桥也由机制统一管理，直接返回已完成任务。
+    /// </summary>
+    /// <remarks>
+    /// Nothing to do on deactivation: the module holds no resources of its own, the sweep tick jobs are owned by the host
+    /// and the bridges published on activation are managed by the mechanism, so a completed task is returned.
+    /// </remarks>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>已完成的任务 / Completed task</returns>
     public Task DeactivateAsync(CancellationToken cancellationToken)
     {
         return Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 基于注册阶段构造的在线状态服务登记玩家封禁与解封管理动作。
+    /// </summary>
+    /// <remarks>
+    /// Registers the suspend / resume player admin action backed by the presence service built during registration.
+    /// </remarks>
+    /// <param name="registry">管理动作注册表 / Admin action registry</param>
     public void RegisterAdminActions(AdminActionRegistry registry)
     {
         OnlineAdminFoundationHandlers.RegisterSuspendResume(registry, _presence);
diff --git a/Capability/GameFrameX.Capability.Online.Foundation/OnlineFoundationOptions.cs b/Capability/GameFrameX.Capability.Online.Foundation/OnlineFoundationOptions.cs
index ededd5dd5..a300dbf5a 100644
--- a/Capability/GameFrameX.Capability.Online.Foundation/OnlineFoundationOptions.cs
+++ b/Capability/GameFrameX.Capability.Online.Foundation/OnlineFoundationOptions.cs
@@ -54,7 +54,14 @@ public sealed class OnlineFoundationOptions : ICapabilityOptions
     /// </summary>
     public OnlinePlayerStorageOptions PlayerStorage { get; set; } = new OnlinePlayerStorageOptions();
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 校验玩家键值存储限制参数：最大负载字节数、单集合最大键数与最大分页大小均须为正数。
+    /// </summary>
+    /// <remarks>
+    /// Validates the player key-value storage limits: maximum payload bytes, maximum keys per collection and maximum page size must
+    /// all be positive. Failures are recorded on the validation collector.
+    /// </remarks>
+    /// <param name="validation">选项校验结果收集器 / Options validation collector</param>
     public void Validate(CapabilityOptionsValidation validation)
     {
         validation.RequirePositive("PlayerStorage.MaxPayloadBytes", PlayerStorage.MaxPayloadBytes);
diff --git a/Capability/GameFrameX.Capability.Online.Foundation/Presence/OnlinePartyPresenceProbe.cs b/Capability/GameFrameX.Capability.Online.Foundation/Presence/OnlinePartyPresenceProbe.cs
index 1a4579fec..32b9a72c2 100644
--- a/Capability/GameFrameX.Capability.Online.Foundation/Presence/OnlinePartyPresenceProbe.cs
+++ b/Capability/GameFrameX.Capability.Online.Foundation/Presence/OnlinePartyPresenceProbe.cs
@@ -60,7 +60,19 @@ public OnlinePartyPresenceProbe(OnlinePresenceService presence)
         _presence = presence ?? throw new ArgumentNullException(nameof(presence));
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 判定队伍成员是否在线：以租户、应用与成员玩家构造作用域（服务器位为 0）查询在线状态事实源；查询成功且状态既非离线也非封禁时返回 true，查询失败一律按离线返回 false。
+    /// </summary>
+    /// <remarks>
+    /// Builds a scope from tenant, app and player (server id 0) and reads the presence service; returns true only when the
+    /// lookup succeeds and the state is neither <see cref="OnlinePresenceState.Offline"/> nor <see cref="OnlinePresenceState.Blocked"/>.
+    /// A failed lookup is treated as offline.
+    /// </remarks>
+    /// <param name="tenantId">租户标识 / Tenant id</param>
+    /// <param name="appId">应用标识 / App id</param>
+    /// <param name="playerId">队伍成员玩家标识 / Party member player id</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>成员是否在线 / Whether the member is online</returns>
     public async Task<bool> IsOnlineAsync(long tenantId, long appId, long playerId, CancellationToken cancellationToken = default)
     {
         var scope = new OnlineScope(tenantId, appId, 0, playerId);
diff --git a/Capability/GameFrameX.Capability.Online.Foundation/Presence/OnlineSocialPresenceProbe.cs b/Capability/GameFrameX.Capability.Online.Foundation/Presence/OnlineSocialPresenceProbe.cs
index ac66eff13..dd781abfe 100644
--- a/Capability/GameFrameX.Capability.Online.Foundation/Presence/OnlineSocialPresenceProbe.cs
+++ b/Capability/GameFrameX.Capability.Online.Foundation/Presence/OnlineSocialPresenceProbe.cs
@@ -59,7 +59,19 @@ public OnlineSocialPresenceProbe(OnlinePresenceService presence)
         _presence = presence ?? throw new ArgumentNullException(nameof(presence));
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 以租户、应用与玩家构造作用域（服务器位为 0）查询在线状态事实源；查询成功且状态既非离线也非封禁时返回 true，查询失败一律按离线返回 false。
+    /// </summary>
+    /// <remarks>
+    /// Builds a scope from tenant, app and player (server id 0) and reads the presence service; returns true only when the
+    /// lookup succeeds and the state is neither <see cref="OnlinePresenceState.Offline"/> nor <see cref="OnlinePresenceState.Blocked"/>.
+    /// A failed lookup is treated as offline.
+    /// </remarks>
+    /// <param name="tenantId">租户标识 / Tenant id</param>
+    /// <param name="appId">应用标识 / App id</param>
+    /// <param name="playerId">玩家标识 / Player id</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>玩家是否在线 / Whether the player is online</returns>
     public async Task<bool> IsOnlineAsync(long tenantId, long appId, long playerId, CancellationToken cancellationToken = default)
     {
         var scope = new OnlineScope(tenantId, appId, 0, playerId);
diff --git a/Capability/GameFrameX.Capability.Online.Foundation/Session/OnlineSessionReconnectService.cs b/Capability/GameFrameX.Capability.Online.Foundation/Session/OnlineSessionReconnectService.cs
index d03775427..d7a96f4a1 100644
--- a/Capability/GameFrameX.Capability.Online.Foundation/Session/OnlineSessionReconnectService.cs
+++ b/Capability/GameFrameX.Capability.Online.Foundation/Session/OnlineSessionReconnectService.cs
@@ -76,7 +76,18 @@ public OnlineSessionReconnectService(OnlineSessionTokenService tokens, OnlineSes
         _tokenTimeToLiveSeconds = tokenTimeToLiveSeconds;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 校验作用域与连接标识后，按最新登录胜出策略签发新会话令牌（顶替旧活跃会话），再把新会话标记为已连接到指定连接；任一步失败即返回该步失败码，成功返回令牌、会话标识与过期时间。
+    /// </summary>
+    /// <remarks>
+    /// Validates the scope and connection id, issues a session token with the latest-wins multi-device policy (kicking the
+    /// previous active session) using the configured token lifetime, then marks the new session connected on the given
+    /// connection. Any failing step returns its failure code; on success the token, session id and expiry are returned.
+    /// </remarks>
+    /// <param name="scope">登录玩家所属作用域 / Scope of the logging-in player</param>
+    /// <param name="connectionId">物理连接通道标识 / Physical connection id</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>登录凭据结果，失败时携带失败码 / Login credential result carrying the failure code on failure</returns>
     public async Task<OnlineResult<OnlineSessionLoginCredential>> IssueForLoginAsync(OnlineScope scope, string connectionId, CancellationToken cancellationToken = default)
     {
         var failure = ValidateScopeAndConnection(scope, connectionId);
@@ -107,7 +118,20 @@ public async Task<OnlineResult<OnlineSessionLoginCredential>> IssueForLoginAsync
         });
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 作用域为空、连接标识为空或令牌为空时返回参数非法；否则在恢复串行门内依次校验令牌、比对会话作用域、把会话切换到新连接并原子轮换令牌，任一步失败返回对应失败码，成功返回新令牌、玩家、会话标识与过期时间。
+    /// </summary>
+    /// <remarks>
+    /// Returns parameter-invalid when the scope, connection id or token is missing. Otherwise, inside the resume gate, it
+    /// validates the token, checks the session scope, moves the session to the new connection and atomically rotates the
+    /// token so the old fingerprint is invalidated; concurrent duplicate resumes therefore fail at validation. Any failing
+    /// step returns its code; on success the new token, player id, session id and expiry are returned.
+    /// </remarks>
+    /// <param name="scope">恢复请求声明的作用域 / Scope claimed by the resume request</param>
+    /// <param name="token">待恢复会话的令牌 / Token of the session to resume</param>
+    /// <param name="connectionId">新的物理连接通道标识 / New physical connection id</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>恢复凭据结果，失败时携带失败码 / Resume credential result carrying the failure code on failure</returns>
     public async Task<OnlineResult<OnlineSessionResumeCredential>> ResumeAsync(OnlineScope scope, string token, string connectionId, CancellationToken cancellationToken = default)
     {
         if (scope == null)
@@ -170,7 +194,18 @@ public async Task<OnlineResult<OnlineSessionResumeCredential>> ResumeAsync(Onlin
         }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 作用域为空、缺少玩家位或重连窗口非正数时返回参数非法；否则把该玩家所有活跃会话标记为断线并开启重连窗口，跳过状态未就绪或会话无效的会话，遇其它失败立即返回该结果，全部处理完返回 true。
+    /// </summary>
+    /// <remarks>
+    /// Returns parameter-invalid when the scope or player id is missing or the reconnect window is not positive. Otherwise
+    /// marks every active session of the player disconnected with the given reconnect window, skipping sessions that report
+    /// state-not-ready or session-invalid; any other failure is returned immediately, and true is returned when all are handled.
+    /// </remarks>
+    /// <param name="scope">断线玩家所属作用域，须带玩家位 / Scope of the disconnected player, must carry a player id</param>
+    /// <param name="reconnectWindowSeconds">重连窗口秒数 / Reconnect window in seconds</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>处理结果，成功为 true / Operation result, true on success</returns>
     public async Task<OnlineResult<bool>> NotifyPlayerDisconnectedAsync(OnlineScope scope, long reconnectWindowSeconds, CancellationToken cancellationToken = default)
     {
         if (scope == null || scope.PlayerId <= 0)
diff --git a/Capability/GameFrameX.Capability.Online.Match/OnlineMatchCapabilityModule.cs b/Capability/GameFrameX.Capability.Online.Match/OnlineMatchCapabilityModule.cs
index 21c7f2b73..d927a3a55 100644
--- a/Capability/GameFrameX.Capability.Online.Match/OnlineMatchCapabilityModule.cs
+++ b/Capability/GameFrameX.Capability.Online.Match/OnlineMatchCapabilityModule.cs
@@ -101,13 +101,29 @@ public sealed class OnlineMatchCapabilityModule : ICapabilityModule, IAdminActio
     /// </summary>
     private IOnlineMatchDomain _matchDomain;
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取在线对局能力的静态清单（单例实例），声明能力标识、依赖与可选的撮合能力。
+    /// </summary>
+    /// <remarks>
+    /// Gets the static manifest singleton of the online match capability, declaring its identity, dependencies and the optional matchmaking capability.
+    /// </remarks>
+    /// <value>能力清单单例 / Capability manifest singleton</value>
     public CapabilityManifest Manifest
     {
         get { return ManifestInstance; }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 注册对局能力：注册内存对局 Actor 存储与结果存储，构造对局运行时并注册石头剪刀布玩法与对局 tick 任务；
+    /// 装配结算服务与结算管线（资产发放服务缺席时只结算不派发）并注册结算 tick 任务；构造并注册对局桥服务；
+    /// 仅当票据服务、撮合协调器与票据存储均在场时才装配匹配域服务并订阅撮合分配事件，缺席时不装配也不报错。
+    /// </summary>
+    /// <remarks>
+    /// Registers in-memory match actor and result stores, builds the match runtime with the rock-paper-scissors game and a match tick job,
+    /// wires the settlement service and pipeline (settle-only when the grant service is absent) with a settlement tick job, registers the game bridge service,
+    /// and only when ticket service, matchmaker coordinator and ticket store are all present builds the match domain service and subscribes to assignment-created events; otherwise it silently skips.
+    /// </remarks>
+    /// <param name="context">能力注册上下文 / Capability registration context</param>
     public void Register(CapabilityRegistrationContext context)
     {
         var options = context.GetOptions<OnlineMatchOptions>();
@@ -147,7 +163,15 @@ public void Register(CapabilityRegistrationContext context)
         }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 激活对局能力：始终发布对局桥；仅当匹配域服务已在注册期装配时才发布匹配域桥。
+    /// </summary>
+    /// <remarks>
+    /// Always publishes the match game bridge; publishes the match domain bridge only when the domain service was assembled during registration.
+    /// </remarks>
+    /// <param name="context">能力激活上下文 / Capability activation context</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>已完成的任务，激活过程为同步操作 / A completed task, as activation is synchronous</returns>
     public Task ActivateAsync(CapabilityActivationContext context, CancellationToken cancellationToken)
     {
         // 桥发布迁 Activate 期（C294）：对局桥恒发布；匹配域桥仅在场发布（缺席态由桥显式失败承载）。
@@ -160,13 +184,26 @@ public Task ActivateAsync(CapabilityActivationContext context, CancellationToken
         return Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 停用对局能力：本实现不做任何处理，因为桥与 tick 任务由宿主统一管理，模块自身不持有需要释放的资源。
+    /// </summary>
+    /// <remarks>
+    /// Performs no work, because bridges and tick jobs are owned by the host and the module holds no resources to release.
+    /// </remarks>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>已完成的任务 / A completed task</returns>
     public Task DeactivateAsync(CancellationToken cancellationToken)
     {
         return Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 注册对局相关管理动作：异常结束对局，以及基于结算管线的对局结算查询。
+    /// </summary>
+    /// <remarks>
+    /// Registers match admin actions: abnormal match termination and match settlement query backed by the settlement pipeline.
+    /// </remarks>
+    /// <param name="registry">管理动作注册表 / Admin action registry</param>
     public void RegisterAdminActions(AdminActionRegistry registry)
     {
         OnlineAdminMatchHandlers.RegisterEndAbnormalMatch(registry);
diff --git a/Capability/GameFrameX.Capability.Online.Match/OnlineMatchDomainService.cs b/Capability/GameFrameX.Capability.Online.Match/OnlineMatchDomainService.cs
index 08e48486b..dd8b85022 100644
--- a/Capability/GameFrameX.Capability.Online.Match/OnlineMatchDomainService.cs
+++ b/Capability/GameFrameX.Capability.Online.Match/OnlineMatchDomainService.cs
@@ -104,7 +104,20 @@ public OnlineMatchDomainService(IOnlineMatchTicketStore store, OnlineMatchTicket
         _game = game ?? throw new ArgumentNullException(nameof(game));
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 为玩家创建单人匹配票据：依次校验作用域、模式（仅允许 1 或 2）与评分（须大于 0），以默认区域和评分上下窗口建票；
+    /// 建票成功后同步执行一轮撮合，再按玩家最新票据解析已撮合的数值对局标识（未撮合时为 0）。
+    /// </summary>
+    /// <remarks>
+    /// Validates scope, mode (only 1 or 2) and rating (must be positive), enqueues a solo ticket in the default region with a rating window,
+    /// runs one immediate matchmaking pass, then resolves the numeric match id from the player's latest ticket (0 when not yet matched).
+    /// Invalid mode or rating fails with <c>ParameterInvalid</c>; ticket service failures are propagated.
+    /// </remarks>
+    /// <param name="scope">玩家作用域 / Player scope</param>
+    /// <param name="mode">匹配模式，仅允许 1 或 2 / Match mode, only 1 or 2 allowed</param>
+    /// <param name="rating">玩家评分，须大于 0 / Player rating, must be positive</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>入队结果，成功时携带已撮合的对局标识（未撮合为 0） / Enqueue result carrying the matched id (0 if not matched) on success</returns>
     public async Task<OnlineResult<OnlineMatchDomainEnqueue>> EnqueueAsync(OnlineScope scope, int mode, int rating, CancellationToken cancellationToken = default)
     {
         var enqueueScopeFailure = ValidateScope(scope);
@@ -145,7 +158,17 @@ public async Task<OnlineResult<OnlineMatchDomainEnqueue>> EnqueueAsync(OnlineSco
         return OnlineResult<OnlineMatchDomainEnqueue>.Ok(new OnlineMatchDomainEnqueue { MatchId = matchId });
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 取消玩家当前排队中的票据：校验作用域后查找活跃票据；无活跃票据时返回成功且 <c>Cancelled = false</c>，不视为失败；
+    /// 票据服务取消失败时透传失败码，成功时仅当票据状态变为已取消才标记已取消。
+    /// </summary>
+    /// <remarks>
+    /// Validates scope and looks up the active ticket; no active ticket yields a successful receipt with <c>Cancelled = false</c>.
+    /// Ticket service failures are propagated; <c>Cancelled</c> is true only when the ticket ends in the cancelled state.
+    /// </remarks>
+    /// <param name="scope">玩家作用域 / Player scope</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>取消回执结果 / Cancel receipt result</returns>
     public async Task<OnlineResult<OnlineMatchDomainCancel>> CancelAsync(OnlineScope scope, CancellationToken cancellationToken = default)
     {
         var failureCode = ValidateScope(scope);
@@ -173,7 +196,17 @@ public async Task<OnlineResult<OnlineMatchDomainCancel>> CancelAsync(OnlineScope
         });
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 查询玩家匹配状态：校验作用域后读取最新票据；无票据返回未排队未撮合，票据排队中返回排队中，
+    /// 其余状态解析数值对局标识，非 0 即视为已撮合。
+    /// </summary>
+    /// <remarks>
+    /// Validates scope and reads the latest ticket: none means neither queuing nor matched, a queued ticket means queuing,
+    /// otherwise the numeric match id is resolved and a non-zero id means matched.
+    /// </remarks>
+    /// <param name="scope">玩家作用域 / Player scope</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>匹配状态结果 / Match status result</returns>
     public async Task<OnlineResult<OnlineMatchDomainStatus>> GetStatusAsync(OnlineScope scope, CancellationToken cancellationToken = default)
     {
         var failureCode = ValidateScope(scope);
@@ -202,7 +235,20 @@ public async Task<OnlineResult<OnlineMatchDomainStatus>> GetStatusAsync(OnlineSc
         });
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 玩家进入已撮合对局：校验入场请求与分配登记后，按服务器标识派生运行时对局标识并获取或创建对局 Actor；
+    /// 对局已结束返回 <c>StateEnded</c>，成员表与分配成员不一致返回 <c>ParameterInvalid</c>；
+    /// 对局处于创建、等待或就绪状态时标记成员就绪并尝试开局；最终返回是否已进入运行状态及成员列表。
+    /// </summary>
+    /// <remarks>
+    /// Validates the entry and assignment registration, derives the runtime match id from the server id and gets or creates the match actor.
+    /// Ended matches fail with <c>StateEnded</c>, member mismatches fail with <c>ParameterInvalid</c>; in created, waiting or ready states members are marked ready and the match is started when possible.
+    /// Returns whether the match is running and the member list.
+    /// </remarks>
+    /// <param name="scope">玩家作用域 / Player scope</param>
+    /// <param name="matchId">数值对局标识 / Numeric match id</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>入场结果 / Entry result</returns>
     public async Task<OnlineResult<OnlineMatchDomainEntry>> EnterAsync(OnlineScope scope, long matchId, CancellationToken cancellationToken = default)
     {
         var invalidEntry = ValidateEntry(scope, matchId, out var registration);
@@ -249,7 +295,19 @@ public async Task<OnlineResult<OnlineMatchDomainEntry>> EnterAsync(OnlineScope s
         });
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 将撮合分配标识解析为数值对局标识、模式与成员列表：分配标识为空返回 <c>ParameterInvalid</c>；
+    /// 优先使用内存登记，未登记时从票据存储读取分配并登记，分配不存在返回 <c>ResourceNotFound</c>。
+    /// </summary>
+    /// <remarks>
+    /// Resolves an assignment id to numeric match id, mode and players. Empty id fails with <c>ParameterInvalid</c>;
+    /// the in-memory registration is preferred, otherwise the assignment is loaded from the ticket store and registered; a missing assignment fails with <c>ResourceNotFound</c>.
+    /// </remarks>
+    /// <param name="tenantId">租户标识 / Tenant id</param>
+    /// <param name="appId">应用标识 / Application id</param>
+    /// <param name="assignmentId">撮合分配标识 / Matchmaking assignment id</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>分配解析结果 / Assignment resolution result</returns>
     public async Task<OnlineResult<OnlineMatchDomainAssignment>> ResolveAssignmentAsync(long tenantId, long appId, string assignmentId, CancellationToken cancellationToken = default)
     {
         if (string.IsNullOrEmpty(assignmentId))
@@ -277,7 +335,19 @@ public async Task<OnlineResult<OnlineMatchDomainAssignment>> ResolveAssignmentAs
         });
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 标记玩家在对局中掉线：校验作用域后按票据、分配登记与运行时成员表定位玩家所属对局；
+    /// 找不到对局、对局已结束或成员缺失、已离开、被踢出时返回成功且 <c>Marked = false</c>；
+    /// 否则经重连服务标记掉线（重连令牌留存在成员表、不下发），失败透传失败码。
+    /// </summary>
+    /// <remarks>
+    /// Validates scope and locates the player's match via ticket, assignment registration and runtime member table.
+    /// Returns success with <c>Marked = false</c> when no match is found, the match has ended, or the member is missing, left or kicked;
+    /// otherwise marks the disconnect via the reconnect service (the reconnect token stays server-side) and propagates its failure.
+    /// </remarks>
+    /// <param name="scope">玩家作用域 / Player scope</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>掉线标记结果 / Disconnect marking result</returns>
     public async Task<OnlineResult<OnlineMatchDomainDisconnect>> NotifyPlayerDisconnectedAsync(OnlineScope scope, CancellationToken cancellationToken = default)
     {
         var scopeFailure = ValidateScope(scope);
@@ -315,7 +385,21 @@ public async Task<OnlineResult<OnlineMatchDomainDisconnect>> NotifyPlayerDisconn
         return OnlineResult<OnlineMatchDomainDisconnect>.Ok(new OnlineMatchDomainDisconnect { Marked = true, MatchId = numericMatchId });
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 为重新登录的玩家恢复对局：校验作用域并定位所属对局，无对局时返回成功且 <c>Resumed = false</c>；
+    /// 成员缺失、已离开或被踢出返回 <c>ScopeDenied</c>，对局已结束返回 <c>StateEnded</c>；
+    /// 掉线成员用服务端留存的重连令牌经重连服务恢复，在线成员做幂等确认直接以当前快照作为恢复结果；
+    /// 返回对局状态、服务器序号、成员状态、玩法状态以及是否有增量可用。
+    /// </summary>
+    /// <remarks>
+    /// Validates scope and locates the match; none yields success with <c>Resumed = false</c>. Missing, left or kicked members fail with <c>ScopeDenied</c>, ended matches with <c>StateEnded</c>.
+    /// Disconnected members reconnect through the reconnect service using the server-held token; online members get an idempotent confirmation based on the current snapshot.
+    /// Returns match state, server sequence, member states, game state and whether a delta is available.
+    /// </remarks>
+    /// <param name="scope">玩家作用域 / Player scope</param>
+    /// <param name="lastAcknowledgedSequence">客户端最后确认的序号 / Last sequence acknowledged by the client</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>对局恢复结果 / Match resume result</returns>
     public async Task<OnlineResult<OnlineMatchDomainResume>> TryResumeForPlayerAsync(OnlineScope scope, long lastAcknowledgedSequence, CancellationToken cancellationToken = default)
     {
         var scopeFailure = ValidateScope(scope);
diff --git a/Capability/GameFrameX.Capability.Online.Match/OnlineMatchGameBridgeService.cs b/Capability/GameFrameX.Capability.Online.Match/OnlineMatchGameBridgeService.cs
index 7373c43e1..84cafa677 100644
--- a/Capability/GameFrameX.Capability.Online.Match/OnlineMatchGameBridgeService.cs
+++ b/Capability/GameFrameX.Capability.Online.Match/OnlineMatchGameBridgeService.cs
@@ -73,7 +73,21 @@ public OnlineMatchGameBridgeService(OnlineMatchRuntime runtime, OnlineRockPaperS
         _game = game ?? throw new ArgumentNullException(nameof(game));
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 为房间的某一局开局：校验作用域、房间标识、局号与成员数（须等于玩法最小人数）以及请求者成员身份；
+    /// 按服务器标识、房间与局号派生对局标识并获取或创建对局 Actor；对局已结束返回 <c>StateEnded</c>，成员表不一致返回 <c>ParameterInvalid</c>；
+    /// 处于创建、等待或就绪状态时准备成员并开局，最后返回对局视图。
+    /// </summary>
+    /// <remarks>
+    /// Validates scope, room id, round, player count (must equal the game minimum) and requester membership, derives the match id and gets or creates the actor.
+    /// Ended matches fail with <c>StateEnded</c>, member mismatches with <c>ParameterInvalid</c>; created, waiting or ready matches get members prepared and started. Returns the game view.
+    /// </remarks>
+    /// <param name="scope">请求作用域 / Request scope</param>
+    /// <param name="roomId">房间标识 / Room id</param>
+    /// <param name="round">局号 / Round number</param>
+    /// <param name="playerIds">房间成员表 / Room player ids</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>对局视图结果 / Game view result</returns>
     public async Task<OnlineResult<OnlineMatchBridgeGameView>> StartRoomGameAsync(OnlineScope scope, long roomId, int round, IReadOnlyList<long> playerIds, CancellationToken cancellationToken = default)
 {
         var invalidRequest = ValidateStartRequest(scope, roomId, round, playerIds);
@@ -114,7 +128,20 @@ public async Task<OnlineResult<OnlineMatchBridgeGameView>> StartRoomGameAsync(On
         return OnlineResult<OnlineMatchBridgeGameView>.Ok(BuildView(roomId, actor));
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 提交石头剪刀布出拳：作用域缺失或无玩家标识返回 <c>ScopeMissing</c>，出拳越界返回 <c>ParameterInvalid</c>，对局不存在返回 <c>ResourceNotFound</c>；
+    /// 客户端序号由服务端按快照中该成员的最后序号加一派生；提交失败透传失败码，未返回确认返回 <c>InternalError</c>，被拒绝时映射拒绝原因，成功返回对局视图。
+    /// </summary>
+    /// <remarks>
+    /// Submits a rock-paper-scissors gesture. Missing scope fails with <c>ScopeMissing</c>, out-of-range gestures with <c>ParameterInvalid</c>, unknown matches with <c>ResourceNotFound</c>.
+    /// The client sequence is derived server-side from the member's last sequence plus one; submission failures are propagated, a missing ack yields <c>InternalError</c>, rejections are mapped, success returns the game view.
+    /// </remarks>
+    /// <param name="scope">请求作用域 / Request scope</param>
+    /// <param name="roomId">房间标识 / Room id</param>
+    /// <param name="round">局号 / Round number</param>
+    /// <param name="gesture">出拳值 / Gesture value</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>对局视图结果 / Game view result</returns>
     public async Task<OnlineResult<OnlineMatchBridgeGameView>> SubmitGestureAsync(OnlineScope scope, long roomId, int round, int gesture, CancellationToken cancellationToken = default)
     {
         if (scope == null || scope.PlayerId <= 0)
@@ -174,7 +201,19 @@ public async Task<OnlineResult<OnlineMatchBridgeGameView>> SubmitGestureAsync(On
         return OnlineResult<OnlineMatchBridgeGameView>.Ok(BuildView(roomId, actor));
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 查询房间某一局的对局信息：作用域缺失返回 <c>ScopeMissing</c>，对局不存在返回 <c>ResourceNotFound</c>，
+    /// 查询者不是未离开、未被踢出的成员时返回 <c>ScopeDenied</c>，否则返回对局视图。
+    /// </summary>
+    /// <remarks>
+    /// Queries the game of a room round: missing scope fails with <c>ScopeMissing</c>, unknown matches with <c>ResourceNotFound</c>,
+    /// non-members (or left/kicked members) with <c>ScopeDenied</c>; otherwise returns the game view.
+    /// </remarks>
+    /// <param name="scope">请求作用域 / Request scope</param>
+    /// <param name="roomId">房间标识 / Room id</param>
+    /// <param name="round">局号 / Round number</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>对局视图结果 / Game view result</returns>
     public async Task<OnlineResult<OnlineMatchBridgeGameView>> GetGameInfoAsync(OnlineScope scope, long roomId, int round, CancellationToken cancellationToken = default)
     {
         if (scope == null || scope.PlayerId <= 0)
diff --git a/Capability/GameFrameX.Capability.Online.Match/OnlineMatchOptions.cs b/Capability/GameFrameX.Capability.Online.Match/OnlineMatchOptions.cs
index b52d403a5..18471f36f 100644
--- a/Capability/GameFrameX.Capability.Online.Match/OnlineMatchOptions.cs
+++ b/Capability/GameFrameX.Capability.Online.Match/OnlineMatchOptions.cs
@@ -52,7 +52,13 @@ public sealed class OnlineMatchOptions : ICapabilityOptions
     /// </summary>
     public OnlineMatchRuntimeOptions Runtime { get; set; } = new OnlineMatchRuntimeOptions();
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 校验合并后的运行时阈值：等待超时、进行中超时、重连窗口、结束留存时长与单局服务端事件上限均须为正数。
+    /// </summary>
+    /// <remarks>
+    /// Requires waiting timeout, running timeout, reconnect window, ended retention and maximum server events per match to be positive.
+    /// </remarks>
+    /// <param name="validation">选项校验收集器 / Options validation collector</param>
     public void Validate(CapabilityOptionsValidation validation)
     {
         validation.RequirePositive("Runtime.WaitingTimeoutSeconds", Runtime.WaitingTimeoutSeconds);
diff --git a/Capability/GameFrameX.Capability.Online.Matchmaking/OnlineMatchmakingCapabilityModule.cs b/Capability/GameFrameX.Capability.Online.Matchmaking/OnlineMatchmakingCapabilityModule.cs
index 5c9f1d385..4a488139e 100644
--- a/Capability/GameFrameX.Capability.Online.Matchmaking/OnlineMatchmakingCapabilityModule.cs
+++ b/Capability/GameFrameX.Capability.Online.Matchmaking/OnlineMatchmakingCapabilityModule.cs
@@ -98,13 +98,29 @@ public sealed class OnlineMatchmakingCapabilityModule : ICapabilityModule, IAdmi
     /// </summary>
     private OnlinePartyService _partyService;
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取在线撮合能力的静态清单（单例实例）。
+    /// </summary>
+    /// <remarks>
+    /// Gets the static manifest singleton of the online matchmaking capability.
+    /// </remarks>
+    /// <value>能力清单单例 / Capability manifest singleton</value>
     public CapabilityManifest Manifest
     {
         get { return ManifestInstance; }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 注册撮合能力：注册内存票据存储、对局列表存储与队伍存储，构造并注册票据服务、撮合协调器与队列观察器；
+    /// 构造队伍服务（在线探针暂留空，激活期回填）并以命名 <c>party</c> 注册为频道成员资格探针；
+    /// 注册撮合执行与过期票据清理两个 tick 任务。
+    /// </summary>
+    /// <remarks>
+    /// Registers in-memory ticket, listing and party stores, builds and registers the ticket service, matchmaker coordinator and queue observer,
+    /// builds the party service (presence probe attached later at activation) and registers it as the named <c>party</c> channel membership probe,
+    /// and adds the matchmaker run and expired ticket sweep tick jobs.
+    /// </remarks>
+    /// <param name="context">能力注册上下文 / Capability registration context</param>
     public void Register(CapabilityRegistrationContext context)
     {
         var options = context.GetOptions<OnlineMatchmakingOptions>();
@@ -142,7 +158,15 @@ public void Register(CapabilityRegistrationContext context)
         });
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 激活撮合能力：枚举队伍在线探针扩展点，存在实现时将第一个回填到队伍服务；无实现则保持探针为空。
+    /// </summary>
+    /// <remarks>
+    /// Enumerates party presence probe implementations and attaches the first one to the party service; leaves it unset when none exist.
+    /// </remarks>
+    /// <param name="context">能力激活上下文 / Capability activation context</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>已完成的任务，激活过程为同步操作 / A completed task, as activation is synchronous</returns>
     public Task ActivateAsync(CapabilityActivationContext context, CancellationToken cancellationToken)
     {
         // 在线事实探针扩展点注入：实现常由非直接依赖能力（online-foundation）提供，只能 Activate 期枚举。
@@ -155,13 +179,26 @@ public Task ActivateAsync(CapabilityActivationContext context, CancellationToken
         return Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 停用撮合能力：本实现不做任何处理，因为存储为内存实现、tick 任务由宿主管理，模块不持有需要释放的资源。
+    /// </summary>
+    /// <remarks>
+    /// Performs no work, because stores are in-memory, tick jobs are host-managed and the module holds no resources to release.
+    /// </remarks>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>已完成的任务 / A completed task</returns>
     public Task DeactivateAsync(CancellationToken cancellationToken)
     {
         return Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 注册撮合管理动作：基于队列观察器、票据存储与票据服务构造撮合管理处理器并注册到管理动作注册表。
+    /// </summary>
+    /// <remarks>
+    /// Registers matchmaking admin handlers built from the queue observer, ticket store and ticket service.
+    /// </remarks>
+    /// <param name="registry">管理动作注册表 / Admin action registry</param>
     public void RegisterAdminActions(AdminActionRegistry registry)
     {
         new OnlineAdminMatchmakingHandlers(_matchQueueObserver, _matchTicketStore, _matchTickets).Register(registry);
diff --git a/Capability/GameFrameX.Capability.Online.Matchmaking/OnlineMatchmakingOptions.cs b/Capability/GameFrameX.Capability.Online.Matchmaking/OnlineMatchmakingOptions.cs
index 96d3e2df9..12c6b681d 100644
--- a/Capability/GameFrameX.Capability.Online.Matchmaking/OnlineMatchmakingOptions.cs
+++ b/Capability/GameFrameX.Capability.Online.Matchmaking/OnlineMatchmakingOptions.cs
@@ -51,7 +51,13 @@ public sealed class OnlineMatchmakingOptions : ICapabilityOptions
     /// </summary>
     public OnlineMatchmakerOptions Matchmaker { get; set; } = new OnlineMatchmakerOptions();
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 校验合并后的撮合参数：票据存活时长、等待扩窗阈值、扩窗间隔、每次扩窗评分增量、频控最大操作数与频控窗口均须为正数。
+    /// </summary>
+    /// <remarks>
+    /// Requires ticket time to live, wait expansion threshold, expansion interval, skill expansion per interval, rate limit maximum operations and rate limit window to be positive.
+    /// </remarks>
+    /// <param name="validation">选项校验收集器 / Options validation collector</param>
     public void Validate(CapabilityOptionsValidation validation)
     {
         validation.RequirePositive("Matchmaker.TicketTimeToLiveSeconds", Matchmaker.TicketTimeToLiveSeconds);
diff --git a/Capability/GameFrameX.Capability.Online.Operations/HotfixRollback/OnlineHotfixArtifactFetcher.cs b/Capability/GameFrameX.Capability.Online.Operations/HotfixRollback/OnlineHotfixArtifactFetcher.cs
index 09334644c..a5ad98d21 100644
--- a/Capability/GameFrameX.Capability.Online.Operations/HotfixRollback/OnlineHotfixArtifactFetcher.cs
+++ b/Capability/GameFrameX.Capability.Online.Operations/HotfixRollback/OnlineHotfixArtifactFetcher.cs
@@ -85,7 +85,26 @@ public OnlineHotfixArtifactFetcher(OnlineHotfixArtifactFetchOptions options, Htt
         _httpClient = new HttpClient(handler ?? new SocketsHttpHandler(), true);
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 确保指定版本的热更制品已落盘到当前工作目录下的版本目录：先校验版本号、SHA-256 与下载地址格式；
+    /// 目标制品已存在时校验和一致即直接返回，不一致即拒绝（版本目录一经落盘不可变更）；
+    /// 未落盘且未提供下载地址时抛出文件不存在异常；否则下载到同卷的临时目录（按配置重试并限制大小），校验通过后原子移动到版本目录，
+    /// 并发移动竞态时按已落盘内容判定幂等，最终总是清理临时目录。
+    /// </summary>
+    /// <remarks>
+    /// Validates the version, SHA-256 and source URL format. An existing artifact with a matching hash returns immediately; a mismatching one is rejected because version directories are immutable.
+    /// Without an on-disk artifact and without a source URL a file-not-found exception is thrown; otherwise the artifact is downloaded into a same-volume staging directory with retries and a size limit,
+    /// verified, and atomically moved into the version directory. Concurrent move races are resolved by re-checking the existing file, and the staging directory is always cleaned up.
+    /// </remarks>
+    /// <param name="version">热更版本号，禁止包含路径分隔符、卷分隔符或双点段 / Hotfix version, must not contain path or volume separators or double-dot segments</param>
+    /// <param name="sourceUrl">制品下载地址，为空时仅校验已落盘制品 / Artifact source URL; when empty only the on-disk artifact is verified</param>
+    /// <param name="artifactSha256">制品 SHA-256 校验和（64 位十六进制） / Artifact SHA-256 checksum (64 hexadecimal characters)</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>表示异步操作的任务 / A task representing the asynchronous operation</returns>
+    /// <exception cref="ArgumentException">版本号、校验和或下载地址格式非法 / The version, checksum or source URL is malformed</exception>
+    /// <exception cref="InvalidOperationException">已落盘制品或下载制品校验不一致，或制品超过大小上限 / The on-disk or downloaded artifact hash mismatches, or the artifact exceeds the size limit</exception>
+    /// <exception cref="FileNotFoundException">仅提供校验和但目标制品未落盘 / Only a checksum is provided but the artifact is not on disk</exception>
+    /// <exception cref="HttpRequestException">下载返回不可重试的失败状态，或可重试失败在重试耗尽后仍未成功 / The download returns a non-retryable failure status, or a retryable failure persists after retries are exhausted</exception>
     public async Task EnsureArtifactAsync(string version, string sourceUrl, string artifactSha256, CancellationToken cancellationToken = default)
     {
         ValidateVersion(version);
diff --git a/Capability/GameFrameX.Capability.Online.Operations/OnlineOperationsCapabilityModule.cs b/Capability/GameFrameX.Capability.Online.Operations/OnlineOperationsCapabilityModule.cs
index e45c93217..d3ef57995 100644
--- a/Capability/GameFrameX.Capability.Online.Operations/OnlineOperationsCapabilityModule.cs
+++ b/Capability/GameFrameX.Capability.Online.Operations/OnlineOperationsCapabilityModule.cs
@@ -110,13 +110,29 @@ public sealed class OnlineOperationsCapabilityModule : ICapabilityModule, IAdmin
     /// </summary>
     private OnlineHotfixRollbackService _hotfixRollback;
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取运营聚合能力的静态清单（单例实例）。
+    /// </summary>
+    /// <remarks>
+    /// Gets the static manifest singleton of the online operations capability.
+    /// </remarks>
+    /// <value>能力清单单例 / Capability manifest singleton</value>
     public CapabilityManifest Manifest
     {
         get { return ManifestInstance; }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 注册运营能力：解析统一审计服务；注册内存热更版本存储，要求宿主提供版本切换执行器，按选项注册制品获取器并装配热更回滚服务；
+    /// 仅在撮合票据、队伍与对局 Actor 存储均在场时装配总览服务，仅在资产查询、社交关系存储与对局 Actor 存储均在场时装配玩家时间线服务；
+    /// 最后对全部已知在线事件主题注册事件与审计桥。
+    /// </summary>
+    /// <remarks>
+    /// Resolves the unified audit service, registers the in-memory hotfix version store, requires the host rollback executor, registers the artifact fetcher from options and builds the hotfix rollback service.
+    /// The overview service is built only when ticket, party and match actor stores exist; the player timeline only when asset query, social graph and match actor stores exist.
+    /// Finally subscribes the event and audit bridge to all known online event topics.
+    /// </remarks>
+    /// <param name="context">能力注册上下文 / Capability registration context</param>
     public void Register(CapabilityRegistrationContext context)
     {
         var options = context.GetOptions<OnlineOperationsOptions>();
@@ -158,19 +174,40 @@ public void Register(CapabilityRegistrationContext context)
         RegisterEventBridge(context);
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 激活运营能力：本实现不做任何处理，因为所有服务与事件订阅已在注册期完成装配，且本能力不发布桥。
+    /// </summary>
+    /// <remarks>
+    /// Performs no work, because all services and event subscriptions are wired during registration and this capability publishes no bridges.
+    /// </remarks>
+    /// <param name="context">能力激活上下文 / Capability activation context</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>已完成的任务 / A completed task</returns>
     public Task ActivateAsync(CapabilityActivationContext context, CancellationToken cancellationToken)
     {
         return Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 停用运营能力：本实现不做任何处理，因为事件订阅由机制事件总线管理，模块不持有需要释放的资源。
+    /// </summary>
+    /// <remarks>
+    /// Performs no work, because event subscriptions are owned by the mechanism event bus and the module holds no resources to release.
+    /// </remarks>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>已完成的任务 / A completed task</returns>
     public Task DeactivateAsync(CancellationToken cancellationToken)
     {
         return Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 注册运营管理动作：控制台动作（总览、时间线与审计，未装配的服务以空值传入）与热更回滚动作。
+    /// </summary>
+    /// <remarks>
+    /// Registers console actions (overview, timeline and audit; unassembled services are passed as null) and hotfix rollback actions.
+    /// </remarks>
+    /// <param name="registry">管理动作注册表 / Admin action registry</param>
     public void RegisterAdminActions(AdminActionRegistry registry)
     {
         OnlineAdminConsoleHandlers.RegisterConsoleActions(registry, _overview, _timeline, _audit);
diff --git a/Capability/GameFrameX.Capability.Online.Operations/OnlineOperationsOptions.cs b/Capability/GameFrameX.Capability.Online.Operations/OnlineOperationsOptions.cs
index 1b6efa593..481ab5935 100644
--- a/Capability/GameFrameX.Capability.Online.Operations/OnlineOperationsOptions.cs
+++ b/Capability/GameFrameX.Capability.Online.Operations/OnlineOperationsOptions.cs
@@ -43,7 +43,13 @@ public sealed class OnlineOperationsOptions : ICapabilityOptions
     /// </summary>
     public OnlineHotfixArtifactFetchOptions ArtifactFetch { get; set; } = new OnlineHotfixArtifactFetchOptions();
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 校验制品获取参数：单次尝试超时须为正时长，最大重试次数不得为负，制品大小上限须为正数。
+    /// </summary>
+    /// <remarks>
+    /// Requires a positive attempt timeout, a non-negative maximum retry count and a positive maximum artifact size.
+    /// </remarks>
+    /// <param name="validation">选项校验收集器 / Options validation collector</param>
     public void Validate(CapabilityOptionsValidation validation)
     {
         if (ArtifactFetch.AttemptTimeout <= TimeSpan.Zero)
diff --git a/Capability/GameFrameX.Capability.Online.Social/OnlineSocialCapabilityModule.cs b/Capability/GameFrameX.Capability.Online.Social/OnlineSocialCapabilityModule.cs
index fe6311fe3..762f20a7c 100644
--- a/Capability/GameFrameX.Capability.Online.Social/OnlineSocialCapabilityModule.cs
+++ b/Capability/GameFrameX.Capability.Online.Social/OnlineSocialCapabilityModule.cs
@@ -145,13 +145,31 @@ public sealed class OnlineSocialCapabilityModule : ICapabilityModule, IAdminActi
     /// </summary>
     private OnlineScope _scope;
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取在线社交能力的静态清单（单例实例）。
+    /// </summary>
+    /// <remarks>
+    /// Gets the static manifest singleton of the online social capability.
+    /// </remarks>
+    /// <value>能力清单单例 / Capability manifest singleton</value>
     public CapabilityManifest Manifest
     {
         get { return ManifestInstance; }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 注册社交能力：解析作用域、会话存储与会话令牌服务；为聊天、好友、群组、通知、举报与社交关系注册内存默认存储；
+    /// 要求宿主提供玩家目录并装配好友服务，装配社交决策、处罚、通知、聊天审计投影服务；
+    /// 以默认放行策略声明聊天审核钩子并构造聊天服务（成员资格探针激活期注入）；群组服务以命名 <c>group</c> 注册为频道成员资格探针；
+    /// 将社交决策服务注册为社交门控，并注册通知与好友请求的过期清理 tick 任务。
+    /// </summary>
+    /// <remarks>
+    /// Resolves scope, session store and session token service, registers in-memory default stores for chat, friends, groups, notifications, reports and the social graph,
+    /// requires the host player directory and builds friend, decision, punishment, notification and chat audit services, declares the chat moderation hook with an allow-all default
+    /// and builds the chat service (membership probes injected at activation), registers the group service as the named <c>group</c> membership probe,
+    /// exposes the decision service as the social gate and adds notification and friend request expiry sweep tick jobs.
+    /// </remarks>
+    /// <param name="context">能力注册上下文 / Capability registration context</param>
     public void Register(CapabilityRegistrationContext context)
     {
         _options = context.GetOptions<OnlineSocialOptions>();
@@ -215,7 +233,17 @@ public void Register(CapabilityRegistrationContext context)
         });
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 激活社交能力：发布好友域桥，向聊天服务注入全部已注册的频道成员资格探针；
+    /// 仅当好友选项开启旧数据迁移时，执行一次旧好友数据迁移。
+    /// </summary>
+    /// <remarks>
+    /// Publishes the friend domain bridge, attaches all registered channel membership probes to the chat service,
+    /// and runs the legacy friend data migration only when it is enabled in the friend options.
+    /// </remarks>
+    /// <param name="context">能力激活上下文 / Capability activation context</param>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>表示异步操作的任务 / A task representing the asynchronous operation</returns>
     public async Task ActivateAsync(CapabilityActivationContext context, CancellationToken cancellationToken)
     {
         // 好友域桥契约面发布（发布者身份 = 本能力；撤销由宿主停止期自动完成）。
@@ -231,13 +259,26 @@ public async Task ActivateAsync(CapabilityActivationContext context, Cancellatio
         }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 停用社交能力：本实现不做任何处理，因为好友域桥由宿主停止期自动撤销，模块不持有需要释放的资源。
+    /// </summary>
+    /// <remarks>
+    /// Performs no work, because the friend domain bridge is revoked automatically by the host on stop and the module holds no resources to release.
+    /// </remarks>
+    /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+    /// <returns>已完成的任务 / A completed task</returns>
     public Task DeactivateAsync(CancellationToken cancellationToken)
     {
         return Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 注册社交管理动作：构造社交管理处理器并注册常规社交动作与对局隔离动作。
+    /// </summary>
+    /// <remarks>
+    /// Builds the social admin handlers and registers the regular social actions and the match isolation actions.
+    /// </remarks>
+    /// <param name="registry">管理动作注册表 / Admin action registry</param>
     public void RegisterAdminActions(AdminActionRegistry registry)
     {
         var handlers = new OnlineAdminSocialHandlers(_sessionStore, _tokens, _punishments, _socialDecisions, _notifications, _reportStore, _chatAudit);
diff --git a/GameFrameX.Architecture.Analyzers/Analyzers/CodeStyle/FileNameMatchTypeAnalyzer.cs b/GameFrameX.Architecture.Analyzers/Analyzers/CodeStyle/FileNameMatchTypeAnalyzer.cs
index 7ddf7e963..5a6b5e4ab 100644
--- a/GameFrameX.Architecture.Analyzers/Analyzers/CodeStyle/FileNameMatchTypeAnalyzer.cs
+++ b/GameFrameX.Architecture.Analyzers/Analyzers/CodeStyle/FileNameMatchTypeAnalyzer.cs
@@ -58,13 +58,26 @@ public sealed class FileNameMatchTypeAnalyzer : DiagnosticAnalyzer
         DiagnosticSeverity.Error,
         true);
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 返回本分析器唯一支持的诊断 GFX0020（文件名必须与唯一顶层类型名一致，严重级别 Error）。
+    /// </summary>
+    /// <remarks>
+    /// Returns the single diagnostic supported by this analyzer: GFX0020 (file name must match the sole top-level type name, severity Error).
+    /// </remarks>
+    /// <value>仅包含 GFX0020 描述符的不可变数组 / Immutable array containing only the GFX0020 descriptor</value>
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
     {
         get { return ImmutableArray.Create(SDescriptor); }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 注册分析动作：不分析生成代码，启用并发执行，并为每棵语法树注册文件名与顶层类型名比对动作。
+    /// </summary>
+    /// <remarks>
+    /// Registers analysis: generated code is skipped, concurrent execution is enabled, and a syntax tree action compares
+    /// the file name with its top-level type name. The tree action skips non-.cs files and files whose top-level type count is not exactly one.
+    /// </remarks>
+    /// <param name="context">分析上下文，用于配置并注册语法树动作 / Analysis context used to configure and register the syntax tree action</param>
     public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
diff --git a/GameFrameX.Architecture.Analyzers/Analyzers/CodeStyle/OneTypePerFileAnalyzer.cs b/GameFrameX.Architecture.Analyzers/Analyzers/CodeStyle/OneTypePerFileAnalyzer.cs
index 880db6813..f48d94c46 100644
--- a/GameFrameX.Architecture.Analyzers/Analyzers/CodeStyle/OneTypePerFileAnalyzer.cs
+++ b/GameFrameX.Architecture.Analyzers/Analyzers/CodeStyle/OneTypePerFileAnalyzer.cs
@@ -58,13 +58,26 @@ public sealed class OneTypePerFileAnalyzer : DiagnosticAnalyzer
         DiagnosticSeverity.Error,
         true);
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 返回本分析器唯一支持的诊断 GFX0019（每个文件只允许一个顶层类型，严重级别 Error）。
+    /// </summary>
+    /// <remarks>
+    /// Returns the single diagnostic supported by this analyzer: GFX0019 (one top-level type per file, severity Error).
+    /// </remarks>
+    /// <value>仅包含 GFX0019 描述符的不可变数组 / Immutable array containing only the GFX0019 descriptor</value>
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
     {
         get { return ImmutableArray.Create(SDescriptor); }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 注册分析动作：不分析生成代码，启用并发执行，并为每棵语法树注册顶层类型计数动作。
+    /// </summary>
+    /// <remarks>
+    /// Registers analysis: generated code is skipped, concurrent execution is enabled, and a syntax tree action collects top-level types.
+    /// Declarations sharing the same name and arity (partial parts) count as one type; only the first extra type is reported.
+    /// </remarks>
+    /// <param name="context">分析上下文，用于配置并注册语法树动作 / Analysis context used to configure and register the syntax tree action</param>
     public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
diff --git a/GameFrameX.Architecture.Analyzers/Analyzers/CodeStyle/UsingDeclarationBanAnalyzer.cs b/GameFrameX.Architecture.Analyzers/Analyzers/CodeStyle/UsingDeclarationBanAnalyzer.cs
index 68e696b36..384d13121 100644
--- a/GameFrameX.Architecture.Analyzers/Analyzers/CodeStyle/UsingDeclarationBanAnalyzer.cs
+++ b/GameFrameX.Architecture.Analyzers/Analyzers/CodeStyle/UsingDeclarationBanAnalyzer.cs
@@ -59,13 +59,26 @@ public sealed class UsingDeclarationBanAnalyzer : DiagnosticAnalyzer
         DiagnosticSeverity.Error,
         true);
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 返回本分析器唯一支持的诊断 GFX0021（禁止 using 声明，须改用带大括号的 using 语句块，严重级别 Error）。
+    /// </summary>
+    /// <remarks>
+    /// Returns the single diagnostic supported by this analyzer: GFX0021 (using declarations are forbidden; use a braced using statement block, severity Error).
+    /// </remarks>
+    /// <value>仅包含 GFX0021 描述符的不可变数组 / Immutable array containing only the GFX0021 descriptor</value>
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
     {
         get { return ImmutableArray.Create(SDescriptor); }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 注册分析动作：不分析生成代码，启用并发执行，并针对局部声明语句节点注册检查动作，带 using 关键字即上报。
+    /// </summary>
+    /// <remarks>
+    /// Registers analysis: generated code is skipped, concurrent execution is enabled, and a syntax node action on
+    /// local declaration statements reports any declaration carrying the using keyword at that keyword's location.
+    /// </remarks>
+    /// <param name="context">分析上下文，用于配置并注册语法节点动作 / Analysis context used to configure and register the syntax node action</param>
     public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
diff --git a/GameFrameX.Hotfix/Logic/Server/Chat/GameChatModerationHook.cs b/GameFrameX.Hotfix/Logic/Server/Chat/GameChatModerationHook.cs
index 3c1b8fabd..ac1ba023a 100644
--- a/GameFrameX.Hotfix/Logic/Server/Chat/GameChatModerationHook.cs
+++ b/GameFrameX.Hotfix/Logic/Server/Chat/GameChatModerationHook.cs
@@ -58,7 +58,17 @@ public sealed class GameChatModerationHook : IOnlineChatModerationHook
     /// </remarks>
     public const int MaximumContentLength = 500;
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 本地同步裁决聊天消息：内容为空白或超过 <see cref="MaximumContentLength"/> 即拒绝并附原因，其余一律放行；不访问外部服务。
+    /// </summary>
+    /// <remarks>
+    /// Synchronously judges a chat message locally: blank content or content longer than <see cref="MaximumContentLength"/>
+    /// is rejected with a reason; everything else is allowed. No external IO is performed and the cancellation token is not consulted.
+    /// </remarks>
+    /// <param name="message">待审核的聊天消息 / Chat message to moderate</param>
+    /// <param name="cancellationToken">取消令牌（本实现为同步裁决，未使用） / Cancellation token (unused by this synchronous verdict)</param>
+    /// <returns>已完成的裁决任务：拒绝（空白或超长）或放行 / Completed verdict task: reject (blank or too long) or allow</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="message"/> 为 null / <paramref name="message"/> is null</exception>
     public Task<OnlineChatModerationVerdict> CheckAsync(OnlineChatMessage message, CancellationToken cancellationToken = default)
     {
         if (message == null)
diff --git a/GameFrameX.Launcher/Online/HostPlayerDirectory.cs b/GameFrameX.Launcher/Online/HostPlayerDirectory.cs
index b78beb8b7..9bd3b1f0f 100644
--- a/GameFrameX.Launcher/Online/HostPlayerDirectory.cs
+++ b/GameFrameX.Launcher/Online/HostPlayerDirectory.cs
@@ -59,7 +59,20 @@ namespace GameFrameX.Launcher.Online;
 /// </remarks>
 public sealed class HostPlayerDirectory : IOnlinePlayerDirectory
 {
-    /// <inheritdoc />
+    /// <summary>
+    /// 按名称关键字搜索本服玩家：关键字去首尾空白后在 <c>GameDb</c> 中按 <c>PlayerState.Name</c> 包含匹配，按玩家 ID 升序取前 limit 条；关键字为空白或 limit 不大于 0 时直接返回空列表。
+    /// </summary>
+    /// <remarks>
+    /// Searches local players by name keyword: the trimmed keyword is matched with a contains query on <c>PlayerState.Name</c> through <c>GameDb</c>,
+    /// results are ordered by player ID and truncated to limit. A blank keyword or non-positive limit returns an empty list without querying.
+    /// Tenant and app IDs are not used for filtering because the host database holds a single server's players; ServerId comes from the current global setting (0 when absent).
+    /// </remarks>
+    /// <param name="tenantId">租户 ID（本宿主实现不参与过滤） / Tenant ID (not used for filtering by this host implementation)</param>
+    /// <param name="appId">应用 ID（本宿主实现不参与过滤） / App ID (not used for filtering by this host implementation)</param>
+    /// <param name="keyword">名称关键字 / Name keyword</param>
+    /// <param name="limit">最大返回条数 / Maximum number of entries to return</param>
+    /// <param name="cancellationToken">取消令牌，透传给数据库查询 / Cancellation token passed to the database query</param>
+    /// <returns>匹配的玩家目录条目列表，可能为空 / Matching player directory entries, possibly empty</returns>
     public async Task<IReadOnlyList<OnlinePlayerDirectoryEntry>> SearchByNameAsync(long tenantId, long appId, string keyword, int limit, CancellationToken cancellationToken = default)
     {
         if (string.IsNullOrWhiteSpace(keyword) || limit <= 0)
@@ -80,7 +93,18 @@ public async Task<IReadOnlyList<OnlinePlayerDirectoryEntry>> SearchByNameAsync(l
             .ToList();
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 按玩家 ID 批量查询本服玩家：经 <c>GameDb.FindByIdsAsync</c> 读取 <c>PlayerState</c>，过滤掉名称为 null 的记录并按玩家 ID 升序返回；ID 列表为 null 或为空时直接返回空列表。
+    /// </summary>
+    /// <remarks>
+    /// Looks up local players by ID through <c>GameDb.FindByIdsAsync</c>, drops states whose name is null and orders by player ID.
+    /// A null or empty ID list returns an empty list without querying. Tenant and app IDs are not used for filtering; ServerId comes from the current global setting (0 when absent).
+    /// </remarks>
+    /// <param name="tenantId">租户 ID（本宿主实现不参与过滤） / Tenant ID (not used for filtering by this host implementation)</param>
+    /// <param name="appId">应用 ID（本宿主实现不参与过滤） / App ID (not used for filtering by this host implementation)</param>
+    /// <param name="playerIds">待查询的玩家 ID 列表 / Player IDs to look up</param>
+    /// <param name="cancellationToken">取消令牌，透传给数据库查询 / Cancellation token passed to the database query</param>
+    /// <returns>存在且有名称的玩家目录条目列表，可能为空 / Directory entries for existing named players, possibly empty</returns>
     public async Task<IReadOnlyList<OnlinePlayerDirectoryEntry>> FindAsync(long tenantId, long appId, IReadOnlyList<long> playerIds, CancellationToken cancellationToken = default)
     {
         if (playerIds == null || playerIds.Count == 0)
diff --git a/GameFrameX.Launcher/Online/HotfixManagerRollbackExecutor.cs b/GameFrameX.Launcher/Online/HotfixManagerRollbackExecutor.cs
index cc298b34f..6ef0c3571 100644
--- a/GameFrameX.Launcher/Online/HotfixManagerRollbackExecutor.cs
+++ b/GameFrameX.Launcher/Online/HotfixManagerRollbackExecutor.cs
@@ -77,7 +77,20 @@ public HotfixManagerRollbackExecutor(AppSetting setting = null)
         _setting = setting;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 将热更程序集切换到已落盘的目标版本：校验版本号并解析制品路径，在互斥门内经 <see cref="HotfixManager"/> 装载并确认实际装载路径；装载失败时尝试恢复切换前版本后抛出。
+    /// </summary>
+    /// <remarks>
+    /// Switches the hotfix assembly to an already-downloaded target version. The version is validated and resolved to an artifact path,
+    /// then under a single-flight gate the artifact must exist on disk (no download at switch time), is loaded via <see cref="HotfixManager"/>,
+    /// and the loaded assembly location is verified. On failure the previously loaded version is reloaded before throwing.
+    /// </remarks>
+    /// <param name="targetVersion">目标热更版本号 / Target hotfix version</param>
+    /// <param name="cancellationToken">取消令牌，仅用于等待切换互斥门 / Cancellation token, used only while waiting for the switch gate</param>
+    /// <returns>表示异步切换操作的任务 / Task representing the asynchronous switch</returns>
+    /// <exception cref="ArgumentException">版本号为空白或含非法路径段 / Version is blank or contains illegal path segments</exception>
+    /// <exception cref="FileNotFoundException">目标版本制品未落盘 / Target version artifact is not on disk</exception>
+    /// <exception cref="InvalidOperationException">目标版本装载失败（已恢复或恢复也失败） / Target load failed (original restored, or restoration also failed)</exception>
     public async Task RollbackAsync(string targetVersion, CancellationToken cancellationToken = default)
     {
         if (string.IsNullOrWhiteSpace(targetVersion))
diff --git a/GameFrameX.Launcher/Online/LogHelperCapabilityAssemblyLog.cs b/GameFrameX.Launcher/Online/LogHelperCapabilityAssemblyLog.cs
index 4f16db9a5..af3ac99b4 100644
--- a/GameFrameX.Launcher/Online/LogHelperCapabilityAssemblyLog.cs
+++ b/GameFrameX.Launcher/Online/LogHelperCapabilityAssemblyLog.cs
@@ -44,13 +44,25 @@ namespace GameFrameX.Launcher.Online;
 /// </remarks>
 public sealed class LogHelperCapabilityAssemblyLog : ICapabilityAssemblyLog
 {
-    /// <inheritdoc />
+    /// <summary>
+    /// 将能力装配的信息日志直接转发到宿主 <c>LogHelper.Info</c>。
+    /// </summary>
+    /// <remarks>
+    /// Forwards capability assembly informational messages directly to the host <c>LogHelper.Info</c>.
+    /// </remarks>
+    /// <param name="message">日志消息 / Log message</param>
     public void Info(string message)
     {
         LogHelper.Info(message);
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 将能力装配的错误日志直接转发到宿主 <c>LogHelper.Error</c>。
+    /// </summary>
+    /// <remarks>
+    /// Forwards capability assembly error messages directly to the host <c>LogHelper.Error</c>.
+    /// </remarks>
+    /// <param name="message">日志消息 / Log message</param>
     public void Error(string message)
     {
         LogHelper.Error(message);
diff --git a/GameFrameX.Templates/templates/gfx-online/{{Name}}/EmptyPlayerDirectory.cs b/GameFrameX.Templates/templates/gfx-online/{{Name}}/EmptyPlayerDirectory.cs
index e92e12f41..a7f5f3a57 100644
--- a/GameFrameX.Templates/templates/gfx-online/{{Name}}/EmptyPlayerDirectory.cs
+++ b/GameFrameX.Templates/templates/gfx-online/{{Name}}/EmptyPlayerDirectory.cs
@@ -46,13 +46,36 @@ namespace {{Name}};
 /// </summary>
 public sealed class EmptyPlayerDirectory : IOnlinePlayerDirectory
 {
-    /// <inheritdoc />
+    /// <summary>
+    /// 模板缺省实现：最小 Online 宿主没有玩家存储，任何关键字搜索都返回空列表；接入真实玩家数据时须替换本类。
+    /// </summary>
+    /// <remarks>
+    /// Template default: the minimal Online host has no player store, so every name search returns an empty list.
+    /// Replace this class when wiring real player data.
+    /// </remarks>
+    /// <param name="tenantId">租户 ID（未使用） / Tenant ID (unused)</param>
+    /// <param name="appId">应用 ID（未使用） / App ID (unused)</param>
+    /// <param name="keyword">名称关键字（未使用） / Name keyword (unused)</param>
+    /// <param name="limit">最大返回条数（未使用） / Maximum number of entries (unused)</param>
+    /// <param name="cancellationToken">取消令牌（未使用） / Cancellation token (unused)</param>
+    /// <returns>已完成的空列表任务 / Completed task with an empty list</returns>
     public Task<IReadOnlyList<OnlinePlayerDirectoryEntry>> SearchByNameAsync(long tenantId, long appId, string keyword, int limit, CancellationToken cancellationToken = default)
     {
         return Task.FromResult<IReadOnlyList<OnlinePlayerDirectoryEntry>>(new List<OnlinePlayerDirectoryEntry>());
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 模板缺省实现：最小 Online 宿主没有玩家存储，任何 ID 查询都返回空列表；接入真实玩家数据时须替换本类。
+    /// </summary>
+    /// <remarks>
+    /// Template default: the minimal Online host has no player store, so every ID lookup returns an empty list.
+    /// Replace this class when wiring real player data.
+    /// </remarks>
+    /// <param name="tenantId">租户 ID（未使用） / Tenant ID (unused)</param>
+    /// <param name="appId">应用 ID（未使用） / App ID (unused)</param>
+    /// <param name="playerIds">玩家 ID 列表（未使用） / Player IDs (unused)</param>
+    /// <param name="cancellationToken">取消令牌（未使用） / Cancellation token (unused)</param>
+    /// <returns>已完成的空列表任务 / Completed task with an empty list</returns>
     public Task<IReadOnlyList<OnlinePlayerDirectoryEntry>> FindAsync(long tenantId, long appId, IReadOnlyList<long> playerIds, CancellationToken cancellationToken = default)
     {
         return Task.FromResult<IReadOnlyList<OnlinePlayerDirectoryEntry>>(new List<OnlinePlayerDirectoryEntry>());
diff --git a/GameFrameX.Templates/templates/gfx-online/{{Name}}/UnsupportedHotfixRollbackExecutor.cs b/GameFrameX.Templates/templates/gfx-online/{{Name}}/UnsupportedHotfixRollbackExecutor.cs
index 3eddc5043..728840ed7 100644
--- a/GameFrameX.Templates/templates/gfx-online/{{Name}}/UnsupportedHotfixRollbackExecutor.cs
+++ b/GameFrameX.Templates/templates/gfx-online/{{Name}}/UnsupportedHotfixRollbackExecutor.cs
@@ -46,7 +46,16 @@ namespace {{Name}};
 /// </summary>
 public sealed class UnsupportedHotfixRollbackExecutor : IOnlineHotfixRollbackExecutor
 {
-    /// <inheritdoc />
+    /// <summary>
+    /// 模板缺省实现：最小 Online 宿主不运行热更运行时，回滚请求一律抛出不支持异常；需要热更回滚时须替换为真实执行器。
+    /// </summary>
+    /// <remarks>
+    /// Template default: the minimal Online host runs no hotfix runtime, so every rollback request throws a not-supported exception.
+    /// Replace with a real executor when hotfix rollback is needed.
+    /// </remarks>
+    /// <param name="targetVersion">目标版本号，仅写入异常消息 / Target version, only included in the exception message</param>
+    /// <param name="cancellationToken">取消令牌（未使用） / Cancellation token (unused)</param>
+    /// <returns>不会正常返回，始终抛出 <c>NotSupportedException</c> / Never returns normally; always throws <c>NotSupportedException</c></returns>
     public Task RollbackAsync(string targetVersion, CancellationToken cancellationToken = default)
     {
         throw new NotSupportedException("This minimal Online host does not run a hotfix runtime; rollback to version '" + targetVersion + "' is not supported.");
diff --git a/Tests/GameFrameX.Hotfix.Tests/ComponentAgentEventDispatchTests.cs b/Tests/GameFrameX.Hotfix.Tests/ComponentAgentEventDispatchTests.cs
index 571f40964..cf90f2a7e 100644
--- a/Tests/GameFrameX.Hotfix.Tests/ComponentAgentEventDispatchTests.cs
+++ b/Tests/GameFrameX.Hotfix.Tests/ComponentAgentEventDispatchTests.cs
@@ -152,7 +152,15 @@ internal static void Reset()
             ReceivedAgent = null;
         }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// 记录收到的玩家组件代理到静态字段，供测试断言派发命中本监听器且代理归属正确；不做其他处理。
+        /// </summary>
+        /// <remarks>
+        /// Records the received player component agent into a static field so tests can assert dispatch reached this listener with the correct agent; performs no other work.
+        /// </remarks>
+        /// <param name="agent">收到事件的玩家组件代理 / Player component agent that received the event</param>
+        /// <param name="gameEventArgs">探针事件参数（本实现不读取） / Probe event arguments (not read by this implementation)</param>
+        /// <returns>记录完成后立即返回的已完成任务 / Completed task returned immediately after recording</returns>
         protected override Task HandleEventAsync(PlayerComponentAgent agent, GameEventArgs gameEventArgs)
         {
             ReceivedAgent = agent;
@@ -175,7 +183,15 @@ internal static void Reset()
             Triggered = false;
         }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// 将触发标记置为 true，供测试断言其他 actor 类型的监听器未被派发；不做其他处理。
+        /// </summary>
+        /// <remarks>
+        /// Sets the triggered flag to true so tests can assert that listeners of other actor types are not dispatched; performs no other work.
+        /// </remarks>
+        /// <param name="agent">收到事件的服务器组件代理（本实现不读取） / Server component agent that received the event (not read by this implementation)</param>
+        /// <param name="gameEventArgs">探针事件参数（本实现不读取） / Probe event arguments (not read by this implementation)</param>
+        /// <returns>置位后立即返回的已完成任务 / Completed task returned immediately after setting the flag</returns>
         protected override Task HandleEventAsync(ServerComponentAgent agent, GameEventArgs gameEventArgs)
         {
             Triggered = true;
diff --git a/Tests/GameFrameX.Hotfix.Tests/HotfixBridgeAssemblyLog.cs b/Tests/GameFrameX.Hotfix.Tests/HotfixBridgeAssemblyLog.cs
index 44967a5f5..1d18800a1 100644
--- a/Tests/GameFrameX.Hotfix.Tests/HotfixBridgeAssemblyLog.cs
+++ b/Tests/GameFrameX.Hotfix.Tests/HotfixBridgeAssemblyLog.cs
@@ -43,13 +43,25 @@ public sealed class HotfixBridgeAssemblyLog : ICapabilityAssemblyLog
     /// <summary>Error 级装配日志。</summary>
     public List<string> Errors { get; } = new List<string>();
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 将信息日志追加到 <c>Infos</c> 列表，供测试断言装配过程输出的信息条目。
+    /// </summary>
+    /// <remarks>
+    /// Appends the informational message to the <c>Infos</c> list so tests can assert assembly informational output.
+    /// </remarks>
+    /// <param name="message">信息日志内容 / Informational log message</param>
     public void Info(string message)
     {
         Infos.Add(message);
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 将错误日志追加到 <c>Errors</c> 列表，供测试断言装配过程输出的错误条目。
+    /// </summary>
+    /// <remarks>
+    /// Appends the error message to the <c>Errors</c> list so tests can assert assembly error output.
+    /// </remarks>
+    /// <param name="message">错误日志内容 / Error log message</param>
     public void Error(string message)
     {
         Errors.Add(message);
diff --git a/Tests/GameFrameX.Hotfix.Tests/HotfixBridgeStubModule.cs b/Tests/GameFrameX.Hotfix.Tests/HotfixBridgeStubModule.cs
index a97924078..8597a25bb 100644
--- a/Tests/GameFrameX.Hotfix.Tests/HotfixBridgeStubModule.cs
+++ b/Tests/GameFrameX.Hotfix.Tests/HotfixBridgeStubModule.cs
@@ -49,19 +49,39 @@ public sealed class HotfixBridgeStubModule : ICapabilityModule
     /// </summary>
     private static readonly CapabilityManifest ManifestInstance = new CapabilityManifest(CapabilityId, "1.0.0");
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取桩模块的能力清单，固定返回静态的 <c>ManifestInstance</c>。
+    /// </summary>
+    /// <remarks>
+    /// Gets the stub module capability manifest; always returns the static <c>ManifestInstance</c>.
+    /// </remarks>
+    /// <value>桩模块固定的能力清单实例 / Fixed capability manifest instance of the stub module</value>
     public CapabilityManifest Manifest
     {
         get { return ManifestInstance; }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 注册期不做任何声明：桥契约只能在激活期发布，因此桩模块无需注册服务。
+    /// </summary>
+    /// <remarks>
+    /// Declares nothing during registration, because bridge contracts may only be published at activation time; the stub module needs no service registration.
+    /// </remarks>
+    /// <param name="context">能力注册上下文（本实现不使用） / Capability registration context (unused by this implementation)</param>
     public void Register(CapabilityRegistrationContext context)
     {
         // 桩模块无注册期声明：桥契约只能在激活期发布。
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 按测试槽位发布桥：好友域与匹配域槽位非空时分别发布 <c>IOnlineFriendDomain</c> 与 <c>IOnlineMatchDomain</c>，开启作用域开关时发布授权作用域提供者桩。
+    /// </summary>
+    /// <remarks>
+    /// Publishes bridges according to the test slots: the friend and match domain bridges when their slots are non-null, and the authorized scope provider stub when the scope switch is enabled.
+    /// </remarks>
+    /// <param name="context">能力激活上下文，用于发布桥 / Capability activation context used to publish bridges</param>
+    /// <param name="cancellationToken">取消令牌（本实现不使用） / Cancellation token (unused by this implementation)</param>
+    /// <returns>发布完成后立即返回的已完成任务 / Completed task returned immediately after publishing</returns>
     public Task ActivateAsync(CapabilityActivationContext context, CancellationToken cancellationToken)
     {
         var friendDomain = HotfixBridgeStubSlots.FriendDomain;
@@ -84,7 +104,14 @@ public Task ActivateAsync(CapabilityActivationContext context, CancellationToken
         return Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 停用时不做任何处理：已发布的桥由机制在停止期自动撤销，模块不得自行撤销。
+    /// </summary>
+    /// <remarks>
+    /// Does nothing on deactivation, because published bridges are retracted automatically by the mechanism during stop and the module must not retract them itself.
+    /// </remarks>
+    /// <param name="cancellationToken">取消令牌（本实现不使用） / Cancellation token (unused by this implementation)</param>
+    /// <returns>立即返回的已完成任务 / Completed task returned immediately</returns>
     public Task DeactivateAsync(CancellationToken cancellationToken)
     {
         // 桥由机制在停止期自动撤销，模块不得自行撤销。
diff --git a/Tests/GameFrameX.Hotfix.Tests/HotfixBridgeStubScopeProvider.cs b/Tests/GameFrameX.Hotfix.Tests/HotfixBridgeStubScopeProvider.cs
index ded12b788..7c7f4b24c 100644
--- a/Tests/GameFrameX.Hotfix.Tests/HotfixBridgeStubScopeProvider.cs
+++ b/Tests/GameFrameX.Hotfix.Tests/HotfixBridgeStubScopeProvider.cs
@@ -50,7 +50,13 @@ public sealed class HotfixBridgeStubScopeProvider : IOnlineAuthorizedScopeProvid
     /// </summary>
     private readonly OnlineScope _authorizedScope = new OnlineScope(TenantId, AppId, ServerId);
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取桩授权作用域，固定返回租户 1、应用 1、区服 1001 构成的单例作用域。
+    /// </summary>
+    /// <remarks>
+    /// Gets the stub authorized scope; always returns the singleton scope built from tenant 1, application 1 and server 1001.
+    /// </remarks>
+    /// <value>固定的桩授权作用域 / Fixed stub authorized scope</value>
     public OnlineScope AuthorizedScope
     {
         get { return _authorizedScope; }
diff --git a/Tests/GameFrameX.Hotfix.Tests/HotfixBridgeTestFamily.cs b/Tests/GameFrameX.Hotfix.Tests/HotfixBridgeTestFamily.cs
index 5a5fcd0de..35af63f07 100644
--- a/Tests/GameFrameX.Hotfix.Tests/HotfixBridgeTestFamily.cs
+++ b/Tests/GameFrameX.Hotfix.Tests/HotfixBridgeTestFamily.cs
@@ -38,25 +38,49 @@ namespace GameFrameX.Hotfix.Tests;
 /// </summary>
 public sealed class HotfixBridgeTestFamily : ICapabilityFamily
 {
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取测试能力族标识，固定返回 <c>hotfix-bridge-tests</c>。
+    /// </summary>
+    /// <remarks>
+    /// Gets the test capability family identifier; always returns <c>hotfix-bridge-tests</c>.
+    /// </remarks>
+    /// <value>固定的族标识 / Fixed family identifier</value>
     public string FamilyId
     {
         get { return "hotfix-bridge-tests"; }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取测试能力族的配置节名，固定返回 <c>HotfixBridgeTests</c>。
+    /// </summary>
+    /// <remarks>
+    /// Gets the configuration section name of the test family; always returns <c>HotfixBridgeTests</c>.
+    /// </remarks>
+    /// <value>固定的配置节名 / Fixed configuration section name</value>
     public string ConfigurationSectionName
     {
         get { return "HotfixBridgeTests"; }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取部署程序集前缀，固定返回 <c>GameFrameX.Hotfix.Tests</c>，使本测试程序集内的桩模块参与发现。
+    /// </summary>
+    /// <remarks>
+    /// Gets the deployment assembly prefix; always returns <c>GameFrameX.Hotfix.Tests</c> so stub modules in this test assembly are discovered.
+    /// </remarks>
+    /// <value>固定的部署程序集前缀 / Fixed deployment assembly prefix</value>
     public string DeploymentAssemblyPrefix
     {
         get { return "GameFrameX.Hotfix.Tests"; }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 不注册任何族基建：域桥测试的桥契约全部由桩模块在激活期发布。
+    /// </summary>
+    /// <remarks>
+    /// Registers no family infrastructure, because all bridge contracts in the domain bridge tests are published by the stub module at activation time.
+    /// </remarks>
+    /// <param name="context">能力族上下文（本实现不使用） / Capability family context (unused by this implementation)</param>
     public void RegisterInfrastructure(CapabilityFamilyContext context)
     {
         // 域桥测试不需要族基建：桥契约全部由桩模块在激活期发布。
diff --git a/Tests/GameFrameX.Tests/DataBase/PostgreSqlDbServiceCompatibilityTests.cs b/Tests/GameFrameX.Tests/DataBase/PostgreSqlDbServiceCompatibilityTests.cs
index 9bedd0f11..14d49239b 100644
--- a/Tests/GameFrameX.Tests/DataBase/PostgreSqlDbServiceCompatibilityTests.cs
+++ b/Tests/GameFrameX.Tests/DataBase/PostgreSqlDbServiceCompatibilityTests.cs
@@ -335,7 +335,13 @@ private sealed class LegacyProbeState : BaseCacheState
         /// </summary>
         public List<LegacyItem> Items { get; set; }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// 将 <c>Id|Name|Level</c> 拼接为文本并按 UTF-8 编码为字节，作为旧格式探针状态的简易序列化结果。
+        /// </summary>
+        /// <remarks>
+        /// Joins <c>Id|Name|Level</c> into text and encodes it as UTF-8 bytes, serving as a simple serialization of the legacy probe state.
+        /// </remarks>
+        /// <returns>拼接文本的 UTF-8 字节 / UTF-8 bytes of the joined text</returns>
         public override byte[] ToBytes()
         {
             var data = $"{Id}|{Name}|{Level}";
@@ -380,7 +386,13 @@ private sealed class IndexProbeState : BaseCacheState
         /// </summary>
         public string Name { get; set; }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// 将 <c>Id|Score</c> 拼接为文本并按 UTF-8 编码为字节，作为索引探针状态的简易序列化结果。
+        /// </summary>
+        /// <remarks>
+        /// Joins <c>Id|Score</c> into text and encodes it as UTF-8 bytes, serving as a simple serialization of the index probe state.
+        /// </remarks>
+        /// <returns>拼接文本的 UTF-8 字节 / UTF-8 bytes of the joined text</returns>
         public override byte[] ToBytes()
         {
             var data = $"{Id}|{Score}";
@@ -404,7 +416,13 @@ private sealed class RebuildProbeState : BaseCacheState
         /// </summary>
         public string Name { get; set; }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// 将 <c>Id|Score</c> 拼接为文本并按 UTF-8 编码为字节，作为索引重建探针状态的简易序列化结果。
+        /// </summary>
+        /// <remarks>
+        /// Joins <c>Id|Score</c> into text and encodes it as UTF-8 bytes, serving as a simple serialization of the index rebuild probe state.
+        /// </remarks>
+        /// <returns>拼接文本的 UTF-8 字节 / UTF-8 bytes of the joined text</returns>
         public override byte[] ToBytes()
         {
             var data = $"{Id}|{Score}";
@@ -427,7 +445,13 @@ private sealed class SortNullProbeState : BaseCacheState
         /// </summary>
         public string Name { get; set; }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// 将 <c>Id|Score</c> 拼接为文本并按 UTF-8 编码为字节，作为空值排序探针状态的简易序列化结果。
+        /// </summary>
+        /// <remarks>
+        /// Joins <c>Id|Score</c> into text and encodes it as UTF-8 bytes, serving as a simple serialization of the null sorting probe state.
+        /// </remarks>
+        /// <returns>拼接文本的 UTF-8 字节 / UTF-8 bytes of the joined text</returns>
         public override byte[] ToBytes()
         {
             var data = $"{Id}|{Score}";
diff --git a/Tests/GameFrameX.Tests/Online/CapabilityBindingTestOptions.cs b/Tests/GameFrameX.Tests/Online/CapabilityBindingTestOptions.cs
index ba2caf313..24385168e 100644
--- a/Tests/GameFrameX.Tests/Online/CapabilityBindingTestOptions.cs
+++ b/Tests/GameFrameX.Tests/Online/CapabilityBindingTestOptions.cs
@@ -49,7 +49,13 @@ public sealed class CapabilityBindingTestOptions : ICapabilityOptions
     /// <summary>获取或设置嵌套参数段（嵌套字段路径验证位）。</summary>
     public NestedSection Nested { get; set; } = new NestedSection();
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 校验 Alpha、Beta、Gamma 与 Nested.Depth 均为正数；嵌套段为 null 时按 0 计入，从而报告校验失败。
+    /// </summary>
+    /// <remarks>
+    /// Validates that Alpha, Beta, Gamma and Nested.Depth are all positive; a null nested section counts as 0 and is therefore reported as a validation failure.
+    /// </remarks>
+    /// <param name="validation">收集校验失败的能力选项校验器 / Capability options validation collector that records failures</param>
     public void Validate(CapabilityOptionsValidation validation)
     {
         validation.RequirePositive("Alpha", Alpha);
diff --git a/Tests/GameFrameX.Tests/Online/CapabilityDependencyCheckTests.cs b/Tests/GameFrameX.Tests/Online/CapabilityDependencyCheckTests.cs
index 9f79353d7..f37970ae6 100644
--- a/Tests/GameFrameX.Tests/Online/CapabilityDependencyCheckTests.cs
+++ b/Tests/GameFrameX.Tests/Online/CapabilityDependencyCheckTests.cs
@@ -69,7 +69,13 @@ public ScopeProbeService(string name)
             Name = name;
         }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// 获取构造时传入的探针名，供测试按名称区分解析到的探针实例。
+        /// </summary>
+        /// <remarks>
+        /// Gets the probe name passed at construction so tests can tell resolved probe instances apart by name.
+        /// </remarks>
+        /// <value>探针名 / Probe name</value>
         public string Name { get; }
     }
 
diff --git a/Tests/GameFrameX.Tests/Online/CapabilityHostServiceAndHookTests.cs b/Tests/GameFrameX.Tests/Online/CapabilityHostServiceAndHookTests.cs
index b9ac4d50f..a2220ec2a 100644
--- a/Tests/GameFrameX.Tests/Online/CapabilityHostServiceAndHookTests.cs
+++ b/Tests/GameFrameX.Tests/Online/CapabilityHostServiceAndHookTests.cs
@@ -114,7 +114,13 @@ public NamedImplementation(string name)
             Name = name;
         }
 
-        /// <inheritdoc cref="IHostDirectoryService.Name" />
+        /// <summary>
+        /// 获取构造时传入的实现标记，供测试按标记断言宿主服务或钩子解析到的是哪个实例。
+        /// </summary>
+        /// <remarks>
+        /// Gets the implementation marker passed at construction so tests can assert which instance a host service or hook resolved to.
+        /// </remarks>
+        /// <value>实现标记 / Implementation marker</value>
         public string Name { get; }
     }
 
diff --git a/Tests/GameFrameX.Tests/Online/CapabilityLifecycleAndBridgeTests.cs b/Tests/GameFrameX.Tests/Online/CapabilityLifecycleAndBridgeTests.cs
index c52cea390..96d22f9a5 100644
--- a/Tests/GameFrameX.Tests/Online/CapabilityLifecycleAndBridgeTests.cs
+++ b/Tests/GameFrameX.Tests/Online/CapabilityLifecycleAndBridgeTests.cs
@@ -122,7 +122,13 @@ public BridgeImplementation(string owner)
             Owner = owner;
         }
 
-        /// <inheritdoc cref="IRollbackFirstBridge.Owner" />
+        /// <summary>
+        /// 获取构造时传入的发布者标记，供测试断言桥解析到的是哪个发布者的实例。
+        /// </summary>
+        /// <remarks>
+        /// Gets the publisher marker passed at construction so tests can assert which publisher's instance a bridge resolved to.
+        /// </remarks>
+        /// <value>发布者标记 / Publisher marker</value>
         public string Owner { get; }
     }
 
diff --git a/Tests/GameFrameX.Tests/Online/CapabilitySchedulerTests.cs b/Tests/GameFrameX.Tests/Online/CapabilitySchedulerTests.cs
index a23f55ad9..b6f4bd673 100644
--- a/Tests/GameFrameX.Tests/Online/CapabilitySchedulerTests.cs
+++ b/Tests/GameFrameX.Tests/Online/CapabilitySchedulerTests.cs
@@ -74,7 +74,13 @@ public ManualSchedulerClock(DateTimeOffset start)
             _utcNow = start;
         }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// 在锁内读取手动维护的虚拟时刻；时刻只随测试显式推进而变化，不读取系统时钟。
+        /// </summary>
+        /// <remarks>
+        /// Reads the manually maintained virtual time under a lock; it changes only when the test advances it explicitly and never reads the system clock.
+        /// </remarks>
+        /// <value>当前虚拟时刻 / Current virtual time</value>
         public DateTimeOffset UtcNow
         {
             get
@@ -188,7 +194,15 @@ public TickRoundRecord[] TickRounds
             }
         }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// 在锁内记录一条作业失败（类型、名称、异常），供测试断言调度器上报的失败。
+        /// </summary>
+        /// <remarks>
+        /// Records a job failure (kind, name, exception) under a lock so tests can assert failures reported by the scheduler.
+        /// </remarks>
+        /// <param name="jobKind">失败作业类型 / Kind of the failed job</param>
+        /// <param name="jobName">失败作业名称 / Name of the failed job</param>
+        /// <param name="exception">作业抛出的异常 / Exception thrown by the job</param>
         public void OnJobFailed(CapabilitySchedulerJobKind jobKind, string jobName, Exception exception)
         {
             lock (_sync)
@@ -197,7 +211,15 @@ public void OnJobFailed(CapabilitySchedulerJobKind jobKind, string jobName, Exce
             }
         }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// 在锁内记录一轮 tick 的执行作业数与失败作业数，供测试断言调度轮次统计；耗时不记录。
+        /// </summary>
+        /// <remarks>
+        /// Records the executed and failed job counts of a tick round under a lock so tests can assert round statistics; the elapsed time is not recorded.
+        /// </remarks>
+        /// <param name="elapsed">本轮耗时（本实现不记录） / Elapsed time of the round (not recorded by this implementation)</param>
+        /// <param name="executedJobCount">本轮执行的作业数 / Number of jobs executed in the round</param>
+        /// <param name="failedJobCount">本轮失败的作业数 / Number of jobs failed in the round</param>
         public void OnTickRoundCompleted(TimeSpan elapsed, int executedJobCount, int failedJobCount)
         {
             lock (_sync)
diff --git a/Tests/GameFrameX.Tests/Online/CollectingCapabilityAssemblyLog.cs b/Tests/GameFrameX.Tests/Online/CollectingCapabilityAssemblyLog.cs
index c43bc1a13..39f5f1cad 100644
--- a/Tests/GameFrameX.Tests/Online/CollectingCapabilityAssemblyLog.cs
+++ b/Tests/GameFrameX.Tests/Online/CollectingCapabilityAssemblyLog.cs
@@ -57,13 +57,25 @@ public sealed class CollectingCapabilityAssemblyLog : ICapabilityAssemblyLog
     /// <summary>Error 级日志流。</summary>
     public readonly List<string> Errors = new();
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 将信息日志追加到 <c>Infos</c> 列表，供测试断言能力装配输出的信息条目。
+    /// </summary>
+    /// <remarks>
+    /// Appends the informational message to the <c>Infos</c> list so tests can assert capability assembly informational output.
+    /// </remarks>
+    /// <param name="message">信息日志内容 / Informational log message</param>
     public void Info(string message)
     {
         Infos.Add(message);
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 将错误日志追加到 <c>Errors</c> 列表，供测试断言能力装配输出的错误条目。
+    /// </summary>
+    /// <remarks>
+    /// Appends the error message to the <c>Errors</c> list so tests can assert capability assembly error output.
+    /// </remarks>
+    /// <param name="message">错误日志内容 / Error log message</param>
     public void Error(string message)
     {
         Errors.Add(message);
diff --git a/Tests/GameFrameX.Tests/Online/HotfixManagerRollbackExecutorTests.cs b/Tests/GameFrameX.Tests/Online/HotfixManagerRollbackExecutorTests.cs
index 492bd8b02..128a892e9 100644
--- a/Tests/GameFrameX.Tests/Online/HotfixManagerRollbackExecutorTests.cs
+++ b/Tests/GameFrameX.Tests/Online/HotfixManagerRollbackExecutorTests.cs
@@ -205,7 +205,15 @@ public PayloadHandler(byte[] payload)
             _payload = payload;
         }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// 递增请求计数后，对任意请求固定返回 200 响应，响应体为构造时传入的制品字节；不发起真实网络请求。
+        /// </summary>
+        /// <remarks>
+        /// Increments the request counter and returns a fixed 200 response whose body is the artifact bytes passed at construction, for any request; no real network call is made.
+        /// </remarks>
+        /// <param name="request">HTTP 请求（本实现不读取） / HTTP request (not read by this implementation)</param>
+        /// <param name="cancellationToken">取消令牌（本实现不使用） / Cancellation token (unused by this implementation)</param>
+        /// <returns>携带制品字节的 200 响应任务 / Task yielding a 200 response carrying the artifact bytes</returns>
         protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
         {
             CallCount++;
diff --git a/Tests/GameFrameX.Tests/Online/MechanismFirstSlotModule.cs b/Tests/GameFrameX.Tests/Online/MechanismFirstSlotModule.cs
index 27fba6f99..f1375f193 100644
--- a/Tests/GameFrameX.Tests/Online/MechanismFirstSlotModule.cs
+++ b/Tests/GameFrameX.Tests/Online/MechanismFirstSlotModule.cs
@@ -39,32 +39,65 @@ namespace GameFrameX.Tests.Online;
 /// <summary>槽位一模块（发现序最先）。</summary>
 public sealed class MechanismFirstSlotModule : ICapabilityModule, IAdminActionContributor
 {
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取槽位一（类型名排序后最先被发现的槽位）的能力清单：每次读取都由 <see cref="MechanismScenario.First"/> 现场生成，能力标识取用例覆写值，未覆写时为缺省 <c>mech-first</c>，版本固定 <c>1.0.0</c>，并带上用例设置的动作、必需依赖、可选依赖与参数类型。
+    /// </summary>
+    /// <remarks>
+    /// Builds the manifest of slot first (the slot discovered first by type-name ordering) on every read from <c>MechanismScenario.First</c>: the capability identifier is the per-test override or the default <c>mech-first</c>, version is fixed at <c>1.0.0</c>, and actions, required and optional dependencies and options type come from the slot setup.
+    /// </remarks>
+    /// <value>槽位一当前场景对应的能力清单 / Capability manifest reflecting the current setup of slot first</value>
     public CapabilityManifest Manifest
     {
         get { return MechanismScenario.First.ToManifest(); }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 把注册阶段转交给槽位一的 <c>Register</c> 委托，供用例在 <c>mech-first</c> 上注入服务或记录注册顺序；用例未设置委托时不做任何注册。
+    /// </summary>
+    /// <remarks>
+    /// Forwards the registration phase to the <c>Register</c> delegate of slot first so tests can inject services or record ordering for <c>mech-first</c>; registers nothing when no delegate is set.
+    /// </remarks>
+    /// <param name="context">能力注册上下文，原样传给槽位一委托 / Registration context passed unchanged to the slot first delegate</param>
     public void Register(CapabilityRegistrationContext context)
     {
         MechanismScenario.First.Register?.Invoke(context);
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 把激活阶段转交给槽位一的 <c>Activate</c> 委托并返回其任务，用于验证 <c>mech-first</c> 的激活顺序、激活失败与回滚等机制；未设置委托时直接返回已完成任务，即视为激活成功。
+    /// </summary>
+    /// <remarks>
+    /// Forwards activation to the <c>Activate</c> delegate of slot first and returns its task, letting tests drive ordering, failure and rollback for <c>mech-first</c>; returns a completed task (successful activation) when no delegate is set.
+    /// </remarks>
+    /// <param name="context">能力激活上下文，原样传给槽位一委托 / Activation context passed unchanged to the slot first delegate</param>
+    /// <param name="cancellationToken">取消令牌，原样传给委托 / Cancellation token passed to the delegate</param>
+    /// <returns>委托返回的任务；无委托时为已完成任务 / Task returned by the delegate, or a completed task when none is set</returns>
     public Task ActivateAsync(CapabilityActivationContext context, CancellationToken cancellationToken)
     {
         return MechanismScenario.First.Activate?.Invoke(context, cancellationToken) ?? Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 同步调用槽位一的 <c>Deactivate</c> 委托（用例借此记录 <c>mech-first</c> 的停用顺序），随后返回已完成任务；委托为同步形式，因此没有需要等待的异步工作。
+    /// </summary>
+    /// <remarks>
+    /// Synchronously invokes the <c>Deactivate</c> delegate of slot first (used to record the deactivation order of <c>mech-first</c>) and returns a completed task, because the delegate is synchronous and nothing needs awaiting.
+    /// </remarks>
+    /// <param name="cancellationToken">取消令牌，原样传给委托 / Cancellation token passed to the delegate</param>
+    /// <returns>已完成的任务 / Completed task</returns>
     public Task DeactivateAsync(CancellationToken cancellationToken)
     {
         MechanismScenario.First.Deactivate?.Invoke(cancellationToken);
         return Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 把管理动作注册转交给槽位一的 <c>RegisterAdminActions</c> 委托，用于验证 <c>mech-first</c> 贡献的管理面动作；未设置委托时不注册任何动作。
+    /// </summary>
+    /// <remarks>
+    /// Forwards admin action registration to the <c>RegisterAdminActions</c> delegate of slot first to exercise admin actions contributed by <c>mech-first</c>; registers no action when no delegate is set.
+    /// </remarks>
+    /// <param name="registry">管理动作注册表，原样传给槽位一委托 / Admin action registry passed unchanged to the slot first delegate</param>
     public void RegisterAdminActions(AdminActionRegistry registry)
     {
         MechanismScenario.First.RegisterAdminActions?.Invoke(registry);
diff --git a/Tests/GameFrameX.Tests/Online/MechanismFourthSlotModule.cs b/Tests/GameFrameX.Tests/Online/MechanismFourthSlotModule.cs
index b261b5ffd..edb90dad1 100644
--- a/Tests/GameFrameX.Tests/Online/MechanismFourthSlotModule.cs
+++ b/Tests/GameFrameX.Tests/Online/MechanismFourthSlotModule.cs
@@ -39,32 +39,65 @@ namespace GameFrameX.Tests.Online;
 /// <summary>槽位四模块。</summary>
 public sealed class MechanismFourthSlotModule : ICapabilityModule, IAdminActionContributor
 {
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取槽位四（发现顺序按类型名 <c>MechanismFourthSlotModule</c> 排序决定，而非槽位序号）的能力清单：每次读取都由 <see cref="MechanismScenario.Fourth"/> 现场生成，能力标识取用例覆写值，未覆写时为缺省 <c>mech-fourth</c>，版本固定 <c>1.0.0</c>，并带上用例设置的动作、必需依赖、可选依赖与参数类型。
+    /// </summary>
+    /// <remarks>
+    /// Builds the manifest of slot fourth (discovery order follows the type name <c>MechanismFourthSlotModule</c>, not the slot number) on every read from <c>MechanismScenario.Fourth</c>: the capability identifier is the per-test override or the default <c>mech-fourth</c>, version is fixed at <c>1.0.0</c>, and actions, required and optional dependencies and options type come from the slot setup.
+    /// </remarks>
+    /// <value>槽位四当前场景对应的能力清单 / Capability manifest reflecting the current setup of slot fourth</value>
     public CapabilityManifest Manifest
     {
         get { return MechanismScenario.Fourth.ToManifest(); }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 把注册阶段转交给槽位四的 <c>Register</c> 委托，供用例在 <c>mech-fourth</c> 上注入服务或记录注册顺序；用例未设置委托时不做任何注册。
+    /// </summary>
+    /// <remarks>
+    /// Forwards the registration phase to the <c>Register</c> delegate of slot fourth so tests can inject services or record ordering for <c>mech-fourth</c>; registers nothing when no delegate is set.
+    /// </remarks>
+    /// <param name="context">能力注册上下文，原样传给槽位四委托 / Registration context passed unchanged to the slot fourth delegate</param>
     public void Register(CapabilityRegistrationContext context)
     {
         MechanismScenario.Fourth.Register?.Invoke(context);
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 把激活阶段转交给槽位四的 <c>Activate</c> 委托并返回其任务，用于验证 <c>mech-fourth</c> 的激活顺序、激活失败与回滚等机制；未设置委托时直接返回已完成任务，即视为激活成功。
+    /// </summary>
+    /// <remarks>
+    /// Forwards activation to the <c>Activate</c> delegate of slot fourth and returns its task, letting tests drive ordering, failure and rollback for <c>mech-fourth</c>; returns a completed task (successful activation) when no delegate is set.
+    /// </remarks>
+    /// <param name="context">能力激活上下文，原样传给槽位四委托 / Activation context passed unchanged to the slot fourth delegate</param>
+    /// <param name="cancellationToken">取消令牌，原样传给委托 / Cancellation token passed to the delegate</param>
+    /// <returns>委托返回的任务；无委托时为已完成任务 / Task returned by the delegate, or a completed task when none is set</returns>
     public Task ActivateAsync(CapabilityActivationContext context, CancellationToken cancellationToken)
     {
         return MechanismScenario.Fourth.Activate?.Invoke(context, cancellationToken) ?? Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 同步调用槽位四的 <c>Deactivate</c> 委托（用例借此记录 <c>mech-fourth</c> 的停用顺序），随后返回已完成任务；委托为同步形式，因此没有需要等待的异步工作。
+    /// </summary>
+    /// <remarks>
+    /// Synchronously invokes the <c>Deactivate</c> delegate of slot fourth (used to record the deactivation order of <c>mech-fourth</c>) and returns a completed task, because the delegate is synchronous and nothing needs awaiting.
+    /// </remarks>
+    /// <param name="cancellationToken">取消令牌，原样传给委托 / Cancellation token passed to the delegate</param>
+    /// <returns>已完成的任务 / Completed task</returns>
     public Task DeactivateAsync(CancellationToken cancellationToken)
     {
         MechanismScenario.Fourth.Deactivate?.Invoke(cancellationToken);
         return Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 把管理动作注册转交给槽位四的 <c>RegisterAdminActions</c> 委托，用于验证 <c>mech-fourth</c> 贡献的管理面动作；未设置委托时不注册任何动作。
+    /// </summary>
+    /// <remarks>
+    /// Forwards admin action registration to the <c>RegisterAdminActions</c> delegate of slot fourth to exercise admin actions contributed by <c>mech-fourth</c>; registers no action when no delegate is set.
+    /// </remarks>
+    /// <param name="registry">管理动作注册表，原样传给槽位四委托 / Admin action registry passed unchanged to the slot fourth delegate</param>
     public void RegisterAdminActions(AdminActionRegistry registry)
     {
         MechanismScenario.Fourth.RegisterAdminActions?.Invoke(registry);
diff --git a/Tests/GameFrameX.Tests/Online/MechanismSecondSlotModule.cs b/Tests/GameFrameX.Tests/Online/MechanismSecondSlotModule.cs
index 7b2c8b16c..03565c31c 100644
--- a/Tests/GameFrameX.Tests/Online/MechanismSecondSlotModule.cs
+++ b/Tests/GameFrameX.Tests/Online/MechanismSecondSlotModule.cs
@@ -39,32 +39,65 @@ namespace GameFrameX.Tests.Online;
 /// <summary>槽位二模块。</summary>
 public sealed class MechanismSecondSlotModule : ICapabilityModule, IAdminActionContributor
 {
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取槽位二（发现顺序按类型名 <c>MechanismSecondSlotModule</c> 排序决定，而非槽位序号）的能力清单：每次读取都由 <see cref="MechanismScenario.Second"/> 现场生成，能力标识取用例覆写值，未覆写时为缺省 <c>mech-second</c>，版本固定 <c>1.0.0</c>，并带上用例设置的动作、必需依赖、可选依赖与参数类型。
+    /// </summary>
+    /// <remarks>
+    /// Builds the manifest of slot second (discovery order follows the type name <c>MechanismSecondSlotModule</c>, not the slot number) on every read from <c>MechanismScenario.Second</c>: the capability identifier is the per-test override or the default <c>mech-second</c>, version is fixed at <c>1.0.0</c>, and actions, required and optional dependencies and options type come from the slot setup.
+    /// </remarks>
+    /// <value>槽位二当前场景对应的能力清单 / Capability manifest reflecting the current setup of slot second</value>
     public CapabilityManifest Manifest
     {
         get { return MechanismScenario.Second.ToManifest(); }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 把注册阶段转交给槽位二的 <c>Register</c> 委托，供用例在 <c>mech-second</c> 上注入服务或记录注册顺序；用例未设置委托时不做任何注册。
+    /// </summary>
+    /// <remarks>
+    /// Forwards the registration phase to the <c>Register</c> delegate of slot second so tests can inject services or record ordering for <c>mech-second</c>; registers nothing when no delegate is set.
+    /// </remarks>
+    /// <param name="context">能力注册上下文，原样传给槽位二委托 / Registration context passed unchanged to the slot second delegate</param>
     public void Register(CapabilityRegistrationContext context)
     {
         MechanismScenario.Second.Register?.Invoke(context);
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 把激活阶段转交给槽位二的 <c>Activate</c> 委托并返回其任务，用于验证 <c>mech-second</c> 的激活顺序、激活失败与回滚等机制；未设置委托时直接返回已完成任务，即视为激活成功。
+    /// </summary>
+    /// <remarks>
+    /// Forwards activation to the <c>Activate</c> delegate of slot second and returns its task, letting tests drive ordering, failure and rollback for <c>mech-second</c>; returns a completed task (successful activation) when no delegate is set.
+    /// </remarks>
+    /// <param name="context">能力激活上下文，原样传给槽位二委托 / Activation context passed unchanged to the slot second delegate</param>
+    /// <param name="cancellationToken">取消令牌，原样传给委托 / Cancellation token passed to the delegate</param>
+    /// <returns>委托返回的任务；无委托时为已完成任务 / Task returned by the delegate, or a completed task when none is set</returns>
     public Task ActivateAsync(CapabilityActivationContext context, CancellationToken cancellationToken)
     {
         return MechanismScenario.Second.Activate?.Invoke(context, cancellationToken) ?? Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 同步调用槽位二的 <c>Deactivate</c> 委托（用例借此记录 <c>mech-second</c> 的停用顺序），随后返回已完成任务；委托为同步形式，因此没有需要等待的异步工作。
+    /// </summary>
+    /// <remarks>
+    /// Synchronously invokes the <c>Deactivate</c> delegate of slot second (used to record the deactivation order of <c>mech-second</c>) and returns a completed task, because the delegate is synchronous and nothing needs awaiting.
+    /// </remarks>
+    /// <param name="cancellationToken">取消令牌，原样传给委托 / Cancellation token passed to the delegate</param>
+    /// <returns>已完成的任务 / Completed task</returns>
     public Task DeactivateAsync(CancellationToken cancellationToken)
     {
         MechanismScenario.Second.Deactivate?.Invoke(cancellationToken);
         return Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 把管理动作注册转交给槽位二的 <c>RegisterAdminActions</c> 委托，用于验证 <c>mech-second</c> 贡献的管理面动作；未设置委托时不注册任何动作。
+    /// </summary>
+    /// <remarks>
+    /// Forwards admin action registration to the <c>RegisterAdminActions</c> delegate of slot second to exercise admin actions contributed by <c>mech-second</c>; registers no action when no delegate is set.
+    /// </remarks>
+    /// <param name="registry">管理动作注册表，原样传给槽位二委托 / Admin action registry passed unchanged to the slot second delegate</param>
     public void RegisterAdminActions(AdminActionRegistry registry)
     {
         MechanismScenario.Second.RegisterAdminActions?.Invoke(registry);
diff --git a/Tests/GameFrameX.Tests/Online/MechanismTestFamily.cs b/Tests/GameFrameX.Tests/Online/MechanismTestFamily.cs
index 19e06b058..62c6ed6d7 100644
--- a/Tests/GameFrameX.Tests/Online/MechanismTestFamily.cs
+++ b/Tests/GameFrameX.Tests/Online/MechanismTestFamily.cs
@@ -42,19 +42,37 @@ namespace GameFrameX.Tests.Online;
 /// </summary>
 public sealed class MechanismTestFamily : ICapabilityFamily
 {
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取机制测试族的族标识，固定返回 <c>mechanism-tests</c>，与业务族区分，避免机制用例和真实能力族互相干扰。
+    /// </summary>
+    /// <remarks>
+    /// Returns the fixed family identifier <c>mechanism-tests</c>, keeping mechanism test cases separate from real capability families.
+    /// </remarks>
+    /// <value>固定值 <c>mechanism-tests</c> / Fixed value <c>mechanism-tests</c></value>
     public string FamilyId
     {
         get { return "mechanism-tests"; }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取机制测试族的配置段名，固定返回 <c>MechanismTests</c>，用例按这个段名提供能力参数配置。
+    /// </summary>
+    /// <remarks>
+    /// Returns the fixed configuration section name <c>MechanismTests</c>, under which test cases supply capability options.
+    /// </remarks>
+    /// <value>固定值 <c>MechanismTests</c> / Fixed value <c>MechanismTests</c></value>
     public string ConfigurationSectionName
     {
         get { return "MechanismTests"; }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取部署程序集名前缀，固定返回 <c>GameFrameX.Tests</c>，让发现流程能扫描到按部署命名约定复制出的 <c>GameFrameX.Tests.CapabilityStubs.dll</c> 中的四个槽位模块。
+    /// </summary>
+    /// <remarks>
+    /// Returns the fixed deployment assembly prefix <c>GameFrameX.Tests</c>, so discovery picks up the four slot modules from the convention-named copy <c>GameFrameX.Tests.CapabilityStubs.dll</c>.
+    /// </remarks>
+    /// <value>固定值 <c>GameFrameX.Tests</c> / Fixed value <c>GameFrameX.Tests</c></value>
     public string DeploymentAssemblyPrefix
     {
         get { return "GameFrameX.Tests"; }
@@ -63,7 +81,13 @@ public string DeploymentAssemblyPrefix
     /// <summary>最近一次组合的事件发布口捕获（事件总线行为用例经它发布）。</summary>
     public static ICapabilityEventPublisher LastEventPublisher;
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 预置管理面测试适配器：注册一组五个错误码位都相同（代码 0、名称 <c>mechanism.test</c>）的 <see cref="AdminApiErrorCodes"/>，注册恒放行的 <see cref="MechanismTestScopeAdapter"/> 作为 <see cref="IAdminApiScopeAdapter"/>，并把上下文的事件发布口保存到 <see cref="LastEventPublisher"/> 供事件总线用例使用；不绑定任何 Online 业务语义。
+    /// </summary>
+    /// <remarks>
+    /// Seeds the admin API test adapters: registers <c>AdminApiErrorCodes</c> whose five slots all share one code (0, <c>mechanism.test</c>), registers the always-allow <c>MechanismTestScopeAdapter</c> as <c>IAdminApiScopeAdapter</c>, and stores the context event publisher in <c>LastEventPublisher</c> for event bus test cases. No Online business semantics are bound.
+    /// </remarks>
+    /// <param name="context">族基础设施注册上下文，用于登记服务并提供事件发布口 / Family infrastructure context used to add services and supply the event publisher</param>
     public void RegisterInfrastructure(CapabilityFamilyContext context)
     {
         // 管理面测试适配器：五个机制用错误码位 + 恒放行作用域（机制口径，不绑 Online 语义）。
diff --git a/Tests/GameFrameX.Tests/Online/MechanismTestScopeAdapter.cs b/Tests/GameFrameX.Tests/Online/MechanismTestScopeAdapter.cs
index fed0feece..5b7d3974d 100644
--- a/Tests/GameFrameX.Tests/Online/MechanismTestScopeAdapter.cs
+++ b/Tests/GameFrameX.Tests/Online/MechanismTestScopeAdapter.cs
@@ -41,7 +41,15 @@ namespace GameFrameX.Tests.Online;
 /// </summary>
 public sealed class MechanismTestScopeAdapter : IAdminApiScopeAdapter
 {
-    /// <inheritdoc />
+    /// <summary>
+    /// 从管理面请求中读取声明的租户、应用、服务器三元组；读取成功时据此构造声明作用域并返回 <c>true</c>，否则输出 <c>null</c> 并返回 <c>false</c>。
+    /// </summary>
+    /// <remarks>
+    /// Reads the claimed tenant, app and server triple from the admin API request; on success builds the claimed scope and returns <c>true</c>, otherwise outputs <c>null</c> and returns <c>false</c>.
+    /// </remarks>
+    /// <param name="request">管理面请求 / Admin API request</param>
+    /// <param name="claimedScope">读取成功时为声明作用域，失败时为 <c>null</c> / Claimed scope on success, <c>null</c> on failure</param>
+    /// <returns>请求中带有完整三元组时为 <c>true</c>，否则为 <c>false</c> / <c>true</c> when the request carries the full triple, otherwise <c>false</c></returns>
     public bool TryReadClaimedScope(AdminApiRequest request, out AdminApiClaimedScope claimedScope)
     {
         if (request.TryReadClaimedScope(out var tenantId, out var appId, out var serverId))
@@ -54,7 +62,15 @@ public bool TryReadClaimedScope(AdminApiRequest request, out AdminApiClaimedScop
         return false;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 恒放行：不比较声明作用域与授权作用域，始终返回 <c>null</c> 表示校验通过；作用域守卫的拒绝语义由 Online 侧用例单独覆盖，这里只服务机制层测试。
+    /// </summary>
+    /// <remarks>
+    /// Always allows: never compares the claimed and authorized scopes and always returns <c>null</c> (validation passed). Rejection semantics of the scope guard are covered separately by Online test cases; this adapter only serves mechanism tests.
+    /// </remarks>
+    /// <param name="claimed">请求声明的作用域（未使用） / Scope claimed by the request (unused)</param>
+    /// <param name="authorized">已授权的作用域（未使用） / Authorized scope (unused)</param>
+    /// <returns>始终为 <c>null</c>，表示无错误 / Always <c>null</c>, meaning no error</returns>
     public AdminApiErrorCode ValidateClaimed(AdminApiClaimedScope claimed, AdminApiClaimedScope authorized)
     {
         return null;
diff --git a/Tests/GameFrameX.Tests/Online/MechanismThirdSlotModule.cs b/Tests/GameFrameX.Tests/Online/MechanismThirdSlotModule.cs
index 574151ced..2476d4731 100644
--- a/Tests/GameFrameX.Tests/Online/MechanismThirdSlotModule.cs
+++ b/Tests/GameFrameX.Tests/Online/MechanismThirdSlotModule.cs
@@ -39,32 +39,65 @@ namespace GameFrameX.Tests.Online;
 /// <summary>槽位三模块。</summary>
 public sealed class MechanismThirdSlotModule : ICapabilityModule, IAdminActionContributor
 {
-    /// <inheritdoc />
+    /// <summary>
+    /// 获取槽位三（发现顺序按类型名 <c>MechanismThirdSlotModule</c> 排序决定，而非槽位序号）的能力清单：每次读取都由 <see cref="MechanismScenario.Third"/> 现场生成，能力标识取用例覆写值，未覆写时为缺省 <c>mech-third</c>，版本固定 <c>1.0.0</c>，并带上用例设置的动作、必需依赖、可选依赖与参数类型。
+    /// </summary>
+    /// <remarks>
+    /// Builds the manifest of slot third (discovery order follows the type name <c>MechanismThirdSlotModule</c>, not the slot number) on every read from <c>MechanismScenario.Third</c>: the capability identifier is the per-test override or the default <c>mech-third</c>, version is fixed at <c>1.0.0</c>, and actions, required and optional dependencies and options type come from the slot setup.
+    /// </remarks>
+    /// <value>槽位三当前场景对应的能力清单 / Capability manifest reflecting the current setup of slot third</value>
     public CapabilityManifest Manifest
     {
         get { return MechanismScenario.Third.ToManifest(); }
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 把注册阶段转交给槽位三的 <c>Register</c> 委托，供用例在 <c>mech-third</c> 上注入服务或记录注册顺序；用例未设置委托时不做任何注册。
+    /// </summary>
+    /// <remarks>
+    /// Forwards the registration phase to the <c>Register</c> delegate of slot third so tests can inject services or record ordering for <c>mech-third</c>; registers nothing when no delegate is set.
+    /// </remarks>
+    /// <param name="context">能力注册上下文，原样传给槽位三委托 / Registration context passed unchanged to the slot third delegate</param>
     public void Register(CapabilityRegistrationContext context)
     {
         MechanismScenario.Third.Register?.Invoke(context);
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 把激活阶段转交给槽位三的 <c>Activate</c> 委托并返回其任务，用于验证 <c>mech-third</c> 的激活顺序、激活失败与回滚等机制；未设置委托时直接返回已完成任务，即视为激活成功。
+    /// </summary>
+    /// <remarks>
+    /// Forwards activation to the <c>Activate</c> delegate of slot third and returns its task, letting tests drive ordering, failure and rollback for <c>mech-third</c>; returns a completed task (successful activation) when no delegate is set.
+    /// </remarks>
+    /// <param name="context">能力激活上下文，原样传给槽位三委托 / Activation context passed unchanged to the slot third delegate</param>
+    /// <param name="cancellationToken">取消令牌，原样传给委托 / Cancellation token passed to the delegate</param>
+    /// <returns>委托返回的任务；无委托时为已完成任务 / Task returned by the delegate, or a completed task when none is set</returns>
     public Task ActivateAsync(CapabilityActivationContext context, CancellationToken cancellationToken)
     {
         return MechanismScenario.Third.Activate?.Invoke(context, cancellationToken) ?? Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 同步调用槽位三的 <c>Deactivate</c> 委托（用例借此记录 <c>mech-third</c> 的停用顺序），随后返回已完成任务；委托为同步形式，因此没有需要等待的异步工作。
+    /// </summary>
+    /// <remarks>
+    /// Synchronously invokes the <c>Deactivate</c> delegate of slot third (used to record the deactivation order of <c>mech-third</c>) and returns a completed task, because the delegate is synchronous and nothing needs awaiting.
+    /// </remarks>
+    /// <param name="cancellationToken">取消令牌，原样传给委托 / Cancellation token passed to the delegate</param>
+    /// <returns>已完成的任务 / Completed task</returns>
     public Task DeactivateAsync(CancellationToken cancellationToken)
     {
         MechanismScenario.Third.Deactivate?.Invoke(cancellationToken);
         return Task.CompletedTask;
     }
 
-    /// <inheritdoc />
+    /// <summary>
+    /// 把管理动作注册转交给槽位三的 <c>RegisterAdminActions</c> 委托，用于验证 <c>mech-third</c> 贡献的管理面动作；未设置委托时不注册任何动作。
+    /// </summary>
+    /// <remarks>
+    /// Forwards admin action registration to the <c>RegisterAdminActions</c> delegate of slot third to exercise admin actions contributed by <c>mech-third</c>; registers no action when no delegate is set.
+    /// </remarks>
+    /// <param name="registry">管理动作注册表，原样传给槽位三委托 / Admin action registry passed unchanged to the slot third delegate</param>
     public void RegisterAdminActions(AdminActionRegistry registry)
     {
         MechanismScenario.Third.RegisterAdminActions?.Invoke(registry);
diff --git a/Tests/GameFrameX.Tests/Online/OnlineCapabilityTestHarness.cs b/Tests/GameFrameX.Tests/Online/OnlineCapabilityTestHarness.cs
index f6bfc13e6..1583dbbf6 100644
--- a/Tests/GameFrameX.Tests/Online/OnlineCapabilityTestHarness.cs
+++ b/Tests/GameFrameX.Tests/Online/OnlineCapabilityTestHarness.cs
@@ -176,13 +176,34 @@ public static async Task WithRuntimeAsync(Func<CapabilityRuntime, Task> body, st
     /// </summary>
     public sealed class EmptyPlayerDirectory : IOnlinePlayerDirectory
     {
-        /// <inheritdoc />
+        /// <summary>
+        /// 按名称搜索玩家目录；本桩不接任何目录数据，固定返回空集合，表示部署未接入玩家目录。
+        /// </summary>
+        /// <remarks>
+        /// Searches the player directory by name; this stub has no directory data and always returns an empty collection.
+        /// </remarks>
+        /// <param name="tenantId">租户标识（本桩忽略） / Tenant identifier (ignored by this stub)</param>
+        /// <param name="appId">应用标识（本桩忽略） / Application identifier (ignored by this stub)</param>
+        /// <param name="keyword">搜索关键字（本桩忽略） / Search keyword (ignored by this stub)</param>
+        /// <param name="limit">返回条数上限（本桩忽略） / Maximum number of results (ignored by this stub)</param>
+        /// <param name="cancellationToken">取消令牌（本桩忽略） / Cancellation token (ignored by this stub)</param>
+        /// <returns>固定为空的目录条目集合 / An always-empty collection of directory entries</returns>
         public Task<IReadOnlyList<OnlinePlayerDirectoryEntry>> SearchByNameAsync(long tenantId, long appId, string keyword, int limit, CancellationToken cancellationToken = default)
         {
             return Task.FromResult<IReadOnlyList<OnlinePlayerDirectoryEntry>>(Array.Empty<OnlinePlayerDirectoryEntry>());
         }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// 按玩家标识批量解析目录条目；本桩不接任何目录数据，固定返回空集合。
+        /// </summary>
+        /// <remarks>
+        /// Resolves directory entries by player identifiers; this stub has no directory data and always returns an empty collection.
+        /// </remarks>
+        /// <param name="tenantId">租户标识（本桩忽略） / Tenant identifier (ignored by this stub)</param>
+        /// <param name="appId">应用标识（本桩忽略） / Application identifier (ignored by this stub)</param>
+        /// <param name="playerIds">待解析的玩家标识集合（本桩忽略） / Player identifiers to resolve (ignored by this stub)</param>
+        /// <param name="cancellationToken">取消令牌（本桩忽略） / Cancellation token (ignored by this stub)</param>
+        /// <returns>固定为空的目录条目集合 / An always-empty collection of directory entries</returns>
         public Task<IReadOnlyList<OnlinePlayerDirectoryEntry>> FindAsync(long tenantId, long appId, IReadOnlyList<long> playerIds, CancellationToken cancellationToken = default)
         {
             return Task.FromResult<IReadOnlyList<OnlinePlayerDirectoryEntry>>(Array.Empty<OnlinePlayerDirectoryEntry>());
@@ -194,7 +215,15 @@ public Task<IReadOnlyList<OnlinePlayerDirectoryEntry>> FindAsync(long tenantId,
     /// </summary>
     public sealed class NoopHotfixRollbackExecutor : IOnlineHotfixRollbackExecutor
     {
-        /// <inheritdoc />
+        /// <summary>
+        /// 执行热更回滚；本桩仅用于满足宿主服务依赖，测试不验证回滚效果，因此不做任何操作直接完成。
+        /// </summary>
+        /// <remarks>
+        /// Performs a hotfix rollback; this stub only satisfies the host service requirement and completes immediately without doing anything.
+        /// </remarks>
+        /// <param name="targetVersion">回滚目标版本（本桩忽略） / Target rollback version (ignored by this stub)</param>
+        /// <param name="cancellationToken">取消令牌（本桩忽略） / Cancellation token (ignored by this stub)</param>
+        /// <returns>已完成的任务 / An already completed task</returns>
         public Task RollbackAsync(string targetVersion, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
diff --git a/Tests/GameFrameX.Tests/Online/OnlineEventPublisherConsumerTests.cs b/Tests/GameFrameX.Tests/Online/OnlineEventPublisherConsumerTests.cs
index fa8fa068d..154493f19 100644
--- a/Tests/GameFrameX.Tests/Online/OnlineEventPublisherConsumerTests.cs
+++ b/Tests/GameFrameX.Tests/Online/OnlineEventPublisherConsumerTests.cs
@@ -53,7 +53,15 @@ private sealed class RecordingCapabilityEventPublisher : ICapabilityEventPublish
             /// <summary>已发布载荷（发布序，装箱原件）。</summary>
             public readonly List<object> Payloads = new();
 
-            /// <inheritdoc />
+            /// <summary>
+            /// 记录一次机制事件发布：按发布顺序追加主题与载荷原件，不做任何分发，供测试断言委托口径。
+            /// </summary>
+            /// <remarks>
+            /// Records a mechanism event publication by appending the topic and the original payload in publish order, without dispatching.
+            /// </remarks>
+            /// <typeparam name="TEvent">事件载荷类型 / Event payload type</typeparam>
+            /// <param name="topic">事件主题，追加到 <c>Topics</c> / Event topic, appended to <c>Topics</c></param>
+            /// <param name="eventPayload">事件载荷，装箱后追加到 <c>Payloads</c> / Event payload, boxed and appended to <c>Payloads</c></param>
             public void Publish<TEvent>(string topic, TEvent eventPayload)
             {
                 Topics.Add(topic);
diff --git a/Tests/GameFrameX.Tests/Online/OnlineGameDbStorePersistenceTests.cs b/Tests/GameFrameX.Tests/Online/OnlineGameDbStorePersistenceTests.cs
index 1710808dc..0f53682f2 100644
--- a/Tests/GameFrameX.Tests/Online/OnlineGameDbStorePersistenceTests.cs
+++ b/Tests/GameFrameX.Tests/Online/OnlineGameDbStorePersistenceTests.cs
@@ -602,7 +602,15 @@ private static OnlinePlayerStorageEntry BuildEntry(OnlineStorageEntryKey key, by
     /// </summary>
     private sealed class NopEventPublisher : IOnlineEventPublisher
     {
-        /// <inheritdoc />
+        /// <summary>
+        /// 发布在线事件；本桩仅满足存储构造所需的事件出口，持久化测试不关心事件，因此直接丢弃并完成。
+        /// </summary>
+        /// <remarks>
+        /// Publishes an online event; this stub only satisfies the event sink dependency and discards the event, completing immediately.
+        /// </remarks>
+        /// <param name="onlineEvent">待发布的在线事件（被丢弃） / Online event to publish (discarded)</param>
+        /// <param name="cancellationToken">取消令牌（本桩忽略） / Cancellation token (ignored by this stub)</param>
+        /// <returns>已完成的任务 / An already completed task</returns>
         public Task PublishAsync(OnlineEvent onlineEvent, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
diff --git a/Tests/GameFrameX.Tests/Online/OnlineMatchSettledLeaderboardProjectorTests.cs b/Tests/GameFrameX.Tests/Online/OnlineMatchSettledLeaderboardProjectorTests.cs
index 86af1283f..1cdd50c13 100644
--- a/Tests/GameFrameX.Tests/Online/OnlineMatchSettledLeaderboardProjectorTests.cs
+++ b/Tests/GameFrameX.Tests/Online/OnlineMatchSettledLeaderboardProjectorTests.cs
@@ -350,13 +350,29 @@ private sealed class TickRoundRecorder : ICapabilitySchedulerObserver
             /// <summary>最近一轮 tick 执行的 job 数（-1 = 尚未完成任何一轮）。</summary>
             public int LastExecutedJobCount = -1;
 
-            /// <inheritdoc />
+            /// <summary>
+            /// 记录失败的调度 job：把 job 名追加到 <c>FailedJobNames</c>，供断言哪些 job 执行失败。
+            /// </summary>
+            /// <remarks>
+            /// Records a failed scheduler job by appending its name to <c>FailedJobNames</c> for assertions.
+            /// </remarks>
+            /// <param name="jobKind">job 类型（本桩忽略） / Job kind (ignored by this stub)</param>
+            /// <param name="jobName">失败的 job 名 / Name of the failed job</param>
+            /// <param name="exception">失败异常（本桩忽略） / Failure exception (ignored by this stub)</param>
             public void OnJobFailed(CapabilitySchedulerJobKind jobKind, string jobName, Exception exception)
             {
                 FailedJobNames.Add(jobName);
             }
 
-            /// <inheritdoc />
+            /// <summary>
+            /// 记录一轮 tick 完成：保存本轮执行的 job 数到 <c>LastExecutedJobCount</c>，用于断言重投 job 是否已注册。
+            /// </summary>
+            /// <remarks>
+            /// Records a completed tick round by storing the executed job count in <c>LastExecutedJobCount</c>.
+            /// </remarks>
+            /// <param name="elapsed">本轮耗时（本桩忽略） / Round elapsed time (ignored by this stub)</param>
+            /// <param name="executedJobCount">本轮执行的 job 数 / Number of jobs executed in this round</param>
+            /// <param name="failedJobCount">本轮失败的 job 数（本桩忽略） / Number of failed jobs in this round (ignored by this stub)</param>
             public void OnTickRoundCompleted(TimeSpan elapsed, int executedJobCount, int failedJobCount)
             {
                 LastExecutedJobCount = executedJobCount;
diff --git a/Tests/GameFrameX.Tests/Online/OnlineMatchSettlementPipelineTests.cs b/Tests/GameFrameX.Tests/Online/OnlineMatchSettlementPipelineTests.cs
index a7dad1dbf..8634f8272 100644
--- a/Tests/GameFrameX.Tests/Online/OnlineMatchSettlementPipelineTests.cs
+++ b/Tests/GameFrameX.Tests/Online/OnlineMatchSettlementPipelineTests.cs
@@ -367,31 +367,81 @@ public bool FailureEnabled
                 set;
             }
 
-            /// <inheritdoc />
+            /// <summary>
+            /// 查询钱包账户；原样委托给内部真实存储，不受失败注入影响。
+            /// </summary>
+            /// <remarks>
+            /// Finds a wallet account by delegating to the inner real store; unaffected by failure injection.
+            /// </remarks>
+            /// <param name="tenantId">租户标识 / Tenant identifier</param>
+            /// <param name="appId">应用标识 / Application identifier</param>
+            /// <param name="playerId">玩家标识 / Player identifier</param>
+            /// <param name="currencyId">货币标识 / Currency identifier</param>
+            /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+            /// <returns>内部存储返回的钱包账户 / Wallet account returned by the inner store</returns>
             public Task<OnlineWalletAccount> FindWalletAsync(long tenantId, long appId, long playerId, string currencyId, CancellationToken cancellationToken = default)
             {
                 return _inner.FindWalletAsync(tenantId, appId, playerId, currencyId, cancellationToken);
             }
 
-            /// <inheritdoc />
+            /// <summary>
+            /// 查询背包堆叠；原样委托给内部真实存储，不受失败注入影响。
+            /// </summary>
+            /// <remarks>
+            /// Finds an inventory stack by delegating to the inner real store; unaffected by failure injection.
+            /// </remarks>
+            /// <param name="tenantId">租户标识 / Tenant identifier</param>
+            /// <param name="appId">应用标识 / Application identifier</param>
+            /// <param name="playerId">玩家标识 / Player identifier</param>
+            /// <param name="itemId">物品标识 / Item identifier</param>
+            /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+            /// <returns>内部存储返回的背包堆叠 / Inventory stack returned by the inner store</returns>
             public Task<OnlineInventoryStack> FindInventoryAsync(long tenantId, long appId, long playerId, string itemId, CancellationToken cancellationToken = default)
             {
                 return _inner.FindInventoryAsync(tenantId, appId, playerId, itemId, cancellationToken);
             }
 
-            /// <inheritdoc />
+            /// <summary>
+            /// 列出玩家全部钱包账户；原样委托给内部真实存储。
+            /// </summary>
+            /// <remarks>
+            /// Lists all wallet accounts of the player by delegating to the inner real store.
+            /// </remarks>
+            /// <param name="tenantId">租户标识 / Tenant identifier</param>
+            /// <param name="appId">应用标识 / Application identifier</param>
+            /// <param name="playerId">玩家标识 / Player identifier</param>
+            /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+            /// <returns>内部存储返回的钱包账户集合 / Wallet accounts returned by the inner store</returns>
             public Task<IReadOnlyList<OnlineWalletAccount>> ListWalletAccountsAsync(long tenantId, long appId, long playerId, CancellationToken cancellationToken = default)
             {
                 return _inner.ListWalletAccountsAsync(tenantId, appId, playerId, cancellationToken);
             }
 
-            /// <inheritdoc />
+            /// <summary>
+            /// 列出玩家全部背包堆叠；原样委托给内部真实存储。
+            /// </summary>
+            /// <remarks>
+            /// Lists all inventory stacks of the player by delegating to the inner real store.
+            /// </remarks>
+            /// <param name="tenantId">租户标识 / Tenant identifier</param>
+            /// <param name="appId">应用标识 / Application identifier</param>
+            /// <param name="playerId">玩家标识 / Player identifier</param>
+            /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+            /// <returns>内部存储返回的背包堆叠集合 / Inventory stacks returned by the inner store</returns>
             public Task<IReadOnlyList<OnlineInventoryStack>> ListInventoryStacksAsync(long tenantId, long appId, long playerId, CancellationToken cancellationToken = default)
             {
                 return _inner.ListInventoryStacksAsync(tenantId, appId, playerId, cancellationToken);
             }
 
-            /// <inheritdoc />
+            /// <summary>
+            /// 应用资产变更批次；开启 <c>FailureEnabled</c> 时不触达内部存储，直接返回 <c>InternalError</c> 失败结果（无流水），否则委托给内部真实存储。
+            /// </summary>
+            /// <remarks>
+            /// Applies an asset change batch; when <c>FailureEnabled</c> is set it returns an injected <c>InternalError</c> failure with no ledger entries, otherwise delegates to the inner store.
+            /// </remarks>
+            /// <param name="batch">资产变更批次 / Asset change batch</param>
+            /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+            /// <returns>注入的失败结果或内部存储的应用结果 / Injected failure result or the inner store's apply result</returns>
             public Task<OnlineAssetApplyResult> ApplyAsync(OnlineAssetChangeBatch batch, CancellationToken cancellationToken = default)
             {
                 if (FailureEnabled)
@@ -402,25 +452,60 @@ public Task<OnlineAssetApplyResult> ApplyAsync(OnlineAssetChangeBatch batch, Can
                 return _inner.ApplyAsync(batch, cancellationToken);
             }
 
-            /// <inheritdoc />
+            /// <summary>
+            /// 分页查询资产流水；原样委托给内部真实存储。
+            /// </summary>
+            /// <remarks>
+            /// Queries ledger entries page by page by delegating to the inner real store.
+            /// </remarks>
+            /// <param name="query">流水分页查询条件 / Ledger page query</param>
+            /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+            /// <returns>内部存储返回的流水集合 / Ledger entries returned by the inner store</returns>
             public Task<IReadOnlyList<OnlineLedgerEntry>> ListLedgerEntriesAsync(OnlineLedgerPageQuery query, CancellationToken cancellationToken = default)
             {
                 return _inner.ListLedgerEntriesAsync(query, cancellationToken);
             }
 
-            /// <inheritdoc />
+            /// <summary>
+            /// 按事务标识查询资产流水；原样委托给内部真实存储，供断言注入失败后未落流水。
+            /// </summary>
+            /// <remarks>
+            /// Finds ledger entries by transaction identifier by delegating to the inner real store.
+            /// </remarks>
+            /// <param name="transactionId">事务标识 / Transaction identifier</param>
+            /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+            /// <returns>内部存储返回的流水集合 / Ledger entries returned by the inner store</returns>
             public Task<IReadOnlyList<OnlineLedgerEntry>> FindLedgerEntriesByTransactionIdAsync(string transactionId, CancellationToken cancellationToken = default)
             {
                 return _inner.FindLedgerEntriesByTransactionIdAsync(transactionId, cancellationToken);
             }
 
-            /// <inheritdoc />
+            /// <summary>
+            /// 按资产汇总玩家流水增量；原样委托给内部真实存储。
+            /// </summary>
+            /// <remarks>
+            /// Sums the player's ledger deltas per asset by delegating to the inner real store.
+            /// </remarks>
+            /// <param name="tenantId">租户标识 / Tenant identifier</param>
+            /// <param name="appId">应用标识 / Application identifier</param>
+            /// <param name="playerId">玩家标识 / Player identifier</param>
+            /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+            /// <returns>资产标识到增量合计的映射 / Mapping from asset identifier to summed delta</returns>
             public Task<IReadOnlyDictionary<string, long>> SumLedgerDeltasByAssetAsync(long tenantId, long appId, long playerId, CancellationToken cancellationToken = default)
             {
                 return _inner.SumLedgerDeltasByAssetAsync(tenantId, appId, playerId, cancellationToken);
             }
 
-            /// <inheritdoc />
+            /// <summary>
+            /// 列出拥有资产记录的玩家标识；原样委托给内部真实存储。
+            /// </summary>
+            /// <remarks>
+            /// Lists player identifiers that have asset records by delegating to the inner real store.
+            /// </remarks>
+            /// <param name="tenantId">租户标识 / Tenant identifier</param>
+            /// <param name="appId">应用标识 / Application identifier</param>
+            /// <param name="cancellationToken">取消令牌 / Cancellation token</param>
+            /// <returns>内部存储返回的玩家标识集合 / Player identifiers returned by the inner store</returns>
             public Task<IReadOnlyList<long>> ListPlayerIdsAsync(long tenantId, long appId, CancellationToken cancellationToken = default)
             {
                 return _inner.ListPlayerIdsAsync(tenantId, appId, cancellationToken);
diff --git a/Tests/GameFrameX.Tests/Online/OnlineSocialCapabilityPackageTests.cs b/Tests/GameFrameX.Tests/Online/OnlineSocialCapabilityPackageTests.cs
index 01e0bf8a2..84a87275a 100644
--- a/Tests/GameFrameX.Tests/Online/OnlineSocialCapabilityPackageTests.cs
+++ b/Tests/GameFrameX.Tests/Online/OnlineSocialCapabilityPackageTests.cs
@@ -236,7 +236,15 @@ public RejectingModerationHook(string reason)
                 _reason = reason;
             }
 
-            /// <inheritdoc />
+            /// <summary>
+            /// 审核聊天消息；本桩不看消息内容，始终以构造时给定的理由返回拒绝判定，用于验证拒绝路径。
+            /// </summary>
+            /// <remarks>
+            /// Moderates a chat message; this stub ignores the content and always returns a rejection verdict with the configured reason.
+            /// </remarks>
+            /// <param name="message">待审核的聊天消息（本桩忽略） / Chat message to moderate (ignored by this stub)</param>
+            /// <param name="cancellationToken">取消令牌（本桩忽略） / Cancellation token (ignored by this stub)</param>
+            /// <returns>携带固定拒绝理由的拒绝判定 / Rejection verdict carrying the fixed reason</returns>
             public Task<OnlineChatModerationVerdict> CheckAsync(OnlineChatMessage message, CancellationToken cancellationToken = default)
             {
                 return Task.FromResult(OnlineChatModerationVerdict.Reject(_reason));
diff --git a/Tests/GameFrameX.Tests/Online/RockPaperScissorsMatchBridgeTests.cs b/Tests/GameFrameX.Tests/Online/RockPaperScissorsMatchBridgeTests.cs
index 7146dc4cc..a07ee4b2c 100644
--- a/Tests/GameFrameX.Tests/Online/RockPaperScissorsMatchBridgeTests.cs
+++ b/Tests/GameFrameX.Tests/Online/RockPaperScissorsMatchBridgeTests.cs
@@ -377,7 +377,13 @@ public StubScopeProvider(OnlineScope scope)
                 _scope = scope;
             }
 
-            /// <inheritdoc />
+            /// <summary>
+            /// 获取授权作用域；固定返回构造时注入的作用域。
+            /// </summary>
+            /// <remarks>
+            /// Gets the authorized scope; always returns the scope injected at construction.
+            /// </remarks>
+            /// <value>构造时注入的授权作用域 / Authorized scope injected at construction</value>
             public OnlineScope AuthorizedScope
             {
                 get { return _scope; }
@@ -422,7 +428,18 @@ private sealed class StubMatchBridge : IOnlineMatchGameBridge
             /// <summary>最近一次提交出拳值。</summary>
             public int LastSubmitGesture;
 
-            /// <inheritdoc />
+            /// <summary>
+            /// 开局桩：累加 <c>StartCallCount</c> 并记录作用域、房间、局号与玩家集合，固定返回成功的保密视图。
+            /// </summary>
+            /// <remarks>
+            /// Start stub: increments <c>StartCallCount</c>, records scope, room, round and players, and always returns a successful secret view.
+            /// </remarks>
+            /// <param name="scope">授权作用域，记录到 <c>LastStartScope</c> / Authorized scope, recorded to <c>LastStartScope</c></param>
+            /// <param name="roomId">房间标识，记录到 <c>LastStartRoomId</c> / Room identifier, recorded to <c>LastStartRoomId</c></param>
+            /// <param name="round">局号，记录到 <c>LastStartRound</c> / Round number, recorded to <c>LastStartRound</c></param>
+            /// <param name="playerIds">玩家集合，记录到 <c>LastStartPlayerIds</c> / Player identifiers, recorded to <c>LastStartPlayerIds</c></param>
+            /// <param name="cancellationToken">取消令牌（本桩忽略） / Cancellation token (ignored by this stub)</param>
+            /// <returns>成功的保密对局视图 / Successful secret game view</returns>
             public Task<OnlineResult<OnlineMatchBridgeGameView>> StartRoomGameAsync(OnlineScope scope, long roomId, int round, IReadOnlyList<long> playerIds, CancellationToken cancellationToken = default)
             {
                 StartCallCount++;
@@ -433,7 +450,18 @@ public Task<OnlineResult<OnlineMatchBridgeGameView>> StartRoomGameAsync(OnlineSc
                 return Task.FromResult(OnlineResult<OnlineMatchBridgeGameView>.Ok(SecretView()));
             }
 
-            /// <inheritdoc />
+            /// <summary>
+            /// 出拳提交桩：累加 <c>SubmitCallCount</c> 并记录作用域、房间、局号与出拳值，返回 <c>SubmitResult</c> 工厂的结果（可注入失败或异常）。
+            /// </summary>
+            /// <remarks>
+            /// Submit stub: increments <c>SubmitCallCount</c>, records scope, room, round and gesture, and returns the result of the <c>SubmitResult</c> factory.
+            /// </remarks>
+            /// <param name="scope">授权作用域，记录到 <c>LastSubmitScope</c> / Authorized scope, recorded to <c>LastSubmitScope</c></param>
+            /// <param name="roomId">房间标识，记录到 <c>LastSubmitRoomId</c> / Room identifier, recorded to <c>LastSubmitRoomId</c></param>
+            /// <param name="round">局号，记录到 <c>LastSubmitRound</c> / Round number, recorded to <c>LastSubmitRound</c></param>
+            /// <param name="gesture">出拳值，记录到 <c>LastSubmitGesture</c> / Gesture value, recorded to <c>LastSubmitGesture</c></param>
+            /// <param name="cancellationToken">取消令牌（本桩忽略） / Cancellation token (ignored by this stub)</param>
+            /// <returns><c>SubmitResult</c> 工厂产出的结果 / Result produced by the <c>SubmitResult</c> factory</returns>
             public Task<OnlineResult<OnlineMatchBridgeGameView>> SubmitGestureAsync(OnlineScope scope, long roomId, int round, int gesture, CancellationToken cancellationToken = default)
             {
                 SubmitCallCount++;
@@ -444,7 +472,17 @@ public Task<OnlineResult<OnlineMatchBridgeGameView>> SubmitGestureAsync(OnlineSc
                 return Task.FromResult(SubmitResult());
             }
 
-            /// <inheritdoc />
+            /// <summary>
+            /// 查询对局信息桩：不记录调用，固定返回成功的保密视图。
+            /// </summary>
+            /// <remarks>
+            /// Game info stub: records nothing and always returns a successful secret view.
+            /// </remarks>
+            /// <param name="scope">授权作用域（本桩忽略） / Authorized scope (ignored by this stub)</param>
+            /// <param name="roomId">房间标识（本桩忽略） / Room identifier (ignored by this stub)</param>
+            /// <param name="round">局号（本桩忽略） / Round number (ignored by this stub)</param>
+            /// <param name="cancellationToken">取消令牌（本桩忽略） / Cancellation token (ignored by this stub)</param>
+            /// <returns>成功的保密对局视图 / Successful secret game view</returns>
             public Task<OnlineResult<OnlineMatchBridgeGameView>> GetGameInfoAsync(OnlineScope scope, long roomId, int round, CancellationToken cancellationToken = default)
             {
                 return Task.FromResult(OnlineResult<OnlineMatchBridgeGameView>.Ok(SecretView()));