backend: serve single-agent task templates with their status and results, rename the kinds in storage

backend/tests/MoShiro.Backend.Tests/AgentDataPlaneTests.cs

@@ -22,8 +22,8 @@ public sealed class AgentDataPlaneTests : IClassFixture<BackendFixture>
         AgentHarness agent = await AgentHarness.StartAsync(_backend);
         await agent.OverrideLineTasksAsync(rateHz: 30);
         DialerSimulator dialer = await agent.ConnectDialerAsync();
-        LineTaskSet set = await dialer.WaitForTasksAsync(s => s.Tasks.Any(t => t.Kind == "udp_echo" && t.Port == agent.App.QuicPorts[0]));
-        return (agent, dialer, set.Tasks.Single(t => t.Kind == "udp_echo"));
+        LineTaskSet set = await dialer.WaitForTasksAsync(s => s.Tasks.Any(t => t.Kind == "quic_ping" && t.Port == agent.App.QuicPorts[0]));
+        return (agent, dialer, set.Tasks.Single(t => t.Kind == "quic_ping"));
     }
 
     [Fact]

backend/tests/MoShiro.Backend.Tests/AgentEndToEndTests.cs

@@ -23,8 +23,8 @@ public sealed class AgentEndToEndTests : IClassFixture<BackendFixture>
         AgentHarness agent = await AgentHarness.StartAsync(_backend);
         await agent.OverrideLineTasksAsync(rateHz: 30);
         DialerSimulator dialer = await agent.ConnectDialerAsync();
-        LineTaskSet set = await dialer.WaitForTasksAsync(s => s.Tasks.Any(t => t.Kind == "udp_echo" && t.Port == agent.App.QuicPorts[0]));
-        return (agent, dialer, set.Tasks.Single(t => t.Kind == "udp_echo"));
+        LineTaskSet set = await dialer.WaitForTasksAsync(s => s.Tasks.Any(t => t.Kind == "quic_ping" && t.Port == agent.App.QuicPorts[0]));
+        return (agent, dialer, set.Tasks.Single(t => t.Kind == "quic_ping"));
     }
 
     private async Task<JsonNode> AgentViewAsync(AgentHarness agent) => await _backend.GetJsonAsync(_backend.Admin, "/api/admin/agents/" + agent.Id);
@@ -61,7 +61,7 @@ public sealed class AgentEndToEndTests : IClassFixture<BackendFixture>
             }, because: (await _backend.GetJsonAsync(_backend.Admin, $"/api/admin/events?agent_id={agent.Id}")).ToJsonString() + $" fragments={agent.App.Counters.Fragments} discarded={agent.App.Counters.FragmentsDiscarded} outbox={agent.App.Link.Outbox.PendingCount}");
             JsonNode chunk = stored["items"]![0]!;
             Assert.True(chunk["kind"] is not null, stored.ToJsonString());
-            Assert.Equal("udp_echo", chunk["kind"]!.GetValue<string>());
+            Assert.Equal("quic_ping", chunk["kind"]!.GetValue<string>());
             Assert.True(agent.App.Counters.Fragments >= 1);
             Assert.True(agent.App.Counters.PacketsIn >= 40);
         }
@@ -76,11 +76,11 @@ public sealed class AgentEndToEndTests : IClassFixture<BackendFixture>
         await using (agent)
         await using (dialer)
         {
-            LineTask tcp = (await dialer.WaitForTasksAsync(s => s.Tasks.Any(t => t.Kind == "tcp_echo" && t.Port == agent.App.TcpPorts[0]))).Tasks.Single(t => t.Kind == "tcp_echo");
+            LineTask tcp = (await dialer.WaitForTasksAsync(s => s.Tasks.Any(t => t.Kind == "tcp_ping" && t.Port == agent.App.TcpPorts[0]))).Tasks.Single(t => t.Kind == "tcp_ping");
             (int sent, int received) = await dialer.RunTcpEchoAsync(tcp, agent.App.TcpPorts[0], 15, TimeSpan.FromMilliseconds(60), tls);
             Assert.Equal(15, sent);
             Assert.Equal(15, received);
-            await BackendFixture.EventuallyAsync(async () => (await _backend.GetJsonAsync(_backend.Admin, $"/api/admin/raw/chunks?agent_id={agent.Id}"))["items"]!.AsArray().Any(c => c!["kind"]!.GetValue<string>() == "tcp_echo"));
+            await BackendFixture.EventuallyAsync(async () => (await _backend.GetJsonAsync(_backend.Admin, $"/api/admin/raw/chunks?agent_id={agent.Id}"))["items"]!.AsArray().Any(c => c!["kind"]!.GetValue<string>() == "tcp_ping"));
         }
     }
 
@@ -98,8 +98,8 @@ public sealed class AgentEndToEndTests : IClassFixture<BackendFixture>
             // The dialer process restarts: a new session with its own streams; sequence numbers start from 0 again
             await using DialerSimulator second = first.Restarted();
             await second.ConnectAsync("127.0.0.1", agent.App.ControlPort, agent.TlsPublicKey, agent.App.QuicPorts[0], agent.NodeId);
-            LineTaskSet set = await second.WaitForTasksAsync(s => s.Tasks.Any(t => t.Kind == "udp_echo" && t.Port == agent.App.QuicPorts[0]));
-            LineTask udp2 = set.Tasks.Single(t => t.Kind == "udp_echo");
+            LineTaskSet set = await second.WaitForTasksAsync(s => s.Tasks.Any(t => t.Kind == "quic_ping" && t.Port == agent.App.QuicPorts[0]));
+            LineTask udp2 = set.Tasks.Single(t => t.Kind == "quic_ping");
             Assert.NotEqual(udp.StreamId, udp2.StreamId);
 
             // The previous session's streams are released with it ...
@@ -135,9 +135,9 @@ public sealed class AgentEndToEndTests : IClassFixture<BackendFixture>
         Assert.Equal(agent.Id, dialerView["outgoing"]![0]!["listener_id"]!.GetValue<string>());
 
         // Both get their own task set (own streams)
-        LineTaskSet setA = await a.WaitForTasksAsync(s => s.Tasks.Any(t => t.Kind == "udp_echo"));
-        LineTaskSet setB = await b.WaitForTasksAsync(s => s.Tasks.Any(t => t.Kind == "udp_echo"));
-        Assert.NotEqual(setA.Tasks.Single(t => t.Kind == "udp_echo").StreamId, setB.Tasks.Single(t => t.Kind == "udp_echo").StreamId);
+        LineTaskSet setA = await a.WaitForTasksAsync(s => s.Tasks.Any(t => t.Kind == "quic_ping"));
+        LineTaskSet setB = await b.WaitForTasksAsync(s => s.Tasks.Any(t => t.Kind == "quic_ping"));
+        Assert.NotEqual(setA.Tasks.Single(t => t.Kind == "quic_ping").StreamId, setB.Tasks.Single(t => t.Kind == "quic_ping").StreamId);
 
         // Drop one: the other stays
         using HttpResponseMessage dropped = await _backend.Admin.PostAsync($"/api/admin/agents/{agent.Id}/dialers/{a.DialerId}/disconnect", null);
@@ -172,7 +172,7 @@ public sealed class AgentEndToEndTests : IClassFixture<BackendFixture>
         await using AgentHarness agent = await AgentHarness.StartAsync(_backend, config => config.Limits.MaxTotalMbps = 20);
         await agent.OverrideLineTasksAsync();
 
-        var phase = new TestPhase { Kind = "udp_train", DurationSeconds = 1, Params = { ["port"] = System.Text.Json.JsonSerializer.SerializeToElement(agent.App.QuicPorts[0]) } };
+        var phase = new TestPhase { Kind = "quic_stream", DurationSeconds = 1, Params = { ["port"] = System.Text.Json.JsonSerializer.SerializeToElement(agent.App.QuicPorts[0]) } };
         var run = new TestRunParams { TestId = new TestId("tst_x"), DialerId = new NodeId("agt_nobody"), Plan = "x", Phases = [phase] };
         Assert.Equal("dialer_offline", agent.App.Tests.Start(run).Error.Code.Value);
 

backend/tests/MoShiro.Backend.Tests/AgentHarness.cs

@@ -105,19 +105,19 @@ public sealed class AgentHarness : IAsyncDisposable
     public async Task OverrideLineTasksAsync(int? rateHz = null)
     {
         JsonNode tasks = await Backend.GetJsonAsync(Backend.Admin, "/api/admin/tasks");
-        // 先处理 connect（关掉），再改 udp_echo / tcp_echo 的速率：否则中途的带宽预算会多出 connect 那一份
-        foreach (JsonNode? task in tasks["items"]!.AsArray().OrderBy(t => t!["kind"]!.GetValue<string>() == "connect" ? 0 : 1))
+        // 先处理 connect（关掉），再改 quic_ping / tcp_ping 的速率：否则中途的带宽预算会多出 connect 那一份
+        foreach (JsonNode? task in tasks["items"]!.AsArray().OrderBy(t => t!["kind"]!.GetValue<string>() == "tcp_connect" ? 0 : 1))
         {
-            if (task!["scope"]!.GetValue<string>() != "line" || task["agent_id"] is not null || task["kind"]!.GetValue<string>() is not ("udp_echo" or "tcp_echo" or "connect"))
+            if (task!["scope"]!.GetValue<string>() != "line" || task["agent_id"] is not null || task["kind"]!.GetValue<string>() is not ("quic_ping" or "tcp_ping" or "tcp_connect"))
             {
                 continue;
             }
 
             string kind = task["kind"]!.GetValue<string>();
-            var parameters = new JsonObject { ["port"] = kind == "udp_echo" ? App.QuicPorts[0] : App.TcpPorts[0] };
+            var parameters = new JsonObject { ["port"] = kind == "quic_ping" ? App.QuicPorts[0] : App.TcpPorts[0] };
             // 默认的 connect 模板在这些用例里不需要（也占预算）：对这个 Agent 关掉它
-            bool enabled = kind != "connect";
-            if (rateHz is { } hz && kind != "connect")
+            bool enabled = kind != "tcp_connect";
+            if (rateHz is { } hz && kind != "tcp_connect")
             {
                 parameters["adaptive"] = false; // 固定频率：用例按这个速率发包，限速也按它算
                 parameters["rate_hz"] = hz;

backend/tests/MoShiro.Backend.Tests/AgentMeshTests.cs

@@ -41,7 +41,7 @@ public sealed class AgentMeshTests : IClassFixture<BackendFixture>
         await BackendFixture.EventuallyAsync(async () =>
         {
             JsonNode chunks = await _backend.GetJsonAsync(_backend.Admin, $"/api/admin/raw/chunks?agent_id={listener.Id}");
-            return chunks["items"]!.AsArray().Any(c => c!["kind"]!.GetValue<string>() == "udp_echo" && c["series"]!.GetValue<string>() == "line:" + dialer.Id);
+            return chunks["items"]!.AsArray().Any(c => c!["kind"]!.GetValue<string>() == "quic_ping" && c["series"]!.GetValue<string>() == "line:" + dialer.Id);
         }, TimeSpan.FromSeconds(40), "the line should persist measured packet data");
     }
 }

backend/tests/MoShiro.Backend.Tests/AgentTaskSetEndToEndTests.cs

@@ -22,15 +22,15 @@ public sealed class AgentTaskSetEndToEndTests : IClassFixture<BackendFixture>
         await using AgentHarness agent = await AgentHarness.StartAsync(_backend);
         await agent.OverrideLineTasksAsync(rateHz: 30);
         await using DialerSimulator dialer = await agent.ConnectDialerAsync();
-        LineTask udp = (await dialer.WaitForTasksAsync(s => s.Tasks.Any(t => t.Kind == "udp_echo" && t.Port == agent.App.QuicPorts[0])))
-            .Tasks.Single(t => t.Kind == "udp_echo");
+        LineTask udp = (await dialer.WaitForTasksAsync(s => s.Tasks.Any(t => t.Kind == "quic_ping" && t.Port == agent.App.QuicPorts[0])))
+            .Tasks.Single(t => t.Kind == "quic_ping");
 
         JsonNode tasks = await _backend.GetJsonAsync(_backend.Admin, "/api/admin/tasks");
-        JsonNode mine = tasks["items"]!.AsArray().Single(t => t!["agent_id"]?.GetValue<string>() == agent.Id && t["kind"]!.GetValue<string>() == "udp_echo")!;
+        JsonNode mine = tasks["items"]!.AsArray().Single(t => t!["agent_id"]?.GetValue<string>() == agent.Id && t["kind"]!.GetValue<string>() == "quic_ping")!;
         using HttpResponseMessage disabled = await _backend.Admin.PatchAsync("/api/admin/tasks/" + mine["id"]!.GetValue<string>(), BackendFixture.Json(new JsonObject { ["enabled"] = false }, "application/merge-patch+json"));
         disabled.EnsureSuccessStatusCode();
 
-        LineTaskSet next = await dialer.WaitForTasksAsync(s => s.Tasks.All(t => t.Kind != "udp_echo") && s.Version > 0);
+        LineTaskSet next = await dialer.WaitForTasksAsync(s => s.Tasks.All(t => t.Kind != "quic_ping") && s.Version > 0);
         Assert.DoesNotContain(next.Tasks, t => t.Id == udp.Id);
     }
 }

backend/tests/MoShiro.Backend.Tests/AotSmokeTests.cs

@@ -58,28 +58,28 @@ public sealed class AotSmokeTests
         string lineId = $"{agent.NodeId.Value}~{dialerId}";
         await agent.ConnectAsync(baseAddress);
         TaskSet tasks = await agent.WaitForTaskSetAsync(s => s.Tasks.Count >= 2);
-        Assert.Contains(tasks.Tasks, t => t.Kind == "udp_echo");
+        Assert.Contains(tasks.Tasks, t => t.Kind == "quic_ping");
 
         // 原始块：二进制通道 → 段文件与索引 → ACK
         long minute = 60_000;
         long baseMs = ((TimeProvider.System.GetUtcNow().ToUnixTimeMilliseconds() / minute) - 3) * minute;
         for (int k = 0; k < 6; k++)
         {
-            Assert.True(await agent.SendChunkAsync(ChunkFactory.Echo(agent.NodeId, "udp_echo", baseMs + (k * 10_000L), 100, 100, i => new EchoPacket(false, i % 10 == 0, 20_000, 20_000))));
+            Assert.True(await agent.SendChunkAsync(ChunkFactory.Echo(agent.NodeId, "quic_ping", baseMs + (k * 10_000L), 100, 100, i => new EchoPacket(false, i % 10 == 0, 20_000, 20_000))));
         }
 
         // 查询：热层的精确汇总，随后是持久层的分钟窗口
         string range = $"from={Iso(baseMs)}&to={Iso(baseMs + minute)}&metrics=loss.total,rtt.p95";
         JsonNode hot = await GetAsync(http, $"/api/public/lines/{lineId}/series?{range}&step=1s");
         Assert.Equal("hot", hot["source"]!.GetValue<string>());
-        Assert.Equal(600, hot["summary"]!["samples"]!["udp_echo"]!.GetValue<long>());
+        Assert.Equal(600, hot["summary"]!["samples"]!["quic_ping"]!.GetValue<long>());
         Assert.Equal(10.0, hot["summary"]!["metrics"]!["loss.total"]!.GetValue<double>(), 6);
         long deadline = TimeProvider.System.GetTimestamp();
         JsonNode persisted;
         do
         {
             persisted = await GetAsync(http, $"/api/public/lines/{lineId}/series?{range}&step=1m");
-            if (persisted["summary"]!["samples"]!["udp_echo"]?.GetValue<long>() == 600)
+            if (persisted["summary"]!["samples"]!["quic_ping"]?.GetValue<long>() == 600)
             {
                 break;
             }
@@ -88,7 +88,7 @@ public sealed class AotSmokeTests
         }
         while (TimeProvider.System.GetElapsedTime(deadline) < TimeSpan.FromSeconds(15));
         Assert.Equal("1m", persisted["source"]!.GetValue<string>());
-        Assert.Equal(600, persisted["summary"]!["samples"]!["udp_echo"]!.GetValue<long>());
+        Assert.Equal(600, persisted["summary"]!["samples"]!["quic_ping"]!.GetValue<long>());
 
         // 原始块可以按 ID 下载并解码
         JsonNode chunks = await GetAsync(http, $"/api/admin/raw/chunks?agent_id={agent.NodeId.Value}&limit=1");

backend/tests/MoShiro.Backend.Tests/ApiBasicsTests.cs

@@ -194,7 +194,7 @@ public sealed class ApiBasicsTests : IClassFixture<BackendFixture>
         Assert.Equal(HttpStatusCode.NotModified, notModified.StatusCode);
 
         JsonNode kinds = await _backend.GetJsonAsync(_backend.Anonymous, "/api/public/catalog/kinds");
-        JsonNode udp = kinds["items"]!.AsArray().Single(k => k!["id"]!.GetValue<string>() == "udp_echo")!;
+        JsonNode udp = kinds["items"]!.AsArray().Single(k => k!["id"]!.GetValue<string>() == "quic_ping")!;
         JsonNode rate = udp["params"]!.AsArray().Single(p => p!["name"]!.GetValue<string>() == "rate_hz")!;
         Assert.Equal(1, rate["min"]!.GetValue<int>());
         Assert.Equal(200, rate["max"]!.GetValue<int>());

backend/tests/MoShiro.Backend.Tests/BackendFixture.cs

@@ -11,7 +11,7 @@ using MoShiro.TestSupport;
 
 namespace MoShiro.Backend.Tests;
 
-/// <summary>首次启动种入的默认线路任务模板数：udp_echo、tcp_echo、connect。</summary>
+/// <summary>首次启动种入的默认线路任务模板数：quic_ping、tcp_ping、connect。</summary>
 internal static class Defaults
 {
     public const int TaskCount = 3;

backend/tests/MoShiro.Backend.Tests/DialerEndToEndTests.cs

@@ -59,7 +59,7 @@ public sealed class DialerEndToEndTests : IClassFixture<BackendFixture>
             TimeSpan.FromSeconds(90));
         Assert.True(test["status"]!.GetValue<string>() == "succeeded", test.ToJsonString());
 
-        await BackendFixture.EventuallyAsync(async () => await ChunkCountAsync(agent, "udp_train") >= 5, because: "the 100 Mbit/s phase (5 s of 1000 B packets, over 50000 records) is split into two fragments");
+        await BackendFixture.EventuallyAsync(async () => await ChunkCountAsync(agent, "quic_stream") >= 5, because: "the 100 Mbit/s phase (5 s of 1000 B packets, over 50000 records) is split into two fragments");
         Assert.Equal(0, agent.App.Counters.FragmentsDiscarded);
     }
 
@@ -84,7 +84,7 @@ public sealed class DialerEndToEndTests : IClassFixture<BackendFixture>
             },
             TimeSpan.FromSeconds(150));
         Assert.True(test["status"]!.GetValue<string>() == "succeeded", test.ToJsonString());
-        await BackendFixture.EventuallyAsync(async () => await ChunkCountAsync(agent, "tcp_bulk") >= 1, because: "the bulk phase stores its fragments");
+        await BackendFixture.EventuallyAsync(async () => await ChunkCountAsync(agent, "tcp_transfer") >= 1, because: "the bulk phase stores its fragments");
         Assert.Equal(0, agent.App.Counters.FragmentsDiscarded);
     }
 }

backend/tests/MoShiro.Backend.Tests/EnrollmentAndTaskSetTests.cs

@@ -24,15 +24,15 @@ public sealed class EnrollmentAndTaskSetTests : IClassFixture<BackendFixture>
         Assert.Equal("active", agent.EnrollmentStatus);
         Assert.Equal("active", agent.AuthStatus);
         TaskSet set = await agent.WaitForTaskSetAsync(s => s.Tasks.Count == Defaults.TaskCount);
-        Assert.Equal(["connect", "tcp_echo", "udp_echo"], set.Tasks.Select(t => t.Kind).Order().ToArray());
+        Assert.Equal(["quic_ping", "tcp_connect", "tcp_ping"], set.Tasks.Select(t => t.Kind).Order().ToArray());
         Assert.All(set.Tasks, t =>
         {
             Assert.Equal("line", t.Scope);
             Assert.Equal(TaskSchedule.Continuous, t.Schedule);
             Assert.NotEmpty(t.Params); // 参数已经补全了默认值
         });
-        Assert.Equal(10, set.Tasks.Single(t => t.Kind == "udp_echo").Params["rate_hz"].GetInt64());
-        Assert.Equal(7444, set.Tasks.Single(t => t.Kind == "tcp_echo").Params["port"].GetInt64());
+        Assert.Equal(10, set.Tasks.Single(t => t.Kind == "quic_ping").Params["rate_hz"].GetInt64());
+        Assert.Equal(7444, set.Tasks.Single(t => t.Kind == "tcp_ping").Params["port"].GetInt64());
         Assert.True(set.Version >= 1);
 
         JsonNode view = await AgentAsync(agent.NodeId.Value);
@@ -46,9 +46,9 @@ public sealed class EnrollmentAndTaskSetTests : IClassFixture<BackendFixture>
     [Fact]
     public async Task TaskSet_OnlyContainsKindsTheAgentSupports()
     {
-        await using AgentSimulator agent = await _backend.ConnectAgentAsync(kinds: ["udp_echo"]);
+        await using AgentSimulator agent = await _backend.ConnectAgentAsync(kinds: ["quic_ping"]);
         TaskSet set = await agent.WaitForTaskSetAsync(s => s.Tasks.Count >= 1);
-        Assert.Equal(["udp_echo"], set.Tasks.Select(t => t.Kind).ToArray());
+        Assert.Equal(["quic_ping"], set.Tasks.Select(t => t.Kind).ToArray());
     }
 
     [Fact]
@@ -265,12 +265,12 @@ public sealed class EnrollmentAndTaskSetTests : IClassFixture<BackendFixture>
     {
         await using AgentSimulator agent = await _backend.ConnectAgentAsync();
         TaskSet initial = await agent.WaitForTaskSetAsync(s => s.Tasks.Count == Defaults.TaskCount);
-        TaskSpec udp = initial.Tasks.Single(t => t.Kind == "udp_echo");
+        TaskSpec udp = initial.Tasks.Single(t => t.Kind == "quic_ping");
 
         using HttpResponseMessage created = await _backend.Admin.PostAsync("/api/admin/tasks", BackendFixture.Json(new JsonObject
         {
             ["scope"] = "line",
-            ["kind"] = "udp_echo",
+            ["kind"] = "quic_ping",
             ["agent_id"] = agent.NodeId.Value,
             ["base_task_id"] = udp.Id.Value,
             ["params"] = new JsonObject { ["rate_hz"] = 20 },
@@ -278,15 +278,15 @@ public sealed class EnrollmentAndTaskSetTests : IClassFixture<BackendFixture>
         Assert.Equal(HttpStatusCode.Created, created.StatusCode);
         Assert.StartsWith("/api/admin/tasks/", created.Headers.Location!.ToString());
 
-        TaskSet updated = await agent.WaitForTaskSetAsync(s => s.Version > initial.Version && s.Tasks.Any(t => t.Kind == "udp_echo" && t.Params["rate_hz"].GetInt64() == 20));
+        TaskSet updated = await agent.WaitForTaskSetAsync(s => s.Version > initial.Version && s.Tasks.Any(t => t.Kind == "quic_ping" && t.Params["rate_hz"].GetInt64() == 20));
         Assert.Equal(Defaults.TaskCount, updated.Tasks.Count);
-        Assert.Equal(7443, updated.Tasks.Single(t => t.Kind == "udp_echo").Params["port"].GetInt64());
+        Assert.Equal(7443, updated.Tasks.Single(t => t.Kind == "quic_ping").Params["port"].GetInt64());
 
         // 停用覆盖 → 该 Agent 不再运行这条任务（模板对其他 Agent 不受影响）
         string overrideId = JsonNode.Parse(await created.Content.ReadAsStringAsync())!["id"]!.GetValue<string>();
         using HttpResponseMessage disable = await _backend.Admin.PatchAsync("/api/admin/tasks/" + overrideId, BackendFixture.Json(new JsonObject { ["enabled"] = false }, "application/merge-patch+json"));
         Assert.Equal(HttpStatusCode.OK, disable.StatusCode);
-        TaskSet disabled = await agent.WaitForTaskSetAsync(s => s.Version > updated.Version && s.Tasks.All(t => t.Kind != "udp_echo"));
+        TaskSet disabled = await agent.WaitForTaskSetAsync(s => s.Version > updated.Version && s.Tasks.All(t => t.Kind != "quic_ping"));
         Assert.Equal(Defaults.TaskCount - 1, disabled.Tasks.Count);
     }
 
@@ -295,7 +295,7 @@ public sealed class EnrollmentAndTaskSetTests : IClassFixture<BackendFixture>
     {
         using HttpResponseMessage badParams = await _backend.Admin.PostAsync("/api/admin/tasks", BackendFixture.Json(new JsonObject
         {
-            ["scope"] = "line", ["kind"] = "udp_echo", ["params"] = new JsonObject { ["rate_hz"] = 5000, ["bogus"] = 1 },
+            ["scope"] = "line", ["kind"] = "quic_ping", ["params"] = new JsonObject { ["rate_hz"] = 5000, ["bogus"] = 1 },
         }));
         Assert.Equal(HttpStatusCode.BadRequest, badParams.StatusCode);
         JsonNode problem = JsonNode.Parse(await badParams.Content.ReadAsStringAsync())!;
@@ -308,33 +308,107 @@ public sealed class EnrollmentAndTaskSetTests : IClassFixture<BackendFixture>
 
         using HttpResponseMessage overBudget = await _backend.Admin.PostAsync("/api/admin/tasks", BackendFixture.Json(new JsonObject
         {
-            ["scope"] = "line", ["kind"] = "udp_echo", ["params"] = new JsonObject { ["rate_hz"] = 200, ["size"] = 1400 },
+            ["scope"] = "line", ["kind"] = "quic_ping", ["params"] = new JsonObject { ["rate_hz"] = 200, ["size"] = 1400 },
         }));
         Assert.Equal(HttpStatusCode.BadRequest, overBudget.StatusCode);
         Assert.Equal("budget_exceeded", JsonNode.Parse(await overBudget.Content.ReadAsStringAsync())!["code"]!.GetValue<string>());
 
-        using HttpResponseMessage wrongScope = await _backend.Admin.PostAsync("/api/admin/tasks", BackendFixture.Json(new JsonObject { ["scope"] = "line", ["kind"] = "icmp_echo" }));
+        using HttpResponseMessage wrongScope = await _backend.Admin.PostAsync("/api/admin/tasks", BackendFixture.Json(new JsonObject { ["scope"] = "line", ["kind"] = "icmp_ping" }));
         Assert.Equal(HttpStatusCode.BadRequest, wrongScope.StatusCode);
 
-        // 目标任务：只接受 IP（不做 DNS 解析），需要指定 Agent
+        // 单个 Agent 的任务：目标的格式按 Kind 检查（Backend 不解析域名），需要指定 Agent
         await using AgentSimulator agent = await _backend.ConnectAgentAsync();
-        using HttpResponseMessage dns = await _backend.Admin.PostAsync("/api/admin/tasks", BackendFixture.Json(new JsonObject
+        foreach ((string kind, string badTarget) in new[] { ("icmp_ping", "https://example.com/"), ("icmp_ping", "not a host"), ("http_request", "example.com") })
         {
-            ["scope"] = "target", ["kind"] = "icmp_echo", ["agent_id"] = agent.NodeId.Value, ["target"] = "example.com",
+            using HttpResponseMessage malformed = await _backend.Admin.PostAsync("/api/admin/tasks", BackendFixture.Json(new JsonObject
+            {
+                ["scope"] = "target", ["kind"] = kind, ["agent_id"] = agent.NodeId.Value, ["target"] = badTarget,
+            }));
+            Assert.Equal(HttpStatusCode.BadRequest, malformed.StatusCode);
+        }
+
+        using HttpResponseMessage page = await _backend.Admin.PostAsync("/api/admin/tasks", BackendFixture.Json(new JsonObject
+        {
+            ["scope"] = "target", ["kind"] = "http_request", ["agent_id"] = agent.NodeId.Value, ["target"] = "https://Example.com/health", ["params"] = new JsonObject { ["version"] = "h3" },
         }));
-        Assert.Equal(HttpStatusCode.BadRequest, dns.StatusCode);
+        Assert.Equal(HttpStatusCode.Created, page.StatusCode);
+        Assert.Equal("https://example.com/health", JsonNode.Parse(await page.Content.ReadAsStringAsync())!["target"]!.GetValue<string>());
         using HttpResponseMessage target = await _backend.Admin.PostAsync("/api/admin/tasks", BackendFixture.Json(new JsonObject
         {
-            ["scope"] = "target", ["kind"] = "icmp_echo", ["agent_id"] = agent.NodeId.Value, ["target"] = "1.1.1.1",
+            ["scope"] = "target", ["kind"] = "icmp_ping", ["agent_id"] = agent.NodeId.Value, ["target"] = "1.1.1.1",
         }));
         Assert.Equal(HttpStatusCode.Created, target.StatusCode);
-        TaskSet set = await agent.WaitForTaskSetAsync(s => s.Tasks.Any(t => t.Scope == "target"));
-        Assert.Equal("1.1.1.1", set.Tasks.Single(t => t.Scope == "target").Target);
+        TaskSet set = await agent.WaitForTaskSetAsync(s => s.Tasks.Any(t => t.Scope == "target" && t.Kind == "icmp_ping"));
+        Assert.Equal("1.1.1.1", set.Tasks.Single(t => t.Scope == "target" && t.Kind == "icmp_ping").Target);
 
-        using HttpResponseMessage onceSchedule = await _backend.Admin.PostAsync("/api/admin/tasks", BackendFixture.Json(new JsonObject { ["scope"] = "line", ["kind"] = "udp_echo", ["schedule"] = "every:30" }));
+        using HttpResponseMessage onceSchedule = await _backend.Admin.PostAsync("/api/admin/tasks", BackendFixture.Json(new JsonObject { ["scope"] = "line", ["kind"] = "quic_ping", ["schedule"] = "every:30" }));
         Assert.Equal(HttpStatusCode.BadRequest, onceSchedule.StatusCode);
     }
 
+    [Fact]
+    public async Task TargetTemplate_AppliesToEveryAgent_AndAnOverrideCanDisableOrRetargetItForOne()
+    {
+        await using AgentSimulator first = await _backend.ConnectAgentAsync();
+        await using AgentSimulator second = await _backend.ConnectAgentAsync();
+        using HttpResponseMessage created = await _backend.Admin.PostAsync("/api/admin/tasks", BackendFixture.Json(new JsonObject
+        {
+            ["scope"] = "target", ["kind"] = "tcp_connect", ["target"] = "Example.com:443",
+        }));
+        Assert.Equal(HttpStatusCode.Created, created.StatusCode);
+        JsonNode template = JsonNode.Parse(await created.Content.ReadAsStringAsync())!;
+        string templateId = template["id"]!.GetValue<string>();
+        Assert.Null(template["agent_id"]);
+        try
+        {
+            foreach (AgentSimulator agent in new[] { first, second })
+            {
+                TaskSet set = await agent.WaitForTaskSetAsync(s => s.Tasks.Any(t => t.Kind == "tcp_connect" && t.Scope == "target"));
+                Assert.Equal("example.com:443", set.Tasks.Single(t => t.Kind == "tcp_connect" && t.Scope == "target").Target);
+            }
+
+            // 展示接口列出每个 Agent 实际执行的目标；模拟的 Agent 没有上传数据，所以是「等待数据」
+            JsonNode listed = await _backend.GetJsonAsync(_backend.Admin, "/api/public/targets");
+            string[] both = [first.NodeId.Value, second.NodeId.Value];
+            JsonNode[] mine = [.. listed["items"]!.AsArray().Select(i => i!).Where(i => i["task_id"]!.GetValue<string>() == templateId && both.Contains(i["agent_id"]!.GetValue<string>()))];
+            Assert.Equal(both.Order(), mine.Select(i => i["agent_id"]!.GetValue<string>()).Order());
+            Assert.All(mine, i =>
+            {
+                Assert.Equal("example.com:443", i["target"]!.GetValue<string>());
+                Assert.Equal("waiting", i["status"]!.GetValue<string>());
+                Assert.Null(i["last_sample"]);
+            });
+
+            JsonNode one = await _backend.GetJsonAsync(_backend.Admin, $"/api/public/targets?agent_id={first.NodeId.Value}&task_id={templateId}&full=true");
+            Assert.Equal(first.NodeId.Value, Assert.Single(one["items"]!.AsArray())!["agent_id"]!.GetValue<string>());
+
+            // 覆盖：第一个 Agent 换一个目标，第二个 Agent 停用
+            using HttpResponseMessage retarget = await _backend.Admin.PostAsync("/api/admin/tasks", BackendFixture.Json(new JsonObject
+            {
+                ["scope"] = "target", ["kind"] = "tcp_connect", ["agent_id"] = first.NodeId.Value, ["base_task_id"] = templateId, ["target"] = "192.0.2.9:8443",
+            }));
+            Assert.Equal(HttpStatusCode.Created, retarget.StatusCode);
+            using HttpResponseMessage off = await _backend.Admin.PostAsync("/api/admin/tasks", BackendFixture.Json(new JsonObject
+            {
+                ["scope"] = "target", ["kind"] = "tcp_connect", ["agent_id"] = second.NodeId.Value, ["base_task_id"] = templateId, ["enabled"] = false,
+            }));
+            Assert.Equal(HttpStatusCode.Created, off.StatusCode);
+            TaskSet firstSet = await first.WaitForTaskSetAsync(s => s.Tasks.Any(t => t.Target == "192.0.2.9:8443"));
+            Assert.Single(firstSet.Tasks, t => t.Kind == "tcp_connect" && t.Scope == "target");
+            await second.WaitForTaskSetAsync(s => s.Tasks.All(t => t.Scope != "target"));
+
+            // 覆盖只能指向同类的单个 Agent 模板
+            using HttpResponseMessage wrongKind = await _backend.Admin.PostAsync("/api/admin/tasks", BackendFixture.Json(new JsonObject
+            {
+                ["scope"] = "target", ["kind"] = "icmp_ping", ["agent_id"] = first.NodeId.Value, ["base_task_id"] = templateId,
+            }));
+            Assert.Equal(HttpStatusCode.BadRequest, wrongKind.StatusCode);
+        }
+        finally
+        {
+            using HttpResponseMessage deleted = await _backend.Admin.DeleteAsync("/api/admin/tasks/" + templateId);
+        }
+    }
+
     [Fact]
     public async Task TaskSet_RejectedItemsReportedByTheAgent_AreVisibleToTheAdmin()
     {
@@ -344,7 +418,7 @@ public sealed class EnrollmentAndTaskSetTests : IClassFixture<BackendFixture>
 
         using HttpResponseMessage created = await _backend.Admin.PostAsync("/api/admin/tasks", BackendFixture.Json(new JsonObject
         {
-            ["scope"] = "target", ["kind"] = "connect", ["agent_id"] = agent.NodeId.Value, ["target"] = "192.0.2.1:443",
+            ["scope"] = "target", ["kind"] = "tcp_connect", ["agent_id"] = agent.NodeId.Value, ["target"] = "192.0.2.1:443",
         }));
         Assert.Equal(HttpStatusCode.Created, created.StatusCode);
         await BackendFixture.EventuallyAsync(async () => (await AgentAsync(agent.NodeId.Value))["rejected"]!.AsArray().Count == 1);

backend/tests/MoShiro.Backend.Tests/IngestAndQueryTests.cs

@@ -29,7 +29,7 @@ public sealed class IngestAndQueryTests : IClassFixture<BackendFixture>
         {
             long start = baseMs + (k * 10_000L);
             RawChunk udp = ChunkFactory.Echo(
-                agent.NodeId, "udp_echo", start, 100, 100,
+                agent.NodeId, "quic_ping", start, 100, 100,
                 i => new EchoPacket(false, lossEvery > 0 && i % lossEvery == 0, (long)(owdMs * 1000), (long)(owdMs * 1000)));
             Assert.True(await agent.SendChunkAsync(udp));
             if (tcp)
@@ -37,7 +37,7 @@ public sealed class IngestAndQueryTests : IClassFixture<BackendFixture>
                 long dialerBase = ChunkFactory.DialerUs(0);
                 RawStream info = ChunkFactory.TcpInfo(Enumerable.Range(0, 10).Select(s => (dialerBase + (s * 1_000_000L), (byte)0, 45_000u, (uint)(s * 2), (uint)(s * 400))));
                 RawChunk tcpChunk = ChunkFactory.Echo(
-                    agent.NodeId, "tcp_echo", start, 200, 50, _ => new EchoPacket(false, false, (long)(owdMs * 1000), (long)(owdMs * 1000)), extraStreams: [info]);
+                    agent.NodeId, "tcp_ping", start, 200, 50, _ => new EchoPacket(false, false, (long)(owdMs * 1000), (long)(owdMs * 1000)), extraStreams: [info]);
                 Assert.True(await agent.SendChunkAsync(tcpChunk));
             }
         }
@@ -87,13 +87,13 @@ public sealed class IngestAndQueryTests : IClassFixture<BackendFixture>
 
             // Anchored at now: the last 5 minutes are empty
             JsonNode atNow = await SeriesAsync(id, "range=5m&step=10s&metrics=loss.total");
-            Assert.Null(atNow["summary"]!["samples"]!["udp_echo"]);
+            Assert.Null(atNow["summary"]!["samples"]!["quic_ping"]);
 
             // Anchored at the latest sample: the window ends where the data ends and carries all of it
             JsonNode anchored = await SeriesAsync(id, "range=5m&step=10s&metrics=loss.total&anchor=latest");
             long to = DateTimeOffset.Parse(anchored["to"]!.GetValue<string>(), System.Globalization.CultureInfo.InvariantCulture).ToUnixTimeMilliseconds();
             Assert.InRange(to, baseMs + (50 * 1000), baseMs + (80 * 1000));
-            Assert.Equal(600, anchored["summary"]!["samples"]!["udp_echo"]!.GetValue<long>());
+            Assert.Equal(600, anchored["summary"]!["samples"]!["quic_ping"]!.GetValue<long>());
             Assert.False(anchored["live"]!.GetValue<bool>());
 
             // 这个窗口是以“最后一个样本”为终点的绝对区间，但线路恢复之后同一个地址的内容就变了：不能被浏览器永久缓存
@@ -102,7 +102,7 @@ public sealed class IngestAndQueryTests : IClassFixture<BackendFixture>
 
             // anchor=now is the default behaviour; anything else is rejected
             JsonNode explicitNow = await SeriesAsync(id, "range=5m&step=10s&metrics=loss.total&anchor=now");
-            Assert.Null(explicitNow["summary"]!["samples"]!["udp_echo"]);
+            Assert.Null(explicitNow["summary"]!["samples"]!["quic_ping"]);
             using HttpResponseMessage bad = await _backend.Admin.GetAsync($"/api/public/lines/{_backend.Line(id)}/series?range=5m&anchor=yesterday");
             Assert.Equal(System.Net.HttpStatusCode.BadRequest, bad.StatusCode);
         }
@@ -162,8 +162,8 @@ public sealed class IngestAndQueryTests : IClassFixture<BackendFixture>
             {
                 minute = await SeriesAsync(agent.NodeId.Value, range + "&step=1m");
                 // 窗口会随着后续的块到达而重算：等到 18 个块的样本都计入之后再比较
-                return minute["source"]!.GetValue<string>() == "1m" && minute["summary"]!["samples"]!["udp_echo"]?.GetValue<long>() == 1800
-                    && minute["summary"]!["samples"]!["tcp_echo"]?.GetValue<long>() == 3600;
+                return minute["source"]!.GetValue<string>() == "1m" && minute["summary"]!["samples"]!["quic_ping"]?.GetValue<long>() == 1800
+                    && minute["summary"]!["samples"]!["tcp_ping"]?.GetValue<long>() == 3600;
             });
 
             JsonNode hotSummary = hot["summary"]!["metrics"]!;
@@ -176,9 +176,9 @@ public sealed class IngestAndQueryTests : IClassFixture<BackendFixture>
                     $"{id}: hot={hotSummary[id]} persisted={minuteSummary[id]}");
             }
 
-            Assert.Equal(1800, hot["summary"]!["samples"]!["udp_echo"]!.GetValue<long>());
-            Assert.Equal(hot["summary"]!["samples"]!["udp_echo"]!.GetValue<long>(), minute["summary"]!["samples"]!["udp_echo"]!.GetValue<long>());
-            Assert.Equal(3600, minute["summary"]!["samples"]!["tcp_echo"]!.GetValue<long>());
+            Assert.Equal(1800, hot["summary"]!["samples"]!["quic_ping"]!.GetValue<long>());
+            Assert.Equal(hot["summary"]!["samples"]!["quic_ping"]!.GetValue<long>(), minute["summary"]!["samples"]!["quic_ping"]!.GetValue<long>());
+            Assert.Equal(3600, minute["summary"]!["samples"]!["tcp_ping"]!.GetValue<long>());
 
             // RTT = 2 × 20 ms，直方图的相对误差 ≤ 4.5%
             Assert.InRange(minuteSummary["rtt.p95"]!.GetValue<double>(), 40 * 0.955, 40 * 1.045);
@@ -234,7 +234,7 @@ public sealed class IngestAndQueryTests : IClassFixture<BackendFixture>
             Assert.True(goodScore > 90, $"clean line scored {goodScore}");
             Assert.True(badScore < goodScore - 30, $"lossy line scored {badScore}");
             Assert.Equal(20.0, lines[badIndex]["summary"]!["metrics"]!["loss.total"]!.GetValue<double>(), 6);
-            Assert.Equal(1200, lines[goodIndex]["summary"]!["samples"]!["udp_echo"]!.GetValue<long>());
+            Assert.Equal(1200, lines[goodIndex]["summary"]!["samples"]!["quic_ping"]!.GetValue<long>());
 
             // 按指标排序：loss.total 升序时好线路在前
             JsonNode byLoss = await _backend.GetJsonAsync(_backend.Anonymous, "/api/public/overview?" + range + "&sort=loss.total&order=asc");
@@ -372,12 +372,12 @@ public sealed class IngestAndQueryTests : IClassFixture<BackendFixture>
         await using (agent)
         {
             string url = $"/api/public/lines/{_backend.Line(agent.NodeId.Value)}/series?from={Iso(baseMs)}&to={Iso(baseMs + Minute)}&step=1m&preset=udp";
-            await BackendFixture.EventuallyAsync(async () => (await _backend.GetJsonAsync(_backend.Admin, url))["summary"]!["samples"]!["udp_echo"]?.GetValue<long>() == 600);
+            await BackendFixture.EventuallyAsync(async () => (await _backend.GetJsonAsync(_backend.Admin, url))["summary"]!["samples"]!["quic_ping"]?.GetValue<long>() == 600);
 
             // Agent 重连后补传一个迟到的块（落在同一个分钟窗口里）
-            RawChunk late = ChunkFactory.Echo(agent.NodeId, "udp_echo", baseMs + 5_000, 100, 10, _ => new EchoPacket(false, false, 20_000, 20_000));
+            RawChunk late = ChunkFactory.Echo(agent.NodeId, "quic_ping", baseMs + 5_000, 100, 10, _ => new EchoPacket(false, false, 20_000, 20_000));
             Assert.True(await agent.SendChunkAsync(late));
-            await BackendFixture.EventuallyAsync(async () => (await _backend.GetJsonAsync(_backend.Admin, url))["summary"]!["samples"]!["udp_echo"]?.GetValue<long>() == 700, because: "the late chunk must re-enter the persistent path");
+            await BackendFixture.EventuallyAsync(async () => (await _backend.GetJsonAsync(_backend.Admin, url))["summary"]!["samples"]!["quic_ping"]?.GetValue<long>() == 700, because: "the late chunk must re-enter the persistent path");
         }
     }
 
@@ -394,7 +394,7 @@ public sealed class IngestAndQueryTests : IClassFixture<BackendFixture>
             await BackendFixture.EventuallyAsync(async () =>
             {
                 oneMinute = await SeriesAsync(agent.NodeId.Value, range + "&step=1m");
-                return oneMinute["summary"]!["samples"]!["udp_echo"]?.GetValue<long>() == 3000;
+                return oneMinute["summary"]!["samples"]!["quic_ping"]?.GetValue<long>() == 3000;
             });
 
             // 5 分钟层由降采样把 5 个 1 分钟窗口精确合并而来
@@ -402,7 +402,7 @@ public sealed class IngestAndQueryTests : IClassFixture<BackendFixture>
             await BackendFixture.EventuallyAsync(async () =>
             {
                 fiveMinutes = await SeriesAsync(agent.NodeId.Value, range + "&step=5m");
-                return fiveMinutes["source"]!.GetValue<string>() == "5m" && fiveMinutes["summary"]!["samples"]!["udp_echo"]?.GetValue<long>() == 3000;
+                return fiveMinutes["source"]!.GetValue<string>() == "5m" && fiveMinutes["summary"]!["samples"]!["quic_ping"]?.GetValue<long>() == 3000;
             });
             Assert.Equal(oneMinute["summary"]!["metrics"]!["loss.total"]!.GetValue<double>(), fiveMinutes["summary"]!["metrics"]!["loss.total"]!.GetValue<double>(), 9);
             Assert.Equal(oneMinute["summary"]!["metrics"]!["rtt.p99"]!.GetValue<double>(), fiveMinutes["summary"]!["metrics"]!["rtt.p99"]!.GetValue<double>(), 9);

backend/tests/MoShiro.Backend.Tests/Ipv6Tests.cs

@@ -30,7 +30,7 @@ public sealed class Ipv6Tests : IClassFixture<BackendFixture>
         {
             foreach (string version in new[] { IpVersions.V4, IpVersions.V6 })
             {
-                RawChunk chunk = ChunkFactory.Echo(agent.NodeId, "udp_echo", start + k * 10_000, 100, 100,
+                RawChunk chunk = ChunkFactory.Echo(agent.NodeId, "quic_ping", start + k * 10_000, 100, 100,
                     i => new EchoPacket(false, version == IpVersions.V6 && i % 2 == 0, 20_000, 20_000));
                 chunk.Header.DialerId = new NodeId(_backend.DefaultDialerId);
                 chunk.Header.IpVersion = version;
@@ -50,7 +50,7 @@ public sealed class Ipv6Tests : IClassFixture<BackendFixture>
                 await BackendFixture.EventuallyAsync(async () =>
                 {
                     series = await _backend.GetJsonAsync(_backend.Admin, $"/api/public/lines/{line}/series?{range}&step={step}&preset=udp");
-                    return series["summary"]!["samples"]!["udp_echo"]?.GetValue<long>() == 600;
+                    return series["summary"]!["samples"]!["quic_ping"]?.GetValue<long>() == 600;
                 });
                 Assert.Equal(loss, series["summary"]!["metrics"]!["loss.total"]!.GetValue<double>(), 6);
             }
@@ -99,7 +99,7 @@ public sealed class Ipv6Tests : IClassFixture<BackendFixture>
         {
             JsonNode raw = await _backend.GetJsonAsync(_backend.Admin, "/api/admin/raw/chunks?agent_id=" + agent.Id);
             return new[] { "line:" + dialer.DialerId, "line:" + dialer.DialerId + ":ipv6" }.All(series =>
-                new[] { "udp_echo", "tcp_echo" }.All(kind => raw["items"]!.AsArray().Any(c => c!["series"]!.GetValue<string>() == series && c["kind"]!.GetValue<string>() == kind)));
+                new[] { "quic_ping", "tcp_ping" }.All(kind => raw["items"]!.AsArray().Any(c => c!["series"]!.GetValue<string>() == series && c["kind"]!.GetValue<string>() == kind)));
         }, TimeSpan.FromSeconds(45));
 
         string v4 = agent.Id + "~" + dialer.DialerId;
@@ -110,8 +110,8 @@ public sealed class Ipv6Tests : IClassFixture<BackendFixture>
             {
                 JsonNode series = await _backend.GetJsonAsync(_backend.Admin, $"/api/public/lines/{line}/series?range=1m&step={step}&preset=udp,tcp");
                 Assert.Equal(family, series["ip_version"]!.GetValue<string>());
-                Assert.True(series["summary"]!["samples"]!["udp_echo"]!.GetValue<long>() > 0, series.ToJsonString());
-                Assert.True(series["summary"]!["samples"]!["tcp_echo"]!.GetValue<long>() > 0, series.ToJsonString());
+                Assert.True(series["summary"]!["samples"]!["quic_ping"]!.GetValue<long>() > 0, series.ToJsonString());
+                Assert.True(series["summary"]!["samples"]!["tcp_ping"]!.GetValue<long>() > 0, series.ToJsonString());
             }
         }
 

backend/tests/MoShiro.Backend.Tests/LiveTests.cs

@@ -34,9 +34,9 @@ public sealed class LiveTests : IClassFixture<BackendFixture>
         await sse.WaitForAsync(e => e.Name == "series" && e.Data!["agent_id"]!.GetValue<string>() == id);
 
         // 新块到达之后：推送新的 1s 桶（列式）和最新的汇总
-        RawChunk chunk = ChunkFactory.Echo(agent.NodeId, "udp_echo", Now() - 10_000, 100, 100, i => new EchoPacket(false, i % 10 == 0, 20_000, 20_000));
+        RawChunk chunk = ChunkFactory.Echo(agent.NodeId, "quic_ping", Now() - 10_000, 100, 100, i => new EchoPacket(false, i % 10 == 0, 20_000, 20_000));
         Assert.True(await agent.SendChunkAsync(chunk));
-        SseEvent series = await sse.WaitForAsync(e => e.Name == "series" && e.Data!["summary"]!["samples"]!["udp_echo"]?.GetValue<long>() >= 100);
+        SseEvent series = await sse.WaitForAsync(e => e.Name == "series" && e.Data!["summary"]!["samples"]!["quic_ping"]?.GetValue<long>() >= 100);
         Assert.True(series.Data!["live"]!.GetValue<bool>());
         Assert.Equal("1s", series.Data["step"]!.GetValue<string>());
         Assert.Equal(series.Data["t"]!.AsArray().Count, series.Data["values"]!["loss.total"]!.AsArray().Count);

backend/tests/MoShiro.Backend.Tests/OnDemandTestsTests.cs

@@ -82,7 +82,7 @@ public sealed class OnDemandTestsTests : IClassFixture<BackendFixture>
         TestRunParams run = agent.TestRuns.Single();
         Assert.Equal(testId, run.TestId.Value);
         Assert.Equal([10d, 25d, 50d, 100d], run.Phases.Select(p => p.Params["mbps"].GetDouble()).ToArray());
-        Assert.All(run.Phases, p => Assert.Equal("udp_train", p.Kind));
+        Assert.All(run.Phases, p => Assert.Equal("quic_stream", p.Kind));
         Assert.All(run.Phases, p => Assert.Equal(1250, p.Params["size"].GetInt64()));
 
         // 同一条线路同时只能跑一个测试
@@ -227,7 +227,7 @@ public sealed class OnDemandTestsTests : IClassFixture<BackendFixture>
         RawChunk chunk = ChunkFactory.UdpEchoClean(agent.NodeId, now - 120_000);
         Assert.True(await agent.SendChunkAsync(chunk));
 
-        JsonNode list = await _backend.GetJsonAsync(_backend.Admin, $"/api/admin/raw/chunks?agent_id={agent.NodeId.Value}&kind=udp_echo");
+        JsonNode list = await _backend.GetJsonAsync(_backend.Admin, $"/api/admin/raw/chunks?agent_id={agent.NodeId.Value}&kind=quic_ping");
         JsonNode item = list["items"]!.AsArray().Single()!;
         Assert.Equal(chunk.Header.ChunkId.ToString(), item["chunk_id"]!.GetValue<string>());
         Assert.Equal("line:" + _backend.DefaultDialerId, item["series"]!.GetValue<string>());

backend/tests/MoShiro.Backend.Tests/OperationsAndSecurityTests.cs

@@ -42,7 +42,7 @@ public sealed class OperationsAndSecurityTests : IClassFixture<BackendFixture>
         await using AgentSimulator agent = await _backend.ConnectAgentAsync();
         for (int k = 0; k < 12; k++)
         {
-            Assert.True(await agent.SendChunkAsync(ChunkFactory.Echo(agent.NodeId, "udp_echo", baseMs + (k * 10_000L), 100, 100, _ => new EchoPacket(false, false, 30_000, 30_000))));
+            Assert.True(await agent.SendChunkAsync(ChunkFactory.Echo(agent.NodeId, "quic_ping", baseMs + (k * 10_000L), 100, 100, _ => new EchoPacket(false, false, 30_000, 30_000))));
         }
 
         string url = $"/api/public/lines/{_backend.Line(agent.NodeId.Value)}/series?from={Iso(baseMs)}&to={Iso(baseMs + (2 * Minute))}&step=1m&metrics=rtt.p95,loss.total";
@@ -50,7 +50,7 @@ public sealed class OperationsAndSecurityTests : IClassFixture<BackendFixture>
         await BackendFixture.EventuallyAsync(async () =>
         {
             before = await _backend.GetJsonAsync(_backend.Admin, url);
-            return before["summary"]!["samples"]!["udp_echo"]?.GetValue<long>() == 1200 && before["source"]!.GetValue<string>() == "1m";
+            return before["summary"]!["samples"]!["quic_ping"]?.GetValue<long>() == 1200 && before["source"]!.GetValue<string>() == "1m";
         });
         double rtt = before["summary"]!["metrics"]!["rtt.p95"]!.GetValue<double>();
         Assert.InRange(rtt, 60 * 0.955, 60 * 1.045);

backend/tests/MoShiro.Backend.Tests/PersistenceTests.cs

@@ -21,14 +21,14 @@ public sealed class PersistenceTests : IAsyncLifetime
         string id = agent.NodeId.Value;
         for (int k = 0; k < 12; k++)
         {
-            Assert.True(await agent.SendChunkAsync(ChunkFactory.Echo(agent.NodeId, "udp_echo", baseMs + (k * 10_000L), 100, 100, i => new EchoPacket(false, i % 4 == 0, 20_000, 20_000))));
+            Assert.True(await agent.SendChunkAsync(ChunkFactory.Echo(agent.NodeId, "quic_ping", baseMs + (k * 10_000L), 100, 100, i => new EchoPacket(false, i % 4 == 0, 20_000, 20_000))));
         }
 
         string from = DateTimeOffset.FromUnixTimeMilliseconds(baseMs).UtcDateTime.ToString("yyyy-MM-dd'T'HH:mm:ss.fff'Z'");
         string to = DateTimeOffset.FromUnixTimeMilliseconds(baseMs + (2 * minute)).UtcDateTime.ToString("yyyy-MM-dd'T'HH:mm:ss.fff'Z'");
         string url = $"/api/public/lines/{_backend.Line(id)}/series?from={from}&to={to}&metrics=loss.total,rtt.p95";
         JsonNode before = await _backend.GetJsonAsync(_backend.Admin, url + "&step=1m");
-        await BackendFixture.EventuallyAsync(async () => (await _backend.GetJsonAsync(_backend.Admin, url + "&step=1m"))["summary"]!["samples"]!["udp_echo"]?.GetValue<long>() == 1200);
+        await BackendFixture.EventuallyAsync(async () => (await _backend.GetJsonAsync(_backend.Admin, url + "&step=1m"))["summary"]!["samples"]!["quic_ping"]?.GetValue<long>() == 1200);
         before = await _backend.GetJsonAsync(_backend.Admin, url + "&step=1m");
 
         await agent.DisposeAsync();
@@ -51,7 +51,7 @@ public sealed class PersistenceTests : IAsyncLifetime
         await BackendFixture.EventuallyAsync(async () =>
         {
             hot = await _backend.GetJsonAsync(admin, url + "&step=1s");
-            return hot["source"]!.GetValue<string>() == "hot" && hot["summary"]!["samples"]!["udp_echo"]?.GetValue<long>() == 1200;
+            return hot["source"]!.GetValue<string>() == "hot" && hot["summary"]!["samples"]!["quic_ping"]?.GetValue<long>() == 1200;
         });
         Assert.Equal(25.0, hot["summary"]!["metrics"]!["loss.total"]!.GetValue<double>(), 6);
 

backend/tests/MoShiro.Backend.Tests/ScheduleTests.cs

@@ -72,8 +72,8 @@ public sealed class ScheduleTests : IClassFixture<BackendFixture>
         Assert.Equal(HttpStatusCode.OK, response.StatusCode);
         JsonArray items = JsonNode.Parse(await response.Content.ReadAsStringAsync())!["items"]!.AsArray();
         string[] kinds = [.. items.Select(i => i!["kind"]!.GetValue<string>())];
-        Assert.Contains("connect", kinds);
-        Assert.Contains("udp_echo", kinds);
-        Assert.Contains("tcp_echo", kinds);
+        Assert.Contains("tcp_connect", kinds);
+        Assert.Contains("quic_ping", kinds);
+        Assert.Contains("tcp_ping", kinds);
     }
 }

backend/tests/MoShiro.Backend.Tests/StorageTests.cs

@@ -48,8 +48,8 @@ public sealed class StorageTests : IDisposable
     public async Task Raw_AppendReadAndDedupe()
     {
         var raw = new SqliteRawStore(_db);
-        RawChunkAppend a = Chunk(s_agent, "udp_echo", 1_000, "2026-01-01");
-        RawChunkAppend b = Chunk(s_agent, "udp_echo", 11_000, "2026-01-01");
+        RawChunkAppend a = Chunk(s_agent, "quic_ping", 1_000, "2026-01-01");
+        RawChunkAppend b = Chunk(s_agent, "quic_ping", 11_000, "2026-01-01");
 
         Assert.True(await raw.AppendAsync(a, default));
         Assert.True(await raw.AppendAsync(b, default));
@@ -57,7 +57,7 @@ public sealed class StorageTests : IDisposable
 
         IReadOnlyList<RawChunkMeta> metas = await raw.FindAsync(new RawQuery(s_agent), default);
         Assert.Equal(2, metas.Count);
-        Assert.Equal("2026-01-01/agt_storage/udp_echo.seg", metas[0].SegmentPath);
+        Assert.Equal("2026-01-01/agt_storage/quic_ping.seg", metas[0].SegmentPath);
         Assert.Equal(0, metas[0].Offset);
         Assert.Equal(metas[0].Length, metas[1].Offset); // 同一个段文件里依次追加
         Assert.Equal(a.Bytes.ToArray(), await raw.ReadAsync(metas[0], default));
@@ -72,7 +72,7 @@ public sealed class StorageTests : IDisposable
         var raw = new SqliteRawStore(_db);
         var evil = new NodeId("../../../outside");
         Assert.True(await raw.AppendAsync(Chunk(evil, "../etc", 1, "2026-01-01"), default));
-        Assert.True(await raw.AppendAsync(Chunk(s_agent, "udp_echo", 2, "2026-01-01", test: new TestId("..\\..\\x"), phase: 0), default));
+        Assert.True(await raw.AppendAsync(Chunk(s_agent, "quic_ping", 2, "2026-01-01", test: new TestId("..\\..\\x"), phase: 0), default));
 
         foreach (string file in Directory.EnumerateFiles(_dir, "*.seg", SearchOption.AllDirectories))
         {
@@ -80,7 +80,7 @@ public sealed class StorageTests : IDisposable
         }
 
         Assert.False(File.Exists(Path.Combine(_dir, "outside")));
-        await Assert.ThrowsAsync<ArgumentException>(async () => await raw.AppendAsync(Chunk(s_agent, "udp_echo", 3, "../2026"), default));
+        await Assert.ThrowsAsync<ArgumentException>(async () => await raw.AppendAsync(Chunk(s_agent, "quic_ping", 3, "../2026"), default));
     }
 
     [Fact]
@@ -90,19 +90,19 @@ public sealed class StorageTests : IDisposable
         var testId = new TestId("tst_one");
         for (int i = 0; i < 6; i++)
         {
-            await raw.AppendAsync(Chunk(s_agent, "udp_echo", i * 10_000L, "2026-01-01"), default);
+            await raw.AppendAsync(Chunk(s_agent, "quic_ping", i * 10_000L, "2026-01-01"), default);
         }
 
-        await raw.AppendAsync(Chunk(s_agent, "tcp_echo", 5_000, "2026-01-01"), default);
-        await raw.AppendAsync(Chunk(new NodeId("agt_other"), "udp_echo", 5_000, "2026-01-01"), default);
-        await raw.AppendAsync(Chunk(s_agent, "udp_train", 0, "2026-01-01", test: testId, phase: 1), default);
+        await raw.AppendAsync(Chunk(s_agent, "tcp_ping", 5_000, "2026-01-01"), default);
+        await raw.AppendAsync(Chunk(new NodeId("agt_other"), "quic_ping", 5_000, "2026-01-01"), default);
+        await raw.AppendAsync(Chunk(s_agent, "quic_stream", 0, "2026-01-01", test: testId, phase: 1), default);
 
         Assert.Equal(8, (await raw.FindAsync(new RawQuery(s_agent), default)).Count);
-        Assert.Equal(6, (await raw.FindAsync(new RawQuery(s_agent, Kind: "udp_echo"), default)).Count);
+        Assert.Equal(6, (await raw.FindAsync(new RawQuery(s_agent, Kind: "quic_ping"), default)).Count);
         Assert.Single(await raw.FindAsync(new RawQuery(TestId: testId), default));
-        Assert.Equal(3, (await raw.FindAsync(new RawQuery(s_agent, Kind: "udp_echo", FromMs: 10_000, ToMs: 40_000), default)).Count);
-        Assert.Equal(2, (await raw.FindAsync(new RawQuery(s_agent, Kind: "udp_echo", Limit: 2), default)).Count);
-        Assert.Equal(4, (await raw.FindAsync(new RawQuery(s_agent, Kind: "udp_echo", AfterStartTs: 20_000), default)).Count);
+        Assert.Equal(3, (await raw.FindAsync(new RawQuery(s_agent, Kind: "quic_ping", FromMs: 10_000, ToMs: 40_000), default)).Count);
+        Assert.Equal(2, (await raw.FindAsync(new RawQuery(s_agent, Kind: "quic_ping", Limit: 2), default)).Count);
+        Assert.Equal(4, (await raw.FindAsync(new RawQuery(s_agent, Kind: "quic_ping", AfterStartTs: 20_000), default)).Count);
 
         IReadOnlyList<(NodeId AgentId, string Series)> series = await raw.ListSeriesAsync(0, 100_000, default);
         Assert.Equal(2, series.Count); // 测试的块不算持续序列
@@ -112,9 +112,9 @@ public sealed class StorageTests : IDisposable
     public async Task Raw_RecoverTruncatesAnUnindexedTail_AndLaterAppendsStayConsistent()
     {
         var raw = new SqliteRawStore(_db);
-        RawChunkAppend first = Chunk(s_agent, "udp_echo", 1, "2026-01-01");
+        RawChunkAppend first = Chunk(s_agent, "quic_ping", 1, "2026-01-01");
         await raw.AppendAsync(first, default);
-        string segment = Directory.EnumerateFiles(_dir, "udp_echo.seg", SearchOption.AllDirectories).Single();
+        string segment = Directory.EnumerateFiles(_dir, "quic_ping.seg", SearchOption.AllDirectories).Single();
         long indexedEnd = new FileInfo(segment).Length;
 
         // 追加之后、写索引之前崩溃：段文件尾部多了没有索引记录的字节
@@ -124,7 +124,7 @@ public sealed class StorageTests : IDisposable
         await raw.RecoverAsync(default);
         Assert.Equal(indexedEnd, new FileInfo(segment).Length);
 
-        RawChunkAppend second = Chunk(s_agent, "udp_echo", 2, "2026-01-01");
+        RawChunkAppend second = Chunk(s_agent, "quic_ping", 2, "2026-01-01");
         await raw.AppendAsync(second, default);
         IReadOnlyList<RawChunkMeta> metas = await raw.FindAsync(new RawQuery(s_agent), default);
         Assert.Equal(first.Bytes.ToArray(), await raw.ReadAsync(metas[0], default));
@@ -137,10 +137,10 @@ public sealed class StorageTests : IDisposable
     {
         var raw = new SqliteRawStore(_db);
         var testId = new TestId("tst_old");
-        await raw.AppendAsync(Chunk(s_agent, "udp_echo", 1, "2026-01-01"), default);
-        await raw.AppendAsync(Chunk(s_agent, "udp_echo", 2, "2026-03-01"), default);
-        await raw.AppendAsync(Chunk(s_agent, "udp_train", 3, "2026-01-01", test: testId, phase: 0), default);
-        await raw.AppendAsync(Chunk(s_agent, "udp_train", 4, "2026-02-01", test: new TestId("tst_mid"), phase: 0), default);
+        await raw.AppendAsync(Chunk(s_agent, "quic_ping", 1, "2026-01-01"), default);
+        await raw.AppendAsync(Chunk(s_agent, "quic_ping", 2, "2026-03-01"), default);
+        await raw.AppendAsync(Chunk(s_agent, "quic_stream", 3, "2026-01-01", test: testId, phase: 0), default);
+        await raw.AppendAsync(Chunk(s_agent, "quic_stream", 4, "2026-02-01", test: new TestId("tst_mid"), phase: 0), default);
 
         // 持续任务保留到 2026-02-01 之后，测试保留到 2026-01-15 之后
         int removed = await raw.DeleteExpiredAsync(new DateOnly(2026, 2, 1), new DateOnly(2026, 1, 15), default);
@@ -365,6 +365,44 @@ public sealed class StorageTests : IDisposable
         Assert.Equal(200, (await settings.GetAllAsync(default)).Count);
     }
 
+    [Fact]
+    public void Schema_UpgradesVersion1_ByRenamingTheKinds()
+    {
+        string dir = Path.Combine(Path.GetTempPath(), "moshiro-schema-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        string path = Path.Combine(dir, "moshiro.db");
+        try
+        {
+            using (var db = new SqliteDatabase(dir))
+            {
+            }
+
+            SqliteConnection.ClearAllPools();
+            using (var connection = new SqliteConnection($"Data Source={path}"))
+            {
+                connection.Open();
+                connection.Exec("INSERT INTO tasks (id, scope, kind, schedule, updated_at) VALUES ('tsk_a', 'line', 'udp_echo', 'continuous', 1), ('tsk_b', 'line', 'connect', 'continuous', 1)");
+                connection.Exec("PRAGMA user_version = 1");
+            }
+
+            SqliteConnection.ClearAllPools();
+            using (var db = new SqliteDatabase(dir))
+            {
+            }
+
+            SqliteConnection.ClearAllPools();
+            using var check = new SqliteConnection($"Data Source={path}");
+            check.Open();
+            Assert.Equal(2, check.Scalar<int>("PRAGMA user_version"));
+            Assert.Equal("quic_ping,tcp_connect", string.Join(',', new[] { "tsk_a", "tsk_b" }.Select(id => check.Scalar<string>($"SELECT kind FROM tasks WHERE id = '{id}'"))));
+        }
+        finally
+        {
+            SqliteConnection.ClearAllPools();
+            Directory.Delete(dir, recursive: true);
+        }
+    }
+
     [Fact]
     public void Schema_RefusesADatabaseFromANewerBuild()
     {