firmwareloop 0.7.0__tar.gz → 0.7.2__tar.gz

{firmwareloop-0.7.0 → firmwareloop-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firmwareloop
-Version: 0.7.0
+Version: 0.7.2
 Summary: AI Agent Firmware Development and Lab Automation Platform (Dual-Tier MCP Server)
 Author-email: WeilinZhang <19523330249@163.com>
 License: MIT
@@ -18,7 +18,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pyvisa>=1.14.0
-Requires-Dist: pyvisa-py>=0.7.0
+Requires-Dist: pyvisa-py>=0.7.2
 Requires-Dist: pyserial>=3.5
 Requires-Dist: pytest>=8.0.0
 Requires-Dist: pyocd>=0.36.0
@@ -383,7 +383,7 @@ claude mcp remove --scope user agentic-hil
 ├── demo-firmware/    示例固件（CMake；宿主编译模拟 MCU，闭环验证载体）
 ├── demo-make/        示例固件（Make；构建测试载体）
 ├── docs/             DEPENDENCY_MATRIX / REUSE_PLAN / V0.0.2_GAP_VERIFICATION
-├── pyproject.toml    标准 Python 包配置与 CLI 入口声明 (v0.7.0)
+├── pyproject.toml    标准 Python 包配置与 CLI 入口声明 (v0.7.2)
 ├── .mcp.example.json 双层 MCP 配置模板（firmwareloop + agentic-hil）
 ├── AGENTS.md         通用智能体规范（Antigravity / Qoder / Cursor 等）
 ├── CLAUDE.md         Claude Code CLI 指南
@@ -393,7 +393,7 @@ claude mcp remove --scope user agentic-hil
 
 ---
 
-## 能力验证状态（v0.7.0）
+## 能力验证状态（v0.7.2）
 
 > 状态定义：`Implemented`（已实现）/ `Simulator Validated`（模拟验证）/
 > `Real Hardware Validated`（真机验证）/ `Experimental` / `Not Implemented`
@@ -416,7 +416,7 @@ claude mcp remove --scope user agentic-hil
 | 自动修复闭环（M6 载体） | Simulator Validated -> Real Hardware Validated 待 DUT |
 | NdtBox 数据采集/调试（fw_ndtdbg_status / fw_ndtdbg_measure, ChipSea Fxx IIC） | Implemented（无硬件 Fail-Closed 已验证）-> Real Hardware Validated 待 NdtBox |
 | NdtBox 目标断电复位（fw_ndtdbg_power_cycle, 仅 io10 断电复位, 无写闸门） | Implemented（单测覆盖时序/探针缺失指引）-> Real Hardware Validated 待 NdtBox |
-| NdtBox IIC 固件烧录（fw_ndtdbg_flash, .bin/.nfw 整片擦写, 芯海 Fxx） | Real Hardware Validated（84.87.1.1 / 84.87.1.2 真机整片擦写 verify pass；双闸门 Fail-Closed）+ v0.7.0 boot 判据后移/整片重写（待真机复测首试成功率） |
+| NdtBox IIC 固件烧录（fw_ndtdbg_flash, .bin/.nfw 整片擦写, 芯海 Fxx） | Real Hardware Validated（84.87.1.1 / 84.87.1.2 真机整片擦写 verify pass; 2026-09-11 同批文件桥内单体 flash 6/6 pass；双闸门 Fail-Closed）。**v0.7.2 起默认引擎 = 桥内单体 flash**（逐笔 serve 路径现场实测"擦除生效但页写不落地"，保留 `flash_engine: serve` 供 A/B）；差分 boot 判据 + `boot_judge: off` 逃生开关见 0.7.1 |
 | 抓开机日志（fw_serial_capture + power_cycle_off_ms, 窗口内断电复位） | Implemented（simulator 验证窗口与复位串联）-> Real Hardware Validated 待 NdtBox + DUT |
 
 ---
@@ -430,10 +430,13 @@ claude mcp remove --scope user agentic-hil
 | 写操作 `PERMISSION_DENIED` | 全局 `lab.yaml` 的 `ndtdbg.write_allowed` 为 `false` → 临时改 `true` 并重启 Agent（测试完建议改回 `false`） |
 | sigrok 报 `Failed to receive reply to EP1 command 0x7d` | Saleae 驱动不是 libusb-win32 → 用 Zadig 重装；或设备被 Logic 软件占用（先退出） |
 | `fw_logic_decode` 空帧 | 抓取窗口内无总线事务 → 改用 `fw_ndtdbg_capture_seq`（抓取与寄存器序列同窗口进行），不要串行先抓后写 |
-| 烧录报 `BOOT_NOT_ENTERED`（擦除后 0x0000 仍读回数据） | 目标没进 boot ROM（应答的是运行态 App）→ 仅对目标板断电重启（勿动 BOX）后重试；反复出现时确认 `off_ms`（默认 500ms，独立看门狗芯片需真 POR）与 io10 供电复位接线 |
-| `fw_ndtdbg_flash` 报 `TARGET_MISMATCH: 烧录校验失败 @0x....` | 响应已带 `stage_timings`/`probe_hex`/`first_mismatch_*`：先看 `probe_hex`（非 FFFFFFFF = 根本没进 boot，属上一条），再看失配偏移是否恒定（恒定=页写未落地）；整片重写次数由 `rewrite_times` 控制（默认 3） |
+| 烧录报 `BOOT_NOT_ENTERED`（擦除魔数前后 0x0000 读回**完全相同**的非平凡数据） | 差分判据认定应答者仍是运行态 App（擦除被忽略）→ 仅对目标板断电重启（勿动 BOX）后重试；反复出现时确认 `off_ms`（默认 500ms，独立看门狗芯片需真 POR）与 io10 供电复位接线。若你确认目标 ROM 的 0x0000 语义特殊，用 `boot_judge: off`（lab.yaml/CLI `--boot-judge off`/MCP `boot_judge`）关闭判据，让逐窗校验做唯一判据 |
+| `fw_ndtdbg_flash` 报 `TARGET_MISMATCH: 烧录校验失败 @0x....` | 校验是**权威判据**（不是探测启发式）。信封带 `stage_timings`/`probe_before_hex`/`probe_hex`/`boot_evidence`/`first_mismatch_*`：`boot_evidence=erase_effective` 说明擦除生效 → 看失配偏移是否恒定（恒定=页写未落地）；`inconclusive` 说明探测无区分度（擦除后读回全 00/全 FF）→ 需人工确认是否真进了 boot；整片重写次数由 `rewrite_times` 控制（默认 3） |
 | 串口 `SERIAL_PORT_ERROR: ... PermissionError(13)` | 端口被 GUI 上位机独占（NDT Debug Tool / STDataCollection.exe、串口助手）→ 关闭占用方后 `fw_serial_open`；残留会话用 `fw_serial_close`（已自动等待/强杀进程，端口释放可验证） |
 | `fw_serial_status` 的 `error_class` 为 `UART_BUSY` | 会话未打开或已被占用 → 先 `fw_serial_open`；残留会话 `fw_serial_close` 清理 |
+| `fw_serial_*` 报 `PermissionError(13)` / `rx_bytes: 0` | 串口被独占：**退出 NDT Debug Tool GUI（STDataCollection.exe）**——它打开时会同时占住 Box 串口与 USB-IIC 通道；失败信封/`fw_serial_status` 的 `suspected_holders` 会直接列出嫌疑进程（注意别杀 MCP server 的 python） |
+| 烧录"擦除生效（probe 从非 00 变 00）但校验读回全 FF"、`pages_written` 已发出 | v0.7.1 及更早的逐笔 serve 路径问题 → v0.7.2 起默认走 `flash_engine: bridge`（桥内单体，与 GUI 同进程模型）；要复现/排查旧行为用 `flash_engine: "serve"` |
+| 长调用（capture/measure）客户端超时 | MCP stdio 循环是**单线程**的：长调用会让同会话其它调用排队（含 3s 的小调用）→ 缩短窗口，或用 `fw_ndtdbg_stream_start` job 模式 |
 
 完整速查表与手工部署细节见 [`Fwloop_setup_pack/README.md`](Fwloop_setup_pack/README.md)。
 

{firmwareloop-0.7.0 → firmwareloop-0.7.2}/README.md

@@ -355,7 +355,7 @@ claude mcp remove --scope user agentic-hil
 ├── demo-firmware/    示例固件（CMake；宿主编译模拟 MCU，闭环验证载体）
 ├── demo-make/        示例固件（Make；构建测试载体）
 ├── docs/             DEPENDENCY_MATRIX / REUSE_PLAN / V0.0.2_GAP_VERIFICATION
-├── pyproject.toml    标准 Python 包配置与 CLI 入口声明 (v0.7.0)
+├── pyproject.toml    标准 Python 包配置与 CLI 入口声明 (v0.7.2)
 ├── .mcp.example.json 双层 MCP 配置模板（firmwareloop + agentic-hil）
 ├── AGENTS.md         通用智能体规范（Antigravity / Qoder / Cursor 等）
 ├── CLAUDE.md         Claude Code CLI 指南
@@ -365,7 +365,7 @@ claude mcp remove --scope user agentic-hil
 
 ---
 
-## 能力验证状态（v0.7.0）
+## 能力验证状态（v0.7.2）
 
 > 状态定义：`Implemented`（已实现）/ `Simulator Validated`（模拟验证）/
 > `Real Hardware Validated`（真机验证）/ `Experimental` / `Not Implemented`
@@ -388,7 +388,7 @@ claude mcp remove --scope user agentic-hil
 | 自动修复闭环（M6 载体） | Simulator Validated -> Real Hardware Validated 待 DUT |
 | NdtBox 数据采集/调试（fw_ndtdbg_status / fw_ndtdbg_measure, ChipSea Fxx IIC） | Implemented（无硬件 Fail-Closed 已验证）-> Real Hardware Validated 待 NdtBox |
 | NdtBox 目标断电复位（fw_ndtdbg_power_cycle, 仅 io10 断电复位, 无写闸门） | Implemented（单测覆盖时序/探针缺失指引）-> Real Hardware Validated 待 NdtBox |
-| NdtBox IIC 固件烧录（fw_ndtdbg_flash, .bin/.nfw 整片擦写, 芯海 Fxx） | Real Hardware Validated（84.87.1.1 / 84.87.1.2 真机整片擦写 verify pass；双闸门 Fail-Closed）+ v0.7.0 boot 判据后移/整片重写（待真机复测首试成功率） |
+| NdtBox IIC 固件烧录（fw_ndtdbg_flash, .bin/.nfw 整片擦写, 芯海 Fxx） | Real Hardware Validated（84.87.1.1 / 84.87.1.2 真机整片擦写 verify pass; 2026-09-11 同批文件桥内单体 flash 6/6 pass；双闸门 Fail-Closed）。**v0.7.2 起默认引擎 = 桥内单体 flash**（逐笔 serve 路径现场实测"擦除生效但页写不落地"，保留 `flash_engine: serve` 供 A/B）；差分 boot 判据 + `boot_judge: off` 逃生开关见 0.7.1 |
 | 抓开机日志（fw_serial_capture + power_cycle_off_ms, 窗口内断电复位） | Implemented（simulator 验证窗口与复位串联）-> Real Hardware Validated 待 NdtBox + DUT |
 
 ---
@@ -402,10 +402,13 @@ claude mcp remove --scope user agentic-hil
 | 写操作 `PERMISSION_DENIED` | 全局 `lab.yaml` 的 `ndtdbg.write_allowed` 为 `false` → 临时改 `true` 并重启 Agent（测试完建议改回 `false`） |
 | sigrok 报 `Failed to receive reply to EP1 command 0x7d` | Saleae 驱动不是 libusb-win32 → 用 Zadig 重装；或设备被 Logic 软件占用（先退出） |
 | `fw_logic_decode` 空帧 | 抓取窗口内无总线事务 → 改用 `fw_ndtdbg_capture_seq`（抓取与寄存器序列同窗口进行），不要串行先抓后写 |
-| 烧录报 `BOOT_NOT_ENTERED`（擦除后 0x0000 仍读回数据） | 目标没进 boot ROM（应答的是运行态 App）→ 仅对目标板断电重启（勿动 BOX）后重试；反复出现时确认 `off_ms`（默认 500ms，独立看门狗芯片需真 POR）与 io10 供电复位接线 |
-| `fw_ndtdbg_flash` 报 `TARGET_MISMATCH: 烧录校验失败 @0x....` | 响应已带 `stage_timings`/`probe_hex`/`first_mismatch_*`：先看 `probe_hex`（非 FFFFFFFF = 根本没进 boot，属上一条），再看失配偏移是否恒定（恒定=页写未落地）；整片重写次数由 `rewrite_times` 控制（默认 3） |
+| 烧录报 `BOOT_NOT_ENTERED`（擦除魔数前后 0x0000 读回**完全相同**的非平凡数据） | 差分判据认定应答者仍是运行态 App（擦除被忽略）→ 仅对目标板断电重启（勿动 BOX）后重试；反复出现时确认 `off_ms`（默认 500ms，独立看门狗芯片需真 POR）与 io10 供电复位接线。若你确认目标 ROM 的 0x0000 语义特殊，用 `boot_judge: off`（lab.yaml/CLI `--boot-judge off`/MCP `boot_judge`）关闭判据，让逐窗校验做唯一判据 |
+| `fw_ndtdbg_flash` 报 `TARGET_MISMATCH: 烧录校验失败 @0x....` | 校验是**权威判据**（不是探测启发式）。信封带 `stage_timings`/`probe_before_hex`/`probe_hex`/`boot_evidence`/`first_mismatch_*`：`boot_evidence=erase_effective` 说明擦除生效 → 看失配偏移是否恒定（恒定=页写未落地）；`inconclusive` 说明探测无区分度（擦除后读回全 00/全 FF）→ 需人工确认是否真进了 boot；整片重写次数由 `rewrite_times` 控制（默认 3） |
 | 串口 `SERIAL_PORT_ERROR: ... PermissionError(13)` | 端口被 GUI 上位机独占（NDT Debug Tool / STDataCollection.exe、串口助手）→ 关闭占用方后 `fw_serial_open`；残留会话用 `fw_serial_close`（已自动等待/强杀进程，端口释放可验证） |
 | `fw_serial_status` 的 `error_class` 为 `UART_BUSY` | 会话未打开或已被占用 → 先 `fw_serial_open`；残留会话 `fw_serial_close` 清理 |
+| `fw_serial_*` 报 `PermissionError(13)` / `rx_bytes: 0` | 串口被独占：**退出 NDT Debug Tool GUI（STDataCollection.exe）**——它打开时会同时占住 Box 串口与 USB-IIC 通道；失败信封/`fw_serial_status` 的 `suspected_holders` 会直接列出嫌疑进程（注意别杀 MCP server 的 python） |
+| 烧录"擦除生效（probe 从非 00 变 00）但校验读回全 FF"、`pages_written` 已发出 | v0.7.1 及更早的逐笔 serve 路径问题 → v0.7.2 起默认走 `flash_engine: bridge`（桥内单体，与 GUI 同进程模型）；要复现/排查旧行为用 `flash_engine: "serve"` |
+| 长调用（capture/measure）客户端超时 | MCP stdio 循环是**单线程**的：长调用会让同会话其它调用排队（含 3s 的小调用）→ 缩短窗口，或用 `fw_ndtdbg_stream_start` job 模式 |
 
 完整速查表与手工部署细节见 [`Fwloop_setup_pack/README.md`](Fwloop_setup_pack/README.md)。
 

{firmwareloop-0.7.0 → firmwareloop-0.7.2}/firmwareloop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firmwareloop
-Version: 0.7.0
+Version: 0.7.2
 Summary: AI Agent Firmware Development and Lab Automation Platform (Dual-Tier MCP Server)
 Author-email: WeilinZhang <19523330249@163.com>
 License: MIT
@@ -18,7 +18,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pyvisa>=1.14.0
-Requires-Dist: pyvisa-py>=0.7.0
+Requires-Dist: pyvisa-py>=0.7.2
 Requires-Dist: pyserial>=3.5
 Requires-Dist: pytest>=8.0.0
 Requires-Dist: pyocd>=0.36.0
@@ -383,7 +383,7 @@ claude mcp remove --scope user agentic-hil
 ├── demo-firmware/    示例固件（CMake；宿主编译模拟 MCU，闭环验证载体）
 ├── demo-make/        示例固件（Make；构建测试载体）
 ├── docs/             DEPENDENCY_MATRIX / REUSE_PLAN / V0.0.2_GAP_VERIFICATION
-├── pyproject.toml    标准 Python 包配置与 CLI 入口声明 (v0.7.0)
+├── pyproject.toml    标准 Python 包配置与 CLI 入口声明 (v0.7.2)
 ├── .mcp.example.json 双层 MCP 配置模板（firmwareloop + agentic-hil）
 ├── AGENTS.md         通用智能体规范（Antigravity / Qoder / Cursor 等）
 ├── CLAUDE.md         Claude Code CLI 指南
@@ -393,7 +393,7 @@ claude mcp remove --scope user agentic-hil
 
 ---
 
-## 能力验证状态（v0.7.0）
+## 能力验证状态（v0.7.2）
 
 > 状态定义：`Implemented`（已实现）/ `Simulator Validated`（模拟验证）/
 > `Real Hardware Validated`（真机验证）/ `Experimental` / `Not Implemented`
@@ -416,7 +416,7 @@ claude mcp remove --scope user agentic-hil
 | 自动修复闭环（M6 载体） | Simulator Validated -> Real Hardware Validated 待 DUT |
 | NdtBox 数据采集/调试（fw_ndtdbg_status / fw_ndtdbg_measure, ChipSea Fxx IIC） | Implemented（无硬件 Fail-Closed 已验证）-> Real Hardware Validated 待 NdtBox |
 | NdtBox 目标断电复位（fw_ndtdbg_power_cycle, 仅 io10 断电复位, 无写闸门） | Implemented（单测覆盖时序/探针缺失指引）-> Real Hardware Validated 待 NdtBox |
-| NdtBox IIC 固件烧录（fw_ndtdbg_flash, .bin/.nfw 整片擦写, 芯海 Fxx） | Real Hardware Validated（84.87.1.1 / 84.87.1.2 真机整片擦写 verify pass；双闸门 Fail-Closed）+ v0.7.0 boot 判据后移/整片重写（待真机复测首试成功率） |
+| NdtBox IIC 固件烧录（fw_ndtdbg_flash, .bin/.nfw 整片擦写, 芯海 Fxx） | Real Hardware Validated（84.87.1.1 / 84.87.1.2 真机整片擦写 verify pass; 2026-09-11 同批文件桥内单体 flash 6/6 pass；双闸门 Fail-Closed）。**v0.7.2 起默认引擎 = 桥内单体 flash**（逐笔 serve 路径现场实测"擦除生效但页写不落地"，保留 `flash_engine: serve` 供 A/B）；差分 boot 判据 + `boot_judge: off` 逃生开关见 0.7.1 |
 | 抓开机日志（fw_serial_capture + power_cycle_off_ms, 窗口内断电复位） | Implemented（simulator 验证窗口与复位串联）-> Real Hardware Validated 待 NdtBox + DUT |
 
 ---
@@ -430,10 +430,13 @@ claude mcp remove --scope user agentic-hil
 | 写操作 `PERMISSION_DENIED` | 全局 `lab.yaml` 的 `ndtdbg.write_allowed` 为 `false` → 临时改 `true` 并重启 Agent（测试完建议改回 `false`） |
 | sigrok 报 `Failed to receive reply to EP1 command 0x7d` | Saleae 驱动不是 libusb-win32 → 用 Zadig 重装；或设备被 Logic 软件占用（先退出） |
 | `fw_logic_decode` 空帧 | 抓取窗口内无总线事务 → 改用 `fw_ndtdbg_capture_seq`（抓取与寄存器序列同窗口进行），不要串行先抓后写 |
-| 烧录报 `BOOT_NOT_ENTERED`（擦除后 0x0000 仍读回数据） | 目标没进 boot ROM（应答的是运行态 App）→ 仅对目标板断电重启（勿动 BOX）后重试；反复出现时确认 `off_ms`（默认 500ms，独立看门狗芯片需真 POR）与 io10 供电复位接线 |
-| `fw_ndtdbg_flash` 报 `TARGET_MISMATCH: 烧录校验失败 @0x....` | 响应已带 `stage_timings`/`probe_hex`/`first_mismatch_*`：先看 `probe_hex`（非 FFFFFFFF = 根本没进 boot，属上一条），再看失配偏移是否恒定（恒定=页写未落地）；整片重写次数由 `rewrite_times` 控制（默认 3） |
+| 烧录报 `BOOT_NOT_ENTERED`（擦除魔数前后 0x0000 读回**完全相同**的非平凡数据） | 差分判据认定应答者仍是运行态 App（擦除被忽略）→ 仅对目标板断电重启（勿动 BOX）后重试；反复出现时确认 `off_ms`（默认 500ms，独立看门狗芯片需真 POR）与 io10 供电复位接线。若你确认目标 ROM 的 0x0000 语义特殊，用 `boot_judge: off`（lab.yaml/CLI `--boot-judge off`/MCP `boot_judge`）关闭判据，让逐窗校验做唯一判据 |
+| `fw_ndtdbg_flash` 报 `TARGET_MISMATCH: 烧录校验失败 @0x....` | 校验是**权威判据**（不是探测启发式）。信封带 `stage_timings`/`probe_before_hex`/`probe_hex`/`boot_evidence`/`first_mismatch_*`：`boot_evidence=erase_effective` 说明擦除生效 → 看失配偏移是否恒定（恒定=页写未落地）；`inconclusive` 说明探测无区分度（擦除后读回全 00/全 FF）→ 需人工确认是否真进了 boot；整片重写次数由 `rewrite_times` 控制（默认 3） |
 | 串口 `SERIAL_PORT_ERROR: ... PermissionError(13)` | 端口被 GUI 上位机独占（NDT Debug Tool / STDataCollection.exe、串口助手）→ 关闭占用方后 `fw_serial_open`；残留会话用 `fw_serial_close`（已自动等待/强杀进程，端口释放可验证） |
 | `fw_serial_status` 的 `error_class` 为 `UART_BUSY` | 会话未打开或已被占用 → 先 `fw_serial_open`；残留会话 `fw_serial_close` 清理 |
+| `fw_serial_*` 报 `PermissionError(13)` / `rx_bytes: 0` | 串口被独占：**退出 NDT Debug Tool GUI（STDataCollection.exe）**——它打开时会同时占住 Box 串口与 USB-IIC 通道；失败信封/`fw_serial_status` 的 `suspected_holders` 会直接列出嫌疑进程（注意别杀 MCP server 的 python） |
+| 烧录"擦除生效（probe 从非 00 变 00）但校验读回全 FF"、`pages_written` 已发出 | v0.7.1 及更早的逐笔 serve 路径问题 → v0.7.2 起默认走 `flash_engine: bridge`（桥内单体，与 GUI 同进程模型）；要复现/排查旧行为用 `flash_engine: "serve"` |
+| 长调用（capture/measure）客户端超时 | MCP stdio 循环是**单线程**的：长调用会让同会话其它调用排队（含 3s 的小调用）→ 缩短窗口，或用 `fw_ndtdbg_stream_start` job 模式 |
 
 完整速查表与手工部署细节见 [`Fwloop_setup_pack/README.md`](Fwloop_setup_pack/README.md)。
 

{firmwareloop-0.7.0 → firmwareloop-0.7.2}/firmwareloop.egg-info/requires.txt

@@ -1,5 +1,5 @@
 pyvisa>=1.14.0
-pyvisa-py>=0.7.0
+pyvisa-py>=0.7.2
 pyserial>=3.5
 pytest>=8.0.0
 pyocd>=0.36.0

{firmwareloop-0.7.0 → firmwareloop-0.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "firmwareloop"
-version = "0.7.0"
+version = "0.7.2"
 description = "AI Agent Firmware Development and Lab Automation Platform (Dual-Tier MCP Server)"
 readme = "README.md"
 authors = [
@@ -14,7 +14,7 @@ license = { text = "MIT" }
 requires-python = ">=3.10"
 dependencies = [
     "pyvisa>=1.14.0",
-    "pyvisa-py>=0.7.0",
+    "pyvisa-py>=0.7.2",
     "pyserial>=3.5",
     "pytest>=8.0.0",
     "pyocd>=0.36.0",

{firmwareloop-0.7.0 → firmwareloop-0.7.2}/tools/__init__.py

@@ -2,4 +2,4 @@
 FirmwareLoop - AI Agent Firmware Development and Lab Automation Platform.
 """
 
-__version__ = "0.7.0"
+__version__ = "0.7.2"

{firmwareloop-0.7.0 → firmwareloop-0.7.2}/tools/fw_mcp_server.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-fw_mcp_server.py - FirmwareLoop High-Level Workflow & Device MCP Server (v0.7.0).
+fw_mcp_server.py - FirmwareLoop High-Level Workflow & Device MCP Server (v0.7.2).
 
 Exposes high-level firmware engineering and hardware management tools to AI Coding
 Agents (Antigravity CLI, Claude Code CLI, Qoder IDE, CodeBuddy IDE, Cursor) via the Model Context
@@ -332,7 +332,7 @@ def handle_fw_ndtdbg_write_reg(args: Dict[str, Any]) -> Dict[str, Any]:
 def handle_fw_ndtdbg_flash(args: Dict[str, Any]) -> Dict[str, Any]:
     """Erase + flash a .bin/.nfw image onto the NdtBox target chip (ChipSea Fxx) over IIC.
 
-    P1-3 (0.7.0): 去掉按签名重试 —— "TARGET_MISMATCH @0x0000" 正是"根本没进 boot"的
+    P1-3 (0.7.2): 去掉按签名重试 —— "TARGET_MISMATCH @0x0000" 正是"根本没进 boot"的
     特征签名 (旧 boot 判据假阳的同一条错误路径), 盲目重试只会重复同一失败路径。
     整片重写 (<= rewrite_times) 现由 flash_exec 内部完成, 结果带 rewrite_count;
     BOOT_NOT_ENTERED 直接返回指引 (需断电重启, 重试无意义)。
@@ -344,6 +344,10 @@ def handle_fw_ndtdbg_flash(args: Dict[str, Any]) -> Dict[str, Any]:
         cmd.extend(["--off-ms", str(int(args["off_ms"]))])
     if args.get("rewrite_times") is not None:
         cmd.extend(["--rewrite-times", str(max(0, int(args["rewrite_times"])))])
+    if args.get("boot_judge"):
+        cmd.extend(["--boot-judge", str(args["boot_judge"])])
+    if args.get("flash_engine"):
+        cmd.extend(["--flash-engine", str(args["flash_engine"])])
     if args.get("confirm"):
         cmd.append("--confirm")
     _ndtdbg_reg_args(args, cmd)
@@ -1677,7 +1681,7 @@ TOOLS_REGISTRY = {
         "handler": handle_fw_ndtdbg_status,
     },
     "fw_ndtdbg_measure": {
-        "description": "Poll NdtBox IIC debug data stream (ChipSea Fxx) for N seconds: frame count, checksum errors, channel samples. Read-only; firmware upgrade is a separate future capability.",
+        "description": "Poll NdtBox IIC debug data stream (ChipSea Fxx) for N seconds: frame count, checksum errors, channel samples. Read-only. NOTE: the MCP stdio loop is single-threaded, so a long call blocks every other call in the same session (a concurrent short call just waits and may time out client-side) - keep duration_seconds small; use fw_ndtdbg_stream_start for long captures.",
         "inputSchema": {
             "type": "object",
             "properties": {
@@ -1770,7 +1774,7 @@ TOOLS_REGISTRY = {
         "handler": handle_fw_ndtdbg_write_reg,
     },
     "fw_ndtdbg_flash": {
-        "description": "Erase and flash a .bin/.nfw firmware image onto the NdtBox target chip (ChipSea Fxx) over IIC via NdtDebugTool (power-cycle reset into boot -> erase magic AA 55 A5 5A -> BOOT JUDGEMENT: 0x0000 must read all-0xFF, a running App answers its own static registers and is rejected with BOOT_NOT_ENTERED -> 128B page writes -> 256B read-back verify, whole-chip rewrite on mismatch -> finish 'PASs'). DESTRUCTIVE full-chip erase: requires lab.yaml ndtdbg.write_allowed: true AND confirm: true, otherwise PERMISSION_DENIED.",
+        "description": "Erase and flash a .bin/.nfw firmware image onto the NdtBox target chip (ChipSea Fxx) over IIC via NdtDebugTool. Default engine 'bridge' runs the whole UpdateFW sequence in ONE 32-bit process holding both the IIC and power-rail handles (power-cycle into boot -> erase magic AA 55 A5 5A -> 128B page writes -> 256B read-back verify per window = the authoritative criterion -> finish 'PASs'), which is the path validated 6/6 on real hardware; engine 'serve' drives one raw transaction per page from Python (kept for A/B reproduction - field evidence showed it can report erase-effective but write nothing on the same frames). DESTRUCTIVE full-chip erase: requires lab.yaml ndtdbg.write_allowed: true AND confirm: true, otherwise PERMISSION_DENIED.",
         "inputSchema": {
             "type": "object",
             "properties": {
@@ -1799,7 +1803,17 @@ TOOLS_REGISTRY = {
                 },
                 "rewrite_times": {
                     "type": "integer",
-                    "description": "Whole-chip rewrite budget when read-back verify mismatches (aligned with ChipSea.cs REWRITE_TIMES). Default 3; 0 disables rewriting. The result carries rewrite_count/attempts, and a failed flash reports stage_timings/probe_hex/first_mismatch_* for post-mortem",
+                    "description": "Whole-chip rewrite budget when read-back verify mismatches (aligned with ChipSea.cs REWRITE_TIMES). Default 3; 0 disables rewriting. The result carries rewrite_count/attempts, and a failed flash reports stage_timings/probe_before_hex/probe_hex/boot_evidence/first_mismatch_* for post-mortem",
+                },
+                "boot_judge": {
+                    "type": "string",
+                    "enum": ["diff", "off"],
+                    "description": "Boot-probe criterion (serve engine only). 'diff' (default): compare 0x0000 before the power cycle vs after the erase, and raise BOOT_NOT_ENTERED only when both reads are identical NON-TRIVIAL data (proof the same running App answered the erase magic). 'off': only record probe evidence (probe_before_hex/probe_hex/boot_evidence) and never block - the 256B read-back verify stays the sole criterion, i.e. exactly the bridge/GUI behaviour. Use 'off' if a target ROM reports an unexpected 0x0000 signature",
+                },
+                "flash_engine": {
+                    "type": "string",
+                    "enum": ["bridge", "serve"],
+                    "description": "Flash transport. 'bridge' (default): whole sequence inside one 32-bit process, frames passed once via stdin, both device handles held - real-hardware validated (6/6). 'serve': one raw I2C transaction per page driven from Python (kept for A/B; field evidence: same frames reported 'erase effective' yet wrote nothing). Use 'serve' only to reproduce/diagnose that case",
                 },
                 "dll_dir": {
                     "type": "string",
@@ -2235,7 +2249,7 @@ TOOLS_REGISTRY = {
         "handler": handle_fw_serial_parse,
     },
     "fw_serial_capture": {
-        "description": "Serial assistant: synchronous window capture - record the RX stream for duration_ms into a timestamped CSV (t_rel_ms, dir, hex, printable) for offline analysis/plotting (real-time-curve equivalent; plotting happens in your tools/Agent from the CSV). Pass power_cycle_off_ms to fire an NdtBox power-cycle inside the window and capture boot-time prints (port is opened first). duration_ms <= 90000; long background captures (job mode) are a planned follow-up.",
+        "description": "Serial assistant: synchronous window capture - record the RX stream for duration_ms into a timestamped CSV (t_rel_ms, dir, hex, printable) for offline analysis/plotting (real-time-curve equivalent; plotting happens in your tools/Agent from the CSV). Pass power_cycle_off_ms to fire an NdtBox power-cycle inside the window and capture boot-time prints (port is opened first). duration_ms <= 90000; long background captures (job mode) are a planned follow-up. NOTE: the MCP stdio loop is single-threaded, so this call blocks every other call in the same session for the whole window (your client may time out first) - prefer windows of a few seconds and call it when nothing else needs the box.",
         "inputSchema": {
             "type": "object",
             "properties": {
@@ -2300,7 +2314,7 @@ def process_request(req: Dict[str, Any]) -> Optional[Dict[str, Any]]:
                 },
                 "serverInfo": {
                     "name": "firmwareloop",
-                    "version": "0.7.0"
+                    "version": "0.7.2"
                 }
             }
         }
@@ -2435,7 +2449,7 @@ def _settle_stashed_entrypoints(stashed) -> None:
 def handle_cli_update() -> int:
     """Handle `firmwareloop update` command."""
     print("============================================================")
-    print("  FirmwareLoop Auto-Updater (v0.7.0)")
+    print("  FirmwareLoop Auto-Updater (v0.7.2)")
     print("============================================================")
 
     is_git_repo = os.path.exists(os.path.join(REPO_ROOT, ".git"))
@@ -2866,7 +2880,7 @@ def set_ndtdbg_dlldir(dll_path: str) -> str:
 def handle_cli_setup() -> int:
     """Handle `firmwareloop setup` command: simultaneously configure Antigravity CLI, Claude Code CLI, Qoder IDE, and CodeBuddy IDE."""
     print("============================================================")
-    print("  FirmwareLoop Multi-Agent Global Setup Helper (v0.7.0)")
+    print("  FirmwareLoop Multi-Agent Global Setup Helper (v0.7.2)")
     print("============================================================")
     print("")
 
@@ -2991,7 +3005,7 @@ def handle_cli_setup() -> int:
 def handle_cli_init(chip: Optional[str] = None, upgrade: bool = False) -> int:
     """Handle `firmwareloop init [target_chip]` command."""
     print("============================================================")
-    print("  FirmwareLoop Multi-Agent Project Initializer (v0.7.0)")
+    print("  FirmwareLoop Multi-Agent Project Initializer (v0.7.2)")
     print("============================================================")
     cwd = os.getcwd()
     print(f"[*] Initializing multi-agent guidelines & bench config in:\n    {cwd}\n")
@@ -3024,7 +3038,7 @@ def handle_cli_init(chip: Optional[str] = None, upgrade: bool = False) -> int:
 
 
 def print_cli_help() -> None:
-    print("""FirmwareLoop (fwloop) — AI Agent Firmware Engineering & Lab Automation Platform (v0.7.0)
+    print("""FirmwareLoop (fwloop) — AI Agent Firmware Engineering & Lab Automation Platform (v0.7.2)
 
 Usage:
   fwloop [command]   (or: firmwareloop [command])
@@ -3070,7 +3084,7 @@ def main() -> None:
                 sys.exit(2)
             sys.exit(handle_cli_ndtdebugtool(args[1]))
         elif cmd in ["version", "-v", "--version"]:
-            print("FirmwareLoop v0.7.0")
+            print("FirmwareLoop v0.7.2")
             sys.exit(0)
         elif cmd in ["help", "-h", "--help"]:
             print_cli_help()

{firmwareloop-0.7.0 → firmwareloop-0.7.2}/tools/lib/ndtdbg.py

@@ -11,6 +11,7 @@ import contextlib
 import json
 import os
 import queue
+import re
 import subprocess
 import sys
 import threading
@@ -262,9 +263,9 @@ PAGE_READ_GAP_MS = 10      # 回读窗口间隔 (ReadFwAndCheck Thread.Sleep(10)
 def _flash_envelope(timings: dict | None = None, **extra) -> dict:
     """P1-2: 烧录成功/失败共用同一组诊断字段。
 
-    分阶段耗时 (stage_timings) + boot 探测原始数据 (probe_hex) + 首个失配点
-    (first_mismatch_offset/expect/got) + 页数与重写次数——失败不再是"只有一句话",
-    能当场区分 "探测假阳 (根本没进 boot)" 与 "进了 boot 但页写没落地"。
+    分阶段耗时 (stage_timings) + boot 探测原始数据 (probe_before_hex/probe_hex) +
+    判据结论 (boot_evidence) + 首个失配点 (first_mismatch_offset/expect/got) +
+    页数与重写次数——失败不再是"只有一句话", 能当场区分"根本没进 boot"与"页写没落地"。
     """
     out: dict = {"stage_timings": dict(timings or {})}
     for key, val in extra.items():
@@ -273,6 +274,38 @@ def _flash_envelope(timings: dict | None = None, **extra) -> dict:
     return out
 
 
+BOOT_JUDGE_MODES = ("diff", "off")
+
+
+def classify_boot_evidence(before: bytes | None, after: bytes | None) -> str:
+    """烧录 boot 判据 (0.7.1 差分判据, 取代被实战证伪的"擦除后必须全 FF")。
+
+    返回: 'app_still_answering' (唯一熔断情形) | 'erase_effective' | 'inconclusive' | 'not_evaluated'
+
+    实战铁证 (2026-09-11, CSA37F72): 擦除后读 0x0000 = `00 00 00 00` 而非 FF ——
+    桥内单体 flash (无判据、时序同 GUI) 对同一批文件全部 verify pass ⇒ "全 FF" 只是
+    该 ROM 的**未验证假设**, 一旦当硬判据就会永久误判 BOOT_NOT_ENTERED。
+
+    现判据只在"有正面证据表明应答者仍是运行态固件"时熔断:
+      * 两次读数不同 (含"有应答 -> 无应答") ⇒ 擦除生效 ⇒ 继续;
+      * 任一侧无应答 (None) ⇒ 无法比对 ⇒ 不确定, 继续;
+      * 两次相同但内容是全 00/全 FF ⇒ 无法区分 (本 ROM 擦除后正是全 00, 而某些固件
+        的静态寄存器也可能全 0) ⇒ 不确定, 继续;
+      * 两次相同且是非平凡数据 (如 `25 01 18 01`) ⇒ 擦除魔数 (boot ROM 专属命令)
+        前后是同一条应答 ⇒ 魔数被忽略, 应答者仍是 App ⇒ 熔断。
+    一切不确定情形都放行, 由页写后的逐窗回读校验做权威兜底 (fail-closed)。
+    """
+    if before is None and after is None:
+        return "inconclusive"
+    if before is None or after is None:
+        return "erase_effective"     # 一侧有内容: 相较之下状态变了
+    if before != after:
+        return "erase_effective"
+    if all(b in (0x00, 0xFF) for b in after):
+        return "inconclusive"        # 全 00/全 FF 无区分度
+    return "app_still_answering"
+
+
 def load_firmware(file_path: str) -> tuple[str, bytes]:
     """读取固件: .nfw 去 256 头 / .bin 128 对齐 0xFF 补齐 (ChipSea.cs LoadFile)。返回 (类型, 载荷)。"""
     if not os.path.isfile(file_path):
@@ -370,13 +403,19 @@ class NdtBoxIo:
         return self._persistent
 
     def _with_sess(self, fn):
+        """在活跃会话上执行单事务。
+
+        `with io.session():` 块内 self._persistent 已置位 ⇒ 复用同一个 32 位桥进程与
+        USB 会话 (事务延迟 = 一次管道往返); 块外为即用即关 (spawn+open+事务+close)。
+        (现场曾怀疑此处未复用导致 77ms/页——每笔新 spawn 是 ~1.5s 量级, 与 77ms 不符,
+        故复用确实生效; 该现象的真因见 flash_exec 的引擎说明。)
+        """
         sess = self._get_live_sess()
-        if self._persistent is sess:
-            return fn(sess)
         try:
             return fn(sess)
         finally:
-            sess.close()
+            if sess is not self._persistent:
+                sess.close()
 
     # -- 芯片无关原语 (对齐 IIC.cs / I2CProxy.cs) --
 
@@ -392,7 +431,18 @@ class NdtBoxIo:
         return self._with_sess(lambda s: s.read_reg(reg, length))
 
     def write_reg(self, reg: int, data: bytes) -> None:
-        self._with_sess(lambda s: s.write_reg(reg, data))
+        try:
+            self._with_sess(lambda s: s.write_reg(reg, data))
+        except NdtBoxError as exc:
+            if exc.error_class != "TARGET_MISMATCH":
+                raise
+            # P2-1: 写 NACK ≠ 从机死了 —— 现场实证"读正常但写稳定失败"
+            raise NdtBoxError(
+                exc.error_class, exc.message, exc.detail,
+                {"hint": "写事务无应答与'从机整体不应答'不同: 若紧随其后的读事务正常, 更可能是"
+                         "该寄存器不可写/写保护, 或目标固件未实现该写寄存器 (也可能是写事务"
+                         "超长/格式不符)。先用 fw_ndtdbg_read_reg 回读邻居寄存器确认链路仍活, "
+                         "再核对寄存器语义"}) from exc
 
     def raw_write_read(self, write: bytes, read_len: int = 0) -> bytes | None:
         """原始 IIC 事务 (对齐 IIC.WriteRead): 写 write 字节(不含从机地址) 再读 read_len 字节。
@@ -615,25 +665,221 @@ class NdtBoxIo:
             "duration_actual_ms": int((time.monotonic() - started) * 1000),
         }
 
+    def _probe_0000(self) -> bytes | None:
+        """读 0x0000 4 字节 (boot 判据探测): 有应答返回字节, 无应答 (TARGET_MISMATCH) 返回 None。
+
+        BUS_TIMEOUT (clock-stretch 挂死) / PROTOCOL_ERROR (会话错位) 上抛——这两种状态下
+        任何继续操作都不可信 (fail-closed)。
+        """
+        try:
+            return self.raw_write_read(b"\x00\x00", 4)
+        except NdtBoxError as exc:
+            if exc.error_class == "TARGET_MISMATCH":
+                return None
+            raise
+
+    def _bridge_plan_json(self, plan: dict) -> str:
+        """桥 flash action 的 stdin plan (只含桥认识的键)。"""
+        return json.dumps({
+            "off_ms": int(plan.get("off_ms", DEFAULT_OFF_MS)),
+            "erase_ms": int(plan.get("erase_ms", 2000)),
+            "page_gap_ms": int(plan.get("page_gap_ms", PAGE_WRITE_GAP_MS)),
+            "read_gap_ms": int(plan.get("read_gap_ms", PAGE_READ_GAP_MS)),
+            "writes": list(plan.get("writes", []) or []),
+            "windows": list(plan.get("windows", []) or []),
+        }, ensure_ascii=False)
+
+    def _bridge_flash_once(self, plan: dict) -> dict:
+        """单次桥内单体烧录 (ndtdbg_bridge.ps1 -Action flash): 返回 data dict, 失败抛 NdtBoxError。
+
+        桥侧 #progress 行转发到 stderr (agent 可见进度), 末行 JSON 为结果 / 错误信封。
+        桥自身无超时 ⇒ 本层按 plan 推预算守护, 超时 kill 并报 BUS_TIMEOUT (不留孤儿进程)。
+        """
+        import time
+        if not os.path.exists(PS32):
+            raise NdtBoxError("CONFIG_ERROR", f"32 位 PowerShell 不存在: {PS32}")
+        if not os.path.isfile(os.path.join(self.dll_dir, "USBIOX.DLL")):
+            raise NdtBoxError("CONFIG_ERROR", f"USBIOX.DLL 不存在: {self.dll_dir}",
+                              "lab.yaml 的 ndtdbg.dll_dir 指向 NdtDebugTool 的 lib 目录")
+        args = [PS32, "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass",
+                "-File", self.bridge_ps1, "-Action", "flash",
+                "-DllDir", self.dll_dir, "-SlaveAddr", str(self.slave_addr),
+                "-Speed", str(self.speed)]
+        pages = len(plan.get("writes") or [])
+        windows = len(plan.get("windows") or [])
+        # 预算: 页写/回读节奏 + 擦除 + 三次断电复位 + 固定裕量; plan["budget_ms"] 可覆盖 (测试用)
+        budget_ms = int(plan.get("budget_ms") or (
+            pages * (int(plan.get("page_gap_ms", PAGE_WRITE_GAP_MS)) + 60)
+            + windows * (int(plan.get("read_gap_ms", PAGE_READ_GAP_MS)) + 40)
+            + int(plan.get("erase_ms", 2000))
+            + int(plan.get("off_ms", DEFAULT_OFF_MS)) * 3 + 30000))
+        t0 = time.monotonic()
+        proc = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                                stderr=subprocess.PIPE, text=True, encoding="utf-8",
+                                errors="replace", bufsize=1)
+        lines: list = []
+
+        def _reader() -> None:
+            try:
+                for raw in proc.stdout:
+                    line = (raw or "").strip()
+                    if not line:
+                        continue
+                    if line.startswith("#progress"):
+                        print(f"[flash] {line[len('#progress'):].strip()}",
+                              file=sys.stderr, flush=True)
+                        continue
+                    if line.startswith("{"):
+                        lines.append(line)
+            except Exception:
+                pass
+
+        reader = threading.Thread(target=_reader, daemon=True)
+        reader.start()
+        try:
+            try:
+                proc.stdin.write(self._bridge_plan_json(plan))
+                proc.stdin.close()
+            except Exception as exc:
+                proc.kill()
+                raise NdtBoxError("UNKNOWN_ERROR", f"向桥 flash 写入计划失败: {exc}") from exc
+            deadline = time.monotonic() + max(5.0, budget_ms / 1000.0)
+            while time.monotonic() < deadline:
+                if proc.poll() is not None and not reader.is_alive():
+                    break
+                time.sleep(0.05)
+            else:
+                proc.kill()
+                raise NdtBoxError(
+                    "BUS_TIMEOUT",
+                    f"桥内 flash 超时 (预算 {budget_ms}ms, {pages} 页/{windows} 窗): 已终止桥进程。"
+                    "检查目标是否卡在擦除/页写 (可先 fw_ndtdbg_power_cycle 复位再试)",
+                    None);
+            elapsed_ms = round((time.monotonic() - t0) * 1000)
+            if not lines:
+                err = ""
+                try:
+                    err = (proc.stderr.read() or "")[-300:]
+                except Exception:
+                    pass
+                raise NdtBoxError("UNKNOWN_ERROR",
+                                  f"桥内 flash 未返回 JSON 结果 (exit={proc.returncode})", err or None)
+            try:
+                body = json.loads(lines[-1])
+            except ValueError as exc:
+                raise NdtBoxError("UNKNOWN_ERROR", f"桥内 flash 结果解析失败: {exc}",
+                                  lines[-1][:200]) from exc
+            if not body.get("ok"):
+                cls = body.get("error_class") or "UNKNOWN_ERROR"
+                msg = str(body.get("error") or "桥内 flash 失败")
+                detail = body.get("detail")
+                extra: dict = {"engine": "bridge"}
+                m = re.search(r"@0x([0-9A-Fa-f]{4})", msg)
+                if m:
+                    extra["first_mismatch_offset"] = int(m.group(1), 16)
+                mm = re.search(r"expect=([0-9A-Fa-f]*) got=([0-9A-Fa-f]*)", str(detail or ""))
+                if mm:
+                    extra["first_mismatch_expect"] = mm.group(1).upper()
+                    extra["first_mismatch_got"] = mm.group(2).upper()
+                raise NdtBoxError(cls, msg, detail, extra)
+            data = body.get("data") or {}
+            data["elapsed_ms"] = elapsed_ms
+            return data
+        finally:
+            try:
+                if proc.poll() is None:
+                    proc.kill()
+            except Exception:
+                pass
+
+    def _flash_exec_bridge(self, plan: dict) -> dict:
+        """桥内单体 flash 引擎 (0.7.2 起为默认): 单进程内 USBIOX(0) 与 USB2IO(1) 句柄同持,
+
+        帧经 stdin 一次性传入、全程连续无逐笔管道往返 —— 即原厂 GUI 的进程模型, 也是
+        现场 (2026-09-11 F72) 6/6 verify pass 的那条路径。校验失败 (桥报
+        TARGET_MISMATCH "烧录校验失败") 时按 rewrite_times 整片重跑, 其余错误直接上抛。
+        """
+        import time
+        rewrite_times = max(0, int(plan.get("rewrite_times", _REWRITE_TIMES)))
+        t_all = time.monotonic()
+        attempts_detail: list = []
+        for attempt in range(rewrite_times + 1):
+            try:
+                data = self._bridge_flash_once(plan)
+            except NdtBoxError as exc:
+                attempts_detail.append({
+                    "attempt": attempt + 1, "ok": False, "error_class": exc.error_class,
+                    "first_mismatch_offset": exc.extra.get("first_mismatch_offset"),
+                    "first_mismatch_expect": exc.extra.get("first_mismatch_expect"),
+                    "first_mismatch_got": exc.extra.get("first_mismatch_got")})
+                if (exc.error_class == "TARGET_MISMATCH" and "校验失败" in exc.message
+                        and attempt < rewrite_times):
+                    continue   # 整片重写 (桥内每次都是完整擦写)
+                raise NdtBoxError(
+                    exc.error_class, exc.message, exc.detail,
+                    {**exc.extra, "engine": "bridge", "attempts": attempt + 1,
+                     "attempts_detail": attempts_detail,
+                     "stage_timings": {"total_ms": round((time.monotonic() - t_all) * 1000)}})
+            attempts_detail.append({"attempt": attempt + 1, "ok": True,
+                                    "elapsed_ms": data.get("elapsed_ms"),
+                                    "verify": data.get("verify"),
+                                    "pages_written": data.get("pages_written")})
+            total_ms = round((time.monotonic() - t_all) * 1000)
+            return {
+                "verify": data.get("verify", "pass"),
+                "pages_written": data.get("pages_written"),
+                "read_windows": data.get("read_windows"),
+                "rewrite_count": attempt,
+                "attempts": attempt + 1,
+                "attempts_detail": attempts_detail,
+                "engine": "bridge",
+                "boot_judge": "n/a (bridge engine: 桥内无探测事务, 逐窗校验为唯一判据)",
+                "boot_evidence": "not_evaluated",
+                "probe_hex": None,
+                "probe_before_hex": None,
+                "off_ms": int(plan.get("off_ms", DEFAULT_OFF_MS)),
+                "stage_timings": {"total_ms": total_ms},
+                "total_ms": total_ms,
+            }
+        raise NdtBoxError("UNKNOWN_ERROR", "flash_exec(bridge) 未产出结果", None)  # pragma: no cover
+
     def flash_exec(self, plan: dict, timeout_ms: int | None = None) -> dict:
+        """烧录引擎分派: "bridge" (默认, 桥内单体 flash) / "serve" (逐笔 Python 驱动)。
+
+        现场实证 (2026-09-11, F72, 同一批固件 + 同一台设备):
+          桥内单体 flash (帧经 stdin 一次传入)      -> 6/6 {"ok":true,"verify":"pass"}
+          逐笔 serve 路径 (每页一笔 raw 事务)        -> 100% "擦除生效但页写不落地"
+            (probe FFFFFFFF -> 00000000 说明 7 字节擦除帧到达; 99 页 write_ms 7594ms
+             ≈ 77ms/页; 校验读回全 FF)
+        两条路径的**帧完全相同** (build_page_write_frame, 命令行核对无误), 故差异在
+        进程/传输模型而非帧组装 ⇒ 默认走桥内单体, serve 引擎保留供 A/B 复现与排查。
+        """
+        engine = str(plan.get("engine", "bridge") or "bridge").lower()
+        if engine == "bridge":
+            return self._flash_exec_bridge(plan)
+        if engine == "serve":
+            return self._flash_exec_serve(plan)
+        raise NdtBoxError("CONFIG_ERROR", "flash engine 非法 (bridge/serve)", engine)
+
+    def _flash_exec_serve(self, plan: dict, timeout_ms: int | None = None) -> dict:
         """Python 驱动整条 UpdateFW 序列 (0.4.0 serve 化): usb2io 断电复位进 boot +
         擦除 -> 页写 -> 回读校验 -> 完成魔数, 全部 I2C 事务经 serve 会话 (同进程同
         会话连续, 复刻原厂 GUI 进程模型)。校验 (逐窗 vs expect_hex) 在本模块完成,
-        失败 Fail-Closed 抛 TARGET_MISMATCH (信封带 stage_timings/probe_hex/first_mismatch_*)。
+        并是 burn 成功与否的**权威判据**; 失败 Fail-Closed 抛 TARGET_MISMATCH
+        (信封带 stage_timings/probe_*/boot_evidence/first_mismatch_*)。
         校验不一致时按 rewrite_times 整片重写 (对齐 ChipSea.cs REWRITE_TIMES)。
 
         plan: {"off_ms":500,"erase_ms":2000,"page_gap_ms":30,"read_gap_ms":10,
-               "rewrite_times":3,
+               "rewrite_times":3,"boot_judge":"diff",
                "writes":["<2B 地址+128B 数据帧 hex>",...],
                "windows":[{"off":0,"expect_hex":"<256B hex>"},...]}
 
-        boot-in 判据 (F1, 2026-09-11 F72 实战修正): 擦除魔数 AA55A55A 是 boot ROM 专属
-        命令, App 不实现就只会忽略——而"运行态固件不应答 0x0000"的旧假设不成立
-        (App 注册的静态寄存器 iic_test @0x00 会正常应答 25 01 18 01 02 05 00 01),
-        旧判据因此假阳, 擦除/378 页写全发给运行中的 App, 最后报误导性的 "校验失败
-        @0x0000"。故判据后移到擦除 + erase_ms 之后读 0x0000: 全 FF (或读无应答) =
-        ROM 已擦除; 读到任何非 FF 数据 = 仍在跟 App 说话 -> BOOT_NOT_ENTERED。
-        时序随之与 GUI/桥内 flash 等价: vbrt -> 100ms(boot ready) -> 擦除魔数。
+        boot 判据 (0.7.1 差分判据; 详见 classify_boot_evidence):
+        断电复位**前**读一次 0x0000 作为基线 (在关键窗口之外, 不影响"断电->擦除"间隔,
+        时序仍与 GUI/桥内 flash 等价: vbrt -> 100ms(boot ready) -> 擦除魔数), 擦除
+        + erase_ms 后再读一次, 只在"两次是同一条非平凡应答"时判 BOOT_NOT_ENTERED;
+        全 00/全 FF/任一侧无应答一律放行, 由页写后的逐窗校验兜底。boot_judge="off"
+        完全关闭该判据 (仅记录证据, 不熔断)。
         """
         import time
         off_ms = int(plan.get("off_ms", DEFAULT_OFF_MS))
@@ -641,6 +887,10 @@ class NdtBoxIo:
         page_gap = int(plan.get("page_gap_ms", PAGE_WRITE_GAP_MS))
         read_gap = int(plan.get("read_gap_ms", PAGE_READ_GAP_MS))
         rewrite_times = max(0, int(plan.get("rewrite_times", _REWRITE_TIMES)))
+        boot_judge = str(plan.get("boot_judge", "diff") or "diff").lower()
+        if boot_judge not in BOOT_JUDGE_MODES:
+            raise NdtBoxError("CONFIG_ERROR",
+                              f"boot_judge 非法 (可选 {'/'.join(BOOT_JUDGE_MODES)})", boot_judge)
         pages = plan.get("writes", [])
         windows = plan.get("windows", [])
         t_all = time.monotonic()
@@ -648,9 +898,20 @@ class NdtBoxIo:
         timings = {"power_cycle_ms": 0, "boot_probe_ms": 0, "erase_ms": 0,
                    "write_ms": 0, "verify_ms": 0}
         probe_hex: str | None = None
+        probe_before_hex: str | None = None
+        boot_evidence = "not_evaluated" if boot_judge == "off" else "inconclusive"
         rewrite_count = 0
         with self.session():
             for attempt in range(rewrite_times + 1):
+                # --- 0) 基線探测 (仅在首试判据开启时): 断电复位前采样 0x0000 ---
+                # 放在 vbrt 之前 => "断电 -> 擦除魔数" 窗口内不多任何事务 (与桥内
+                # 单体 flash/GUI 时序一致), 同时拿到"运行态固件应答长什么样"的基线。
+                if boot_judge == "diff" and attempt == 0:
+                    t_stage = time.monotonic()
+                    probe_before = self._probe_0000()
+                    if probe_before:
+                        probe_before_hex = probe_before.hex().upper()
+                    timings["boot_probe_ms"] += round((time.monotonic() - t_stage) * 1000)
                 # --- 1) 断电复位进 boot (IOoperation.VBRTOFF) ---
                 t_stage = time.monotonic()
                 self.vbrt_reset(off_ms)
@@ -668,6 +929,8 @@ class NdtBoxIo:
                             "擦除命令超时无应答 (目标未进 boot 或总线挂死)。请仅对目标板断电重启 "
                             "(勿动 BOX), 然后重新调用 fw_ndtdbg_flash", exc.detail,
                             _flash_envelope(timings, probe_hex=probe_hex,
+                                            probe_before_hex=probe_before_hex,
+                                            boot_evidence=boot_evidence,
                                             rewrite_count=rewrite_count)) from exc
                     raise NdtBoxError(
                         "BOOT_NOT_ENTERED",
@@ -677,34 +940,38 @@ class NdtBoxIo:
                         "独立看门狗芯片需要真断电)",
                         exc.detail,
                         _flash_envelope(timings, probe_hex=probe_hex,
+                                        probe_before_hex=probe_before_hex,
+                                        boot_evidence=boot_evidence,
                                         rewrite_count=rewrite_count)) from exc
                 time.sleep(erase_ms / 1000.0)
                 timings["erase_ms"] += round((time.monotonic() - t_stage) * 1000)
-                # --- 3) boot 判据 (擦除后 0x0000 全 FF = ROM 已擦除; 非 FF = 还在跟 App 说话) ---
+                # --- 3) boot 判据 (差分: 只有"魔数前后同一条非平凡应答"才熔断) ---
                 t_stage = time.monotonic()
-                probe: bytes | None = None
-                try:
-                    probe = self.raw_write_read(b"\x00\x00", 4)
-                except NdtBoxError as exc:
-                    if exc.error_class == "BUS_TIMEOUT":
-                        raise   # clock-stretch 挂死: 上抛 (信封已带断电指引)
-                    probe = None   # 无应答: ROM 在 boot 窗口内的读协议不确定, 交给后续校验兜底
+                probe = self._probe_0000()
                 timings["boot_probe_ms"] += round((time.monotonic() - t_stage) * 1000)
                 if probe:
                     probe_hex = probe.hex().upper()
-                if probe and any(b != 0xFF for b in probe):
+                if boot_judge == "diff" and attempt == 0:
+                    boot_evidence = classify_boot_evidence(
+                        bytes.fromhex(probe_before_hex) if probe_before_hex else None, probe)
+                elif boot_judge == "off":
+                    boot_evidence = "not_evaluated"
+                # 重写轮次不再判据 (基线已过期), 证据沿用首试结论
+                if boot_evidence == "app_still_answering":
                     raise NdtBoxError(
                         "BOOT_NOT_ENTERED",
-                        f"擦除后 0x0000 仍读回数据 ({probe_hex}): 目标未进入 boot ROM —— "
-                        "擦除魔数被忽略, 说明当前应答的是目标固件本身 (它在该地址注册了会应答本"
-                        "工具读协议的寄存器, 实测 iic_test[8] @0x00 = 25 01 18 01 02 05 00 01)。"
+                        f"擦除魔数前后 0x0000 读回完全相同 ({probe_hex}): 擦除被忽略 ⇒ 目标未进入 "
+                        "boot ROM (该命令只有 boot ROM 执行, 同一条应答说明应答者仍是运行态固件)。"
                         "请仅对目标板断电重启 (勿动 BOX) 后重试; 若反复出现: ①确认 off_ms 足以构成"
                         "真 POR (默认 500ms, 独立看门狗芯片只有上电/掉电/复位脚能清零); ②检查 "
                         "usb2io IO10 供电复位接线; ③确认烧录的是本芯片 boot ROM 支持的协议; "
                         "④若目标固件由你 (agent) 改动过, 先确认它确实使能了 I2C 从机 (从机未 init "
-                        "或提前 return 时该地址不应答, 现象会变成读回全 FF, 与掉电不可区分)",
+                        "或提前 return 时该地址不应答, 现象会变成读回全 FF, 与掉电不可区分)。"
+                        "如仍要强制烧录: lab.yaml ndtdbg.flash.boot_judge: off / CLI --boot-judge off",
                         None,
                         _flash_envelope(timings, probe_hex=probe_hex,
+                                        probe_before_hex=probe_before_hex,
+                                        boot_evidence=boot_evidence,
                                         pages_written=0, rewrite_count=rewrite_count))
                 # --- 4) 逐页写 (WriteFw) ---
                 t_stage = time.monotonic()
@@ -739,11 +1006,17 @@ class NdtBoxIo:
                     if attempt < rewrite_times:
                         rewrite_count += 1   # 整片重写 (ChipSea.cs REWRITE_TIMES 语义)
                         continue
+                    hint = ("校验是烧录成功与否的权威判据 (非探测启发式): 若 probe 前后一致且为"
+                            "全 00/全 FF, 说明本次未进 boot 与'擦除生效'无法区分——请检查目标是否"
+                            "真的断电复位 (off_ms/IO10 接线)、以及目标固件是否使能了 I2C 从机; "
+                            "必要时可 --boot-judge off 关闭探测判据 (不改变校验)")
                     raise NdtBoxError(
                         "TARGET_MISMATCH",
                         f"烧录校验失败 @0x{mismatch['offset']:04X} (整片重写 {rewrite_count} 次后仍不一致)",
-                        f"expect={mismatch['expect']} got={mismatch['got']}",
+                        f"expect={mismatch['expect']} got={mismatch['got']}; {hint}",
                         _flash_envelope(timings, probe_hex=probe_hex,
+                                        probe_before_hex=probe_before_hex,
+                                        boot_evidence=boot_evidence,
                                         pages_written=len(pages),
                                         pages_written_total=len(pages) * (rewrite_count + 1),
                                         rewrite_count=rewrite_count,
@@ -759,7 +1032,9 @@ class NdtBoxIo:
                 timings["total_ms"] = round((time.monotonic() - t_all) * 1000)
                 out = {"verify": "pass", "pages_written": len(pages),
                        "read_windows": len(windows), "rewrite_count": rewrite_count,
-                       "attempts": rewrite_count + 1, "probe_hex": probe_hex,
+                       "attempts": rewrite_count + 1,
+                       "probe_hex": probe_hex, "probe_before_hex": probe_before_hex,
+                       "boot_evidence": boot_evidence, "boot_judge": boot_judge,
                        "off_ms": off_ms, "stage_timings": timings}
                 # 兼容 0.6.x 的扁平键 (P3 分阶段耗时): 由 stage_timings 派生, 单一来源
                 out.update({"reset_ms": timings["power_cycle_ms"],
@@ -1118,21 +1393,23 @@ class ChipSeaFxx:
 
     def flash_bin(self, file_path: str, erase_ms: int = 2000,
                   off_ms: int | None = None, rewrite_times: int | None = None,
+                  boot_judge: str | None = None, engine: str | None = None,
                   progress=None) -> dict:
         """经 NdtBox IIC 烧录 .bin/.nfw 固件到芯海 Fxx (UpdateFW 语义)。
 
         时序逐行对齐 ChipSea.cs UpdateFW, 进程模型对齐原厂 STDataCollection GUI:
-          VBRTOFF(off_ms) 断电复位进 boot -> 100ms -> 擦除魔数 -> erase_ms ->
-          擦除后 0x0000 判据 (F1) -> 逐 128B 页写(30ms) -> 200ms ->
-          逐 256B 窗回读校验(10ms) -> 不一致整片重写 (<= rewrite_times) ->
-          完成魔数 "PASs" -> VBRTOFF(off_ms) 复位加载。
+          [判据基线探测 0x0000 (在窗口之外)] -> VBRTOFF(off_ms) 断电复位进 boot
+          -> 100ms -> 擦除魔数 -> erase_ms -> 差分 boot 判据 ->
+          逐 128B 页写(30ms) -> 200ms -> 逐 256B 窗回读校验(10ms, 权威判据)
+          -> 不一致整片重写 (<= rewrite_times) -> 完成魔数 "PASs" -> VBRTOFF 复位加载。
         全程经同一 serve 会话连续执行 (同进程同 USB 会话), ~15s 量级。
         帧组装在本层 (可单测); 校验失败 Fail-Closed 抛 NdtBoxError, 信封带
-        stage_timings/probe_hex/first_mismatch_* (P1-2)。
+        stage_timings/probe_before_hex/probe_hex/boot_evidence/first_mismatch_* (P1-2)。
 
         off_ms 默认 DEFAULT_OFF_MS=500 (独立看门狗芯片需真 POR); rewrite_times
-        默认 _REWRITE_TIMES=3 (对齐 ChipSea.cs)。progress(phase, done, total) 在
-        verify 阶段末回调。
+        默认 _REWRITE_TIMES=3 (对齐 ChipSea.cs); boot_judge 默认 "diff" (差分判据,
+        只在有正面证据表明应答者仍是运行态固件时熔断; "off" = 完全关闭, 仅记录证据)。
+        progress(phase, done, total) 在 verify 阶段末回调。
         """
         import time
         fw_type, fw = load_firmware(file_path)
@@ -1145,6 +1422,8 @@ class ChipSeaFxx:
             "page_gap_ms": PAGE_WRITE_GAP_MS,
             "read_gap_ms": PAGE_READ_GAP_MS,
             "rewrite_times": _REWRITE_TIMES if rewrite_times is None else max(0, int(rewrite_times)),
+            "boot_judge": str(boot_judge or "diff").lower(),
+            "engine": str(engine or "bridge").lower(),
             "writes": [build_page_write_frame(off, fw[off:off + FLASH_WRITE_PAGE]).hex()
                        for off in pages],
             "windows": [{"off": off, "expect_hex": expected_read_window(fw, off).hex()}
@@ -1162,8 +1441,14 @@ class ChipSeaFxx:
             "erase_ms": int(erase_ms),
             "off_ms": plan["off_ms"],
             "rewrite_times": plan["rewrite_times"],
+            "engine": res.get("engine", plan["engine"]),
+            "boot_judge": res.get("boot_judge", plan["boot_judge"]),
+            "boot_evidence": res.get("boot_evidence"),
+            "probe_hex": res.get("probe_hex"),
+            "probe_before_hex": res.get("probe_before_hex"),
             "rewrite_count": res.get("rewrite_count", 0),
             "attempts": res.get("attempts", 1),
+            "attempts_detail": res.get("attempts_detail"),
             "stage_timings": res.get("stage_timings"),
             "verify": res.get("verify", "pass"),
             "duration_ms": int((time.monotonic() - started) * 1000),

{firmwareloop-0.7.0 → firmwareloop-0.7.2}/tools/lib/serial_assistant.py

@@ -994,6 +994,49 @@ class SerialSession:
         return out
 
 
+_PORT_HOG_HINTS = ("stdatacollection", "ndtdebug", "ndt debug", "serialassistant", "sscom",
+                   "comassistant", "putty", "xshell", "securecrt", "minicom", "logic", "saleae")
+
+
+def suspected_port_holders(session_pid: int | None = None) -> list[dict]:
+    """列出可能占着串口的本机进程 (tasklist 扫描, best-effort; 失败返回空列表)。
+
+    Windows 没有便宜的"谁持有 COMx"API, 但现场 90% 的 PermissionError(13) 都是
+    NDT Debug Tool GUI (STDataCollection.exe) 或残留的 fwloop serve 会话 —— 直接给
+    出嫌疑名单比只报一句 PermissionError 更有用。session_pid 用于把"本会话 serve"
+    与"其它 python (很可能是 MCP server, 勿盲杀)"区分开。
+    """
+    out: list[dict] = []
+    if os.name != "nt":
+        return out
+    try:
+        res = subprocess.run(["tasklist", "/FO", "CSV", "/NH"], capture_output=True,
+                             text=True, timeout=15, errors="replace")
+    except Exception:  # noqa: BLE001
+        return out
+    self_pid = os.getpid()
+    for line in (res.stdout or "").splitlines():
+        cols = [c.strip().strip('"') for c in line.split('","')]
+        if len(cols) < 2:
+            continue
+        name, pid_s = cols[0], cols[1]
+        try:
+            pid = int(pid_s)
+        except ValueError:
+            continue
+        low = name.lower()
+        if any(k in low for k in _PORT_HOG_HINTS):
+            out.append({"name": name, "pid": pid,
+                        "why": "GUI/上位机软件可能独占串口 (关闭后再重试)"})
+        elif low.startswith("python") and pid not in (self_pid, session_pid):
+            out.append({"name": name, "pid": pid,
+                        "why": "python 进程 (可能是残留 serve 会话; 若为 MCP server 请勿终止)"})
+    if session_pid:
+        out = [h for h in out if h["pid"] != session_pid]
+        out.append({"name": "(本会话 serve)", "pid": session_pid, "why": "正常: fw_serial_close 会回收"})
+    return out
+
+
 def pid_alive(pid: int | None) -> bool:
     """进程存活探测。
 

{firmwareloop-0.7.0 → firmwareloop-0.7.2}/tools/ndtdbg_cli.py

@@ -249,9 +249,16 @@ def cmd_status(io: NdtBoxIo) -> None:
         # P2-1 分层判据表: 把"全 FF/无应答"的几种成因摊开, 避免一句 hint 把人带偏
         data["diagnosis_table"] = [
             {"symptom": "能读到任一已知寄存器", "likely": "从机在跑, 链路正常 (判活以此为准)"},
-            {"symptom": "读回全 FF/FE、无异常", "likely": "从机未使能 / 目标掉电 / 从机地址不符"},
+            {"symptom": "读回全 FF/FE、无异常",
+             "likely": "①目标固件未使能 I2C 从机 (最常见, 与掉电现象一致) ②目标掉电 ③从机地址不符"},
             {"symptom": "TARGET_MISMATCH: IIC 事务无应答",
              "likely": "地址未被 ACK (外设未使能/复位中/芯片未上电)"},
+            {"symptom": "只有写事务 NACK, 读事务正常",
+             "likely": "不是从机死: 该寄存器不可写/写保护, 或目标固件未实现该写寄存器 "
+                       "(此时应回读邻近寄存器确认链路仍活)"},
+            {"symptom": "原本可读, 新增静态寄存器地址后整机读不到",
+             "likely": "新增地址破坏了从机寄存器表约定 (必须按 addr 升序且不与擦除魔数 0x0000 "
+                       "冲突) ⇒ 建议优先复用已有寄存器的空闲字, 避免新增地址"},
             {"symptom": "BUS_TIMEOUT", "likely": "时钟拉伸、关中断死循环 (fault handler 自旋饿死 I2C 中断)"},
         ]
     ok("status", data, log="Open + ReadFwVersion(0x10) + ReadModuleConnect(0x29)")
@@ -288,9 +295,15 @@ def cmd_read_reg(io: NdtBoxIo, reg: int, length: int, retry: int = 0) -> None:
             "io_ms": round((time.monotonic() - t0) * 1000, 1),
             "retries": attempts - 1}
     if data and all(b in (0xFF, 0xFE) for b in data):
-        # 总线无应答时上拉/悬空读回默认电平, 不能当作真实寄存器值误导调用方
-        body["warning"] = ("读回全部 0xFF/0xFE: 疑似 IIC 目标无应答 (总线悬空默认电平), "
-                           "请检查接线/上拉/供电/从机地址")
+        # 总线无应答时上拉/悬空读回默认电平, 不能当作真实寄存器值误导调用方。
+        # P2-1: 第一候选是"目标固件没使能从机"(现象与掉电完全一样), 而不是硬件掉了
+        body["warning"] = ("读回全部 0xFF/0xFE: 疑似 IIC 目标无应答。第一候选是【目标固件"
+                           "根本没使能 I2C 从机】(从机表初始化提前 return / 未注册), 现象与掉电"
+                           "完全一样; 其次才是掉电/接线/上拉/从机地址。可参考 fw_ndtdbg_status "
+                           "的 diagnosis_table 逐条排除")
+        body["candidates"] = ["目标固件未使能 I2C 从机 (最常见, 现象与掉电一致)",
+                              "目标掉电 / 复位中", "接线/上拉/供电异常",
+                              "从机地址不符 (lab.yaml ndtdbg.slave_addr)"]
     ok("read-reg", body, log=f"ReadReg(0x{reg:02X}, {length})")
 
 
@@ -504,7 +517,8 @@ def cmd_stream(io: NdtBoxIo, config: dict, specs: list, interval_ms, duration_s:
 
 
 def cmd_flash_bin(io: NdtBoxIo, config: dict, file_path: str, erase_ms: int, confirm: bool,
-                  off_ms: int | None = None, rewrite_times: int | None = None) -> None:
+                  off_ms: int | None = None, rewrite_times: int | None = None,
+                  boot_judge: str | None = None, engine: str | None = None) -> None:
     # 烧录 = 整片擦除 + 页写, 破坏性高于 write-reg, 同款双闸门
     ndt_cfg = config.get("ndtdbg") or {}
     allowed = ndt_cfg.get("write_allowed", False)
@@ -516,22 +530,30 @@ def cmd_flash_bin(io: NdtBoxIo, config: dict, file_path: str, erase_ms: int, con
                      f"生效配置: {effective_config_desc()}"))
     # P1-1: off_ms 可配置 (CLI --off-ms > lab.yaml ndtdbg.flash.off_ms > 内置 500ms)。
     # 独立看门狗芯片 (如 CSA37F72 IWDG_S) 只有真 POR 能清零, 200ms 可能只是深度掉压。
+    flash_cfg = ndt_cfg.get("flash") or {}
     if off_ms is None:
-        flash_cfg = ndt_cfg.get("flash") or {}
         off_ms = flash_cfg.get("off_ms")
+    # 0.7.1: boot 判据可整体关闭 (差分判据仍是启发式; 现场遇到与本 ROM 行为不符的
+    # 目标时, 用 off 让页写后的逐窗校验做唯一判据 —— 即桥内单体 flash 的语义)
+    if boot_judge is None:
+        boot_judge = flash_cfg.get("boot_judge")
+    # 0.7.2: 烧录引擎 (bridge 默认 = 桥内单体 flash; serve = 逐笔 Python 驱动, 供 A/B 复现)
+    if engine is None:
+        engine = flash_cfg.get("engine")
 
     def progress(phase: str, done: int, total: int) -> None:
         print(f"[flash-bin] {phase} {done}/{total}", file=sys.stderr, flush=True)
 
     result = ChipSeaFxx(io).flash_bin(file_path, erase_ms=erase_ms, off_ms=off_ms,
-                                      rewrite_times=rewrite_times, progress=progress)
+                                      rewrite_times=rewrite_times, boot_judge=boot_judge,
+                                      engine=engine, progress=progress)
     result["authorization"] = {"write_allowed": True,
                                "granted_by": write_allowed_source() or "(default false)",
                                "chain": list(_CONFIG_FILES)}
     ok("flash-bin", result,
        log=f"UpdateFW({file_path}): {result['fw_len']}B, {result['pages_written']} pages, "
-           f"off_ms={result.get('off_ms')}, rewrite={result.get('rewrite_count', 0)}, "
-           f"verify={result['verify']}")
+           f"engine={result.get('engine')}, off_ms={result.get('off_ms')}, "
+           f"rewrite={result.get('rewrite_count', 0)}, verify={result['verify']}")
 
 
 # --------------------------------------------------------------------------- main
@@ -582,6 +604,13 @@ def build_parser() -> argparse.ArgumentParser:
                         "独立看门狗芯片需要真 POR)")
     f.add_argument("--rewrite-times", type=int, default=None,
                    help="校验不一致时整片重写次数上限 (默认对齐 ChipSea.cs 的 3; 0=不重写)")
+    f.add_argument("--boot-judge", choices=["diff", "off"], default=None,
+                   help="boot 判据 (默认 diff: 只有'擦除魔数前后同一条非平凡应答'才熔断; "
+                        "off: 完全关闭探测判据, 仅记录证据, 由逐窗校验做唯一判据); "
+                        "仅 serve 引擎适用")
+    f.add_argument("--flash-engine", choices=["bridge", "serve"], default=None,
+                   help="烧录引擎 (默认 bridge = 桥内单体 flash: 单进程、帧经 stdin 一次传入、"
+                        "现场 6/6 verify pass; serve = 逐笔 raw 事务的 Python 驱动, 供 A/B 复现)")
 
     st = sub.add_parser("stream", parents=[common],
                         help="高速连续采集寄存器组到 CSV (单会话长驻, 只读)")
@@ -641,7 +670,8 @@ def main(argv=None) -> None:
             cmd_poll(io, args.duration_ms, args.interval_ms, args.max_frames, args.full)
         elif args.cmd == "flash-bin":
             cmd_flash_bin(io, config, args.file, args.erase_ms, args.confirm,
-                          off_ms=args.off_ms, rewrite_times=args.rewrite_times)
+                          off_ms=args.off_ms, rewrite_times=args.rewrite_times,
+                          boot_judge=args.boot_judge, engine=args.flash_engine)
         elif args.cmd == "stream":
             specs = [parse_reg_spec(s) for s in args.regs]
             cmd_stream(io, config, specs, args.interval_ms, args.duration_s,

{firmwareloop-0.7.0 → firmwareloop-0.7.2}/tools/serial_cli.py

@@ -36,6 +36,7 @@ from lib.serial_assistant import (  # noqa: E402
     parse_hex,
     probe_session,
     to_hex,
+    suspected_port_holders,
     wait_pid_exit,
 )
 
@@ -122,6 +123,8 @@ def cmd_status(_args: argparse.Namespace) -> None:
                     "started_at": stats.get("started_at")},
         "conclusion": f"会话存活 (port={sess.get('port') or stats.get('port')}, "
                       f"opened={alive})" if alive else "serve 进程存活但串口未打开",
+        # P1-4: 串口被谁占着 —— 直接给嫌疑名单 (GUI/上位机 + 残留 python serve)
+        "suspected_holders": suspected_port_holders(sess.get("pid")),
     })
 
 
@@ -149,6 +152,7 @@ def cmd_open(args: argparse.Namespace) -> None:
                 "holder_hint",
                 "端口可能被 GUI 上位机占用: NDT Debug Tool (STDataCollection.exe) 打开时会同时占用 "
                 "Box 串口与 USB-IIC 通道; 请关闭占用方后重试, 残留会话可用 fw_serial_close 清理")
+            extra.setdefault("suspected_holders", suspected_port_holders())
         fail(exc.error_class, exc.detail, extra=extra)
     data = {k: info.get(k) for k in
             ("port", "baud", "simulated", "log_path", "reused", "pid", "started_at")}
@@ -212,7 +216,7 @@ def cmd_send(args: argparse.Namespace) -> None:
                     time.sleep(delay / 1000.0)
         stats = session.stats()
     except SerialAssistantError as exc:
-        fail(exc.error_class, exc.detail, extra=exc.extra)
+        fail(exc.error_class, exc.detail, extra=_port_error_extra(exc))
     ok("send", {"frames_sent": sent, "frames_defined": len(frames),
                 "elapsed_ms": round((time.monotonic() - t0) * 1000, 2),
                 "tx_bytes": stats.get("tx_bytes"), "rx_bytes": stats.get("rx_bytes")},
@@ -229,7 +233,7 @@ def cmd_read(args: argparse.Namespace) -> None:
         else:
             result = session.read(max_bytes=RX_BUFFER_LIMIT if args.drain else args.max_bytes)
     except SerialAssistantError as exc:
-        fail(exc.error_class, exc.detail, extra=exc.extra)
+        fail(exc.error_class, exc.detail, extra=_port_error_extra(exc))
 
     if args.drain and not args.expect:
         # P2-3 (0909 提案): 单次排空整个缓冲; 大 payload 落盘而非进 MCP 响应,
@@ -321,7 +325,7 @@ def cmd_parse(args: argparse.Namespace) -> None:
         frames = parser.feed(data_bytes)
         frames += parser.finalize()
     except SerialAssistantError as exc:
-        fail(exc.error_class, exc.detail, extra=exc.extra)
+        fail(exc.error_class, exc.detail, extra=_port_error_extra(exc))
     valid_n = sum(1 for f in frames if f["valid"])
     ok("parse", {"source": src, "frames_n": len(frames), "valid_n": valid_n,
                  "invalid_n": len(frames) - valid_n, "bytes": len(data_bytes),
@@ -329,6 +333,14 @@ def cmd_parse(args: argparse.Namespace) -> None:
        log=f"SerialParse({src}): {len(frames)} frames, {valid_n} valid")
 
 
+def _port_error_extra(exc: SerialAssistantError) -> dict:
+    """串口类错误的统一附加信息: 嫌疑占用进程名单 (P1-4)。"""
+    extra = dict(exc.extra)
+    if exc.error_class in ("SERIAL_PORT_ERROR", "UART_BUSY"):
+        extra.setdefault("suspected_holders", suspected_port_holders())
+    return extra
+
+
 def _run_power_cycle(off_ms: int) -> dict:
     """P2-4: 触发一次 NdtBox 断电复位 (复用 ndtdbg_cli power-cycle, 同 lab.yaml 解析链)。"""
     cli = os.path.join(os.path.dirname(os.path.abspath(__file__)), "ndtdbg_cli.py")
@@ -389,9 +401,15 @@ def cmd_capture(args: argparse.Namespace) -> None:
             result = box.get("r") or {}
         stats = session.stats()
     except SerialAssistantError as exc:
-        fail(exc.error_class, exc.detail, extra=exc.extra)
+        fail(exc.error_class, exc.detail, extra=_port_error_extra(exc))
     payload = {**result, "tx_bytes": stats.get("tx_bytes"),
                "simulated": stats.get("simulated")}
+    if args.duration_ms >= 10000:
+        # P2: MCP stdio 循环单线程 —— 长调用会让同会话的其它调用排队, 客户端可能先超时
+        payload["blocking_notice"] = (
+            f"服务端本次阻塞 {args.duration_ms}ms: MCP stdio 是单线程的, 同一会话内其它工具"
+            "调用会排在它后面 (客户端超时往往先到)。长采集建议缩短窗口, 或用 ndtdbg stream "
+            "job 模式 (fw_ndtdbg_stream_start/status/stop) 让采集不占调用通道")
     if power_off_ms is not None:
         payload["power_cycle"] = pc_result
         if not (pc_result or {}).get("ok"):
@@ -498,7 +516,7 @@ def main() -> None:
     try:
         handler(args)
     except SerialAssistantError as exc:
-        fail(exc.error_class, exc.detail, extra=exc.extra)
+        fail(exc.error_class, exc.detail, extra=_port_error_extra(exc))
 
 
 if __name__ == "__main__":

{firmwareloop-0.7.0 → firmwareloop-0.7.2}/tools/setup-agent-mcp.ps1

@@ -1,6 +1,6 @@
 <#
 .SYNOPSIS
-    Dual-Tier MCP setup and registration helper (v0.7.0).
+    Dual-Tier MCP setup and registration helper (v0.7.2).
     Inspects installed AI coding agents (Qoder, Claude Code, Antigravity, Cursor)
     and configures global MCP / skills or prints exact registration commands.
 
@@ -242,7 +242,7 @@ if ($Json) {
     Write-FwJson ([pscustomobject]$report)
 } else {
     Write-Host "============================================================" -ForegroundColor Cyan
-    Write-Host "  FirmwareLoop Dual-Tier MCP & Agent Setup Helper (v0.7.0)" -ForegroundColor Green
+    Write-Host "  FirmwareLoop Dual-Tier MCP & Agent Setup Helper (v0.7.2)" -ForegroundColor Green
     Write-Host "============================================================" -ForegroundColor Cyan
     Write-Host ""
     Write-Host "[1] Google Antigravity / Gemini CLI:" -ForegroundColor Yellow