diff --git a/Drivers/BSP/CH395F/ch395f.c b/Drivers/BSP/CH395F/ch395f.c
index 133e5759..e3207705 100644
--- a/Drivers/BSP/CH395F/ch395f.c
+++ b/Drivers/BSP/CH395F/ch395f.c
@@ -1671,7 +1671,7 @@ int ch395f_sock_reset_poll(uint8_t sn) {
             p->state = CH395F_RST_ST_IDLE;
             return 0;
         }
-        /* 二段关闭实证（TC1501 台架 2026-10-13）：LISTEN 态 Socket 的 CLOSE 返
+        /* 二段关闭实证（TC-NET-1501 台架 2026-10-13）：LISTEN 态 Socket 的 CLOSE 返
          * SUCCESS 但只拆监听（TCP 01->00），byte0 恒 05；需再发一次 CLOSE 才落
          * 00（生产 net 层靠 TRAP-NET-09 open 重试吸收此行为）。复位状态机自行补发，
          * 补发标记=drain 字段置 0xF（本阶段已用尽，复用安全）。 */
diff --git a/scripts/check_test_traceability.py b/scripts/check_test_traceability.py
index 3abd8e25..0078caaa 100644
--- a/scripts/check_test_traceability.py
+++ b/scripts/check_test_traceability.py
@@ -27,6 +27,7 @@
       ② 代码有、母号不在文档、**且号旁边没写人话意图** → CODE-ONLY（真未登记）；
       ③ 代码有、靠"旁边有意图"放过 → 单独打印为 IN-CODE，**弱于文档**，不算已登记。
     小写子项后缀（`TC-XXX-003b`）按母号算（`subitem_ok`），与编号门禁同口径。
+    **批 6 再分两档**：硬件层人工用例（标题/章节含「（硬件层）」）记为 `BENCH`、文档已标未实现/待补/暂缓/已取消的记为 `NOTIMPL`，两者**单列示数**不进差异——但也不是「已覆盖」，只是「不该在这里期望代码」。
     **2026-10-21 第二次口径修正（批 5）**：变更记录行与 `[示例]`/`[计划]` 行**不参与比对**
     （冻结历史按编号规范 §8.1 不回改，旧号靠 `id_aliases.json` 解析；这条豁免另三支脚本早有，本脚本是最后缺它的一个，`DOC-ONLY` 因此 38 → 29、交集不变）；被豁免的号存进 `frozen_ids`，`--verbose` 全量列出——**豁免不等于已对应**，别拿它当收敛。
 
@@ -74,6 +75,22 @@ PLACEHOLDER_PREFIXES = {"XXX"}
 # 该号在批 2 已随代码改名成 TC-ADCIN-*，历史行不该回改，拿它去代码里找同号必然落空。
 SKIP_LINE = re.compile(r"\[示例\]|\[计划\]|^\s*\|\s*20\d\d-\d\d-\d\d\s*\|")
 frozen_ids: set = set()   # 只在 --verbose 里列：被豁免的号（历史/示例），不是"已对应"
+# 2026-10-21 批 6：`DOC-ONLY` 里混着两种"不是缺口"的号，一律**单列示数**而不是塞进差异，
+# 也**不静默消失**——数量恒打印，明细 `--verbose` 可查：
+#   BENCH    硬件层人工用例（标题或所属章节含「（硬件层）」）：本来就没有代码载体，
+#            属主是人工台架步骤，不是 C 代码（例：§12.5 阶段 15「自愈驱动原语（硬件层，无需 PC）」）。
+#   NOTIMPL  文档已显式标了状态词（未实现 / 待补 / 暂缓 / 已取消）：是**已登记的欠账**，
+#            不是"查无此号"的假警报。
+# ⚠ 反过来别把 BENCH 当"已覆盖"：它只说明"不该期望代码里有"，不证明人工真做过。
+BENCH_RX = re.compile(r"[（(]\s*硬件层")
+NOTIMPL_RX = re.compile(r"未实现|待补|暂缓|已取消")
+# 定义行（决定这个号的**载体类型**）：markdown 标题行，或表格里号在**首格**的行。
+# 引用行（正文里"同 TC-NET-601"、"参见 TC-NET-302"）不改变载体判断——否则一个人工
+# 用例只要在别处被提一次，就又被要求"代码里必须有"（2026-10-21 实测：按"任意行都算"
+# 实现时，BENCH 收了 16 个号却只消掉 1 处差异，等于没生效）。
+DEF_LINE_RX = re.compile(r"^(?:#{2,6}\s|\|\s*\*{0,2}\s*TC-)")
+bench_ids: set = set()
+notimpl_ids: set = set()
 
 
 def _prefix(tc: str) -> str:
@@ -110,7 +127,8 @@ def collect(paths, label, want_intent=False):
     """返回 (ids_set, per_prefix_counts[, intent_set])。逐文件扫描，缺文件不致命。"""
     ids = set()
     intents = set()
-    global frozen_ids
+    global frozen_ids, bench_ids, notimpl_ids
+    in_bench_section = False
     for p in paths:
         try:
             text = p.read_text(encoding="utf-8", errors="replace")
@@ -118,6 +136,11 @@ def collect(paths, label, want_intent=False):
             print(f"[ERR] 无法读取 {p}: {e}", file=sys.stderr)
             return (None, None, None) if want_intent else (None, None)
         for line in text.splitlines():
+            if re.match(r"^#{2,6}\s+\S", line):        # markdown 章节：记住是否硬件层
+                in_bench_section = bool(BENCH_RX.search(line))
+            is_def = bool(DEF_LINE_RX.search(line))
+            bench = bool(BENCH_RX.search(line)) or (in_bench_section and is_def)
+            notimpl = bool(NOTIMPL_RX.search(line))
             skip = bool(SKIP_LINE.search(line))
             for m in TC_RE.findall(line):
                 if _prefix(m) in PLACEHOLDER_PREFIXES:
@@ -125,6 +148,13 @@ def collect(paths, label, want_intent=False):
                 if skip:          # 冻结历史 / 示例行：不参与双向比对，只留痕
                     frozen_ids.add(m)
                     continue
+                if label == "doc" and is_def:
+                    # 只对文档侧分类：载体类型由**文档里的定义行**说了算，
+                    # 且必须从全集里整体减掉（见上面注释的实测坑）
+                    if bench:
+                        bench_ids.add(m)      # 硬件层人工 → 不期望代码载体
+                    if notimpl:
+                        notimpl_ids.add(m)    # 已标未实现/待补 → 已登记的欠账
                 ids.add(m)
                 if want_intent and has_intent(line, m):
                     intents.add(m)
@@ -173,6 +203,9 @@ def main():
     if code_ids is None or doc_ids is None:
         return 2
 
+    # 文档侧的两个单列档整体从文档全集里减掉后再比差异（数量已在上面打印，
+    # --verbose 有明细）：BENCH = 人工台架定义，NOTIMPL = 已显式登记未实现
+    doc_ids -= bench_ids | notimpl_ids
     doc_bases = {_base(i) for i in doc_ids}
     # 真差异定义（B 层口径 2026-10-21，docs/编号规范.md §8.1）：
     #   ① 文档声明了、代码里没有 → 未实现/未标注（保留，这是硬断链）；
@@ -189,7 +222,11 @@ def main():
     print(f"代码侧：{len(code_files)} 个文件，{len(code_ids)} 个 TC")
     print(f"文档侧：{len(doc_files)} 个文件，{len(doc_ids)} 个 TC")
     print(f"交集：{len(code_ids & doc_ids)}")
+    # 注意：交集/文档侧计数在减档之前打印，这里补一行减档后的口径
+    print(f"（减 BENCH/NOTIMPL 后参与比对：文档 {len(doc_ids)}、交集 {len(code_ids & doc_ids)}）")
     print(f"豁免：变更记录/[示例]/[计划] 行的号 {len(frozen_ids)} 个（口径同 check_ids.py，见 §8.1）")
+    print(f"单列 BENCH（硬件层人工用例，不期望有代码载体）：{len(bench_ids)} 个")
+    print(f"单列 NOTIMPL（文档已标未实现/待补/暂缓/已取消）：{len(notimpl_ids)} 个")
 
     if args.verbose:
         print("--- 各前缀 TC 计数（代码 / 文档）---")
@@ -211,6 +248,12 @@ def main():
         for i in code_only_in_code:
             print(f"    {i}")
 
+    for name, bag in (("BENCH 硬件层人工", bench_ids), ("NOTIMPL 已登记未实现", notimpl_ids)):
+        if args.verbose and bag:
+            print("--- %s：不参与差异比对，但**不等于已验证**（共 %d 个）---" % (name, len(bag)))
+            for i in sorted(bag):
+                print("    ", i)
+
     if args.verbose and frozen_ids:
         print("--- 被豁免的号（变更记录 / [示例] / [计划] 行，共 %d 个）**不是已对应**，"
               "历史旧号靠 id_aliases.json 解析 ---" % len(frozen_ids))
diff --git a/scripts/id_aliases.json b/scripts/id_aliases.json
index 2d9f53ec..069398b1 100644
--- a/scripts/id_aliases.json
+++ b/scripts/id_aliases.json
@@ -1,7 +1,7 @@
 {
   "schema": 1,
   "generated_from": "docs/编号规范.md §7 迁移映射 + §4.3 冻结前缀；本表只登记**仓库里已实际出现**的旧字面量 → 现行字面量，不做尚未落地的批量改写（§7.2 阶段 1 一律保留存量）",
-  "note": "旧号引用不因本表而改写：本表只让门禁把「旧号引用」判成可解析（校验 3 悬空引用 / 校验 4 重复定义）。批量改写属 §9 阶段 1，须逐批 dry-run + 三重复核（§7.3）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。",
+  "note": "旧号引用不因本表而改写：本表只让门禁把「旧号引用」判成可解析（校验 3 悬空引用 / 校验 4 重复定义）。批量改写属 §9 阶段 1，须逐批 dry-run + 三重复核（§7.3）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。",
   "aliases": {
     "N-31": {
       "to": null,
@@ -2829,6 +2829,270 @@
         "MDK-ARM/retracted_bench_20260922/README.txt",
         "scripts/README.md"
       ]
+    },
+    "TC-201": {
+      "to": "TC-NET-201",
+      "status": "renamed",
+      "note": "阶段 2 芯片层 TCP Client 用例 201~204 的裸形标注（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC-203": {
+      "to": "TC-NET-203",
+      "status": "renamed",
+      "note": "阶段 2 芯片层 TCP Client 用例 201~204 的裸形标注（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC201": {
+      "to": "TC-NET-201",
+      "status": "renamed",
+      "note": "阶段 2 芯片层 TCP Client 用例 201~204 的裸形标注（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC202": {
+      "to": "TC-NET-202",
+      "status": "renamed",
+      "note": "阶段 2 芯片层 TCP Client 用例 201~204 的裸形标注（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC203": {
+      "to": "TC-NET-203",
+      "status": "renamed",
+      "note": "阶段 2 芯片层 TCP Client 用例 201~204 的裸形标注（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC204": {
+      "to": "TC-NET-204",
+      "status": "renamed",
+      "note": "阶段 2 芯片层 TCP Client 用例 201~204 的裸形标注（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC 701": {
+      "to": "TC-NET-701",
+      "status": "renamed",
+      "note": "阶段 7 NET 层 TCP Client 用例 701~704（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC 702": {
+      "to": "TC-NET-702",
+      "status": "renamed",
+      "note": "阶段 7 NET 层 TCP Client 用例 701~704（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC 703": {
+      "to": "TC-NET-703",
+      "status": "renamed",
+      "note": "阶段 7 NET 层 TCP Client 用例 701~704（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC 704": {
+      "to": "TC-NET-704",
+      "status": "renamed",
+      "note": "阶段 7 NET 层 TCP Client 用例 701~704（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC701": {
+      "to": "TC-NET-701",
+      "status": "renamed",
+      "note": "阶段 7 NET 层 TCP Client 用例 701~704（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC702": {
+      "to": "TC-NET-702",
+      "status": "renamed",
+      "note": "阶段 7 NET 层 TCP Client 用例 701~704（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC703": {
+      "to": "TC-NET-703",
+      "status": "renamed",
+      "note": "阶段 7 NET 层 TCP Client 用例 701~704（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC704": {
+      "to": "TC-NET-704",
+      "status": "renamed",
+      "note": "阶段 7 NET 层 TCP Client 用例 701~704（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC-1501": {
+      "to": "TC-NET-1501",
+      "status": "renamed",
+      "note": "阶段 15 自愈驱动原语 1501/1502/1502b/1503（含 b 子项后缀，序号原样保留）（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC-1502": {
+      "to": "TC-NET-1502",
+      "status": "renamed",
+      "note": "阶段 15 自愈驱动原语 1501/1502/1502b/1503（含 b 子项后缀，序号原样保留）（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC-1502b": {
+      "to": "TC-NET-1502b",
+      "status": "renamed",
+      "note": "阶段 15 自愈驱动原语 1501/1502/1502b/1503（含 b 子项后缀，序号原样保留）（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC-1503": {
+      "to": "TC-NET-1503",
+      "status": "renamed",
+      "note": "阶段 15 自愈驱动原语 1501/1502/1502b/1503（含 b 子项后缀，序号原样保留）（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC1501": {
+      "to": "TC-NET-1501",
+      "status": "renamed",
+      "note": "阶段 15 自愈驱动原语 1501/1502/1502b/1503（含 b 子项后缀，序号原样保留）（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC1502": {
+      "to": "TC-NET-1502",
+      "status": "renamed",
+      "note": "阶段 15 自愈驱动原语 1501/1502/1502b/1503（含 b 子项后缀，序号原样保留）（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC1502b": {
+      "to": "TC-NET-1502b",
+      "status": "renamed",
+      "note": "阶段 15 自愈驱动原语 1501/1502/1502b/1503（含 b 子项后缀，序号原样保留）（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
+    },
+    "TC1503": {
+      "to": "TC-NET-1503",
+      "status": "renamed",
+      "note": "阶段 15 自愈驱动原语 1501/1502/1502b/1503（含 b 子项后缀，序号原样保留）（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
+      "scope": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ]
     }
   },
   "id_aliases": {}
diff --git a/scripts/id_known_backlog.json b/scripts/id_known_backlog.json
index 57ce5de5..08c0b79e 100644
--- a/scripts/id_known_backlog.json
+++ b/scripts/id_known_backlog.json
@@ -2,8 +2,8 @@
   "schema": 1,
   "note": "编号债务台账（docs/编号规范.md §8.4）：--strict 只对**台账之外**的新错误级问题拦提交。台账只许减不许增——还清的用 --prune-backlog 收掉；确需新增一条必须写 reason 字段说明这笔债为什么该存在，默认禁止顺手加行（否则一周后台账就变成第二个 backlog）。指纹 = 文件 + 校验号 + 字面量，不含行号（行号会漂，用它台账天天假新增）。",
   "generated_by": "scripts/check_ids.py --write-backlog",
-  "total_error_findings": 632,
-  "decidable_ratio_at_generation": 82.99,
+  "total_error_findings": 626,
+  "decidable_ratio_at_generation": 83.26,
   "entries": [
     {
       "file": ".dsh/skills/serial-assistant/scripts/serial_tool.py",
@@ -1139,42 +1139,6 @@
       "literal": "DP-04",
       "count": 3
     },
-    {
-      "file": "test/board/ch395f_test_task.c",
-      "code": 2,
-      "literal": "TC-1501",
-      "count": 1
-    },
-    {
-      "file": "test/board/ch395f_test_task.c",
-      "code": 2,
-      "literal": "TC-1502",
-      "count": 1
-    },
-    {
-      "file": "test/board/ch395f_test_task.c",
-      "code": 2,
-      "literal": "TC-1502b",
-      "count": 1
-    },
-    {
-      "file": "test/board/ch395f_test_task.c",
-      "code": 2,
-      "literal": "TC-1503",
-      "count": 1
-    },
-    {
-      "file": "test/board/ch395f_test_task.c",
-      "code": 2,
-      "literal": "TC-201",
-      "count": 1
-    },
-    {
-      "file": "test/board/ch395f_test_task.c",
-      "code": 2,
-      "literal": "TC-203",
-      "count": 1
-    },
     {
       "file": "test/board/ch395f_test_task.c",
       "code": 2,
diff --git a/scripts/rename_maps/batch6-net-annotate.json b/scripts/rename_maps/batch6-net-annotate.json
new file mode 100644
index 00000000..205bb697
--- /dev/null
+++ b/scripts/rename_maps/batch6-net-annotate.json
@@ -0,0 +1,61 @@
+{
+  "schema": 1,
+  "batch": "批 6（2026-10-21 板级 NET 用例号标注）",
+  "applied_by": "scripts/rename_ids.py",
+  "record": "docs/编号规范.md §8.3",
+  "note": "追溯器分档后暴露的真问题：板级 NET 用例的**实现体里标的是裸形**（TC204 / TC-201 / TC1501 / TC1502b…），文档侧写的是合规号 TC-NET-204 等 → 双向追溯对不上，看上去像「文档声明了没实现」，实际是**标注形态烂**。本批只补模块码、序号一位不改（§7.1），作用域限定 5 个真载体文件；改完 @build 验证（改到 test/board 与 Drivers/BSP/CH395F 注释）。刻意不含别的模块（host 侧 TC-00x 那批属另一个模块，另批处理）。",
+  "batches": [
+    {
+      "family": "TC",
+      "old": "\\bTC[- ]?(?P<n>20[1-4])\\b",
+      "new": "TC-NET-{n}",
+      "files": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ],
+      "note": "阶段 2 芯片层 TCP Client 用例 201~204 的裸形标注"
+    },
+    {
+      "family": "TC",
+      "old": "\\bTC[- ]?(?P<n>70[1-4])\\b",
+      "new": "TC-NET-{n}",
+      "files": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ],
+      "note": "阶段 7 NET 层 TCP Client 用例 701~704"
+    },
+    {
+      "family": "TC",
+      "old": "\\bTC[- ]?(?P<n>15\\d{2}b?)\\b",
+      "new": "TC-NET-{n}",
+      "files": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ],
+      "note": "阶段 15 自愈驱动原语 1501/1502/1502b/1503（含 b 子项后缀，序号原样保留）"
+    },
+    {
+      "family": "TC",
+      "old": "\\bTC[- ]?(?P<n>60[16]|80[12]|90[12]|1006|110[01])\\b",
+      "new": "TC-NET-{n}",
+      "files": [
+        "test/board/ch395f_test_task.c",
+        "test/board/net_test_task.c",
+        "test/board/net_test_task.h",
+        "test/host/ch395f_socket_test.py",
+        "Drivers/BSP/CH395F/ch395f.c"
+      ],
+      "note": "阶段 6/8/9/11/12 的 601/606/801/802/901/902/1006/1100/1101 裸形（有则补，无则 0 命中）"
+    }
+  ]
+}
diff --git a/test/board/ch395f_test_task.c b/test/board/ch395f_test_task.c
index ec0371dd..ebbf73b0 100644
--- a/test/board/ch395f_test_task.c
+++ b/test/board/ch395f_test_task.c
@@ -277,7 +277,7 @@ static void phase1_run(void) {
 #define PHASE2_TIMEOUT_MS       10000
 #endif
 #ifndef PHASE2_TC203_TIMEOUT_MS
-#define PHASE2_TC203_TIMEOUT_MS 30000   /* TC-203 连接超时窗（指南规定 30s） */
+#define PHASE2_TC203_TIMEOUT_MS 30000   /* TC-NET-203 连接超时窗（指南规定 30s） */
 #endif
 
 /* TCP Client 单次会话：对应 TC-NET-201 步 2~7 与 TC-NET-202 每轮 6 步。
@@ -309,7 +309,7 @@ static void phase2_tc201(void)
     ch395f_set_des_port(sock, PHASE2_REMOTE_PORT);
     ch395f_set_sour_port(sock, (uint16_t)PHASE2_LOCAL_PORT);
     TEST_CHECK(ch395f_get_cmd_status() == CH395F_ERR_SUCCESS,
-               "TC201 step1 cfg proto/ip/port");
+               "TC-NET-201 step1 cfg proto/ip/port");
     if (ch395f_get_cmd_status() != CH395F_ERR_SUCCESS) return;
 
     /* 构造 64 字节递增模式数据 0x00..0x3F */
@@ -319,12 +319,12 @@ static void phase2_tc201(void)
 
     /* 步2：OPEN Socket 0 */
     r = ch395f_open_socket(sock);
-    TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC201 step2 open");
+    TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC-NET-201 step2 open");
     if (r != CH395F_ERR_SUCCESS) return;
 
     /* 步3：CONNECT */
     r = ch395f_tcp_connect(sock);
-    TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC201 step3 connect");
+    TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC-NET-201 step3 connect");
     if (r != CH395F_ERR_SUCCESS) { ch395f_close_socket(sock); return; }
 
     /* 步4：等待 CONNECT 中断
@@ -349,7 +349,7 @@ static void phase2_tc201(void)
          * 继续下一轮轮询等 CONNECT */
         HAL_Delay(10);   /* 10ms 轮询周期，直至 CONNECT 或超时退出 */
     }
-    TEST_CHECK(ok, "TC201 step4 connected");
+    TEST_CHECK(ok, "TC-NET-201 step4 connected");
     if (!ok) {
         ch395f_close_socket(sock);
         return;
@@ -367,7 +367,7 @@ static void phase2_tc201(void)
         }
         HAL_Delay(10);
     }
-    TEST_CHECK(ok, "TC201 step5 sendbuf_free");
+    TEST_CHECK(ok, "TC-NET-201 step5 sendbuf_free");
     if (!ok) {
         ch395f_close_socket(sock);
         return;
@@ -419,7 +419,7 @@ static void phase2_tc201(void)
                     break;
                 }
             }
-            TEST_CHECK(match, "TC201 step6 echo verify");
+            TEST_CHECK(match, "TC-NET-201 step6 echo verify");
 
             ok = 1;      /* 标记"收到过数据"，循环外的 echo rcvd 检查不再重复报错 */
             break;       /* 校验结论已得出，无论 PASS/FAIL 都跳出 */
@@ -442,7 +442,7 @@ static void phase2_tc201(void)
      *   ok==1：收到过数据，结果已由循环内 "echo verify" 记录；
      *   ok==0：10s 内什么都没收到 / 中途断开 —— 在此补一条 FAIL。 */
     if (!ok) {
-        TEST_CHECK(0, "TC201 step6 echo rcvd");
+        TEST_CHECK(0, "TC-NET-201 step6 echo rcvd");
     }
 
     /* 步7：关闭 Socket 并等待状态回到 CLOSED（CH395F_SOCKET_CLOSED = 0x00） */
@@ -458,7 +458,7 @@ static void phase2_tc201(void)
         }
         HAL_Delay(50);
     }
-    TEST_CHECK(ok, "TC201 step7 closed");
+    TEST_CHECK(ok, "TC-NET-201 step7 closed");
     HAL_Delay(200);
 }
 
@@ -483,12 +483,12 @@ static void phase2_tc202_once(uint8_t sock, uint16_t local_port)
     /* 步1：设置本地端口并 OPEN Socket 0 */
     ch395f_set_sour_port(sock, local_port);
     r = ch395f_open_socket(sock);
-    TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC202 step1 open");
+    TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC-NET-202 step1 open");
     if (r != CH395F_ERR_SUCCESS) return;
 
     /* 步2：CONNECT */
     r = ch395f_tcp_connect(sock);
-    TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC202 step2 connect");
+    TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC-NET-202 step2 connect");
     if (r != CH395F_ERR_SUCCESS) { ch395f_close_socket(sock); return; }
 
     /* 步3：等待 CONNECT 中断 */
@@ -498,7 +498,7 @@ static void phase2_tc202_once(uint8_t sock, uint16_t local_port)
         if (ch395f_get_sock_int_status(sock) & CH395F_SINT_STAT_CONNECT) { ok = 1; break; }
         HAL_Delay(10);
     }
-    TEST_CHECK(ok, "TC202 step3 connected");
+    TEST_CHECK(ok, "TC-NET-202 step3 connected");
     if (!ok) { ch395f_close_socket(sock); return; }
     HAL_Delay(100);
 
@@ -510,7 +510,7 @@ static void phase2_tc202_once(uint8_t sock, uint16_t local_port)
         if (ch395f_get_sock_int_status(sock) & CH395F_SINT_STAT_SENBUF_FREE) { ok = 1; break; }
         HAL_Delay(10);
     }
-    TEST_CHECK(ok, "TC202 step4 sendbuf_free");
+    TEST_CHECK(ok, "TC-NET-202 step4 sendbuf_free");
     if (!ok) { ch395f_close_socket(sock); return; }
 
     /* 步5：等待回显并验证 */
@@ -527,7 +527,7 @@ static void phase2_tc202_once(uint8_t sock, uint16_t local_port)
             for (p = 0; p < n; p++) {
                 if (rx[p] != tx[p]) { match = 0; break; }
             }
-            TEST_CHECK(match, "TC202 step5 echo verify");
+            TEST_CHECK(match, "TC-NET-202 step5 echo verify");
             ok = 1;
             break;
         }
@@ -535,7 +535,7 @@ static void phase2_tc202_once(uint8_t sock, uint16_t local_port)
             (CH395F_SINT_STAT_DISCONNECT | CH395F_SINT_STAT_SOCK_TIMEOUT)) break;
         HAL_Delay(50);
     }
-    if (!ok) TEST_CHECK(0, "TC202 step5 echo rcvd");
+    if (!ok) TEST_CHECK(0, "TC-NET-202 step5 echo rcvd");
 
     /* 步6：关闭 + 等待 CLOSED */
     ch395f_close_socket(sock);
@@ -547,7 +547,7 @@ static void phase2_tc202_once(uint8_t sock, uint16_t local_port)
         if (st[0] == CH395F_SOCKET_CLOSED) { ok = 1; break; }
         HAL_Delay(50);
     }
-    TEST_CHECK(ok, "TC202 step6 closed");
+    TEST_CHECK(ok, "TC-NET-202 step6 closed");
     HAL_Delay(200);
 }
 
@@ -629,12 +629,12 @@ static uint8_t tc204_session(uint8_t sock, uint16_t lport, uint8_t mode, uint8_t
     ch395f_set_sour_port(sock, lport);
     r = ch395f_open_socket(sock);
     if (r != CH395F_ERR_SUCCESS) {
-        DBG_INFO("TC204 m%u r%u open ret=0x%02X", (unsigned)mode, (unsigned)round, r);
+        DBG_INFO("TC-NET-204 m%u r%u open ret=0x%02X", (unsigned)mode, (unsigned)round, r);
         return 0;
     }
     r = ch395f_tcp_connect(sock);
     if (r != CH395F_ERR_SUCCESS) {
-        DBG_INFO("TC204 m%u r%u connect cmd ret=0x%02X", (unsigned)mode, (unsigned)round, r);
+        DBG_INFO("TC-NET-204 m%u r%u connect cmd ret=0x%02X", (unsigned)mode, (unsigned)round, r);
         ch395f_close_socket(sock);
         return 0;
     }
@@ -648,14 +648,14 @@ static uint8_t tc204_session(uint8_t sock, uint16_t lport, uint8_t mode, uint8_t
             break;
         }
         if (si != 0U) {
-            DBG_INFO("TC204 m%u r%u stale-int=0x%02X at +%ums",
+            DBG_INFO("TC-NET-204 m%u r%u stale-int=0x%02X at +%ums",
                      (unsigned)mode, (unsigned)round, si,
                      (unsigned)(HAL_GetTick() - tick));
         }
         HAL_Delay(10);
     }
     if (!ok) {
-        DBG_INFO("TC204 m%u r%u no CONNECT within %ums", (unsigned)mode, (unsigned)round,
+        DBG_INFO("TC-NET-204 m%u r%u no CONNECT within %ums", (unsigned)mode, (unsigned)round,
                  (unsigned)PHASE2_TIMEOUT_MS);
         ch395f_close_socket(sock);
         return 0;
@@ -674,7 +674,7 @@ static uint8_t tc204_session(uint8_t sock, uint16_t lport, uint8_t mode, uint8_t
         HAL_Delay(10);
     }
     if (!ok) {
-        DBG_INFO("TC204 m%u r%u no SENBUF_FREE", (unsigned)mode, (unsigned)round);
+        DBG_INFO("TC-NET-204 m%u r%u no SENBUF_FREE", (unsigned)mode, (unsigned)round);
         ch395f_close_socket(sock);
         return 0;
     }
@@ -694,14 +694,14 @@ static uint8_t tc204_session(uint8_t sock, uint16_t lport, uint8_t mode, uint8_t
                 }
             }
             if (!match) {
-                DBG_INFO("TC204 m%u r%u echo MISMATCH (rlen=%u)", (unsigned)mode,
+                DBG_INFO("TC-NET-204 m%u r%u echo MISMATCH (rlen=%u)", (unsigned)mode,
                          (unsigned)round, (unsigned)rlen);
             }
             return match;
         }
         HAL_Delay(20);
     }
-    DBG_INFO("TC204 m%u r%u echo NOT rcvd", (unsigned)mode, (unsigned)round);
+    DBG_INFO("TC-NET-204 m%u r%u echo NOT rcvd", (unsigned)mode, (unsigned)round);
     ch395f_close_socket(sock);
     return 0;
 }
@@ -724,11 +724,11 @@ static uint8_t tc204_close_seq(uint8_t sock, uint8_t mode, uint8_t round)
 
     if (mode >= 1U) {
         uint8_t r = ch395f_tcp_disconnect(sock);
-        DBG_INFO("TC204 m%u r%u disconnect ret=0x%02X", (unsigned)mode, (unsigned)round, r);
+        DBG_INFO("TC-NET-204 m%u r%u disconnect ret=0x%02X", (unsigned)mode, (unsigned)round, r);
     }
     if (mode <= 1U) {
         uint8_t r = ch395f_close_socket(sock);
-        DBG_INFO("TC204 m%u r%u close ret=0x%02X", (unsigned)mode, (unsigned)round, r);
+        DBG_INFO("TC-NET-204 m%u r%u close ret=0x%02X", (unsigned)mode, (unsigned)round, r);
     }
 
     tick = HAL_GetTick();
@@ -736,7 +736,7 @@ static uint8_t tc204_close_seq(uint8_t sock, uint8_t mode, uint8_t round)
         ch395f_get_socket_status(sock, st);
         el = (uint32_t)(HAL_GetTick() - tick);
         while ((mi < n_marks) && (el >= s_marks[mi])) {
-            DBG_INFO("TC204 m%u r%u poll +%ums st=0x%02X/0x%02X", (unsigned)mode,
+            DBG_INFO("TC-NET-204 m%u r%u poll +%ums st=0x%02X/0x%02X", (unsigned)mode,
                      (unsigned)round, (unsigned)s_marks[mi], st[0], st[1]);
             mi++;
         }
@@ -749,10 +749,10 @@ static uint8_t tc204_close_seq(uint8_t sock, uint8_t mode, uint8_t round)
     /* 判定瞬间再读一次：byte0 已 CLOSED 时 byte1 按 §5.22/官方注释属"无意义"区 */
     ch395f_get_socket_status(sock, st);
     if (closed != 0U) {
-        DBG_INFO("TC204 m%u r%u CLOSED at +%ums (byte0=0x%02X byte1=0x%02X)",
+        DBG_INFO("TC-NET-204 m%u r%u CLOSED at +%ums (byte0=0x%02X byte1=0x%02X)",
                  (unsigned)mode, (unsigned)round, (unsigned)el, st[0], st[1]);
     } else {
-        DBG_INFO("TC204 m%u r%u NOT-CLOSED within %ums (byte0=0x%02X byte1=0x%02X)",
+        DBG_INFO("TC-NET-204 m%u r%u NOT-CLOSED within %ums (byte0=0x%02X byte1=0x%02X)",
                  (unsigned)mode, (unsigned)round, (unsigned)PHASE204_CLOSE_WAIT_MS,
                  st[0], st[1]);
     }
@@ -761,7 +761,7 @@ static uint8_t tc204_close_seq(uint8_t sock, uint8_t mode, uint8_t round)
 
 /* 轮末收尾：关闭本轮第二条连接并等回 CLOSED
  * 说明：芯片不允许对已 OPEN 的 Socket 再 open（返回 0x20 FAIL）——不收尾则下一轮
- *       首轮 open 必失败并级联（2026-10-11 TC204 首跑实测踩过）。 */
+ *       首轮 open 必失败并级联（2026-10-11 TC-NET-204 首跑实测踩过）。 */
 static void tc204_round_teardown(uint8_t sock)
 {
     uint8_t st[2] = { 0, 0 };
@@ -788,12 +788,12 @@ static void phase2_tc204_once(uint8_t mode, uint8_t round)
     uint8_t s2;
     uint8_t closed;
 
-    DBG_INFO("TC204 === m%u r%u lport %u ===", (unsigned)mode, (unsigned)round,
+    DBG_INFO("TC-NET-204 === m%u r%u lport %u ===", (unsigned)mode, (unsigned)round,
              (unsigned)lport);
 
     /* 1. 建立真实连接（有连接才谈得上 FIN_WAIT_*） */
     s1 = tc204_session(sock, lport, mode, round);
-    TEST_CHECK(s1, "TC204 m%u r%u session1 (connect+echo)", (unsigned)mode, (unsigned)round);
+    TEST_CHECK(s1, "TC-NET-204 m%u r%u session1 (connect+echo)", (unsigned)mode, (unsigned)round);
     if (!s1) {
         tc204_round_teardown(sock);
         return;
@@ -803,24 +803,24 @@ static void phase2_tc204_once(uint8_t mode, uint8_t round)
     closed = tc204_close_seq(sock, mode, round);
     if (mode == 2U) {
         /* 模式 C 的预期恰恰相反：bit3=1（§5.52 ②）下芯片不得自行关闭 Socket */
-        TEST_CHECK(!closed, "TC204 m2 r%u stays OPEN after disconnect (FUN_PARA bit3)",
+        TEST_CHECK(!closed, "TC-NET-204 m2 r%u stays OPEN after disconnect (FUN_PARA bit3)",
                    (unsigned)round);
         if (!closed) {
             /* TRAP-NET-07 的"无法重新打开"现场：不 close 直接 open，看芯片返回什么 */
             uint8_t r = ch395f_open_socket(sock);
-            DBG_INFO("TC204 m2 r%u open-without-close ret=0x%02X", (unsigned)round, r);
+            DBG_INFO("TC-NET-204 m2 r%u open-without-close ret=0x%02X", (unsigned)round, r);
             /* 收尾：显式 close 并测耗时（证明 close 才是把 Socket 拉回 CLOSED 的动作） */
             (void)tc204_close_seq(sock, 0U, round);
         }
     } else {
-        TEST_CHECK(closed, "TC204 m%u r%u back to CLOSED within %ums", (unsigned)mode,
+        TEST_CHECK(closed, "TC-NET-204 m%u r%u back to CLOSED within %ums", (unsigned)mode,
                    (unsigned)round, (unsigned)PHASE204_CLOSE_WAIT_MS);
     }
 
     /* 3. 重开 + 重连 + 回显（TRAP-NET-07 的"无法重新打开"判据；TRAP-NET-09 沉降 200ms） */
     HAL_Delay(200);
     s2 = tc204_session(sock, (uint16_t)(lport + 64U), mode, round);
-    TEST_CHECK(s2, "TC204 m%u r%u reopen+reconnect+echo OK", (unsigned)mode, (unsigned)round);
+    TEST_CHECK(s2, "TC-NET-204 m%u r%u reopen+reconnect+echo OK", (unsigned)mode, (unsigned)round);
     tc204_round_teardown(sock);
 }
 
@@ -847,7 +847,7 @@ static void phase2_tc204(void)
 
 /* TC-NET-203（硬件层）：TCP Client 连接超时（负向测试，P1）
  *
- * 前置环境：PC 未在 192.168.1.2:8081 提供服务（与 TC-201/202 互斥，
+ * 前置环境：PC 未在 192.168.1.2:8081 提供服务（与 TC-NET-201/202 互斥，
  * 需先关闭 PC 端 tcp_server）。固件自行辨别环境错误：
  * 若等待期间误收到 CONNECT，说明 PC 服务未关，判 FAIL 并给出指引。
  *
@@ -884,7 +884,7 @@ static void phase2_tc203(void)
     ch395f_set_des_port(sock, (uint16_t)PHASE2_REMOTE_PORT);
     ch395f_set_sour_port(sock, sour_port);
     TEST_CHECK(ch395f_get_cmd_status() == CH395F_ERR_SUCCESS,
-               "TC203 step1 cfg proto/ip/port");
+               "TC-NET-203 step1 cfg proto/ip/port");
     if (ch395f_get_cmd_status() != CH395F_ERR_SUCCESS) return;
 
     /* 预清陈旧事件（TRAP-NET-12）：上一会话 close 的 DISCONNECT 可能滞后锁存
@@ -896,11 +896,11 @@ static void phase2_tc203(void)
     /* 步2：OPEN + CONNECT。命令为异步下发，此时均应立即返回成功，
      * 真正的失败结果由步 3 的中断体现 */
     r = ch395f_open_socket(sock);
-    TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC203 step2 open");
+    TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC-NET-203 step2 open");
     if (r != CH395F_ERR_SUCCESS) return;
 
     r = ch395f_tcp_connect(sock);
-    TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC203 step2 connect");
+    TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC-NET-203 step2 connect");
     if (r != CH395F_ERR_SUCCESS) { ch395f_close_socket(sock); return; }
 
     /* 步3：30s 直读本 Socket SINT 轮询（读即清），等"连不上"的证据。
@@ -963,12 +963,12 @@ static void phase2_tc203(void)
             short_tag = "T/O-slow(silence)";
         }
         DBG_INFO("  negative event @%lums: %s", elapsed, why);
-        TEST_CHECK(1, "TC203 step3 no-connect OK (%lums %s)", elapsed, short_tag);
+        TEST_CHECK(1, "TC-NET-203 step3 no-connect OK (%lums %s)", elapsed, short_tag);
     } else if (ev == 2) {
         DBG_ERROR("  CONNECT received -> PC 8081 server is still running!");
-        TEST_CHECK(0, "TC203 step3 connected?! stop PC server and retry");
+        TEST_CHECK(0, "TC-NET-203 step3 connected?! stop PC server and retry");
     } else {
-        TEST_CHECK(0, "TC203 step3 no interrupt in %dms (state machine hang?)",
+        TEST_CHECK(0, "TC-NET-203 step3 no interrupt in %dms (state machine hang?)",
                    PHASE2_TC203_TIMEOUT_MS);
     }
 
@@ -982,7 +982,7 @@ static void phase2_tc203(void)
         if (st[0] == CH395F_SOCKET_CLOSED) { ev = 1; break; }
         HAL_Delay(50);
     }
-    TEST_CHECK(ev == 1, "TC203 step4 closed");
+    TEST_CHECK(ev == 1, "TC-NET-203 step4 closed");
 
     HAL_Delay(200);
 }
@@ -1599,7 +1599,7 @@ static void phase15_run(void) {
 
     DBG_INFO("=== CH395F Phase 15 Tests (self-heal phase-2 primitives) ===");
 
-    /* ---- TC-1501: 状态回读一致性 + cmd_done 语义（E2/E3 定案形态） ---- */
+    /* ---- TC-NET-1501: 状态回读一致性 + cmd_done 语义（E2/E3 定案形态） ---- */
     ch395f_set_proto_type(sn, CH395F_PROTO_TYPE_TCP);
     ch395f_set_sour_port(sn, 5107U);
     (void)ch395f_open_socket(sn);
@@ -1609,7 +1609,7 @@ static void phase15_run(void) {
         if (ch395f_cmd_done(sn, CH395F_DONE_OPEN) == 1) { done = 1; break; }
         HAL_Delay(1);
     }
-    TEST_CHECK(done == 1, "TC1501 open done within 50ms");
+    TEST_CHECK(done == 1, "TC-NET-1501 open done within 50ms");
 
     (void)ch395f_tcp_listen(sn);
     t0 = HAL_GetTick();
@@ -1619,11 +1619,11 @@ static void phase15_run(void) {
         HAL_Delay(1);
     }
     /* E2 矩阵：LISTEN 可见延迟 100% <=10ms（24 轮无长尾） */
-    TEST_CHECK(done == 1, "TC1501 listen done within 20ms (E2: 100 pct <=10ms)");
-    TEST_CHECK(ch395f_sock_is_listening(sn) == 1, "TC1501 cached is_listening");
+    TEST_CHECK(done == 1, "TC-NET-1501 listen done within 20ms (E2: 100 pct <=10ms)");
+    TEST_CHECK(ch395f_sock_is_listening(sn) == 1, "TC-NET-1501 cached is_listening");
     st = ch395f_sock_state_cached(sn);
     TEST_CHECK(st.open == CH395F_SOCKET_OPEN && st.tcp_state == CH395F_TCP_LISTEN,
-               "TC1501 cached state 05/01 (got %02X/%02X)", st.open, st.tcp_state);
+               "TC-NET-1501 cached state 05/01 (got %02X/%02X)", st.open, st.tcp_state);
 
     /* 二段关闭实证（2026-10-13 本 TC 二跑定案）：LISTEN 态 Socket 的
      * CLOSE_SOCKET 返 SUCCESS 但只拆监听（TCP 01->00），byte0 恒 05；
@@ -1631,10 +1631,10 @@ static void phase15_run(void) {
      * sock_reset 状态机在 WAIT_CLOSE 阶段自行补发（见 ch395f.c）。 */
     uint8_t close_st = ch395f_close_socket(sn);
     TEST_CHECK(close_st == CH395F_ERR_SUCCESS,
-               "TC1501 close cmd st=0x%02X (expect 00)", close_st);
+               "TC-NET-1501 close cmd st=0x%02X (expect 00)", close_st);
     st = ch395f_get_sock_state(sn);
     TEST_CHECK(st.open == CH395F_SOCKET_OPEN && st.tcp_state == CH395F_TCP_CLOSED,
-               "TC1501 listen-close stage1: 05/00 listen torn down (got %02X/%02X)",
+               "TC-NET-1501 listen-close stage1: 05/00 listen torn down (got %02X/%02X)",
                st.open, st.tcp_state);
     (void)ch395f_close_socket(sn);
     t0 = HAL_GetTick();
@@ -1643,20 +1643,20 @@ static void phase15_run(void) {
         if (ch395f_cmd_done(sn, CH395F_DONE_CLOSE) == 1) { done = (int)(HAL_GetTick() - t0); break; }
         HAL_Delay(1);
     }
-    TEST_CHECK(done >= 0, "TC1501 listen-close stage2: byte0=00 in %dms (win 500)", done);
+    TEST_CHECK(done >= 0, "TC-NET-1501 listen-close stage2: byte0=00 in %dms (win 500)", done);
     st = ch395f_get_sock_state(sn);
     TEST_CHECK(st.tcp_state == CH395F_SOCK_STATE_NONE,
-               "TC1501 tcp_state sentinel 0xFF when closed (got %02X)", st.tcp_state);
+               "TC-NET-1501 tcp_state sentinel 0xFF when closed (got %02X)", st.tcp_state);
     st = ch395f_get_sock_state(8U);
     TEST_CHECK(st.open == CH395F_SOCKET_CLOSED && st.tcp_state == CH395F_SOCK_STATE_NONE,
-               "TC1501 sn=8 boundary -> CLOSED+sentinel");
+               "TC-NET-1501 sn=8 boundary -> CLOSED+sentinel");
 
-    /* ---- TC-1502: sock_reset 非阻塞状态机跑通（E4 定案序列） ---- */
+    /* ---- TC-NET-1502: sock_reset 非阻塞状态机跑通（E4 定案序列） ---- */
     (void)ch395f_open_socket(sn);
     rc = ch395f_sock_reset_begin(sn, CH395F_RESET_QUARANTINE);
-    TEST_CHECK(rc == 0, "TC1502 begin accepted (rc=%d)", rc);
+    TEST_CHECK(rc == 0, "TC-NET-1502 begin accepted (rc=%d)", rc);
     TEST_CHECK(ch395f_sock_reset_begin(sn, CH395F_RESET_QUARANTINE) == -1,
-               "TC1502 busy reject on second begin");
+               "TC-NET-1502 busy reject on second begin");
     t0 = HAL_GetTick();
     rc = 1;
     while (rc == 1 && (uint32_t)(HAL_GetTick() - t0) < 3000U) {
@@ -1664,15 +1664,15 @@ static void phase15_run(void) {
         HAL_Delay(1);
     }
     /* QUARANTINE 最短等待 400ms + 各阶段，3s 窗内必落定 */
-    TEST_CHECK(rc == 0, "TC1502 reset done within 3000ms (rc=%d)", rc);
-    TEST_CHECK(ch395f_cmd_done(sn, CH395F_DONE_CLOSE) == 1, "TC1502 chip CLOSED after reset");
-    TEST_CHECK(ch395f_sock_reset_poll(sn) == 0, "TC1502 poll idempotent after done");
+    TEST_CHECK(rc == 0, "TC-NET-1502 reset done within 3000ms (rc=%d)", rc);
+    TEST_CHECK(ch395f_cmd_done(sn, CH395F_DONE_CLOSE) == 1, "TC-NET-1502 chip CLOSED after reset");
+    TEST_CHECK(ch395f_sock_reset_poll(sn) == 0, "TC-NET-1502 poll idempotent after done");
     /* 复位后可重开（复位语义 = 回到可用态） */
     (void)ch395f_open_socket(sn);
-    TEST_CHECK(ch395f_cmd_done(sn, CH395F_DONE_OPEN) == 1, "TC1502 reopen after reset OK");
+    TEST_CHECK(ch395f_cmd_done(sn, CH395F_DONE_OPEN) == 1, "TC-NET-1502 reopen after reset OK");
     (void)ch395f_close_socket(sn);
 
-    /* TC-1502b: LISTEN 态 Socket 复位（走 WAIT_CLOSE 二段补发路径，GRACEFUL） */
+    /* TC-NET-1502b: LISTEN 态 Socket 复位（走 WAIT_CLOSE 二段补发路径，GRACEFUL） */
     (void)ch395f_open_socket(sn);
     (void)ch395f_tcp_listen(sn);
     rc = ch395f_sock_reset_begin(sn, CH395F_RESET_GRACEFUL);
@@ -1682,16 +1682,16 @@ static void phase15_run(void) {
         rc = ch395f_sock_reset_poll(sn);
         HAL_Delay(1);
     }
-    TEST_CHECK(rc == 0, "TC1502b reset on LISTEN socket done (rc=%d, two-stage absorbed)", rc);
-    TEST_CHECK(ch395f_cmd_done(sn, CH395F_DONE_CLOSE) == 1, "TC1502b chip CLOSED after listen-reset");
+    TEST_CHECK(rc == 0, "TC-NET-1502b reset on LISTEN socket done (rc=%d, two-stage absorbed)", rc);
+    TEST_CHECK(ch395f_cmd_done(sn, CH395F_DONE_CLOSE) == 1, "TC-NET-1502b chip CLOSED after listen-reset");
 
-    /* ---- TC-1503: 链路态缓存 + 事件护栏边界 ---- */
+    /* ---- TC-NET-1503: 链路态缓存 + 事件护栏边界 ---- */
     uint16_t c0 = ch395f_link_change_count();
     ch395f_glob_event_feed(CH395F_GINT_STAT_PHY_CHANGE);  /* 首次 feed 建档 */
     ch395f_glob_event_feed(CH395F_GINT_STAT_PHY_CHANGE);  /* 链路稳定：不应虚增计数 */
-    TEST_CHECK(ch395f_link_change_count() == c0, "TC1503 no spurious link change on stable link");
-    TEST_CHECK(ch395f_link_up_cached() == 1U, "TC1503 link_up cached (bench link present)");
-    TEST_CHECK(ch395f_sock_events(8U) == 0U, "TC1503 sock_events sn=8 boundary -> 0");
+    TEST_CHECK(ch395f_link_change_count() == c0, "TC-NET-1503 no spurious link change on stable link");
+    TEST_CHECK(ch395f_link_up_cached() == 1U, "TC-NET-1503 link_up cached (bench link present)");
+    TEST_CHECK(ch395f_sock_events(8U) == 0U, "TC-NET-1503 sock_events sn=8 boundary -> 0");
     (void)ch395f_sock_events(sn);   /* 读即清护栏：合法调用不崩 */
 
     TEST_REPORT("Phase 15");
diff --git a/test/board/net_test_task.c b/test/board/net_test_task.c
index d74c067a..4b5bb394 100644
--- a/test/board/net_test_task.c
+++ b/test/board/net_test_task.c
@@ -118,8 +118,8 @@ static void phase6_run(int32_t sockfd) {
  *          4. 连接超时负向用例（PC 服务关闭时 connect 不应成功）
  *
  * 入口条件：PC 运行 `python test/ch395f_socket_test.py tcp_server --port 8081`
- *          （TC 703 需先关闭该服务）。
- * TC 映射：TC 701（连接 + 回显）/ TC 702（关闭重连）/ TC 703（连接超时）。
+ *          （TC-NET-703 需先关闭该服务）。
+ * TC 映射：TC-NET-701（连接 + 回显）/ TC-NET-702（关闭重连）/ TC-NET-703（连接超时）。
  * 通过：回显逐字节一致且 32 位 checksum 匹配；重连全部成功；超时用例未建连。
  * 失败：连接失败 / 回显不一致 / 重连中断 / 超时用例误建连。
  * =================================================================== */
@@ -146,7 +146,7 @@ static void phase6_run(int32_t sockfd) {
 #define PHASE7_CONN_TIMEOUT_MS  10000
 #endif
 #ifndef PHASE7_TIMEOUT_TEST_MS
-#define PHASE7_TIMEOUT_TEST_MS  30000   /* TC 703 连接超时窗（指南规定 30s） */
+#define PHASE7_TIMEOUT_TEST_MS  30000   /* TC-NET-703 连接超时窗（指南规定 30s） */
 #endif
 
 /* 32 位累加和：足以发现丢字节/错位，比 CRC32 便宜 */
@@ -156,14 +156,14 @@ static uint32_t phase7_cksum(const uint8_t *p, uint32_t n) {
     return s;
 }
 
-/* 单次 TCP Client 会话：对应 TC 701 主体 / TC 702 单轮。
+/* 单次 TCP Client 会话：对应 TC-NET-701 主体 / TC-NET-702 单轮。
  * 每轮使用不同本地端口 local_port 规避 TIME_WAIT。
  * 返回 1 表示全流程通过，0 表示中途失败（已记录 TEST_CHECK）。 */
 static int32_t phase7_session(uint16_t local_port)
 {
     int32_t sockfd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
     if (sockfd < 0) {
-        TEST_CHECK(0, "TC701 socket create");
+        TEST_CHECK(0, "TC-NET-701 socket create");
         return 0;
     }
 
@@ -174,7 +174,7 @@ static int32_t phase7_session(uint16_t local_port)
         laddr.sin_family = NET_AF_INET;
         laddr.sin_port   = net_htons(local_port);
         if (net_bind(sockfd, (struct net_sockaddr *)&laddr, sizeof(laddr)) < 0) {
-            TEST_CHECK(0, "TC701 bind port %d", local_port);
+            TEST_CHECK(0, "TC-NET-701 bind port %d", local_port);
             net_close(sockfd);
             return 0;
         }
@@ -187,10 +187,10 @@ static int32_t phase7_session(uint16_t local_port)
     raddr.sin_port        = net_htons((uint16_t)PHASE7_REMOTE_PORT);
     raddr.sin_addr.s_addr = net_inet_addr(PHASE7_REMOTE_IP);
 
-    DBG_INFO("TC701 connecting %s:%d (local port %d)",
+    DBG_INFO("TC-NET-701 connecting %s:%d (local port %d)",
              PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT, local_port);
     int32_t rc = net_connect(sockfd, (struct net_sockaddr *)&raddr, sizeof(raddr));
-    TEST_CHECK(rc == 0, "TC701 connect issued (ret=%d)", rc);
+    TEST_CHECK(rc == 0, "TC-NET-701 connect issued (ret=%d)", rc);
     if (rc != 0) { net_close(sockfd); return 0; }
 
     /* 等待连接建立：轮询 socket 状态（ESTABLISHED）。
@@ -208,7 +208,7 @@ static int32_t phase7_session(uint16_t local_port)
             }
             osDelay(100);   /* 仅作等待/让出 CPU；连接状态由 netTask 的 net_poll 每 10ms 刷新 */
         }
-        TEST_CHECK(connected, "TC701 connected within %dms", PHASE7_CONN_TIMEOUT_MS);
+        TEST_CHECK(connected, "TC-NET-701 connected within %dms", PHASE7_CONN_TIMEOUT_MS);
         if (!connected) { net_close(sockfd); return 0; }
     }
 
@@ -218,7 +218,7 @@ static int32_t phase7_session(uint16_t local_port)
     for (int32_t i = 0; i < PHASE7_EXCH_SIZE; i++) tx[i] = (uint8_t)i;
 
     int32_t sent = net_send(sockfd, tx, PHASE7_EXCH_SIZE, 0);
-    TEST_CHECK(sent == PHASE7_EXCH_SIZE, "TC701 send %dB (sent=%d)", PHASE7_EXCH_SIZE, sent);
+    TEST_CHECK(sent == PHASE7_EXCH_SIZE, "TC-NET-701 send %dB (sent=%d)", PHASE7_EXCH_SIZE, sent);
     if (sent != PHASE7_EXCH_SIZE) { net_close(sockfd); return 0; }
 
     int32_t recvd = 0;
@@ -245,23 +245,23 @@ static int32_t phase7_session(uint16_t local_port)
         for (int32_t i = 0; i < PHASE7_EXCH_SIZE; i++) {
             if (rx[i] != (uint8_t)i) { bad = 1; break; }
         }
-        TEST_CHECK(!bad, "TC701 byte-compare %dB", PHASE7_EXCH_SIZE);
-        TEST_CHECK(1, "TC701 recv %dB, cksum=0x%08X", recvd, phase7_cksum(rx, PHASE7_EXCH_SIZE));
+        TEST_CHECK(!bad, "TC-NET-701 byte-compare %dB", PHASE7_EXCH_SIZE);
+        TEST_CHECK(1, "TC-NET-701 recv %dB, cksum=0x%08X", recvd, phase7_cksum(rx, PHASE7_EXCH_SIZE));
     } else {
-        TEST_CHECK(0, "TC701 recv %dB (expect %d)", recvd, PHASE7_EXCH_SIZE);
+        TEST_CHECK(0, "TC-NET-701 recv %dB (expect %d)", recvd, PHASE7_EXCH_SIZE);
     }
 
     net_close(sockfd);
     return ok;
 }
 
-/* TC 703（负向）：连接超时。PC 未在 REMOTE_IP:REMOTE_PORT 提供服务时，
- * connect 不应成功建立。本用例需先关闭 PC 端 tcp_server（与 TC 701/702 互斥环境：
+/* TC-NET-703（负向）：连接超时。PC 未在 REMOTE_IP:REMOTE_PORT 提供服务时，
+ * connect 不应成功建立。本用例需先关闭 PC 端 tcp_server（与 TC-NET-701/702 互斥环境：
  * 701/702 要求服务端在线，703 要求服务端离线，故 703 应在独立的一轮中运行）。 */
 static void phase7_test_timeout(void)
 {
     int32_t sockfd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
-    if (sockfd < 0) { TEST_CHECK(0, "TC703 socket create"); return; }
+    if (sockfd < 0) { TEST_CHECK(0, "TC-NET-703 socket create"); return; }
 
     struct net_sockaddr_in raddr;
     memset(&raddr, 0, sizeof(raddr));
@@ -269,10 +269,10 @@ static void phase7_test_timeout(void)
     raddr.sin_port        = net_htons((uint16_t)PHASE7_REMOTE_PORT);
     raddr.sin_addr.s_addr = net_inet_addr(PHASE7_REMOTE_IP);
 
-    DBG_INFO("TC703 connecting %s:%d (expect TIMEOUT, PC server must be OFF)",
+    DBG_INFO("TC-NET-703 connecting %s:%d (expect TIMEOUT, PC server must be OFF)",
              PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT);
     int32_t rc = net_connect(sockfd, (struct net_sockaddr *)&raddr, sizeof(raddr));
-    TEST_CHECK(rc == 0, "TC703 connect issued (ret=%d)", rc);
+    TEST_CHECK(rc == 0, "TC-NET-703 connect issued (ret=%d)", rc);
     if (rc != 0) { net_close(sockfd); return; }
 
     int32_t established = 0;
@@ -284,14 +284,14 @@ static void phase7_test_timeout(void)
         osDelay(100);   /* 仅作等待/让出 CPU；连接状态由 netTask 的 net_poll 每 10ms 刷新 */
     }
     if (established) {
-        TEST_CHECK(0, "TC703 connected?! stop PC server and retry");
+        TEST_CHECK(0, "TC-NET-703 connected?! stop PC server and retry");
     } else {
-        TEST_CHECK(1, "TC703 no-connect within %dms (timeout as expected)", PHASE7_TIMEOUT_TEST_MS);
+        TEST_CHECK(1, "TC-NET-703 no-connect within %dms (timeout as expected)", PHASE7_TIMEOUT_TEST_MS);
     }
     net_close(sockfd);
 }
 
-/* TC 704：多 Socket 并发 TCP Client。
+/* TC-NET-704：多 Socket 并发 TCP Client。
  * 并发上限 = NET_MAX_SOCKETS(8) − 3 个常驻监听（FTP / 对时 / 远显）= 5；
  * 本用例同时打开 Socket 0~4，各自连 PC echo server，每路独立收发
  * PHASE7_EXCH_SIZE 字节回显并比对，验证 5 个 Socket 均能独立工作。
@@ -315,7 +315,7 @@ static int32_t phase7_session_multi(void)
     for (int32_t i = 0; i < PHASE7_MULTI_COUNT; i++) {
         sockfd[i] = net_socket(NET_AF_INET, NET_SOCK_STREAM);
         if (sockfd[i] < 0) {
-            TEST_CHECK(0, "TC704 socket create #%d", i);
+            TEST_CHECK(0, "TC-NET-704 socket create #%d", i);
             for (int32_t j = 0; j < i; j++) net_close(sockfd[j]);
             return 0;
         }
@@ -324,7 +324,7 @@ static int32_t phase7_session_multi(void)
         laddr.sin_family = NET_AF_INET;
         laddr.sin_port   = net_htons((uint16_t)(PHASE7_MULTI_BASE_PORT + i));
         if (net_bind(sockfd[i], (struct net_sockaddr *)&laddr, sizeof(laddr)) < 0) {
-            TEST_CHECK(0, "TC704 bind #%d port %d", i, PHASE7_MULTI_BASE_PORT + i);
+            TEST_CHECK(0, "TC-NET-704 bind #%d port %d", i, PHASE7_MULTI_BASE_PORT + i);
             net_close(sockfd[i]);
             for (int32_t j = 0; j < i; j++) net_close(sockfd[j]);
             return 0;
@@ -335,7 +335,7 @@ static int32_t phase7_session_multi(void)
         raddr.sin_port        = net_htons((uint16_t)PHASE7_REMOTE_PORT);
         raddr.sin_addr.s_addr = net_inet_addr(PHASE7_REMOTE_IP);
         int32_t rc = net_connect(sockfd[i], (struct net_sockaddr *)&raddr, sizeof(raddr));
-        TEST_CHECK(rc == 0, "TC704 connect #%d issued (ret=%d)", i, rc);
+        TEST_CHECK(rc == 0, "TC-NET-704 connect #%d issued (ret=%d)", i, rc);
         if (rc != 0) {
             net_close(sockfd[i]);
             for (int32_t j = 0; j < i; j++) net_close(sockfd[j]);
@@ -356,11 +356,11 @@ static int32_t phase7_session_multi(void)
             if (all_up) break;
             osDelay(100);
         }
-        TEST_CHECK(all_up, "TC704 all %d sockets established within %dms", PHASE7_MULTI_COUNT, PHASE7_CONN_TIMEOUT_MS);
+        TEST_CHECK(all_up, "TC-NET-704 all %d sockets established within %dms", PHASE7_MULTI_COUNT, PHASE7_CONN_TIMEOUT_MS);
         if (!all_up) {
             for (int32_t i = 0; i < PHASE7_MULTI_COUNT; i++) {
                 net_sock_t *sk = net_get_sock(sockfd[i]);
-                if (sk) DBG_ERROR("TC704 socket #%d state=%d", i, sk->state);
+                if (sk) DBG_ERROR("TC-NET-704 socket #%d state=%d", i, sk->state);
                 net_close(sockfd[i]);
             }
             return 0;
@@ -372,7 +372,7 @@ static int32_t phase7_session_multi(void)
     for (int32_t i = 0; i < PHASE7_MULTI_COUNT; i++) {
         int32_t sent = net_send(sockfd[i], tx, PHASE7_EXCH_SIZE, 0);
         if (sent != PHASE7_EXCH_SIZE) {
-            TEST_CHECK(0, "TC704 socket #%d send %dB (sent=%d)", i, PHASE7_EXCH_SIZE, sent);
+            TEST_CHECK(0, "TC-NET-704 socket #%d send %dB (sent=%d)", i, PHASE7_EXCH_SIZE, sent);
             ok = 0;
             continue;
         }
@@ -393,9 +393,9 @@ static int32_t phase7_session_multi(void)
         if (sock_ok) {
             int32_t bad = 0;
             for (int32_t k = 0; k < PHASE7_EXCH_SIZE; k++) if (rx[k] != (uint8_t)k) { bad = 1; break; }
-            TEST_CHECK(!bad, "TC704 socket #%d echo %dB OK", i, PHASE7_EXCH_SIZE);
+            TEST_CHECK(!bad, "TC-NET-704 socket #%d echo %dB OK", i, PHASE7_EXCH_SIZE);
         } else {
-            TEST_CHECK(0, "TC704 socket #%d recv %dB (expect %d)", i, recvd, PHASE7_EXCH_SIZE);
+            TEST_CHECK(0, "TC-NET-704 socket #%d recv %dB (expect %d)", i, recvd, PHASE7_EXCH_SIZE);
             ok = 0;
         }
     }
@@ -410,23 +410,23 @@ void net_layer_client_test_main(void)
 {
     DBG_INFO("=== CH395F Phase 7 Tests (NET TCP Client) ===");
 
-    DBG_INFO("--- TC 701: connect + %dB echo exchange ---", PHASE7_EXCH_SIZE);
+    DBG_INFO("--- TC-NET-701: connect + %dB echo exchange ---", PHASE7_EXCH_SIZE);
     phase7_session((uint16_t)PHASE7_LOCAL_PORT);
 
-    DBG_INFO("--- TC 702: close/reconnect x%d ---", PHASE7_LOOP_COUNT);
+    DBG_INFO("--- TC-NET-702: close/reconnect x%d ---", PHASE7_LOOP_COUNT);
     {
         int32_t all_ok = 1;
         for (int32_t i = 0; i < PHASE7_LOOP_COUNT; i++) {
             if (!phase7_session((uint16_t)(PHASE7_LOCAL_PORT + 1 + i))) all_ok = 0;
         }
-        TEST_CHECK(all_ok, "TC702 reconnect x%d all passed", PHASE7_LOOP_COUNT);
+        TEST_CHECK(all_ok, "TC-NET-702 reconnect x%d all passed", PHASE7_LOOP_COUNT);
     }
 
-    DBG_INFO("--- TC 704: %d-socket concurrent client (PC %s:%d MUST be ON) ---",
+    DBG_INFO("--- TC-NET-704: %d-socket concurrent client (PC %s:%d MUST be ON) ---",
              PHASE7_MULTI_COUNT, PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT);
     phase7_session_multi();
 
-    DBG_INFO("--- TC 703: connect timeout (PC %s:%d MUST be OFF) ---",
+    DBG_INFO("--- TC-NET-703: connect timeout (PC %s:%d MUST be OFF) ---",
              PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT);
     phase7_test_timeout();
 
diff --git a/test/board/net_test_task.h b/test/board/net_test_task.h
index 2f406af5..d9003efe 100644
--- a/test/board/net_test_task.h
+++ b/test/board/net_test_task.h
@@ -12,7 +12,7 @@ void net_layer_test_main(void);
 
 /* NET 层 TCP Client 测试入口（定义于 net_test_task.c）。
  * 由 ch395fTestTask 在 NET 层构建模式下（ENABLE_PHASE7_TESTS）调用，
- * MCU 作为 TCP Client 主动连接 PC 回显服务器，覆盖 TC 701/702/703。 */
+ * MCU 作为 TCP Client 主动连接 PC 回显服务器，覆盖 TC-NET-701/702/703。 */
 void net_layer_client_test_main(void);
 
 #ifdef __cplusplus
diff --git a/test/host/ch395f_socket_test.py b/test/host/ch395f_socket_test.py
index dcb6353b..8f3616bf 100644
--- a/test/host/ch395f_socket_test.py
+++ b/test/host/ch395f_socket_test.py
@@ -158,8 +158,8 @@ def _echo_conn_handler(conn_idx, client_socket, counters, lock):
 def tcp_server_test(args):
     """TCP 回显服务器测试（测试 CH395F TCP Client）
 
-    与固件 TC701/702/704 配套：MCU 连接后发送数据并等待原样回显。
-    每个连接由独立线程处理，支持多 Socket 并发（TC704 一次打开 8 个）。
+    与固件 TC-NET-701/702/704 配套：MCU 连接后发送数据并等待原样回显。
+    每个连接由独立线程处理，支持多 Socket 并发（TC-NET-704 一次打开 8 个）。
 
     首个连接等待 args.timeout 秒；之后每个连接间最多等待 INTER_ACCEPT_TIMEOUT 秒；
     若指定 --max-conn（>0），达到连接数上限后停止接受并等待全部线程结束。
@@ -1267,7 +1267,7 @@ def main():
     parser.add_argument('--op', choices=['send', 'recv', 'echo'], default='recv',
                         help='tcp_file 方向: send=读文件发往 MCU, recv=从 MCU 收文件落盘, echo=连 MCU 回显')
     parser.add_argument('--file', default=None, help='tcp_file 文件路经（send: 读取; recv: 写入）')
-    parser.add_argument('--max-conn', type=int, default=0, help='最大并发连接数（默认0=不限；按并发计数，非累计，TC704 并发测试用 8）')
+    parser.add_argument('--max-conn', type=int, default=0, help='最大并发连接数（默认0=不限；按并发计数，非累计，TC-NET-704 并发测试用 8）')
     parser.add_argument('--dhcp-iface', default='192.168.1.2', help='DHCP 服务器网卡 IP')
     parser.add_argument('--dhcp-mask', default='255.255.255.0', help='DHCP 分配的子网掩码')
     parser.add_argument('--dhcp-gw', default='192.168.1.1', help='DHCP 分配的网关')