看门狗判定状态机增加主机侧单元测试（L0.5 层）

为 task_watchdog.c 的判定逻辑（位图取走清零 / 必需掩码 0x37 判定 /
miss_streak 连续 8 次停喂 / 100ms 抽样节流 / tick 回绕安全）补一层
主机侧纯逻辑单元测试，弥补此前只能靠真机或模拟器才能发现回归的空白。

架构（沿用项目既有"共享核心 + 平台后端"做法，参照 cfg_file_store）：
- task_watchdog.h 末段新增"平台后端（内部）"声明 3 个钩子
  （wd_platform_feed / _start / _tick_ms），MCU 端以 __weak 提供默认实现，
  行为与重构前逐字一致（@build 0 错误 0 警告，Flash +20B）。
- 主机侧单测以同名强符号覆盖三钩子，即可离线注入/观测，无需碰 MCU 代码。
- 测试文件 #include 生产源文件本身，保证测的是真代码而非副本。
- 测试专用复位 task_wd_test_reset() 仅 TASK_WATCHDOG_UNIT_TEST 下编入，
  MCU 构建零代码零符号。

测试（test/host/watchdog/，MSVC 离线编译，纯标准库驱动）：
- 39 项断言全过（退出码 0）；注入故障可复现退出码 1。
- run_unit_test.py 直接拼 INCLUDE/LIB 调 cl.exe，绕开本机被禁的 reg.exe。
- stub/ 三桩头覆盖 main.h / iwdg.h / dbg_log.h。

门禁：pre-commit 新增 watchdog-unit-test 本地钩子（L0.5 层），仅被测文件
或其测试变动时触发；测试开发标准流程.md 新增 L0.5 层说明。

顺带改善：task_watchdog.c 的节流基线 s_last_tick 由函数内 static 提为文件
static（可测性 + 模块状态归一）。

test/host/watchdog/run_unit_test.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""看门狗判定状态机的主机侧单元测试运行器（纯标准库）。
+
+做什么：
+    用本机 MSVC 编译 test/host/watchdog/watchdog_test.c（它以 #include 纳入
+    **生产源文件** App/util/task_watchdog.c），在 PC 上离线跑完整判定状态机，
+    失败即非 0 退出。零硬件、零烧录、毫秒级。
+
+为什么要主机侧单测（而不是只用板端套件）：
+    task_watchdog.c 的判定逻辑（位图取走清零 / 掩码 / miss_streak 累计 / 节流）
+    是纯逻辑，与硬件无关；板端套件只能"在真机上跑一遍"，无法穷举边界（节流窗口
+    99/100ms、tick 回绕、连续 8 次缺席的第 8/9 次分界）。主机侧单测把这些一次性
+    钉死，且不占 MCU 的 RAM（项目 RAM 已 95%）。
+
+实现要点（为何不用 vcvars64.bat）：
+    vcvars64.bat 内部调用 reg.exe 探测环境；本机策略禁止 reg.exe。故这里**直接
+    拼 INCLUDE/LIB 环境变量**并绝对路径调用 cl.exe——只需 3 个已知目录
+    （MSVC 版本 / Windows SDK include / SDK lib），无副作用、可重复。
+
+用法（仓库根目录）：
+    python test/host/watchdog/run_unit_test.py
+    或统一用 .venv：  & '.venv\\Scripts\\python.exe' test/host/watchdog/run_unit_test.py
+
+退出码：0=PASS / 1=测试失败 / 2=环境错误（找不到编译器 / 编译失败）。
+
+设计依据：docs/测试说明/看门狗单元测试说明.md
+创建日期：2026-10-01
+"""
+import glob
+import os
+import subprocess
+import sys
+import tempfile
+
+# ----------------------------- 路径 -----------------------------
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.dirname(os.path.dirname(os.path.dirname(HERE)))
+STUB = os.path.join(HERE, "stub")
+SRC = os.path.join(HERE, "watchdog_test.c")
+APP_UTIL = os.path.join(ROOT, "App", "util")   # task_watchdog.c 所在目录
+
+VS_ROOTS = [
+    r"C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools",
+    r"C:\Program Files\Microsoft Visual Studio\2022\BuildTools",
+    r"C:\Program Files\Microsoft Visual Studio\2022\Community",
+    r"C:\Program Files\Microsoft Visual Studio\2022\Professional",
+]
+SDK_ROOTS = [r"C:\Program Files (x86)\Windows Kits\10"]
+
+
+def _first(pattern):
+    hits = sorted(glob.glob(pattern))
+    return hits[-1] if hits else None
+
+
+def _decode(b):
+    """把 subprocess 字节输出解码为字符串：本机 MSVC 输出为 GBK（代码页 936），
+    测试程序自身输出为 UTF-8；按 UTF-8 优先、失败回退 GBK 处理。"""
+    if isinstance(b, str):
+        return b
+    try:
+        return b.decode("utf-8")
+    except UnicodeDecodeError:
+        return b.decode("gbk", errors="replace")
+
+
+def locate_toolchain():
+    """返回 (cl.exe, include_dirs, lib_dirs)；找不到返回 (None, [], [])。"""
+    cl = None
+    for vs in VS_ROOTS:
+        c = _first(os.path.join(vs, r"VC\Tools\MSVC\*\bin\Hostx64\x64\cl.exe"))
+        if c:
+            cl = c
+            break
+    if not cl:
+        return None, [], []
+
+    msvc_ver_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(cl))))
+    # cl.exe = <vs>\VC\Tools\MSVC\<ver>\bin\Hostx64\x64\cl.exe
+    msvc_ver_dir = os.path.dirname(os.path.dirname(os.path.dirname(
+        os.path.dirname(cl))))  # -> ...\MSVC\<ver>
+    inc = [
+        os.path.join(msvc_ver_dir, "include"),
+    ]
+    lib = [
+        os.path.join(msvc_ver_dir, "lib", "x64"),
+    ]
+
+    for sdk in SDK_ROOTS:
+        sdk_inc = _first(os.path.join(sdk, r"Include\*"))
+        sdk_lib = _first(os.path.join(sdk, r"Lib\*"))
+        if sdk_inc:
+            inc += [
+                os.path.join(sdk_inc, "ucrt"),
+                os.path.join(sdk_inc, "shared"),
+                os.path.join(sdk_inc, "um"),
+            ]
+        if sdk_lib:
+            lib += [
+                os.path.join(sdk_lib, "ucrt", "x64"),
+                os.path.join(sdk_lib, "um", "x64"),
+            ]
+    return cl, inc, lib
+
+
+def main():
+    cl, inc, lib = locate_toolchain()
+    if not cl:
+        print("[ENV] 找不到 MSVC cl.exe（需要 VS2019/2022 的 C++ 工具链）",
+              file=sys.stderr)
+        return 2
+
+    tmp = tempfile.gettempdir()
+    objdir = os.path.join(tmp, "wd_test_obj")
+    os.makedirs(objdir, exist_ok=True)
+    exe = os.path.join(tmp, "watchdog_unit_test.exe")
+
+    env = dict(os.environ)
+    env["INCLUDE"] = os.pathsep.join(inc)
+    env["LIB"] = os.pathsep.join(lib)
+    env["PATH"] = os.path.dirname(cl) + os.pathsep + env.get("PATH", "")
+
+    cmd = [
+        cl, "/nologo", "/W4", "/std:c11", "/utf-8",
+        # C4819（"源代码包含不能在当前代码页中表示的字符"）是**纯编码诊断**：
+        # 本文件确为 UTF-8（带 BOM，已核验），且已显式传 /utf-8，字节解码无误、
+        # 编译产物正确。但在"只设 INCLUDE/LIB、不调 vcvars"的调用方式下，
+        # MSVC 的代码页探测会退化为 `代码页(0)` → 恒定误报 10 条。
+        # 该文件仅主机侧编译（ARMCC 从不编译 test/），故显式屏蔽，保持门禁输出干净。
+        "/wd4819",
+        "/I", STUB,                      # stub 头优先于真实头（覆盖 main.h/iwdg.h/dbg_log.h）
+        "/I", APP_UTIL,                  # task_watchdog.c / task_watchdog.h
+        "/I", HERE,                      # （保留）本目录
+        SRC,
+        "/Fe:" + exe,
+        "/Fo:" + objdir + os.sep,
+    ]
+
+    print("=== 编译并运行看门狗单元测试 ===")
+    cp = subprocess.run(cmd, env=env, capture_output=True)
+    cout = _decode(cp.stdout)
+    cerr = _decode(cp.stderr)
+    if cout:
+        sys.stdout.write(cout)
+    if cerr:
+        sys.stderr.write(cerr)
+    if cp.returncode != 0:
+        print("[ENV] 编译失败", file=sys.stderr)
+        return 2
+
+    run = subprocess.run([exe], env=env, capture_output=True)
+    out = _decode(run.stdout)
+    sys.stdout.write(out)
+    errout = _decode(run.stderr)
+    if errout:
+        sys.stderr.write(errout)
+
+    if "=== Task Watchdog Tests:" not in out:
+        print("[ENV] 未产生测试汇总行", file=sys.stderr)
+        return 2
+    if run.returncode == 0:
+        print("[OK] 单元测试全部通过")
+        return 0
+    print("[FAIL] 有测试用例未通过", file=sys.stderr)
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

test/host/watchdog/stub/dbg_log.h

@@ -0,0 +1,27 @@
+/*
+ * 主机侧单测桩：dbg_log.h
+ * 模块功能：为 task_watchdog.c 提供主机可编译的日志宏（映射到 printf / 计数）。
+ *
+ * ⚠ 仅供 test/host/watchdog/ 使用，不参与 MCU 构建。
+ *
+ * 与 simulator/dbg_log.h 同思路：MCU 版依赖 sys_clock（RTC 时间戳）与 USART，
+ * 主机侧替换为 printf，并把 DBG_ERROR 计入计数器供单测断言（"停喂时是否打了
+ * [WD] task stall" 是可观测行为的一部分）。
+ *
+ * 创建日期：2026-10-01
+ */
+
+#ifndef DBG_LOG_H
+#define DBG_LOG_H
+
+#include <stdio.h>
+
+/* 测试期望的"最后遗言"计数（在 watchdog_test.c 实现，单测断言其增量） */
+extern int g_wdtest_err_count;
+
+/* 断言：停喂时应恰好出现若干条 DBG_ERROR（[WD] task stall） */
+#define DBG_INFO(fmt, ...)   do { } while (0)
+#define DBG_DEBUG(fmt, ...)  do { } while (0)
+#define DBG_ERROR(fmt, ...)  do { g_wdtest_err_count++; } while (0)
+
+#endif /* DBG_LOG_H */

test/host/watchdog/stub/iwdg.h

@@ -0,0 +1,34 @@
+/*
+ * 主机侧单测桩：iwdg.h
+ * 模块功能：为 task_watchdog.c 提供主机可编译、可观测的 IWDG 模型。
+ *
+ * ⚠ 仅供 test/host/watchdog/ 使用，不参与 MCU 构建。
+ *
+ * 说明：真实代码写 `IWDG->KR = 0xAAAAu;`（重装/喂狗）与 0xCCCC（启动）。
+ * 本桩把 IWDG 指向 watchdog_test.c 中的影子对象，写入落到普通内存；
+ * 单测通过平台钩子（wd_platform_feed/start）计次观测，无需读寄存器。
+ *
+ * 创建日期：2026-10-01
+ */
+
+#ifndef IWDG_H
+#define IWDG_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* 与真实芯粒同名的结构（本模块仅用到 KR） */
+typedef struct {
+    volatile uint32_t KR;
+} IWDG_TypeDef;
+
+extern IWDG_TypeDef *IWDG;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* IWDG_H */

test/host/watchdog/stub/main.h

@@ -0,0 +1,28 @@
+/*
+ * 主机侧单测桩：main.h
+ * 模块功能：为 task_watchdog.c 提供主机可编译的最小替代，仅需 HAL_GetTick() 声明。
+ *
+ * ⚠ 仅供 test/host/watchdog/ 使用，不参与 MCU 构建。
+ *   MCU 构建走真实 Inc/main.h（含 stm32f4xx_hal.h）；本文件因 include 路径
+ *   优先级被优先命中（见 run 脚本 -I 顺序）。
+ *
+ * 创建日期：2026-10-01
+ */
+
+#ifndef __MAIN_H
+#define __MAIN_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* HAL 毫秒时基（MCU 端 = TIM7 中断累加；主机侧由桩提供可控时钟） */
+uint32_t HAL_GetTick(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __MAIN_H */

test/host/watchdog/watchdog_test.c

@@ -0,0 +1,313 @@
+/*
+ * 模块名称：Task Watchdog 主机侧单元测试
+ * 模块功能：在 PC 上对 App/util/task_watchdog.c 的**判定状态机**做穷举验证。
+ *
+ * 被测对象：真实源文件 ../App/util/task_watchdog.c（以 #include 原样纳入，
+ *           保证测的是生产代码而非副本）。硬件访问由本文件提供的三个强符号
+ *           平台钩子（wd_platform_feed/start/tick_ms）替换为可观测桩。
+ *
+ * 隔离：每个用例前调用 task_wd_test_reset()（生产文件中由
+ *       TASK_WATCHDOG_UNIT_TEST 守卫的测试专用复位，MCU 构建零开销）
+ *       把模块静态态恢复到"刚上电"。
+ *
+ * 覆盖点（对应 docs/测试说明/看门狗单元测试说明.md 的 TC-WD-xxx）：
+ *   TC-WD-001 未启动时 poll 不做任何判定（也不喂狗）
+ *   TC-WD-002 节流：< 100ms 的 poll 直接返回
+ *   TC-WD-003 全员到位置位 → 喂狗一次，且位图取走清零
+ *   TC-WD-004 取走清零语义：旧位不残留（下一轮必须重新置位）
+ *   TC-WD-005 掩码判定：缺任一位不喂，last_mask 精确记录
+ *   TC-WD-006 连续 1..7 次缺席不喂不报；第 8 次打 [WD] task stall
+ *   TC-WD-007 停喂后 stall 日志持续复报（现状行为，见用例内说明）
+ *   TC-WD-008 恢复：重新全员到位 → 喂狗 + streak 归零
+ *   TC-WD-009 节流窗口边界 99/100/199/200
+ *   TC-WD-010 tick 回绕安全（无符号差）
+ *   TC-WD-011 观测接口：last_mask / is_armed
+ *   TC-WD-013 非法任务 ID 被忽略（防位图越界）
+ *   TC-WD-014 start 幂等
+ *
+ * 通过：全部 TC PASS（main 返回 0）。
+ * 入口：int main(void)，返回 0=PASS / 1=FAIL（由 run 脚本判读）。
+ *
+ * 创建日期：2026-10-01
+ */
+
+/* 打开生产文件里的测试专用复位钩子（MCU 构建不定义此宏） */
+#define TASK_WATCHDOG_UNIT_TEST 1
+
+#include <stdint.h>
+#include <stdio.h>
+
+/*
+ * 先纳入桩头文件，再纳入生产源码——保证 IWDG_TypeDef / HAL_GetTick 等
+ * 类型与声明在使用前可见（生产源码内部是同名 include，走 include guard 不再重复）。
+ *   - stub/main.h   → HAL_GetTick 声明
+ *   - stub/iwdg.h   → IWDG_TypeDef + IWDG 外部声明
+ *   - stub/dbg_log.h→ DBG_* 映射与 g_wdtest_err_count
+ *
+ * 注意：生产源码里的三个 __weak 平台默认实现由 TASK_WATCHDOG_UNIT_TEST 守卫
+ * 而不编入（避免与本文件桩重名），故主机侧无需处理 __weak 关键字。
+ */
+#include "main.h"
+#include "iwdg.h"
+#include "dbg_log.h"
+
+/* ===================== 平台桩：时间与 IWDG ===================== */
+
+/* 可控毫秒时钟（单测手动推进；真实 MCU 由 TIM7 累加） */
+static uint32_t s_tick = 0u;
+
+/* IWDG 影子寄存器：真实代码写 IWDG->KR = x，这里落到本对象 */
+static IWDG_TypeDef s_iwdg_shadow;
+IWDG_TypeDef *IWDG = &s_iwdg_shadow;
+
+/* 喂狗 / 启动 计数（平台钩子观测） */
+static int s_feed_count = 0;
+static int s_start_count = 0;
+
+/* DBG_ERROR 计数（停喂时应打 [WD] task stall） */
+int g_wdtest_err_count = 0;
+
+/* ---- 强符号覆盖：三个平台钩子（覆盖 task_watchdog.c 的 __weak 默认实现） ---- */
+void wd_platform_feed(void)  { s_feed_count++; s_iwdg_shadow.KR = 0x0000AAAAu; }
+void wd_platform_start(void) { s_start_count++; s_iwdg_shadow.KR = 0x0000CCCCu; }
+uint32_t wd_platform_tick_ms(void) { return s_tick; }
+
+/* main.h 声明的 HAL 时基 */
+uint32_t HAL_GetTick(void) { return s_tick; }
+
+/* ===================== 测试框架（极简） ===================== */
+static int s_total = 0, s_passed = 0, s_failed = 0;
+
+#define CHECK(cond, name) do { \
+    s_total++; \
+    if (cond) { s_passed++; printf("  [PASS] %s\n", name); } \
+    else      { s_failed++; printf("  [FAIL] %s  (line %d)\n", name, __LINE__); } \
+} while (0)
+
+/* ===================== 被测代码 ===================== */
+/* 原样纳入生产源文件（stub/ 里的 main.h / iwdg.h / dbg_log.h 生效） */
+#include "task_watchdog.c"
+
+/* ===================== 辅助 ===================== */
+
+/* 每个用例前的干净起点：复位模块静态态 + 清空观测计数 + 时钟归零 */
+static void fresh(void) {
+    task_wd_test_reset();
+    s_tick = 0u;
+    s_feed_count = 0;
+    s_start_count = 0;
+    g_wdtest_err_count = 0;
+    s_iwdg_shadow.KR = 0u;
+}
+
+/* 推进时间并触发一次 poll */
+static void poll_advance(uint32_t ms) {
+    s_tick += ms;
+    task_wd_poll();
+}
+
+/*
+ * 启动并清空喂狗计数：task_wd_start() 内部会先喂一次（让首个抽样窗口从启动
+ * 时刻起算，见生产代码注释），该次喂狗由 TC-WD-015 单独断言；其余用例只关心
+ * "启动之后 poll 的喂狗行为"，故此处把计数归零。
+ */
+static void start_and_clear(void) {
+    task_wd_start();
+    s_feed_count = 0;
+}
+
+/* 全员置位（默认必需掩码 0x37 = bit0|1|2|4|5） */
+static void beat_all(void) {
+    task_wd_beat(TASK_WD_DEFAULT);
+    task_wd_beat(TASK_WD_NET);
+    task_wd_beat(TASK_WD_FTP);
+    task_wd_beat(TASK_WD_UI);
+    task_wd_beat(TASK_WD_TIMESYNC);
+}
+
+/* ===================== 用例 ===================== */
+
+static void tc_001_not_armed(void) {
+    printf("TC-WD-001 未启动时 poll 不做判定\n");
+    beat_all();
+    poll_advance(1000);
+    CHECK(s_feed_count == 0, "未启动时 poll 不喂狗");
+    CHECK(task_wd_is_armed() == 0, "is_armed == 0（未启动）");
+}
+
+static void tc_002_throttle(void) {
+    printf("TC-WD-002 节流：< 100ms 直接返回\n");
+    start_and_clear();
+    beat_all();
+    poll_advance(50);                    /* 50ms < 100ms → 不抽样 */
+    CHECK(s_feed_count == 0, "50ms 内 poll 不喂狗");
+    poll_advance(50);                    /* 累计 100ms → 抽样 */
+    CHECK(s_feed_count == 1, "累计 100ms 后喂狗 1 次");
+}
+
+static void tc_003_all_beat_feeds(void) {
+    printf("TC-WD-003 全员到位 → 喂狗一次\n");
+    start_and_clear();
+    beat_all();
+    poll_advance(100);
+    CHECK(s_feed_count == 1, "全员到位喂狗 1 次");
+    CHECK(task_wd_last_mask() == 0x37u, "last_mask == 0x37（bit0|1|2|4|5）");
+}
+
+static void tc_004_take_and_clear(void) {
+    printf("TC-WD-004 取走清零：旧位不残留\n");
+    start_and_clear();
+    beat_all();
+    poll_advance(100);                   /* 消费位图并喂狗 */
+    CHECK(s_feed_count == 1, "第一轮喂狗");
+    poll_advance(100);                   /* 不重新置位 */
+    CHECK(s_feed_count == 1, "未重新置位 → 第二轮不喂狗（位图已取走清零）");
+}
+
+static void tc_005_mask_required(void) {
+    printf("TC-WD-005 掩码判定：缺任一位不喂\n");
+    start_and_clear();
+    /* 故意缺 UI（bit4） */
+    task_wd_beat(TASK_WD_DEFAULT);
+    task_wd_beat(TASK_WD_NET);
+    task_wd_beat(TASK_WD_FTP);
+    task_wd_beat(TASK_WD_TIMESYNC);
+    poll_advance(100);
+    CHECK(s_feed_count == 0, "缺 UI 位 → 不喂狗");
+    CHECK(task_wd_last_mask() == (0x37u & ~(1u << TASK_WD_UI)),
+          "last_mask 精确记录缺失位");
+}
+
+static void tc_006_stall_8(void) {
+    printf("TC-WD-006 连续 8 次缺席 → 打 stall 并停喂\n");
+    start_and_clear();
+    beat_all(); poll_advance(100);       /* streak 清零 */
+    int err0 = g_wdtest_err_count;
+    for (int i = 1; i <= 7; i++) {
+        poll_advance(100);
+        CHECK(g_wdtest_err_count == err0, "第 1..7 次缺席不报 stall");
+    }
+    poll_advance(100);                   /* 第 8 次 */
+    CHECK(g_wdtest_err_count == err0 + 1, "第 8 次缺席打 [WD] task stall");
+    CHECK(s_feed_count == 1, "全程仅在开始时喂过 1 次（缺席期间未喂）");
+}
+
+static void tc_007_stall_repeats_until_reset(void) {
+    printf("TC-WD-007 停喂后 stall 日志持续复报（当前设计：每 100ms 一条）\n");
+    start_and_clear();
+    for (int i = 0; i < 8; i++) poll_advance(100);   /* 第 8 次触发 */
+    int err8 = g_wdtest_err_count;
+    CHECK(err8 == 1, "第 8 次缺席后已报 1 条 stall");
+    poll_advance(100);                   /* 第 9 次 */
+    poll_advance(100);                   /* 第 10 次 */
+    /*
+     * 当前实现：streak 封顶 8，但判定条件 `streak >= 8` 在后续每轮仍成立
+     * → 每 100ms 复报一条（"最后遗言"持续到 IWDG ~900ms 后复位）。
+     * 这是**刻意记录**的现状行为：它让复位前的日志窗口内信息不丢；
+     * 代价是日志冗余（约 9 条/停顿周期）。若改为"每停顿周期仅报一次"，
+     * 需加一个 s_stall_reported 标志，见文档"已知可优化点"。
+     */
+    CHECK(g_wdtest_err_count == err8 + 2, "停喂后每次抽样都复报 stall（现状）");
+}
+
+static void tc_008_recover(void) {
+    printf("TC-WD-008 恢复：重新全员到位 → 喂狗 + streak 归零\n");
+    start_and_clear();
+    for (int i = 0; i < 8; i++) poll_advance(100);   /* 触发 stall */
+    beat_all();
+    poll_advance(100);
+    CHECK(s_feed_count == 1, "恢复后立即喂狗");
+    int err0 = g_wdtest_err_count;
+    poll_advance(100);                   /* 再缺一次 */
+    CHECK(g_wdtest_err_count == err0, "streak 已归零：单次缺席不报 stall");
+}
+
+static void tc_009_throttle_boundary(void) {
+    printf("TC-WD-009 节流窗口边界 99/100/199/200\n");
+    start_and_clear();
+    beat_all();
+    poll_advance(99);   CHECK(s_feed_count == 0, "99ms 不判");
+    poll_advance(1);    CHECK(s_feed_count == 1, "100ms 判（喂狗）");
+    beat_all();
+    poll_advance(99);   CHECK(s_feed_count == 1, "再 99ms 不判");
+    poll_advance(1);    CHECK(s_feed_count == 2, "累计 100ms 判");
+}
+
+static void tc_010_tick_wrap(void) {
+    printf("TC-WD-010 tick 回绕安全\n");
+    start_and_clear();
+    s_tick = 0xFFFFFF00u;                /* 推到接近 2^32 回绕 */
+    task_wd_poll();                      /* 建立基线（此处可能不判，取决节流） */
+    beat_all();
+    s_feed_count = 0;
+    poll_advance(0x100u);                /* 跨越回绕：0xFFFFFF00 + 0x100 = 0 */
+    CHECK(s_feed_count == 1, "回绕处 100ms 仍正确判（无符号差）");
+}
+
+static void tc_011_observers(void) {
+    printf("TC-WD-011 观测接口语义\n");
+    start_and_clear();
+    CHECK(task_wd_is_armed() == 1, "is_armed == 1（已启动）");
+    beat_all();
+    poll_advance(100);
+    CHECK(task_wd_last_mask() == 0x37u, "last_mask 反映最近一次抽样");
+    CHECK(task_wd_miss_count() == 0u, "全程达标 → miss_count == 0");
+}
+
+static void tc_013_bad_id(void) {
+    printf("TC-WD-013 非法任务 ID 被忽略\n");
+    start_and_clear();
+    task_wd_beat((task_wd_id_t)(TASK_WD_ID_MAX + 3));   /* 非法：应被忽略 */
+    poll_advance(100);
+    CHECK(s_feed_count == 0, "非法 ID 未污染位图（必需位全缺 → 不喂）");
+    CHECK(task_wd_last_mask() == 0u, "位图保持 0（非法位未置）");
+}
+
+static void tc_014_start_idempotent(void) {
+    printf("TC-WD-014 start 幂等\n");
+    task_wd_start();
+    task_wd_start();
+    CHECK(s_start_count == 1, "重复 start 只启动 IWDG 一次");
+    CHECK(task_wd_is_armed() == 1, "is_armed == 1");
+}
+
+static void tc_015_start_feeds_once(void) {
+    printf("TC-WD-015 start 先喂一次（首个窗口从启动时刻起算）\n");
+    task_wd_start();
+    CHECK(s_start_count == 1, "start 启动 IWDG 一次");
+    CHECK(s_feed_count == 1, "start 内部先喂狗一次（避免启动即超时）");
+}
+
+static void tc_016_stall_not_armed_no_feed(void) {
+    printf("TC-WD-016 未启动时即便全员到位也不喂\n");
+    /* 未 start：poll 直接返回 */
+    beat_all();
+    poll_advance(500);
+    CHECK(s_feed_count == 0, "未启动 → 不喂狗（无论位图）");
+    CHECK(task_wd_last_mask() == 0u, "未启动 → 不更新 last_mask");
+}
+
+int main(void) {
+    printf("=== Task Watchdog 主机侧单元测试 ===\n");
+    printf("被测：App/util/task_watchdog.c（判定状态机）\n\n");
+
+    fresh(); tc_001_not_armed();
+    fresh(); tc_016_stall_not_armed_no_feed();
+    fresh(); tc_014_start_idempotent();
+    fresh(); tc_015_start_feeds_once();
+    fresh(); tc_002_throttle();
+    fresh(); tc_003_all_beat_feeds();
+    fresh(); tc_004_take_and_clear();
+    fresh(); tc_005_mask_required();
+    fresh(); tc_006_stall_8();
+    fresh(); tc_007_stall_repeats_until_reset();
+    fresh(); tc_008_recover();
+    fresh(); tc_009_throttle_boundary();
+    fresh(); tc_010_tick_wrap();
+    fresh(); tc_011_observers();
+    fresh(); tc_013_bad_id();
+
+    printf("\n=== Task Watchdog Tests: %d/%d PASSED (failed=%d) ===\n",
+           s_passed, s_total, s_failed);
+    return (s_failed == 0) ? 0 : 1;
+}