.cubemx_survival_baseline.json

@@ -13,7 +13,8 @@
     "stack-overflow-hook-impl": "a006edbd30d2c4d7",
     "malloc-failed-hook-impl": "fcd7250e5cd6403b",
     "stack-overflow-hook-helper": "cacd9fd028be9b5b",
-    "watchdog-module": "663f05caf22cf7d0",
+    "watchdog-module": "b3501b5ed1be1793",
+    "net-msgq-adopt": "a0f913e3f34c8e9e",
     "reset-cause-latch": "983927d587cb9f48",
     "iwdg-hal-driver": "4b902875a84554e9",
     "hal-iwdg-enabled": "1a8ed6cff34f7ba6",

App/util/task_watchdog.c

@@ -58,6 +58,16 @@
 #include "lftpd.h"         /* lftpd_task_wd_beat() 弱钩子声明（本文件提供强符号，见下方） */
 #include "sys_log.h"       /* SYSLOG_RUN（flush 诱导落盘）+ sys_log_evidence()（round 7 取证落盘） */
 #include "console_log.h"   /* dbg_console_tx_fault()（僵尸通道计数） */
+/* 测试构建可见性（2026-10-25 台架实测缺陷）：wd_required_mask() 里那条
+ * ENABLE_HW_LAYER_TESTS 分支要按"硬件层独占测试构建"剔除 netTask，而该宏定义在
+ * test/board/ch395f_test.h（由 test_config.h 拉入）。本文件此前没 include 它 →
+ * 宏在本 TU 永远不可见 → **那条分支自加入起就是死代码**，HW 层测试构建仍按产品
+ * 掩码 0x1F7 要求 netTask 供位，而 netTask 按设计自挂起 → 每 ~110ms 刷一条
+ * [ERR][WD] task stall（台架一轮刷出 468 条）。做法与 App/task/net_task.c 的
+ * #include "test_config.h" 一致；产品构建 TEST_SUITE_* 全注释、宏未定义，
+ * 走的仍是原分支（实测产品固件 Code/RO/RW/ZI 逐项不变）。
+ * 证据：boot log 20261025_050539（req=0x1F7 而 mask 最高只到 0x1F5）。 */
+#include "test_config.h"
 #endif
 
 #define DBG_TAG "[WD]"

scripts/check_size_gate.py

@@ -47,8 +47,13 @@
 
 指纹范围（= 会影响固件体积的全部受管源码）
     App/ Drivers/ Src/ Inc/ Lib/ Middlewares/ test/board/  以及 MDK-ARM 下的 .sct/.s
-列表取 `git ls-files`（与 layer-deps / id-check 同口径），逐文件 sha256(路径+内容) 再
-聚合；未跟踪文件与构建产物天然不在内。
+身份取 **git 索引 blob**（`git ls-files -s` 的 path+blob 逐行聚合哈希），不是工作树
+原始字节——本仓 core.autocrlf=true 而 .gitattributes 写死 eol=lf，实测主树 1046/1388
+个受管源码落成 CRLF、新建工作树同一提交落成 LF，而索引 blob 完全一致；按原始字节算
+会让同一份代码在不同 checkout 得到不同指纹（主树盖的戳在别人工作树与 runner 上误红）
+→ 索引 blob 才是跨 checkout 稳定的身份，也是 AGENTS「不依赖 core.autocrlf」的机器化。
+推论：**未 staged 的改动不在索引里**，凭证覆盖不到 → --stamp 拒绝在有脏时盖章，
+--local/--ci 也把它单独报出来（已 git add 的不算脏：索引已含其内容，正是要测的那份）。
 
 用法（仓库根）：
     python scripts/check_size_gate.py --stamp
@@ -76,7 +81,9 @@ import ram_report  # noqa: E402
 
 REPO_ROOT = pathlib.Path(__file__).resolve().parent.parent
 ATTESTATION = REPO_ROOT / "scripts" / "size_attestation.json"
-SCHEMA = 1
+# v1 = 工作树原始字节指纹（跨 checkout 不稳定，见 index_snapshot 的实测说明）→ 作废；
+# v2 = git 索引 blob 指纹。schema 不符即拒绝复用，逼一次重新盖戳，不静默误判。
+SCHEMA = 2
 
 SIZE_SCOPE_DIRS = ("App/", "Drivers/", "Src/", "Inc/", "Lib/", "Middlewares/",
                    "test/board/")
@@ -93,46 +100,89 @@ def in_scope(rel):
     return False
 
 
-def tracked_files():
-    """受管文件列表（git 不可用时退回目录遍历，同 check_layer_deps.py）。"""
+def _git(args):
+    """跑 git 并返回 stdout 文本；git 不可用/非仓库 → 抛 RuntimeError（调用方按环境错误）。"""
     try:
-        out = subprocess.run(["git", "ls-files", "-z"], cwd=str(REPO_ROOT),
+        out = subprocess.run(["git"] + args, cwd=str(REPO_ROOT),
                              capture_output=True, check=True)
-    except Exception:  # noqa: BLE001  git 缺失/不在仓库内
-        files = []
-        for root, dirs, names in os.walk(REPO_ROOT):
-            dirs[:] = [d for d in dirs if d not in (".git", ".venv", "build")]
-            for n in names:
-                rel = os.path.relpath(os.path.join(root, n), REPO_ROOT)
-                files.append(rel.replace(os.sep, "/"))
-        return sorted(files)
-    return sorted(p.decode("utf-8", "replace") for p in out.stdout.split(b"\0") if p)
+    except subprocess.CalledProcessError as exc:
+        raise RuntimeError("git %s 失败：%s" % (" ".join(args), exc)) from exc
+    except (OSError, subprocess.SubprocessError) as exc:
+        raise RuntimeError("无法调用 git：%s" % exc) from exc
+    return out.stdout
 
 
-def scoped_files():
-    return [f for f in tracked_files() if in_scope(f)]
+def index_snapshot():
+    """受管且**在指纹范围内**的 (路径, 索引 blob id) 有序表。
+
+    ⚠ 为什么取**索引 blob**而不是工作树原始字节（2026-10-25 实测发现，别改回去）：
+      本仓 core.autocrlf=true，而 .gitattributes 写死 eol=lf —— 主工作树的受管源码
+      里有 **1046/1388 个文件落成 CRLF**，新建工作树同一提交落成 LF，两者**索引 blob
+      完全相同**（实测 dbg_cfg.h：1247 B/LF vs 1293 B/CRLF，blob 都是 c39395f7）。
+      拿原始字节算指纹 = 同一份代码在不同 checkout 得到不同指纹：主树盖的戳在道C
+      新工作树里判"不同码"，runner 上同样会误红——**门禁自己造 false positive**。
+      索引 blob 是 git 归一化后的身份，跨 checkout 稳定，也正是 AGENTS「行尾由
+      .gitattributes 写死、不依赖 core.autocrlf」的机器化说法。
+    """
+    raw = _git(["ls-files", "-s", "-z"])
+    rows = []
+    for item in raw.split(b"\0"):
+        if not item:
+            continue
+        meta, _, path = item.partition(b"\t")      # "<mode> <sha> <stage>"
+        parts = meta.decode("ascii", "replace").split(" ")
+        if len(parts) < 2:
+            continue
+        rel = path.decode("utf-8", "surrogateescape").replace(os.sep, "/")
+        if in_scope(rel):
+            rows.append((rel, parts[1]))
+    return sorted(rows)
 
 
 def tree_fingerprint():
-    """(指纹, 文件数, 缺失数)。受管但已删除的文件以哨兵入指纹，保证增删也变指纹。"""
+    """(指纹, 文件数)。指纹 = sha256(每行 "path\\tblob" 拼接)，取自 git 索引。"""
+    rows = index_snapshot()
     h = hashlib.sha256()
-    n = miss = 0
-    for rel in scoped_files():
-        n += 1
-        try:
-            blob = (REPO_ROOT / rel).read_bytes()
-        except OSError:
-            miss += 1
-            blob = b"<deleted>"
+    for rel, blob in rows:
         h.update(rel.encode("utf-8", "surrogateescape"))
-        h.update(b"\0")
-        h.update(hashlib.sha256(blob).digest())
-    return h.hexdigest(), n, miss
+        h.update(b"\t")
+        h.update(blob.encode("ascii", "replace"))
+        h.update(b"\n")
+    return h.hexdigest(), len(rows)
+
+
+def unmeasured_dirt(limit=8):
+    """范围内**未 staged** 的改动（含未跟踪文件）——它们不在索引里，指纹覆盖不到。
+
+    返回 (条数, 样例列表)。判据用 porcelain v1 的第二列（工作树列）：非空格且非
+    未跟踪标记即"改了没 staged"；'??' = 未跟踪新文件。⚠ 第一列（索引列）有改动是
+    **允许**的——那正是"已 git add、即将提交"的那份内容，索引已经把它算进指纹。
+    """
+    raw = _git(["status", "--porcelain=v1", "-z", "--untracked-files=all"])
+    dirty = []
+    for rec in raw.split(b"\0"):
+        if len(rec) < 4:
+            continue
+        xy = rec[:2].decode("ascii", "replace")
+        rel = rec[3:].decode("utf-8", "surrogateescape").replace(os.sep, "/")
+        if not in_scope(rel):
+            continue
+        if xy == "??":
+            dirty.append(rel)
+        elif xy[1] != " ":
+            dirty.append(rel)
+    return len(dirty), dirty[:limit]
 
 
 def newest_source_mtime():
+    """范围内**工作树文件**的最新 mtime（只用于 .map 新鲜度守卫，不进指纹）。
+
+    注意这里必须看工作树：守卫要抓的是"盖戳前又改了文件却没重编"，而那正是索引
+    之外（未 staged）或已 staged 但磁盘更新的那份内容。文件已删除则跳过（增删本身
+    由指纹变化表达）。
+    """
     newest = 0.0
-    for rel in scoped_files():
+    for rel, _blob in index_snapshot():
         try:
             newest = max(newest, (REPO_ROOT / rel).stat().st_mtime)
         except OSError:
@@ -227,12 +277,28 @@ def cmd_stamp(args):
         for b in bad:
             print("  - " + b, file=sys.stderr)
         return 1
-    fp, n, miss = tree_fingerprint()
+    # 第四道前置：范围内**有未 staged 的改动就拒绝盖戳**——索引（= 即将提交的那份）
+    # 里没有它们，凭证会"声称覆盖"一份并不存在的代码。已 git add 的改动**不算脏**
+    # （索引已含其内容，正是凭证该描述的东西）。
+    dirt, samples = unmeasured_dirt()
+    if dirt:
+        print("[FAIL] 指纹范围内有 %d 处未 staged 的改动/未跟踪文件，拒绝盖戳：" % dirt,
+              file=sys.stderr)
+        for s in samples:
+            print("  - " + s, file=sys.stderr)
+        print("  原因：凭证按 git 索引内容生成，未 staged 的部分不在索引里、覆盖不到。",
+              file=sys.stderr)
+        print("  修复：先 git add <这些文件>（凭证描述的就是你正要提交的那份），再盖戳；",
+              file=sys.stderr)
+        print("        或把它们还原。@build 与盖戳都应在同一份内容上做。")
+        return 1
+    fp, n = tree_fingerprint()
     write_attestation({
         "schema": SCHEMA,
         "fingerprint": fp,
+        "fingerprint_source": "git-index",
         "fingerprint_files": n,
-        "fingerprint_missing": miss,
+        "worktree_dirt_at_stamp": dirt,
         "sizes": m["sizes"],
         "regions": m["regions"],
         "pct": m["pct"],
@@ -248,7 +314,7 @@ def cmd_stamp(args):
     })
     ir = m["regions"].get("RW_IRAM1", {}).get("size", 0)
     cc = m["regions"].get("RW_CCM", {}).get("size", 0)
-    print("[OK] 体积同码凭证已写出：%s（指纹 %s…，%d 个文件）" % (
+    print("[OK] 体积同码凭证已写出：%s（索引指纹 %s…，%d 个文件）" % (
         ATTESTATION.relative_to(REPO_ROOT), fp[:12], n))
     print("     Code=%s B / RW_IRAM1=%s B / RW_CCM=%s B" % (
         format(m["sizes"]["code"], ","), format(ir, ","), format(cc, ",")))
@@ -276,17 +342,25 @@ def _cmd_parity(args, ci_mode):
             "  修复：本地 @build 之后跑 python scripts/ram_baseline.py --update",
             "        （或单独跑 python scripts/check_size_gate.py --stamp）",
         ])
-    fp, n, miss = tree_fingerprint()
+    fp, n = tree_fingerprint()
     problems = []
+    dirt, samples = unmeasured_dirt()
+    if dirt:
+        problems += [
+            "指纹范围内有 %d 处**未 staged** 的改动/未跟踪文件，凭证覆盖不到它们" % dirt,
+            "  " + "、".join(samples) + ("…" if dirt > len(samples) else ""),
+            "  含义：这些内容既没进索引（凭证按索引生成），也就没被那次测量算进去",
+            "  修复：git add 之后 @build，再跑 python scripts/ram_baseline.py --update",
+        ]
     if fp != doc["fingerprint"]:
         problems += [
             "本次代码（指纹 %s…，%d 文件）与体积测量（指纹 %s…，%s）不同码" % (
                 fp[:12], n, str(doc["fingerprint"])[:12], doc.get("built_at", "?")),
             "  含义：这份源码没有被真实链接测量过（或测量完又改了代码/合入了别的改动）",
             "  修复：@build 0/0 之后跑 python scripts/ram_baseline.py --update 再提交",
+            "  （指纹取 git 索引 blob：同一份内容在任何工作树/runner 上算法一致，"
+            "不受 CRLF/LF 检出差异影响）",
         ]
-        if miss:
-            problems.append("  （注：当前树缺 %d 个受管文件，可能 checkout 不完整）" % miss)
     if ci_mode:
         thr = doc.get("threshold_pct", ram_baseline.THRESHOLD_PCT)
         bad = []
@@ -338,8 +412,11 @@ def _tsv_consistency(doc):
 
 
 def cmd_show(_args):
-    fp, n, miss = tree_fingerprint()
-    print("当前受管源码指纹：%s（%d 文件，缺失 %d）" % (fp, n, miss))
+    fp, n = tree_fingerprint()
+    dirt, samples = unmeasured_dirt()
+    print("当前受管源码索引指纹：%s（%d 文件；未 staged %d 处）" % (fp, n, dirt))
+    for s in samples:
+        print("  dirty: " + s)
     doc, err = read_attestation()
     if doc is None:
         print("凭证：%s" % err)

scripts/check_test_coverage.py

@@ -46,6 +46,12 @@ r"""
     2 = 环境错误（找不到 cl.exe / 找不到 mscoverage / 编译失败 / XML 缺失或解析失败）
     3 = 用法错误
 
+中间产物目录（2026-10-25 起与主机单测同家）：
+    %TEMP%\dtu_host\<工作树哈希>\coverage\<模块>\ —— exe / PDB / .coverage /
+    cobertura XML 都在这里，**不进仓库**。按工作树分家，是因为旧的固定共享名
+    %TEMP%\dtu_test_cov 在多棵工作树并行跑覆盖率时会互相覆盖（判据与来龙去脉见
+    test/host/common/unit_test_harness.py 顶部"产物目录归属"一节）。改根：--work-dir
+    或环境变量 DTU_HOST_BUILD。
 用法（仓库根目录）：
     & '.venv\Scripts\python.exe' scripts/check_test_coverage.py                    # 全量跑 + 比基线
     & '.venv\Scripts\python.exe' scripts/check_test_coverage.py --module sha256    # 只跑一套（调试）
@@ -79,7 +85,6 @@ import re
 import shutil
 import subprocess
 import sys
-import tempfile
 import xml.etree.ElementTree as ET
 from pathlib import Path
 
@@ -682,7 +687,17 @@ def run(args):
     prod = production_sources()
     canon = {rel.lower(): rel for rel in prod}
 
-    work_root = args.work_dir or os.path.join(tempfile.gettempdir(), "dtu_test_cov")
+    # 中间产物根：**跟着工作树走**，与主机单测同一个家（task-10）。旧写法是
+    # tempfile.gettempdir()/dtu_test_cov —— 全机一个名字，多棵工作树并行跑覆盖率就
+    # 互相覆盖 exe/PDB/cov 文件（docs/测试说明/主机单测覆盖率口径.md 里"并行期每人
+    # 只跑 --module 自己模块"那条规避，就是为了绕开它；分家之后不再需要）。
+    # 复用 harness 的同一套判据（含 DTU_HOST_BUILD 覆盖），避免两处口径漂移。
+    _host_build_root = getattr(harness, "host_build_root", None)
+    if _host_build_root is None:
+        print("[ENV] unit_test_harness 缺 host_build_root()——覆盖率产物无法与主机"
+              "单测同家（harness 版本过旧？），拒绝跑。", file=sys.stderr)
+        return 2
+    work_root = args.work_dir or os.path.join(_host_build_root(), "coverage")
     if args.clean:
         shutil.rmtree(work_root, ignore_errors=True)
     os.makedirs(work_root, exist_ok=True)
@@ -820,7 +835,7 @@ def main():
     ap.add_argument("--md", metavar="PATH", help="额外输出 Markdown 报告")
     ap.add_argument("--json", metavar="PATH", help="额外输出 JSON 明细")
     ap.add_argument("--work-dir", metavar="PATH",
-                    help="中间产物目录（默认临时目录下 dtu_test_cov）")
+                    help="中间产物目录（默认与主机单测同家：TEMP 下 dtu_host/<工作树哈希>/coverage）")
     ap.add_argument("--clean", action="store_true", help="跑前清空中间目录")
     ap.add_argument("--timeout", type=int, default=600, metavar="SEC",
                     help="单模块插桩运行超时（默认 600 秒）")

scripts/ci_local.py

@@ -441,17 +441,24 @@ def main(argv=None):
         return 2
 
     rc = 0
+    # 实际跑过哪些段——收尾那行只报这些。理由与 A-5 同源且是同一类错误：
+    # "--l05-only 却宣布 L0/L0b/L0c 全部通过"就是把没跑的说成跑过了（SKIP 冒充 PASS
+    # 的镜像版）。2026-10-25 做 task-10 时从 --l05-only 的输出里发现，当场改掉。
+    ran = []
     try:
         if args.size_only:
             return run_size_gate()
         if not args.l05_only:
             rc = run_l0()
+            ran.append("L0")
             # 提交信息门禁独立于 --all-files（stage 不同），故单独跑一段；
             # 即使 L0 已失败也照跑，一次看全所有违规项。
             rc_msg = run_gitlint(args.commits)
+            ran.append("L0b")
             # L0c 体积门禁同样**无条件照跑**：它回答的是"这份代码测过体积没有"，
             # 与 L0/L0b 的结论正交，且只要 0.3 s——少跑一次就是 A-5 那个盲区。
             rc_size = run_size_gate()
+            ran.append("L0c")
             if rc != 0 or rc_msg != 0 or rc_size != 0:
                 if not args.keep_going:
                     print("")
@@ -461,9 +468,11 @@ def main(argv=None):
                 rc = rc or rc_msg or rc_size
         if not args.l0_only:
             rc05 = run_l05(args)
+            ran.append("L0.5")
             rc = rc or rc05
             if args.coverage:
                 rc = rc or run_coverage()
+                ran.append("L0.5c")
     except FileNotFoundError as e:
         print("[ERROR] 环境错误：{}".format(e))
         return 2
@@ -471,7 +480,7 @@ def main(argv=None):
     print("")
     print("=" * 64)
     if rc == 0:
-        print("  [OK] 本地 CI 全部通过（L0 + L0b + L0c + L0.5）")
+        print("  [OK] 本地 CI 全部通过（{}）".format(" + ".join(ran)))
     else:
         print("  [FAIL] 本地 CI 有未通过项（见上方输出）")
     print("=" * 64)

scripts/size_attestation.json

@@ -1,15 +1,15 @@
 {
-  "built_at": "2026-10-25T05:31:08+08:00",
-  "fingerprint": "548011fc4a68e087a855c952e73c6d8d85c6f4a4dee28702f29dfa858ff3577c",
+  "built_at": "2026-10-25T05:51:46+08:00",
+  "fingerprint": "abfd54b71de9462ed967df31a7ecfd56ff784325e5fc23ead1aa180dd5dbc6b7",
   "fingerprint_files": 1396,
-  "fingerprint_missing": 0,
+  "fingerprint_source": "git-index",
   "gated_regions": [
     "RW_IRAM1",
     "RW_CCM"
   ],
-  "git_head": "59da40bb4a53db082953164a9d7c58bb342f8c19",
+  "git_head": "d07a9a4d67db62878dd071b5e597a4134e6b4a8c",
   "map": "MDK-ARM/STM32F407-Demo/STM32F407-Demo.map",
-  "map_mtime": 1792877445,
+  "map_mtime": 1792878704,
   "pct": {
     "ER_IROM1": 22.62,
     "RW_CCM": 87.89,
@@ -34,7 +34,7 @@
       "size": 48
     }
   },
-  "schema": 1,
+  "schema": 2,
   "scope_note": "\u540c\u7801\u51ed\u8bc1\uff1a\u6307\u7eb9\u8986\u76d6\u56fa\u4ef6\u4f53\u79ef\u76f8\u5173\u6e90\u7801\uff0c\u53e3\u5f84\u89c1\u672c\u811a\u672c docstring",
   "sizes": {
     "code": 215744,
@@ -43,5 +43,6 @@
     "zi_data": 131984
   },
   "threshold_pct": 92.0,
+  "worktree_dirt_at_stamp": 0,
   "written_by": "scripts/check_size_gate.py --stamp"
 }

test/board/ch395f_test.h

@@ -62,18 +62,63 @@ extern "C" {
 //#define ENABLE_PHASE8_TESTS     /* [网] 大文件传输（100KB 文件收发） */
 //#define ENABLE_PHASE9_TESTS     /* [网] Select/Poll I/O 多路复用 */
 //#define ENABLE_PHASE10_TESTS    /* [网] 边界条件测试 */
-#define ENABLE_PHASE11_TESTS    /* [网] KeepAlive 超时断开：PC 连 8080 后须制造
-                                 * 死对端（禁用网卡；防火墙规则对已建立连接无效，
-                                 * E11 实证）；勿与 Phase 6/9/10/13 混选（recv 互抢数据） */
+/* [网] KeepAlive 超时断开：PC 连 8080 后须制造死对端（禁用网卡；防火墙规则对已建立
+ * 连接无效，E11 实证）；勿与 Phase 6/9/10/13 混选（recv 互抢数据）。
+ * ⚠ 说明写在**上一行**而不是挂在 #define 行尾：见本节末尾的"开关行注释规范" */
+#define ENABLE_PHASE11_TESTS    /* [网] KeepAlive 超时断开（判据见 CH395F_Test_Guide） */
 /* ---- 链路时延基线（M1；分段/阈值见 docs/测试说明/链路延迟测试说明.md）---- */
 //#define ENABLE_PHASE12_TESTS     /* [硬] SPI 字节命令 / DMA 时延基线（L1/L2，无需 PC）—— M1 已完成，基线见说明文档 §6.1 */
-//#define ENABLE_PHASE15_TESTS     /* [硬] 自愈驱动原语：状态回读一致性/cmd_done/sock_reset 状态机跑通/链路缓存（无需 PC）——TC 详见 docs/测试说明/CH395F_Test_Guide.md 阶段 15；台架 20/20 PASS */
+//#define ENABLE_PHASE15_TESTS     /* [硬] 自愈驱动原语：状态回读一致性/cmd_done/sock_reset 状态机跑通/链路缓存（无需 PC）——TC 详见 docs/测试说明/CH395F_Test_Guide.md 阶段 15；台架 21/21 PASS */
 /* ---- 链路时延（M2/M3；分段/阈值见 docs/测试说明/链路延迟测试说明.md）---- */
 //#define ENABLE_PHASE13_TESTS     /* [网] 芯片 + 队列时延（L3~L7/L10，需 PC peer）—— M2 已完成，基线见说明文档 §6.2 */
-#define ENABLE_PHASE14_TESTS     /* [网] 生产路径时延（L8~L11 + 模拟器 Δ）—— M3，需 peer --mode remo（:7003）；
-                                  * 与 Phase 11 共存安全：peer 缺席时有 LAT_P14_TIMEOUT_MS 整体超时
-                                  * 自动 done，不永久挡 accept */
+/* [网] 生产路径时延（L8~L11 + 模拟器 Δ）—— M3，需 peer --mode remo（:7003）；
+ * 与 Phase 11 共存安全：peer 缺席时有 LAT_P14_TIMEOUT_MS 整体超时，自动 done，
+ * 不永久挡 accept */
+#define ENABLE_PHASE14_TESTS    /* [网] 生产路径时延（L8~L11） */
 
+/*
+ * 开关行注释规范（2026-10-25 构建矩阵实测踩出来的，别改回去）：
+ *   每个 ENABLE_PHASE*_TESTS 行只许带"同一行内闭合"的行尾注释，或不写注释；
+ *   需要多行说明就挪到该行的**上一段**。原因：关一个阶段的动作是在行首加两个
+ *   斜杠，而它只注释到行尾——挂在行尾的跨行注释会从第二行起**变成裸代码**（实测
+ *   188 条 error #7: unrecognized token，报点落在注释的续行上，看着像头文件坏了，
+ *   其实只是注释被腰斩）。开阶段是同一个坑的反面：去掉行首斜杠并不会把注释拼回来。
+ *   test/run_all_suites.py 的 _rewrite_config 只改 TEST_SUITE_* 行（那些行没有行尾
+ *   跨行注释）所以一直没炸；本文件是"人手工切阶段"的入口，必须自身安全。
+ *
+ * 链接余量构建实测（条目属主 docs/任务规划/测试与架构专项.md P1-10；2026-10-25，
+ *   RW_IRAM1 = 128 KB 的 .sct 区，92% 红线 = 120,586 B）：
+ *   配置（TEST_SUITE_CH395F + 阶段）        Code      ZI     RW_IRAM1    距红线余量
+ *   产品基线（阶段全关）                    214,104   131,852   75,632  57.7%  44,954 B
+ *   默认阶段 11/14（只切套件宏）            217,468   134,076   77,920  59.5%  42,666 B
+ *   NET 层全开 6~11/13/14                  218,992   141,688   85,552  65.3%  35,034 B
+ *   HW  层全开 1~5/12/15（最坏态）          229,256   147,176   90,952  69.4%  29,634 B
+ *   HW  层无需 PC 1/12/15（台架冒烟用）      215,244   134,896   78,672  60.0%  41,914 B
+ *
+ *   同日 sync 追平后的复测（合入 59da40b 与 891ca81 两笔之后，产品基线前进到
+ *   Code=215,744 / RO=21,396 / RW=1,224 / ZI=131,984，RW_IRAM1 75,784 B / 57.82%）：
+ *     配置                            Code      ZI      RW_IRAM1       距红线余量
+ *     默认阶段 11/14                  219,112   134,208   78,072 59.6%   42,514 B
+ *     NET 层全开 6~10/13/14           220,636   141,804   85,688 65.4%   34,898 B
+ *     HW  层全开 1~5/12/15（最坏态）  230,900   147,300   91,088 69.5%   29,498 B
+ *     HW  层无需 PC 1/12/15           216,888   135,020   78,808 60.1%   41,778 B
+ *     四档仍全部 0 错误 0 警告、链接通过；PHASE5 三块缓冲依旧在链（hw_full 的
+ *     ch395f_test_task.o 数据段仍是 12,285 B）。上表 04 点那组的产品基线已前进，
+ *     作为当日历史记录保留、不追改（两组差值都在 +136~+152 B 量级，来自新增的
+ *     adc_cal 数据段；结论"最坏态仍余约 29 KB、不必扩 scatter"不变）。
+ *   台架冒烟（2026-10-25，_wt 同树构建 → 主树烧录，boot log 20261025_050539）：
+ *   镜像 ch395f_hw_nopc_v2.hex（戳 suite=CH395F dstr=off）单次开机跑完 1/12/15 三段，
+ *   汇总行 Phase 1: 9/9、Phase 12: 1/1、Phase 15: **21/21**（failed=0），全程无 Fault。
+ *   同轮暴露两类设计外/设计内 [ERR]：P2 越界守卫留痕（设计内，见 ch395f.c）与
+ *   [WD] task stall 刷屏 468 条（**设计外**：HW 层构建的必需心跳掩码没生效，
+ *   因为 App/util/task_watchdog.c 未 include test_config.h，看不到本文件的
+ *   ENABLE_HW_LAYER_TESTS → 那段剔除 netTask 的分支自加入起就是死代码）。
+ *   该条目关心的 PHASE5 三块静态缓冲（3 x PHASE5_CHUNK_SIZE = 4093）确实进了链接：
+ *   hw_full 的 ch395f_test_task.o 数据段 = 12,285 B（3 x 4093 = 12,279 + 其余 6 B）。
+ *   "理论余量足够"由未实测转为已实测：最坏态还余 29,634 B，不必把 .sct 扩到 192 KB
+ *   （与该条目"不建议扩 scatter"的约束一致）。RW_CCM 四档恒为 57,376 B / 87.9%——
+ *   但该区已贴着 92% 线，任何往 CCM 加东西的改动都得单独核算。
+ */
 #if defined(ENABLE_PHASE1_TESTS) || defined(ENABLE_PHASE2_TESTS) || \
     defined(ENABLE_PHASE3_TESTS) || defined(ENABLE_PHASE4_TESTS) || \
     defined(ENABLE_PHASE5_TESTS) || defined(ENABLE_PHASE12_TESTS) || \

test/host/common/README.md

@@ -68,7 +68,7 @@ raise SystemExit(run_host_unit_test(TestBuild(name="...", src="...", ...)))
 | `include_dirs` | | `/I` 目录列表；**桩目录需排在前面**才能覆盖真实头 |
 | `summary_marker` | | 运行输出中必须出现的汇总行前缀；空 = 不校验 |
 | `extra_flags` | | 追加的 `cl.exe` 开关 |
-| `exe_name` / `obj_tag` | | 覆盖派生的产物名 / 中间目录名（默认由 `name` 派生，落在系统 temp） |
+| `exe_name` / `obj_tag` | | 覆盖派生的产物名 / 中间目录名（默认由 `name` 派生；落点见下节"产物目录归属"） |
 
 ## 环境要求
 
@@ -76,6 +76,43 @@ raise SystemExit(run_host_unit_test(TestBuild(name="...", src="...", ...)))
 MSVC `cl.exe`（装了 VS 即有）+ Windows SDK + 纯标准库 Python；**不调 `vcvars64.bat`**
 （内部 `reg.exe` 受限），直接拼环境变量调 `cl.exe`。
 
+## 产物目录归属（跨工作树并行，2026-10-25）
+
+**obj / exe / pdb 每次运行独占一个子目录**，按工作树分家：
+
+```
+%TEMP%\dtu_host\<仓库根路径 sha1 前 10 位>\runs\<pid>-<纳秒时间戳>\
+    <suite>_obj\*.obj        ← 中间目标文件
+    <suite>_tests.exe        ← 本次编译产物（跑完随目录一起删）
+    <suite>_tests.exe.owner.json  ← 归属凭据：suite / repo_root / pid / started
+```
+
+为什么这么放（两条都是实测出来的，不是洁癖）：
+
+- **旧写法把 obj/exe 摊在全机共用的 `%TEMP%`，名字由套件名派生**（
+  `%TEMP%\net_socket_tests.exe`）。多棵工作树并行跑同名套件就会互相覆盖，而最坏情况
+  不是编不过：A 树编译完，B 树把同名 exe 又盖一遍，A 树随后执行的是 **B 树编出来的
+  二进制**——两棵树的 `summary_marker` 一模一样，harness 分辨不出来，等于拿别人的
+  运行结果给自己下结论。2026-10-25 三条道并行时全量 `ci_local` 里 `test-cppcheck` /
+  `test-coverage` 偶发 "files were modified by this hook"、单跑即绿，就是这一类。
+- **按工作树分家 + 每次跑独占**同时解决"跨树互踩"和"同树并发"（覆盖率钩子与手工 L0.5
+  同时跑同一棵树时也会撞）。不牺牲任何东西：每个测试单元就一个 `.c`，`cl` 每次整体
+  重编，"共享 obj 省编译"本来就是错觉。**没有加锁**——这里没有需要互斥的独占资源，
+  只是名字撞了；加锁等于把 L0.5 变成和 build/bench 一样的全局串行。
+
+两个开关（都写在 harness 顶部注释里，判据以 `unit_test_harness.host_build_root()` 为准）：
+
+- `DTU_HOST_BUILD=<目录>`：改产物根（CI/容器要固定路径时用）。覆盖率侧同源——
+  `scripts/check_test_coverage.py` 复用同一个函数，不再用自己那套固定名
+  （旧 `%TEMP%\dtu_test_cov` 的共享名，正是 docs/测试说明/主机单测覆盖率口径.md 里
+  "并行期每人只跑 `--module` 自己模块"那条规避的由来；分家之后该规避不再必要）。
+- `DTU_HOST_BUILD_KEEP=1`：保留本次独占目录不删（要单步调试那个 exe 时用，会打印路径）。
+
+想知道当前树算到哪个目录：
+
+```powershell
+& '.venv\Scripts\python.exe' -c "import sys;sys.path.insert(0,'test/host/common');import unit_test_harness as U;print(U.host_build_root())"
+```
 ## ⚠️ 注意
 
 - 本目录在 pre-commit 的 cppcheck / 代码规范**排除范围**（`test/` 豁免）

test/host/common/unit_test_harness.py

@@ -41,10 +41,14 @@
 """
 
 import glob
+import hashlib
+import json
 import os
+import shutil
 import subprocess
 import sys
 import tempfile
+import time
 from dataclasses import dataclass, field
 
 # ----------------------------- 工具链探测位置 -----------------------------
@@ -129,6 +133,61 @@ class TestBuild:
         return tag + "_obj"
 
 
+# ----------------------------- 产物目录归属（跨工作树并行） -----------------------------
+# 现象（2026-10-25 三条道并行开发实测）：全量 ci_local 的 L0 里 test-cppcheck /
+# test-coverage 偶发 "files were modified by this hook"，单独重跑即绿、工作树零改动。
+# 根因是旧写法把 obj/exe 直接落在**全机共用**的 %TEMP%，名字由套件名派生
+# （%TEMP%\net_socket_tests.exe 与 %TEMP%\net_socket_obj）。多棵工作树并行跑**同名
+# 套件**就会互相覆盖，而最坏的不是编不过：A 树编译完，B 树把同名 exe 又盖一遍，
+# A 树随后执行的是 **B 树编出来的二进制**——两棵树的 summary_marker 一模一样，
+# harness 分辨不出来，于是拿着别人的运行结果给自己下结论（比红更难查）。
+# 覆盖率侧同源：%TEMP%\dtu_test_cov 也是固定共享名（docs/测试说明/主机单测覆盖率
+# 口径.md 里"并行期每人只跑 --module 自己模块"就是为绕开它写的规避；本处修好后
+# 那条规避不再必要）。
+#
+# 口径：**按工作树分家**。产物根 = %TEMP%\dtu_host\<仓库根路径哈希>\，跨树天然不撞，
+# 同一棵树内仍复用同一份目录（33 套的编译缓存没必要白白重编）。**不用锁**——锁会把
+# L0.5 变成和 build/bench 一样的全局串行，而这里并没有需要互斥的独占资源，只是名字
+# 撞了。显式覆盖：DTU_HOST_BUILD=<目录>（CI/容器要固定路径时用）。
+
+
+def repo_root():
+    """本 harness 所在工作树的根（test/host/common/ 往上三级）。
+
+    每棵工作树都有自己的 test/host/（工作树之间只共享 .venv 与模拟器 SDK 两个目录
+    联接），所以"harness 文件自身的位置"就是可靠的树身份，不依赖 cwd 或环境变量。
+    """
+    here = os.path.dirname(os.path.abspath(__file__))   # <root>/test/host/common
+    root = here
+    for _ in range(3):                                      # common -> host -> test -> root
+        root = os.path.dirname(root)
+    return os.path.normpath(root)
+
+
+def host_build_root():
+    """主机单测产物根目录（按工作树分家；判据见上方"产物目录归属"）。"""
+    env = os.environ.get("DTU_HOST_BUILD")
+    if env:
+        return os.path.abspath(os.path.expanduser(env))
+    key = hashlib.sha1(os.path.normcase(repo_root()).encode("utf-8")).hexdigest()[:10]
+    return os.path.join(tempfile.gettempdir(), "dtu_host", key)
+
+
+def _write_owner(root, build):
+    """在产物根里落一份归属凭据（<exe>.owner.json）：并发/偶发问题时一眼看出这份
+    产物属于哪棵树、哪个进程、什么时候跑的。写失败不阻塞测试（只是诊断信息）。"""
+    info = {"suite": build.name, "repo_root": repo_root(), "pid": os.getpid(),
+            "started": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
+            "build_root": root}
+    try:
+        with open(os.path.join(root, build.resolved_exe() + ".owner.json"), "w",
+                  encoding="utf-8") as f:
+            json.dump(info, f, ensure_ascii=True, sort_keys=True)
+            f.write("\n")
+    except OSError:
+        pass
+
+
 def _first(pattern):
     """glob 命中里取最大者（版本号目录的字符串序即数值序，前提是位数一致）。"""
     hits = sorted(glob.glob(pattern))
@@ -219,11 +278,22 @@ def build_and_run(build, out=None):
         print("[ENV] 找不到 MSVC cl.exe（设置 DTU_MSVC_CL，或安装 VS2019/2022/2026 的 C++ 工具链）", file=err)
         return 2
 
-    tmp = tempfile.gettempdir()
-    objdir = os.path.join(tmp, build.resolved_obj_tag())
-    os.makedirs(objdir, exist_ok=True)
-    exe = os.path.join(tmp, build.resolved_exe())
-
+    # 产物落**按工作树分家**的根目录（判据见上方"产物目录归属"）；旧写法用
+    # tempfile.gettempdir() 把 obj/exe 摊在全机共用的 %TEMP%，跨树同名即互踩。
+    # 而且**每次跑独占一个子目录**（obj 与 exe 都在里面）——这一步才真正消灭竞态：
+    # 两个进程哪怕同树并发、哪怕有人把 DTU_HOST_BUILD 指到同一处，也拿不到同一个
+    # exe 路径（旧写法会出现"A 编完 B 覆盖、A 跑的是 B 的二进制"），也拿不到同一个
+    # .obj（并发 cl.exe 写同名 obj 会直接编不过）。这里不牺牲什么：每个测试单元就一个
+    # .c，cl 每次都是整体重编，"共享 obj 省编译"本来就是错觉。跑完默认删掉该子目录；
+    # 调试要保留就用 DTU_HOST_BUILD_KEEP=1（会打印路径）。
+    root = host_build_root()
+    rundir = os.path.join(root, "runs", "{}-{}".format(os.getpid(), time.time_ns()))
+    objdir = os.path.join(rundir, build.resolved_obj_tag())
+    os.makedirs(objdir, exist_ok=True)   # 顺带把 rundir 建出来
+    exe = os.path.join(rundir, build.resolved_exe())
+    _write_owner(rundir, build)
+    keep = (os.environ.get("DTU_HOST_BUILD_KEEP") or "").strip().lower() not in (
+        "", "0", "false", "no")
     env = dict(os.environ)
     env["INCLUDE"] = os.pathsep.join(inc)
     env["LIB"] = os.pathsep.join(lib)
@@ -235,32 +305,48 @@ def build_and_run(build, out=None):
     cmd += list(build.extra_flags)
     cmd += [build.src, "/Fe:" + exe, "/Fo:" + objdir + os.sep]
 
-    print("=== 编译并运行 {} ===".format(build.name), file=out)
-    cp = subprocess.run(cmd, env=env, capture_output=True)
-    cout, cerr = decode(cp.stdout), decode(cp.stderr)
-    if cout:
-        out.write(cout)
-    if cerr:
-        err.write(cerr)
-    if cp.returncode != 0:
-        print("[ENV] 编译失败", file=err)
-        return 2
+    print("=== 编译并运行 {} ===（产物 {}）".format(build.name, rundir), file=out)
+    try:
+        cp = subprocess.run(cmd, env=env, capture_output=True)
+        cout, cerr = decode(cp.stdout), decode(cp.stderr)
+        if cout:
+            out.write(cout)
+        if cerr:
+            err.write(cerr)
+        if cp.returncode != 0:
+            print("[ENV] 编译失败", file=err)
+            return 2
 
-    run = subprocess.run([exe], env=env, capture_output=True)
-    rout = decode(run.stdout)
-    out.write(rout)
-    rerr = decode(run.stderr)
-    if rerr:
-        err.write(rerr)
+        # 只跑"本次编译确实产出的"exe：路径是本次独占的，所以只要存在就必须是本次
+        # 写的；不存在 = 编译虽返回 0 但没落地（磁盘/杀软/并发清理），一律按环境错误
+        # 处理，绝不拿着来路不明的二进制出结论。
+        if not os.path.isfile(exe):
+            print("[ENV] 编译返回 0 但没有产物 exe: {}".format(exe), file=err)
+            return 2
 
-    if build.summary_marker and build.summary_marker not in rout:
-        print("[ENV] 未产生测试汇总行（找不到 {!r}）".format(build.summary_marker), file=err)
-        return 2
-    if run.returncode == 0:
-        print("[OK] 单元测试全部通过", file=out)
-        return 0
-    print("[FAIL] 有测试用例未通过", file=err)
-    return 1
+        run = subprocess.run([exe], env=env, capture_output=True)
+        rout = decode(run.stdout)
+        out.write(rout)
+        rerr = decode(run.stderr)
+        if rerr:
+            err.write(rerr)
+
+        if build.summary_marker and build.summary_marker not in rout:
+            print("[ENV] 未产生测试汇总行（找不到 {!r}）".format(build.summary_marker),
+                  file=err)
+            return 2
+        if run.returncode == 0:
+            print("[OK] 单元测试全部通过", file=out)
+            return 0
+        print("[FAIL] 有测试用例未通过", file=err)
+        return 1
+    finally:
+        # 跑完（含异常/Ctrl-C）就把本次独占目录收掉：残留的半截 exe 永远不会被下一
+        # 次运行当作自己的产物。调试场景用 DTU_HOST_BUILD_KEEP=1 保留（会打印路径）。
+        if keep:
+            print("[KEEP] 本次产物保留在 {}".format(rundir), file=out)
+        else:
+            shutil.rmtree(rundir, ignore_errors=True)
 
 
 def run_host_unit_test(build):

test/run_all_suites.py

@@ -57,15 +57,34 @@ KEIL_BUILD = REPO_ROOT / ".dsh" / "skills" / "keil-build" / "scripts" / "keil_bu
 STLINK_FLASH = REPO_ROOT / ".dsh" / "skills" / "stlink-flash" / "scripts" / "stlink_flash.py"
 RUN_BOOT = REPO_ROOT / ".dsh" / "skills" / "serial-boot-test" / "scripts" / "run_boot_test.py"
 
+# 套件态的 forbidden 覆盖（判据边界见下方注释块，正文只这一处）。
+FORBIDDEN_SUITE = "HardFault;MEMFAULT;BUSFAULT;USAGEFAULT;assert;bring-up FAIL"
+
 # 套件 -> (宏名, verify_log 需要的汇总行名称, 该套件的 Required 标记, --forbidden 覆盖)
 # 汇总行名称与套件 `XXX_TEST_REPORT("...")` 里的字符串一致（见各模块 Test_Guide）。
-# forbidden 覆盖：套件含"预期 [ERR]"的守卫负路径时须覆盖（空 = 用默认 `HardFault;assert;[ERR]`）。
-#   GD5F：TC-GD5F-704 故意用非 DMA 可达缓冲触发 `[ERR][NAND] RX DMA buffer not DMA-reachable`
-#         回落轮询（用例 PASS）——按 verify_log.py 的说明去掉 [ERR]，保留 HardFault/assert。
+# forbidden 覆盖：套件含"预期 [ERR]"的守卫负路径时须覆盖（空 = 用默认
+#   `HardFault;assert;[ERR]`，与 .serialtest/config.json 的产品判据同源）。
+#
+# 为什么不能只是"把 [ERR] 删掉"（2026-10-25 台架实测 + verify_log 源码核对）：
+#   四种 Fault 的崩溃行长这样：`[ERR] HARDFAULT|MEMFAULT|BUSFAULT|USAGEFAULT …`
+#   （Src/stm32f4xx_it.c 的 hard_fault_report），而 verify_log 的 forbidden 是**大小写
+#   不敏感的子串匹配**（fl in ln.lower()）→ 默认集合里的 `HardFault` 能命中硬Fault，
+#   但 MEM/BUS/USAGE 三种**平时完全靠 [ERR] 兜**。所以旧 GD5F 只写 `HardFault;assert` 其实
+#   放过了后三种崩溃。覆盖集合一律显式列出四个 Fault 标签 + assert + 起网失败字样：
+#   豁免的是**设计内的守卫 [ERR]**，崩溃照旧判失败。
+#   产品 @test 判据（.serialtest/config.json 的 forbidden 含 [ERR]）**不在这里动**——
+#   豁免只活在"套件回归"这条路上，渗不回产品路径。
+#   GD5F：TC-GD5F-704 故意用非 DMA 可达缓冲触发 `[ERR][NAND] RX DMA buffer not
+#         DMA-reachable` 回落轮询（用例 PASS）→ 需豁免设计内 [ERR]。
+#   CH395F：Phase 15 的 sn 越界负向用例命中驱动守卫 `[ERR][CH395] ch395f P2
+#         boundary fault @get_state sn`（Drivers/BSP/CH395F/ch395f.c 的
+#         ch395f_p2_fault_note()：首次留痕、之后只计数）→ 同属设计内。
+#         另外 `[ERR][WD] task stall` 那类**不是设计内**，是构建配置缺陷（HW 层
+#         测试构建下必需心跳掩码仍含 netTask），已单独提修，不用豁免掩盖它。
 SUITES = {
-    "CH395F":  ("TEST_SUITE_CH395F", None,            "", ""),
+    "CH395F":  ("TEST_SUITE_CH395F", None,            "", FORBIDDEN_SUITE),
     "STORAGE": ("TEST_SUITE_STORAGE", "Storage Tests", "=== Storage Tests:", ""),
-    "GD5F":    ("TEST_SUITE_GD5F",    "GD5F2GQ5UE Tests", "=== GD5F2GQ5UE Tests:", "HardFault;assert"),
+    "GD5F":    ("TEST_SUITE_GD5F",    "GD5F2GQ5UE Tests", "=== GD5F2GQ5UE Tests:", FORBIDDEN_SUITE),
     "RTC":     ("TEST_SUITE_RTC",     "RTC Tests",     "=== RTC Tests:", ""),
 }