agent: unify listening and dialing with directed mutual measurements

Replace Probe with Agent across node runtime, Fleet contracts, backend state, API and storage. Report incoming sessions and outgoing link health through each Agent uplink, and retain directed link controls and retry.

Update protocol fixtures and end-to-end coverage for the unified model; accept requested cancellation during the Fleet timeout test cleanup.

backend/shared/MoShiro.Measurement/Blocks/BlockCatalog.cs

@@ -3,7 +3,7 @@ using MoShiro.Protocol;
 namespace MoShiro.Measurement;
 
 /// <summary>
-/// 一种采集方法（Kind）的两个角色：拨号方（Probe）和监听方（Agent），以及它能不能作为目标任务（Agent 自己探测一个地址，没有对端）运行。
+/// 一种采集方法（Kind）的两个角色：拨号方和监听方，以及它能不能作为目标任务（节点自己探测一个地址，没有对端）运行。
 /// 积木只按机制命名、只产生原始列，不知道上层的方案或协议。
 /// </summary>
 public sealed record BlockPair(
@@ -19,7 +19,7 @@ public sealed record BlockPair(
 }
 
 /// <summary>
-/// 积木目录：新增一种采集方法 = 在 <see cref="Kinds"/> 里加一条声明，在这里加一行，实现它的两个角色。Probe 和 Agent 同时获得。
+/// 积木目录：新增一种采集方法 = 在 <see cref="Kinds"/> 里加一条声明，在这里加一行，实现它的两个角色。所有节点同时获得。
 /// hello 里上报的 capabilities、本地预算检查的支持列表都从这里推出来，不再手写。
 /// </summary>
 public static class BlockCatalog
@@ -37,9 +37,12 @@ public static class BlockCatalog
 
     public static BlockPair? Find(string kind) => All.FirstOrDefault(p => p.Kind == kind);
 
-    /// <summary>这个构建的 Agent 能运行的 Kind（监听方，或目标任务）。</summary>
+    /// <summary>不监听的节点能运行的 Kind：只有目标任务（节点自己探测一个地址）。</summary>
+    public static IReadOnlyList<string> TargetKinds { get; } = [.. All.Where(p => p.RunsAsTarget).Select(p => p.Kind)];
+
+    /// <summary>监听的节点能运行的 Kind（监听方，或目标任务）。</summary>
     public static IReadOnlyList<string> AgentKinds { get; } = [.. All.Where(p => p.Listener is not null || p.RunsAsTarget).Select(p => p.Kind)];
 
-    /// <summary>这个构建的 Probe 能运行的 Kind（有监听方可以配对的拨号方）。</summary>
-    public static IReadOnlyList<string> ProbeKinds { get; } = [.. All.Where(p => p.Listener is not null).Select(p => p.Kind)];
+    /// <summary>这个构建能作为拨号方运行的 Kind（有监听方可以配对的拨号方）。</summary>
+    public static IReadOnlyList<string> DialerKinds { get; } = [.. All.Where(p => p.Listener is not null).Select(p => p.Kind)];
 }

backend/shared/MoShiro.Measurement/Blocks/Bulk.cs

@@ -56,8 +56,8 @@ internal static class BulkIo
 }
 
 /// <summary>
-/// 批量传输，拨号方（Probe）：开 <c>streams</c> 条 TCP 连接（可选 TLS），按 <c>direction</c> 发送（fwd）或接收（rev），持续 <c>duration_s</c>。
-/// 记录每个采样间隔每条连接的<b>累计字节数</b>（<c>bytes</c> 流，Probe 的时钟），Backend 据此求每个间隔的吞吐；
+/// 批量传输，拨号方：开 <c>streams</c> 条 TCP 连接（可选 TLS），按 <c>direction</c> 发送（fwd）或接收（rev），持续 <c>duration_s</c>。
+/// 记录每个采样间隔每条连接的<b>累计字节数</b>（<c>bytes</c> 流，拨号方 的时钟），Backend 据此求每个间隔的吞吐；
 /// 同时采样第一条连接自己这一侧的内核 <c>tcp_info</c>（多条连接的累计计数器不能混在同一个序列里求差）。
 /// 发送速率不超过本地上限 <see cref="BlockEnv.MaxBulkMbps"/>。
 /// </summary>
@@ -76,8 +76,8 @@ public sealed class TcpBulkDialer : BlockBase
         : base(env, spec)
     {
         long expectedRows = spec.Int("streams") * spec.Int("duration_s") * Math.Max(1, 1000 / Math.Max(1, spec.Int("sample_ms")));
-        _log = new DriverLog(spec.Kind.FindStream("bytes")!, Side.Probe, (int)Math.Clamp(expectedRows + 256, 1024, 262_144));
-        _info = new TcpInfoRecorder(spec.Kind.FindStream("tcp_info")!, Side.Probe, env.Clock);
+        _log = new DriverLog(spec.Kind.FindStream("bytes")!, Side.Dialer, (int)Math.Clamp(expectedRows + 256, 1024, 262_144));
+        _info = new TcpInfoRecorder(spec.Kind.FindStream("tcp_info")!, Side.Dialer, env.Clock);
         _ts = _log.Store.ColumnIndex("ts");
         _conn = _log.Store.ColumnIndex("conn");
         _bytes = _log.Store.ColumnIndex("bytes");
@@ -211,7 +211,7 @@ public sealed class TcpBulkDialer : BlockBase
 }
 
 /// <summary>
-/// 批量传输，监听方（Agent）：接受连接，<c>rev</c> 时向 Probe 发送（受本地码率上限约束），<c>fwd</c> 时接收并丢弃；
+/// 批量传输，监听方：接受连接，<c>rev</c> 时向 拨号方 发送（受本地码率上限约束），<c>fwd</c> 时接收并丢弃；
 /// 采样第一条连接自己这一侧的内核 <c>tcp_info</c>（Agent 的重传反映下行方向，代理场景里大流量走这个方向）。
 /// 连接在 <c>duration_s</c> 之后（加几秒余量）或阶段结束时关闭。
 /// </summary>
@@ -224,7 +224,7 @@ public sealed class TcpBulkListener : BlockBase
     public TcpBulkListener(BlockEnv env, BlockSpec spec)
         : base(env, spec)
     {
-        _info = new TcpInfoRecorder(spec.Kind.FindStream("tcp_info")!, Side.Agent, env.Clock);
+        _info = new TcpInfoRecorder(spec.Kind.FindStream("tcp_info")!, Side.Listener, env.Clock);
     }
 
     public override RowStore? Records(string streamName) => streamName == "tcp_info" ? _info.Rows : null;

backend/shared/MoShiro.Measurement/Blocks/Echo.cs

@@ -34,7 +34,7 @@ internal sealed class EchoRows
         _graceUs = graceUs;
         _settleOnReply = settleOnReply;
         StreamSpec spec = kind.FindStream("msg")!;
-        _log = new DriverLog(spec, Side.Probe, capacity);
+        _log = new DriverLog(spec, Side.Dialer, capacity);
         _size = _log.Store.ColumnIndex("size");
         _t1 = _log.Store.ColumnIndex("t1");
         _t4 = _log.Store.ColumnIndex("t4");
@@ -76,7 +76,7 @@ internal sealed class EchoRows
 }
 
 /// <summary>
-/// UDP 回显，拨号方（Probe）：按声明的速率发包，t1 在发出时记录，回复到达时回填 t4。回复丢失的行 t4 缺失（Agent 一侧再补 t2/t3）。
+/// UDP 回显，拨号方：按声明的速率发包，t1 在发出时记录，回复到达时回填 t4。回复丢失的行 t4 缺失（Agent 一侧再补 t2/t3）。
 /// </summary>
 public sealed class DatagramEchoDialer : BlockBase
 {
@@ -163,7 +163,7 @@ public sealed class DatagramEchoDialer : BlockBase
     }
 }
 
-/// <summary>UDP 回显，监听方（Agent）：校验后立即回复一个等长的包，记录 t2（到达）和 t3（回复发出），按序号留给合并。</summary>
+/// <summary>UDP 回显，监听方：校验后立即回复一个等长的包，记录 t2（到达）和 t3（回复发出），按序号留给合并。</summary>
 public sealed class DatagramEchoListener : BlockBase
 {
     private readonly RowStore _records;
@@ -171,7 +171,7 @@ public sealed class DatagramEchoListener : BlockBase
     public DatagramEchoListener(BlockEnv env, BlockSpec spec)
         : base(env, spec)
     {
-        _records = new RowStore(spec.Kind.FindStream("msg")!, Side.Agent, 32768);
+        _records = new RowStore(spec.Kind.FindStream("msg")!, Side.Listener, 32768);
     }
 
     public override RowStore? Records(string streamName) => streamName == "msg" ? _records : null;
@@ -216,7 +216,7 @@ public sealed class TcpEchoDialer : BlockBase
         : base(env, spec)
     {
         _rows = new EchoRows(spec.Kind, 16384, EchoRows.TcpGraceUs, settleOnReply: true);
-        _info = new TcpInfoRecorder(spec.Kind.FindStream("tcp_info")!, Side.Probe, env.Clock);
+        _info = new TcpInfoRecorder(spec.Kind.FindStream("tcp_info")!, Side.Dialer, env.Clock);
     }
 
     public override long Produced => _rows.Count;
@@ -341,8 +341,8 @@ public sealed class TcpEchoListener : BlockBase
     public TcpEchoListener(BlockEnv env, BlockSpec spec, bool record = true)
         : base(env, spec)
     {
-        _records = record ? new RowStore(spec.Kind.FindStream("msg")!, Side.Agent, 32768) : null;
-        _info = record ? new TcpInfoRecorder(spec.Kind.FindStream("tcp_info")!, Side.Agent, env.Clock) : null;
+        _records = record ? new RowStore(spec.Kind.FindStream("msg")!, Side.Listener, 32768) : null;
+        _info = record ? new TcpInfoRecorder(spec.Kind.FindStream("tcp_info")!, Side.Listener, env.Clock) : null;
     }
 
     public override RowStore? Records(string streamName) => streamName switch

backend/shared/MoShiro.Measurement/Blocks/Session.cs

@@ -19,7 +19,7 @@ public sealed class IdleListener : BlockBase
 
 /// <summary>
 /// 反复建立连接（TCP，可选 TLS）并记录每个阶段的耗时和结果。结果编码与 Backend 的 <c>ConnectOutcome</c> 一致：
-/// 0 成功、1 超时、2 被重置或拒绝、3 TLS 告警、4 其他。拨号方是 Probe 时对端是 Agent（按指纹固定证书，建好连接即关闭）；
+/// 0 成功、1 超时、2 被重置或拒绝、3 TLS 告警、4 其他。拨号方连接监听方时（按指纹固定证书，建好连接即关闭）；
 /// 作为目标任务在 Agent 上运行时对端是任意地址（不校验证书，只测握手耗时）。
 /// </summary>
 public sealed class ConnectDialer : BlockBase
@@ -34,7 +34,7 @@ public sealed class ConnectDialer : BlockBase
     public ConnectDialer(BlockEnv env, BlockSpec spec)
         : base(env, spec)
     {
-        _log = new DriverLog(spec.Kind.FindStream("conn")!, Side.Probe, 1024);
+        _log = new DriverLog(spec.Kind.FindStream("conn")!, Side.Dialer, 1024);
         _attempt = _log.Store.ColumnIndex("attempt");
         _ts = _log.Store.ColumnIndex("ts");
         _tcp = _log.Store.ColumnIndex("tcp_us");
@@ -147,7 +147,7 @@ public sealed class HoldDialer : BlockBase
     public HoldDialer(BlockEnv env, BlockSpec spec)
         : base(env, spec)
     {
-        _log = new DriverLog(spec.Kind.FindStream("hold")!, Side.Probe, 1024);
+        _log = new DriverLog(spec.Kind.FindStream("hold")!, Side.Dialer, 1024);
         _ts = _log.Store.ColumnIndex("ts");
         _event = _log.Store.ColumnIndex("event");
         _lifetime = _log.Store.ColumnIndex("lifetime_ms");
@@ -293,7 +293,7 @@ public sealed class IcmpEchoSolo : BlockBase
     public IcmpEchoSolo(BlockEnv env, BlockSpec spec)
         : base(env, spec)
     {
-        _log = new DriverLog(spec.Kind.FindStream("msg")!, Side.Probe, 1024);
+        _log = new DriverLog(spec.Kind.FindStream("msg")!, Side.Dialer, 1024);
         _seq = _log.Store.ColumnIndex("seq");
         _size = _log.Store.ColumnIndex("size");
         _t1 = _log.Store.ColumnIndex("t1");

backend/shared/MoShiro.Measurement/Blocks/Train.cs

@@ -7,7 +7,7 @@ namespace MoShiro.Measurement;
 
 /// <summary>
 /// 单向数据流（UDP train），监听方（Agent，行的主导方）：按声明的码率均匀发包，发出的每个包 (seq, size, t_send) 记在按序号的记录里，
-/// Probe 的接收时刻之后按序号合并（没有到达的就是丢失）。发送在专用线程上完成，不占用线程池。
+/// 拨号方 的接收时刻之后按序号合并（没有到达的就是丢失）。发送在专用线程上完成，不占用线程池。
 /// 等不到对端的地址（5 秒内没有任何认证过的包）就以 <see cref="BlockFaultException"/> 结束。
 /// </summary>
 public sealed class TrainListener : BlockBase
@@ -21,7 +21,7 @@ public sealed class TrainListener : BlockBase
         : base(env, spec)
     {
         double pps = spec.Params.GetNumber("mbps") * 1_000_000 / 8 / Math.Max(1, spec.Int("size"));
-        _records = new RowStore(spec.Kind.FindStream("pkt")!, Side.Agent, (int)Math.Clamp(pps * spec.Int("duration_s") * 1.25, 1024, 4_000_000));
+        _records = new RowStore(spec.Kind.FindStream("pkt")!, Side.Listener, (int)Math.Clamp(pps * spec.Int("duration_s") * 1.25, 1024, 4_000_000));
     }
 
     public override long Produced => Interlocked.Read(ref _sent);
@@ -30,7 +30,7 @@ public sealed class TrainListener : BlockBase
 
     public override async Task RunAsync(CancellationToken ct)
     {
-        // Probe 开始前发来的探活包（Data）要被接受，准入策略才能据此学到它当前的源地址（NAT 映射）；它们本身没有内容
+        // 拨号方 开始前发来的探活包（Data）要被接受，准入策略才能据此学到它当前的源地址（NAT 映射）；它们本身没有内容
         Env.Datagrams!.Register(Spec.StreamId, static (in QuicDatagramDelivery _) => { });
         try
         {
@@ -138,7 +138,7 @@ public sealed class TrainListener : BlockBase
 }
 
 /// <summary>
-/// 单向数据流，拨号方（Probe，行的跟随方）：接收，记录每个序号第一次到达的时刻（按序号索引，热路径不分配）；
+/// 单向数据流，拨号方（行的跟随方）：接收，记录每个序号第一次到达的时刻（按序号索引，热路径不分配）；
 /// 序号超过本地包速率上限推算出的范围时忽略。阶段结束时按序号范围切成多个列块交给 Agent，每块不超过 <see cref="ProtocolLimits.MaxRecordsPerChunk"/> 的记录。
 /// 开始时先发几个探活包，让 Agent 学到我们当前的源地址（NAT 映射）再开始发送。
 /// </summary>
@@ -159,9 +159,9 @@ public sealed class TrainDialer : BlockBase
         double pps = spec.Params.GetNumber("mbps") * 1_000_000 / 8 / Math.Max(1, spec.Int("size"));
         long seconds = Math.Max(1, spec.Int("duration_s"));
         _maxSeq = Math.Max(1024, Math.Min((long)(pps * seconds * 1.25), env.MaxPacketsPerSecond * seconds * 3 / 2));
-        _received = new RowStore(spec.Kind.FindStream("pkt")!, Side.Probe, (int)_maxSeq);
+        _received = new RowStore(spec.Kind.FindStream("pkt")!, Side.Dialer, (int)_maxSeq);
         _tRecv = _received.ColumnIndex("t_recv");
-        _step = new RowStore(spec.Kind.FindStream("step")!, Side.Probe, 16);
+        _step = new RowStore(spec.Kind.FindStream("step")!, Side.Dialer, 16);
     }
 
     public override async Task RunAsync(CancellationToken ct)