diff --git a/text2.txt b/text2.txt
new file mode 100644
index 0000000..e97f89c
--- /dev/null
+++ b/text2.txt
@@ -0,0 +1,274 @@
+新下一步执行计划
+
+生成时间：2026-06-09 14:20 CST
+
+本计划接替 `text.txt`。后续执行以本文件为准。
+
+项目纪律：
+
+- 数控/G-code/remap/tool/parameter/planner/kinematics/user-M 语义必须来自
+  LinuxCNC upstream 或 vendored LinuxCNC C/C++ source。
+- 本项目允许写的代码范围是：构建、source sync、runtime shim、filesystem
+  staging、OPFS、WASM/browser boundary、测试胶水、文档。
+- 不通过修改 G-code 语义、JS 解释逻辑、或 standalone `Interp::...` 实现来让
+  测试通过。
+- 需要 INI/tool table/parameter file/SUBROUTINE_PATH/USER_M_PATH/remap-NGC
+  上下文的程序，必须带上下文运行，不能脱离配置单独判断。
+- browser 不能依赖目录枚举。browser/Node 共享 staging 时，优先使用
+  `tools/source-manifest.txt` + INI 文本生成计划。
+
+当前已完成基线：
+
+- 规划 i：G-code run_step 状态输出已完成第一阶段。
+  已输出当前行号、statement_uri、进度相关 step、X/Y/Z/A/B/C/U/V/W 位置。
+  UI 已优先解析 run_step，fallback 到 canonical event。
+
+- 规划 ii：基础 G-code smoke 已固化代表集。
+  `nc_files/3D_Chips.ngc` 已按 tool-table context 运行，裸跑缺 tool 的负向边界
+  已明确。
+
+- configs/sim 代表 runtime edge 已覆盖：
+  `axis/foam` U/V axis mask、bridge-mill W/remap path、`axis/geometry` M110、
+  `external_offsets` M111 和 subroutine staging 已在 native/WASM/browser
+  representative smoke 中验证。
+
+- 文件上下文 staging 规则已抽成通用 SDK helper：
+  `planIniFileContextStaging()` 负责 generic INI-context manifest-based plan；
+  `planSimConfigStaging()` 是 `configs/sim` wrapper；
+  Node 和真实 browser smoke 已覆盖 INI、OPEN_FILE、TOOL_TABLE、PARAMETER_FILE、
+  multi-directory SUBROUTINE_PATH、USER_M_PATH、executable user-M、remap-NGC 和
+  wasmPath 输出。
+
+- 测试分层文档已补齐：
+  `docs/compatibility-validation.md` 已记录 4 层测试的入口、当前结果、
+  LinuxCNC-owned behavior、host/WASM adapter allowance 和 expected-failure
+  policy。
+
+当前验证口径：
+
+- Layer 1: `wasm-port/tests/native/verify_nc_files.sh`
+  当前基线：total 107, pass 101, expected_fail 6, unexpected_fail 0。
+
+- Layer 2: `wasm-port/tests/native/verify_sim_configs.sh`
+  当前基线：total 159, pass 151, expected_fail 8, unexpected_fail 0。
+
+- Layer 3: `wasm-port/tests/native/verify_native_probes.sh`
+  当前应通过，包含 source sync、no-standalone-semantics、native fixture
+  baseline、sim-config 和 nc_files checks。
+
+- Layer 4: `wasm-port/tests/host/verify_host_smokes.sh`
+  当前应通过，包含 Node WASM、OPFS、browser interpreter 和 browser INI panel
+  representative smoke。
+
+新执行顺序：
+
+1. 先稳定当前大批改动，不继续扩大测试面
+
+目标：
+
+- 对当前累计改动做一次完整一致性验证。
+- 确认 vendor manifest、native probes、Node/browser smoke 都仍处于可提交状态。
+- 在继续新增 upstream tests 前，先把当前批次变成一个清晰、可审查的工作集。
+
+执行：
+
+```bash
+git diff --check
+wasm-port/tools/verify_vendor_sync.sh
+wasm-port/tests/wasm/node/verify_interp_wasm.sh
+wasm-port/tests/wasm/node/verify_sim_configs_wasm.sh
+wasm-port/tests/browser/verify_interp_browser.sh
+wasm-port/tests/host/verify_host_smokes.sh
+wasm-port/tests/native/verify_native_probes.sh
+```
+
+通过条件：
+
+- `git diff --check` clean。
+- `vendor sync validation complete`。
+- `interp_wasm_node_smoke=ok`。
+- `sim_configs_wasm_node_smoke=ok`。
+- `browser_interp_smoke=ok`。
+- `host_wasm_opfs_browser_smokes=ok`。
+- native summaries 中仍为：
+  `sim-configs total 159 pass 151 expected_fail 8 unexpected_fail 0`
+  和
+  `nc_files total 107 pass 101 expected_fail 6 unexpected_fail 0`。
+
+不做：
+
+- 不新增 upstream fixture。
+- 不改 LinuxCNC vendored 文件内容。
+- 不把 expected failure 改成 pass，除非 runtime edge 已经通过 vendored source
+  路径证明。
+
+2. 整理当前大批改动的提交/审查边界
+
+目标：
+
+- 把当前累计改动按逻辑拆成可审查批次。
+- 如果不提交，也至少在文档里列出可拆分边界，方便后续 review。
+
+建议拆分边界：
+
+- Batch A: run_step 状态输出和 UI/browser/Node 断言。
+- Batch B: nc_files 代表 smoke 和 `3D_Chips.ngc` tool-table context。
+- Batch C: upstream `tests/interp/*`、`tests/ccomp/*` selected fixture 扩展。
+- Batch D: G92 parameter persistence、tool table、G10/G52/G71/G72/G76 等
+  interpreter regression coverage。
+- Batch E: generic INI-context staging helper 和 Node/browser synthetic coverage。
+- Batch F: 文档分层、source reuse map、compatibility validation、tracker 更新。
+
+执行：
+
+```bash
+git status --short
+git diff --stat
+git diff --name-only
+```
+
+输出要求：
+
+- 记录每个 batch 对应文件。
+- 标明哪些新增 `wasm-port/vendor/linuxcnc/...` 文件必须由
+  `tools/source-manifest.txt` 和 `verify_vendor_sync.sh` 覆盖。
+
+3. 收敛 configs/sim 剩余 expected failure，不改语义
+
+目标：
+
+- 继续分析 Layer 2 中 8 个 expected_fail。
+- 明确哪些只是 upstream `rs274` 缺 task/user-M/runtime context；
+  哪些已经由 Layer 3/4 runtime representative smoke 覆盖；
+  哪些仍需要新的 runtime adapter 或 blocked entry。
+
+重点对象：
+
+- `axis/foam/foam.ngc`
+  已有 U/V axis mask runtime coverage。确认 Layer 2 expected_fail 是否只属于
+  native upstream standalone context 限制。
+
+- `axis/vismach/5axis/bridgemill/5axisgui.ngc`
+  已有 bridge-mill W/remap representative coverage。确认 expected_fail 是否只
+  属于 native full sim/task/HAL boundary。
+
+- `axis/geometry/xyzc.ngc`
+  已有 M110 USER_M_PATH deterministic boundary。确认 native expected_fail 与
+  runtime coverage 对齐。
+
+- `axis/external_offsets/*.ngc`
+  已有 M111 deterministic boundary 和 `opa_demo.ngc -> circles.ngc`
+  SUBROUTINE_PATH staging。确认剩余 expected_fail 的具体原因。
+
+- `incremental_repetition_g533.ngc`
+  保留 upstream demo expected failure。禁止通过修改 G-code 语义或 runner
+  语义让它 pass。
+
+执行：
+
+```bash
+wasm-port/tests/native/verify_sim_configs.sh
+cat wasm-port/build/native/sim-configs/summary.tsv
+```
+
+产出：
+
+- 更新 `docs/compatibility-validation.md` 或
+  `docs/linuxcnc-test-porting-tracker.md`，逐条记录 8 个 expected_fail 的当前
+  层级归因。
+- 如果某项已由 Layer 3/4 覆盖，写明对应验证命令和 smoke assertion。
+- 如果某项未覆盖，加入明确 blocked dependency 或下一步 runtime boundary。
+
+4. 将 generic INI-context staging helper 用到更多手写 staging 点
+
+目标：
+
+- 减少 Node/browser 测试中手写 `TOOL_TABLE`、`PARAMETER_FILE`、
+  `SUBROUTINE_PATH`、`USER_M_PATH` 和 remap files 的重复。
+- 只迁移“已经 vendored 且 manifest 完整”的测试，不扩大功能面。
+
+候选：
+
+- `tests/wasm/node/verify_interp_wasm.mjs` 中带 `test.ini`、`test.tbl`、
+  `startup.var`、`subs/*.ngc` 的 upstream regression staging。
+- `tests/browser/interp_smoke.html` 中与 Node 同构的 upstream regression
+  staging。
+- 不急于迁移 five-axis 专用 staging，除非能保持 `executionMode:
+  "fiveAxisRemap"` 现有路径清晰。
+
+执行原则：
+
+- 先抽小 helper：`loadPlannedVendorFiles(plan)` 或测试局部 helper。
+- 保持 `planIniFileContextStaging()` 只返回 plan，不读文件、不 fetch。
+- Node 侧从 filesystem 读 `vendor/linuxcnc/${sourceRel}`。
+- Browser 侧 fetch `../../vendor/linuxcnc/${sourceRel}`。
+- 每次迁移后跑：
+
+```bash
+wasm-port/tests/wasm/node/verify_interp_wasm.sh
+wasm-port/tests/browser/verify_interp_browser.sh
+wasm-port/tests/host/verify_host_smokes.sh
+```
+
+5. 继续 upstream `tests/interp/*` intake，但必须小批量
+
+前置条件：
+
+- 第 1 步完整验证通过。
+- 第 2 步当前工作集边界清楚。
+- 第 3 步 expected failure 归因没有新疑点。
+
+候选优先级：
+
+- 纯 interpreter file execution。
+- 不需要 Python remap。
+- 不需要 full task/motion/HAL process。
+- 需要 tool table/parameter/subroutine context 的测试，必须通过 INI-context
+  staging 运行。
+- 有 upstream expected output 或可稳定断言 canonical event/error text。
+
+候选方向：
+
+- `tests/interp/oword-unwind`
+  可能适合 continue-on-error runner；先 native probe 验证，再 Node/browser。
+
+- `tests/interp/g6164`
+  先确认是否纯 interpreter、是否需要额外 machine/runtime context。
+
+- `tests/interp/compile`
+  先判断它是 compile/source test 还是 runtime interpreter test；不要误归类。
+
+- `tests/interp/mdi-*`、`oword-mdi-*`
+  默认视为 MDI/UI/full-process 候选，先加入 blocked table，除非能证明存在
+  NGC-only subpath。
+
+- `tests/interp/pymove`、`python-self`
+  默认 blocked：Python O-word/remap boundary 未实现。
+
+每个 intake 必须执行 checklist：
+
+- 记录 upstream path。
+- byte-for-byte vendor 原始文件。
+- 更新 `tools/source-manifest.txt` 和 vendor sync。
+- 确认 LinuxCNC source ownership。
+- 先 native harness/probe，再 Node WASM，再 browser。
+- 更新 `docs/source-reuse-map.md`、
+  `docs/compatibility-validation.md`、
+  `docs/linuxcnc-test-porting-tracker.md`。
+- 如 blocked，加入 blocked-test table 并写清 dependency。
+
+6. 不做事项
+
+- 不继续扩大 `configs/sim` 全量 WASM/browser 执行面，除非某个 expected failure
+  已经有明确 runtime boundary 价值。
+- 不引入 JS G-code parser 或 JS remap/tool/parameter semantics。
+- 不编辑 `linuxcnc/` upstream 工作树。
+- 不修改 `wasm-port/vendor/linuxcnc/` vendored 文件内容；只能 byte-for-byte copy
+  upstream 文件。
+- 不绕过 `tools/verify_no_standalone_cnc_semantics.sh`。
+
+推荐下一次立即执行：
+
+1. 运行第 1 步完整一致性验证。
+2. 如果通过，执行第 2 步，整理当前工作集 batch 边界。
+3. 然后再进入第 3 步，逐条归因 configs/sim 8 个 expected_fail。
diff --git a/text3.txt b/text3.txt
new file mode 100644
index 0000000..ec781ef
--- /dev/null
+++ b/text3.txt
@@ -0,0 +1,386 @@
+configs/sim 全面测试下一步实施计划
+
+生成时间：2026-06-09 15:00 CST
+
+本计划接替 `text2.txt`。后续 `configs/sim` 相关工作以本文件为准。
+
+目标定义：
+
+- 这里的“全部完成全面测试”不等于“让 `linuxcnc/configs/sim` 下所有 `.ngc`
+  在 standalone `bin/rs274` 下全部 PASS”。
+- 正确目标是：
+  1. 对 `configs/sim` 下所有 `.ngc` 建立完整 inventory；
+  2. 每个文件都被归入明确类别；
+  3. 每个类别都有正确入口点和验证层；
+  4. 能在 standalone native/WASM/browser 中运行的，必须补齐覆盖；
+  5. 不能在 standalone 路径中真实复现的，必须记录为 blocked，并写清依赖；
+  6. 不通过修改 G-code 语义、JS 解释逻辑、或 project-owned standalone
+     interpreter 语义让测试“看起来通过”。
+
+项目纪律：
+
+- CNC 语义来源只能是 LinuxCNC upstream 或 vendored LinuxCNC source。
+- `configs/sim` 程序必须在完整上下文下判断：INI、tool table、parameter file、
+  `SUBROUTINE_PATH`、`USER_M_PATH`、remap-NGC、Python remap、task/runtime
+  边界都要按 LinuxCNC 真实归属处理。
+- browser 不能依赖目录枚举；Node/browser staging 继续优先使用
+  `tools/source-manifest.txt` + INI 文本生成计划。
+- 不为了“全面测试”而把 full-process / HAL / UI / linuxcncrsh / Python binding
+  误降级为 standalone interpreter file execution。
+
+当前真实基线：
+
+- Layer 2: `wasm-port/tests/native/verify_sim_configs.sh`
+  当前基线：`total 159, pass 151, expected_fail 8, unexpected_fail 0`。
+- Layer 3: `wasm-port/tests/native/verify_native_probes.sh`
+  当前通过，已经覆盖代表性 runtime edge：
+  `axis/foam` U/V、bridge-mill W/remap、`axis/geometry` M110、
+  `axis/external_offsets` M111、`opa_demo.ngc -> circles.ngc`。
+- Layer 4:
+  `wasm-port/tests/wasm/node/verify_sim_configs_wasm.sh`、
+  `wasm-port/tests/browser/verify_interp_browser.sh`、
+  `wasm-port/tests/host/verify_host_smokes.sh`
+  当前通过，但只覆盖 representative subset，不是全量 `configs/sim`。
+
+当前已知剩余 expected failure：
+
+- `axis/foam/foam.ngc`
+  native upstream standalone `rs274` 缺 U/V axis reader，上层 runtime 已覆盖。
+- `axis/vismach/5axis/bridgemill/5axisgui.ngc`
+  native upstream standalone `rs274` 缺 W axis reader，上层 runtime 已覆盖。
+- `axis/geometry/xyzc.ngc`
+  native upstream standalone `rs274` 缺 `USER_M_PATH` M110 注册，上层 runtime 已覆盖。
+- `axis/external_offsets/dyn_demo.ngc`
+- `axis/external_offsets/eoffsets.ngc`
+- `axis/external_offsets/jwp_z.ngc`
+- `axis/external_offsets/opa_demo.ngc`
+  native upstream standalone `rs274` 缺 `USER_M_PATH` M111 注册，上层 runtime 已覆盖；
+  其中 `opa_demo.ngc` 还依赖 `SUBROUTINE_PATH` `circles.ngc`，上层 runtime 已覆盖。
+- `axis/vismach/5axis/table-rotary_spindle-rotary-nutating/demos/incremental_repetition_g533.ngc`
+  保持 upstream demo expected failure；禁止通过修改 G-code 或 JS 解释逻辑让它 PASS。
+
+全面测试还缺哪些工作：
+
+1. 完整建立 `configs/sim` 程序级覆盖矩阵
+
+当前问题：
+
+- 我们有 harness summary，但还没有一份“每个 `.ngc` 的归属矩阵”：
+  哪些是 `main`、哪些是 `macro_load`、哪些是 `remap_subroutine`、
+  哪些只是 LinuxCNC native baseline、哪些已经进入 Layer 3、哪些已经进入 Layer 4、
+  哪些仍 blocked。
+
+需要产出：
+
+- 一份 tracked matrix，建议新增：
+
+```text
+wasm-port/docs/sim-configs-coverage-matrix.md
+```
+
+矩阵至少包含列：
+
+- `path`
+- `class`
+- `native_rs274_status`
+- `expected_failure_reason`
+- `layer3_runtime_probe`
+- `layer4_node`
+- `layer4_browser`
+- `blocked_dependency`
+- `notes`
+
+通过条件：
+
+- `wasm-port/build/native/sim-configs/summary.tsv` 中所有 159 条记录都能映射到 matrix。
+- matrix 中不能有“未分类”行。
+
+2. 明确“全部”里的 blocked 边界，而不是继续误扩面
+
+当前问题：
+
+- `configs/sim` 下面并不是所有 `.ngc` 都应该被强行推进到 browser full execution。
+- 还缺一份 `configs/sim` 专属 blocked policy，用来区分：
+  - pure interpreter / remap / INI-context 可移植程序；
+  - task/user-M/runtime edge 程序；
+  - Python remap/full-process/HAL/UI 依赖程序；
+  - demo edge / upstream malformed demo。
+
+需要明确加入 blocked 的类：
+
+- 任何本质依赖 linuxcncrsh、GUI driver、HAL process、实时 motion 状态反馈、
+  外部 userspace component、或 Python binding API 的 sim-config path。
+- `mdi-*`、UI action、或只能通过 full task process 触发的配置流。
+- 不能通过 NGC-only subpath 提纯的 Python/full-process config family。
+
+执行：
+
+- 从 `verify_sim_configs.sh` summary 和 `configs/sim` 路径结构出发，
+  逐目录补 blocked classification。
+- 先补 family-level blocked，再细化到 program-level。
+
+产出：
+
+- 更新 `docs/linuxcnc-test-porting-tracker.md` blocked table；
+- 更新 `docs/compatibility-validation.md` 的 `configs/sim` 边界说明；
+- 在新 matrix 中写出每个 blocked 程序或目录的 dependency。
+
+3. 把 representative coverage 扩展成 class coverage，而不是盲目追求全量 browser
+
+当前问题：
+
+- Layer 4 现在只覆盖 representative subset：
+  `foam`、`geometry`、`external_offsets`、bridge-mill。
+- 这还不足以支撑“全面测试完成”的说法，因为 `configs/sim` 还包含多种 machine class：
+  - plain INI/tool-table/main program；
+  - Python remap main program；
+  - remap subroutine only；
+  - five-axis switchkins / TWP / TDR / TRT；
+  - macro-only config families；
+  - on_abort / macro load / tool-change style files。
+
+实施原则：
+
+- 不是把 159 个程序都复制进 browser smoke。
+- 是每种独立 runtime class 至少补一个 native + Node + browser representative，
+  并且 class 到 program 的归因在 matrix 中完整记录。
+
+最低还要补齐的 representative class：
+
+- TWP `table-rotary_spindle-rotary-nutating`：
+  当前 native baseline 已有 14/15 passing inventory，但 Layer 4 还没有代表性 TWP
+  runtime smoke。
+- gmoccapy Python remap family：
+  native inventory 已通过，但 Layer 4 还没有任何 gmoccapy representative。
+- axis/laser Python remap family：
+  native inventory 已通过，但 Layer 4 还没有任何 laser representative。
+- generic `macro_load` family：
+  当前 Layer 4 基本聚焦 main programs，缺少“宏文件只验证 load/parse，不伪造 main”
+  的 shared assertion。
+- `on_abort` / deterministic user-action macro family：
+  当前 native inventory大量 PASS，但 Node/browser 尚未有独立 representative class。
+
+通过条件：
+
+- 每个 runtime class 在 `docs/sim-configs-coverage-matrix.md` 中都能对应至少一个
+  Layer 3/Layer 4 representative。
+- 不要求 159 个程序全部进入 browser smoke；
+  但要求每个 class 都有代表 sample，且每个非代表 sample 都有“为什么不需要单独进
+  browser”的记录。
+
+4. 补 `configs/sim` 专属全量 Node inventory runner
+
+当前问题：
+
+- Node 侧现在只有 representative smoke，没有一个“只跑能在 standalone/WASM
+  路径中合理成立的 `configs/sim` 全量 inventory”。
+
+需要新增：
+
+```text
+wasm-port/tests/wasm/node/verify_sim_configs_inventory_wasm.mjs
+wasm-port/tests/wasm/node/verify_sim_configs_inventory_wasm.sh
+```
+
+职责：
+
+- 读取 native `summary.tsv` 或同等来源；
+- 只挑选：
+  - native PASS 条目；
+  - 以及 Layer 2 expected_fail 但 Layer 3/4 已知有 runtime adapter coverage 的条目；
+- 跳过已标记 blocked 的 full-process/HAL/UI-only family；
+- 对 Node WASM 做 inventory run；
+- 输出 Node 侧 summary.tsv。
+
+重要限制：
+
+- 不把 browser 作为 first target；
+- 不新增 JS CNC 语义；
+- 不把 Python/full-process family 强行塞进 Emscripten，除非已存在 LinuxCNC-owned
+  runtime path。
+
+通过条件：
+
+- Node inventory summary 可重跑、可对比、可纳入 CI；
+- unexpected failure 为 0；
+- expected skip / blocked 有明确计数。
+
+5. 再决定 browser inventory，而不是直接上全量 browser
+
+当前问题：
+
+- browser 环境成本高，且不能依赖目录枚举。
+- 如果先做 browser 全量 inventory，会把大量问题混在 host boundary、
+  asset staging、Emscripten runtime、Playwright orchestration 里，定位价值低。
+
+实施顺序：
+
+- 先完成 Node inventory；
+- 从 Node inventory 中挑出最有价值的 browser representative 扩展；
+- browser 保持 focused class smoke，不追求一次性全量 159。
+
+可以进入 browser 扩展候选的 class：
+
+- TWP representative；
+- gmoccapy Python remap representative；
+- axis/laser representative；
+- one deterministic macro-only family；
+- one toolchange / on_abort family。
+
+通过条件：
+
+- browser 侧 class coverage 明确，不再只是 `foam/geometry/external_offsets/bridgemill`；
+- 仍然保持稳定、可复现、非目录枚举。
+
+6. 把 `verify_sim_configs.sh` 从 inventory 提升为 coverage source-of-truth
+
+当前问题：
+
+- native `summary.tsv` 已经是事实来源，但还缺少稳定的 machine-readable 统计，
+  用来支撑 docs、Node inventory 和后续 CI 对账。
+
+需要增强：
+
+- 保持 `summary.tsv` 不变；
+- 增加稳定派生 artifact，建议：
+
+```text
+wasm-port/build/native/sim-configs/class-summary.tsv
+wasm-port/build/native/sim-configs/path-matrix.tsv
+```
+
+最少字段：
+
+- `path`
+- `class`
+- `status`
+- `expected_failure`
+- `ini`
+- `tbl`
+- `runtime_family`
+- `blocked`
+
+注意：
+
+- 如果不想提交 generated artifact，就由脚本生成并由 docs 读取规则描述；
+- 但字段模型要先定下来。
+
+7. 清理 `configs/sim` 文档的“完成”定义
+
+当前问题：
+
+- 现有 `docs/sim-configs-completion-plan.md` 更多描述了“把当前大块 runtime edge
+  打通”的完成，不是“全面测试完成”的完成。
+
+需要文档调整：
+
+- 新增一节：`Definition of Done for Full configs/sim coverage`
+- 明确：
+  - inventory complete
+  - blocked table complete
+  - native source-of-truth complete
+  - Node inventory complete
+  - browser class coverage complete
+  - every expected failure justified
+  - no accidental standalone semantic ownership
+
+8. 最后再谈“还能不能把 Layer 2 的 8 个 expected_fail 变少”
+
+原则：
+
+- `foam` / `bridgemill` / `M110` / `M111` 这些 expected_fail 不是当前首要问题；
+  它们已经由 Layer 3/4 runtime path 证明。
+- 只有当能够通过 vendored LinuxCNC source path 合法地把 native strict baseline
+  改造成更贴近 runtime 的入口点时，才讨论减少 expected_fail。
+- 在那之前，不改 `verify_sim_configs.sh` 的语义口径，不把 expected_fail 硬改成 PASS。
+
+优先级排序：
+
+1. coverage matrix
+2. blocked table
+3. Node inventory
+4. browser class expansion
+5. docs done-definition
+6. 再评估 Layer 2 baseline 是否需要新入口点
+
+推荐执行顺序：
+
+1. 先建立 coverage matrix
+
+执行：
+
+```bash
+wasm-port/tests/native/verify_sim_configs.sh
+cat wasm-port/build/native/sim-configs/summary.tsv
+```
+
+产出：
+
+- 新增 `wasm-port/docs/sim-configs-coverage-matrix.md`
+- 159 条记录全部分类
+
+2. 再补 blocked table 和 class taxonomy
+
+执行：
+
+- 逐目录梳理 `linuxcnc/configs/sim`
+- 对照 `verify_sim_configs.sh` summary
+- 把 full-process/HAL/UI-only family 写进 tracker blocked table
+
+产出：
+
+- 更新 `docs/linuxcnc-test-porting-tracker.md`
+- 更新 `docs/compatibility-validation.md`
+
+3. 实施 Node inventory runner
+
+执行：
+
+```text
+wasm-port/tests/wasm/node/verify_sim_configs_inventory_wasm.mjs
+wasm-port/tests/wasm/node/verify_sim_configs_inventory_wasm.sh
+```
+
+通过条件：
+
+- Node inventory 只跑可移植条目
+- unexpected failure = 0
+
+4. 扩 browser class coverage
+
+执行：
+
+- 先补 TWP representative
+- 再补 gmoccapy representative
+- 再补 axis/laser representative
+- 最后补 macro-only / on_abort representative
+
+通过条件：
+
+- `verify_interp_browser.sh` 和 `verify_host_smokes.sh` 仍稳定通过
+- browser 不引入目录枚举
+
+5. 更新完成定义和漂移控制
+
+执行：
+
+- 更新 `docs/sim-configs-completion-plan.md`
+- 更新 `docs/compatibility-validation.md`
+- 更新 `docs/source-reuse-map.md`
+
+完成判定：
+
+- `configs/sim` 每个 `.ngc` 都有明确分类；
+- 每个类别都有合适层级的验证入口；
+- blocked dependency 清单完整；
+- Node inventory 可重跑；
+- browser class coverage 覆盖所有重要 runtime family；
+- Layer 2 的 8 个 expected_fail 都有稳定归因；
+- 没有通过 project-owned CNC 语义让测试看起来通过。
+
+不做事项：
+
+- 不把 159 个程序全部塞进 browser smoke；
+- 不把 full-process/HAL/UI/linuxcncrsh 依赖程序误降级为 standalone file execution；
+- 不修改 `linuxcnc/configs/sim` upstream 文件；
+- 不通过 JS 解释逻辑、临时字符串匹配、或 standalone `Interp::...` 新语义实现来换取 PASS。
diff --git a/text4.txt b/text4.txt
new file mode 100644
index 0000000..d380af2
--- /dev/null
+++ b/text4.txt
@@ -0,0 +1,248 @@
+HAL/UI/full-process standalone/browser boundary design and next plan
+
+Generated: 2026-06-10 CST
+
+This plan follows `text3.txt`. The `configs/sim` inventory/matrix work is now
+complete for the current definition. This file defines the next boundary before
+any previously blocked HAL/UI/full-process family is promoted into standalone,
+Node, or browser execution.
+
+Goal
+
+- Preserve LinuxCNC as the CNC semantic source of truth.
+- Make HAL/UI/full-process dependencies machine-readable before attempting
+  execution.
+- Promote only the subpaths that can run through vendored LinuxCNC source plus
+  explicit standalone runtime adapters.
+- Keep task, HAL process launch, UI driver process launch, linuxcncrsh, Python
+  remap, and tool-database process behavior blocked until each has a deliberate
+  LinuxCNC-owned runtime boundary.
+
+Non-goals
+
+- Do not implement HAL, task, linuxcncrsh, GUI, Python remap, or tool-database
+  semantics in JavaScript.
+- Do not make blocked `configs/sim` programs pass by editing upstream G-code,
+  changing SDK behavior, or adding project-owned interpreter semantics.
+- Do not treat native LinuxCNC GUI code as implementation code for the browser
+  UI.
+
+Current implementation added by this batch
+
+1. SDK runtime-boundary classifier
+
+   Added:
+
+   ```text
+   wasm-port/runtime/sdk/src/sim-config-staging.js
+   analyzeIniRuntimeBoundaries()
+   ```
+
+   Exported through:
+
+   ```text
+   wasm-port/runtime/sdk/src/index.js
+   ```
+
+   The classifier reads INI text, manifest text, source-root metadata, and
+   optional execution text. It reports:
+
+   - declared `HAL` process inputs: `HALFILE`, `HALCMD`, `POSTGUI_HALFILE`,
+     `HALUI`;
+   - declared UI process inputs: `DISPLAY`, `PYVCP`, `GLADEVCP`,
+     `EMBED_TAB_COMMAND`;
+   - `HALUI` MDI command dependencies;
+   - `[EMCIO]DB_PROGRAM` tool-database process dependencies;
+   - Python references in UI, DB, `[PYTHON]`, or Python remap declarations;
+   - `[RS274NGC]USER_M_PATH` plus whether the current execution text calls
+     unstaged external `M100..M199` process codes.
+
+   It returns a policy recommendation for hard Layer 4 blocks:
+
+   - `L4-TOOL-DB` when `[EMCIO]DB_PROGRAM` is present;
+   - `L4-USER-M-PROCESS` when the current execution chain calls unstaged
+     external user-M process codes;
+   - `L4-PYTHON-REMAP` for Python remap runtime declarations;
+   - `-` when the dependency is only a declared process dependency already
+     represented by a narrower standalone adapter or class representative.
+
+   This is policy/accounting only. It does not execute or emulate HAL, task,
+   UI, Python, user-M, or tool-database behavior.
+
+2. Node coverage for the classifier
+
+   Updated:
+
+   ```text
+   wasm-port/tests/wasm/node/verify_sim_configs_wasm.mjs
+   ```
+
+   Covered cases:
+
+   - synthetic INI with vendored `M123` user-M file remains unblocked;
+   - `axis/db_demo/db_nonran.ini` reports `L4-TOOL-DB`;
+   - `axis/vismach/millturn/millturn.ini` plus its remap execution chain
+     reports `L4-USER-M-PROCESS` because `M428/M429` call unstaged `M128/M129`;
+   - `axis/vismach/puma/puma_cube.ini` declares HAL/UI/HALUI process
+     dependencies but remains unblocked for the current representative program
+     because the promoted execution path does not call unstaged external
+     user-M process codes;
+   - `axis/gladevcp/gladevcp_panel.ini` declares UI/Python UI process
+     dependencies but remains unblocked for the current `probe.ngc`
+     representative.
+
+3. Inventory policy guard
+
+   Updated:
+
+   ```text
+   wasm-port/tests/wasm/node/verify_sim_configs_inventory_wasm.mjs
+   ```
+
+   The Node inventory now checks vendored INI rows against
+   `analyzeIniRuntimeBoundaries()` before execution/skipping:
+
+   - `L4-TOOL-DB` rows must declare `DB_PROGRAM`;
+   - `L4-USER-M-PROCESS` rows must be backed by an execution chain that calls
+     unstaged external user-M process codes;
+   - generated/tracked blocked policy drift fails the inventory.
+
+Boundary model
+
+Layer A: declaration classification
+
+- Input: INI text, manifest text, optional execution text.
+- Output: dependency list and recommended blocked kind.
+- Owner: SDK host-boundary code.
+- Validation: Node unit/smoke assertions and Node inventory policy checks.
+
+Layer B: standalone adapter execution
+
+- Allowed only when a narrow runtime edge already exists and CNC behavior still
+  comes from vendored LinuxCNC source.
+- Current examples:
+  - HAL named-parameter lookup and switchkins M68/M66 synchronization through
+    the standalone HAL adapter;
+  - deterministic `USER_M_COMMAND` canonical events for already vendored
+    M110/M111-style user-M registration;
+  - five-axis remap execution through vendored LinuxCNC remap/O-word paths;
+  - OPFS/file/parameter/tool-table persistence as host storage boundaries.
+
+Layer C: browser/UI representation
+
+- Browser UI may present standalone simulation state and user controls.
+- Browser UI must not execute native LinuxCNC GUI code.
+- Browser UI must call SDK/WASM boundaries that are already validated in Node
+  or native probes.
+- Full LinuxCNC GUI actions remain blocked unless expressed as a deliberate
+  standalone command boundary with LinuxCNC-owned behavior underneath.
+
+Layer D: full-process blocked boundary
+
+Keep blocked until explicitly designed:
+
+- LinuxCNC task process lifecycle;
+- HAL process/module loading and realtime scheduling;
+- HALUI/linuxcncrsh command queues;
+- external userspace components;
+- native GUI driver processes;
+- Python remap/prolog/epilog runtime;
+- tool database process startup and protocol/state behavior.
+
+Immediate next implementation batches
+
+Batch 1: make boundary reports durable
+
+- Add a generated machine-readable boundary artifact:
+
+  ```text
+  wasm-port/build/wasm/sim-configs-inventory/boundary-summary.tsv
+  ```
+
+- Minimum fields:
+
+  ```text
+  path
+  ini
+  blocked
+  recommended_blocked
+  dependencies
+  user_m_execution_codes
+  user_m_vendored_count
+  db_program
+  hal_process
+  ui_process
+  halui_mdi_process
+  python_process
+  ```
+
+- The existing Node inventory should fail if `blocked` and
+  `recommended_blocked` conflict for hard blocks.
+
+Batch 2: promote only safe HAL/UI representatives
+
+- Keep `axis/gladevcp/probe.ngc`, `woodpecker/on_abort.ngc`,
+  `axis/vismach/puma/puma_cube.ngc`, and `axis/vismach/melfa-sim/example.ngc`
+  as representative file-execution paths.
+- Add browser assertions that these programs remain file/remap execution
+  representatives and do not claim full UI/HAL process coverage.
+- Do not promote `axis/vismach/millturn/example.ngc` until the user-M process
+  boundary is designed, because the remap chain calls M128/M129.
+
+Batch 3: design external user-M process boundary
+
+- Start with `axis/vismach/millturn` because it is the smallest current hard
+  blocked row with vendored INI and program context.
+- Required design questions:
+  - Which LinuxCNC source owns M128/M129 behavior in the native config?
+  - Is the behavior expressible as a LinuxCNC-owned deterministic adapter
+    boundary, or does it require spawning external process scripts?
+  - What canonical/state output proves behavior without adding JS CNC
+    semantics?
+- Do not mark `millturn` unblocked until native, Node, and browser checks can
+  prove the boundary.
+
+Batch 4: design tool DB boundary
+
+- Start with `axis/db_demo/db_nonran.ini`.
+- Required design questions:
+  - Which LinuxCNC source owns `DB_PROGRAM` startup/protocol semantics?
+  - Can a standalone tool database adapter call vendored LinuxCNC tooldata
+    source without reimplementing database behavior?
+  - What fixture demonstrates tool lookup/update behavior across native and
+    WASM?
+- Keep `axis/db_demo/base.ngc` as `L4-TOOL-DB` until this exists.
+
+Batch 5: Python remap/full-process family plan
+
+- Do not vendor or execute `gmoccapy`, `axis/laser`, or TWP nutating Layer 4
+  paths until Python remap runtime ownership is designed.
+- First artifact should be a dependency inventory, not execution:
+  - Python modules referenced by INI/remap;
+  - prolog/epilog functions;
+  - HAL/task/UI assumptions;
+  - NGC-only subpaths, if any, that can be separated safely.
+
+Validation gates
+
+Run after each batch:
+
+```bash
+wasm-port/tests/wasm/node/verify_sim_configs_wasm.sh
+wasm-port/tests/wasm/node/verify_sim_configs_inventory_wasm.sh
+wasm-port/tests/browser/verify_interp_browser.sh
+wasm-port/tests/host/verify_host_smokes.sh
+wasm-port/tools/verify_vendor_sync.sh
+wasm-port/tools/verify_no_standalone_cnc_semantics.sh
+```
+
+Completion criteria for this boundary phase
+
+- Every vendored sim-config INI used by Node inventory has a machine-readable
+  runtime-boundary report.
+- Hard blocked rows have a dependency-backed reason rather than path-only
+  classification.
+- Safe representatives can declare HAL/UI process dependencies without being
+  mislabeled as full-process coverage.
+- No blocked family is promoted until a LinuxCNC-owned runtime boundary exists
+  and is validated native, Node, and browser where appropriate.
diff --git a/wasm-port/docs/compatibility-validation.md b/wasm-port/docs/compatibility-validation.md
index 6152154..67ec2ce 100644
--- a/wasm-port/docs/compatibility-validation.md
+++ b/wasm-port/docs/compatibility-validation.md
@@ -36,6 +36,12 @@ The current WASM sim-config smoke validation command is:
 wasm-port/tests/wasm/node/verify_sim_configs_wasm.sh
 ```
 
+The current WASM sim-config inventory validation command is:
+
+```bash
+wasm-port/tests/wasm/node/verify_sim_configs_inventory_wasm.sh
+```
+
 The current WASM `nc_files` smoke validation command is:
 
 ```bash
@@ -92,6 +98,7 @@ running the aggregate host check:
 wasm-port/tests/wasm/node/verify_ini_wasm.sh
 wasm-port/tests/wasm/node/verify_interp_wasm.sh
 wasm-port/tests/wasm/node/verify_sim_configs_wasm.sh
+wasm-port/tests/wasm/node/verify_sim_configs_inventory_wasm.sh
 wasm-port/tests/wasm/node/verify_nc_files_wasm.sh
 wasm-port/tests/wasm/node/verify_tp_wasm.sh
 wasm-port/tests/opfs/node/verify_file_service.sh
@@ -122,7 +129,278 @@ Layer responsibilities are intentionally narrow:
 
 The current `wasm-port/tests/native/verify_sim_configs.sh` run reports
 `total: 159`, `pass: 151`, `expected_fail: 8`, and `unexpected_fail: 0`.
-The eight expected failures are:
+The eight expected failures are listed in the table below.
+
+The tracked per-program inventory for this layer now lives in
+`wasm-port/docs/sim-configs-coverage-matrix.md`. That matrix maps all 159
+current `summary.tsv` records to program class, native result, current
+Layer 3/4 coverage, and the first-pass blocked or follow-up note used for
+future `configs/sim` coverage work.
+
+The native harness also emits machine-readable derived artifacts without
+changing the `summary.tsv` schema:
+
+```text
+wasm-port/build/native/sim-configs/class-summary.tsv
+wasm-port/build/native/sim-configs/path-matrix.tsv
+```
+
+`class-summary.tsv` aggregates class/status/expected-failure counts.
+`path-matrix.tsv` records each path, class, native status, expected-failure
+reason, INI, tool table, runtime family, and blocked kind for CI and Node
+inventory reconciliation.
+
+The Node inventory layer writes its own machine-readable artifacts:
+
+```text
+wasm-port/build/wasm/sim-configs-inventory/summary.tsv
+wasm-port/build/wasm/sim-configs-inventory/skip-summary.tsv
+wasm-port/build/wasm/sim-configs-inventory/boundary-summary.tsv
+wasm-port/build/wasm/sim-configs-inventory/ini-boundary-summary.tsv
+wasm-port/build/wasm/sim-configs-inventory/blocked-dependency-summary.tsv
+wasm-port/build/wasm/sim-configs-inventory/full-process-boundary-summary.tsv
+wasm-port/build/wasm/sim-configs-inventory/user-m-process-state-targets.tsv
+wasm-port/build/wasm/sim-configs-inventory/user-m-process-native-state-alignment.tsv
+wasm-port/build/wasm/sim-configs-inventory/tool-db-process-protocol-gates.tsv
+wasm-port/build/wasm/sim-configs-inventory/tool-db-process-native-protocol-alignment.tsv
+wasm-port/build/wasm/sim-configs-inventory/python-remap-boundary-summary.tsv
+wasm-port/build/wasm/sim-configs-inventory/python-remap-runtime-gates.tsv
+wasm-port/build/wasm/sim-configs-inventory/python-remap-native-runtime-alignment.tsv
+wasm-port/build/wasm/sim-configs-inventory/python-remap-native-runtime-readiness.tsv
+wasm-port/build/wasm/sim-configs-inventory/python-remap-native-runtime-state-plan.tsv
+wasm-port/build/wasm/sim-configs-inventory/python-remap-native-runtime-fixture-plan.tsv
+wasm-port/build/wasm/sim-configs-inventory/python-remap-family-summary.tsv
+wasm-port/build/wasm/sim-configs-inventory/boundary-phase-completion-summary.tsv
+wasm-port/build/wasm/sim-configs-inventory/native-proof-alignment-summary.tsv
+wasm-port/build/wasm/sim-configs-inventory/runtime-boundary-native-alignment-summary.tsv
+wasm-port/build/wasm/sim-configs-inventory/blocked-runtime-promotion-lock.tsv
+wasm-port/build/wasm/sim-configs-inventory/next-boundary-worklist.tsv
+wasm-port/build/wasm/sim-configs-inventory/boundary-proof-gates.tsv
+```
+
+The current skip/block summary is `ASSET-ONLY=65`, `L4-PYTHON-REMAP=53`,
+`L4-TOOL-DB=1`, `L4-USER-M-PROCESS=1`, `NON_MAIN_CLASS=10`, and
+`UPSTREAM-DEMO=1`.
+`skip-summary.tsv` is checked against the skip reasons derived from
+`path-matrix.tsv`, so both the per-row inventory status and the aggregate
+skip counts fail on blocked-policy drift.
+For eligible rows, missing vendored machine context is an inventory failure,
+not an expected skip; blocked rows must be classified by runtime dependency
+before the Node inventory filter runs.
+`boundary-summary.tsv` records one row per native inventory path with the
+matrix blocked kind, SDK classifier recommendation, declared HAL/UI/HALUI/Python
+process dependencies, `[EMCIO]DB_PROGRAM`, user-M execution codes, and the
+subset of execution user-M codes that are not staged by vendored
+`USER_M_PATH` files. It also separates Python UI/DB process dependencies from
+Python remap runtime dependencies. For vendored INI rows, the SDK classifier
+report must be available and `L4-TOOL-DB` / `L4-USER-M-PROCESS` hard blocks
+must match the classifier recommendation. `recommended_blocked=UNAVAILABLE` is
+only allowed when the boundary row records a missing vendored INI. Non-vendored
+Python-remap families remain unavailable until their dependency inventory batch
+vendors the required INI context.
+`ini-boundary-summary.tsv` aggregates those path-level reports by INI, giving
+vendored sim-config INIs a direct `report_available=1` coverage check and
+recording hard-block recommendation alignment at INI granularity.
+The inventory also guards safe representative rows such as
+`axis/gladevcp/probe.ngc`, `woodpecker/on_abort.ngc`,
+`axis/vismach/puma/puma_cube.ngc`, and
+`axis/vismach/melfa-sim/example.ngc`: they must keep their declared process
+dependencies in `boundary-summary.tsv`, remain Node/browser representatives,
+match the expected HAL/UI/HALUI/Python process flags, and avoid hard-block
+promotion unless a real hard runtime dependency appears.
+Deterministic `M110`/`M111` representatives are also guarded: the inventory
+must see the execution-chain user-M code, a vendored user-M file, and no hard
+`L4-USER-M-PROCESS` recommendation. `opa_demo.ngc` includes its vendored
+`circles.ngc` subroutine text in the boundary analysis so the `M111` call is
+accounted for even though it is reached through `SUBROUTINE_PATH`.
+`blocked-dependency-summary.tsv` records the hard blocked rows without
+promoting them: 53 Python-remap rows, one tool-database row, and one external
+user-M process row. It reads the source `linuxcnc/configs/sim` INI files for
+dependency accounting only and records Python modules, remap/prolog/epilog
+function ownership, NGC remap subpaths, HAL/UI/HALUI process declarations,
+`DB_PROGRAM`, tool database protocol evidence, external user-M execution
+codes, user-M process script files, user-M process side-effect evidence, and
+the LinuxCNC source/config files that own the blocked behavior. The user-M
+evidence is source-derived from the `M128`/`M129` Tcl scripts and records their
+Tcl/HAL runtime use, kinstype guard, and `ini.[xyz]` HAL pin updates. The tool
+database evidence is source-derived from `taskclass.cc`, `tooldata_db.cc`, and
+`axis/db_demo/db.py`, including the `v2.1` handshake, `g`/`FINI` get-all, and
+`l`/`u`/`p` notification protocol.
+The final Node inventory `summary.tsv` also guards every hard-blocked row:
+`L4-TOOL-DB`, `L4-USER-M-PROCESS`, and `L4-PYTHON-REMAP` paths must remain
+`SKIP` with their matching blocked reason, not only carry a matrix-level
+blocked label.
+The detailed boundary design for the current non-Python hard blocks is tracked
+in `wasm-port/docs/full-process-boundary-design.md`. That document records the
+LinuxCNC owner sets and proof required before `axis/vismach/millturn/example.ngc`
+or `axis/db_demo/base.ngc` can move out of `L4-USER-M-PROCESS` or
+`L4-TOOL-DB`. It is not an execution artifact and does not change the current
+Layer 4 blocked counts.
+`full-process-boundary-summary.tsv` is the machine-readable companion for that
+design record. It has one designed-but-blocked row for `millturn` and one for
+`db_demo`, records the LinuxCNC runtime owner evidence from the corresponding
+blocked dependency row, records the required native/Node/browser proof, and
+keeps `execution_enabled=0` until the corresponding LinuxCNC-owned runtime
+boundary exists. The tracked matrix and inventory guard also require those two
+rows to remain non-representative in Node/browser until that proof exists.
+`user-m-process-state-targets.tsv` expands the `millturn` M128/M129 process
+boundary into per-pin proof targets: two user-M codes, three axes, and four
+`ini.[xyz]` HAL pins per axis. Each row records the source Tcl file, remap
+caller, kinstype guard, INI source section/field, expected value,
+`proof_status=pending`, `execution_enabled=0`, and `promotion_allowed=0`.
+`user-m-process-native-state-alignment.tsv` then aligns each generated pin
+target with the native source probe stdout key/value pair, for example
+`M128_X_AXIS_X.MIN_LIMIT_ok=1`. This catches drift between generated target
+rows and the LinuxCNC-owned native source proof without executing Tcl/HAL or
+allowing promotion.
+`user-m-process-native-transition-alignment.tsv` performs the same source
+alignment for the `M428/M429` transition plan. It checks the native probe
+stdout for `motion.analog-out-03`, kinstype targets `0` and `1`,
+`G59.1`/`G59.2`, `P7`/`P8`, and the `M428 -> M128` / `M429 -> M129` calls.
+Those rows also remain `proof_status=pending`, `execution_enabled=0`, and
+`promotion_allowed=0`.
+`user-m-process-native-runtime-state-plan.tsv` is the runnable native probe
+contract that follows those source-alignment tables. It names the required
+LinuxCNC task/HAL/Tcl user-M process runtime, the required HAL/INI
+environment, and the exact `ini.[xyz].*` state values that a future native
+runtime probe must record after `M428` and `M429`. It remains a plan only with
+`native_runtime_status=pending_native_hal_tcl_process_probe`,
+`execution_enabled=0`, and `promotion_allowed=0`.
+`user-m-process-native-runtime-readiness.tsv` is the host capability gate for
+that future probe. It records availability of `tclsh`, `halrun`, `halcmd`, and
+`linuxcnc`, captures PATH evidence for available commands, and leaves
+`proof_status=pending`, `execution_enabled=0`, and `promotion_allowed=0`.
+`user-m-process-native-runtime-probe-gate.tsv` combines that readiness with the
+source/state proof for `M428/M128` and `M429/M129`. The native
+`probe_millturn_user_m_runtime.sh` entry point is wired through
+`build_native_probes.sh`; without the full LinuxCNC HAL/Tcl command set it
+reports `skipped_missing_host_runtime`, and with the runtime present it remains
+disabled by default. When explicitly enabled with
+`ENABLE_MILLTURN_USER_M_RUNTIME_PROBE=1`, it starts the vendored `millturn.ini`,
+runs the LinuxCNC-owned Tcl `M128`/`M129` scripts, verifies the expected
+`ini.[xyz].*` HAL pin state, and reports `runtime_state_probe_passed` without
+enabling promotion.
+`tool-db-process-protocol-gates.tsv` expands the `db_demo` tool-database
+boundary into pending protocol, callback, and state gates. It records the
+LinuxCNC `v2.1`, `g`, `l`, `u`, and `p` protocol requirements, the demo DB
+callbacks, DB mode state targets such as ignored `TOOL_TABLE`, `T10..T19`,
+`tno+100` pockets, and OPFS/host persistence boundaries, while keeping
+`proof_status=pending`, `execution_enabled=0`, and `promotion_allowed=0`.
+`tool-db-process-native-protocol-alignment.tsv` aligns each generated DB gate
+with the native source probe stdout proof keys, including the protocol
+handshake, get-all, notifications, callback registration, and nonrandom state
+targets. This is still dependency/proof accounting only: it does not spawn
+`DB_PROGRAM`, emulate the tool database protocol in JavaScript, or fall back to
+a `.tbl` file.
+`tool-db-process-native-runtime-readiness.tsv` records the host prerequisites
+for the guarded DB process protocol probe: `python3`, `linuxcnc`, `milltask`,
+`halcmd`, the configured `db_nonran.py` executable, and LinuxCNC's Python
+`linuxcnc.so` / `tooldb.py` modules. It captures availability evidence while
+keeping `proof_status=pending`, `execution_enabled=0`, and
+`promotion_allowed=0`. When explicitly enabled with
+`ENABLE_TOOL_DB_RUNTIME_PROBE=1`, `probe_tool_db_runtime.sh` starts the
+vendored `DB_PROGRAM`, drives the LinuxCNC `tooldb.py` `v2.1`/`g`/`p`/`l`/`u`
+protocol, verifies nonrandom startup/update/load/unload state and persistence,
+and reports `runtime_protocol_probe_passed` without enabling promotion.
+`python-remap-boundary-summary.tsv` is the machine-readable companion for the
+Python remap inventory batch. It has one inventory-only row for each
+`L4-PYTHON-REMAP` path, records Python modules, remap/prolog/epilog functions,
+NGC-only subpaths, HAL/UI/HALUI assumptions, LinuxCNC Python runtime owner
+evidence from `interp_python.cc` and `python_plugin.cc`, and keeps
+`execution_enabled=0` until a LinuxCNC-owned Python runtime boundary exists.
+`python-remap-runtime-gates.tsv` expands those rows into Python module,
+remap/prolog/epilog callable, NGC-only subpath, process-assumption, and
+runtime-owner gates, all with `proof_status=pending`,
+`execution_enabled=0`, and `promotion_allowed=0`.
+`python-remap-native-runtime-alignment.tsv` aligns every generated Python gate
+with native source proof: exact runtime owner gates use keys such as
+`python_runtime_pycall_dispatch`, while dependency gates use representative
+family inventory proof or the aggregate
+`python_remap_native_source_inventory_proof`. It does not initialize Python,
+import modules, execute callbacks, or promote browser/Node coverage.
+`python-remap-native-runtime-readiness.tsv` records the native runtime
+prerequisites for guarded probes by family: `python3`, `linuxcnc`,
+LinuxCNC's `interp_python.cc` / `python_plugin.cc` owner source files, and the
+configured Python modules. It is a readiness gate only and keeps every row
+`proof_status=pending`, `execution_enabled=0`, and `promotion_allowed=0`.
+`python-remap-native-runtime-state-plan.tsv` records the next native runtime
+probe target set by family: LinuxCNC Python phases, configured modules,
+callables, NGC-only subpaths, process assumptions, readiness counts, and
+source-alignment artifacts. It remains a plan only and does not initialize
+Python, import modules, execute callbacks, or permit promotion.
+`python-remap-native-runtime-fixture-plan.tsv` selects the first minimal
+Python runtime lifecycle fixture, `axis/remap/stop-lookahead/nc_files`, because
+it exercises Python runtime phases and configured modules without Python
+callable or NGC-only subpath complexity. It is still a fixture plan only:
+`proof_status=pending`, `execution_enabled=0`, and `promotion_allowed=0`.
+When explicitly enabled with `ENABLE_PYTHON_REMAP_RUNTIME_PROBE=1`,
+`probe_python_remap_runtime.sh` follows the fixture `demo.ini` Python path and
+toplevel declarations, imports the vendored modules, verifies `queuebuster`
+callable lookup, generator return, and first `INTERP_EXECUTE_FINISH` yield, and
+reports `runtime_lifecycle_probe_passed` without promoting Python-remap
+execution.
+`python-remap-family-summary.tsv` aggregates the same blocked rows by runtime
+family, preserving row and INI counts plus family-level Python module,
+remap/prolog/epilog, NGC-only subpath, Python runtime owner evidence,
+HAL/UI/HALUI, and `execution_enabled=0` evidence. It is dependency inventory
+only and must not be used to promote Python-remap execution.
+`boundary-phase-completion-summary.tsv` records the current boundary-phase
+completion criteria as machine-readable checks: vendored INI boundary report
+coverage, hard-block dependency evidence, safe HAL/UI representative coverage,
+proof that blocked families remain skipped/non-representative with execution
+disabled, and proof that blocked runtime families carry LinuxCNC-owned user-M,
+tool DB, and Python runtime evidence fields. It also records native source
+proof alignment when the native proof summary is available, plus the aggregate
+native stdout alignment summary for user-M, tool DB, and Python runtime gates.
+`native-proof-alignment-summary.tsv` aligns native source proof rows with the
+generated worklist and native proof gates for user-M, tool DB, and Python
+runtime blockers. It is proof-consumption accounting only and keeps execution
+and promotion disabled.
+`runtime-boundary-native-alignment-summary.tsv` summarizes the three detailed
+native alignment artifacts. It requires every alignment row to have native
+stdout evidence, `alignment_ok=1`, `proof_status=pending`,
+`execution_enabled=0`, and `promotion_allowed=0`.
+`blocked-runtime-promotion-lock.tsv` combines the next-boundary worklist,
+native/Node/browser proof gates, and runtime native alignment summary into one
+promotion lock per blocked runtime target. A lock row is active only while
+every proof layer is still pending, execution and promotion remain disabled,
+and the matching runtime alignment artifact is complete.
+`next-boundary-worklist.tsv` records the next blocked runtime-boundary design
+targets in priority order. It starts with the designed-but-disabled
+`millturn` external user-M process and `db_demo` tool database process
+boundaries, then lists Python runtime families from the inventory. Every row
+keeps `execution_enabled=0` and `promotion_allowed=0`, records the LinuxCNC
+owner set and runtime owner evidence, records required native, Node, and
+browser proof, and names the next boundary-design action before promotion.
+`boundary-proof-gates.tsv` expands that worklist into one pending native,
+Node, and browser proof gate per target. It is a promotion guard only: current
+rows keep `proof_status=pending`, `execution_enabled=0`, and
+`promotion_allowed=0`; user-M gates must require HAL pin state rather than
+event-only proof, tool-DB gates must require protocol proof rather than a
+`.tbl` fallback, and Python gates must require a LinuxCNC-owned Python runtime
+boundary rather than JavaScript semantics.
+The browser interpreter smoke reads the browser-layer rows from this artifact
+before running safe representatives, so `millturn`, `db_demo`, and Python
+runtime families cannot be accidentally treated as browser/full-process
+coverage while their proof gates remain pending.
+
+Current `configs/sim` class taxonomy:
+
+| Class | Meaning | Current policy |
+| --- | --- | --- |
+| `main` | A complete standalone-executable sim-config program. | Eligible for native inventory; promote to Layer 3/4 when the required runtime boundary exists. |
+| `macro_load` | A macro or load/parse asset that is not the primary machine program entry point. | Keep in native inventory, but do not treat it as a browser main-program target by default. Add class-level load/parse representatives instead of widening browser execution blindly. |
+| `remap_subroutine` | A remap or subroutine asset under `remap_subs/` or similar directories. | Validate through remap parse/execute paths, not by pretending it is a standalone browser main program. |
+
+Current `configs/sim` blocked policy:
+
+| Blocked kind | Meaning | Current examples |
+| --- | --- | --- |
+| `ASSET-ONLY` | The file is a macro/remap asset or subroutine and is not a standalone browser main-program target. | `configs/sim/*/remap_subs/*.ngc` entries in the matrix. |
+| `L4-TOOL-DB` | Native LinuxCNC `rs274` coverage exists, but Node/browser inventory is blocked by LinuxCNC tool-database process boundaries such as `[EMCIO]DB_PROGRAM`. | `configs/sim/axis/db_demo/*`. |
+| `L4-USER-M-PROCESS` | Native LinuxCNC `rs274` coverage exists, but Node/browser inventory is blocked because the config depends on external `USER_M_PATH` process execution rather than the deterministic `M110`/`M111` boundary already modeled by the standalone runtime. | `configs/sim/axis/vismach/millturn/*`. |
+| `L4-PYTHON-REMAP` | Native LinuxCNC `rs274` coverage exists, but full Node/browser inventory is blocked until an intentional Python-remap runtime boundary is exposed for Layer 4. | `configs/sim/gmoccapy/*`, `configs/sim/axis/laser/*`, `configs/sim/axis/remap/*/nc_files/*.ngc`, `configs/sim/axis/vismach/5axis/table-rotary_spindle-rotary-nutating/demos/*`, and `configs/sim/axis/vismach/VMC_toolchange/toolchange.ngc`. |
+| `UPSTREAM-DEMO` | A preserved upstream demo edge that should remain an expected failure instead of being forced through standalone semantics. | `axis/vismach/5axis/table-rotary_spindle-rotary-nutating/demos/incremental_repetition_g533.ngc`. |
 
 | Program | Layer 2 classification | Current Layer 3/4 coverage or boundary |
 | --- | --- | --- |
@@ -499,14 +777,15 @@ The validation fails if:
 | Harness | Purpose |
 | --- | --- |
 | `tests/wasm/node/verify_ini_wasm.sh` | Validates the browser-facing INI WASM module can be built from vendored LinuxCNC `inifile.cc`, loaded through the JS SDK in Node, and queried through the exported C ABI, including LinuxCNC-backed boolean conversion and machine-session file-name string lookup. |
-| `tests/wasm/node/verify_interp_wasm.sh` | Validates the interpreter-core WASM module can be built from vendored LinuxCNC interpreter/remap source, loaded through the interpreter JS SDK, run the first fixture group through `Interp::execute()` and selected file fixtures plus vendored upstream `tests/interp` regression files through `Interp::open()`/`read()`/`execute()`, match the native canonical event plus required state readback fixtures, emit `run_step` execution-status records with LinuxCNC line number, encoded source statement, return code, and interpreter axis positions for file execution, cover vendored `tests/interp/flowsnake` recursive O-word file execution, `tests/interp/g6164` path-control and naive-cam tolerance execution, `tests/interp/oword-unwind` continue-on-error stack unwind behavior through planner-staged INI context, selected `tests/interp/bad` file-error paths, and `tests/interp/g33.1` rigid-tap file execution, run vendored `xyzac-trt`/`xyzbc-trt` switchkins remap demo files through the WASM C ABI/SDK path, and run parameter-file restore/save through vendored LinuxCNC `Interp::restore_parameters()` and `Interp::save_parameters()`. |
-| `tests/wasm/node/verify_sim_configs_wasm.sh` | Validates representative vendored LinuxCNC `configs/sim` programs in Node WASM through `planSimConfigStaging()` plus `runSimConfigProgram()`. The generic `planIniFileContextStaging()` planner and its sim-config wrapper use INI text and `tools/source-manifest.txt` to collect the program, INI, tool table, parameter file when vendored, `SUBROUTINE_PATH` files, `USER_M_PATH` files, and remap-NGC files before forwarding to `runFileWithIni()` or `runFiveAxisRemapFile()`. This covers INI-driven `U/V/W` axis mask handling, real `USER_M_PATH` registration for executable `M110`/`M111`, all four current external-offset M111 expected-failure programs, `SUBROUTINE_PATH` staging for `opa_demo.ngc -> circles.ngc`, bridge-mill remap-subroutine staging, and vendored LinuxCNC bridge-mill NGC remap execution without spawning host processes. The same smoke includes synthetic staging-plan assertions for generic `TOOL_TABLE`, `PARAMETER_FILE`, multi-directory `SUBROUTINE_PATH`, `USER_M_PATH`, and `REMAP ... ngc=...` file collection. |
+| `tests/wasm/node/verify_interp_wasm.sh` | Validates the interpreter-core WASM module can be built from vendored LinuxCNC interpreter/remap source, loaded through the interpreter JS SDK, run the first fixture group through `Interp::execute()` and selected file fixtures plus vendored upstream `tests/interp` regression files through `Interp::open()`/`read()`/`execute()`, match the native canonical event plus required state readback fixtures, emit `run_step` execution-status records with LinuxCNC line number, encoded source statement, return code, and interpreter axis positions for file execution, cover vendored `tests/interp/flowsnake` recursive O-word file execution, `tests/interp/g6164` path-control and naive-cam tolerance execution, `tests/interp/oword-unwind` continue-on-error stack unwind behavior through planner-staged INI context, selected `tests/interp/bad` file-error paths, and `tests/interp/g33.1` rigid-tap file execution, run vendored `xyzac-trt`/`xyzbc-trt` table-rotary-tilting and `xyzab-tdr` table-dual-rotary switchkins remap demo files through the WASM C ABI/SDK path, and run parameter-file restore/save through vendored LinuxCNC `Interp::restore_parameters()` and `Interp::save_parameters()`. |
+| `tests/wasm/node/verify_sim_configs_wasm.sh` | Validates representative vendored LinuxCNC `configs/sim` programs in Node WASM through `planSimConfigStaging()` plus `runSimConfigProgram()`. The generic `planIniFileContextStaging()` planner and its sim-config wrapper use INI text and `tools/source-manifest.txt` to collect the program, INI, tool table, parameter file when vendored, `SUBROUTINE_PATH` files, `USER_M_PATH` files, and remap-NGC files before forwarding to `runFileWithIni()` or `runFiveAxisRemapFile()`. This covers INI-driven `U/V/W` axis mask handling, real `USER_M_PATH` registration for executable `M110`/`M111`, all four current external-offset M111 expected-failure programs, deterministic `woodpecker/on_abort.ngc` file execution, plain INI/tool-table execution through `axis/gladevcp/probe.ngc`, `SUBROUTINE_PATH` staging for `opa_demo.ngc -> circles.ngc`, bridge-mill remap-subroutine staging, vendored LinuxCNC bridge-mill and `melfa-sim` NGC remap execution, and PUMA machine-context execution without spawning host processes. The same smoke includes synthetic staging-plan assertions for generic `TOOL_TABLE`, `PARAMETER_FILE`, multi-directory `SUBROUTINE_PATH`, `USER_M_PATH`, and `REMAP ... ngc=...` file collection. |
+| `tests/wasm/node/verify_sim_configs_inventory_wasm.sh` | Validates the first machine-readable Node inventory layer for `configs/sim`. It ensures native `build/native/sim-configs/summary.tsv`, generated `class-summary.tsv`, and generated `path-matrix.tsv` exist; verifies that generated `path-matrix.tsv` and tracked `docs/sim-configs-coverage-matrix.md` contain the same 159 paths as native `summary.tsv`; checks tracked matrix fields for class, native status, expected-failure reason, and blocked kind drift against generated `path-matrix.tsv`; and checks that generated `class-summary.tsv` matches class/status/expected-failure counts derived from `summary.tsv`. It then executes only entries that are currently vendored and have a defined standalone/WASM runtime path, and writes the sim-config inventory TSV artifacts. The boundary summary records one row per native inventory path with the matrix block, SDK classifier recommendation, declared HAL/UI/HALUI/Python process dependencies, `[EMCIO]DB_PROGRAM`, and execution-chain user-M codes; vendored INI rows must have an available classifier report, vendored hard blocks fail on classifier/matrix drift, safe process-declaring representatives must remain Node/browser `REP` rows with the expected process flag combinations rather than full-process promotions, and the designed full-process blocked rows must remain non-`REP` until their proof criteria are met. The generated inventory summary also requires all hard-blocked rows to remain `SKIP` with matching reasons, and `skip-summary.tsv` must match the matrix-derived skip counts. The blocked-dependency and boundary summaries record hard blocked Python-remap, tool-database, and external user-M rows from source `linuxcnc/configs/sim` INI files for dependency accounting only, including LinuxCNC source/config ownership fields, user-M script side effects, tool DB protocol evidence, Python runtime owner evidence, and completion criteria that all remain non-executing. Current gate: `executed=28`, `passed=28`, `skipped=131`, `unexpected_fail=0`; current skip/block counts are `ASSET_ONLY=65`, `L4_PYTHON_REMAP=53`, `L4_TOOL_DB=1`, `L4_USER_M_PROCESS=1`, `NON_MAIN_CLASS=10`, and `UPSTREAM_DEMO=1`. The executed set now includes the deterministic `woodpecker` plus `qtdragon` / `qtdragon_hd` / `qtvcp_screens` `on_abort.ngc` family, `axis/gladevcp/probe.ngc`, `axis/rose_engine/rcone_demo.ngc`, `axis/vismach/melfa-sim/example.ngc`, and the `axis/vismach/puma` sample programs after vendoring the required machine INI, tool-table, and remap-subroutine inputs. When an upstream INI declares a missing local tool table but the native harness resolved a valid fallback table, the Node inventory stages that native-selected table at the INI-declared path so WASM execution uses the same machine context. The skip reasons are explicit: `NON_MAIN_CLASS`, `L4-TOOL-DB`, `L4-USER-M-PROCESS`, `L4-PYTHON-REMAP`, and `UPSTREAM-DEMO`; an eligible row that lacks vendored machine context is reported as an inventory failure. This runner is an inventory source-of-truth for Node WASM and is intentionally narrower than a browser full inventory. |
 | `tests/wasm/node/verify_nc_files_wasm.sh` | Validates representative vendored LinuxCNC `nc_files` examples in Node WASM by copying `3D_Chips.ngc`, `arcspiral.ngc`, `hole-circle.ngc`, `factorial.ngc`, and `m6demo.ngc` into the Emscripten filesystem and forwarding to the LinuxCNC-backed `Interp::open()`/`read()`/`execute()` path. `3D_Chips.ngc` is staged with a minimal INI-declared `tool.tbl` because the upstream program contains `T1 M6`; JavaScript only stages files and checks LinuxCNC output, including `run_step` status records, and does not implement G-code, O-word, tool-change, or M-code behavior. |
 | `tests/wasm/node/verify_tp_wasm.sh` | Validates a standalone trajectory-planner WASM module can be built from vendored LinuxCNC TP/TC/Ruckig support source, loaded in Node, and run the same linear, arc, and queued-line planner probe paths covered by the native TP harness. |
 | `tests/opfs/node/verify_file_service.sh` | Validates the host-owned OPFS text-file adapter, path model, session snapshot store including custom filenames and envelope/path rejection paths, machine file store, G-code text store including filename rejection paths, OPFS-to-WASM parameter/tool-table bridges, and grouped machine-session loading without moving file persistence, parameter semantics, or tool-table semantics into the WASM core. |
 | `tests/browser/verify_ini_panel_browser.sh` | Validates the INI SDK, INI/interpreter WASM module loading, LinuxCNC-backed INI machine-session file-name string lookup, OPFS text-file round trip, generic session snapshot round trip plus custom filename and envelope/path rejection paths, machine file text round trip, G-code text round trip plus filename rejection paths, and the INI panel UI's machine-session load with default OPFS parameter/tool-table file mapping, G-code run, `run_step`-backed progress/line/statement/axis display, canonical-event display paths, and 5-axis remap demo action in a real browser runtime. |
-| `tests/browser/verify_interp_browser.sh` | Validates the interpreter-core WASM module loads through the interpreter JS SDK in a real browser runtime and runs selected positive and negative canonical fixtures plus vendored upstream `tests/interp` regression files through vendored LinuxCNC `Interp::execute()` and `Interp::open()`/`read()`/`execute()` via the exported C ABI, including direct browser SDK and OPFS-backed parameter-file restore/save, non-random/random tool-table load/save through vendored LinuxCNC source, vendored `xyzac-trt`/`xyzbc-trt` switchkins remap demo execution, representative vendored `configs/sim` `foam`, `geometry`, `external_offsets`, and bridge-mill programs through `runSimConfigProgram()`, representative vendored `nc_files` examples through `runFile()` or `runFileWithIni()` when the upstream file requires INI/tool-table context, and a synthetic browser assertion that `planIniFileContextStaging()` can collect INI, program, tool-table, parameter, multi-directory subroutine, executable user-M, and remap-NGC files using only manifest text. |
-| `tests/host/verify_host_smokes.sh` | Runs the current host-side Node, WASM interpreter-core, WASM trajectory-planner, OPFS, and browser smoke validation with shared WASM builds. |
+| `tests/browser/verify_interp_browser.sh` | Validates the interpreter-core WASM module loads through the interpreter JS SDK in a real browser runtime and runs selected positive and negative canonical fixtures plus vendored upstream `tests/interp` regression files through vendored LinuxCNC `Interp::execute()` and `Interp::open()`/`read()`/`execute()` via the exported C ABI, including direct browser SDK and OPFS-backed parameter-file restore/save, non-random/random tool-table load/save through vendored LinuxCNC source, vendored `xyzac-trt`/`xyzbc-trt` table-rotary-tilting and `xyzab-tdr` table-dual-rotary switchkins remap demo execution, representative vendored `configs/sim` `foam`, `geometry`, `external_offsets`, `axis/gladevcp/probe.ngc`, deterministic `woodpecker/on_abort.ngc`, bridge-mill, `melfa-sim`, and `puma_cube.ngc` programs through `runSimConfigProgram()`, representative vendored `nc_files` examples through `runFile()` or `runFileWithIni()` when the upstream file requires INI/tool-table context, and a synthetic browser assertion that `planIniFileContextStaging()` can collect INI, program, tool-table, parameter, multi-directory subroutine, executable user-M, and remap-NGC files using only manifest text. |
+| `tests/host/verify_host_smokes.sh` | Runs the current host-side Node, WASM interpreter-core, sim-config representative smoke, sim-config Node inventory, WASM trajectory-planner, OPFS, and browser smoke validation with shared WASM builds. |
 
 ## Fixture Coverage
 
diff --git a/wasm-port/docs/full-process-boundary-design.md b/wasm-port/docs/full-process-boundary-design.md
new file mode 100644
index 0000000..979ecca
--- /dev/null
+++ b/wasm-port/docs/full-process-boundary-design.md
@@ -0,0 +1,513 @@
+# Full-Process Runtime Boundary Design
+
+Generated: 2026-06-10 CST
+
+This document records the first design pass for `configs/sim` rows that are
+already classified by the Node inventory, but must remain blocked until a
+LinuxCNC-owned runtime boundary exists. It is a design and accounting artifact,
+not an execution path.
+
+## Scope
+
+- `axis/vismach/millturn/example.ngc`, currently `L4-USER-M-PROCESS`.
+- `axis/db_demo/base.ngc`, currently `L4-TOOL-DB`.
+- Python-remap and broader full-process families remain inventoried in
+  `build/wasm/sim-configs-inventory/blocked-dependency-summary.tsv`; they are
+  not promoted here.
+
+## Non-Goals
+
+- Do not implement HAL, task, HALUI, Tcl, Python, tool-database, or external
+  process semantics in JavaScript.
+- Do not make blocked rows pass by editing upstream G-code, Tcl, Python, INI,
+  or tool-table files.
+- Do not treat native GUI code or config helper scripts as browser UI
+  implementation code.
+- Do not mark a row unblocked until native, Node, and browser validation prove
+  the boundary where that layer is applicable.
+
+## External User-M Process Boundary
+
+### Current Block
+
+`axis/vismach/millturn/example.ngc` is blocked because
+`millturn.ini` declares:
+
+- `[RS274NGC]USER_M_PATH = ./mcodes`;
+- `REMAP = M428 ... ngc=428remap`;
+- `REMAP = M429 ... ngc=429remap`;
+- `[HAL]HALUI = halui`, `HALFILE`, `HALCMD`, and `POSTGUI_HALFILE`;
+- `[HALUI]MDI_COMMAND = M128` and `M129`;
+- `[DISPLAY]PYVCP = millturn.xml`.
+
+The promoted execution chain reaches `remap_subs/428remap.ngc` and
+`remap_subs/429remap.ngc`. Those LinuxCNC NGC remaps execute `M68`/`M66`
+switchkins synchronization and then call external user-M process codes
+`M128` or `M129`.
+
+### LinuxCNC Owner Set
+
+- `configs/sim/axis/vismach/millturn/millturn.ini` owns the machine
+  declarations and search paths.
+- `configs/sim/axis/vismach/millturn/remap_subs/428remap.ngc` and
+  `429remap.ngc` own the NGC remap call sequence around `M128` and `M129`.
+- `configs/sim/axis/vismach/millturn/mcodes/M128` and
+  `configs/sim/axis/vismach/millturn/mcodes/M129` own the config side effects.
+- `src/emc/task/emctask.cc` owns `USER_M_PATH` search, executable detection,
+  `USER_DEFINED_FUNCTION_ADD()`, and queuing `EMC_SYSTEM_CMD`.
+- `src/emc/task/emctaskmain.cc` owns `emcSystemCmd()` process spawning and
+  completion tracking for queued system commands.
+- `src/emc/usr_intf/halui.cc` owns HALUI MDI command queue behavior.
+- The HAL runtime owns `hal getp`/`hal setp` state, including the `ini.*`
+  soft-limit pins used by the scripts.
+
+### Native Behavior To Preserve
+
+`M128` is a Tcl process script that:
+
+- requires the LinuxCNC and HAL Tcl packages;
+- calls `emc_init -quick`;
+- calls `parse_ini $::env(INI_FILE_NAME)`;
+- checks `hal getp kinstype.is-0`;
+- writes mill limits from `[AXIS_X]`, `[AXIS_Y]`, and `[AXIS_Z]` into
+  `ini.x.*`, `ini.y.*`, and `ini.z.*` HAL pins.
+
+`M129` follows the same process path, but checks `kinstype.is-1` and writes the
+`MIN_LIMIT_TURN` / `MAX_LIMIT_TURN` values for X, Y, and Z. Both scripts also
+restore `MAX_VELOCITY` and `MAX_ACCELERATION`.
+
+The NGC remap files own the surrounding interpreter-visible work:
+
+- set `motion.analog-out-03` through `M68`;
+- force synchronization with `M66`;
+- set G5x offsets with `G10 L2 P7` or `G10 L2 P8`;
+- activate `G59.1` or `G59.2`;
+- verify `_hal[motion.switchkins-type]` after the switch.
+
+### Boundary Decision
+
+This is not the same boundary as the existing deterministic `M110`/`M111`
+registration adapter. `M110` and `M111` can currently be represented as
+deterministic `USER_M_COMMAND` canonical events because the promoted tests only
+need the interpreter to accept and queue the user-M command. `M128` and `M129`
+must also prove HAL pin state updates that affect soft limits after a
+kinematics switch.
+
+The row therefore remains `L4-USER-M-PROCESS`.
+
+### Current Machine-Readable Artifact
+
+`user-m-process-boundary-summary.tsv` records the current designed-but-blocked
+state target set for this boundary. It maps `M128` to
+`remap_subs/428remap.ngc` and `M129` to `remap_subs/429remap.ngc`, records the
+`kinstype.is-0` and `kinstype.is-1` guards, and expands the source-traceable
+`ini.[xyz].min_limit`, `ini.[xyz].max_limit`, `ini.[xyz].min_velocity`, and
+`ini.[xyz].max_acceleration` target pins from `millturn.ini`.
+`user-m-process-state-targets.tsv` is the normalized companion table for that
+same evidence. It has one pending proof row per `M128`/`M129` target pin,
+including the config script source file, remap caller, mill/turn state mode,
+guard pin, source INI section/field, and expected value. The current table has
+24 target rows plus a header and keeps `proof_status=pending`,
+`execution_enabled=0`, and `promotion_allowed=0`.
+`user-m-process-transition-plan.tsv` records the next non-executing contract
+for this boundary. It binds `M428` to `M128` and `M429` to `M129`, records the
+`motion.analog-out-03` switchkins output, target kinstype values `0` and `1`,
+the active `G59.1`/`G59.2` work offsets, `P7`/`P8` offset pockets, guard pins,
+and the 12 expected `ini.[xyz].*` state outputs for each user-M code. This is
+still a pending transition contract only; it does not execute Tcl, start HAL,
+or permit standalone/browser promotion.
+`user-m-process-native-state-alignment.tsv` aligns those 24 generated target
+rows with the native source probe stdout keys, such as
+`M128_X_AXIS_X.MIN_LIMIT_ok` and `M129_Z_AXIS_Z.MAX_LIMIT_TURN_ok`. This table
+proves the generated pin targets still match the native LinuxCNC source/state
+probe output, but it also remains `proof_status=pending`,
+`execution_enabled=0`, and `promotion_allowed=0`.
+`user-m-process-native-transition-alignment.tsv` aligns the two generated
+transition-plan rows with native source probe stdout for `M428` and `M429`.
+It verifies the source-owned `motion.analog-out-03` switchkins output, target
+kinstype values `0` and `1`, active `G59.1`/`G59.2` offsets, `P7`/`P8`
+offset pockets, and `M428 -> M128` / `M429 -> M129` process calls. This is
+still source-transition alignment only; it does not execute the Tcl user-M
+processes, start HAL, or allow promotion.
+`user-m-process-native-runtime-state-plan.tsv` is the next native runnable
+probe contract. It records the required LinuxCNC task/HAL/Tcl user-M runtime,
+the required environment (`INI_FILE_NAME`, `motion.switchkins-type`,
+`kinstype.is-0`, `kinstype.is-1`, and `ini.[xyz].*` pins), the two transition
+steps, and the exact expected `ini.[xyz].*` values after each user-M process.
+It requires the source transition/state alignment artifacts to be complete, but
+keeps `native_runtime_status=pending_native_hal_tcl_process_probe`,
+`proof_status=pending`, `execution_enabled=0`, and `promotion_allowed=0`.
+`user-m-process-native-runtime-readiness.tsv` records whether the host has the
+runtime commands needed to attempt that native probe. It currently checks
+`tclsh`, `halrun`, `halcmd`, and `linuxcnc`, records PATH evidence where a
+command exists, and keeps the boundary blocked with `proof_status=pending`,
+`execution_enabled=0`, and `promotion_allowed=0` even if the commands become
+available.
+`user-m-process-native-runtime-probe-gate.tsv` is the generated execution gate
+for the future runtime probe. It combines source proof readiness with host
+runtime readiness for `M428/M128` and `M429/M129`, records missing runtime
+commands, and keeps `proof_status=pending`, `execution_enabled=0`, and
+`promotion_allowed=0`.
+`tests/native/probe_millturn_user_m_runtime.sh` is wired into
+`build_native_probes.sh` as `linuxcnc_millturn_user_m_runtime_probe`. On hosts
+without `halrun`, `halcmd`, or `linuxcnc`, it exits successfully but reports
+`millturn_user_m_runtime_probe_status=skipped_missing_host_runtime`; on a host
+with the full LinuxCNC runtime it remains disabled by default. If explicitly
+enabled with `ENABLE_MILLTURN_USER_M_RUNTIME_PROBE=1`, it starts the vendored
+`millturn.ini`, runs the LinuxCNC-owned Tcl `M128`/`M129` scripts, and verifies
+the resulting `ini.[xyz].*` HAL state targets before reporting
+`runtime_state_probe_passed`.
+
+The artifact keeps `execution_enabled=0` and `promotion_allowed=0`. It is not
+a standalone Tcl/HAL executor and does not make `millturn` a Node/browser
+representative.
+
+`linuxcnc_millturn_user_m_boundary_probe` is the current native guard for this
+evidence. It reads the LinuxCNC source `millturn.ini`, `mcodes/M128`,
+`mcodes/M129`, and the `428remap`/`429remap` callers, then verifies the
+source-derived guard pins, `M428`/`M429` switchkins transition fields, and
+`ini.[xyz].*` target values recorded in the machine-readable tables. This is a
+source/state-target and source-transition proof only: it does not execute Tcl,
+start HAL, spawn the external user-M process, or permit promotion.
+
+### Candidate Boundary
+
+A valid future boundary would have to be LinuxCNC-owned and state based:
+
+1. Reuse LinuxCNC task user-M search and registration behavior for discovering
+   `M128` and `M129`.
+2. Reuse a LinuxCNC-owned HAL/INI state boundary for the `ini.x.*`,
+   `ini.y.*`, `ini.z.*`, `kinstype.is-*`, and `motion.switchkins-type` pins.
+3. Execute or faithfully host the config-owned side-effect source without
+   translating it into JavaScript CNC semantics. If the Tcl scripts cannot be
+   executed in the target layer, the boundary must be narrowed to a documented
+   LinuxCNC-owned state transition with source-traceable inputs and outputs.
+4. Keep browser execution blocked unless the same state transition can be
+   proven without spawning arbitrary host processes.
+
+### Required Proof Before Promotion
+
+Native proof:
+
+- The existing `linuxcnc_millturn_user_m_boundary_probe` source/state guard
+  must continue to prove that the pending M128/M129 state targets come from
+  LinuxCNC config files rather than project-owned behavior.
+- A LinuxCNC or standalone-native probe runs the `M428 -> M129 -> M429 -> M128`
+  relevant switch path and records the `ini.[xyz].min_limit`,
+  `ini.[xyz].max_limit`, `ini.[xyz].min_velocity`, and
+  `ini.[xyz].max_acceleration` pin values before and after each user-M call.
+- The same probe records the kinstype guard result and the active G5x offset.
+
+Node WASM proof:
+
+- The SDK stages the same INI, remap, and script assets for dependency
+  accounting.
+- The WASM runtime proves the same state output through a LinuxCNC-owned
+  boundary. A `USER_M_COMMAND` event alone is not sufficient.
+
+Browser proof:
+
+- The browser smoke calls the already validated SDK/WASM boundary.
+- The test labels the row as a millturn process-boundary representative only
+  after the state proof exists. It must not claim full LinuxCNC HAL/task/UI
+  process coverage.
+
+## Tool Database Boundary
+
+### Current Block
+
+`axis/db_demo/base.ngc` is blocked because `db_nonran.ini` declares:
+
+```text
+[EMCIO]
+RANDOM_TOOLCHANGER = 0
+DB_PROGRAM = ./db_nonran.py
+```
+
+The INI explicitly notes that `TOOL_TABLE` is not used with `DB_PROGRAM`.
+Standalone interpreter file execution would therefore bypass the tool database
+startup, command/reply protocol, and persistent database state.
+
+### LinuxCNC Owner Set
+
+- `configs/sim/axis/db_demo/db_nonran.ini` owns the DB program declaration.
+- `configs/sim/axis/db_demo/db.py` owns the demo database behavior.
+- `src/emc/task/taskclass.cc` owns reading `[EMCIO]DB_PROGRAM`, enabling DB
+  mode, calling `tooldata_db_init()`, loading tooldata, and notifying DB state
+  changes during tool load/unload paths.
+- `src/emc/tooldata/tooldata_db.cc` owns child process startup, pipe setup,
+  version handshake, `g` get-all requests, and `l`/`u`/`p` notifications.
+- `src/emc/tooldata/tooldata_common.cc` owns common tooldata storage and DB
+  refresh behavior.
+
+### Native Behavior To Preserve
+
+`tooldata_db_init()` splits `DB_PROGRAM` into argv, verifies that the program is
+executable, forks it, connects stdin/stdout pipes, and waits for the version
+reply `v2.1`. `tooldata_db_getall()` sends `g`, resets local tooldata, reads
+tool lines until `FINI`, and calls `tooldata_read_entry()` for each line.
+
+`tooldata_db_notify()` sends:
+
+- `l ...` for `SPINDLE_LOAD`;
+- `u ...` for `SPINDLE_UNLOAD`;
+- `p ...` for `TOOL_OFFSET`.
+
+The demo `db.py` uses LinuxCNC's `tooldb` module with callbacks for:
+
+- `user_get_tool`;
+- `user_put_tool`;
+- `user_load_spindle_nonran_tc` or `user_load_spindle_ran_tc`;
+- `user_unload_spindle_nonran_tc` or `user_unload_spindle_ran_tc`.
+
+It maintains a persistent flat-file database, updates tool usage minutes, and
+can call `linuxcnc.command().load_tool_table` to synchronize changes back to
+LinuxCNC. Those details are DB process behavior, not interpreter file
+execution behavior.
+
+### Boundary Decision
+
+This row remains `L4-TOOL-DB`. A standalone adapter that merely loads a
+fallback `.tbl` file would be wrong for this config because DB mode explicitly
+replaces the tool table file path.
+
+### Current Machine-Readable Artifact
+
+`tool-db-process-boundary-summary.tsv` records the current designed-but-blocked
+protocol and state target set for this boundary. It records `DB_PROGRAM =
+./db_nonran.py`, the LinuxCNC tooldata protocol messages `v2.1`, `g`, `l`, `u`,
+and `p`, the demo DB callbacks `user_get_tool`, `user_put_tool`,
+`user_load_spindle_nonran_tc`, and `user_unload_spindle_nonran_tc`, and the
+nonrandom database state targets such as `T10..T19`, `/tmp/db_nonran_file`,
+`tno+100` startup pockets, and pocket-0 spindle load/unload behavior.
+`tool-db-process-protocol-gates.tsv` is the normalized companion table for
+that evidence. It splits the blocked DB boundary into pending protocol-message,
+DB-program-callback, and state-target gates, including the `v2.1` startup
+reply, `g` get-all through `FINI`, `l`/`u`/`p` notifications, demo callback
+registration, ignored `TOOL_TABLE`, startup tools, nonrandom pocket mapping,
+and persistence/sync targets. The current table keeps `proof_status=pending`,
+`execution_enabled=0`, and `promotion_allowed=0`.
+`tool-db-process-transaction-plan.tsv` records the next non-executing contract
+for this boundary. It orders the pending DB protocol into startup handshake,
+initial get-all, spindle load notify, tool offset notify, and spindle unload
+notify steps. Each step binds one LinuxCNC protocol message to the expected
+`db.py` callback, required native/Node/browser proof, and source-traceable
+state targets. This is still a transaction contract only; it does not start
+`DB_PROGRAM`, run Python, mutate `/tmp/db_nonran_file`, fall back to a tool
+table, or permit standalone/browser promotion.
+`tool-db-process-native-protocol-alignment.tsv` aligns those generated gates
+with the native source probe stdout keys, such as `tool_db_v2_1_handshake`,
+`tool_db_getall_g_until_fini`, `tool_db_notify_l_u_p_protocol`, and
+`tool_db_program_nonran_state_targets`. This table proves the generated gates
+still match LinuxCNC-owned task/tooldata/config evidence, but it also remains
+`proof_status=pending`, `execution_enabled=0`, and `promotion_allowed=0`.
+`tool-db-process-native-runtime-readiness.tsv` records whether the host has
+the runtime pieces needed to attempt a DB process protocol probe. It checks
+`python3`, `linuxcnc`, `milltask`, `halcmd`, the configured
+`axis/db_demo/db_nonran.py` program, and the LinuxCNC Python `linuxcnc.so` and
+`tooldb.py` modules. It records PATH/source evidence where available and keeps
+the DB boundary blocked with `proof_status=pending`, `execution_enabled=0`,
+and `promotion_allowed=0`.
+`tests/native/probe_tool_db_runtime.sh` is wired into `build_native_probes.sh`
+as `linuxcnc_tool_db_runtime_probe`. On hosts without the required DB runtime
+commands it exits successfully with `tool_db_runtime_probe_status =
+skipped_missing_host_runtime`; on a ready host it remains disabled by default.
+If explicitly enabled with `ENABLE_TOOL_DB_RUNTIME_PROBE=1`, it starts the
+vendored `DB_PROGRAM`, drives the LinuxCNC `tooldb.py` `v2.1`/`g`/`p`/`l`/`u`
+protocol over stdin/stdout, verifies nonrandom `T10..T19` startup state, tool
+update, spindle load/unload, and flat-file persistence, then reports
+`runtime_protocol_probe_passed`.
+
+The artifact keeps `execution_enabled=0` and `promotion_allowed=0`. It is not
+a standalone tool database executor, does not replace `DB_PROGRAM` with a
+fallback `.tbl`, and does not make `axis/db_demo/base.ngc` a Node/browser
+representative.
+
+`linuxcnc_tool_db_boundary_probe` is the current native guard for this
+evidence. It reads the LinuxCNC source `db_nonran.ini`, `db.py`,
+`src/emc/task/taskclass.cc`, and `src/emc/tooldata/tooldata_db.cc`, then
+verifies the DB mode owner path, child-process protocol, `v2.1` startup
+handshake, `g`/`FINI` get-all path, `l`/`u`/`p` notifications, demo DB
+callbacks, and nonrandom state targets. This is a source/protocol-target proof
+only: it does not start `DB_PROGRAM`, run the Python tooldb loop, mutate the
+flat-file database, or permit promotion.
+
+### Candidate Boundary
+
+A valid future boundary should be a narrow tool-database host adapter:
+
+1. Reuse `tooldata_db.cc` and `tooldata_common.cc` for DB mode behavior.
+2. Isolate the process-spawn edge behind a host abstraction so native can spawn
+   the configured DB program, while WASM/browser use an explicitly designed
+   equivalent only if it preserves the LinuxCNC protocol.
+3. Preserve the `v2.1`, `g`, `l`, `u`, and `p` command/reply protocol rather
+   than parsing or inventing tool semantics in JavaScript.
+4. Treat `db.py` as a config-owned process dependency. If it is not executable
+   in a target layer, that layer remains blocked.
+
+### Required Proof Before Promotion
+
+Native proof:
+
+- The existing `linuxcnc_tool_db_boundary_probe` source/protocol guard must
+  continue to prove that the pending DB gates come from LinuxCNC task/tooldata
+  and demo DB sources rather than project-owned behavior.
+- A probe starts `db_nonran.py` through the LinuxCNC DB path and verifies the
+  `v2.1` handshake.
+- A get-all request returns the expected nonrandom startup tools.
+- A load/unload or update path changes DB state through `l`, `u`, or `p` and
+  is reflected by a subsequent get-all.
+
+Node WASM proof:
+
+- The same protocol is visible through the SDK boundary.
+- Tool lookup/update behavior matches the native proof without staging a fake
+  `.tbl` replacement.
+
+Browser proof:
+
+- Browser validation calls the Node-proven SDK/WASM boundary.
+- OPFS may store DB files only as host persistence. It must not implement DB
+  command semantics.
+
+## Python-Remap Inventory Boundary
+
+Python-remap rows remain inventory-only. The current
+`blocked-dependency-summary.tsv` records Python modules, remap/prolog/epilog
+functions, NGC-only subpaths, and HAL/UI/HALUI declarations.
+`python-remap-boundary-summary.tsv` preserves the same evidence per blocked
+path and records LinuxCNC Python runtime owner evidence from
+`src/emc/rs274ngc/interp_python.cc` and
+`src/emc/pythonplugin/python_plugin.cc`. `python-remap-family-summary.tsv`
+aggregates it by runtime family so mixed Python/NGC-only subpaths remain
+visible without promoting execution. No Python-remap row should be promoted
+until a separate LinuxCNC-owned Python runtime boundary exists and has native
+plus Node/browser proof appropriate to the target layer.
+`python-remap-runtime-gates.tsv` expands each blocked path into Python module,
+remap/prolog/epilog callable, NGC-only subpath, process-assumption, and
+runtime-owner gates. `python-remap-native-runtime-alignment.tsv` aligns those
+generated gates with the current native source probe stdout. Runtime owner
+gates map to exact LinuxCNC runtime proof keys such as
+`python_runtime_pycall_dispatch` and `python_plugin_callable_invoke`; dependency
+inventory gates map to representative family inventory proof or the aggregate
+`python_remap_native_source_inventory_proof`. Both tables remain
+`proof_status=pending`, `execution_enabled=0`, and `promotion_allowed=0`.
+`python-remap-runtime-contract.tsv` records the next non-executing family-level
+contract. It keeps one row per blocked Python-remap family, records the
+LinuxCNC-owned Python runtime phases (`initialize_python`,
+`apply_ini_python_path`, `execute_toplevel`, callable lookup/invoke,
+remap-phase dispatch, generator finish, execute-string/file, and reload),
+aggregates Python modules/callables/NGC-only subpaths, carries HAL/UI/HALUI
+process assumptions, and binds each family to native, Node, and browser proof
+requirements. It is a runtime contract only: it does not initialize Python,
+import modules, execute callbacks, or permit promotion.
+`python-remap-native-runtime-readiness.tsv` records the current host/source
+readiness for future native Python-remap runtime probes. It checks `python3`,
+`linuxcnc`, the LinuxCNC interpreter/plugin owner source files, and each
+configured Python module by blocked runtime family. The artifact remains a
+gate only: every row stays `proof_status=pending`, `execution_enabled=0`, and
+`promotion_allowed=0`.
+`python-remap-native-runtime-state-plan.tsv` records the non-executing runtime
+state plan for those future probes. It binds each blocked Python-remap family
+to the required LinuxCNC Python phases, configured modules, callables,
+NGC-only subpaths, process assumptions, readiness counts, source-alignment
+artifacts, and future native proof targets. It does not initialize Python,
+import modules, execute callbacks, or permit promotion.
+`python-remap-native-runtime-fixture-plan.tsv` selects the first native runtime
+fixture target, `axis/remap/stop-lookahead/nc_files`. That family is the
+smallest current Python runtime lifecycle candidate because it needs the
+LinuxCNC Python initialization/path/toplevel/runtime phases and configured
+modules but avoids Python callable and NGC-only subpath complexity. The
+fixture plan is still non-executing: it records the proof target only and
+keeps `proof_status=pending`, `execution_enabled=0`, and
+`promotion_allowed=0`.
+`tests/native/probe_python_remap_runtime.sh` is wired into
+`build_native_probes.sh` as `linuxcnc_python_remap_runtime_probe`. It records
+the stop-lookahead fixture identity, configured Python modules, required
+LinuxCNC Python runtime phases, host command readiness, and source/module
+availability. On hosts without `linuxcnc`, it exits successfully but reports
+`python_remap_runtime_probe_status=skipped_missing_host_runtime`; on hosts with
+the runtime available it remains disabled by default. If explicitly enabled
+with `ENABLE_PYTHON_REMAP_RUNTIME_PROBE=1`, it follows the `demo.ini`
+`[PYTHON]` path/toplevel declarations, imports the vendored stop-lookahead
+modules, verifies `queuebuster` callable lookup, confirms the callable returns
+a generator, and checks that the first yield is the LinuxCNC
+`INTERP_EXECUTE_FINISH` value from `interp_return.hh` before reporting
+`runtime_lifecycle_probe_passed`.
+
+`linuxcnc_python_remap_boundary_probe` is the current native guard for this
+inventory. It reads the LinuxCNC Python runtime owners and representative
+config families (`axis/laser`, `axis/remap/cycle`, TWP nutating, and
+`gmoccapy` stdglue), then verifies the runtime dispatch/phase/callable owner
+evidence plus representative Python modules, remap callables, prolog/epilog
+callables, and Python path declarations. This is source inventory only: it
+does not initialize Python, import modules, execute remap callbacks, or permit
+promotion.
+
+## Next Boundary Worklist
+
+`next-boundary-worklist.tsv` is the machine-readable handoff for the next
+runtime-boundary design phase. It is a planning artifact only: every row keeps
+`execution_enabled=0` and `promotion_allowed=0`, records the LinuxCNC owner set,
+records runtime owner evidence, records required native, Node, and browser
+proof, and names the next boundary-design action before promotion.
+
+`boundary-proof-gates.tsv` is the machine-readable proof checklist derived from
+that worklist. It expands every target into native, Node, and browser proof
+rows and keeps each row at `proof_status=pending`, `execution_enabled=0`, and
+`promotion_allowed=0`. It must fail validation if a future edit tries to
+promote a target without first replacing the pending gate with LinuxCNC-owned
+proof for that layer. For the current blockers, event-only `USER_M_COMMAND`
+coverage is insufficient for `millturn`, `.tbl` fallback coverage is
+insufficient for `db_demo`, and JavaScript-owned behavior is insufficient for
+Python runtime families.
+
+`native-proof-alignment-summary.tsv` records whether the native source proof
+summary, when present, is consumed by generated worklist and native proof-gate
+rows. It currently aligns the `millturn` user-M source-state proof, `db_demo`
+tool database protocol source proof, and Python runtime source-inventory proof
+without enabling execution or promotion.
+`runtime-boundary-native-alignment-summary.tsv` is the aggregate guard for the
+detailed native alignment artifacts. It requires every user-M, tool DB, and
+Python alignment row to have native stdout evidence, `alignment_ok=1`,
+`proof_status=pending`, `execution_enabled=0`, and `promotion_allowed=0`.
+`build/native/native-runtime-probe-summary.tsv` is the native companion for the
+disabled runtime probe entry points. It summarizes the current runtime
+readiness for `millturn` user-M, `db_demo` tool DB, and the Python
+stop-lookahead fixture, records the missing host runtime requirements, points
+back to each probe stdout log, and keeps every row at `execution_enabled=0` and
+`promotion_allowed=0`.
+`runtime-boundary-contract-summary.tsv` is the aggregate guard for the
+non-executing runtime contracts. It ties the `millturn` user-M transition
+contract, `db_demo` tool DB transaction contract, and Python-remap family
+runtime contract to their native-alignment artifacts, and requires every
+contract row to remain pending with execution and promotion disabled.
+`blocked-runtime-promotion-lock.tsv` is the final machine-readable lock for
+this phase. It combines the worklist, native/Node/browser proof gates, and
+runtime alignment summary so every blocked target has `lock_active=1` until a
+LinuxCNC-owned runtime boundary replaces the pending gates.
+
+The first two priorities are the current designed-but-disabled full-process
+blocks:
+
+1. `external_user_m_process` for `axis/vismach/millturn/example.ngc`;
+2. `tool_database_process` for `axis/db_demo/base.ngc`.
+
+Python runtime family rows follow as inventory-only targets. They must remain
+behind a LinuxCNC-owned Python runtime boundary and must not be used to vendor
+or execute `gmoccapy`, `axis/laser`, TWP nutating, or other Python-remap
+families by path alone.
+
+## Current Validation
+
+These commands must continue to pass after any change to this document or to
+the inventory code:
+
+```bash
+wasm-port/tests/wasm/node/verify_sim_configs_wasm.sh
+wasm-port/tests/wasm/node/verify_sim_configs_inventory_wasm.sh
+wasm-port/tests/browser/verify_interp_browser.sh
+wasm-port/tests/host/verify_host_smokes.sh
+wasm-port/tools/verify_vendor_sync.sh
+wasm-port/tools/verify_no_standalone_cnc_semantics.sh
+```
diff --git a/wasm-port/docs/linuxcnc-test-porting-tracker.md b/wasm-port/docs/linuxcnc-test-porting-tracker.md
index 068de3c..8b501ee 100644
--- a/wasm-port/docs/linuxcnc-test-porting-tracker.md
+++ b/wasm-port/docs/linuxcnc-test-porting-tracker.md
@@ -48,13 +48,14 @@ wasm-port/tests/host/verify_host_smokes.sh
 | Reject standalone CNC semantics | Done | `tools/verify_no_standalone_cnc_semantics.sh` guards project-owned `Interp::...` definitions outside documented runtime-edge stubs. |
 | Maintain source reuse map | Done | Current sim-config, remap, interpreter, kinematics, TP, user-M, tool, named-parameter, and OPFS runtime boundaries are recorded in `docs/source-reuse-map.md`; keep updating it whenever LinuxCNC source, test assets, or runtime boundaries are added. |
 | Maintain compatibility validation notes | Done | Current native, Node WASM, browser, OPFS, and host aggregate checks are recorded in `docs/compatibility-validation.md`; keep updating it whenever a validation command or fixture class is added. |
+| Maintain sim-config coverage matrix | Done | `docs/sim-configs-coverage-matrix.md` now maps all current `verify_sim_configs.sh` records to program class, native result, current Layer 3/4 coverage, and blocked/class-coverage notes. The native harness emits `class-summary.tsv` and `path-matrix.tsv`, and the Node inventory runner checks generated/tracked path sets plus tracked class/native-status/expected-failure/blocked fields against native outputs before execution. Future changes should update the matrix only with a matching regenerated native inventory. |
 | Document validation layers | Done | `docs/compatibility-validation.md` now records Layer 1 `nc_files` basic smoke, Layer 2 `configs/sim` native strict harness, Layer 3 standalone native runtime probes, and Layer 4 WASM Node/browser representative smokes with entry commands, current results, expected boundaries, and the no-LinuxCNC-semantics rule. |
 | Build LinuxCNC test inventory | In progress | `linuxcnc/tests/remap` has been inventoried by dependency class; the first broader `linuxcnc/tests` pass now records full-process, HAL/realtime, linuxcncrsh, Python-binding, and external-component families in the blocked table. |
 | Prefer pure interpreter tests first | In progress | Continue with tests that can run through `Interp::open()`, `read()`, and `execute()` without realtime hardware or GUI. |
 | Add upstream-output comparison | In progress | Use upstream `../linuxcnc/bin/rs274` or original `test.sh` output where practical, then compare against native/WASM/browser output. |
 | Promote tests through three layers | In progress | Add each selected test first to native harnesses, then WASM Node, then browser smoke where meaningful. |
 | Record blocked tests | In progress | First broader family-level blocked batch is recorded below; continue expanding it as each `linuxcnc/tests` family is inspected. |
-| Add aggregate smoke coverage | Done | `tests/host/verify_host_smokes.sh` now runs stable Node WASM, sim-config WASM, `nc_files` WASM, OPFS, and browser smoke checks with shared builds. Current run passed with `host_wasm_opfs_browser_smokes=ok`. |
+| Add aggregate smoke coverage | Done | `tests/host/verify_host_smokes.sh` now runs stable Node WASM, sim-config representative WASM, sim-config Node inventory, `nc_files` WASM, OPFS, and browser smoke checks with shared builds. Current run passed with `host_wasm_opfs_browser_smokes=ok`. |
 | Add `linuxcnc/nc_files` basic examples | Done | `tests/native/verify_nc_files.sh` now runs the basic/example subset of upstream `linuxcnc/nc_files` through LinuxCNC `bin/rs274`; current native baseline is 107 total, 101 pass, 6 expected context/entry-point edges, 0 unexpected failures. Exploratory `--all` inventory is 247 total, 219 pass, 28 expected context/entry-point edges, 0 unexpected failures. A representative vendored subset now passes Node WASM and browser execution through LinuxCNC-backed `Interp::open()`/`read()`/`execute()`, with `3D_Chips.ngc` using an INI-declared tool-table context for its upstream `T1 M6` line. |
 
 ## Current Review Boundaries
@@ -132,6 +133,10 @@ directories under `wasm-port/vendor/linuxcnc/tests/interp/` including
 | `configs/sim/axis/foam/foam.ngc` | Done | Native, WASM Node, browser | Vendored under `wasm-port/vendor/linuxcnc/configs/sim/axis/foam`; validates LinuxCNC INI-driven `U/V` axis mask handling through `axis_foam.ini` and vendored file execution paths. |
 | `configs/sim/axis/geometry/xyzc.ngc` | Done | Native, WASM Node, browser | Vendored under `wasm-port/vendor/linuxcnc/configs/sim/axis/geometry`; validates LinuxCNC `USER_M_PATH` registration with the real executable `M110` while process execution remains a deterministic standalone `USER_M_COMMAND` boundary. |
 | `configs/sim/axis/external_offsets/*.ngc` M111 demos | Done | Native, WASM Node, browser | Vendored under `wasm-port/vendor/linuxcnc/configs/sim/axis/external_offsets`; validates `dyn_demo.ngc`, `eoffsets.ngc`, `jwp_z.ngc`, and `opa_demo.ngc` with their corresponding INI files, real executable `M111`, shared `eoffset.tbl`, and `opa_demo.ngc`'s `circles.ngc` subroutine while process execution remains a deterministic standalone boundary. |
+| `configs/sim/axis/gladevcp/probe.ngc` | Done | Native, WASM Node, browser | Vendored under `wasm-port/vendor/linuxcnc/configs/sim/axis/gladevcp`; validates plain INI/tool-table main-program staging through `gladevcp_panel.ini` without treating the GTK panel process as browser runtime. |
+| `configs/sim/axis/vismach/melfa-sim/example.ngc` | Done | Native, WASM Node, browser | Vendored under `wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim`; validates a robot/Genser-style remap machine representative through real INI, tool table, and M428/M429/M430 remap subroutines while GUI/HAL process launch remains outside the standalone boundary. |
+| `configs/sim/axis/vismach/puma/puma_cube.ngc` | Done | Native, WASM Node, browser | Vendored under `wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma`; validates a PUMA machine-context representative through real INI, tool table, and remap subroutine staging while external GUI/HAL process launch remains outside the standalone boundary. |
+| `configs/sim/woodpecker/on_abort.ngc` | Done | Native, WASM Node, browser | Vendored under `wasm-port/vendor/linuxcnc/configs/sim/woodpecker`; validates deterministic `on_abort` file execution through the real machine INI and tool table without expanding browser coverage to unrelated full-process UI flows. |
 | More `tests/remap/*` interpreter-only cases | Planned | Native first | Select cases that do not require Python behavior beyond documented runtime-edge stubs unless the required LinuxCNC source path is ported. |
 | More `tests/interp/*` interpreter-only cases | Planned | Native first | Select upstream interpreter cases that can run through vendored file execution without Python, HAL, realtime motion, or GUI. |
 | `tests/rs274ngc/*` candidates | Planned | Native first | Use upstream `rs274` as the baseline where output is comparable. |
@@ -192,6 +197,15 @@ Use this checklist when adding each LinuxCNC upstream test:
 | `tests/trajectory-planner/circular-arcs` | Blocked | Full LinuxCNC sim configs with task, HAL/Tcl files, GUI/display settings, and motion execution logs. | Keep using standalone TP API probes for planner code; full circular-arc machine tests require task/HAL/motion boundaries. |
 | `tests/lowlevel/emcmot-error-mpsc` | Blocked | RIP-only build against LinuxCNC motion sources and low-level motion error driver. | Revisit only if low-level motion process test drivers are intentionally ported. |
 | `tests/uspace/spawnv-root` | Blocked | Sudo-installed userspace HAL component and `spawnv` root behavior. | Keep upstream-only unless HAL component install/runtime support is added. |
+| `configs/sim/*/remap_subs/*.ngc` browser main-program inventory | Blocked | These files are remap/subroutine assets, not standalone browser main-program targets. | Keep validating them through native remap parse/execute paths and explicit five-axis/runtime probes instead of widening browser `runSimConfigProgram()` blindly. |
+| `configs/sim/axis/db_demo/base.ngc` Layer 4 inventory | Blocked | `[EMCIO]DB_PROGRAM = ./db_nonran.py` requires LinuxCNC task/tooldata DB process startup, command/reply protocol, and database state behavior, not standalone interpreter file execution. | Keep as `L4-TOOL-DB` until a LinuxCNC-owned tool database runtime boundary exists and proves lookup/update behavior across native and WASM. `blocked-dependency-summary.tsv` records `taskclass.cc`, `tooldata_db.cc`, `tooldata_common.cc`, and `configs/sim/axis/db_demo/db.py` as the owner set plus source-derived `tool_db_protocol_evidence` for the `v2.1` handshake, `g`/`FINI` get-all, and `l`/`u`/`p` notification protocol. |
+| `configs/sim/axis/vismach/millturn/example.ngc` Layer 4 inventory | Blocked | The remap execution chain calls external `USER_M_PATH` process codes `M128` and `M129`, with HAL/HALUI/UI process declarations in `millturn.ini`. | Keep as `L4-USER-M-PROCESS`; do not promote until the M128/M129 LinuxCNC-owned state boundary proves the kinstype guard and `ini.[xyz].*` HAL pin updates. `blocked-dependency-summary.tsv` records the `mcodes/M128` and `mcodes/M129` Tcl scripts plus source-derived `user_m_process_effects` for Tcl/HAL runtime use, kinstype guards, and `ini.[xyz]` HAL pin side effects. |
+| `configs/sim/gmoccapy/*` Layer 4 full inventory | Blocked | Python remap runtime boundary is present in native LinuxCNC `rs274`, but not yet intentionally exposed for Node/browser full inventory. | Keep native inventory coverage as source-of-truth; add one representative Node/browser class sample only after the Python remap boundary is deliberately designed. Python module and prolog/epilog ownership is inventoried in `blocked-dependency-summary.tsv`; LinuxCNC runtime ownership is recorded as `python_runtime_evidence` in the Python boundary/family summaries. |
+| `configs/sim/axis/laser/*` Layer 4 full inventory | Blocked | Python remap runtime boundary is present in native LinuxCNC `rs274`, but not yet intentionally exposed for Node/browser full inventory. | Keep native inventory coverage as source-of-truth; add one representative Node/browser class sample only after the Python remap boundary is deliberately designed. Python module and remap ownership is inventoried in `blocked-dependency-summary.tsv`; LinuxCNC runtime ownership is recorded as `python_runtime_evidence` in the Python boundary/family summaries. |
+| `configs/sim/axis/remap/*/nc_files/*.ngc` Layer 4 full inventory | Blocked | Native LinuxCNC `rs274` coverage exists, but these demo main programs depend on Python remaps, Python prolog/epilog callbacks, or Python-backed queue/tool-change handlers. | Keep native inventory coverage as source-of-truth; do not reduce Python remap demos to missing vendored files or browser standalone execution until the Python remap boundary is deliberately designed. Dependency ownership is inventoried in `blocked-dependency-summary.tsv`; LinuxCNC runtime ownership is recorded as `python_runtime_evidence` in the Python boundary/family summaries. |
+| `configs/sim/axis/vismach/5axis/table-rotary_spindle-rotary-nutating/demos/*` Layer 4 full inventory | Blocked | Native LinuxCNC `rs274` coverage exists, but the demo family depends on Python remap entry points such as `g682`, `g69_core`, and `g53x_core` that are not yet intentionally exposed for Node/browser inventory. | Keep native inventory coverage as source-of-truth; revisit Layer 4 only after the Python remap boundary is deliberately designed rather than faked in JS. Python and NGC remap dependencies are inventoried in `blocked-dependency-summary.tsv`; LinuxCNC runtime ownership is recorded as `python_runtime_evidence` in the Python boundary/family summaries. |
+| `configs/sim/axis/vismach/VMC_toolchange/toolchange.ngc` Layer 4 full inventory | Blocked | Native LinuxCNC `rs274` coverage exists, but the program is the remapped tool-change body for a Python prolog/epilog and full tool-change/HAL process flow. | Keep native inventory coverage as source-of-truth and validate tool-change mechanics through existing standalone interpreter/tooldata probes until task/HAL/tool-change runtime boundaries exist. |
+| `configs/sim/axis/vismach/5axis/table-rotary_spindle-rotary-nutating/demos/incremental_repetition_g533.ngc` | Blocked | Preserved upstream demo edge: line uses bare `X/Y/Z` after `G53.6` without an explicit motion G-code in the upstream standalone baseline. | Keep as expected failure in Layer 2 and do not modify G-code or project-owned interpreter semantics to force a pass. |
 
 ## Next Work Batch
 
diff --git a/wasm-port/docs/sim-configs-completion-plan.md b/wasm-port/docs/sim-configs-completion-plan.md
index 6e9c4d5..dac3aa3 100644
--- a/wasm-port/docs/sim-configs-completion-plan.md
+++ b/wasm-port/docs/sim-configs-completion-plan.md
@@ -16,6 +16,8 @@ Result file:
 
 ```text
 wasm-port/build/native/sim-configs/summary.tsv
+wasm-port/build/native/sim-configs/class-summary.tsv
+wasm-port/build/native/sim-configs/path-matrix.tsv
 ```
 
 Baseline:
@@ -50,19 +52,52 @@ Remaining failures are explicit LinuxCNC-native baseline edges:
 
 ## Target
 
-The first target is not a browser UI feature. It is a repeatable native and
-WASM simulation harness that can load and execute all `linuxcnc/configs/sim`
-programs that are meaningful in a standalone non-hardware simulation context.
+The first target is not a browser UI feature and not a requirement that every
+`linuxcnc/configs/sim` `.ngc` program pass through standalone `bin/rs274`.
+It is a repeatable native and WASM inventory that classifies every
+`configs/sim` program, runs the entries that are meaningful in standalone
+native/WASM/browser contexts, and records blocked dependencies for the entries
+that require full LinuxCNC task, HAL, UI, Python-remap, or external process
+runtime.
 
 Acceptance criteria:
 
-- The native sim-config harness reports all executable sim programs as `PASS`.
+- The native sim-config harness reports `unexpected_fail: 0` and writes
+  `summary.tsv`, `class-summary.tsv`, and `path-matrix.tsv`.
 - Macro/remap files are validated by the correct entry point: direct execution
   only for real programs, load/parse or remap-call validation for subroutines.
-- WASM tests cover the same representative classes after the native harness is
-  green.
-- Any remaining unsupported files are explicitly classified as native GUI or
-  hardware-only and excluded by rule, not by accident.
+- Node WASM inventory executes only entries with a defined standalone/WASM
+  runtime path and reports `unexpected_fail: 0`.
+- Browser coverage remains focused on representative runtime classes rather
+  than blind full-directory execution.
+- Any remaining unsupported files are explicitly classified by dependency, not
+  by accident.
+
+## Definition Of Done For Full configs/sim Coverage
+
+Full coverage for this project means:
+
+- Inventory complete: every `summary.tsv` `.ngc` entry appears in
+  `docs/sim-configs-coverage-matrix.md` and generated `path-matrix.tsv`.
+- Classification complete: every entry has `main`, `macro_load`, or
+  `remap_subroutine` class.
+- Blocked table complete: full-process, HAL, UI, linuxcncrsh, external
+  userspace component, Python binding/remap, tool-database, and process user-M
+  dependencies are recorded explicitly.
+- Native source-of-truth complete: `verify_sim_configs.sh` remains the Layer 2
+  source for per-path status and expected-failure reason.
+- Node inventory complete: `verify_sim_configs_inventory_wasm.sh` checks the
+  native/generated/tracked path sets, runs eligible vendored programs, and
+  emits stable WASM inventory and skip/block summaries.
+  Any eligible row with missing vendored machine context is an inventory
+  failure, not an expected skip.
+- Browser class coverage complete: each promoted browser class has a
+  representative sample and no browser test relies on directory enumeration.
+- Expected failures justified: the current eight Layer 2 expected failures are
+  tied to runtime boundaries or the preserved upstream demo edge.
+- No accidental standalone semantic ownership: tests must not pass by changing
+  G-code semantics, JS interpreter behavior, or project-owned
+  `Interp::...` implementations.
 
 ## Phase 1: Make The Harness A First-Class Test
 
@@ -80,7 +115,8 @@ validation entry point.
    - scan only `linuxcnc/configs/sim`;
    - identify `.ngc`, nearest `.ini`, nearest `.tbl`;
    - run from the INI directory;
-   - write `summary.tsv`, stdout, stderr, and interpreter output under
+   - write `summary.tsv`, `class-summary.tsv`, `path-matrix.tsv`, stdout,
+     stderr, and interpreter output under
      `wasm-port/build/native/sim-configs/`;
    - classify programs as `main`, `macro_load`, `remap_subroutine`, or
      `unsupported_runtime_edge`;
@@ -252,71 +288,61 @@ wasm-port/tests/native/verify_native_probes.sh
 wasm-port/tests/wasm/node/verify_interp_wasm.sh
 ```
 
-## Phase 4: Bring Up Python Remap Runtime Edges
+## Phase 4: Classify Python Remap Runtime Edges
 
-Status: complete for the native sim-config harness. Current checks:
+Status: complete for the native sim-config harness and blocked for Layer 4
+full inventory. Current native checks:
 
 ```text
 gmoccapy:   total 38, pass 38, fail 0
 axis/laser: total 3,  pass 3,  fail 0
+axis/remap main demos: total 6, pass 6, fail 0
+VMC_toolchange: total 1, pass 1, fail 0
 ```
 
-Root cause:
+Boundary:
 
-The configs use LinuxCNC Python remap modules. Earlier harness runs failed while
-initializing `python/toplevel.py`; current native runs now resolve and execute
-these configs under the LinuxCNC `rs274` baseline.
+The configs use LinuxCNC Python remap modules. Native LinuxCNC `rs274` can
+resolve and execute these configs under the current baseline, but Node/browser
+Layer 4 full inventory is intentionally blocked until a Python-remap runtime
+boundary is deliberately designed. Do not make these pass in browser by
+translating Python remap behavior into JavaScript or by adding project-owned
+CNC semantics.
 
-Implementation steps:
+Recorded dependency:
 
-1. Preserve upstream behavior where possible:
+- `configs/sim/gmoccapy/python/toplevel.py`
+- `configs/sim/gmoccapy/python/remap.py`
+- `configs/sim/gmoccapy/python/stdglue.py`
+- `configs/sim/axis/laser/python/toplevel.py`
+- `configs/sim/axis/laser/python/remap.py`
+- `configs/sim/axis/remap/*/python/*.py` for Python remap, prolog, epilog,
+  queue, and tool-change callbacks.
+- `configs/sim/axis/vismach/VMC_toolchange/remap.py` and `toplevel.py` for
+  Python tool-change prolog/epilog handling.
 
-   - inspect vendored LinuxCNC Python plugin interfaces;
-   - identify exact APIs used by:
-     - `configs/sim/gmoccapy/python/toplevel.py`
-     - `configs/sim/gmoccapy/python/remap.py`
-     - `configs/sim/gmoccapy/python/stdglue.py`
-     - `configs/sim/axis/laser/python/toplevel.py`
-     - `configs/sim/axis/laser/python/remap.py`
+Current policy:
 
-2. Split the implementation into two layers:
-
-   - native harness support using the host Python runtime, if available;
-   - WASM support using a documented adapter boundary or a Python-free
-     equivalent only for runtime edges, not G-code semantics.
-
-3. Add runtime state adapters required by Python remap:
-
-   - selected tool and pocket;
-   - tool table access;
-   - interpreter status object fields used by stdglue;
-   - message/error reporting;
-   - canonical tool-change side effects needed by `M6`, `M61`, and laser
-     remaps.
-
-4. Make Python module path resolution match LinuxCNC:
-
-   - INI directory is the base directory;
-   - `PYTHONPATH` includes config `python/` directories;
-   - remap modules load relative to the sim config.
-
-5. Add narrowly-scoped tests before running all 38 gmoccapy programs. Done:
-
-   - one gmoccapy tool-change macro;
-   - one gmoccapy lathe macro;
-   - one gmoccapy 5-axis example;
-   - one laser raster/vector program.
+- Keep native inventory as source-of-truth.
+- Mark `gmoccapy/*`, `axis/laser/*`, `axis/remap/*/nc_files/*.ngc`, and
+  `axis/vismach/VMC_toolchange/toolchange.ngc` rows as `L4-PYTHON-REMAP` in
+  `docs/sim-configs-coverage-matrix.md`.
+- Revisit Layer 4 only after the runtime boundary is designed from LinuxCNC
+  source ownership, not as a browser smoke expansion.
 
 Completion check:
 
 ```bash
 wasm-port/tests/native/verify_sim_configs.sh --only gmoccapy
 wasm-port/tests/native/verify_sim_configs.sh --only axis/laser
+wasm-port/tests/native/verify_sim_configs.sh --only axis/remap
+wasm-port/tests/native/verify_sim_configs.sh --only VMC_toolchange
 ```
 
-## Phase 5: Support TWP Remaps Including G69
+## Phase 5: Classify TWP Remaps Including G69
 
-Status: mapping complete. The harness now maps
+Status: native mapping complete and Layer 4 blocked on Python-remap runtime
+ownership. The harness now maps
 `axis/vismach/5axis/table-rotary_spindle-rotary-nutating/demos/*` through the
 explicit `xyzacb-trsrn_twp/xyzacb-trsrn.ini` machine config instead of falling
 back to `axis/axis.ini`. That loads the TWP `G69` remap declarations correctly,
@@ -329,7 +355,7 @@ Current failures:
   `x50y50z150` after `G53.6`; same-directory demos use explicit `G0` motion
   words at this point.
 
-Root cause:
+Boundary:
 
 The demo programs rely on table/spindle rotary TWP remaps. The original test
 mapping fell back to `axis/axis.ini` for these demo files because the actual
@@ -341,26 +367,15 @@ axis/vismach/5axis/table-rotary_spindle-rotary-nutating/
   xyzbca-trsrn_twp/xyzbca-trsrn.ini
 ```
 
-Implementation steps:
+Current policy:
 
-1. Improve sim-config mapping. Done:
-
-   - if a `.ngc` is under a `demos/` sibling of machine-specific INI
-     directories, map it to the appropriate TWP INI instead of walking upward
-     to `axis/axis.ini`;
-   - encode this as explicit metadata in the harness, not a fragile heuristic.
-
-2. Ensure `SUBROUTINE_PATH` includes `../remap_subs:../demos` as declared by
-   the TWP INIs.
-
-3. Verify remap subroutines:
-
-   - `g69remap.ngc`
-   - `g531remap.ngc`
-   - `g533remap.ngc`
-   - `g536remap.ngc`
-
-4. Add a native test for each failing demo.
+- Keep native mapping and expected-failure classification in
+  `verify_sim_configs.sh`.
+- Keep `incremental_repetition_g533.ngc` as `UPSTREAM-DEMO`; do not edit the
+  upstream G-code or add standalone semantics to force a pass.
+- Keep TWP demo Layer 4 rows as `L4-PYTHON-REMAP` until Python remap entry
+  points such as `g682`, `g69_core`, and `g53x_core` have an intentional
+  runtime boundary.
 
 Latest result:
 
@@ -380,13 +395,14 @@ Completion check:
 wasm-port/tests/native/verify_sim_configs.sh --only table-rotary_spindle-rotary-nutating
 ```
 
-## Phase 6: Promote Native Coverage To WASM
+## Phase 6: Promote Eligible Native Coverage To WASM
 
-Status: complete for representative Node and browser WASM coverage. Dedicated
-Node and browser smokes now pass a representative vendored `configs/sim` subset
-through the SDK `runSimConfigProgram()` host boundary, which copies files into
-the Emscripten filesystem and forwards execution to existing LinuxCNC-backed C
-ABI paths. They cover:
+Status: complete for the current representative Node/browser class coverage
+and the Node inventory layer. Dedicated Node and browser smokes now pass a
+representative vendored `configs/sim` subset through the SDK
+`runSimConfigProgram()` host boundary, which copies files into the Emscripten
+filesystem and forwards execution to existing LinuxCNC-backed C ABI paths. They
+cover:
 
 - `axis/foam/foam.ngc` with `axis_foam.ini`, verifying INI-driven `U/V` axis
   mask handling in WASM.
@@ -400,87 +416,214 @@ ABI paths. They cover:
   shared `eoffset.tbl`, and `opa_demo.ngc`'s `circles.ngc` subroutine,
   verifying the same user-M and `SUBROUTINE_PATH` boundaries against upstream
   sim programs.
+  The Node inventory guard keeps these deterministic `M110`/`M111` rows
+  unblocked, requires a vendored user-M file, and includes the `opa_demo.ngc`
+  `circles.ngc` subroutine text in boundary analysis so the reached `M111`
+  call is accounted for instead of being mistaken for an external user-M
+  process gap.
+- `axis/gladevcp/probe.ngc` as a plain INI/tool-table main-program sample.
+- `axis/external_offsets/circles.ngc` as the macro-load class representative,
+  wrapped only with an added `M2` for load/parse style execution.
+- `axis/vismach/5axis/table-dual-rotary/demos/xyzab-tdr-demo.ngc` and
+  `axis/vismach/5axis/table-rotary-tilting/demos/*` through the existing
+  five-axis remap execution C ABI.
+- `axis/vismach/melfa-sim/example.ngc` and `axis/vismach/puma/puma_cube.ngc`
+  as additional remap/kinematics machine representatives.
+- `woodpecker/on_abort.ngc` as the deterministic on-abort/user-action macro
+  class representative.
+- Node inventory for the eligible vendored program set:
+  `executed=28`, `passed=28`, `skipped=131`, `unexpected_fail=0`.
+- Node inventory skip/block summary:
+  `ASSET-ONLY=65`, `L4-PYTHON-REMAP=53`, `L4-TOOL-DB=1`,
+  `L4-USER-M-PROCESS=1`, `NON_MAIN_CLASS=10`, `UPSTREAM-DEMO=1`.
+- Node blocked-dependency inventory for the hard blocked row set:
+  `L4-PYTHON-REMAP=53`, `L4-TOOL-DB=1`, `L4-USER-M-PROCESS=1`.
+  The inventory reads source `linuxcnc/configs/sim` INI files for dependency
+  accounting only and writes
+  `build/wasm/sim-configs-inventory/blocked-dependency-summary.tsv` without
+  vendoring or executing those blocked families. The blocked summary includes
+  source-derived `user_m_process_effects` for `millturn`,
+  `tool_db_protocol_evidence` for `db_demo`, and Python module/remap/prolog/
+  epilog dependency ownership for Python-remap families. Python-remap rows are
+  also projected into
+  `build/wasm/sim-configs-inventory/python-remap-boundary-summary.tsv`, which
+  keeps all 53 `L4-PYTHON-REMAP` rows inventory-only with
+  `python_runtime_evidence` and `execution_enabled=0`.
+
+Boundary decisions for the current hard blocks:
+
+- `axis/vismach/millturn/example.ngc` remains `L4-USER-M-PROCESS`. The
+  source INI declares HAL, HALUI MDI, and UI process dependencies, and the
+  remap chain enters `remap_subs/428remap.ngc` and `429remap.ngc`, which call
+  external user-M process codes `M128` and `M129`. Those process scripts live
+  at `configs/sim/axis/vismach/millturn/mcodes/M128` and `M129`; they use Tcl
+  LinuxCNC/HAL packages, `emc_init`, `parse_ini`, `hal getp`, and `hal setp`
+  to change INI axis limit HAL pins after the kinematics switch. The current
+  LinuxCNC owner is therefore task user-M process dispatch plus HALUI/MDI and
+  the config-owned Tcl process scripts, not the standalone interpreter. Do not
+  promote this row until the boundary design in
+  `docs/full-process-boundary-design.md` has a deterministic state proof for
+  these HAL pin updates across native, Node, and browser. The Node inventory
+  guard requires this row to stay non-`REP` in Node and browser while it remains
+  `L4-USER-M-PROCESS`, and the generated inventory summary must keep it as
+  `SKIP` with that reason.
+- `axis/db_demo/base.ngc` remains `L4-TOOL-DB`. The source INI declares
+  `[EMCIO]DB_PROGRAM = ./db_nonran.py`, so standalone interpreter execution
+  would miss LinuxCNC tool-database process startup and protocol/state
+  behavior. The LinuxCNC owner is `src/emc/task/taskclass.cc` for DB_PROGRAM
+  activation, `src/emc/tooldata/tooldata_db.cc` for DB process startup and
+  command/reply protocol, `src/emc/tooldata/tooldata_common.cc` for DB-backed
+  tooldata behavior, and the config program `configs/sim/axis/db_demo/db.py`.
+  Do not promote until the boundary design in
+  `docs/full-process-boundary-design.md` has a LinuxCNC-owned tool database
+  boundary that proves lookup/update behavior across native and WASM. The Node
+  inventory guard requires this row to stay non-`REP` in Node and browser while
+  it remains `L4-TOOL-DB`, and the generated inventory summary must keep it as
+  `SKIP` with that reason.
+- Python-remap/full-process families remain `L4-PYTHON-REMAP`. The blocked
+  dependency inventory records Python modules, remap/prolog/epilog function
+  ownership, NGC remap subpaths, and HAL/UI/HALUI declarations for gmoccapy,
+  axis/laser, axis/remap demos, TWP nutating demos, and VMC tool-change
+  rows. The Python-specific boundary summary records the same row set as
+  inventory-only and requires a LinuxCNC-owned Python runtime boundary before
+  any promotion. Every `L4-PYTHON-REMAP` row must also remain `SKIP` with
+  `L4-PYTHON-REMAP` in the generated inventory summary. This is an inventory
+  artifact, not a Layer 4 execution path.
 
 Completion checks:
 
 ```bash
 wasm-port/tests/wasm/node/verify_sim_configs_wasm.sh
+wasm-port/tests/wasm/node/verify_sim_configs_inventory_wasm.sh
 wasm-port/tests/browser/verify_interp_browser.sh
 ```
 
-Remaining work:
+Current Layer 4 non-goals:
 
-1. Extend `runtime/core/linuxcnc_wrap/linuxcnc_interp_wasm.cpp` with the same
-   machine-config entry point used by native tests. Done for the existing
-   `runFileWithIni()` file-execution path.
+- Do not run all 159 programs in browser.
+- Do not promote Python remap/full-process/HAL/UI-only families into
+  Emscripten without LinuxCNC-owned runtime support.
+- Do not add JS-owned G-code, remap, tool, kinematics, parameter, or planner
+  semantics.
 
-2. Extend `runtime/sdk/src/linuxcnc-interp.js` with a host-boundary method such
-   as:
+Browser inventory decision record:
 
-   ```js
-   runSimConfigProgram({ iniPath, programPath, files })
-   ```
-
-   Done. The method only writes caller-provided text files into the
-   Emscripten filesystem, applies executable bits for user M-code files, and
-   forwards execution to the existing LinuxCNC-backed C ABI path. It does not
-   implement CNC semantics in JavaScript.
-
-3. Copy required sim config files into the Emscripten FS:
-
-   - INI;
-   - tool table;
-   - parameter file;
-   - `.ngc` program;
-   - `SUBROUTINE_PATH` files;
-   - `USER_M_PATH` handler files or registered adapter handlers.
-
-   Done for the representative Node and browser subsets.
-
-4. Add Node WASM coverage. Done:
-
-   ```text
-   wasm-port/tests/wasm/node/verify_sim_configs_wasm.mjs
-   wasm-port/tests/wasm/node/verify_sim_configs_wasm.sh
-   ```
-
-5. Add representative browser coverage. Done in
-   `wasm-port/tests/browser/interp_smoke.html` through the existing browser
-   interpreter smoke and the same `runSimConfigProgram()` SDK boundary as Node.
+- Promoted after Node inventory: plain INI/tool-table execution
+  (`axis/gladevcp/probe.ngc`), deterministic macro/load execution
+  (`axis/external_offsets/circles.ngc`), deterministic on-abort/user-action
+  execution (`woodpecker/on_abort.ngc`), TDR/TRT five-axis remap execution,
+  bridge-mill W-axis remap execution, `melfa-sim`, and PUMA.
+  The Node inventory guard requires process-declaring representatives such as
+  `axis/gladevcp/probe.ngc`, `woodpecker/on_abort.ngc`,
+  `axis/vismach/melfa-sim/example.ngc`, and
+  `axis/vismach/puma/puma_cube.ngc` to keep their dependency rows in
+  `boundary-summary.tsv`, match the expected HAL/UI/HALUI/Python process flag
+  combinations, remain Node/browser `REP` rows, and avoid hard-block promotion
+  unless the classifier finds a real hard runtime dependency.
+- Kept as blocked: TWP `table-rotary_spindle-rotary-nutating`, `gmoccapy`,
+  `axis/laser`, `axis/remap/*/nc_files`, and VMC tool-change Python remap
+  families. These are not missing browser staging work; they depend on
+  Python-remap, prolog/epilog, or full runtime process boundaries that have not
+  been intentionally exposed in Layer 4.
+- Kept out of browser full inventory: remap subroutine assets and macro-only
+  non-representatives. They remain covered by native inventory, native remap
+  parse/execute probes, Node inventory where eligible, or a class
+  representative in browser.
 
 ## Phase 7: Documentation And Drift Control
 
-Status: complete for the current representative sim-config WASM/browser
-coverage. The documentation and manifest now record the native, Node WASM,
-browser, source reuse, and vendor-sync state for the selected sim-config
-programs.
+Status: complete for the current full `configs/sim` coverage definition. The
+documentation and manifest now record native inventory, generated class/path
+artifacts, blocked policy, Node inventory, browser class coverage, source
+reuse, and vendor-sync state.
 
-1. Update `docs/compatibility-validation.md` with the sim-config matrix. Done.
+1. Update `docs/compatibility-validation.md` with the sim-config matrix,
+   blocked policy, and validation commands. Done.
 
-2. Update `docs/source-reuse-map.md` for newly vendored source files. Done.
+2. Add `docs/sim-configs-coverage-matrix.md` as the tracked review surface for
+   all 159 current native inventory rows. Done.
 
-3. Update `tools/source-manifest.txt` and `tools/verify_vendor_sync.sh` if new
+3. Update `docs/source-reuse-map.md` for newly vendored source files. Done.
+
+4. Update `tools/source-manifest.txt` and `tools/verify_vendor_sync.sh` if new
    LinuxCNC files are copied into `wasm-port/vendor/linuxcnc`. Done for the
-   representative `axis/foam`, `axis/geometry`, and `axis/external_offsets`
-   sim-config files, including the remaining external-offset M111 programs and
-   `circles.ngc`; no `verify_vendor_sync.sh` logic change was needed.
+   current representative and inventory-backed sim-config files; no
+   `verify_vendor_sync.sh` logic change was needed.
 
-4. Preserve the latest result summary as a machine-readable artifact, but do
+5. Preserve the latest result summary as a machine-readable artifact, but do
    not commit generated logs unless they are intentionally used as fixtures.
-   Done: generated logs remain under build/test output directories, while the
-   tracked documentation records only the current summary values and validation
-   commands.
+   Done: `summary.tsv` remains the source row set, and `class-summary.tsv` plus
+   `path-matrix.tsv` are generated artifacts under `build/native/sim-configs/`.
+   Node inventory also writes `build/wasm/sim-configs-inventory/summary.tsv`
+   `build/wasm/sim-configs-inventory/skip-summary.tsv`, and
+   `build/wasm/sim-configs-inventory/boundary-summary.tsv` plus
+   `build/wasm/sim-configs-inventory/ini-boundary-summary.tsv` for Layer 4
+   execution, skip/block accounting, and runtime-boundary dependency reporting.
+   The same inventory now writes the full blocked-boundary handoff artifacts:
+   `blocked-dependency-summary.tsv`, `full-process-boundary-summary.tsv`,
+   `user-m-process-boundary-summary.tsv`, `user-m-process-state-targets.tsv`,
+   `tool-db-process-boundary-summary.tsv`,
+   `tool-db-process-protocol-gates.tsv`,
+   `python-remap-boundary-summary.tsv`, `python-remap-family-summary.tsv`,
+   `boundary-phase-completion-summary.tsv`,
+   `native-proof-alignment-summary.tsv`, `next-boundary-worklist.tsv`, and
+   `boundary-proof-gates.tsv`. These remain accounting/proof-gate artifacts;
+   they do not enable blocked execution or promotion.
+   The inventory guard checks `skip-summary.tsv` against skip reasons derived
+   from `path-matrix.tsv`, so aggregate skip counts drift when any blocked or
+   class policy changes without updating the tracked matrix and inventory.
+   The inventory guard requires every vendored INI row to have an available
+   SDK runtime-boundary classifier report; `UNAVAILABLE` is reserved for rows
+   whose boundary summary records a missing vendored INI.
+   Hard blocked rows are additionally recorded in
+  `build/wasm/sim-configs-inventory/blocked-dependency-summary.tsv` without
+  promotion into standalone/WASM execution. That artifact includes source
+  owner fields and runtime proof fields such as `user_m_process_files`,
+  `user_m_process_effects`, `tool_db_protocol_evidence`, and `linuxcnc_owner`,
+  so `millturn` and `db_demo` remain blocked for dependency-backed reasons
+  rather than path-only classification. The follow-up boundary design and
+  required proof for those two blocked rows are tracked in
+  `docs/full-process-boundary-design.md`. Node inventory also writes
+  `build/wasm/sim-configs-inventory/full-process-boundary-summary.tsv` for
+  the designed-but-blocked non-Python full-process rows, including their
+  `runtime_owner_evidence`, and
+  `build/wasm/sim-configs-inventory/python-remap-boundary-summary.tsv` for
+  the Python remap inventory-only row set. The Python boundary and family
+  summaries include `python_runtime_evidence`. All blocked boundary artifacts
+  require `execution_enabled=0`.
 
-## Recommended Work Order
+## Layer 2 Expected-Failure Policy
 
-1. Harness first: make `verify_sim_configs.sh` reproducible.
-2. Axis config next: unblock `U/V/W` failures.
-3. TWP mapping: complete; remaining TWP demo failures are Python/HAL remap
-   runtime edges.
-4. User M-code dispatch: small runtime-edge feature, unblocks five files.
-5. Python remap runtime: largest block; do it after the harness and smaller
-   runtime edges are stable.
-6. WASM promotion after native parity.
+The current Layer 2 baseline remains:
+
+```text
+total: 159
+pass: 151
+fail: 8
+timeout: 0
+expected_fail: 8
+unexpected_fail: 0
+```
+
+Do not reduce the eight expected failures by changing upstream G-code, JS
+interpreter behavior, or project-owned standalone interpreter semantics. Reducing
+this count is only valid if a new LinuxCNC-owned native/runtime entry point can
+legitimately supply the missing task/user-M/axis/TWP context while preserving the
+strict native baseline as a separately documented source of truth.
+
+## Recommended Next Work
+
+1. Keep `verify_sim_configs.sh`, `path-matrix.tsv`, and
+   `docs/sim-configs-coverage-matrix.md` in sync whenever the source manifest or
+   vendored sim-config set changes.
+2. Add new Node/browser representatives only when they cover a new runtime class
+   with a LinuxCNC-owned execution path.
+3. Treat Python remap, full-process HAL/UI, tool database, and external
+   userspace process families as blocked until their runtime boundary is
+   intentionally designed and the proof criteria in
+   `docs/full-process-boundary-design.md` are met where applicable.
+4. Re-evaluate Layer 2 expected failures only after a new legitimate
+   LinuxCNC-owned entry point exists.
 
 ## Non-Goals
 
diff --git a/wasm-port/docs/sim-configs-coverage-matrix.md b/wasm-port/docs/sim-configs-coverage-matrix.md
new file mode 100644
index 0000000..24d4dc6
--- /dev/null
+++ b/wasm-port/docs/sim-configs-coverage-matrix.md
@@ -0,0 +1,421 @@
+# Sim Configs Coverage Matrix
+
+This matrix maps every current `wasm-port/tests/native/verify_sim_configs.sh` entry
+to its native classification and current Layer 3/4 coverage status. It is the
+tracked review surface for `linuxcnc/configs/sim` inventory; the native harness
+also emits machine-readable artifacts for automation.
+
+Current baseline:
+
+- Source file: `wasm-port/build/native/sim-configs/summary.tsv`
+- Generated class summary: `wasm-port/build/native/sim-configs/class-summary.tsv`
+- Generated path matrix: `wasm-port/build/native/sim-configs/path-matrix.tsv`
+- Total records: `159`
+- Native result: `pass 151`, `expected_fail 8`, `unexpected_fail 0`
+- Current Layer 4 representative subset: `axis/foam`, `axis/geometry`,
+  `axis/external_offsets`, `axis/gladevcp`, `woodpecker/on_abort.ngc`,
+  bridge-mill `5axisgui.ngc`, TDR/TRT five-axis switchkins demos,
+  `melfa-sim`, and `puma_cube.ngc`
+- `wasm-port/tests/wasm/node/verify_sim_configs_inventory_wasm.mjs` checks that
+  this tracked matrix and generated `path-matrix.tsv` contain the same 159 paths
+  as native `summary.tsv` before running Node inventory.
+- Node inventory artifact: `wasm-port/build/wasm/sim-configs-inventory/summary.tsv`
+- Node skip/block artifact: `wasm-port/build/wasm/sim-configs-inventory/skip-summary.tsv`
+- Node runtime-boundary artifact: `wasm-port/build/wasm/sim-configs-inventory/boundary-summary.tsv`
+- Node INI runtime-boundary artifact:
+  `wasm-port/build/wasm/sim-configs-inventory/ini-boundary-summary.tsv`
+- Node blocked-dependency artifact:
+  `wasm-port/build/wasm/sim-configs-inventory/blocked-dependency-summary.tsv`
+- Node full-process boundary design artifact:
+  `wasm-port/build/wasm/sim-configs-inventory/full-process-boundary-summary.tsv`
+- Node user-M process boundary design artifact:
+  `wasm-port/build/wasm/sim-configs-inventory/user-m-process-boundary-summary.tsv`
+- Node user-M process transition contract artifact:
+  `wasm-port/build/wasm/sim-configs-inventory/user-m-process-transition-plan.tsv`
+- Node tool DB process boundary design artifact:
+  `wasm-port/build/wasm/sim-configs-inventory/tool-db-process-boundary-summary.tsv`
+- Node tool DB process transaction contract artifact:
+  `wasm-port/build/wasm/sim-configs-inventory/tool-db-process-transaction-plan.tsv`
+- Node Python-remap boundary inventory artifact:
+  `wasm-port/build/wasm/sim-configs-inventory/python-remap-boundary-summary.tsv`
+- Node Python-remap family inventory artifact:
+  `wasm-port/build/wasm/sim-configs-inventory/python-remap-family-summary.tsv`
+- Node Python-remap runtime contract artifact:
+  `wasm-port/build/wasm/sim-configs-inventory/python-remap-runtime-contract.tsv`
+- Node Python-remap native runtime readiness artifact:
+  `wasm-port/build/wasm/sim-configs-inventory/python-remap-native-runtime-readiness.tsv`
+- Node Python-remap native runtime state-plan artifact:
+  `wasm-port/build/wasm/sim-configs-inventory/python-remap-native-runtime-state-plan.tsv`
+- Node Python-remap native runtime fixture-plan artifact:
+  `wasm-port/build/wasm/sim-configs-inventory/python-remap-native-runtime-fixture-plan.tsv`
+- Node runtime-boundary contract summary artifact:
+  `wasm-port/build/wasm/sim-configs-inventory/runtime-boundary-contract-summary.tsv`
+- Node boundary-phase completion artifact:
+  `wasm-port/build/wasm/sim-configs-inventory/boundary-phase-completion-summary.tsv`
+- Node next-boundary worklist artifact:
+  `wasm-port/build/wasm/sim-configs-inventory/next-boundary-worklist.tsv`
+- Current Node inventory: `executed 28`, `passed 28`, `skipped 131`,
+  `unexpected_fail 0`
+- Current Node skip/block counts: `ASSET-ONLY 65`, `L4-PYTHON-REMAP 53`,
+  `L4-TOOL-DB 1`, `L4-USER-M-PROCESS 1`, `NON_MAIN_CLASS 10`,
+  `UPSTREAM-DEMO 1`
+
+Legend:
+
+- `Layer 3`: `SIM-*` means dedicated native runtime probe coverage; `5AX-EXEC` means
+  native five-axis remap execution coverage; `-` means no dedicated runtime probe yet.
+- `Layer 4 Node/Browser`: `REP` means the current representative smoke covers this
+  exact program; `INV` means the Node inventory runner covers the exact program;
+  `N/A` means the row is a subroutine asset and should not be judged as a standalone
+  browser main program; `-` means the row is not individually promoted at that layer
+  and must be interpreted with the row's blocked or class-coverage note.
+- `Blocked`: current hard blocked dependency or non-target classification for future
+  inventory work. `ASSET-ONLY` means the row is not a browser/main-program target.
+  `L4-PYTHON-REMAP` means native `rs274` coverage exists but Node/browser full inventory
+  is blocked on an intentional Python-remap runtime boundary decision. `UPSTREAM-DEMO`
+  means the file is a preserved upstream expected-failure edge.
+- `boundary-summary.tsv`: one row per native inventory path. It records the
+  matrix blocked kind, the SDK classifier's recommended hard block when an INI
+  is vendored, declared HAL/UI/HALUI/Python process dependencies, tool database
+  declarations, user-M process codes seen in the execution text, and which of
+  those user-M codes are not staged by vendored `USER_M_PATH` files. Python is
+  split into total process dependency, UI/DB process dependency, and Python
+  remap runtime dependency so safe UI representatives such as `gladevcp` are
+  not mislabeled as Python-remap coverage. Rows whose INI has not been
+  vendored yet use `recommended_blocked=UNAVAILABLE` and keep their tracked
+  matrix policy as the source of truth until the relevant boundary inventory
+  batch vendors the missing context.
+- `ini-boundary-summary.tsv`: one row per unique INI referenced by the native
+  inventory. It aggregates path-level boundary reports so vendored INIs have a
+  direct machine-readable `report_available=1` check and hard block
+  recommendations can be audited at INI granularity.
+- `blocked-dependency-summary.tsv`: one row per hard blocked
+  `L4-PYTHON-REMAP`, `L4-TOOL-DB`, and `L4-USER-M-PROCESS` path. It reads the
+  source `linuxcnc/configs/sim` INI files without vendoring or executing those
+  families, records Python modules, remap/prolog/epilog function ownership,
+  NGC remap subpaths, HAL/UI/HALUI process declarations, `DB_PROGRAM`, and
+  tool database protocol evidence, plus external user-M execution codes, their
+  process script files, and process side-effect evidence. The `linuxcnc_owner`
+  field records the LinuxCNC source/config files that own the blocked behavior,
+  and keeps those rows blocked until a LinuxCNC-owned runtime boundary is
+  designed.
+- `full-process-boundary-summary.tsv`: one row for each designed-but-still-blocked
+  non-Python full-process boundary. It currently covers `axis/db_demo/base.ngc`
+  and `axis/vismach/millturn/example.ngc`, records LinuxCNC runtime owner
+  evidence, records required native/Node/browser proof, and requires
+  `execution_enabled=0`.
+- `user-m-process-boundary-summary.tsv`: one row for each designed-but-still-blocked
+  external user-M process boundary. It currently records the `millturn`
+  `M128`/`M129` process files, remap call chain, kinstype guards, and
+  source-traceable `ini.[xyz].*` HAL pin state targets, while requiring
+  `execution_enabled=0` and `promotion_allowed=0`.
+- `user-m-process-transition-plan.tsv`: the pending non-executing transition
+  contract for the `millturn` user-M boundary. It binds `M428` to `M128` and
+  `M429` to `M129`, records switchkins output/target, active G5x work offset,
+  guard pin, state mode, and expected `ini.[xyz].*` outputs, and still requires
+  `execution_enabled=0` and `promotion_allowed=0`.
+- `user-m-process-native-transition-alignment.tsv`: the native source
+  alignment for the two `millturn` transition rows. It proves the generated
+  `M428/M429` transition contract still matches the native probe stdout for
+  switchkins output/target, G5x, offset pocket, and `M428 -> M128` /
+  `M429 -> M129` calls, while remaining pending and non-executing.
+- `user-m-process-native-runtime-state-plan.tsv`: the pending native runnable
+  state-probe contract for `millturn`. It records the required LinuxCNC
+  task/HAL/Tcl user-M runtime, the HAL/INI environment, and exact
+  `ini.[xyz].*` values that a future runtime probe must observe after the
+  transitions, while keeping `execution_enabled=0` and `promotion_allowed=0`.
+- `user-m-process-native-runtime-readiness.tsv`: the host capability gate for
+  that future native probe. It records whether `tclsh`, `halrun`, `halcmd`,
+  and `linuxcnc` are available on PATH and keeps the boundary pending and
+  non-promotable regardless of host readiness.
+- `user-m-process-native-runtime-probe-gate.tsv`: the generated execution gate
+  for that future native probe. It records per-transition runtime readiness,
+  missing host commands, source-proof readiness, and the pending gate status.
+  The native `probe_millturn_user_m_runtime.sh` entry point reports
+  `skipped_missing_host_runtime` on hosts without the full LinuxCNC HAL/Tcl
+  runtime, `ready_disabled_by_default` when the host is ready but the guarded
+  runtime probe is not explicitly enabled, or `runtime_state_probe_passed` when
+  `ENABLE_MILLTURN_USER_M_RUNTIME_PROBE=1` proves the LinuxCNC-owned
+  `M128`/`M129` Tcl scripts update the expected `ini.[xyz].*` HAL pins.
+  command set and does not enable execution or promotion.
+- `tool-db-process-boundary-summary.tsv`: one row for each designed-but-still-blocked
+  tool database process boundary. It currently records `db_nonran.py`,
+  LinuxCNC tooldata protocol messages, DB program callbacks, nonrandom tool
+  database state targets, and runtime owner evidence, while requiring
+  `execution_enabled=0` and `promotion_allowed=0`.
+- `tool-db-process-transaction-plan.tsv`: the pending non-executing transaction
+  contract for the `db_demo` tool database boundary. It orders startup
+  handshake, get-all, spindle load notify, tool offset notify, and spindle
+  unload notify steps, binds each protocol message to the expected `db.py`
+  callback and state targets, and still requires `execution_enabled=0` and
+  `promotion_allowed=0`.
+- `tool-db-process-native-runtime-readiness.tsv`: the host capability gate for
+  the guarded native DB process protocol probe. It records whether `python3`,
+  `linuxcnc`, `milltask`, `halcmd`, the configured `db_nonran.py`, and
+  LinuxCNC's `linuxcnc.so` / `tooldb.py` Python modules are available, while
+  keeping the DB boundary pending and non-promotable. The native
+  `probe_tool_db_runtime.sh` entry point reports `skipped_missing_host_runtime`
+  when the host runtime is unavailable, `ready_disabled_by_default` when it is
+  available but not explicitly enabled, or `runtime_protocol_probe_passed` when
+  `ENABLE_TOOL_DB_RUNTIME_PROBE=1` proves the LinuxCNC-owned `DB_PROGRAM`
+  `v2.1`/`g`/`p`/`l`/`u` protocol, nonrandom state updates, and flat-file
+  persistence.
+- `python-remap-boundary-summary.tsv`: one row for each `L4-PYTHON-REMAP`
+  path. It records Python modules, remap/prolog/epilog functions, NGC-only
+  subpaths, HAL/UI/HALUI assumptions, the LinuxCNC Python owner set, LinuxCNC
+  Python runtime owner evidence, and requires `execution_enabled=0`.
+- `python-remap-family-summary.tsv`: one row per blocked Python-remap runtime
+  family. It aggregates row and INI counts plus Python module,
+  remap/prolog/epilog, NGC-only subpath, Python runtime owner evidence,
+  HAL/UI/HALUI, and `execution_enabled=0` evidence without vendoring or
+  executing those families.
+- `python-remap-runtime-contract.tsv`: one row per blocked Python-remap runtime
+  family. It records LinuxCNC-owned Python runtime phases, Python modules,
+  remap/prolog/epilog callables, NGC-only subpaths, HAL/UI/HALUI assumptions,
+  native/Node/browser proof requirements, and keeps `proof_status=pending`,
+  `execution_enabled=0`, and `promotion_allowed=0`.
+- `python-remap-native-runtime-readiness.tsv`: the host/source capability gate
+  for guarded native Python-remap runtime probes. It records `python3`,
+  `linuxcnc`, LinuxCNC's Python interpreter/plugin owner source files, and the
+  configured Python modules for each blocked family, while keeping every row
+  pending, non-executing, and non-promotable.
+- `python-remap-native-runtime-state-plan.tsv`: one row per blocked
+  Python-remap family. It records the runtime phases, modules, callables,
+  NGC-only subpaths, process assumptions, readiness counts, source-alignment
+  inputs, and exact future native state-probe targets while keeping every row
+  pending, non-executing, and non-promotable.
+- `python-remap-native-runtime-fixture-plan.tsv`: the first non-executing
+  Python runtime fixture plan. It selects
+  `axis/remap/stop-lookahead/nc_files` as the minimal lifecycle fixture because
+  it has Python modules and runtime phases without Python callable or NGC-only
+  subpath complexity, and keeps execution/promotion disabled. The native
+  `probe_python_remap_runtime.sh` entry point reports
+  `skipped_missing_host_runtime` without the host runtime,
+  `ready_disabled_by_default` when the host is ready but the probe is not
+  explicitly enabled, or `runtime_lifecycle_probe_passed` when
+  `ENABLE_PYTHON_REMAP_RUNTIME_PROBE=1` proves the `demo.ini`
+  path/toplevel import, `queuebuster` callable lookup, generator return, and
+  first `INTERP_EXECUTE_FINISH` yield.
+- `runtime-boundary-contract-summary.tsv`: one row per blocked runtime boundary
+  class. It unifies the user-M transition contract, tool DB transaction
+  contract, and Python runtime contract with their native-alignment artifact,
+  and requires every contract row to remain pending with execution and
+  promotion disabled.
+- `boundary-phase-completion-summary.tsv`: one row per boundary-phase
+  completion criterion. It requires vendored INI boundary reports, dependency
+  evidence for hard blocks, safe HAL/UI representative coverage, blocked
+  families remaining skipped/non-representative with execution disabled, and
+  LinuxCNC-owned runtime proof fields for user-M, tool DB, and Python runtime
+  blockers. When native source proof is available, it also requires that proof
+  to be consumed by generated worklist/native proof-gate rows without enabling
+  execution or promotion.
+- `native-proof-alignment-summary.tsv`: one row per native source proof class.
+  It aligns the native source proof summary with generated worklist/native
+  proof-gate consumers for user-M, tool DB, and Python runtime blockers.
+- `next-boundary-worklist.tsv`: one row per next blocked runtime-boundary
+  design target. It keeps execution and promotion disabled, records the
+  LinuxCNC owner set and runtime owner evidence, records native, Node, and
+  browser proof requirements, and names the next boundary-design action before
+  any blocked family can be promoted.
+
+## Summary
+
+| Class | Count |
+| --- | --- |
+| `main` | `48` |
+| `macro_load` | `46` |
+| `remap_subroutine` | `65` |
+
+## Family Summary
+
+| Family | Count |
+| --- | --- |
+| `axis/db_demo` | `1` |
+| `axis/external_offsets` | `6` |
+| `axis/foam` | `1` |
+| `axis/geometry` | `1` |
+| `axis/gladevcp` | `1` |
+| `axis/laser` | `3` |
+| `axis/lathe-fanucy` | `1` |
+| `axis/remap` | `29` |
+| `axis/rose_engine` | `2` |
+| `axis/vismach` | `57` |
+| `gmoccapy/lathe_configs` | `8` |
+| `gmoccapy/macros` | `25` |
+| `gmoccapy/non_trivial_kinematics` | `5` |
+| `gscreen/industrial_lathe_wear` | `1` |
+| `gscreen/silverdragon` | `4` |
+| `qtaxis/non-trivial` | `3` |
+| `qtdragon/qtdragon_multi_joint` | `1` |
+| `qtdragon/qtdragon_xyz` | `1` |
+| `qtdragon/qtdragon_xyz45` | `1` |
+| `qtdragon_hd/qtdragon_hd_xyz` | `1` |
+| `qtdragon_hd/qtdragon_hd_z_compensation` | `1` |
+| `qtvcp_screens/industrial_lathe_wear` | `1` |
+| `qtvcp_screens/non-trivial` | `3` |
+| `qtvcp_screens/qtdragon` | `1` |
+| `woodpecker` | `1` |
+
+## Program Matrix
+
+| Path | Family | Class | Native | Expected Failure | Layer 3 | Layer 4 Node | Layer 4 Browser | Blocked | Notes |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| `axis/db_demo/base.ngc` | `axis/db_demo` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-TOOL-DB` | native pass, but Node/browser inventory is blocked by the LinuxCNC tool-database process boundary declared by `[EMCIO]DB_PROGRAM` |
+| `axis/external_offsets/circles.ngc` | `axis/external_offsets` | `macro_load` | `PASS` | `-` | `SIM-EOFF` | `REP` | `REP` | `-` | Layer 4 macro-only class representative now covered through wrapped execution with native staging inputs |
+| `axis/external_offsets/dyn_demo.ngc` | `axis/external_offsets` | `main` | `FAIL` | `user-m-code-M111` | `SIM-EOFF` | `REP` | `REP` | `-` | Layer 2 expected-fail; M111 runtime edge covered |
+| `axis/external_offsets/eoffsets.ngc` | `axis/external_offsets` | `main` | `FAIL` | `user-m-code-M111` | `SIM-EOFF` | `REP` | `REP` | `-` | Layer 2 expected-fail; M111 runtime edge covered |
+| `axis/external_offsets/jwp_z.ngc` | `axis/external_offsets` | `main` | `FAIL` | `user-m-code-M111` | `SIM-EOFF` | `REP` | `REP` | `-` | Layer 2 expected-fail; M111 runtime edge covered |
+| `axis/external_offsets/opa_demo.ngc` | `axis/external_offsets` | `main` | `FAIL` | `user-m-code-M111` | `SIM-EOFF` | `REP` | `REP` | `-` | Layer 2 expected-fail; M111 runtime edge covered |
+| `axis/external_offsets/queuebuster.ngc` | `axis/external_offsets` | `macro_load` | `PASS` | `-` | `SIM-EOFF` | `-` | `-` | `-` | inventory-only macro/load path; macro_load class coverage is represented by `axis/external_offsets/circles.ngc` |
+| `axis/foam/foam.ngc` | `axis/foam` | `main` | `FAIL` | `ini-axis-mask-UV` | `SIM-FOAM` | `REP` | `REP` | `-` | Layer 2 expected-fail; Layer 3/4 runtime edge covered |
+| `axis/geometry/xyzc.ngc` | `axis/geometry` | `main` | `FAIL` | `user-m-code-M110` | `SIM-XYZC` | `REP` | `REP` | `-` | Layer 2 expected-fail; M110 runtime edge covered |
+| `axis/gladevcp/probe.ngc` | `axis/gladevcp` | `main` | `PASS` | `-` | `-` | `REP` | `REP` | `-` | plain INI/tool-table main-program class representative covered in Node and browser through vendored staging inputs |
+| `axis/laser/raster_test.ngc` | `axis/laser` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `axis/laser/vector_test.ngc` | `axis/laser` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `axis/laser/vector_test2.ngc` | `axis/laser` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `axis/lathe-fanucy/toolchange.ngc` | `axis/lathe-fanucy` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `-` | inventory-only macro/load path; macro_load class coverage is represented by `axis/external_offsets/circles.ngc` unless this family is deliberately promoted later |
+| `axis/remap/cycle/nc_files/examples.ngc` | `axis/remap` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native baseline pass, but Layer 4 full inventory is blocked by Python remap/prolog/epilog runtime boundaries; remap subroutine assets remain `ASSET-ONLY` |
+| `axis/remap/cycle/nc_subroutines/g843.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/extend-builtins/nc_files/examples.ngc` | `axis/remap` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native baseline pass, but Layer 4 full inventory is blocked by Python prolog/epilog remap runtime boundaries; remap subroutine assets remain `ASSET-ONLY` |
+| `axis/remap/extend-builtins/nc_subroutines/change.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/extend-builtins/nc_subroutines/extend_m0.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/extend-builtins/nc_subroutines/extend_m1.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/extend-builtins/nc_subroutines/extend_m60.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/extend-builtins/nc_subroutines/extend_m7.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/extend-builtins/nc_subroutines/extend_m8.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/extend-builtins/nc_subroutines/extend_m9.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/extend-builtins/nc_subroutines/prepare.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/extend-builtins/nc_subroutines/setfeed.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/extend-builtins/nc_subroutines/setspeed.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/extend-builtins/nc_subroutines/settool.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/getting-started/nc_files/examples.ngc` | `axis/remap` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native baseline pass, but Layer 4 full inventory is blocked by Python remap handlers such as `G88.1`; remap subroutine assets remain `ASSET-ONLY` |
+| `axis/remap/getting-started/nc_subroutines/change_min.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/getting-started/nc_subroutines/m400.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/getting-started/nc_subroutines/m410.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/getting-started/nc_subroutines/prepare_min.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/manual-toolchange-with-tool-length-switch/nc_files/tcdemo.ngc` | `axis/remap` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native baseline pass, but Layer 4 full inventory is blocked by Python tool-change prolog/epilog runtime boundaries; remap subroutine assets remain `ASSET-ONLY` |
+| `axis/remap/manual-toolchange-with-tool-length-switch/nc_subroutines/manual_change.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/manual-toolchange-with-tool-length-switch/nc_subroutines/on_abort.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/manual-toolchange-with-tool-length-switch/nc_subroutines/restore.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/rack-toolchange/nc_files/tcdemo.ngc` | `axis/remap` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native baseline pass, but Layer 4 full inventory is blocked by Python tool-change prolog/epilog runtime boundaries; remap subroutine assets remain `ASSET-ONLY` |
+| `axis/remap/rack-toolchange/nc_subroutines/on_abort.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/rack-toolchange/nc_subroutines/rack_change.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/rack-toolchange/nc_subroutines/tool_getput_move.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/rack-toolchange/nc_subroutines/tool_holder_clear_move.ngc` | `axis/remap` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/remap/stop-lookahead/nc_files/examples.ngc` | `axis/remap` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native baseline pass, but Layer 4 full inventory is blocked by Python `queuebuster` remap runtime boundaries; remap subroutine assets remain `ASSET-ONLY` |
+| `axis/rose_engine/rcone.ngc` | `axis/rose_engine` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `-` | inventory-only macro/load path; macro_load class coverage is represented by `axis/external_offsets/circles.ngc` unless this family is deliberately promoted later |
+| `axis/rose_engine/rcone_demo.ngc` | `axis/rose_engine` | `main` | `PASS` | `-` | `-` | `INV` | `-` | `-` | Node inventory coverage uses the native harness-selected `axis/sim.tbl` fallback staged at the INI-declared tool-table path; browser class coverage is represented by other plain INI/tool-table samples |
+| `axis/vismach/5axis/bridgemill/5axisgui.ngc` | `axis/vismach` | `main` | `FAIL` | `ini-axis-mask-W` | `SIM-BRIDGE,5AX-EXEC` | `REP` | `REP` | `-` | Layer 2 expected-fail; W-axis and remap runtime edge covered |
+| `axis/vismach/5axis/bridgemill/remap_subs/428remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `5AX-EXEC` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/bridgemill/remap_subs/429remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `5AX-EXEC` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/bridgemill/remap_subs/430remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `5AX-EXEC` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-dual-rotary/demos/xyzab-tdr-demo.ngc` | `axis/vismach` | `main` | `PASS` | `-` | `5AX-EXEC` | `REP` | `REP` | `-` | TDR five-axis remap class covered in Node and browser through vendored INI, tool-table, remap-subroutine, and demo staging |
+| `axis/vismach/5axis/table-dual-rotary/remap_subs/428remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `5AX-EXEC` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-dual-rotary/remap_subs/429remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `5AX-EXEC` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-rotary-tilting/demos/boat-xyzac.ngc` | `axis/vismach` | `main` | `PASS` | `-` | `5AX-EXEC` | `REP` | `REP` | `-` | TRT five-axis remap class covered in Node and browser through vendored INI, tool-table, remap-subroutine, and demo staging |
+| `axis/vismach/5axis/table-rotary-tilting/demos/boat-xyzbc.ngc` | `axis/vismach` | `main` | `PASS` | `-` | `5AX-EXEC` | `REP` | `REP` | `-` | TRT five-axis remap class covered in Node and browser through vendored INI, tool-table, remap-subroutine, and demo staging |
+| `axis/vismach/5axis/table-rotary-tilting/demos/impeller-7bl-xyzac.ngc` | `axis/vismach` | `main` | `PASS` | `-` | `5AX-EXEC` | `REP` | `REP` | `-` | TRT five-axis remap class covered in Node and browser through vendored INI, tool-table, remap-subroutine, and demo staging |
+| `axis/vismach/5axis/table-rotary-tilting/demos/xyzac_switchkins.ngc` | `axis/vismach` | `main` | `PASS` | `-` | `5AX-EXEC` | `REP` | `REP` | `-` | TRT five-axis remap class covered in Node and browser through vendored INI, tool-table, remap-subroutine, and demo staging |
+| `axis/vismach/5axis/table-rotary-tilting/demos/xyzac_switchkins_test_1.ngc` | `axis/vismach` | `main` | `PASS` | `-` | `5AX-EXEC` | `REP` | `REP` | `-` | TRT five-axis remap class covered in Node and browser through vendored INI, tool-table, remap-subroutine, and demo staging |
+| `axis/vismach/5axis/table-rotary-tilting/demos/xyzac_switchkins_test_2.ngc` | `axis/vismach` | `main` | `PASS` | `-` | `5AX-EXEC` | `REP` | `REP` | `-` | TRT five-axis remap class covered in Node and browser through vendored INI, tool-table, remap-subroutine, and demo staging |
+| `axis/vismach/5axis/table-rotary-tilting/demos/xyzac_switchkins_test_3.ngc` | `axis/vismach` | `main` | `PASS` | `-` | `5AX-EXEC` | `REP` | `REP` | `-` | TRT five-axis remap class covered in Node and browser through vendored INI, tool-table, remap-subroutine, and demo staging |
+| `axis/vismach/5axis/table-rotary-tilting/demos/xyzbc_switchkins.ngc` | `axis/vismach` | `main` | `PASS` | `-` | `5AX-EXEC` | `REP` | `REP` | `-` | TRT five-axis remap class covered in Node and browser through vendored INI, tool-table, remap-subroutine, and demo staging |
+| `axis/vismach/5axis/table-rotary-tilting/remap_subs/428remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `5AX-EXEC` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-rotary-tilting/remap_subs/429remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `5AX-EXEC` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-rotary-tilting/remap_subs/430remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `5AX-EXEC` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-rotary-tilting/remap_subs/centering.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `5AX-EXEC` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-rotary-tilting/remap_subs/helix_ac.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `5AX-EXEC` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-rotary-tilting/remap_subs/helix_bc.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `5AX-EXEC` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-rotary-tilting/remap_subs/xyzac_switchkins_sub.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `5AX-EXEC` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-rotary-tilting/remap_subs/xyzbc_switchkins_sub.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `5AX-EXEC` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-rotary_spindle-rotary-nutating/demos/circular_pocket.ngc` | `axis/vismach` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass, but Layer 4 full inventory is blocked on Python remap entry points such as g682, g69_core, and g53x_core |
+| `axis/vismach/5axis/table-rotary_spindle-rotary-nutating/demos/incremental_repetition.ngc` | `axis/vismach` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass, but Layer 4 full inventory is blocked on Python remap entry points such as g682, g69_core, and g53x_core |
+| `axis/vismach/5axis/table-rotary_spindle-rotary-nutating/demos/incremental_repetition_back_and_forth.ngc` | `axis/vismach` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass, but Layer 4 full inventory is blocked on Python remap entry points such as g682, g69_core, and g53x_core |
+| `axis/vismach/5axis/table-rotary_spindle-rotary-nutating/demos/incremental_repetition_g533.ngc` | `axis/vismach` | `main` | `FAIL` | `upstream-demo-missing-motion-gcode` | `-` | `-` | `-` | `UPSTREAM-DEMO` | preserve upstream demo failure; do not force PASS |
+| `axis/vismach/5axis/table-rotary_spindle-rotary-nutating/demos/simple_example.ngc` | `axis/vismach` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass, but Layer 4 full inventory is blocked on Python remap entry points such as g682, g69_core, and g53x_core |
+| `axis/vismach/5axis/table-rotary_spindle-rotary-nutating/demos/square.ngc` | `axis/vismach` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass, but Layer 4 full inventory is blocked on Python remap entry points such as g682, g69_core, and g53x_core |
+| `axis/vismach/5axis/table-rotary_spindle-rotary-nutating/remap_subs/428remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-rotary_spindle-rotary-nutating/remap_subs/429remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-rotary_spindle-rotary-nutating/remap_subs/430remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-rotary_spindle-rotary-nutating/remap_subs/g531remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-rotary_spindle-rotary-nutating/remap_subs/g533remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-rotary_spindle-rotary-nutating/remap_subs/g536remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-rotary_spindle-rotary-nutating/remap_subs/g69remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-rotary_spindle-rotary-nutating/remap_subs/on_abort_no_twp_reset.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/5axis/table-rotary_spindle-rotary-nutating/remap_subs/on_abort_with_twp_reset.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/VMC_toolchange/toolchange.ngc` | `axis/vismach` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native baseline pass, but Layer 4 full inventory is blocked by Python tool-change prolog/epilog and full tool-change runtime boundaries |
+| `axis/vismach/hexapod-sim/remap_subs/428remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/hexapod-sim/remap_subs/429remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/hexapod-sim/remap_subs/430remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/melfa-sim/example.ngc` | `axis/vismach` | `main` | `PASS` | `-` | `-` | `REP` | `REP` | `-` | robot/Genser-style remap machine class representative covered in Node and browser through vendored INI, tool-table, and remap-subroutine staging |
+| `axis/vismach/melfa-sim/remap_subs/428remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/melfa-sim/remap_subs/429remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/melfa-sim/remap_subs/430remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/millturn/example.ngc` | `axis/vismach` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-USER-M-PROCESS` | native pass, but Node/browser inventory is blocked by external `USER_M_PATH` process M-codes `M128` and `M129` rather than the deterministic `M110`/`M111` boundary already modeled by the standalone runtime |
+| `axis/vismach/millturn/remap_subs/428remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/millturn/remap_subs/429remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/puma/puma_cube.ngc` | `axis/vismach` | `main` | `PASS` | `-` | `-` | `REP` | `REP` | `-` | PUMA kinematics/remap machine class representative covered in Node and browser through vendored INI, tool-table, and remap-subroutine staging |
+| `axis/vismach/puma/puma_seam_weld.ngc` | `axis/vismach` | `main` | `PASS` | `-` | `-` | `INV` | `-` | `-` | Node inventory covered with the same vendored puma machine context; browser class coverage is represented by `puma_cube.ngc` |
+| `axis/vismach/puma/remap_subs/428remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/puma/remap_subs/429remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/puma/remap_subs/430remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/scara/remap_subs/428remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/scara/remap_subs/429remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `axis/vismach/scara/remap_subs/430remap.ngc` | `axis/vismach` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `gmoccapy/lathe_configs/boring.ngc` | `gmoccapy/lathe_configs` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/lathe_configs/chamfer.ngc` | `gmoccapy/lathe_configs` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/lathe_configs/drilling.ngc` | `gmoccapy/lathe_configs` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/lathe_configs/facing.ngc` | `gmoccapy/lathe_configs` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/lathe_configs/grooving.ngc` | `gmoccapy/lathe_configs` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/lathe_configs/radius.ngc` | `gmoccapy/lathe_configs` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/lathe_configs/threading.ngc` | `gmoccapy/lathe_configs` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/lathe_configs/turning.ngc` | `gmoccapy/lathe_configs` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/change.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/change_g43.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/go_to_position.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/halo_world.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/i_am_lost.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/increment.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/jog_around.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/macro_0.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/macro_1.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/macro_10.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/macro_11.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/macro_12.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/macro_13.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/macro_14.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/macro_15.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/macro_2.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/macro_3.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/macro_4.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/macro_5.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/macro_6.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/macro_7.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/macro_8.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/macro_9.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/on_abort.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/macros/settool_g43.ngc` | `gmoccapy/macros` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/non_trivial_kinematics/table-rotary-tilting/examples/boat-xyzac.ngc` | `gmoccapy/non_trivial_kinematics` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/non_trivial_kinematics/table-rotary-tilting/examples/boat-xyzbc.ngc` | `gmoccapy/non_trivial_kinematics` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/non_trivial_kinematics/table-rotary-tilting/examples/impeller-7bl-xyzac.ngc` | `gmoccapy/non_trivial_kinematics` | `main` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/non_trivial_kinematics/table-rotary-tilting/examples/test-xyzac.ngc` | `gmoccapy/non_trivial_kinematics` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gmoccapy/non_trivial_kinematics/table-rotary-tilting/examples/test-xyzbc.ngc` | `gmoccapy/non_trivial_kinematics` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `L4-PYTHON-REMAP` | native pass; Layer 4 is blocked until the Python-remap runtime boundary is deliberately designed |
+| `gscreen/industrial_lathe_wear/toolchange.ngc` | `gscreen/industrial_lathe_wear` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `-` | inventory-only macro/load path; macro_load class coverage is represented by `axis/external_offsets/circles.ngc` unless this family is deliberately promoted later |
+| `gscreen/silverdragon/macros/auto_zref.ngc` | `gscreen/silverdragon` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `-` | inventory-only macro/load path; macro_load class coverage is represented by `axis/external_offsets/circles.ngc` unless this family is deliberately promoted later |
+| `gscreen/silverdragon/macros/laserzero.ngc` | `gscreen/silverdragon` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `-` | inventory-only macro/load path; macro_load class coverage is represented by `axis/external_offsets/circles.ngc` unless this family is deliberately promoted later |
+| `gscreen/silverdragon/macros/tool_sensor.ngc` | `gscreen/silverdragon` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `-` | inventory-only macro/load path; macro_load class coverage is represented by `axis/external_offsets/circles.ngc` unless this family is deliberately promoted later |
+| `gscreen/silverdragon/macros/touch_plate.ngc` | `gscreen/silverdragon` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `-` | inventory-only macro/load path; macro_load class coverage is represented by `axis/external_offsets/circles.ngc` unless this family is deliberately promoted later |
+| `qtaxis/non-trivial/scara/remap_subs/428remap.ngc` | `qtaxis/non-trivial` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `qtaxis/non-trivial/scara/remap_subs/429remap.ngc` | `qtaxis/non-trivial` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `qtaxis/non-trivial/scara/remap_subs/430remap.ngc` | `qtaxis/non-trivial` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `qtdragon/qtdragon_multi_joint/on_abort.ngc` | `qtdragon/qtdragon_multi_joint` | `main` | `PASS` | `-` | `-` | `INV` | `-` | `-` | vendored INI/tool-table now allow Node inventory coverage; browser representative still delegated to the shared `woodpecker/on_abort.ngc` class sample |
+| `qtdragon/qtdragon_xyz/on_abort.ngc` | `qtdragon/qtdragon_xyz` | `main` | `PASS` | `-` | `-` | `INV` | `-` | `-` | vendored INI/tool-table now allow Node inventory coverage; browser representative still delegated to the shared `woodpecker/on_abort.ngc` class sample |
+| `qtdragon/qtdragon_xyz45/on_abort.ngc` | `qtdragon/qtdragon_xyz45` | `main` | `PASS` | `-` | `-` | `INV` | `-` | `-` | vendored INI/tool-table now allow Node inventory coverage; browser representative still delegated to the shared `woodpecker/on_abort.ngc` class sample |
+| `qtdragon_hd/qtdragon_hd_xyz/on_abort.ngc` | `qtdragon_hd/qtdragon_hd_xyz` | `main` | `PASS` | `-` | `-` | `INV` | `-` | `-` | vendored INI/tool-table now allow Node inventory coverage; browser representative still delegated to the shared `woodpecker/on_abort.ngc` class sample |
+| `qtdragon_hd/qtdragon_hd_z_compensation/on_abort.ngc` | `qtdragon_hd/qtdragon_hd_z_compensation` | `main` | `PASS` | `-` | `-` | `INV` | `-` | `-` | vendored INI/tool-table now allow Node inventory coverage; browser representative still delegated to the shared `woodpecker/on_abort.ngc` class sample |
+| `qtvcp_screens/industrial_lathe_wear/toolchange.ngc` | `qtvcp_screens/industrial_lathe_wear` | `macro_load` | `PASS` | `-` | `-` | `-` | `-` | `-` | inventory-only macro/load path; macro_load class coverage is represented by `axis/external_offsets/circles.ngc` unless this family is deliberately promoted later |
+| `qtvcp_screens/non-trivial/scara/remap_subs/428remap.ngc` | `qtvcp_screens/non-trivial` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `qtvcp_screens/non-trivial/scara/remap_subs/429remap.ngc` | `qtvcp_screens/non-trivial` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `qtvcp_screens/non-trivial/scara/remap_subs/430remap.ngc` | `qtvcp_screens/non-trivial` | `remap_subroutine` | `PASS` | `-` | `-` | `N/A` | `N/A` | `ASSET-ONLY` | subroutine asset; validate by parse/remap path rather than standalone main-program execution |
+| `qtvcp_screens/qtdragon/on_abort.ngc` | `qtvcp_screens/qtdragon` | `main` | `PASS` | `-` | `-` | `INV` | `-` | `-` | vendored INI/tool-table now allow Node inventory coverage; browser representative still delegated to the shared `woodpecker/on_abort.ngc` class sample |
+| `woodpecker/on_abort.ngc` | `woodpecker` | `main` | `PASS` | `-` | `-` | `REP` | `REP` | `-` | Layer 4 deterministic on_abort class representative now covered |
diff --git a/wasm-port/docs/source-reuse-map.md b/wasm-port/docs/source-reuse-map.md
index 38ca74c..445cfda 100644
--- a/wasm-port/docs/source-reuse-map.md
+++ b/wasm-port/docs/source-reuse-map.md
@@ -41,7 +41,8 @@ Current validation is intentionally mechanical:
 | Switchable 5-axis bridge kinematics | `src/emc/kinematics/5axiskins.c`, `switchkins.c`, `switchkins.h`, `userkfuncs.c`, plus `src/rtapi/rtapi_ctype.h` | Copy unchanged | HAL pin allocation, HAL component lifecycle, and RTAPI module metadata are standalone runtime edges; switchable 5-axis forward/inverse behavior remains LinuxCNC source | Vendor byte sync, per-file source probes, `linuxcnc_5axis_kinematics_probe` |
 | TRT table-rotary kinematics | `src/emc/kinematics/trtfuncs.c`, `xyzac-trt-kins.c`, `xyzbc-trt-kins.c` | Copy unchanged | HAL pin allocation and switchkins lifecycle stay runtime boundaries; XYZAC/XYZBC TRT forward/inverse behavior remains LinuxCNC source | Vendor byte sync, per-file source probes, `linuxcnc_xyzac_trt_kinematics_probe`, `linuxcnc_xyzbc_trt_kinematics_probe` |
 | Five-axis switchkins machine configs and M428/M429/M430 remaps | `configs/sim/axis/vismach/5axis/bridgemill/*`, `table-dual-rotary/*`, and `table-rotary-tilting/*` selected INI, HAL, tool-table, XML, demo, and `remap_subs/*.ngc` files plus `src/emc/rs274ngc/interp_remap.cc` | Copy unchanged | `M428`, `M429`, and `M430` remain LinuxCNC `REMAP` entries that call LinuxCNC NGC subroutines using `M68`, `M66`, `_hal[motion.switchkins-type]`, and the INI/HAL `motion.analog-out-03 => motion.switchkins-type` link; standalone remap descriptor parsing routes through vendored `Interp::parse_remap()` and `find_ngc_file()`, and NGC remap/file execution routes through vendored LinuxCNC O-word and `open()`/`read()`/`execute()` paths while HAL synchronization stays a runtime adapter boundary | Vendor byte sync, `linuxcnc_5axis_remap_asset_probe`, `linuxcnc_remap_parse_harness`, `linuxcnc_remap_hal_sync_harness`, `linuxcnc_5axis_remap_execute_harness`, `tests/wasm/node/verify_interp_wasm.sh`, `tests/wasm/node/verify_sim_configs_wasm.sh`, `tests/browser/verify_interp_browser.sh`, `tests/browser/verify_ini_panel_browser.sh` |
-| Representative sim-config machine programs | `configs/sim/axis/foam/*`, `configs/sim/axis/geometry/M110`, `xyzc.ini`, `xyzc.ngc`, `configs/sim/axis/external_offsets/M111`, `dyn_demo.ngc`, `dynamic_offsets.ini`, `eoffsets.ngc`, `eoffsets.ini`, `jwp_z.ngc`, `jwp_z.ini`, `opa_demo.ngc`, `opa.ini`, `circles.ngc`, `eoffset.tbl`, and `configs/sim/axis/sim.tbl` | Copy unchanged | The `foam`, `xyzc`, and external-offset sample programs remain LinuxCNC sim-config assets. The standalone boundary only copies INI, tool table, G-code, executable user-M files, `SUBROUTINE_PATH` files, and remap-NGC files into the native or WASM filesystem, then calls vendored LinuxCNC INI parsing and `Interp::open()`/`read()`/`execute()` through the existing machine-config adapter. The native sim-config harness now prefers `[DISPLAY]OPEN_FILE` when several INI files live beside a program, so each program is judged with its corresponding machine context. The JS SDK `planIniFileContextStaging()` is a generic manifest-based file-plan helper, `planSimConfigStaging()` is its `configs/sim` wrapper, and `runSimConfigProgram()` only writes caller-provided text files to the Emscripten filesystem, applies executable bits, and forwards to LinuxCNC-backed C ABI entry points. `M110`/`M111` process execution stays a runtime boundary represented by deterministic `USER_M_COMMAND` canonical events | Vendor byte sync, `tests/native/verify_sim_configs.sh`, `tests/wasm/node/verify_sim_configs_wasm.sh`, `tests/browser/verify_interp_browser.sh` |
+| Representative sim-config machine programs | `configs/sim/axis/foam/*`, `configs/sim/axis/geometry/M110`, `xyzc.ini`, `xyzc.ngc`, `configs/sim/axis/external_offsets/M111`, `dyn_demo.ngc`, `dynamic_offsets.ini`, `eoffsets.ngc`, `eoffsets.ini`, `jwp_z.ngc`, `jwp_z.ini`, `opa_demo.ngc`, `opa.ini`, `circles.ngc`, `eoffset.tbl`, `configs/sim/axis/sim.tbl`, `configs/sim/axis/gladevcp/gladevcp_panel.ini`, `probe.ngc`, `sim.tbl`, `configs/sim/axis/vismach/melfa-sim/*`, selected `configs/sim/axis/vismach/puma/*`, and `configs/sim/woodpecker/on_abort.ngc`, `tool.tbl`, `woodpecker.ini` | Copy unchanged | The `foam`, `xyzc`, external-offset, plain `gladevcp/probe.ngc`, `melfa-sim`, PUMA, and deterministic `woodpecker/on_abort.ngc` sample programs remain LinuxCNC sim-config assets. The standalone boundary only copies INI, tool table, G-code, executable user-M files, `SUBROUTINE_PATH` files, and remap-NGC files into the native or WASM filesystem, then calls vendored LinuxCNC INI parsing and `Interp::open()`/`read()`/`execute()` or the existing five-axis remap execution C ABI through the machine-config adapter. The native sim-config harness now prefers `[DISPLAY]OPEN_FILE` when several INI files live beside a program, so each program is judged with its corresponding machine context. The JS SDK `planIniFileContextStaging()` is a generic manifest-based file-plan helper, `planSimConfigStaging()` is its `configs/sim` wrapper, and `runSimConfigProgram()` only writes caller-provided text files to the Emscripten filesystem, applies executable bits, and forwards to LinuxCNC-backed C ABI entry points. `M110`/`M111` process execution stays a runtime boundary represented by deterministic `USER_M_COMMAND` canonical events, while GUI driver, HAL process launch, and external userspace process startup remain outside standalone Node/browser execution. The TWP `table-rotary_spindle-rotary-nutating` demo family remains outside this representative row because its Layer 4 promotion still depends on a deliberate Python-remap runtime boundary, not on additional JS-owned staging logic. | Vendor byte sync, `tests/native/verify_sim_configs.sh`, `tests/wasm/node/verify_sim_configs_wasm.sh`, `tests/wasm/node/verify_sim_configs_inventory_wasm.sh`, `tests/browser/verify_interp_browser.sh`, `tests/host/verify_host_smokes.sh` |
+| Sim-config inventory and blocked-boundary assets | Selected `configs/sim/axis/db_demo/*`, `axis/rose_engine/*`, `axis/vismach/millturn/*`, `configs/sim/qtdragon/*`, `configs/sim/qtdragon_hd/*`, and `configs/sim/qtvcp_screens/qtdragon/*` files | Copy unchanged | These assets are vendored for the machine-readable `configs/sim` Node inventory and blocked-boundary accounting. Eligible `on_abort` and plain INI/tool-table rows run through the same LinuxCNC-backed `runSimConfigProgram()` staging path as other sim-config samples. Rows such as `axis/db_demo/base.ngc` and `axis/vismach/millturn/example.ngc` remain explicit Layer 4 blocked entries because their native LinuxCNC configs depend on tool-database or external user-M process boundaries; Node/browser inventory records those dependencies instead of reducing them to standalone file execution. | Vendor byte sync, `tests/native/verify_sim_configs.sh`, `tests/wasm/node/verify_sim_configs_inventory_wasm.sh`, `tests/host/verify_host_smokes.sh` |
 | Representative `nc_files` examples | `nc_files/3D_Chips.ngc`, `nc_files/arcspiral.ngc`, `nc_files/factorial.ngc`, `nc_files/hole-circle.ngc`, `nc_files/m6demo.ngc` | Copy unchanged | These upstream `linuxcnc/nc_files` examples are copied byte-for-byte into the WASM vendor tree after the native `nc_files` harness classifies the broader directory. Node and browser tests only stage the original `.ngc` text and, for `3D_Chips.ngc`, the minimal INI-declared tool table context required by its upstream `T1 M6` line in the Emscripten filesystem, then call the LinuxCNC-backed `Interp::open()`, `read()`, and `execute()` path through the existing SDK; no G-code, O-word, tool-change, or M-code behavior is implemented in JavaScript | Vendor byte sync, `tests/native/verify_nc_files.sh`, `tests/wasm/node/verify_nc_files_wasm.sh`, `tests/browser/verify_interp_browser.sh`, `tests/host/verify_host_smokes.sh` |
 | LinuxCNC remap regression fixtures | `tests/remap/duplicate-o-word/*`, `tests/remap/fail/args.0/*`, `tests/remap/fail/args.1/*`, `tests/remap/fail/args.2/*`, `tests/remap/fail/body-ngc/*`, `tests/remap/m30-interaction/*`, `tests/remap/nested-remaps-oword/*`, `tests/remap/posargs.0/*`, `tests/remap/sequencing/*`, selected NGC-only `tests/remap/remap-io/test-ngc.ini` plus `io_*.ngc`, and `src/emc/rs274ngc/interp_remap.cc` plus `interp_o_word.cc` | Copy unchanged | The upstream duplicate O-word, NGC-only remap failure, M30/remap-level interaction, nested O-word remap, positional-argument remap, G/M remap sequencing, and remap-IO NGC subroutine regressions remain LinuxCNC REMAP/O-word/file or MDI execution tests. The standalone boundary only copies the upstream test files into native or WASM filesystems, reads LinuxCNC INI `SUBROUTINE_PATH`, `REMAP`, and `OWORD_NARGS` entries, and calls vendored `Interp::parse_remap()`, `open()`, `read()`, and `execute()` or feeds the upstream remap-IO MDI sequence into vendored `Interp::execute()`; the continue-on-error runner path only mirrors LinuxCNC `rs274 -n 0` test execution and does not implement duplicate-label, O-word, nested remap, M30, positional-argument, failure, sequencing, M62-M68, M66 input, or remap semantics | Vendor byte sync, `linuxcnc_duplicate_oword_remap_harness`, `tests/wasm/node/verify_interp_wasm.sh`, `tests/browser/verify_interp_browser.sh` |
 | LinuxCNC interpreter regression fixtures | `tests/interp/do-while-break/*`, `tests/interp/oword-bug315/*`, `tests/interp/oword-bug315-p2/*`, `tests/interp/exists/*`, `tests/interp/return-value/*`, `tests/interp/subs-follow-main/*`, `tests/interp/fractional-linenumbers/*`, `tests/interp/cam-nisley/*`, `tests/interp/namedparam-bug424/*`, `tests/interp/flowsnake/*`, selected `tests/interp/good/*.ngc` center-format arc tolerance fixtures, `tests/interp/g6164/*`, `tests/interp/inside-corners/*`, `tests/interp/inverse-time-with-comp/*`, selected `tests/ccomp/*` standalone cutter-compensation fixtures, selected `tests/interp/bad/*.ngc` file-error fixtures, `tests/interp/g33.1/*`, selected `tests/interp/g71-*/*` and `tests/interp/g72-*/*` lathe canned-cycle fixtures, `tests/interp/g76/*`, `tests/interp/g10/*`, `tests/interp/g52/g52-g92-interaction/*`, selected `tests/interp/rotation/*` pure interpreter cases, `tests/interp/iniparam/*`, `tests/interp/iniparam-failassign/*`, `tests/interp/m19/*`, `tests/interp/magic_comments/param_format_printing/*`, selected `tests/interp/m98m99/*` pure interpreter cases, `tests/interp/sub-call-from-sub/*`, `tests/interp/sequence-number/*`, `tests/interp/nested-sub-error/*`, `tests/interp/nested-sub-in-file-error/*`, `tests/interp/oword-unwind/*`, `tests/interp/abort-hot-comment/*`, plus vendored interpreter/O-word sources including `interp_o_word.cc`, `interp_read.cc`, `interp_execute.cc`, `interp_find.cc`, `interp_namedparams.cc`, and `rs274ngc_pre.cc` | Copy unchanged | The upstream do/while/break, O-word bug315, `EXISTS[]`, subroutine return-value, subs-after-main, fractional line-number, storm-door latch cam toolpath with upstream tool-table context, named-parameter, recursive O-word flowsnake toolpath, selected center-format arc tolerance acceptance/rejection cases, `G61`/`G64` path-control and naive-cam tolerance behavior, cutter-compensation concave/convex/tangent geometry, inverse-time feed and cutter-compensation interaction, selected standalone cutter-compensation file execution with upstream tool tables, selected file-execution error cases including canned-cycle A-axis rejection, center-format arc radius mismatch rejection, cutter-compensation arc-exit/gouging rejection, and malformed `EXISTS[]`, rigid-tap `G33.1`, G71/G72 lathe canned-cycle iteration behavior, G76 lathe threading with upstream tool-table context, `G10 L1/L10/L11/L2/L20` tool-table/offset/G5X/G92/rotation regressions, G52/G92 shared-offset interaction, selected rotation/G53/G28 absolute-position and endpoint, INI named-parameter lookup/read-only protection, M19 spindle-orient offset/timeout handling, magic-comment parameter formatting, selected Fanuc `M98/M99` call, loop, missing-P-word, missing-subprogram, mixed Fanuc/RS274NGC sub-style, `DISABLE_FANUC_STYLE_SUB`, main-program O-word termination, and O-expression regressions, external-subroutine-call, external-subroutine line-number, nested-subroutine-definition rejection, blocked forward-seek-to-later-numbered-sub, O-word stack unwind after a subroutine error, `(ABORT,...)` hot-comment parameter-expansion regressions, and INI-declared G92 parameter-file startup persistence remain LinuxCNC interpreter file-execution or initialization tests. The standalone boundary only vendors the original upstream assets, copies `*.ngc`, `test.ini`, `test.tbl`, `subs/*.ngc`, referenced external subroutine `.ngc` files, and staged variable files into native or WASM filesystems where applicable, sets the LinuxCNC `INI_FILE_NAME` runtime edge for `_ini[...]`, applies LinuxCNC INI machine settings such as `[RS274NGC]ORIENT_OFFSET`, loads upstream tool tables through LinuxCNC `tooldata_load()`/`Interp::load_tool_table()`, reads LinuxCNC INI `SUBROUTINE_PATH`, passes `[RS274NGC]PARAMETER_FILE` through vendored `ini_load()`/`Interp::init()`/`restore_parameters()` when the staged variable file exists, captures LinuxCNC `(PRINT,...)` output through the existing stdout/Emscripten `print` boundary, and calls vendored `Interp::open()`, `read()`, and `execute()`; it does not implement O-word loop, break, unwind, subroutine, dynamic call, `M98/M99`, `EXISTS[]`, named-parameter, canned-cycle, cutter-compensation, inverse-time feed, recursive O-word or cam toolpath generation, path-control, naive-cam tolerance, arc tolerance, threading, rigid tap, `G10`, G52/G92 offset behavior, G92 persistence, tool-offset, absolute-position named-parameter, G28/G53 endpoint, INI-variable, read-only parameter, line-number, spindle-speed, spindle-orient, magic-comment formatting, subroutine lookup, ABORT hot-comment, error, or branch semantics | Vendor byte sync, `linuxcnc_interp_minimal_harness`, `tests/wasm/node/verify_interp_wasm.sh`, `tests/browser/verify_interp_browser.sh` |
diff --git a/wasm-port/runtime/core/linuxcnc_wrap/linuxcnc_millturn_user_m_boundary_probe.cpp b/wasm-port/runtime/core/linuxcnc_wrap/linuxcnc_millturn_user_m_boundary_probe.cpp
new file mode 100644
index 0000000..d265f4a
--- /dev/null
+++ b/wasm-port/runtime/core/linuxcnc_wrap/linuxcnc_millturn_user_m_boundary_probe.cpp
@@ -0,0 +1,215 @@
+#include <fstream>
+#include <iostream>
+#include <iterator>
+#include <string>
+
+#include "emc/ini/inifile.hh"
+
+#ifndef LINUXCNC_SOURCE_CONFIG_DIR
+#error "LINUXCNC_SOURCE_CONFIG_DIR must point at the LinuxCNC configs/sim tree"
+#endif
+
+namespace {
+
+struct UserMCase {
+    const char *code;
+    const char *remap_code;
+    const char *script_rel;
+    const char *remap_rel;
+    const char *state_mode;
+    const char *guard_pin;
+    const char *switchkins_target;
+    const char *active_g5x;
+    const char *work_offset_pocket;
+    const char *work_offset_words;
+    const char *min_limit_key;
+    const char *max_limit_key;
+};
+
+std::string source_config_path(const std::string &rel)
+{
+    return std::string(LINUXCNC_SOURCE_CONFIG_DIR) + "/" + rel;
+}
+
+std::string read_text(const std::string &path)
+{
+    std::ifstream input(path);
+    return std::string(
+        std::istreambuf_iterator<char>(input),
+        std::istreambuf_iterator<char>());
+}
+
+bool contains(const std::string &text, const std::string &needle)
+{
+    return text.find(needle) != std::string::npos;
+}
+
+void print_bool(const std::string &name, bool value)
+{
+    std::cout << name << "=" << (value ? 1 : 0) << "\n";
+}
+
+bool check_ini_value(
+    const linuxcnc::IniFile &ini,
+    const std::string &label,
+    const std::string &section,
+    const std::string &tag,
+    const std::string &expected)
+{
+    const auto actual = ini.findString(tag, section);
+    std::cout << label << "_" << section << "." << tag << "="
+              << (actual ? *actual : "<missing>") << "\n";
+    const bool ok = actual && *actual == expected;
+    print_bool(label + "_" + section + "." + tag + "_ok", ok);
+    return ok;
+}
+
+bool check_axis_targets(
+    const linuxcnc::IniFile &ini,
+    const UserMCase &user_m,
+    const char *axis,
+    const char *expected_min,
+    const char *expected_max,
+    const char *expected_velocity,
+    const char *expected_acceleration)
+{
+    const std::string section = std::string("AXIS_") + axis;
+    const std::string label = std::string(user_m.code) + "_" + axis;
+    bool ok = true;
+    ok &= check_ini_value(ini, label, section, user_m.min_limit_key, expected_min);
+    ok &= check_ini_value(ini, label, section, user_m.max_limit_key, expected_max);
+    ok &= check_ini_value(ini, label, section, "MAX_VELOCITY", expected_velocity);
+    ok &= check_ini_value(ini, label, section, "MAX_ACCELERATION", expected_acceleration);
+    return ok;
+}
+
+bool check_script(const UserMCase &user_m)
+{
+    const std::string text = read_text(source_config_path(user_m.script_rel));
+    bool ok = true;
+    ok &= contains(text, "#!/usr/bin/tclsh");
+    ok &= contains(text, "package require Linuxcnc");
+    ok &= contains(text, "package require Hal");
+    ok &= contains(text, "parse_ini $::env(INI_FILE_NAME)");
+    ok &= contains(text, std::string("hal getp ") + user_m.guard_pin);
+    ok &= contains(text, "hal setp ini.$l.min_limit");
+    ok &= contains(text, "hal setp ini.$l.max_limit");
+    ok &= contains(text, "hal setp ini.$l.min_velocity");
+    ok &= contains(text, "hal setp ini.$l.max_acceleration");
+    ok &= contains(text, user_m.min_limit_key);
+    ok &= contains(text, user_m.max_limit_key);
+    print_bool(std::string(user_m.code) + "_script_tcl_hal_runtime", ok);
+    return ok;
+}
+
+bool check_remap_caller(const UserMCase &user_m)
+{
+    const std::string text = read_text(source_config_path(user_m.remap_rel));
+    const std::string remap_code(user_m.remap_code);
+    const bool ok =
+        contains(text, user_m.code) &&
+        contains(text, "#<SWITCHKINS_PIN> = 3") &&
+        contains(text, std::string("#<kinstype> = ") + user_m.switchkins_target) &&
+        contains(text, "M68") &&
+        contains(text, "M68  E#<SWITCHKINS_PIN> Q#<kinstype>") &&
+        contains(text, "M66") &&
+        contains(text, "M66  E0 L0") &&
+        contains(text, std::string("G10 L2 ") + user_m.work_offset_pocket + " " + user_m.work_offset_words) &&
+        contains(text, user_m.active_g5x) &&
+        contains(text, "#<_hal[motion.switchkins-type]>") &&
+        contains(text, std::string("[#<_hal[motion.switchkins-type]> NE ") + user_m.switchkins_target + "]");
+    std::cout << remap_code << "_switchkins_output_pin=motion.analog-out-03\n";
+    std::cout << remap_code << "_switchkins_target=" << user_m.switchkins_target << "\n";
+    std::cout << remap_code << "_work_offset_pocket=" << user_m.work_offset_pocket << "\n";
+    std::cout << remap_code << "_work_offset_words=" << user_m.work_offset_words << "\n";
+    std::cout << remap_code << "_active_g5x=" << user_m.active_g5x << "\n";
+    print_bool(remap_code + "_calls_" + user_m.code, contains(text, user_m.code));
+    print_bool(remap_code + "_source_transition_from_linuxcnc", ok);
+    print_bool(std::string(user_m.code) + "_remap_calls_user_m_process", ok);
+    return ok;
+}
+
+bool check_user_m_case(const linuxcnc::IniFile &ini, const UserMCase &user_m)
+{
+    bool ok = true;
+    ok &= check_script(user_m);
+    ok &= check_remap_caller(user_m);
+    if (std::string(user_m.code) == "M128") {
+        ok &= check_axis_targets(ini, user_m, "X", "-300", "300", "60.0", "400.0");
+        ok &= check_axis_targets(ini, user_m, "Y", "-100", "100", "60.0", "400.0");
+        ok &= check_axis_targets(ini, user_m, "Z", "-240", "0", "60.0", "400.0");
+    } else {
+        ok &= check_axis_targets(ini, user_m, "X", "-240", "0", "60.0", "400.0");
+        ok &= check_axis_targets(ini, user_m, "Y", "-100", "100", "60.0", "400.0");
+        ok &= check_axis_targets(ini, user_m, "Z", "-300", "300", "60.0", "400.0");
+    }
+    print_bool(std::string(user_m.code) + "_source_state_targets_from_linuxcnc", ok);
+    return ok;
+}
+
+}  // namespace
+
+int main()
+{
+    const std::string ini_path = source_config_path("axis/vismach/millturn/millturn.ini");
+    linuxcnc::IniFile ini(ini_path);
+    const bool opened = static_cast<bool>(ini);
+    print_bool("millturn_ini_open", opened);
+    if (!opened) {
+        return 1;
+    }
+
+    bool ok = true;
+    ok &= check_ini_value(ini, "millturn", "RS274NGC", "USER_M_PATH", "./mcodes");
+    ok &= check_ini_value(ini, "millturn", "RS274NGC", "SUBROUTINE_PATH", "./remap_subs");
+    ok &= check_ini_value(ini, "millturn", "DISPLAY", "PYVCP", "millturn.xml");
+    ok &= check_ini_value(ini, "millturn", "HAL", "HALUI", "halui");
+    ok &= check_ini_value(
+        ini,
+        "millturn",
+        "HAL",
+        "HALCMD",
+        "net :kinstype-select <= motion.analog-out-03 => motion.switchkins-type");
+
+    const UserMCase cases[] = {
+        {
+            "M128",
+            "M428",
+            "axis/vismach/millturn/mcodes/M128",
+            "axis/vismach/millturn/remap_subs/428remap.ngc",
+            "mill",
+            "kinstype.is-0",
+            "0",
+            "G59.1",
+            "P7",
+            "X-290 Y0 Z-160 A0",
+            "MIN_LIMIT",
+            "MAX_LIMIT",
+        },
+        {
+            "M129",
+            "M429",
+            "axis/vismach/millturn/mcodes/M129",
+            "axis/vismach/millturn/remap_subs/429remap.ngc",
+            "turn",
+            "kinstype.is-1",
+            "1",
+            "G59.2",
+            "P8",
+            "X-160 Y0 Z-290 A0",
+            "MIN_LIMIT_TURN",
+            "MAX_LIMIT_TURN",
+        },
+    };
+
+    for (const auto &user_m : cases) {
+        std::cout << user_m.code << "_state_mode=" << user_m.state_mode << "\n";
+        std::cout << user_m.code << "_guard_pin=" << user_m.guard_pin << "\n";
+        ok &= check_user_m_case(ini, user_m);
+    }
+
+    print_bool("millturn_user_m_native_source_state_proof", ok);
+    print_bool("millturn_user_m_execution_enabled", false);
+    print_bool("millturn_user_m_promotion_allowed", false);
+    return ok ? 0 : 1;
+}
diff --git a/wasm-port/runtime/core/linuxcnc_wrap/linuxcnc_python_remap_boundary_probe.cpp b/wasm-port/runtime/core/linuxcnc_wrap/linuxcnc_python_remap_boundary_probe.cpp
new file mode 100644
index 0000000..f4318c6
--- /dev/null
+++ b/wasm-port/runtime/core/linuxcnc_wrap/linuxcnc_python_remap_boundary_probe.cpp
@@ -0,0 +1,189 @@
+#include <fstream>
+#include <iostream>
+#include <iterator>
+#include <string>
+
+#ifndef LINUXCNC_SOURCE_DIR
+#error "LINUXCNC_SOURCE_DIR must point at the LinuxCNC source tree"
+#endif
+
+#ifndef LINUXCNC_SOURCE_CONFIG_DIR
+#error "LINUXCNC_SOURCE_CONFIG_DIR must point at the LinuxCNC configs/sim tree"
+#endif
+
+namespace {
+
+std::string source_path(const std::string &rel)
+{
+    return std::string(LINUXCNC_SOURCE_DIR) + "/" + rel;
+}
+
+std::string source_config_path(const std::string &rel)
+{
+    return std::string(LINUXCNC_SOURCE_CONFIG_DIR) + "/" + rel;
+}
+
+std::string read_text(const std::string &path)
+{
+    std::ifstream input(path);
+    return std::string(
+        std::istreambuf_iterator<char>(input),
+        std::istreambuf_iterator<char>());
+}
+
+bool contains(const std::string &text, const std::string &needle)
+{
+    return text.find(needle) != std::string::npos;
+}
+
+void print_bool(const std::string &name, bool value)
+{
+    std::cout << name << "=" << (value ? 1 : 0) << "\n";
+}
+
+bool check_python_runtime_owner()
+{
+    const std::string interp_python = read_text(source_path("src/emc/rs274ngc/interp_python.cc"));
+    const std::string python_plugin = read_text(source_path("src/emc/pythonplugin/python_plugin.cc"));
+
+    const bool pycall_dispatch =
+        contains(interp_python, "PythonPlugin *python_plugin") &&
+        contains(interp_python, "Interp::pycall") &&
+        contains(interp_python, "python_plugin->call(module,funcname");
+    const bool remap_phases =
+        contains(interp_python, "PY_PROLOG") &&
+        contains(interp_python, "PY_BODY") &&
+        contains(interp_python, "PY_EPILOG");
+    const bool generator_finish =
+        contains(interp_python, "PyGen_Check(retval.ptr())") &&
+        contains(interp_python, "PY_FINISH_PROLOG") &&
+        contains(interp_python, "PY_FINISH_EPILOG");
+    const bool callable_lookup =
+        contains(interp_python, "Interp::is_pycallable") &&
+        contains(interp_python, "python_plugin->is_callable(module,funcname)");
+    const bool execute_runtime =
+        contains(interp_python, "Interp::py_execute") &&
+        contains(interp_python, "python_plugin->run_string(cmd, retval, as_file)");
+
+    const bool initializes_python =
+        contains(python_plugin, "PyConfig_InitPythonConfig(&config)") &&
+        contains(python_plugin, "Py_InitializeFromConfig(&config)");
+    const bool toplevel_exec =
+        contains(python_plugin, "findString(\"TOPLEVEL\", section)") &&
+        contains(python_plugin, "bp::exec_file(abs_path, main_namespace, main_namespace)");
+    const bool ini_python_path =
+        contains(python_plugin, "findString(n, \"PATH_PREPEND\", \"PYTHON\")") &&
+        contains(python_plugin, "findString(n, \"PATH_APPEND\", \"PYTHON\")") &&
+        contains(python_plugin, "PyRun_SimpleString(pycmd)");
+    const bool callable_invoke =
+        contains(python_plugin, "PythonPlugin::call") &&
+        contains(python_plugin, "PyObject_Call(function.ptr(), tupleargs.ptr(), kwargs.ptr())");
+    const bool reload_on_change =
+        contains(python_plugin, "PythonPlugin::reload") &&
+        contains(python_plugin, "reload_on_change");
+
+    print_bool("python_runtime_pycall_dispatch", pycall_dispatch);
+    print_bool("python_runtime_remap_phases", remap_phases);
+    print_bool("python_runtime_generator_finish", generator_finish);
+    print_bool("python_runtime_callable_lookup", callable_lookup);
+    print_bool("python_runtime_execute_runtime", execute_runtime);
+    print_bool("python_plugin_initializes_python", initializes_python);
+    print_bool("python_plugin_toplevel_exec_file", toplevel_exec);
+    print_bool("python_plugin_ini_python_path", ini_python_path);
+    print_bool("python_plugin_callable_invoke", callable_invoke);
+    print_bool("python_plugin_reload_on_change", reload_on_change);
+
+    return pycall_dispatch && remap_phases && generator_finish && callable_lookup &&
+        execute_runtime && initializes_python && toplevel_exec && ini_python_path &&
+        callable_invoke && reload_on_change;
+}
+
+bool check_axis_laser_family()
+{
+    const std::string ini = read_text(source_config_path("axis/laser/laser.ini"));
+    const std::string remap = read_text(source_config_path("axis/laser/python/remap.py"));
+    const bool ok =
+        contains(ini, "REMAP= M10 modalgroup=10 python=rasterStop") &&
+        contains(ini, "REMAP= M11 modalgroup=10 python=rasterBegin") &&
+        contains(ini, "REMAP= M12 modalgroup=10 python=rasterData") &&
+        contains(ini, "REMAP= M13 modalgroup=10 python=rasterStart") &&
+        contains(ini, "TOPLEVEL=python/toplevel.py") &&
+        contains(ini, "PATH_APPEND=python") &&
+        contains(remap, "def rasterBegin(self, **words):") &&
+        contains(remap, "def rasterData(self, **words):") &&
+        contains(remap, "def rasterStart(self, **words):") &&
+        contains(remap, "def rasterStop(self, **words):");
+    print_bool("python_family_axis_laser_inventory", ok);
+    return ok;
+}
+
+bool check_twp_nutating_family()
+{
+    const std::string ini = read_text(source_config_path(
+        "axis/vismach/5axis/table-rotary_spindle-rotary-nutating/xyzacb-trsrn_twp/xyzacb-trsrn.ini"));
+    const std::string remap = read_text(source_config_path(
+        "axis/vismach/5axis/table-rotary_spindle-rotary-nutating/python/remap.py"));
+    const bool ok =
+        contains(ini, "REMAP = G68.2") &&
+        contains(ini, "python=g682") &&
+        contains(ini, "REMAP = G68.3") &&
+        contains(ini, "python=g683") &&
+        contains(ini, "REMAP = G68.4") &&
+        contains(ini, "python=g684") &&
+        contains(ini, "python=g53x_core") &&
+        contains(ini, "python=g69_core") &&
+        contains(ini, "PATH_APPEND = ../python") &&
+        contains(ini, "TOPLEVEL = ../python/toplevel.py") &&
+        contains(remap, "def g53x_core(self):") &&
+        contains(remap, "def g69_core(self):") &&
+        contains(remap, "def g682(self, **words):") &&
+        contains(remap, "def g683(self, **words):") &&
+        contains(remap, "def g684(self, **words):");
+    print_bool("python_family_twp_nutating_inventory", ok);
+    return ok;
+}
+
+bool check_cycle_and_stdglue_families()
+{
+    const std::string cycle_ini = read_text(source_config_path("axis/remap/cycle/cycle.ini"));
+    const std::string cycle_remap = read_text(source_config_path("axis/remap/cycle/python/remap.py"));
+    const std::string stdglue = read_text(source_config_path(
+        "axis/nc_files/remap_lib/python-stdglue/stdglue.py"));
+    const std::string gmoccapy_stdglue = read_text(source_config_path("gmoccapy/python/stdglue.py"));
+
+    const bool cycle_ok =
+        contains(cycle_ini, "python=g842") &&
+        contains(cycle_ini, "prolog=cycle_prolog") &&
+        contains(cycle_ini, "epilog=cycle_epilog") &&
+        contains(cycle_ini, "PATH_PREPEND=./python") &&
+        contains(cycle_ini, "PATH_APPEND=../../nc_files/remap_lib/python-stdglue") &&
+        contains(cycle_remap, "def g842(self,**words):") &&
+        contains(stdglue, "def cycle_prolog(self,**words):") &&
+        contains(stdglue, "def cycle_epilog(self,**words):");
+
+    const bool gmoccapy_ok =
+        contains(gmoccapy_stdglue, "def settool_prolog(self,**words):") &&
+        contains(gmoccapy_stdglue, "def settool_epilog(self,**words):") &&
+        contains(gmoccapy_stdglue, "def change_prolog(self, **words):") &&
+        contains(gmoccapy_stdglue, "def change_epilog(self, **words):");
+
+    print_bool("python_family_axis_remap_cycle_inventory", cycle_ok);
+    print_bool("python_family_gmoccapy_stdglue_inventory", gmoccapy_ok);
+    return cycle_ok && gmoccapy_ok;
+}
+
+}  // namespace
+
+int main()
+{
+    bool ok = true;
+    ok &= check_python_runtime_owner();
+    ok &= check_axis_laser_family();
+    ok &= check_twp_nutating_family();
+    ok &= check_cycle_and_stdglue_families();
+
+    print_bool("python_remap_native_source_inventory_proof", ok);
+    print_bool("python_remap_execution_enabled", false);
+    print_bool("python_remap_promotion_allowed", false);
+    return ok ? 0 : 1;
+}
diff --git a/wasm-port/runtime/core/linuxcnc_wrap/linuxcnc_tool_db_boundary_probe.cpp b/wasm-port/runtime/core/linuxcnc_wrap/linuxcnc_tool_db_boundary_probe.cpp
new file mode 100644
index 0000000..6a761b5
--- /dev/null
+++ b/wasm-port/runtime/core/linuxcnc_wrap/linuxcnc_tool_db_boundary_probe.cpp
@@ -0,0 +1,177 @@
+#include <fstream>
+#include <iostream>
+#include <iterator>
+#include <string>
+
+#include "emc/ini/inifile.hh"
+
+#ifndef LINUXCNC_SOURCE_DIR
+#error "LINUXCNC_SOURCE_DIR must point at the LinuxCNC source tree"
+#endif
+
+#ifndef LINUXCNC_SOURCE_CONFIG_DIR
+#error "LINUXCNC_SOURCE_CONFIG_DIR must point at the LinuxCNC configs/sim tree"
+#endif
+
+namespace {
+
+std::string source_path(const std::string &rel)
+{
+    return std::string(LINUXCNC_SOURCE_DIR) + "/" + rel;
+}
+
+std::string source_config_path(const std::string &rel)
+{
+    return std::string(LINUXCNC_SOURCE_CONFIG_DIR) + "/" + rel;
+}
+
+std::string read_text(const std::string &path)
+{
+    std::ifstream input(path);
+    return std::string(
+        std::istreambuf_iterator<char>(input),
+        std::istreambuf_iterator<char>());
+}
+
+bool contains(const std::string &text, const std::string &needle)
+{
+    return text.find(needle) != std::string::npos;
+}
+
+void print_bool(const std::string &name, bool value)
+{
+    std::cout << name << "=" << (value ? 1 : 0) << "\n";
+}
+
+bool check_ini_value(
+    const linuxcnc::IniFile &ini,
+    const std::string &label,
+    const std::string &section,
+    const std::string &tag,
+    const std::string &expected)
+{
+    const auto actual = ini.findString(tag, section);
+    std::cout << label << "_" << section << "." << tag << "="
+              << (actual ? *actual : "<missing>") << "\n";
+    const bool ok = actual && *actual == expected;
+    print_bool(label + "_" + section + "." + tag + "_ok", ok);
+    return ok;
+}
+
+bool check_task_owner()
+{
+    const std::string text = read_text(source_path("src/emc/task/taskclass.cc"));
+    const bool db_init =
+        contains(text, "findString(\"DB_PROGRAM\", \"EMCIO\")") &&
+        contains(text, "tooldata_set_db(db_mode)") &&
+        contains(text, "tooldata_db_init(db_program, random_toolchanger)");
+    const bool tbl_ignored = contains(text, "DB_PROGRAM active: IGNORING tool table file");
+    const bool load_unload_notify =
+        contains(text, "tooldata_db_notify(SPINDLE_UNLOAD") &&
+        contains(text, "tooldata_db_notify(SPINDLE_LOAD");
+
+    print_bool("tool_db_task_db_mode_init", db_init);
+    print_bool("tool_db_task_ignores_tool_table_with_db_program", tbl_ignored);
+    print_bool("tool_db_task_load_unload_notify", load_unload_notify);
+    return db_init && tbl_ignored && load_unload_notify;
+}
+
+bool check_tooldata_db_owner()
+{
+    const std::string text = read_text(source_path("src/emc/tooldata/tooldata_db.cc"));
+    const bool child_process =
+        contains(text, "pipe2(pipes[PARENT_READ_PIPE]") &&
+        contains(text, "pipe2(pipes[PARENT_WRITE_PIPE]") &&
+        contains(text, "fork()") &&
+        contains(text, "execv(myargv[0], myargv)");
+    const bool executable_check =
+        contains(text, "access(child_argv[0],X_OK)") &&
+        contains(text, "not executable");
+    const bool version_handshake =
+        contains(text, "#define DB_VERSION \"v2.1\"") &&
+        contains(text, "read_reply(reply,sizeof(reply))") &&
+        contains(text, "strncmp(reply,DB_VERSION");
+    const bool getall =
+        contains(text, "send_request((char*)\"g\\n\")") &&
+        contains(text, "tooldata_reset()") &&
+        contains(text, "strstr(reply,\"FINI\")") &&
+        contains(text, "tooldata_read_entry(reply)");
+    const bool notify =
+        contains(text, "snprintf(msg,sizeof(msg),\"l %s\\n\",buffer)") &&
+        contains(text, "snprintf(msg,sizeof(msg),\"u %s\\n\",buffer)") &&
+        contains(text, "snprintf(msg,sizeof(msg),\"p %s\\n\",buffer)") &&
+        contains(text, "send_and_verify(msg)");
+
+    print_bool("tool_db_child_process_boundary", child_process);
+    print_bool("tool_db_program_executable_check", executable_check);
+    print_bool("tool_db_v2_1_handshake", version_handshake);
+    print_bool("tool_db_getall_g_until_fini", getall);
+    print_bool("tool_db_notify_l_u_p_protocol", notify);
+    return child_process && executable_check && version_handshake && getall && notify;
+}
+
+bool check_db_program_owner()
+{
+    const std::string text = read_text(source_config_path("axis/db_demo/db.py"));
+    const bool imports =
+        contains(text, "from tooldb import tooldb_callbacks") &&
+        contains(text, "from tooldb import tooldb_tools") &&
+        contains(text, "from tooldb import tooldb_loop");
+    const bool callbacks =
+        contains(text, "def user_get_tool(tno):") &&
+        contains(text, "def user_put_tool(tno,params):") &&
+        contains(text, "def user_load_spindle_nonran_tc(tno,params):") &&
+        contains(text, "def user_unload_spindle_nonran_tc(tno,params):") &&
+        contains(text, "tooldb_callbacks(user_get_tool") &&
+        contains(text, "tooldb_tools(toollist)") &&
+        contains(text, "tooldb_loop()");
+    const bool state_targets =
+        contains(text, "db_nonran_savefile = \"/tmp/db_nonran_file\"") &&
+        contains(text, "toolno_min = 10") &&
+        contains(text, "toolno_max = 19") &&
+        contains(text, "pocket_offset      = 100") &&
+        contains(text, "return tno+pocket_offset") &&
+        contains(text, "D['P'] = \"0\"") &&
+        contains(text, "nonran_restore_pocket(spindle_tool)") &&
+        contains(text, "linuxcnc.command().load_tool_table") &&
+        contains(text, "save_tools_to_file(db_savefile");
+    const bool reload_rules =
+        contains(text, "apply_db_rules()") &&
+        contains(text, "G10L0");
+
+    print_bool("tool_db_program_tooldb_module", imports);
+    print_bool("tool_db_program_nonran_callbacks", callbacks);
+    print_bool("tool_db_program_nonran_state_targets", state_targets);
+    print_bool("tool_db_program_reload_rules", reload_rules);
+    return imports && callbacks && state_targets && reload_rules;
+}
+
+}  // namespace
+
+int main()
+{
+    const std::string ini_path = source_config_path("axis/db_demo/db_nonran.ini");
+    const std::string ini_text = read_text(ini_path);
+    linuxcnc::IniFile ini(ini_path);
+    const bool opened = static_cast<bool>(ini);
+    print_bool("db_nonran_ini_open", opened);
+    if (!opened) {
+        return 1;
+    }
+
+    bool ok = true;
+    ok &= check_ini_value(ini, "db_nonran", "EMCIO", "RANDOM_TOOLCHANGER", "0");
+    ok &= check_ini_value(ini, "db_nonran", "EMCIO", "DB_PROGRAM", "./db_nonran.py");
+    const bool tool_table_ignored = contains(ini_text, "TOOL_TABLE= is not used with DB_PROGRAM");
+    print_bool("db_nonran_tool_table_ignored_with_db_program", tool_table_ignored);
+    ok &= tool_table_ignored;
+
+    ok &= check_task_owner();
+    ok &= check_tooldata_db_owner();
+    ok &= check_db_program_owner();
+
+    print_bool("tool_db_native_source_protocol_proof", ok);
+    print_bool("tool_db_execution_enabled", false);
+    print_bool("tool_db_promotion_allowed", false);
+    return ok ? 0 : 1;
+}
diff --git a/wasm-port/runtime/sdk/README.md b/wasm-port/runtime/sdk/README.md
index e014d57..a949551 100644
--- a/wasm-port/runtime/sdk/README.md
+++ b/wasm-port/runtime/sdk/README.md
@@ -23,6 +23,7 @@ Use `src/index.js` for stable imports:
 
 ```js
 import {
+  analyzeIniRuntimeBoundaries,
   createLinuxCncIniSdk,
   createLinuxCncInterpSdk,
   planIniFileContextStaging,
@@ -104,6 +105,20 @@ source manifest text, machine relative path, INI file name, and INI text. It
 uses `planIniFileContextStaging()` with a `configs/sim/<machine>` source root
 and `configs/sim` upward-search boundary.
 
+`analyzeIniRuntimeBoundaries()` is a host-boundary classifier for LinuxCNC
+INI-driven runs. It reads INI text plus optional execution text and manifest
+text, then reports declared HAL, UI, HALUI MDI, Python, tool-database, and
+external user-M process dependencies. User-M accounting is per execution code:
+`executionCodes` lists `M100..M199` codes seen in the supplied execution text,
+while `unstagedExecutionCodes` lists the subset not backed by vendored
+`USER_M_PATH` files. Python accounting keeps UI/DB references separate from
+Python remap runtime references, so a UI handler or DB program does not imply
+Python-remap coverage. It also returns the currently recommended Layer 4
+blocked kind for hard process boundaries such as `L4-TOOL-DB` and
+`L4-USER-M-PROCESS`. The classifier is policy/accounting only: it does not
+execute HAL, task, UI, Python, user-M, or tool-database behavior and does not
+change interpreter semantics.
+
 `runFileWithIniContinueOnError()` uses the same LinuxCNC-backed file execution
 path but keeps the runner loop going after LinuxCNC reports an error, matching
 upstream `rs274 -n 0` regression tests such as `tests/interp/oword-unwind`.
diff --git a/wasm-port/runtime/sdk/src/index.js b/wasm-port/runtime/sdk/src/index.js
index 49dbfc8..1d16764 100644
--- a/wasm-port/runtime/sdk/src/index.js
+++ b/wasm-port/runtime/sdk/src/index.js
@@ -1,6 +1,7 @@
 export { createLinuxCncIniSdk } from "./linuxcnc-ini.js";
 export { createLinuxCncInterpSdk } from "./linuxcnc-interp.js";
 export {
+  analyzeIniRuntimeBoundaries,
   planIniFileContextStaging,
   planSimConfigStaging,
 } from "./sim-config-staging.js";
diff --git a/wasm-port/runtime/sdk/src/sim-config-staging.js b/wasm-port/runtime/sdk/src/sim-config-staging.js
index 0944af8..b5a05c6 100644
--- a/wasm-port/runtime/sdk/src/sim-config-staging.js
+++ b/wasm-port/runtime/sdk/src/sim-config-staging.js
@@ -172,6 +172,197 @@ function remapNgcNames(iniValues) {
   return names;
 }
 
+function sectionValues(iniValues, section) {
+  const prefix = `${section.toUpperCase()}.`;
+  const values = [];
+  for (const [key, entries] of iniValues.entries()) {
+    if (!key.startsWith(prefix)) {
+      continue;
+    }
+    for (const value of entries) {
+      values.push({ key: key.slice(prefix.length), value });
+    }
+  }
+  return values;
+}
+
+function valuesMatching(iniValues, section, keys) {
+  const wanted = new Set(keys.map((key) => key.toUpperCase()));
+  return sectionValues(iniValues, section)
+    .filter((entry) => wanted.has(entry.key))
+    .map((entry) => entry.value);
+}
+
+function looksLikePythonReference(value) {
+  return /(^|\s|=|:)["']?[^"'\s]*\.py(["'\s]|$)/i.test(value);
+}
+
+function userMCodesInText(text) {
+  const codes = new Set();
+  for (const match of text.matchAll(/(?<![A-Za-z0-9_])M\s*(1\d\d)(?![0-9])/gi)) {
+    codes.add(`M${match[1]}`);
+  }
+  return [...codes].sort();
+}
+
+function vendoredUserMCodes({
+  manifestEntries,
+  sourceDir,
+  normalizedSearchRoot,
+  userMPathValues,
+}) {
+  const manifestSet = new Set(manifestEntries);
+  const executableCodes = new Set();
+  for (const dirEntry of userMPathValues.flatMap(splitSearchPath)) {
+    if (dirEntry.startsWith("/")) {
+      continue;
+    }
+    const sourceUserMDir = normalizeRel(`${sourceDir}/${dirEntry}`);
+    const prefix = sourceUserMDir ? `${sourceUserMDir}/` : "";
+    for (const sourceRel of manifestEntries) {
+      if (
+        sourceRel.startsWith(prefix) &&
+        !sourceRel.slice(prefix.length).includes("/") &&
+        isUserMCodePath(sourceRel)
+      ) {
+        executableCodes.add(basename(sourceRel).toUpperCase());
+      }
+    }
+  }
+
+  for (const dirEntry of userMPathValues.flatMap(splitSearchPath)) {
+    if (dirEntry.startsWith("/")) {
+      continue;
+    }
+    const sourceUserMDir = normalizeRel(`${sourceDir}/${dirEntry}`);
+    for (let code = 100; code <= 199; code += 1) {
+      const candidate = findUpwardByBasename(
+        manifestSet,
+        sourceUserMDir,
+        `M${code}`,
+        normalizedSearchRoot,
+      );
+      if (candidate) {
+        executableCodes.add(`M${code}`);
+      }
+    }
+  }
+
+  return [...executableCodes].sort();
+}
+
+export function analyzeIniRuntimeBoundaries({
+  manifestText = "",
+  sourceRootRel,
+  sourceSearchRootRel = sourceRootRel,
+  iniFile = "",
+  iniText,
+  executionTexts = [],
+}) {
+  const manifestEntries = cleanManifest(manifestText);
+  const iniValues = parseIni(iniText);
+  const normalizedSourceRoot = normalizeRel(sourceRootRel);
+  const normalizedSearchRoot = normalizeRel(sourceSearchRootRel);
+  const sourceDir = normalizeRel(`${normalizedSourceRoot}/${dirname(iniFile)}`);
+  const userMPathValues = allIniValues(iniValues, "RS274NGC", "USER_M_PATH");
+  const halValues = valuesMatching(iniValues, "HAL", [
+    "HALFILE",
+    "HALCMD",
+    "POSTGUI_HALFILE",
+    "HALUI",
+  ]);
+  const displayValues = valuesMatching(iniValues, "DISPLAY", [
+    "DISPLAY",
+    "PYVCP",
+    "GLADEVCP",
+    "EMBED_TAB_COMMAND",
+  ]);
+  const halUiMdiCommands = allIniValues(iniValues, "HALUI", "MDI_COMMAND");
+  const dbProgram = firstIniValue(iniValues, "EMCIO", "DB_PROGRAM");
+  const remapValues = allIniValues(iniValues, "RS274NGC", "REMAP");
+  const pythonRemapReferences = [
+    ...sectionValues(iniValues, "PYTHON").map((entry) => entry.value),
+    ...remapValues.filter((value) => /(?:^|\s)python=/i.test(value)),
+  ];
+  const pythonUiReferences = [
+    ...displayValues.filter(looksLikePythonReference),
+    ...(dbProgram && looksLikePythonReference(dbProgram) ? [dbProgram] : []),
+  ];
+  const pythonReferences = [...pythonRemapReferences, ...pythonUiReferences];
+  const vendoredUserMCodeList = vendoredUserMCodes({
+    manifestEntries,
+    sourceDir,
+    normalizedSearchRoot,
+    userMPathValues,
+  });
+  const vendoredUserMCodeSet = new Set(vendoredUserMCodeList);
+  const hasUserMPath = userMPathValues.length > 0;
+  const executionUserMCodes = [...new Set(executionTexts.flatMap(userMCodesInText))].sort();
+  const unstagedExecutionUserMCodes = executionUserMCodes
+    .filter((code) => !vendoredUserMCodeSet.has(code));
+  const hasExternalUserMUse = hasUserMPath && unstagedExecutionUserMCodes.length > 0;
+
+  const dependencies = [];
+  if (dbProgram) {
+    dependencies.push("tool_database_process");
+  }
+  if (halValues.length > 0) {
+    dependencies.push("hal_process");
+  }
+  if (displayValues.some((value) => !/^axis$/i.test(value))) {
+    dependencies.push("ui_process");
+  }
+  if (halUiMdiCommands.length > 0) {
+    dependencies.push("halui_mdi_process");
+  }
+  if (pythonReferences.length > 0) {
+    dependencies.push("python_runtime");
+  }
+  if (hasExternalUserMUse) {
+    dependencies.push("external_user_m_process");
+  }
+
+  let recommendedBlockedKind = "-";
+  if (dbProgram) {
+    recommendedBlockedKind = "L4-TOOL-DB";
+  } else if (hasExternalUserMUse) {
+    recommendedBlockedKind = "L4-USER-M-PROCESS";
+  } else if (pythonRemapReferences.length > 0) {
+    recommendedBlockedKind = "L4-PYTHON-REMAP";
+  }
+
+  return {
+    dependencies: [...new Set(dependencies)].sort(),
+    recommendedBlockedKind,
+    toolDatabaseProgram: dbProgram ?? "",
+    halRuntime: {
+      values: halValues,
+      requiresProcess: halValues.length > 0,
+    },
+    uiRuntime: {
+      values: displayValues,
+      requiresProcess: displayValues.some((value) => !/^axis$/i.test(value)),
+    },
+    haluiRuntime: {
+      mdiCommands: halUiMdiCommands,
+      requiresProcess: halUiMdiCommands.length > 0,
+    },
+    userMRuntime: {
+      paths: userMPathValues,
+      vendoredExecutableCount: vendoredUserMCodeList.length,
+      executionCodes: executionUserMCodes,
+      unstagedExecutionCodes: unstagedExecutionUserMCodes,
+      requiresExternalProcess: hasExternalUserMUse,
+    },
+    pythonRuntime: {
+      references: pythonReferences,
+      remapReferences: pythonRemapReferences,
+      uiReferences: pythonUiReferences,
+      requiresProcess: pythonReferences.length > 0,
+    },
+  };
+}
+
 export function planSimConfigStaging({
   manifestText,
   machineRel,
diff --git a/wasm-port/tests/browser/interp_smoke.html b/wasm-port/tests/browser/interp_smoke.html
index 29505ec..a03c020 100644
--- a/wasm-port/tests/browser/interp_smoke.html
+++ b/wasm-port/tests/browser/interp_smoke.html
@@ -8,6 +8,7 @@
   <pre id="status">running</pre>
   <script type="module">
     import {
+      analyzeIniRuntimeBoundaries,
       createLinuxCncIniSdk,
       createLinuxCncInterpSdk,
       planIniFileContextStaging,
@@ -67,6 +68,1464 @@
       }
     }
 
+    function parseTsv(text) {
+      const [headerLine, ...lines] = text.trim().split("\n");
+      const headers = headerLine.split("\t");
+      return lines.filter(Boolean).map((line) => {
+        const values = line.split("\t");
+        return Object.fromEntries(headers.map((header, index) => [header, values[index] ?? ""]));
+      });
+    }
+
+    async function verifyBrowserBoundaryPhaseCompletion() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/boundary-phase-completion-summary.tsv"),
+      );
+      const expectedCriteria = [
+        "vendored_runtime_boundary_reports",
+        "hard_block_dependency_evidence",
+        "safe_hal_ui_representatives",
+        "blocked_families_not_promoted",
+        "linuxcnc_runtime_owner_proof",
+        "native_source_proof_alignment",
+        "runtime_native_alignment_artifacts",
+        "native_runtime_probe_summary",
+        "user_m_transition_contract",
+        "user_m_native_runtime_state_plan",
+        "user_m_native_runtime_readiness",
+        "user_m_native_runtime_probe_gate",
+        "tool_db_transaction_contract",
+        "tool_db_native_runtime_readiness",
+        "python_runtime_contract",
+        "python_native_runtime_readiness",
+        "python_native_runtime_state_plan",
+        "python_native_runtime_fixture_plan",
+        "runtime_contract_summary",
+      ];
+      const actualCriteria = rows.map((row) => row.criterion).join(",");
+      if (actualCriteria !== expectedCriteria.join(",")) {
+        throw new Error(`browser_boundary_phase_completion: criterion drift ${actualCriteria}`);
+      }
+      for (const row of rows) {
+        if (row.passed !== "1") {
+          throw new Error(`${row.criterion}: boundary phase completion failed`);
+        }
+        if (!/^[1-9][0-9]*$/.test(row.count)) {
+          throw new Error(`${row.criterion}: invalid completion count ${row.count}`);
+        }
+        if (row.evidence === "-") {
+          throw new Error(`${row.criterion}: missing completion evidence`);
+        }
+      }
+    }
+
+    async function verifyBrowserIniBoundarySummary() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/ini-boundary-summary.tsv"),
+      );
+      const byIni = new Map(rows.map((row) => [row.ini, row]));
+      const requiredVendoredInis = new Map([
+        ["axis/db_demo/db_nonran.ini", "L4-TOOL-DB"],
+        ["axis/gladevcp/gladevcp_panel.ini", "-"],
+        ["axis/vismach/melfa-sim/melfa.ini", "-"],
+        ["axis/vismach/millturn/millturn.ini", "L4-USER-M-PROCESS"],
+        ["axis/vismach/puma/puma_cube.ini", "-"],
+        ["woodpecker/woodpecker.ini", "-"],
+      ]);
+
+      for (const [ini, expectedRecommendation] of requiredVendoredInis) {
+        const row = byIni.get(ini);
+        if (!row) {
+          throw new Error(`browser_ini_boundary_summary: missing ${ini}`);
+        }
+        if (row.vendored !== "1" || row.report_available !== "1") {
+          throw new Error(`${ini}: vendored INI boundary report unavailable`);
+        }
+        if (!row.recommended_blocked.split(",").includes(expectedRecommendation)) {
+          throw new Error(`${ini}: recommended block drift ${row.recommended_blocked}`);
+        }
+        if (row.hard_block_policy_aligned !== "1") {
+          throw new Error(`${ini}: hard-block policy alignment failed`);
+        }
+      }
+    }
+
+    async function verifyBrowserBoundaryProofGates() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/boundary-proof-gates.tsv"),
+      );
+      const browserRows = rows.filter((row) => row.proof_layer === "browser");
+      const browserByTarget = new Map(browserRows.map((row) => [row.target, row]));
+      const requiredBlockedTargets = new Map([
+        [
+          "axis/vismach/millturn/example.ngc",
+          {
+            blocked: "L4-USER-M-PROCESS",
+            proof: "no_full_process_claim",
+            nextAction: "design_m128_m129_linuxcnc_state_boundary",
+          },
+        ],
+        [
+          "axis/db_demo/base.ngc",
+          {
+            blocked: "L4-TOOL-DB",
+            proof: "opfs_persistence_only",
+            nextAction: "design_tooldata_db_protocol_boundary",
+          },
+        ],
+      ]);
+
+      if (browserRows.length === 0) {
+        throw new Error("browser_boundary_proof_gates: missing browser proof rows");
+      }
+
+      for (const [target, expected] of requiredBlockedTargets) {
+        const row = browserByTarget.get(target);
+        if (!row) {
+          throw new Error(`browser_boundary_proof_gates: missing ${target}`);
+        }
+        if (row.blocked !== expected.blocked) {
+          throw new Error(`${target}: blocked gate drift ${row.blocked}`);
+        }
+        if (row.proof_status !== "pending") {
+          throw new Error(`${target}: browser proof gate must remain pending`);
+        }
+        if (row.execution_enabled !== "0" || row.promotion_allowed !== "0") {
+          throw new Error(`${target}: browser proof gate must not enable execution or promotion`);
+        }
+        if (!row.required_proof.includes(expected.proof)) {
+          throw new Error(`${target}: browser proof gate missing ${expected.proof}`);
+        }
+        if (row.next_action !== expected.nextAction) {
+          throw new Error(`${target}: next action drift ${row.next_action}`);
+        }
+      }
+
+      for (const row of browserRows.filter((entry) => entry.boundary_kind === "python_runtime")) {
+        if (row.blocked !== "L4-PYTHON-REMAP") {
+          throw new Error(`${row.target}: Python browser proof gate blocked kind drift`);
+        }
+        if (row.proof_status !== "pending") {
+          throw new Error(`${row.target}: Python browser proof gate must remain pending`);
+        }
+        if (row.execution_enabled !== "0" || row.promotion_allowed !== "0") {
+          throw new Error(`${row.target}: Python browser proof gate must stay disabled`);
+        }
+        if (!row.required_proof.includes("no_full_process_claim")) {
+          throw new Error(`${row.target}: Python browser proof gate must avoid full-process claim`);
+        }
+      }
+    }
+
+    async function verifyBrowserBoundarySummary() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/boundary-summary.tsv"),
+      );
+      const byPath = new Map(rows.map((row) => [row.path, row]));
+      const safeRepresentatives = new Map([
+        [
+          "axis/gladevcp/probe.ngc",
+          {
+            dependencies: "hal_process,python_runtime,ui_process",
+            hal_process: "1",
+            ui_process: "1",
+            halui_mdi_process: "0",
+            python_process: "1",
+            python_remap_process: "0",
+          },
+        ],
+        [
+          "axis/vismach/melfa-sim/example.ngc",
+          {
+            dependencies: "hal_process,halui_mdi_process,ui_process",
+            hal_process: "1",
+            ui_process: "1",
+            halui_mdi_process: "1",
+            python_process: "0",
+            python_remap_process: "0",
+          },
+        ],
+        [
+          "axis/vismach/puma/puma_cube.ngc",
+          {
+            dependencies: "hal_process,halui_mdi_process,ui_process",
+            hal_process: "1",
+            ui_process: "1",
+            halui_mdi_process: "1",
+            python_process: "0",
+            python_remap_process: "0",
+          },
+        ],
+        [
+          "woodpecker/on_abort.ngc",
+          {
+            dependencies: "hal_process,ui_process",
+            hal_process: "1",
+            ui_process: "1",
+            halui_mdi_process: "0",
+            python_process: "0",
+            python_remap_process: "0",
+          },
+        ],
+      ]);
+
+      for (const [path, expected] of safeRepresentatives) {
+        const row = byPath.get(path);
+        if (!row) {
+          throw new Error(`browser_boundary_summary: missing safe representative ${path}`);
+        }
+        if (row.blocked !== "-" || row.recommended_blocked !== "-") {
+          throw new Error(`${path}: safe representative must not be hard-blocked`);
+        }
+        if (row.dependencies !== expected.dependencies) {
+          throw new Error(`${path}: dependency drift ${row.dependencies}`);
+        }
+        for (const field of [
+          "hal_process",
+          "ui_process",
+          "halui_mdi_process",
+          "python_process",
+          "python_remap_process",
+        ]) {
+          if (row[field] !== expected[field]) {
+            throw new Error(`${path}: ${field} drift ${row[field]}`);
+          }
+        }
+      }
+
+      const millturn = byPath.get("axis/vismach/millturn/example.ngc");
+      if (!millturn) {
+        throw new Error("browser_boundary_summary: missing millturn blocked row");
+      }
+      if (
+        millturn.blocked !== "L4-USER-M-PROCESS" ||
+        millturn.recommended_blocked !== "L4-USER-M-PROCESS"
+      ) {
+        throw new Error("millturn boundary summary must remain L4-USER-M-PROCESS");
+      }
+      if (
+        millturn.user_m_execution_codes !== "M128,M129" ||
+        millturn.user_m_unstaged_execution_codes !== "M128,M129"
+      ) {
+        throw new Error("millturn boundary summary must keep M128/M129 unstaged");
+      }
+    }
+
+    async function verifyBrowserUserMTransitionPlan() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/user-m-process-transition-plan.tsv"),
+      );
+      const expected = new Map([
+        [
+          "M128",
+          {
+            remapCode: "M428",
+            switchkinsTarget: "0",
+            activeG5x: "G59.1",
+            workOffsetPocket: "P7",
+            guardPin: "kinstype.is-0",
+            stateMode: "mill",
+          },
+        ],
+        [
+          "M129",
+          {
+            remapCode: "M429",
+            switchkinsTarget: "1",
+            activeG5x: "G59.2",
+            workOffsetPocket: "P8",
+            guardPin: "kinstype.is-1",
+            stateMode: "turn",
+          },
+        ],
+      ]);
+      const byCode = new Map(rows.map((row) => [row.user_m_code, row]));
+
+      if (rows.length !== expected.size) {
+        throw new Error(`browser_user_m_transition_plan: row count drift ${rows.length}`);
+      }
+
+      for (const [code, expectedRow] of expected) {
+        const row = byCode.get(code);
+        if (!row) {
+          throw new Error(`browser_user_m_transition_plan: missing ${code}`);
+        }
+        if (
+          row.path !== "axis/vismach/millturn/example.ngc" ||
+          row.blocked !== "L4-USER-M-PROCESS" ||
+          row.remap_code !== expectedRow.remapCode
+        ) {
+          throw new Error(`${code}: transition plan identity drift`);
+        }
+        if (
+          row.switchkins_output_pin !== "motion.analog-out-03" ||
+          row.switchkins_target !== expectedRow.switchkinsTarget ||
+          row.active_g5x !== expectedRow.activeG5x ||
+          row.work_offset_pocket !== expectedRow.workOffsetPocket ||
+          row.guard_pin !== expectedRow.guardPin ||
+          row.state_mode !== expectedRow.stateMode
+        ) {
+          throw new Error(`${code}: transition plan state drift`);
+        }
+        if (row.state_target_count !== "12") {
+          throw new Error(`${code}: transition plan state target count drift`);
+        }
+        for (const pin of ["ini.x.min_limit", "ini.y.min_velocity", "ini.z.max_acceleration"]) {
+          if (!row.expected_state_pins.includes(pin)) {
+            throw new Error(`${code}: transition plan missing ${pin}`);
+          }
+        }
+        if (
+          row.proof_status !== "pending" ||
+          row.execution_enabled !== "0" ||
+          row.promotion_allowed !== "0"
+        ) {
+          throw new Error(`${code}: transition plan must remain pending and disabled`);
+        }
+        if (!row.notes.includes("no_process_execution")) {
+          throw new Error(`${code}: transition plan must record non-execution policy`);
+        }
+      }
+    }
+
+    async function verifyBrowserUserMNativeTransitionAlignment() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/user-m-process-native-transition-alignment.tsv"),
+      );
+      const expected = new Map([
+        [
+          "M428",
+          {
+            userMCode: "M128",
+            switchkinsTarget: "0",
+            activeG5x: "G59.1",
+            workOffsetPocket: "P7",
+          },
+        ],
+        [
+          "M429",
+          {
+            userMCode: "M129",
+            switchkinsTarget: "1",
+            activeG5x: "G59.2",
+            workOffsetPocket: "P8",
+          },
+        ],
+      ]);
+      const byRemap = new Map(rows.map((row) => [row.remap_code, row]));
+
+      if (rows.length !== expected.size) {
+        throw new Error(`browser_user_m_native_transition_alignment: row count drift ${rows.length}`);
+      }
+
+      for (const [remapCode, expectedRow] of expected) {
+        const row = byRemap.get(remapCode);
+        if (!row) {
+          throw new Error(`browser_user_m_native_transition_alignment: missing ${remapCode}`);
+        }
+        if (
+          row.path !== "axis/vismach/millturn/example.ngc" ||
+          row.blocked !== "L4-USER-M-PROCESS" ||
+          row.user_m_code !== expectedRow.userMCode
+        ) {
+          throw new Error(`${remapCode}: native transition alignment identity drift`);
+        }
+        if (
+          row.switchkins_output_pin !== "motion.analog-out-03" ||
+          row.native_switchkins_output_pin !== row.switchkins_output_pin ||
+          row.switchkins_target !== expectedRow.switchkinsTarget ||
+          row.native_switchkins_target !== row.switchkins_target ||
+          row.active_g5x !== expectedRow.activeG5x ||
+          row.native_active_g5x !== row.active_g5x ||
+          row.work_offset_pocket !== expectedRow.workOffsetPocket ||
+          row.native_work_offset_pocket !== row.work_offset_pocket
+        ) {
+          throw new Error(`${remapCode}: native transition alignment state drift`);
+        }
+        if (
+          row.native_call_key !== `${remapCode}_calls_${expectedRow.userMCode}` ||
+          row.native_call_value !== "1" ||
+          row.native_transition_key !== `${remapCode}_source_transition_from_linuxcnc` ||
+          row.native_transition_value !== "1" ||
+          row.alignment_ok !== "1"
+        ) {
+          throw new Error(`${remapCode}: native transition source proof drift`);
+        }
+        if (
+          row.proof_status !== "pending" ||
+          row.execution_enabled !== "0" ||
+          row.promotion_allowed !== "0"
+        ) {
+          throw new Error(`${remapCode}: native transition alignment must remain pending and disabled`);
+        }
+        if (!row.notes.includes("no_process_execution")) {
+          throw new Error(`${remapCode}: native transition alignment must record non-execution policy`);
+        }
+      }
+    }
+
+    async function verifyBrowserUserMNativeRuntimeStatePlan() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/user-m-process-native-runtime-state-plan.tsv"),
+      );
+      const expected = new Map([
+        ["M428", { userMCode: "M128", target: "0", g5x: "G59.1", pocket: "P7" }],
+        ["M429", { userMCode: "M129", target: "1", g5x: "G59.2", pocket: "P8" }],
+      ]);
+      const byRemap = new Map(rows.map((row) => [row.remap_code, row]));
+
+      if (rows.length !== expected.size) {
+        throw new Error(`browser_user_m_native_runtime_state_plan: row count drift ${rows.length}`);
+      }
+
+      for (const [remapCode, expectedRow] of expected) {
+        const row = byRemap.get(remapCode);
+        if (!row) {
+          throw new Error(`browser_user_m_native_runtime_state_plan: missing ${remapCode}`);
+        }
+        if (
+          row.path !== "axis/vismach/millturn/example.ngc" ||
+          row.blocked !== "L4-USER-M-PROCESS" ||
+          row.user_m_code !== expectedRow.userMCode ||
+          row.required_runtime !== "linuxcnc_task_hal_tcl_user_m_process"
+        ) {
+          throw new Error(`${remapCode}: runtime state plan identity drift`);
+        }
+        for (const token of ["INI_FILE_NAME", "motion.switchkins-type", "kinstype.is-0", "kinstype.is-1", "ini.[xyz].*"]) {
+          if (!row.required_environment.includes(token)) {
+            throw new Error(`${remapCode}: runtime state plan missing environment ${token}`);
+          }
+        }
+        if (
+          row.switchkins_output_pin !== "motion.analog-out-03" ||
+          row.switchkins_target !== expectedRow.target ||
+          row.active_g5x !== expectedRow.g5x ||
+          row.work_offset_pocket !== expectedRow.pocket ||
+          row.state_target_count !== "12" ||
+          row.source_alignment_ok !== "1"
+        ) {
+          throw new Error(`${remapCode}: runtime state plan state drift`);
+        }
+        if (
+          !row.source_alignment_artifacts.includes("user-m-process-native-transition-alignment.tsv") ||
+          !row.source_alignment_artifacts.includes("user-m-process-native-state-alignment.tsv")
+        ) {
+          throw new Error(`${remapCode}: runtime state plan missing source alignment artifacts`);
+        }
+        if (
+          row.native_runtime_status !== "pending_native_hal_tcl_process_probe" ||
+          row.proof_kind !== "native_runtime_state_probe_required" ||
+          row.proof_status !== "pending" ||
+          row.execution_enabled !== "0" ||
+          row.promotion_allowed !== "0"
+        ) {
+          throw new Error(`${remapCode}: runtime state plan must remain pending and disabled`);
+        }
+        if (!row.notes.includes("keep_millturn_blocked")) {
+          throw new Error(`${remapCode}: runtime state plan must keep millturn blocked`);
+        }
+      }
+    }
+
+    async function verifyBrowserUserMNativeRuntimeReadiness() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/user-m-process-native-runtime-readiness.tsv"),
+      );
+      const expectedRequirements = ["tclsh", "halrun", "halcmd", "linuxcnc"];
+
+      if (rows.map((row) => row.requirement).join(",") !== expectedRequirements.join(",")) {
+        throw new Error("browser_user_m_native_runtime_readiness: requirement order drift");
+      }
+
+      for (const row of rows) {
+        if (
+          row.path !== "axis/vismach/millturn/example.ngc" ||
+          row.blocked !== "L4-USER-M-PROCESS" ||
+          row.required_runtime !== "linuxcnc_task_hal_tcl_user_m_process" ||
+          row.requirement_kind !== "host_command"
+        ) {
+          throw new Error(`${row.requirement}: runtime readiness identity drift`);
+        }
+        if (!["0", "1"].includes(row.available)) {
+          throw new Error(`${row.requirement}: invalid readiness availability ${row.available}`);
+        }
+        if (row.available === "1" && row.evidence === "-") {
+          throw new Error(`${row.requirement}: available runtime command lacks evidence`);
+        }
+        if (
+          ![
+            "blocked_missing_host_runtime",
+            "host_runtime_available_probe_not_implemented",
+          ].includes(row.native_runtime_status)
+        ) {
+          throw new Error(`${row.requirement}: invalid runtime readiness status`);
+        }
+        if (
+          row.proof_kind !== "native_runtime_state_probe_required" ||
+          row.proof_status !== "pending" ||
+          row.execution_enabled !== "0" ||
+          row.promotion_allowed !== "0"
+        ) {
+          throw new Error(`${row.requirement}: runtime readiness must remain pending and disabled`);
+        }
+        if (
+          !row.notes.includes("keep_millturn_blocked") &&
+          !row.notes.includes("probe_still_not_implemented")
+        ) {
+          throw new Error(`${row.requirement}: runtime readiness must keep blocked state`);
+        }
+      }
+    }
+
+    async function verifyBrowserUserMNativeRuntimeProbeGate() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/user-m-process-native-runtime-probe-gate.tsv"),
+      );
+      const expected = new Map([
+        ["M428", "M128"],
+        ["M429", "M129"],
+      ]);
+
+      if (rows.length !== expected.size) {
+        throw new Error(`browser_user_m_native_runtime_probe_gate: row count drift ${rows.length}`);
+      }
+
+      const allRuntimeReady = rows.every((row) => row.runtime_ready === "1");
+      for (const row of rows) {
+        if (
+          row.path !== "axis/vismach/millturn/example.ngc" ||
+          row.ini !== "axis/vismach/millturn/millturn.ini" ||
+          row.blocked !== "L4-USER-M-PROCESS" ||
+          row.required_runtime !== "linuxcnc_task_hal_tcl_user_m_process"
+        ) {
+          throw new Error(`${row.remap_code}: runtime probe gate identity drift`);
+        }
+        if (expected.get(row.remap_code) !== row.user_m_code) {
+          throw new Error(`${row.remap_code}: runtime probe gate user-M drift`);
+        }
+        for (const requirement of ["tclsh", "halrun", "halcmd", "linuxcnc"]) {
+          if (!row.runtime_requirements.includes(`${requirement}:`)) {
+            throw new Error(`${row.remap_code}: runtime probe gate missing ${requirement}`);
+          }
+        }
+        if (
+          row.source_proof_ready !== "1" ||
+          row.required_native_proof !== "native_runtime_state_probe_required" ||
+          row.proof_status !== "pending" ||
+          row.execution_enabled !== "0" ||
+          row.promotion_allowed !== "0"
+        ) {
+          throw new Error(`${row.remap_code}: runtime probe gate must remain source-ready, pending, and disabled`);
+        }
+        if (allRuntimeReady) {
+          if (
+            row.missing_requirements !== "-" ||
+            row.gate_status !== "ready_to_implement_probe" ||
+            !row.notes.includes("write_native_hal_tcl_state_probe")
+          ) {
+            throw new Error(`${row.remap_code}: ready runtime probe gate drift`);
+          }
+        } else {
+          if (
+            row.missing_requirements === "-" ||
+            row.gate_status !== "blocked_missing_host_runtime" ||
+            !row.notes.includes("keep_millturn_blocked")
+          ) {
+            throw new Error(`${row.remap_code}: missing-runtime probe gate drift`);
+          }
+        }
+      }
+    }
+
+    async function verifyBrowserToolDbTransactionPlan() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/tool-db-process-transaction-plan.tsv"),
+      );
+      const expectedPhases = [
+        "startup_handshake",
+        "initial_get_all",
+        "spindle_load_notify",
+        "tool_offset_notify",
+        "spindle_unload_notify",
+      ];
+      const expectedProtocol = new Map([
+        ["startup_handshake", "startup:expect_reply=v2.1"],
+        ["initial_get_all", "request:g:get_all_until_FINI"],
+        ["spindle_load_notify", "notify:l:SPINDLE_LOAD"],
+        ["tool_offset_notify", "notify:p:TOOL_OFFSET"],
+        ["spindle_unload_notify", "notify:u:SPINDLE_UNLOAD"],
+      ]);
+      const expectedCallback = new Map([
+        ["startup_handshake", "registration:tooldb_callbacks_tools_loop"],
+        ["initial_get_all", "g:user_get_tool"],
+        ["spindle_load_notify", "l:user_load_spindle_nonran_tc"],
+        ["tool_offset_notify", "p:user_put_tool"],
+        ["spindle_unload_notify", "u:user_unload_spindle_nonran_tc"],
+      ]);
+
+      if (rows.length !== expectedPhases.length) {
+        throw new Error(`browser_tool_db_transaction_plan: row count drift ${rows.length}`);
+      }
+      const actualPhases = rows.map((row) => row.transaction_phase).join(",");
+      if (actualPhases !== expectedPhases.join(",")) {
+        throw new Error(`browser_tool_db_transaction_plan: phase order drift ${actualPhases}`);
+      }
+
+      for (const row of rows) {
+        if (
+          row.path !== "axis/db_demo/base.ngc" ||
+          row.blocked !== "L4-TOOL-DB" ||
+          row.db_program !== "./db_nonran.py"
+        ) {
+          throw new Error(`${row.transaction_phase}: tool DB transaction identity drift`);
+        }
+        if (row.protocol_message !== expectedProtocol.get(row.transaction_phase)) {
+          throw new Error(`${row.transaction_phase}: tool DB protocol message drift`);
+        }
+        if (row.db_program_callback !== expectedCallback.get(row.transaction_phase)) {
+          throw new Error(`${row.transaction_phase}: tool DB callback drift`);
+        }
+        if (row.state_targets === "-") {
+          throw new Error(`${row.transaction_phase}: missing tool DB state targets`);
+        }
+        if (
+          row.required_native_proof === "-" ||
+          row.required_node_proof === "-" ||
+          row.required_browser_proof === "-"
+        ) {
+          throw new Error(`${row.transaction_phase}: missing tool DB required proof`);
+        }
+        if (
+          row.proof_status !== "pending" ||
+          row.execution_enabled !== "0" ||
+          row.promotion_allowed !== "0"
+        ) {
+          throw new Error(`${row.transaction_phase}: tool DB transaction must remain pending and disabled`);
+        }
+        if (!row.notes.includes("no_db_process_execution") || !row.notes.includes("no_tool_table_fallback")) {
+          throw new Error(`${row.transaction_phase}: tool DB transaction must record blocked execution policy`);
+        }
+      }
+    }
+
+    async function verifyBrowserToolDbNativeRuntimeReadiness() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/tool-db-process-native-runtime-readiness.tsv"),
+      );
+      const expectedRequirements = [
+        "python3",
+        "linuxcnc",
+        "milltask",
+        "halcmd",
+        "axis/db_demo/db_nonran.py",
+        "linuxcnc.so",
+        "tooldb.py",
+      ];
+
+      if (rows.map((row) => row.requirement).join(",") !== expectedRequirements.join(",")) {
+        throw new Error("browser_tool_db_native_runtime_readiness: requirement order drift");
+      }
+
+      for (const row of rows) {
+        if (
+          row.path !== "axis/db_demo/base.ngc" ||
+          row.blocked !== "L4-TOOL-DB" ||
+          row.required_runtime !== "linuxcnc_tooldata_db_process" ||
+          row.db_program !== "./db_nonran.py"
+        ) {
+          throw new Error(`${row.requirement}: tool DB readiness identity drift`);
+        }
+        if (!["host_command", "source_config_file", "linuxcnc_python_module"].includes(row.requirement_kind)) {
+          throw new Error(`${row.requirement}: invalid readiness kind ${row.requirement_kind}`);
+        }
+        if (!["0", "1"].includes(row.available)) {
+          throw new Error(`${row.requirement}: invalid readiness availability ${row.available}`);
+        }
+        if (row.available === "1" && row.evidence === "-") {
+          throw new Error(`${row.requirement}: available tool DB requirement lacks evidence`);
+        }
+        if (
+          ![
+            "blocked_missing_host_runtime",
+            "host_runtime_available_probe_not_implemented",
+          ].includes(row.native_runtime_status)
+        ) {
+          throw new Error(`${row.requirement}: invalid tool DB runtime readiness status`);
+        }
+        if (
+          row.proof_kind !== "native_db_process_protocol_probe_required" ||
+          row.proof_status !== "pending" ||
+          row.execution_enabled !== "0" ||
+          row.promotion_allowed !== "0"
+        ) {
+          throw new Error(`${row.requirement}: tool DB readiness must remain pending and disabled`);
+        }
+        if (
+          !row.notes.includes("keep_tool_db_blocked") &&
+          !row.notes.includes("probe_still_not_implemented")
+        ) {
+          throw new Error(`${row.requirement}: tool DB readiness must keep blocked state`);
+        }
+      }
+    }
+
+    async function verifyBrowserPythonRuntimeContract() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/python-remap-runtime-contract.tsv"),
+      );
+      const requiredFamilies = new Set([
+        "axis/laser",
+        "axis/remap/extend-builtins/nc_files",
+        "axis/vismach/5axis/table-rotary_spindle-rotary-nutating/demos",
+        "gmoccapy/macros",
+      ]);
+      const phases = [
+        "initialize_python",
+        "apply_ini_python_path",
+        "execute_toplevel",
+        "callable_lookup",
+        "pycall_dispatch",
+        "callable_invoke",
+        "remap_phase_dispatch",
+      ];
+
+      if (rows.length < requiredFamilies.size) {
+        throw new Error(`browser_python_runtime_contract: too few rows ${rows.length}`);
+      }
+
+      const byFamily = new Map(rows.map((row) => [row.family, row]));
+      for (const family of requiredFamilies) {
+        if (!byFamily.has(family)) {
+          throw new Error(`browser_python_runtime_contract: missing ${family}`);
+        }
+      }
+
+      for (const row of rows) {
+        if (row.blocked !== "L4-PYTHON-REMAP" || row.design_status !== "inventory_only") {
+          throw new Error(`${row.family}: Python runtime contract identity drift`);
+        }
+        if (row.python_modules === "-" || row.runtime_owner_evidence === "-") {
+          throw new Error(`${row.family}: Python runtime contract lacks dependency evidence`);
+        }
+        for (const phase of phases) {
+          if (!row.runtime_phases.includes(phase)) {
+            throw new Error(`${row.family}: Python runtime contract missing phase ${phase}`);
+          }
+        }
+        if (
+          row.required_native_proof !== "python_runtime_owner_and_fixture" ||
+          row.required_node_proof !== "linuxcnc_python_runtime_boundary_not_js_semantics" ||
+          row.required_browser_proof !== "browser_after_node_python_boundary_no_full_process_claim"
+        ) {
+          throw new Error(`${row.family}: Python runtime contract proof drift`);
+        }
+        if (
+          row.proof_status !== "pending" ||
+          row.execution_enabled !== "0" ||
+          row.promotion_allowed !== "0"
+        ) {
+          throw new Error(`${row.family}: Python runtime contract must remain pending and disabled`);
+        }
+        if (!row.notes.includes("python_runtime_contract_only_no_execution")) {
+          throw new Error(`${row.family}: Python runtime contract must record non-execution policy`);
+        }
+      }
+    }
+
+    async function verifyBrowserPythonNativeRuntimeReadiness() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/python-remap-native-runtime-readiness.tsv"),
+      );
+      const requiredFamilies = new Set([
+        "axis/laser",
+        "axis/remap/extend-builtins/nc_files",
+        "axis/vismach/5axis/table-rotary_spindle-rotary-nutating/demos",
+        "gmoccapy/macros",
+      ]);
+
+      if (rows.length <= requiredFamilies.size * 4) {
+        throw new Error(`browser_python_native_runtime_readiness: too few rows ${rows.length}`);
+      }
+
+      const byFamily = new Map();
+      for (const row of rows) {
+        const familyRows = byFamily.get(row.family) || [];
+        familyRows.push(row);
+        byFamily.set(row.family, familyRows);
+
+        if (row.blocked !== "L4-PYTHON-REMAP") {
+          throw new Error(`${row.family}: Python readiness blocked kind drift`);
+        }
+        if (row.required_runtime !== "linuxcnc_python_remap_runtime") {
+          throw new Error(`${row.family}: Python readiness runtime drift`);
+        }
+        if (
+          ![
+            "host_command",
+            "linuxcnc_source_file",
+            "source_config_python_module",
+          ].includes(row.requirement_kind)
+        ) {
+          throw new Error(`${row.family}: invalid Python readiness kind ${row.requirement_kind}`);
+        }
+        if (!["0", "1"].includes(row.available)) {
+          throw new Error(`${row.family}: invalid Python readiness availability`);
+        }
+        if (row.available === "1" && row.evidence === "-") {
+          throw new Error(`${row.family}: available Python readiness row lacks evidence`);
+        }
+        if (
+          ![
+            "blocked_missing_host_runtime",
+            "host_runtime_available_probe_not_implemented",
+          ].includes(row.native_runtime_status)
+        ) {
+          throw new Error(`${row.family}: invalid Python readiness runtime status`);
+        }
+        if (
+          row.proof_kind !== "native_python_runtime_probe_required" ||
+          row.proof_status !== "pending" ||
+          row.execution_enabled !== "0" ||
+          row.promotion_allowed !== "0"
+        ) {
+          throw new Error(`${row.family}: Python readiness must remain pending and disabled`);
+        }
+        if (
+          !row.notes.includes("keep_python_remap_blocked") &&
+          !row.notes.includes("probe_still_not_implemented")
+        ) {
+          throw new Error(`${row.family}: Python readiness must keep blocked state`);
+        }
+      }
+
+      for (const family of requiredFamilies) {
+        const familyRows = byFamily.get(family);
+        if (!familyRows) {
+          throw new Error(`browser_python_native_runtime_readiness: missing ${family}`);
+        }
+        const requirements = new Set(familyRows.map((row) => row.requirement));
+        for (const requirement of [
+          "python3",
+          "linuxcnc",
+          "src/emc/rs274ngc/interp_python.cc",
+          "src/emc/pythonplugin/python_plugin.cc",
+        ]) {
+          if (!requirements.has(requirement)) {
+            throw new Error(`${family}: missing Python readiness requirement ${requirement}`);
+          }
+        }
+        if (!familyRows.some((row) => row.requirement_kind === "source_config_python_module")) {
+          throw new Error(`${family}: Python readiness lacks configured module rows`);
+        }
+      }
+    }
+
+    async function verifyBrowserPythonNativeRuntimeStatePlan() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/python-remap-native-runtime-state-plan.tsv"),
+      );
+      const requiredFamilies = new Set([
+        "axis/laser",
+        "axis/remap/extend-builtins/nc_files",
+        "axis/vismach/5axis/table-rotary_spindle-rotary-nutating/demos",
+        "gmoccapy/macros",
+      ]);
+      const requiredPhaseTargets = [
+        "phase:initialize_python",
+        "phase:apply_ini_python_path",
+        "phase:execute_toplevel",
+        "phase:callable_lookup",
+        "phase:pycall_dispatch",
+        "phase:callable_invoke",
+        "phase:remap_phase_dispatch",
+      ];
+
+      if (rows.length !== 12) {
+        throw new Error(`browser_python_native_runtime_state_plan: row count drift ${rows.length}`);
+      }
+
+      const byFamily = new Map(rows.map((row) => [row.family, row]));
+      for (const family of requiredFamilies) {
+        if (!byFamily.has(family)) {
+          throw new Error(`browser_python_native_runtime_state_plan: missing ${family}`);
+        }
+      }
+
+      for (const row of rows) {
+        if (row.blocked !== "L4-PYTHON-REMAP") {
+          throw new Error(`${row.family}: Python state plan blocked kind drift`);
+        }
+        if (row.required_runtime !== "linuxcnc_python_remap_runtime") {
+          throw new Error(`${row.family}: Python state plan runtime drift`);
+        }
+        if (row.python_modules === "-" || row.runtime_phases === "-") {
+          throw new Error(`${row.family}: Python state plan lacks module or phase evidence`);
+        }
+        for (const token of [
+          "python3",
+          "linuxcnc",
+          "interp_python.cc",
+          "python_plugin.cc",
+          "configured_python_modules",
+        ]) {
+          if (!row.required_environment.includes(token)) {
+            throw new Error(`${row.family}: Python state plan missing environment ${token}`);
+          }
+        }
+        if (
+          !/^[1-9][0-9]*$/.test(row.readiness_requirement_count) ||
+          !/^[0-9]+$/.test(row.readiness_available_count)
+        ) {
+          throw new Error(`${row.family}: invalid Python state plan readiness counts`);
+        }
+        if (
+          !row.source_alignment_artifacts.includes("python-remap-native-runtime-alignment.tsv") ||
+          !row.source_alignment_artifacts.includes("python-remap-native-runtime-readiness.tsv")
+        ) {
+          throw new Error(`${row.family}: Python state plan missing source artifacts`);
+        }
+        if (
+          row.source_alignment_ok !== "1" ||
+          row.native_runtime_status !== "pending_native_python_runtime_probe"
+        ) {
+          throw new Error(`${row.family}: Python state plan source/runtime status drift`);
+        }
+        for (const target of requiredPhaseTargets) {
+          if (!row.required_state_probe.includes(target)) {
+            throw new Error(`${row.family}: Python state plan missing target ${target}`);
+          }
+        }
+        if (!row.required_state_probe.includes("module:")) {
+          throw new Error(`${row.family}: Python state plan lacks module proof target`);
+        }
+        if (
+          row.proof_kind !== "native_python_runtime_state_probe_required" ||
+          row.proof_status !== "pending" ||
+          row.execution_enabled !== "0" ||
+          row.promotion_allowed !== "0"
+        ) {
+          throw new Error(`${row.family}: Python state plan must remain pending and disabled`);
+        }
+        if (!row.notes.includes("native_runtime_not_executed_keep_python_remap_blocked")) {
+          throw new Error(`${row.family}: Python state plan must keep blocked state`);
+        }
+      }
+    }
+
+    async function verifyBrowserPythonNativeRuntimeFixturePlan() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/python-remap-native-runtime-fixture-plan.tsv"),
+      );
+      if (rows.length !== 1) {
+        throw new Error(`browser_python_native_runtime_fixture_plan: row count drift ${rows.length}`);
+      }
+
+      const row = rows[0];
+      if (row.family !== "axis/remap/stop-lookahead/nc_files") {
+        throw new Error(`Python fixture family drift ${row.family}`);
+      }
+      if (row.blocked !== "L4-PYTHON-REMAP") {
+        throw new Error(`${row.family}: Python fixture blocked kind drift`);
+      }
+      if (row.required_runtime !== "linuxcnc_python_remap_runtime") {
+        throw new Error(`${row.family}: Python fixture runtime drift`);
+      }
+      if (
+        row.selection_reason !== "selected_minimal_python_runtime_lifecycle_fixture" ||
+        row.fixture_id !== "stop_lookahead_python_runtime_lifecycle" ||
+        row.fixture_scope !== "no_python_callables_no_ngc_only_subpaths"
+      ) {
+        throw new Error(`${row.family}: Python fixture selection drift`);
+      }
+      for (const phase of [
+        "initialize_python",
+        "apply_ini_python_path",
+        "execute_toplevel",
+        "callable_lookup",
+        "pycall_dispatch",
+        "callable_invoke",
+        "remap_phase_dispatch",
+      ]) {
+        if (!row.runtime_phases.includes(phase) || !row.expected_runtime_observations.includes(phase)) {
+          throw new Error(`${row.family}: Python fixture missing phase ${phase}`);
+        }
+      }
+      for (const modulePath of [
+        "axis/remap/stop-lookahead/python/remap.py",
+        "axis/remap/stop-lookahead/python/toplevel.py",
+      ]) {
+        if (!row.python_modules.includes(modulePath)) {
+          throw new Error(`${row.family}: Python fixture missing module ${modulePath}`);
+        }
+        if (!row.expected_module_inputs.includes(`module:${modulePath}`)) {
+          throw new Error(`${row.family}: Python fixture missing module input ${modulePath}`);
+        }
+      }
+      if (row.process_assumptions !== "hal_process") {
+        throw new Error(`${row.family}: Python fixture process assumption drift`);
+      }
+      if (
+        !row.required_environment.includes("python3") ||
+        !row.required_environment.includes("linuxcnc") ||
+        !row.required_environment.includes("interp_python.cc") ||
+        !row.required_environment.includes("python_plugin.cc")
+      ) {
+        throw new Error(`${row.family}: Python fixture environment drift`);
+      }
+      if (
+        row.source_alignment_ok !== "1" ||
+        !row.source_alignment_artifacts.includes("python-remap-native-runtime-alignment.tsv") ||
+        !row.source_alignment_artifacts.includes("python-remap-native-runtime-readiness.tsv")
+      ) {
+        throw new Error(`${row.family}: Python fixture source alignment drift`);
+      }
+      if (
+        row.proof_kind !== "linuxcnc_python_runtime_lifecycle_probe_required" ||
+        row.proof_status !== "pending" ||
+        row.execution_enabled !== "0" ||
+        row.promotion_allowed !== "0"
+      ) {
+        throw new Error(`${row.family}: Python fixture must remain pending and disabled`);
+      }
+      if (!row.notes.includes("fixture_plan_only_no_python_execution_no_promotion")) {
+        throw new Error(`${row.family}: Python fixture must remain non-executing`);
+      }
+    }
+
+    async function verifyBrowserNativeProofAlignment() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/native-proof-alignment-summary.tsv"),
+      );
+      const byClass = new Map(rows.map((row) => [row.boundary_class, row]));
+      const expected = new Map([
+        [
+          "L4-USER-M-PROCESS",
+          {
+            boundaryKind: "external_user_m_process",
+            proofKey: "millturn_user_m_native_source_state_proof",
+          },
+        ],
+        [
+          "L4-TOOL-DB",
+          {
+            boundaryKind: "tool_database_process",
+            proofKey: "tool_db_native_source_protocol_proof",
+          },
+        ],
+        [
+          "L4-PYTHON-REMAP",
+          {
+            boundaryKind: "python_runtime",
+            proofKey: "python_remap_native_source_inventory_proof",
+          },
+        ],
+      ]);
+
+      for (const [boundaryClass, expectedRow] of expected) {
+        const row = byClass.get(boundaryClass);
+        if (!row) {
+          throw new Error(`browser_native_proof_alignment: missing ${boundaryClass}`);
+        }
+        if (row.boundary_kind !== expectedRow.boundaryKind) {
+          throw new Error(`${boundaryClass}: native proof boundary kind drift`);
+        }
+        if (row.proof_key !== expectedRow.proofKey) {
+          throw new Error(`${boundaryClass}: native proof key drift`);
+        }
+        if (row.native_summary_available === "0") {
+          if (
+            row.alignment_ok !== "0" ||
+            row.notes !== "native_source_proof_summary_unavailable"
+          ) {
+            throw new Error(`${boundaryClass}: unavailable native proof alignment drift`);
+          }
+          continue;
+        }
+        if (
+          row.proof_value !== "1" ||
+          row.execution_enabled !== "0" ||
+          row.promotion_allowed !== "0" ||
+          row.alignment_ok !== "1"
+        ) {
+          throw new Error(`${boundaryClass}: native proof alignment failed`);
+        }
+        if (row.matching_worklist_count === "0" || row.matching_native_gate_count === "0") {
+          throw new Error(`${boundaryClass}: native proof lacks generated gate consumer`);
+        }
+      }
+    }
+
+    async function verifyBrowserRuntimeNativeAlignmentSummary() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/runtime-boundary-native-alignment-summary.tsv"),
+      );
+      const expected = new Map([
+        [
+          "L4-USER-M-PROCESS",
+          {
+            boundaryKind: "external_user_m_process",
+            artifact: "user-m-process-native-state-alignment.tsv",
+          },
+        ],
+        [
+          "L4-TOOL-DB",
+          {
+            boundaryKind: "tool_database_process",
+            artifact: "tool-db-process-native-protocol-alignment.tsv",
+          },
+        ],
+        [
+          "L4-PYTHON-REMAP",
+          {
+            boundaryKind: "python_runtime",
+            artifact: "python-remap-native-runtime-alignment.tsv",
+          },
+        ],
+      ]);
+      const byClass = new Map(rows.map((row) => [row.boundary_class, row]));
+
+      if (rows.length !== expected.size) {
+        throw new Error(`browser_runtime_native_alignment_summary: row count drift ${rows.length}`);
+      }
+
+      for (const [boundaryClass, expectedRow] of expected) {
+        const row = byClass.get(boundaryClass);
+        if (!row) {
+          throw new Error(`browser_runtime_native_alignment_summary: missing ${boundaryClass}`);
+        }
+        if (row.boundary_kind !== expectedRow.boundaryKind || row.artifact !== expectedRow.artifact) {
+          throw new Error(`${boundaryClass}: runtime native alignment summary metadata drift`);
+        }
+        if (!/^[1-9][0-9]*$/.test(row.row_count)) {
+          throw new Error(`${boundaryClass}: invalid runtime alignment row count ${row.row_count}`);
+        }
+        for (const field of [
+          "native_stdout_available_count",
+          "alignment_ok_count",
+          "pending_count",
+          "execution_disabled_count",
+          "promotion_disabled_count",
+        ]) {
+          if (row[field] !== row.row_count) {
+            throw new Error(`${boundaryClass}: ${field} must match row_count`);
+          }
+        }
+        if (row.summary_ok !== "1") {
+          throw new Error(`${boundaryClass}: runtime native alignment summary failed`);
+        }
+        if (!row.notes.includes("no_runtime_execution")) {
+          throw new Error(`${boundaryClass}: runtime native alignment summary must remain non-executing`);
+        }
+      }
+
+      return rows;
+    }
+
+    async function verifyBrowserNativeRuntimeProbeSummary() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/native-runtime-probe-summary.tsv"),
+      );
+      const expected = new Map([
+        [
+          "L4-USER-M-PROCESS",
+          {
+            boundaryKind: "external_user_m_process",
+            target: "axis/vismach/millturn/example.ngc",
+            runtimeProbe: "linuxcnc_millturn_user_m_runtime_probe",
+          },
+        ],
+        [
+          "L4-TOOL-DB",
+          {
+            boundaryKind: "tool_database_process",
+            target: "axis/db_demo/base.ngc",
+            runtimeProbe: "linuxcnc_tool_db_runtime_probe",
+          },
+        ],
+        [
+          "L4-PYTHON-REMAP",
+          {
+            boundaryKind: "python_runtime",
+            target: "axis/remap/stop-lookahead/nc_files",
+            runtimeProbe: "linuxcnc_python_remap_runtime_probe",
+          },
+        ],
+      ]);
+
+      if (rows.length !== expected.size) {
+        throw new Error(`browser_native_runtime_probe_summary: row count drift ${rows.length}`);
+      }
+
+      for (const row of rows) {
+        const expectedRow = expected.get(row.boundary_class);
+        if (!expectedRow) {
+          throw new Error(`browser_native_runtime_probe_summary: unexpected ${row.boundary_class}`);
+        }
+        if (
+          row.boundary_kind !== expectedRow.boundaryKind ||
+          row.target !== expectedRow.target ||
+          row.runtime_probe !== expectedRow.runtimeProbe
+        ) {
+          throw new Error(`${row.boundary_class}: native runtime probe metadata drift`);
+        }
+        if (row.source_proof_ready !== "1") {
+          throw new Error(`${row.boundary_class}: native runtime probe source proof is not ready`);
+        }
+        if (!["0", "1"].includes(row.runtime_ready)) {
+          throw new Error(`${row.boundary_class}: invalid runtime readiness`);
+        }
+        if (
+          ![
+            "skipped_missing_host_runtime",
+            "ready_disabled_by_default",
+            "not_implemented_full_process_guard",
+            "runtime_state_probe_passed",
+            "runtime_protocol_probe_passed",
+            "runtime_lifecycle_probe_passed",
+          ].includes(row.probe_status)
+        ) {
+          throw new Error(`${row.boundary_class}: invalid runtime probe status ${row.probe_status}`);
+        }
+        if (row.runtime_ready === "0" && row.probe_status !== "skipped_missing_host_runtime") {
+          throw new Error(`${row.boundary_class}: non-ready runtime must remain skipped`);
+        }
+        if (row.execution_enabled !== "0" || row.promotion_allowed !== "0") {
+          throw new Error(`${row.boundary_class}: native runtime probe must not enable execution or promotion`);
+        }
+        if (row.stdout_log === "-") {
+          throw new Error(`${row.boundary_class}: native runtime probe lacks stdout evidence`);
+        }
+      }
+    }
+
+    async function verifyBrowserRuntimeBoundaryContractSummary() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/runtime-boundary-contract-summary.tsv"),
+      );
+      const expected = new Map([
+        [
+          "L4-USER-M-PROCESS",
+          {
+            boundaryKind: "external_user_m_process",
+            contractArtifact: "user-m-process-transition-plan.tsv",
+            rowCount: "2",
+          },
+        ],
+        [
+          "L4-TOOL-DB",
+          {
+            boundaryKind: "tool_database_process",
+            contractArtifact: "tool-db-process-transaction-plan.tsv",
+            rowCount: "5",
+          },
+        ],
+        [
+          "L4-PYTHON-REMAP",
+          {
+            boundaryKind: "python_runtime",
+            contractArtifact: "python-remap-runtime-contract.tsv",
+            rowCount: "12",
+          },
+        ],
+      ]);
+
+      if (rows.length !== expected.size) {
+        throw new Error(`browser_runtime_contract_summary: row count drift ${rows.length}`);
+      }
+
+      for (const row of rows) {
+        const expectedRow = expected.get(row.boundary_class);
+        if (!expectedRow) {
+          throw new Error(`browser_runtime_contract_summary: unexpected ${row.boundary_class}`);
+        }
+        if (
+          row.boundary_kind !== expectedRow.boundaryKind ||
+          row.contract_artifact !== expectedRow.contractArtifact ||
+          row.contract_row_count !== expectedRow.rowCount
+        ) {
+          throw new Error(`${row.boundary_class}: runtime contract summary metadata drift`);
+        }
+        for (const field of [
+          "pending_count",
+          "execution_disabled_count",
+          "promotion_disabled_count",
+        ]) {
+          if (row[field] !== row.contract_row_count) {
+            throw new Error(`${row.boundary_class}: runtime contract ${field} drift`);
+          }
+        }
+        if (row.runtime_alignment_ok !== "1" || row.contract_ok !== "1") {
+          throw new Error(`${row.boundary_class}: runtime contract summary failed`);
+        }
+        if (!row.notes.includes("no_runtime_execution") || !row.notes.includes("no_promotion")) {
+          throw new Error(`${row.boundary_class}: runtime contract summary must remain non-executing`);
+        }
+      }
+    }
+
+    async function verifyBrowserRuntimeNativeAlignmentDetails(summaryRows) {
+      for (const summary of summaryRows) {
+        const rows = parseTsv(
+          await fetchText(`../../build/wasm/sim-configs-inventory/${summary.artifact}`),
+        );
+        if (String(rows.length) !== summary.row_count) {
+          throw new Error(`${summary.boundary_class}: detailed alignment row count drift`);
+        }
+        for (const row of rows) {
+          if (row.blocked !== summary.boundary_class) {
+            throw new Error(`${summary.boundary_class}: detailed alignment blocked kind drift`);
+          }
+          if (row.native_stdout_available !== "1" || row.alignment_ok !== "1") {
+            throw new Error(`${summary.boundary_class}: detailed alignment failed`);
+          }
+          if (row.proof_status !== "pending") {
+            throw new Error(`${summary.boundary_class}: detailed alignment proof must remain pending`);
+          }
+          if (row.execution_enabled !== "0" || row.promotion_allowed !== "0") {
+            throw new Error(`${summary.boundary_class}: detailed alignment must not enable execution or promotion`);
+          }
+          if (!row.notes.includes("no_")) {
+            throw new Error(`${summary.boundary_class}: detailed alignment must record non-execution notes`);
+          }
+        }
+      }
+    }
+
+    async function verifyBrowserBlockedRuntimePromotionLock() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/blocked-runtime-promotion-lock.tsv"),
+      );
+      const requiredTargets = new Map([
+        ["axis/vismach/millturn/example.ngc", "L4-USER-M-PROCESS"],
+        ["axis/db_demo/base.ngc", "L4-TOOL-DB"],
+      ]);
+
+      if (rows.length < requiredTargets.size) {
+        throw new Error("browser_blocked_runtime_promotion_lock: too few rows");
+      }
+
+      const byTarget = new Map(rows.map((row) => [row.target, row]));
+      for (const [target, blocked] of requiredTargets) {
+        const row = byTarget.get(target);
+        if (!row) {
+          throw new Error(`browser_blocked_runtime_promotion_lock: missing ${target}`);
+        }
+        if (row.blocked !== blocked) {
+          throw new Error(`${target}: promotion lock blocked kind drift`);
+        }
+      }
+
+      for (const row of rows) {
+        if (row.execution_enabled !== "0" || row.promotion_allowed !== "0") {
+          throw new Error(`${row.target}: promotion lock must keep execution and promotion disabled`);
+        }
+        for (const field of [
+          "native_gate_pending",
+          "node_gate_pending",
+          "browser_gate_pending",
+          "runtime_alignment_ok",
+          "lock_active",
+        ]) {
+          if (row[field] !== "1") {
+            throw new Error(`${row.target}: promotion lock ${field} drift`);
+          }
+        }
+        if (!/^[1-9][0-9]*$/.test(row.runtime_alignment_row_count)) {
+          throw new Error(`${row.target}: invalid promotion lock alignment count`);
+        }
+        if (!row.notes.includes("blocked_until_linuxcnc_owned_runtime_boundary")) {
+          throw new Error(`${row.target}: promotion lock note drift`);
+        }
+        if (row.boundary_kind === "python_runtime" && row.design_status !== "inventory_only") {
+          throw new Error(`${row.target}: Python promotion lock must remain inventory-only`);
+        }
+      }
+    }
+
+    async function verifyBrowserNextBoundaryRecommendations() {
+      const rows = parseTsv(
+        await fetchText("../../build/wasm/sim-configs-inventory/next-boundary-recommendations.tsv"),
+      );
+      const expected = new Map([
+        [
+          "external_user_m_process",
+          {
+            target: "axis/vismach/millturn/example.ngc",
+            blocked: "L4-USER-M-PROCESS",
+            recommendation: "implement_native_m128_m129_state_probe",
+            primaryArtifact: "user-m-process-native-runtime-probe-gate.tsv",
+            proofToken: "not_user_m_event_only",
+          },
+        ],
+        [
+          "tool_database_process",
+          {
+            target: "axis/db_demo/base.ngc",
+            blocked: "L4-TOOL-DB",
+            recommendation: "implement_tooldata_db_protocol_probe",
+            primaryArtifact: "tool-db-process-transaction-plan.tsv",
+            proofToken: "not_tbl_fallback",
+          },
+        ],
+        [
+          "python_runtime",
+          {
+            target: "axis/remap/stop-lookahead/nc_files",
+            blocked: "L4-PYTHON-REMAP",
+            recommendation: "implement_minimal_python_runtime_lifecycle_probe",
+            primaryArtifact: "python-remap-native-runtime-fixture-plan.tsv",
+            proofToken: "not_js_semantics",
+          },
+        ],
+      ]);
+
+      if (rows.length !== expected.size) {
+        throw new Error(`browser_next_boundary_recommendations: row count drift ${rows.length}`);
+      }
+      if (rows.map((row) => row.priority).join(",") !== "1,2,3") {
+        throw new Error("browser_next_boundary_recommendations: priority order drift");
+      }
+
+      for (const row of rows) {
+        const expectedRow = expected.get(row.boundary_kind);
+        if (!expectedRow) {
+          throw new Error(`${row.boundary_kind}: unexpected recommendation boundary kind`);
+        }
+        if (
+          row.target !== expectedRow.target ||
+          row.blocked !== expectedRow.blocked ||
+          row.recommendation !== expectedRow.recommendation ||
+          row.primary_artifact !== expectedRow.primaryArtifact
+        ) {
+          throw new Error(`${row.boundary_kind}: recommendation identity drift`);
+        }
+        if (!/^[1-9][0-9]*$/.test(row.artifact_row_count)) {
+          throw new Error(`${row.boundary_kind}: invalid recommendation artifact row count`);
+        }
+        if (
+          row.promotion_lock_active !== "1" ||
+          row.contract_ok !== "1" ||
+          row.execution_enabled !== "0" ||
+          row.promotion_allowed !== "0"
+        ) {
+          throw new Error(`${row.boundary_kind}: recommendation must keep active lock and disabled execution`);
+        }
+        if (
+          row.required_native_proof === "-" ||
+          !row.required_node_proof.includes(expectedRow.proofToken) ||
+          row.required_browser_proof === "-"
+        ) {
+          throw new Error(`${row.boundary_kind}: recommendation proof drift`);
+        }
+        if (
+          !row.source_artifacts.includes("next-boundary-worklist.tsv") ||
+          !row.source_artifacts.includes("blocked-runtime-promotion-lock.tsv")
+        ) {
+          throw new Error(`${row.boundary_kind}: recommendation lacks source artifact trace`);
+        }
+      }
+    }
+
     function verifyExpectedFileError(fixtureName, output, expectedText) {
       if (!output.includes("file_open=0")) {
         throw new Error(`${fixtureName}: missing file_open=0`);
@@ -187,6 +1646,150 @@
       };
     }
 
+    async function verifySimBoundaryDeclaration(name, options) {
+      const {
+        machineRel,
+        iniFile,
+        executionFiles = [],
+        expectedDependencies,
+        expectedProcesses,
+        expectedPythonUiReferences = [],
+        expectedPythonRemapReferences = [],
+        expectedCoverage,
+        fullProcessCoverage = false,
+      } = options;
+      const boundary = analyzeIniRuntimeBoundaries({
+        manifestText: await getSourceManifestText(),
+        sourceRootRel: `configs/sim/${machineRel}`,
+        sourceSearchRootRel: "configs/sim",
+        iniFile,
+        iniText: await fetchText(`../../vendor/linuxcnc/configs/sim/${machineRel}/${iniFile}`),
+        executionTexts: await Promise.all(executionFiles.map((file) =>
+          fetchText(`../../vendor/linuxcnc/configs/sim/${machineRel}/${file}`),
+        )),
+      });
+
+      if (boundary.recommendedBlockedKind !== "-") {
+        throw new Error(`${name}: unexpected hard block ${boundary.recommendedBlockedKind}`);
+      }
+      if (!["file", "remap"].includes(expectedCoverage)) {
+        throw new Error(`${name}: representative coverage must be file or remap`);
+      }
+      if (fullProcessCoverage) {
+        throw new Error(`${name}: browser sim representatives must not claim full-process coverage`);
+      }
+      const actualDependencies = boundary.dependencies.join(",");
+      const expectedDependencyText = expectedDependencies.join(",");
+      if (actualDependencies !== expectedDependencyText) {
+        throw new Error(`${name}: dependency drift ${actualDependencies}`);
+      }
+      for (const [field, expected] of Object.entries(expectedProcesses)) {
+        if (boundary[field].requiresProcess !== expected) {
+          throw new Error(`${name}: ${field}.requiresProcess drift`);
+        }
+      }
+      const actualPythonUiReferences = boundary.pythonRuntime.uiReferences.join(",");
+      const expectedPythonUiReferenceText = expectedPythonUiReferences.join(",");
+      if (actualPythonUiReferences !== expectedPythonUiReferenceText) {
+        throw new Error(`${name}: Python UI/DB reference drift ${actualPythonUiReferences}`);
+      }
+      const actualPythonRemapReferences = boundary.pythonRuntime.remapReferences.join(",");
+      const expectedPythonRemapReferenceText = expectedPythonRemapReferences.join(",");
+      if (actualPythonRemapReferences !== expectedPythonRemapReferenceText) {
+        throw new Error(`${name}: Python remap reference drift ${actualPythonRemapReferences}`);
+      }
+    }
+
+    async function verifySimHardBlockedBoundary(name, options) {
+      const {
+        machineRel,
+        iniFile,
+        executionFiles,
+        expectedBlockedKind,
+        expectedDependencies,
+        expectedProcesses,
+        expectedUserMCodes = [],
+        expectedUnstagedUserMCodes = expectedUserMCodes,
+        expectedPythonUiReferences = [],
+        expectedPythonRemapReferences = [],
+        expectedVendoredUserMCount = 0,
+        expectedRequiresExternalUserM = false,
+        expectedToolDatabaseProgram = "",
+      } = options;
+      const boundary = analyzeIniRuntimeBoundaries({
+        manifestText: await getSourceManifestText(),
+        sourceRootRel: `configs/sim/${machineRel}`,
+        sourceSearchRootRel: "configs/sim",
+        iniFile,
+        iniText: await fetchText(`../../vendor/linuxcnc/configs/sim/${machineRel}/${iniFile}`),
+        executionTexts: await Promise.all(executionFiles.map((file) =>
+          fetchText(`../../vendor/linuxcnc/configs/sim/${machineRel}/${file}`),
+        )),
+      });
+
+      if (boundary.recommendedBlockedKind !== expectedBlockedKind) {
+        throw new Error(`${name}: blocked kind drift ${boundary.recommendedBlockedKind}`);
+      }
+      const actualDependencies = boundary.dependencies.join(",");
+      const expectedDependencyText = expectedDependencies.join(",");
+      if (actualDependencies !== expectedDependencyText) {
+        throw new Error(`${name}: dependency drift ${actualDependencies}`);
+      }
+      const actualUserMCodes = boundary.userMRuntime.executionCodes.join(",");
+      const expectedUserMCodeText = expectedUserMCodes.join(",");
+      if (actualUserMCodes !== expectedUserMCodeText) {
+        throw new Error(`${name}: user-M execution code drift ${actualUserMCodes}`);
+      }
+      const actualUnstagedUserMCodes = boundary.userMRuntime.unstagedExecutionCodes.join(",");
+      const expectedUnstagedUserMCodeText = expectedUnstagedUserMCodes.join(",");
+      if (actualUnstagedUserMCodes !== expectedUnstagedUserMCodeText) {
+        throw new Error(`${name}: unstaged user-M execution code drift ${actualUnstagedUserMCodes}`);
+      }
+      if (boundary.userMRuntime.vendoredExecutableCount !== expectedVendoredUserMCount) {
+        throw new Error(`${name}: vendored user-M count drift`);
+      }
+      if (boundary.userMRuntime.requiresExternalProcess !== expectedRequiresExternalUserM) {
+        throw new Error(`${name}: external user-M process requirement drift`);
+      }
+      if (boundary.toolDatabaseProgram !== expectedToolDatabaseProgram) {
+        throw new Error(`${name}: DB_PROGRAM drift ${boundary.toolDatabaseProgram}`);
+      }
+      for (const [field, expected] of Object.entries(expectedProcesses)) {
+        if (boundary[field].requiresProcess !== expected) {
+          throw new Error(`${name}: ${field}.requiresProcess drift`);
+        }
+      }
+      const actualPythonUiReferences = boundary.pythonRuntime.uiReferences.join(",");
+      const expectedPythonUiReferenceText = expectedPythonUiReferences.join(",");
+      if (actualPythonUiReferences !== expectedPythonUiReferenceText) {
+        throw new Error(`${name}: Python UI/DB reference drift ${actualPythonUiReferences}`);
+      }
+      const actualPythonRemapReferences = boundary.pythonRuntime.remapReferences.join(",");
+      const expectedPythonRemapReferenceText = expectedPythonRemapReferences.join(",");
+      if (actualPythonRemapReferences !== expectedPythonRemapReferenceText) {
+        throw new Error(`${name}: Python remap reference drift ${actualPythonRemapReferences}`);
+      }
+    }
+
+    function wrapSimProgramFiles(machine, wrappedName) {
+      const sourceFile = machine.files.find((file) => file.path === machine.programPath);
+      if (!sourceFile) {
+        throw new Error(`${machine.programPath}: wrapped source file`);
+      }
+      return {
+        ...machine,
+        programPath: `${machine.wasmDir}/${wrappedName}`,
+        files: [
+          ...machine.files,
+          {
+            path: `${machine.wasmDir}/${wrappedName}`,
+            text: `${sourceFile.text}\nM2\n`,
+            executable: false,
+          },
+        ],
+      };
+    }
+
     let sourceManifestText = null;
 
     async function getSourceManifestText() {
@@ -472,6 +2075,29 @@
 
     try {
       verifyBrowserIniContextStagingPlan();
+      await verifyBrowserBoundaryPhaseCompletion();
+      await verifyBrowserIniBoundarySummary();
+      await verifyBrowserBoundaryProofGates();
+      await verifyBrowserBoundarySummary();
+      await verifyBrowserUserMTransitionPlan();
+      await verifyBrowserUserMNativeTransitionAlignment();
+      await verifyBrowserUserMNativeRuntimeStatePlan();
+      await verifyBrowserUserMNativeRuntimeReadiness();
+      await verifyBrowserUserMNativeRuntimeProbeGate();
+      await verifyBrowserToolDbTransactionPlan();
+      await verifyBrowserToolDbNativeRuntimeReadiness();
+      await verifyBrowserPythonRuntimeContract();
+      await verifyBrowserPythonNativeRuntimeReadiness();
+      await verifyBrowserPythonNativeRuntimeStatePlan();
+      await verifyBrowserPythonNativeRuntimeFixturePlan();
+      await verifyBrowserNativeProofAlignment();
+      const runtimeNativeAlignmentSummaryRows =
+        await verifyBrowserRuntimeNativeAlignmentSummary();
+      await verifyBrowserNativeRuntimeProbeSummary();
+      await verifyBrowserRuntimeBoundaryContractSummary();
+      await verifyBrowserRuntimeNativeAlignmentDetails(runtimeNativeAlignmentSummaryRows);
+      await verifyBrowserBlockedRuntimePromotionLock();
+      await verifyBrowserNextBoundaryRecommendations();
 
       const interp = await createLinuxCncInterpSdk({
         locateFile(path) {
@@ -905,6 +2531,72 @@
         ].join("\n"),
       );
 
+      const gladevcpProbe = await loadSimMachineFiles(
+        "axis/gladevcp",
+        "gladevcp_panel.ini",
+        "probe.ngc",
+      );
+      await verifySimBoundaryDeclaration("browser_sim_axis_gladevcp_probe_boundary", {
+        machineRel: "axis/gladevcp",
+        iniFile: "gladevcp_panel.ini",
+        executionFiles: ["probe.ngc"],
+        expectedDependencies: ["hal_process", "python_runtime", "ui_process"],
+        expectedProcesses: {
+          halRuntime: true,
+          uiRuntime: true,
+          haluiRuntime: false,
+          pythonRuntime: true,
+        },
+        expectedPythonUiReferences: ["-u hitcounter.py manual-example.ui"],
+        expectedPythonRemapReferences: [],
+        expectedCoverage: "file",
+      });
+      verifyExpectedOutput(
+        "browser_sim_axis_gladevcp_probe",
+        interp.runSimConfigProgram({
+          files: gladevcpProbe.files,
+          programPath: gladevcpProbe.programPath,
+          iniPath: gladevcpProbe.iniPath,
+        }),
+        [
+          "file_open=0",
+          "file_saw_error=0",
+          "canon_event=PROGRAM_END",
+          "absent=file_error_text=",
+        ].join("\n"),
+      );
+
+      const externalOffsetsMacro = wrapSimProgramFiles(
+        await loadSimMachineFiles(
+          "axis/external_offsets",
+          "dynamic_offsets.ini",
+          "circles.ngc",
+        ),
+        "__wrapped_circles.ngc",
+      );
+      verifyExpectedOutput(
+        "browser_sim_axis_external_offsets_circles_macro",
+        interp.runSimConfigProgram({
+          files: externalOffsetsMacro.files,
+          programPath: externalOffsetsMacro.programPath,
+          iniPath: externalOffsetsMacro.iniPath,
+        }),
+        [
+          "file_open=0",
+          "file_execute_45=1",
+          "statement_uri=M2",
+          "file_read_count=45",
+          "file_execute_count=45",
+          "file_saw_error=0",
+          "canon_event=COMMENT: info: Multiple circles at radius R, use 0 for current val",
+          "canon_event=PROGRAM_END",
+          "post_execute.origin_index=1",
+          "post_execute.mist=0",
+          "post_execute.flood=0",
+          "absent=file_error_text=",
+        ].join("\n"),
+      );
+
       for (const externalOffsetCase of [
         {
           name: "dyn_demo",
@@ -967,6 +2659,166 @@
         );
       }
 
+      const melfaSim = await loadSimMachineFiles(
+        "axis/vismach/melfa-sim",
+        "melfa.ini",
+        "example.ngc",
+      );
+      await verifySimBoundaryDeclaration("browser_sim_axis_vismach_melfa_boundary", {
+        machineRel: "axis/vismach/melfa-sim",
+        iniFile: "melfa.ini",
+        executionFiles: ["example.ngc"],
+        expectedDependencies: ["hal_process", "halui_mdi_process", "ui_process"],
+        expectedProcesses: {
+          halRuntime: true,
+          uiRuntime: true,
+          haluiRuntime: true,
+          pythonRuntime: false,
+        },
+        expectedCoverage: "remap",
+      });
+      verifyExpectedOutput(
+        "browser_sim_axis_vismach_melfa",
+        interp.runSimConfigProgram({
+          files: melfaSim.files,
+          programPath: melfaSim.programPath,
+          iniPath: melfaSim.iniPath,
+          executionMode: "fiveAxisRemap",
+        }),
+        [
+          "fiveaxis_ini_open=1",
+          "fiveaxis_tool_table_load=0",
+          "fiveaxis_file_open=0",
+          "fiveaxis_file_reached_exit=1",
+          "fiveaxis_linuxcnc_remap_file_execute=1",
+        ].join("\n"),
+      );
+
+      const pumaCube = await loadSimMachineFiles(
+        "axis/vismach/puma",
+        "puma_cube.ini",
+        "puma_cube.ngc",
+      );
+      await verifySimBoundaryDeclaration("browser_sim_axis_vismach_puma_cube_boundary", {
+        machineRel: "axis/vismach/puma",
+        iniFile: "puma_cube.ini",
+        executionFiles: ["puma_cube.ngc"],
+        expectedDependencies: ["hal_process", "halui_mdi_process", "ui_process"],
+        expectedProcesses: {
+          halRuntime: true,
+          uiRuntime: true,
+          haluiRuntime: true,
+          pythonRuntime: false,
+        },
+        expectedCoverage: "file",
+      });
+      verifyExpectedOutput(
+        "browser_sim_axis_vismach_puma_cube",
+        interp.runSimConfigProgram({
+          files: pumaCube.files,
+          programPath: pumaCube.programPath,
+          iniPath: pumaCube.iniPath,
+        }),
+        [
+          "file_open=0",
+          "file_saw_error=0",
+          "canon_event=PROGRAM_END",
+          "absent=file_error_text=",
+        ].join("\n"),
+      );
+
+      const woodpeckerOnAbort = await loadSimMachineFiles(
+        "woodpecker",
+        "woodpecker.ini",
+        "on_abort.ngc",
+      );
+      await verifySimBoundaryDeclaration("browser_sim_woodpecker_on_abort_boundary", {
+        machineRel: "woodpecker",
+        iniFile: "woodpecker.ini",
+        executionFiles: ["on_abort.ngc"],
+        expectedDependencies: ["hal_process", "ui_process"],
+        expectedProcesses: {
+          halRuntime: true,
+          uiRuntime: true,
+          haluiRuntime: false,
+          pythonRuntime: false,
+        },
+        expectedCoverage: "file",
+      });
+      verifyExpectedOutput(
+        "browser_sim_woodpecker_on_abort",
+        interp.runSimConfigProgram({
+          files: woodpeckerOnAbort.files,
+          programPath: woodpeckerOnAbort.programPath,
+          iniPath: woodpeckerOnAbort.iniPath,
+        }),
+        [
+          "file_open=0",
+          "run_step phase=execute step=17 rc=1 line=17",
+          "statement_uri=m2",
+          "file_read_count=17",
+          "file_execute_count=17",
+          "file_saw_error=0",
+          "canon_event=ON_RESET",
+          "canon_event=PROGRAM_END",
+          "post_execute.origin_index=1",
+          "post_execute.mist=0",
+          "post_execute.flood=0",
+          "absent=file_error_text=",
+        ].join("\n"),
+      );
+
+      await verifySimHardBlockedBoundary("browser_sim_axis_vismach_millturn_boundary", {
+        machineRel: "axis/vismach/millturn",
+        iniFile: "millturn.ini",
+        executionFiles: [
+          "example.ngc",
+          "remap_subs/428remap.ngc",
+          "remap_subs/429remap.ngc",
+        ],
+        expectedBlockedKind: "L4-USER-M-PROCESS",
+        expectedDependencies: [
+          "external_user_m_process",
+          "hal_process",
+          "halui_mdi_process",
+          "ui_process",
+        ],
+        expectedProcesses: {
+          halRuntime: true,
+          uiRuntime: true,
+          haluiRuntime: true,
+          pythonRuntime: false,
+        },
+        expectedUserMCodes: ["M128", "M129"],
+        expectedUnstagedUserMCodes: ["M128", "M129"],
+        expectedPythonUiReferences: [],
+        expectedPythonRemapReferences: [],
+        expectedVendoredUserMCount: 0,
+        expectedRequiresExternalUserM: true,
+        expectedToolDatabaseProgram: "",
+      });
+
+      await verifySimHardBlockedBoundary("browser_sim_axis_db_demo_tool_db_boundary", {
+        machineRel: "axis/db_demo",
+        iniFile: "db_nonran.ini",
+        executionFiles: ["base.ngc"],
+        expectedBlockedKind: "L4-TOOL-DB",
+        expectedDependencies: ["python_runtime", "tool_database_process"],
+        expectedProcesses: {
+          halRuntime: false,
+          uiRuntime: false,
+          haluiRuntime: false,
+          pythonRuntime: true,
+        },
+        expectedUserMCodes: [],
+        expectedUnstagedUserMCodes: [],
+        expectedPythonUiReferences: ["./db_nonran.py"],
+        expectedPythonRemapReferences: [],
+        expectedVendoredUserMCount: 0,
+        expectedRequiresExternalUserM: false,
+        expectedToolDatabaseProgram: "./db_nonran.py",
+      });
+
       const fiveAxisTrtDir = await writeFiveAxisTrtMachineFiles(interp);
       verifyExpectedOutput(
         "browser_fiveaxis_xyzac_switchkins",
diff --git a/wasm-port/tests/browser/verify_interp_browser.sh b/wasm-port/tests/browser/verify_interp_browser.sh
index d65d5a2..a1ebce8 100755
--- a/wasm-port/tests/browser/verify_interp_browser.sh
+++ b/wasm-port/tests/browser/verify_interp_browser.sh
@@ -3,6 +3,33 @@ set -euo pipefail
 
 ROOT_DIR="$(cd "$(dirname "$0")/../.." && pwd)"
 CHROMIUM="${CHROMIUM:-$(command -v chromium || command -v chromium-browser || command -v google-chrome || command -v google-chrome-stable || true)}"
+BOUNDARY_PROOF_GATES="$ROOT_DIR/build/wasm/sim-configs-inventory/boundary-proof-gates.tsv"
+BOUNDARY_SUMMARY="$ROOT_DIR/build/wasm/sim-configs-inventory/boundary-summary.tsv"
+INI_BOUNDARY_SUMMARY="$ROOT_DIR/build/wasm/sim-configs-inventory/ini-boundary-summary.tsv"
+NATIVE_PROOF_ALIGNMENT_SUMMARY="$ROOT_DIR/build/wasm/sim-configs-inventory/native-proof-alignment-summary.tsv"
+NATIVE_RUNTIME_PROBE_SUMMARY="$ROOT_DIR/build/wasm/sim-configs-inventory/native-runtime-probe-summary.tsv"
+RUNTIME_BOUNDARY_NATIVE_ALIGNMENT_SUMMARY="$ROOT_DIR/build/wasm/sim-configs-inventory/runtime-boundary-native-alignment-summary.tsv"
+RUNTIME_BOUNDARY_CONTRACT_SUMMARY="$ROOT_DIR/build/wasm/sim-configs-inventory/runtime-boundary-contract-summary.tsv"
+USER_M_PROCESS_NATIVE_STATE_ALIGNMENT="$ROOT_DIR/build/wasm/sim-configs-inventory/user-m-process-native-state-alignment.tsv"
+USER_M_PROCESS_NATIVE_TRANSITION_ALIGNMENT="$ROOT_DIR/build/wasm/sim-configs-inventory/user-m-process-native-transition-alignment.tsv"
+USER_M_PROCESS_NATIVE_RUNTIME_STATE_PLAN="$ROOT_DIR/build/wasm/sim-configs-inventory/user-m-process-native-runtime-state-plan.tsv"
+USER_M_PROCESS_NATIVE_RUNTIME_READINESS="$ROOT_DIR/build/wasm/sim-configs-inventory/user-m-process-native-runtime-readiness.tsv"
+USER_M_PROCESS_NATIVE_RUNTIME_PROBE_GATE="$ROOT_DIR/build/wasm/sim-configs-inventory/user-m-process-native-runtime-probe-gate.tsv"
+USER_M_PROCESS_TRANSITION_PLAN="$ROOT_DIR/build/wasm/sim-configs-inventory/user-m-process-transition-plan.tsv"
+TOOL_DB_PROCESS_NATIVE_PROTOCOL_ALIGNMENT="$ROOT_DIR/build/wasm/sim-configs-inventory/tool-db-process-native-protocol-alignment.tsv"
+TOOL_DB_PROCESS_NATIVE_RUNTIME_READINESS="$ROOT_DIR/build/wasm/sim-configs-inventory/tool-db-process-native-runtime-readiness.tsv"
+TOOL_DB_PROCESS_TRANSACTION_PLAN="$ROOT_DIR/build/wasm/sim-configs-inventory/tool-db-process-transaction-plan.tsv"
+PYTHON_REMAP_NATIVE_RUNTIME_ALIGNMENT="$ROOT_DIR/build/wasm/sim-configs-inventory/python-remap-native-runtime-alignment.tsv"
+PYTHON_REMAP_NATIVE_RUNTIME_READINESS="$ROOT_DIR/build/wasm/sim-configs-inventory/python-remap-native-runtime-readiness.tsv"
+PYTHON_REMAP_NATIVE_RUNTIME_STATE_PLAN="$ROOT_DIR/build/wasm/sim-configs-inventory/python-remap-native-runtime-state-plan.tsv"
+PYTHON_REMAP_NATIVE_RUNTIME_FIXTURE_PLAN="$ROOT_DIR/build/wasm/sim-configs-inventory/python-remap-native-runtime-fixture-plan.tsv"
+PYTHON_REMAP_RUNTIME_CONTRACT="$ROOT_DIR/build/wasm/sim-configs-inventory/python-remap-runtime-contract.tsv"
+BLOCKED_RUNTIME_PROMOTION_LOCK="$ROOT_DIR/build/wasm/sim-configs-inventory/blocked-runtime-promotion-lock.tsv"
+BOUNDARY_PHASE_COMPLETION_SUMMARY="$ROOT_DIR/build/wasm/sim-configs-inventory/boundary-phase-completion-summary.tsv"
+NEXT_BOUNDARY_RECOMMENDATIONS="$ROOT_DIR/build/wasm/sim-configs-inventory/next-boundary-recommendations.tsv"
+INVENTORY_SCRIPT="$ROOT_DIR/tests/wasm/node/verify_sim_configs_inventory_wasm.mjs"
+NATIVE_SOURCE_PROOF_SUMMARY="$ROOT_DIR/build/native/native-source-proof-summary.tsv"
+NATIVE_RUNTIME_PROBE_SOURCE_SUMMARY="$ROOT_DIR/build/native/native-runtime-probe-summary.tsv"
 
 if [[ -z "$CHROMIUM" ]]; then
   echo "missing Chromium-compatible browser; set CHROMIUM=/path/to/browser" >&2
@@ -15,6 +42,45 @@ fi
 if [[ "${SKIP_INI_BUILD:-0}" != "1" ]]; then
   "$ROOT_DIR/tools/build_ini_panel.sh"
 fi
+INVENTORY_REQUIRED=0
+for artifact in \
+  "$BOUNDARY_PROOF_GATES" \
+  "$BOUNDARY_SUMMARY" \
+  "$INI_BOUNDARY_SUMMARY" \
+  "$NATIVE_PROOF_ALIGNMENT_SUMMARY" \
+  "$RUNTIME_BOUNDARY_NATIVE_ALIGNMENT_SUMMARY" \
+  "$RUNTIME_BOUNDARY_CONTRACT_SUMMARY" \
+  "$USER_M_PROCESS_NATIVE_STATE_ALIGNMENT" \
+  "$USER_M_PROCESS_NATIVE_TRANSITION_ALIGNMENT" \
+  "$USER_M_PROCESS_NATIVE_RUNTIME_STATE_PLAN" \
+  "$USER_M_PROCESS_NATIVE_RUNTIME_READINESS" \
+  "$USER_M_PROCESS_NATIVE_RUNTIME_PROBE_GATE" \
+  "$USER_M_PROCESS_TRANSITION_PLAN" \
+  "$TOOL_DB_PROCESS_NATIVE_PROTOCOL_ALIGNMENT" \
+  "$TOOL_DB_PROCESS_NATIVE_RUNTIME_READINESS" \
+  "$TOOL_DB_PROCESS_TRANSACTION_PLAN" \
+  "$PYTHON_REMAP_NATIVE_RUNTIME_ALIGNMENT" \
+  "$PYTHON_REMAP_NATIVE_RUNTIME_READINESS" \
+  "$PYTHON_REMAP_NATIVE_RUNTIME_STATE_PLAN" \
+  "$PYTHON_REMAP_NATIVE_RUNTIME_FIXTURE_PLAN" \
+  "$PYTHON_REMAP_RUNTIME_CONTRACT" \
+  "$NATIVE_RUNTIME_PROBE_SUMMARY" \
+  "$BLOCKED_RUNTIME_PROMOTION_LOCK" \
+  "$BOUNDARY_PHASE_COMPLETION_SUMMARY" \
+  "$NEXT_BOUNDARY_RECOMMENDATIONS"; do
+  if [[ ! -f "$artifact" || "$INVENTORY_SCRIPT" -nt "$artifact" ]]; then
+    INVENTORY_REQUIRED=1
+  fi
+done
+if [[ -f "$NATIVE_SOURCE_PROOF_SUMMARY" && "$NATIVE_SOURCE_PROOF_SUMMARY" -nt "$NATIVE_PROOF_ALIGNMENT_SUMMARY" ]]; then
+  INVENTORY_REQUIRED=1
+fi
+if [[ -f "$NATIVE_RUNTIME_PROBE_SOURCE_SUMMARY" && "$NATIVE_RUNTIME_PROBE_SOURCE_SUMMARY" -nt "$NATIVE_RUNTIME_PROBE_SUMMARY" ]]; then
+  INVENTORY_REQUIRED=1
+fi
+if [[ "$INVENTORY_REQUIRED" == "1" ]]; then
+  SKIP_INTERP_BUILD=1 "$ROOT_DIR/tests/wasm/node/verify_sim_configs_inventory_wasm.sh"
+fi
 
 TMP_DIR="$(mktemp -d)"
 PORT_FILE="$TMP_DIR/port"
diff --git a/wasm-port/tests/host/verify_host_smokes.sh b/wasm-port/tests/host/verify_host_smokes.sh
index ddbd3c0..c2e8c4c 100755
--- a/wasm-port/tests/host/verify_host_smokes.sh
+++ b/wasm-port/tests/host/verify_host_smokes.sh
@@ -9,6 +9,7 @@ ROOT_DIR="$(cd "$(dirname "$0")/../.." && pwd)"
 SKIP_INI_BUILD=1 "$ROOT_DIR/tests/wasm/node/verify_ini_wasm.sh"
 SKIP_INTERP_BUILD=1 "$ROOT_DIR/tests/wasm/node/verify_interp_wasm.sh"
 SKIP_INTERP_BUILD=1 "$ROOT_DIR/tests/wasm/node/verify_sim_configs_wasm.sh"
+SKIP_INTERP_BUILD=1 "$ROOT_DIR/tests/wasm/node/verify_sim_configs_inventory_wasm.sh"
 SKIP_INTERP_BUILD=1 "$ROOT_DIR/tests/wasm/node/verify_nc_files_wasm.sh"
 SKIP_TP_BUILD=1 "$ROOT_DIR/tests/wasm/node/verify_tp_wasm.sh"
 "$ROOT_DIR/tests/opfs/node/verify_file_service.sh"
diff --git a/wasm-port/tests/native/probe_millturn_user_m_runtime.sh b/wasm-port/tests/native/probe_millturn_user_m_runtime.sh
new file mode 100644
index 0000000..604e2c4
--- /dev/null
+++ b/wasm-port/tests/native/probe_millturn_user_m_runtime.sh
@@ -0,0 +1,202 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/../.." && pwd)"
+LINUXCNC_ROOT="${LINUXCNC_ROOT:-$ROOT_DIR/../linuxcnc}"
+MACHINE_DIR="$LINUXCNC_ROOT/configs/sim/axis/vismach/millturn"
+INI_FILE="$MACHINE_DIR/millturn.ini"
+RUN_DIR="$ROOT_DIR/build/native/millturn-user-m-runtime"
+LINUXCNC_STDOUT="$RUN_DIR/linuxcnc.stdout.log"
+LINUXCNC_STDERR="$RUN_DIR/linuxcnc.stderr.log"
+
+required_commands=(tclsh halrun halcmd linuxcnc)
+missing_commands=()
+LINUXCNC_PID=""
+
+cleanup() {
+  if [[ -n "$LINUXCNC_PID" ]]; then
+    kill "$LINUXCNC_PID" 2>/dev/null || true
+    wait "$LINUXCNC_PID" 2>/dev/null || true
+  fi
+}
+trap cleanup EXIT
+
+command_path() {
+  command -v "$1" 2>/dev/null || true
+}
+
+csv_join() {
+  local IFS=,
+  printf '%s' "$*"
+}
+
+print_kv() {
+  printf '%s=%s\n' "$1" "$2"
+}
+
+runtime_requirements=()
+for command_name in "${required_commands[@]}"; do
+  path="$(command_path "$command_name")"
+  if [[ -n "$path" ]]; then
+    runtime_requirements+=("$command_name:1")
+    print_kv "millturn_user_m_runtime_${command_name}_path" "$path"
+  else
+    runtime_requirements+=("$command_name:0")
+    missing_commands+=("$command_name")
+  fi
+done
+
+source_ready=1
+for rel in \
+  millturn.ini \
+  mcodes/M128 \
+  mcodes/M129 \
+  remap_subs/428remap.ngc \
+  remap_subs/429remap.ngc; do
+  if [[ ! -f "$MACHINE_DIR/$rel" ]]; then
+    source_ready=0
+    print_kv "millturn_user_m_missing_source_${rel//[^A-Za-z0-9]/_}" "$MACHINE_DIR/$rel"
+  fi
+done
+
+runtime_ready=0
+if [[ "${#missing_commands[@]}" -eq 0 ]]; then
+  runtime_ready=1
+fi
+
+print_kv millturn_user_m_runtime_requirements "$(csv_join "${runtime_requirements[@]}")"
+if [[ "${#missing_commands[@]}" -eq 0 ]]; then
+  print_kv millturn_user_m_missing_requirements "-"
+else
+  print_kv millturn_user_m_missing_requirements "$(csv_join "${missing_commands[@]}")"
+fi
+print_kv millturn_user_m_source_proof_ready "$source_ready"
+print_kv millturn_user_m_runtime_ready "$runtime_ready"
+print_kv millturn_user_m_execution_enabled 0
+print_kv millturn_user_m_promotion_allowed 0
+
+if [[ "$source_ready" != "1" ]]; then
+  print_kv millturn_user_m_runtime_probe_status "blocked_missing_source"
+  exit 0
+fi
+
+if [[ "$runtime_ready" != "1" ]]; then
+  print_kv millturn_user_m_runtime_probe_status "skipped_missing_host_runtime"
+  exit 0
+fi
+
+if [[ "${ENABLE_MILLTURN_USER_M_RUNTIME_PROBE:-0}" != "1" ]]; then
+  print_kv millturn_user_m_runtime_probe_status "ready_disabled_by_default"
+  print_kv millturn_user_m_runtime_probe_note "set_ENABLE_MILLTURN_USER_M_RUNTIME_PROBE_1_to_run_full_process_probe"
+  exit 0
+fi
+
+mkdir -p "$RUN_DIR"
+
+wait_for_hal_pin() {
+  local pin="$1"
+  local limit="${MILLTURN_USER_M_RUNTIME_WAIT_SECONDS:-30}"
+  local end=$((SECONDS + limit))
+  while (( SECONDS < end )); do
+    if halcmd getp "$pin" >/dev/null 2>&1; then
+      return 0
+    fi
+    sleep 0.25
+  done
+  return 1
+}
+
+read_hal_pin() {
+  halcmd getp "$1" 2>/dev/null | tr -d '[:space:]'
+}
+
+expect_hal_pin() {
+  local label="$1"
+  local pin="$2"
+  local expected="$3"
+  local actual
+  actual="$(read_hal_pin "$pin")"
+  print_kv "millturn_user_m_${label}_${pin//[^A-Za-z0-9]/_}" "$actual"
+  [[ "$actual" == "$expected" ]]
+}
+
+set_switchkins_target() {
+  local target="$1"
+  local guard_pin="kinstype.is-$target"
+  if ! halcmd setp motion.switchkins-type "$target" >/dev/null 2>&1; then
+    halcmd unlinkp motion.switchkins-type >/dev/null 2>&1 || true
+    halcmd setp motion.switchkins-type "$target"
+  fi
+  for _ in $(seq 1 40); do
+    if [[ "$(read_hal_pin "$guard_pin")" =~ ^(TRUE|1)$ ]]; then
+      return 0
+    fi
+    sleep 0.05
+  done
+  return 1
+}
+
+run_user_m_case() {
+  local code="$1"
+  local mode="$2"
+  local switchkins_target="$3"
+  local expected_x_min="$4"
+  local expected_x_max="$5"
+  local expected_y_min="$6"
+  local expected_y_max="$7"
+  local expected_z_min="$8"
+  local expected_z_max="$9"
+
+  print_kv "millturn_user_m_${code}_runtime_mode" "$mode"
+  if ! set_switchkins_target "$switchkins_target"; then
+    print_kv "millturn_user_m_${code}_switchkins_target_ready" 0
+    return 1
+  fi
+  print_kv "millturn_user_m_${code}_switchkins_target_ready" 1
+
+  INI_FILE_NAME="$INI_FILE" "$MACHINE_DIR/mcodes/$code"
+
+  local ok=1
+  expect_hal_pin "${code}" ini.x.min_limit "$expected_x_min" || ok=0
+  expect_hal_pin "${code}" ini.x.max_limit "$expected_x_max" || ok=0
+  expect_hal_pin "${code}" ini.y.min_limit "$expected_y_min" || ok=0
+  expect_hal_pin "${code}" ini.y.max_limit "$expected_y_max" || ok=0
+  expect_hal_pin "${code}" ini.z.min_limit "$expected_z_min" || ok=0
+  expect_hal_pin "${code}" ini.z.max_limit "$expected_z_max" || ok=0
+  expect_hal_pin "${code}" ini.x.max_velocity "60" || ok=0
+  expect_hal_pin "${code}" ini.y.max_velocity "60" || ok=0
+  expect_hal_pin "${code}" ini.z.max_velocity "60" || ok=0
+  expect_hal_pin "${code}" ini.x.max_acceleration "400" || ok=0
+  expect_hal_pin "${code}" ini.y.max_acceleration "400" || ok=0
+  expect_hal_pin "${code}" ini.z.max_acceleration "400" || ok=0
+
+  print_kv "millturn_user_m_${code}_runtime_state_ok" "$ok"
+  [[ "$ok" == "1" ]]
+}
+
+print_kv millturn_user_m_runtime_probe_ini "$INI_FILE"
+print_kv millturn_user_m_runtime_probe_linuxcnc_stdout "$LINUXCNC_STDOUT"
+print_kv millturn_user_m_runtime_probe_linuxcnc_stderr "$LINUXCNC_STDERR"
+
+linuxcnc -r "$INI_FILE" >"$LINUXCNC_STDOUT" 2>"$LINUXCNC_STDERR" &
+LINUXCNC_PID="$!"
+
+if ! wait_for_hal_pin ini.x.min_limit || ! wait_for_hal_pin motion.switchkins-type; then
+  print_kv millturn_user_m_runtime_probe_status "runtime_state_probe_failed"
+  print_kv millturn_user_m_runtime_probe_note "linuxcnc_started_but_required_hal_pins_did_not_appear"
+  exit 1
+fi
+
+probe_ok=1
+run_user_m_case M128 mill 0 -300 300 -100 100 -240 0 || probe_ok=0
+run_user_m_case M129 turn 1 -240 0 -100 100 -300 300 || probe_ok=0
+
+if [[ "$probe_ok" == "1" ]]; then
+  print_kv millturn_user_m_runtime_probe_status "runtime_state_probe_passed"
+  print_kv millturn_user_m_runtime_probe_note "linuxcnc_owned_M128_M129_tcl_hal_state_probe_passed_without_promotion"
+  exit 0
+fi
+
+print_kv millturn_user_m_runtime_probe_status "runtime_state_probe_failed"
+print_kv millturn_user_m_runtime_probe_note "linuxcnc_owned_M128_M129_tcl_hal_state_probe_failed"
+exit 1
diff --git a/wasm-port/tests/native/probe_python_remap_runtime.sh b/wasm-port/tests/native/probe_python_remap_runtime.sh
new file mode 100755
index 0000000..f940a27
--- /dev/null
+++ b/wasm-port/tests/native/probe_python_remap_runtime.sh
@@ -0,0 +1,189 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/../.." && pwd)"
+LINUXCNC_ROOT="${LINUXCNC_ROOT:-$ROOT_DIR/../linuxcnc}"
+FIXTURE_FAMILY="axis/remap/stop-lookahead/nc_files"
+FIXTURE_DIR="$LINUXCNC_ROOT/configs/sim/axis/remap/stop-lookahead"
+FIXTURE_INI="$FIXTURE_DIR/demo.ini"
+RUN_DIR="$ROOT_DIR/build/native/python-remap-runtime"
+PYTHON_RUNTIME_STDOUT="$RUN_DIR/python_lifecycle.stdout.log"
+PYTHON_RUNTIME_STDERR="$RUN_DIR/python_lifecycle.stderr.log"
+
+required_commands=(python3 linuxcnc)
+missing_requirements=()
+
+command_path() {
+  command -v "$1" 2>/dev/null || true
+}
+
+csv_join() {
+  local IFS=,
+  printf '%s' "$*"
+}
+
+print_kv() {
+  printf '%s=%s\n' "$1" "$2"
+}
+
+runtime_requirements=()
+for command_name in "${required_commands[@]}"; do
+  path="$(command_path "$command_name")"
+  if [[ -n "$path" ]]; then
+    runtime_requirements+=("$command_name:1")
+    print_kv "python_remap_runtime_${command_name}_path" "$path"
+  else
+    runtime_requirements+=("$command_name:0")
+    missing_requirements+=("$command_name")
+  fi
+done
+
+source_ready=1
+for rel in \
+  src/emc/rs274ngc/interp_python.cc \
+  src/emc/pythonplugin/python_plugin.cc \
+  configs/sim/axis/remap/stop-lookahead/demo.ini \
+  configs/sim/axis/remap/stop-lookahead/python/remap.py \
+  configs/sim/axis/remap/stop-lookahead/python/toplevel.py; do
+  if [[ ! -f "$LINUXCNC_ROOT/$rel" ]]; then
+    source_ready=0
+    missing_requirements+=("$rel")
+    print_kv "python_remap_missing_source_${rel//[^A-Za-z0-9]/_}" "$LINUXCNC_ROOT/$rel"
+  fi
+done
+
+runtime_ready=0
+if [[ "${#missing_requirements[@]}" -eq 0 ]]; then
+  runtime_ready=1
+fi
+
+print_kv python_remap_runtime_fixture_family "$FIXTURE_FAMILY"
+print_kv python_remap_runtime_fixture_id "stop_lookahead_python_runtime_lifecycle"
+print_kv python_remap_runtime_fixture_scope "no_python_callables_no_ngc_only_subpaths"
+print_kv python_remap_runtime_phases "initialize_python,apply_ini_python_path,execute_toplevel,callable_lookup,pycall_dispatch,callable_invoke,remap_phase_dispatch,generator_finish,execute_python_runtime,reload_on_change"
+print_kv python_remap_runtime_modules "axis/remap/stop-lookahead/python/remap.py,axis/remap/stop-lookahead/python/toplevel.py"
+print_kv python_remap_runtime_requirements "$(csv_join "${runtime_requirements[@]}")"
+if [[ "${#missing_requirements[@]}" -eq 0 ]]; then
+  print_kv python_remap_missing_requirements "-"
+else
+  print_kv python_remap_missing_requirements "$(csv_join "${missing_requirements[@]}")"
+fi
+print_kv python_remap_source_proof_ready "$source_ready"
+print_kv python_remap_runtime_ready "$runtime_ready"
+print_kv python_remap_execution_enabled 0
+print_kv python_remap_promotion_allowed 0
+
+if [[ "$source_ready" != "1" ]]; then
+  print_kv python_remap_runtime_probe_status "blocked_missing_source"
+  exit 0
+fi
+
+if [[ "$runtime_ready" != "1" ]]; then
+  print_kv python_remap_runtime_probe_status "skipped_missing_host_runtime"
+  exit 0
+fi
+
+if [[ "${ENABLE_PYTHON_REMAP_RUNTIME_PROBE:-0}" != "1" ]]; then
+  print_kv python_remap_runtime_probe_status "ready_disabled_by_default"
+  print_kv python_remap_runtime_probe_note "set_ENABLE_PYTHON_REMAP_RUNTIME_PROBE_1_to_run_python_lifecycle_probe"
+  exit 0
+fi
+
+mkdir -p "$RUN_DIR"
+rm -f "$PYTHON_RUNTIME_STDOUT" "$PYTHON_RUNTIME_STDERR"
+
+print_kv python_remap_runtime_probe_fixture "$FIXTURE_DIR"
+print_kv python_remap_runtime_probe_ini "$FIXTURE_INI"
+print_kv python_remap_runtime_probe_stdout "$PYTHON_RUNTIME_STDOUT"
+print_kv python_remap_runtime_probe_stderr "$PYTHON_RUNTIME_STDERR"
+
+if python3 - "$LINUXCNC_ROOT" "$FIXTURE_DIR" "$FIXTURE_INI" "$RUN_DIR" \
+    >"$PYTHON_RUNTIME_STDOUT" 2>"$PYTHON_RUNTIME_STDERR" <<'PY'
+import configparser
+import importlib
+import inspect
+import os
+from pathlib import Path
+import re
+import sys
+import tempfile
+
+linuxcnc_root = Path(sys.argv[1])
+fixture_dir = Path(sys.argv[2])
+fixture_ini = Path(sys.argv[3])
+run_dir = Path(sys.argv[4])
+
+def emit(name, value):
+    print(f"{name}={value}")
+
+def require(condition, message):
+    if not condition:
+        raise RuntimeError(message)
+
+interp_return = linuxcnc_root / "src/emc/nml_intf/interp_return.hh"
+match = re.search(
+    r"INTERP_EXECUTE_FINISH\s*=\s*([0-9]+)",
+    interp_return.read_text(encoding="utf-8"),
+)
+require(match, "missing_INTERP_EXECUTE_FINISH_source_value")
+execute_finish = int(match.group(1))
+emit("python_remap_lifecycle_execute_finish_source_value", execute_finish)
+
+stub_dir = Path(tempfile.mkdtemp(prefix="python-remap-interpreter-", dir=run_dir))
+(stub_dir / "interpreter.py").write_text(
+    f"INTERP_EXECUTE_FINISH = {execute_finish}\n",
+    encoding="utf-8",
+)
+
+parser = configparser.ConfigParser(strict=False)
+parser.optionxform = str
+parser.read(fixture_ini)
+require(parser.has_section("PYTHON"), "missing_PYTHON_section")
+path_prepend = parser.get("PYTHON", "PATH_PREPEND", fallback="")
+toplevel = parser.get("PYTHON", "TOPLEVEL", fallback="")
+require(path_prepend == "python", f"PATH_PREPEND_drift:{path_prepend}")
+require(toplevel == "python/toplevel.py", f"TOPLEVEL_drift:{toplevel}")
+emit("python_remap_lifecycle_ini_path_prepend", path_prepend)
+emit("python_remap_lifecycle_ini_toplevel", toplevel)
+
+sys.path.insert(0, str(stub_dir))
+sys.path.insert(0, str(fixture_dir / path_prepend))
+sys.path.insert(0, str(linuxcnc_root / "lib/python"))
+
+import interpreter  # noqa: E402
+require(interpreter.INTERP_EXECUTE_FINISH == execute_finish, "interpreter_sentinel_drift")
+emit("python_remap_lifecycle_interpreter_sentinel_ok", 1)
+
+toplevel_module = importlib.import_module(Path(toplevel).stem)
+emit("python_remap_lifecycle_toplevel_imported", int(toplevel_module.__name__ == "toplevel"))
+remap_module = importlib.import_module("remap")
+emit("python_remap_lifecycle_remap_imported", int(remap_module.__name__ == "remap"))
+require(hasattr(remap_module, "queuebuster"), "missing_queuebuster_callable")
+require(callable(remap_module.queuebuster), "queuebuster_not_callable")
+emit("python_remap_lifecycle_callable_lookup_ok", 1)
+
+result = remap_module.queuebuster(object())
+require(inspect.isgenerator(result), "queuebuster_not_generator")
+emit("python_remap_lifecycle_generator_returned", 1)
+first_yield = next(result)
+require(first_yield == execute_finish, f"queuebuster_yield_drift:{first_yield}")
+emit("python_remap_lifecycle_generator_first_yield", first_yield)
+try:
+    next(result)
+    raise RuntimeError("queuebuster_generator_did_not_finish")
+except StopIteration:
+    emit("python_remap_lifecycle_generator_finish_ok", 1)
+
+emit("python_remap_runtime_lifecycle_probe_ok", 1)
+PY
+then
+  cat "$PYTHON_RUNTIME_STDOUT"
+  print_kv python_remap_runtime_probe_status "runtime_lifecycle_probe_passed"
+  print_kv python_remap_runtime_probe_note "linuxcnc_stop_lookahead_python_lifecycle_probe_passed_without_promotion"
+  exit 0
+fi
+
+cat "$PYTHON_RUNTIME_STDOUT" || true
+print_kv python_remap_runtime_probe_status "runtime_lifecycle_probe_failed"
+print_kv python_remap_runtime_probe_note "linuxcnc_stop_lookahead_python_lifecycle_probe_failed"
+exit 1
diff --git a/wasm-port/tests/native/probe_tool_db_runtime.sh b/wasm-port/tests/native/probe_tool_db_runtime.sh
new file mode 100644
index 0000000..0ff73fe
--- /dev/null
+++ b/wasm-port/tests/native/probe_tool_db_runtime.sh
@@ -0,0 +1,232 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/../.." && pwd)"
+LINUXCNC_ROOT="${LINUXCNC_ROOT:-$ROOT_DIR/../linuxcnc}"
+DB_DEMO_DIR="$LINUXCNC_ROOT/configs/sim/axis/db_demo"
+DB_PROGRAM="$DB_DEMO_DIR/db_nonran.py"
+RUN_DIR="$ROOT_DIR/build/native/tool-db-runtime"
+DB_SAVEFILE="$RUN_DIR/db_nonran_probe"
+DB_STDOUT="$RUN_DIR/db_program.stdout.log"
+DB_STDERR="$RUN_DIR/db_program.stderr.log"
+
+required_commands=(python3 linuxcnc milltask halcmd)
+missing_requirements=()
+
+command_path() {
+  command -v "$1" 2>/dev/null || true
+}
+
+csv_join() {
+  local IFS=,
+  printf '%s' "$*"
+}
+
+print_kv() {
+  printf '%s=%s\n' "$1" "$2"
+}
+
+runtime_requirements=()
+for command_name in "${required_commands[@]}"; do
+  path="$(command_path "$command_name")"
+  if [[ -n "$path" ]]; then
+    runtime_requirements+=("$command_name:1")
+    print_kv "tool_db_runtime_${command_name}_path" "$path"
+  else
+    runtime_requirements+=("$command_name:0")
+    missing_requirements+=("$command_name")
+  fi
+done
+
+source_ready=1
+for rel in \
+  configs/sim/axis/db_demo/db_nonran.ini \
+  configs/sim/axis/db_demo/db.py \
+  lib/python/tooldb.py \
+  lib/python/linuxcnc.so; do
+  if [[ ! -e "$LINUXCNC_ROOT/$rel" ]]; then
+    source_ready=0
+    missing_requirements+=("$rel")
+    print_kv "tool_db_missing_source_${rel//[^A-Za-z0-9]/_}" "$LINUXCNC_ROOT/$rel"
+  fi
+done
+
+if [[ ! -x "$DB_PROGRAM" ]]; then
+  source_ready=0
+  missing_requirements+=("configs/sim/axis/db_demo/db_nonran.py:executable")
+fi
+
+runtime_ready=0
+if [[ "${#missing_requirements[@]}" -eq 0 ]]; then
+  runtime_ready=1
+fi
+
+print_kv tool_db_runtime_requirements "$(csv_join "${runtime_requirements[@]}")"
+if [[ "${#missing_requirements[@]}" -eq 0 ]]; then
+  print_kv tool_db_missing_requirements "-"
+else
+  print_kv tool_db_missing_requirements "$(csv_join "${missing_requirements[@]}")"
+fi
+print_kv tool_db_source_proof_ready "$source_ready"
+print_kv tool_db_runtime_ready "$runtime_ready"
+print_kv tool_db_execution_enabled 0
+print_kv tool_db_promotion_allowed 0
+
+if [[ "$source_ready" != "1" ]]; then
+  print_kv tool_db_runtime_probe_status "blocked_missing_source"
+  exit 0
+fi
+
+if [[ "$runtime_ready" != "1" ]]; then
+  print_kv tool_db_runtime_probe_status "skipped_missing_host_runtime"
+  exit 0
+fi
+
+if [[ "${ENABLE_TOOL_DB_RUNTIME_PROBE:-0}" != "1" ]]; then
+  print_kv tool_db_runtime_probe_status "ready_disabled_by_default"
+  print_kv tool_db_runtime_probe_note "set_ENABLE_TOOL_DB_RUNTIME_PROBE_1_to_run_db_protocol_probe"
+  exit 0
+fi
+
+mkdir -p "$RUN_DIR"
+rm -f "$DB_SAVEFILE" "$DB_STDOUT" "$DB_STDERR"
+
+print_kv tool_db_runtime_probe_program "$DB_PROGRAM"
+print_kv tool_db_runtime_probe_db_savefile "$DB_SAVEFILE"
+print_kv tool_db_runtime_probe_stdout "$DB_STDOUT"
+print_kv tool_db_runtime_probe_stderr "$DB_STDERR"
+
+if python3 - "$DB_PROGRAM" "$DB_DEMO_DIR" "$LINUXCNC_ROOT/lib/python" "$DB_SAVEFILE" "$DB_STDOUT" "$DB_STDERR" <<'PY'
+import os
+import select
+import subprocess
+import sys
+import time
+
+db_program, db_demo_dir, python_path, db_savefile, stdout_log, stderr_log = sys.argv[1:]
+
+env = os.environ.copy()
+env["PYTHONPATH"] = python_path + (os.pathsep + env["PYTHONPATH"] if env.get("PYTHONPATH") else "")
+
+stdout_file = open(stdout_log, "w", encoding="utf-8")
+stderr_file = open(stderr_log, "w", encoding="utf-8")
+proc = subprocess.Popen(
+    [db_program, "--period_minutes=999", db_savefile],
+    cwd=db_demo_dir,
+    env=env,
+    stdin=subprocess.PIPE,
+    stdout=subprocess.PIPE,
+    stderr=stderr_file,
+    text=True,
+    bufsize=1,
+)
+
+def emit(name, value):
+    print(f"{name}={value}")
+
+def read_line(timeout=5.0):
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        ready, _, _ = select.select([proc.stdout], [], [], 0.1)
+        if ready:
+            line = proc.stdout.readline()
+            if line == "":
+                raise RuntimeError("db_program_stdout_closed")
+            line = line.rstrip("\n")
+            stdout_file.write(line + "\n")
+            stdout_file.flush()
+            return line
+        if proc.poll() is not None:
+            raise RuntimeError(f"db_program_exited_{proc.returncode}")
+    raise RuntimeError("timeout_waiting_for_db_program_reply")
+
+def send(command):
+    proc.stdin.write(command + "\n")
+    proc.stdin.flush()
+
+def read_until_fini(command, timeout=5.0):
+    send(command)
+    lines = []
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        line = read_line(max(0.1, deadline - time.monotonic()))
+        lines.append(line)
+        if line.startswith("FINI"):
+            return lines
+    raise RuntimeError(f"timeout_waiting_for_fini_{command.split()[0]}")
+
+def require(condition, message):
+    if not condition:
+        raise RuntimeError(message)
+
+ok = False
+try:
+    version = read_line()
+    emit("tool_db_protocol_version", version)
+    require(version == "v2.1", f"version_drift:{version}")
+
+    get_all = read_until_fini("g")
+    tool_lines = [line for line in get_all if line.startswith("T")]
+    emit("tool_db_get_all_count", len(tool_lines))
+    require(len(tool_lines) == 10, "get_all_tool_count_drift")
+    for toolno in range(10, 20):
+        expected = f"T{toolno} "
+        require(any(line.startswith(expected) for line in tool_lines), f"missing_tool_{toolno}")
+        require(any(line.startswith(expected) and f"P{toolno + 100}" in line for line in tool_lines), f"pocket_drift_{toolno}")
+    emit("tool_db_get_all_fini", int(get_all[-1].startswith("FINI")))
+
+    put_reply = read_until_fini("p t11 p111 d0.33 z0.11")
+    emit("tool_db_put_tool_update_fini", int(put_reply[-1].startswith("FINI")))
+
+    get_after_put = read_until_fini("g")
+    t11_rows = [line for line in get_after_put if line.startswith("T11 ")]
+    require(t11_rows and "D0.33" in t11_rows[0] and "Z0.11" in t11_rows[0], "put_update_state_drift")
+    emit("tool_db_put_tool_update_state_ok", 1)
+
+    load_reply = read_until_fini("l t14 p0")
+    emit("tool_db_load_spindle_fini", int(load_reply[-1].startswith("FINI")))
+    t14_loaded = read_until_fini("t 14")
+    require(any(line.startswith("T14 ") and "P0" in line for line in t14_loaded), "load_spindle_state_drift")
+    emit("tool_db_load_spindle_state_ok", 1)
+
+    unload_reply = read_until_fini("u t0 p0")
+    emit("tool_db_unload_spindle_fini", int(unload_reply[-1].startswith("FINI")))
+    t14_unloaded = read_until_fini("t 14")
+    require(any(line.startswith("T14 ") and "P114" in line for line in t14_unloaded), "unload_spindle_state_drift")
+    emit("tool_db_unload_spindle_state_ok", 1)
+
+    require(os.path.exists(db_savefile), "db_savefile_missing")
+    with open(db_savefile, "r", encoding="utf-8") as handle:
+        saved = handle.read()
+    require("T11 P111 D0.33 Z0.11" in saved, "db_savefile_put_update_missing")
+    require("T14 P114" in saved, "db_savefile_unload_state_missing")
+    emit("tool_db_persistence_state_ok", 1)
+    ok = True
+finally:
+    try:
+        if proc.stdin:
+            proc.stdin.close()
+    except Exception:
+        pass
+    if proc.poll() is None:
+        proc.terminate()
+        try:
+            proc.wait(timeout=2)
+        except subprocess.TimeoutExpired:
+            proc.kill()
+            proc.wait(timeout=2)
+    stderr_file.close()
+    stdout_file.close()
+
+emit("tool_db_runtime_protocol_probe_ok", int(ok))
+sys.exit(0 if ok else 1)
+PY
+then
+  print_kv tool_db_runtime_probe_status "runtime_protocol_probe_passed"
+  print_kv tool_db_runtime_probe_note "linuxcnc_owned_DB_PROGRAM_protocol_probe_passed_without_promotion"
+  exit 0
+fi
+
+print_kv tool_db_runtime_probe_status "runtime_protocol_probe_failed"
+print_kv tool_db_runtime_probe_note "linuxcnc_owned_DB_PROGRAM_protocol_probe_failed"
+exit 1
diff --git a/wasm-port/tests/native/verify_native_probes.sh b/wasm-port/tests/native/verify_native_probes.sh
index 16596d6..65a1688 100755
--- a/wasm-port/tests/native/verify_native_probes.sh
+++ b/wasm-port/tests/native/verify_native_probes.sh
@@ -32,6 +32,8 @@ hash_build_validation_inputs() {
       -o -name '*.run.stdout.log' \
       -o -name '*.run.stderr.log' \
       -o -name 'source-probes.tsv' \
+      -o -name 'native-source-proof-summary.tsv' \
+      -o -name 'native-runtime-probe-summary.tsv' \
       -o -name 'native-probes.ok' \
       -o -name 'linuxcnc_interp_minimal_harness' \
     \) \
@@ -122,13 +124,195 @@ check_exitcode() {
   fi
 }
 
+check_native_source_proof_summary_row() {
+  local boundary_class="$1"
+  local proof_key="$2"
+  local summary_file="$BUILD_DIR/native-source-proof-summary.tsv"
+
+  local row
+  row="$(awk -F'\t' -v boundary_class="$boundary_class" -v proof_key="$proof_key" '
+    NR > 1 && $1 == boundary_class && $2 == proof_key { print; count++ }
+    END {
+      if (count != 1) {
+        exit 1
+      }
+    }
+  ' "$summary_file")" || {
+    echo "missing native source proof summary row: $boundary_class $proof_key" >&2
+    exit 1
+  }
+
+  local proof_value
+  local execution_enabled
+  local promotion_allowed
+  local stdout_log
+  IFS=$'\t' read -r _ _ proof_value execution_enabled promotion_allowed stdout_log <<< "$row"
+
+  if [[ "$proof_value" != "1" ]]; then
+    echo "$boundary_class native source proof is not complete: $proof_value" >&2
+    exit 1
+  fi
+  if [[ "$execution_enabled" != "0" || "$promotion_allowed" != "0" ]]; then
+    echo "$boundary_class unexpectedly enables execution or promotion" >&2
+    exit 1
+  fi
+  if [[ ! -f "$BUILD_DIR/$stdout_log" ]]; then
+    echo "$boundary_class summary references missing stdout log: $stdout_log" >&2
+    exit 1
+  fi
+}
+
+check_native_source_proof_summary() {
+  local summary_file="$BUILD_DIR/native-source-proof-summary.tsv"
+
+  if [[ ! -f "$summary_file" ]]; then
+    echo "missing native source proof summary: $summary_file" >&2
+    exit 1
+  fi
+
+  local expected_header
+  expected_header=$'boundary_class\tproof_key\tproof_value\texecution_enabled\tpromotion_allowed\tstdout_log'
+  if [[ "$(sed -n '1p' "$summary_file")" != "$expected_header" ]]; then
+    echo "native source proof summary header drift: $summary_file" >&2
+    exit 1
+  fi
+
+  local row_count
+  row_count="$(awk 'END { print NR - 1 }' "$summary_file")"
+  if [[ "$row_count" != "3" ]]; then
+    echo "native source proof summary must contain exactly 3 proof rows, got $row_count" >&2
+    exit 1
+  fi
+
+  check_native_source_proof_summary_row \
+    L4-USER-M-PROCESS \
+    millturn_user_m_native_source_state_proof
+  check_native_source_proof_summary_row \
+    L4-TOOL-DB \
+    tool_db_native_source_protocol_proof
+  check_native_source_proof_summary_row \
+    L4-PYTHON-REMAP \
+    python_remap_native_source_inventory_proof
+}
+
+check_native_runtime_probe_summary_row() {
+  local boundary_class="$1"
+  local boundary_kind="$2"
+  local target="$3"
+  local runtime_probe="$4"
+  local summary_file="$BUILD_DIR/native-runtime-probe-summary.tsv"
+
+  local row
+  row="$(awk -F'\t' \
+    -v boundary_class="$boundary_class" \
+    -v boundary_kind="$boundary_kind" \
+    -v target="$target" \
+    -v runtime_probe="$runtime_probe" '
+      NR > 1 && $1 == boundary_class && $2 == boundary_kind && $3 == target && $4 == runtime_probe {
+        print
+        count++
+      }
+      END {
+        if (count != 1) {
+          exit 1
+        }
+      }
+    ' "$summary_file")" || {
+    echo "missing native runtime probe summary row: $boundary_class $boundary_kind $target" >&2
+    exit 1
+  }
+
+  local runtime_ready
+  local source_proof_ready
+  local probe_status
+  local execution_enabled
+  local promotion_allowed
+  local missing_requirements
+  local stdout_log
+  IFS=$'\t' read -r _ _ _ _ runtime_ready source_proof_ready probe_status execution_enabled promotion_allowed missing_requirements stdout_log <<< "$row"
+
+  if [[ "$source_proof_ready" != "1" ]]; then
+    echo "$target runtime probe lacks source proof readiness: $source_proof_ready" >&2
+    exit 1
+  fi
+  if [[ "$execution_enabled" != "0" || "$promotion_allowed" != "0" ]]; then
+    echo "$target runtime probe unexpectedly enables execution or promotion" >&2
+    exit 1
+  fi
+  if [[ ! "$probe_status" =~ ^(skipped_missing_host_runtime|ready_disabled_by_default|not_implemented_full_process_guard|runtime_state_probe_passed|runtime_protocol_probe_passed|runtime_lifecycle_probe_passed)$ ]]; then
+    echo "$target runtime probe has invalid status: $probe_status" >&2
+    exit 1
+  fi
+  if [[ "$runtime_ready" == "0" && "$probe_status" != "skipped_missing_host_runtime" ]]; then
+    echo "$target runtime probe is not ready but did not skip: $probe_status" >&2
+    exit 1
+  fi
+  if [[ "$runtime_ready" == "1" && "$missing_requirements" != "-" ]]; then
+    echo "$target runtime probe is ready but lists missing requirements: $missing_requirements" >&2
+    exit 1
+  fi
+  if [[ ! -f "$BUILD_DIR/$stdout_log" ]]; then
+    echo "$target runtime summary references missing stdout log: $stdout_log" >&2
+    exit 1
+  fi
+}
+
+check_native_runtime_probe_summary() {
+  local summary_file="$BUILD_DIR/native-runtime-probe-summary.tsv"
+
+  if [[ ! -f "$summary_file" ]]; then
+    echo "missing native runtime probe summary: $summary_file" >&2
+    exit 1
+  fi
+
+  local expected_header
+  expected_header=$'boundary_class\tboundary_kind\ttarget\truntime_probe\truntime_ready\tsource_proof_ready\tprobe_status\texecution_enabled\tpromotion_allowed\tmissing_requirements\tstdout_log'
+  if [[ "$(sed -n '1p' "$summary_file")" != "$expected_header" ]]; then
+    echo "native runtime probe summary header drift: $summary_file" >&2
+    exit 1
+  fi
+
+  local row_count
+  row_count="$(awk 'END { print NR - 1 }' "$summary_file")"
+  if [[ "$row_count" != "3" ]]; then
+    echo "native runtime probe summary must contain exactly 3 probe rows, got $row_count" >&2
+    exit 1
+  fi
+
+  check_native_runtime_probe_summary_row \
+    L4-USER-M-PROCESS \
+    external_user_m_process \
+    axis/vismach/millturn/example.ngc \
+    linuxcnc_millturn_user_m_runtime_probe
+  check_native_runtime_probe_summary_row \
+    L4-TOOL-DB \
+    tool_database_process \
+    axis/db_demo/base.ngc \
+    linuxcnc_tool_db_runtime_probe
+  check_native_runtime_probe_summary_row \
+    L4-PYTHON-REMAP \
+    python_runtime \
+    axis/remap/stop-lookahead/nc_files \
+    linuxcnc_python_remap_runtime_probe
+}
+
 check_source_probe_coverage
+check_native_source_proof_summary
+check_native_runtime_probe_summary
 check_exitcode linuxcnc_interp_state_probe
 check_exitcode linuxcnc_emc_status_probe
 check_exitcode linuxcnc_emc_status_probe.run
 check_exitcode linuxcnc_inifile_source_probe
 check_exitcode linuxcnc_5axis_remap_asset_probe
 check_exitcode linuxcnc_5axis_remap_asset_probe.run
+check_exitcode linuxcnc_millturn_user_m_boundary_probe
+check_exitcode linuxcnc_millturn_user_m_boundary_probe.run
+check_exitcode linuxcnc_millturn_user_m_runtime_probe.run
+check_exitcode linuxcnc_tool_db_boundary_probe
+check_exitcode linuxcnc_tool_db_boundary_probe.run
+check_exitcode linuxcnc_python_remap_boundary_probe
+check_exitcode linuxcnc_python_remap_boundary_probe.run
+check_exitcode linuxcnc_python_remap_runtime_probe.run
 check_exitcode linuxcnc_tp_api_probe
 check_exitcode linuxcnc_tp_api_probe.run
 check_exitcode linuxcnc_kinematics_probe
@@ -381,6 +565,157 @@ grep -Fq "xyzac_trt_switch_mcodes_from_linuxcnc=1" "$FIVEAXIS_REMAP_ASSET_STDOUT
 grep -Fq "xyzbc_trt_switch_mcodes_from_linuxcnc=1" "$FIVEAXIS_REMAP_ASSET_STDOUT"
 grep -Fq "fiveaxis_remap_assets_from_linuxcnc=1" "$FIVEAXIS_REMAP_ASSET_STDOUT"
 
+MILLTURN_USER_M_BOUNDARY_STDOUT="$BUILD_DIR/linuxcnc_millturn_user_m_boundary_probe.run.stdout.log"
+grep -Fq "millturn_ini_open=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "millturn_RS274NGC.USER_M_PATH_ok=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "millturn_RS274NGC.SUBROUTINE_PATH_ok=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "millturn_DISPLAY.PYVCP_ok=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "millturn_HAL.HALUI_ok=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M128_state_mode=mill" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M128_guard_pin=kinstype.is-0" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M128_script_tcl_hal_runtime=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M128_remap_calls_user_m_process=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M428_switchkins_output_pin=motion.analog-out-03" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M428_switchkins_target=0" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M428_work_offset_pocket=P7" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M428_work_offset_words=X-290 Y0 Z-160 A0" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M428_active_g5x=G59.1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M428_calls_M128=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M428_source_transition_from_linuxcnc=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M128_X_AXIS_X.MIN_LIMIT_ok=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M128_X_AXIS_X.MAX_LIMIT_ok=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M128_Z_AXIS_Z.MAX_LIMIT_ok=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M128_source_state_targets_from_linuxcnc=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M129_state_mode=turn" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M129_guard_pin=kinstype.is-1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M129_script_tcl_hal_runtime=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M129_remap_calls_user_m_process=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M429_switchkins_output_pin=motion.analog-out-03" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M429_switchkins_target=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M429_work_offset_pocket=P8" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M429_work_offset_words=X-160 Y0 Z-290 A0" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M429_active_g5x=G59.2" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M429_calls_M129=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M429_source_transition_from_linuxcnc=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M129_X_AXIS_X.MIN_LIMIT_TURN_ok=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M129_Z_AXIS_Z.MAX_LIMIT_TURN_ok=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "M129_source_state_targets_from_linuxcnc=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "millturn_user_m_native_source_state_proof=1" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "millturn_user_m_execution_enabled=0" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+grep -Fq "millturn_user_m_promotion_allowed=0" "$MILLTURN_USER_M_BOUNDARY_STDOUT"
+
+MILLTURN_USER_M_RUNTIME_STDOUT="$BUILD_DIR/linuxcnc_millturn_user_m_runtime_probe.run.stdout.log"
+grep -Fq "millturn_user_m_runtime_requirements=" "$MILLTURN_USER_M_RUNTIME_STDOUT"
+grep -Fq "millturn_user_m_source_proof_ready=1" "$MILLTURN_USER_M_RUNTIME_STDOUT"
+grep -Fq "millturn_user_m_execution_enabled=0" "$MILLTURN_USER_M_RUNTIME_STDOUT"
+grep -Fq "millturn_user_m_promotion_allowed=0" "$MILLTURN_USER_M_RUNTIME_STDOUT"
+if grep -Fq "millturn_user_m_runtime_ready=1" "$MILLTURN_USER_M_RUNTIME_STDOUT"; then
+  grep -Eq "millturn_user_m_runtime_probe_status=(ready_disabled_by_default|runtime_state_probe_passed)" \
+    "$MILLTURN_USER_M_RUNTIME_STDOUT"
+  if grep -Fq "millturn_user_m_runtime_probe_status=runtime_state_probe_passed" "$MILLTURN_USER_M_RUNTIME_STDOUT"; then
+    grep -Fq "millturn_user_m_M128_runtime_state_ok=1" "$MILLTURN_USER_M_RUNTIME_STDOUT"
+    grep -Fq "millturn_user_m_M129_runtime_state_ok=1" "$MILLTURN_USER_M_RUNTIME_STDOUT"
+  fi
+else
+  grep -Fq "millturn_user_m_runtime_ready=0" "$MILLTURN_USER_M_RUNTIME_STDOUT"
+  grep -Fq "millturn_user_m_runtime_probe_status=skipped_missing_host_runtime" \
+    "$MILLTURN_USER_M_RUNTIME_STDOUT"
+fi
+
+TOOL_DB_BOUNDARY_STDOUT="$BUILD_DIR/linuxcnc_tool_db_boundary_probe.run.stdout.log"
+grep -Fq "db_nonran_ini_open=1" "$TOOL_DB_BOUNDARY_STDOUT"
+grep -Fq "db_nonran_EMCIO.RANDOM_TOOLCHANGER_ok=1" "$TOOL_DB_BOUNDARY_STDOUT"
+grep -Fq "db_nonran_EMCIO.DB_PROGRAM_ok=1" "$TOOL_DB_BOUNDARY_STDOUT"
+grep -Fq "db_nonran_tool_table_ignored_with_db_program=1" "$TOOL_DB_BOUNDARY_STDOUT"
+grep -Fq "tool_db_task_db_mode_init=1" "$TOOL_DB_BOUNDARY_STDOUT"
+grep -Fq "tool_db_task_ignores_tool_table_with_db_program=1" "$TOOL_DB_BOUNDARY_STDOUT"
+grep -Fq "tool_db_task_load_unload_notify=1" "$TOOL_DB_BOUNDARY_STDOUT"
+grep -Fq "tool_db_child_process_boundary=1" "$TOOL_DB_BOUNDARY_STDOUT"
+grep -Fq "tool_db_program_executable_check=1" "$TOOL_DB_BOUNDARY_STDOUT"
+grep -Fq "tool_db_v2_1_handshake=1" "$TOOL_DB_BOUNDARY_STDOUT"
+grep -Fq "tool_db_getall_g_until_fini=1" "$TOOL_DB_BOUNDARY_STDOUT"
+grep -Fq "tool_db_notify_l_u_p_protocol=1" "$TOOL_DB_BOUNDARY_STDOUT"
+grep -Fq "tool_db_program_tooldb_module=1" "$TOOL_DB_BOUNDARY_STDOUT"
+grep -Fq "tool_db_program_nonran_callbacks=1" "$TOOL_DB_BOUNDARY_STDOUT"
+grep -Fq "tool_db_program_nonran_state_targets=1" "$TOOL_DB_BOUNDARY_STDOUT"
+grep -Fq "tool_db_program_reload_rules=1" "$TOOL_DB_BOUNDARY_STDOUT"
+grep -Fq "tool_db_native_source_protocol_proof=1" "$TOOL_DB_BOUNDARY_STDOUT"
+grep -Fq "tool_db_execution_enabled=0" "$TOOL_DB_BOUNDARY_STDOUT"
+grep -Fq "tool_db_promotion_allowed=0" "$TOOL_DB_BOUNDARY_STDOUT"
+
+TOOL_DB_RUNTIME_STDOUT="$BUILD_DIR/linuxcnc_tool_db_runtime_probe.run.stdout.log"
+grep -Fq "tool_db_runtime_requirements=" "$TOOL_DB_RUNTIME_STDOUT"
+grep -Fq "tool_db_source_proof_ready=1" "$TOOL_DB_RUNTIME_STDOUT"
+grep -Fq "tool_db_execution_enabled=0" "$TOOL_DB_RUNTIME_STDOUT"
+grep -Fq "tool_db_promotion_allowed=0" "$TOOL_DB_RUNTIME_STDOUT"
+if grep -Fq "tool_db_runtime_ready=1" "$TOOL_DB_RUNTIME_STDOUT"; then
+  grep -Eq "tool_db_runtime_probe_status=(ready_disabled_by_default|runtime_protocol_probe_passed)" \
+    "$TOOL_DB_RUNTIME_STDOUT"
+  if grep -Fq "tool_db_runtime_probe_status=runtime_protocol_probe_passed" "$TOOL_DB_RUNTIME_STDOUT"; then
+    grep -Fq "tool_db_runtime_protocol_probe_ok=1" "$TOOL_DB_RUNTIME_STDOUT"
+    grep -Fq "tool_db_get_all_fini=1" "$TOOL_DB_RUNTIME_STDOUT"
+    grep -Fq "tool_db_put_tool_update_state_ok=1" "$TOOL_DB_RUNTIME_STDOUT"
+    grep -Fq "tool_db_load_spindle_state_ok=1" "$TOOL_DB_RUNTIME_STDOUT"
+    grep -Fq "tool_db_unload_spindle_state_ok=1" "$TOOL_DB_RUNTIME_STDOUT"
+    grep -Fq "tool_db_persistence_state_ok=1" "$TOOL_DB_RUNTIME_STDOUT"
+  fi
+else
+  grep -Fq "tool_db_runtime_ready=0" "$TOOL_DB_RUNTIME_STDOUT"
+  grep -Fq "tool_db_runtime_probe_status=skipped_missing_host_runtime" \
+    "$TOOL_DB_RUNTIME_STDOUT"
+fi
+
+PYTHON_REMAP_BOUNDARY_STDOUT="$BUILD_DIR/linuxcnc_python_remap_boundary_probe.run.stdout.log"
+grep -Fq "python_runtime_pycall_dispatch=1" "$PYTHON_REMAP_BOUNDARY_STDOUT"
+grep -Fq "python_runtime_remap_phases=1" "$PYTHON_REMAP_BOUNDARY_STDOUT"
+grep -Fq "python_runtime_generator_finish=1" "$PYTHON_REMAP_BOUNDARY_STDOUT"
+grep -Fq "python_runtime_callable_lookup=1" "$PYTHON_REMAP_BOUNDARY_STDOUT"
+grep -Fq "python_runtime_execute_runtime=1" "$PYTHON_REMAP_BOUNDARY_STDOUT"
+grep -Fq "python_plugin_initializes_python=1" "$PYTHON_REMAP_BOUNDARY_STDOUT"
+grep -Fq "python_plugin_toplevel_exec_file=1" "$PYTHON_REMAP_BOUNDARY_STDOUT"
+grep -Fq "python_plugin_ini_python_path=1" "$PYTHON_REMAP_BOUNDARY_STDOUT"
+grep -Fq "python_plugin_callable_invoke=1" "$PYTHON_REMAP_BOUNDARY_STDOUT"
+grep -Fq "python_plugin_reload_on_change=1" "$PYTHON_REMAP_BOUNDARY_STDOUT"
+grep -Fq "python_family_axis_laser_inventory=1" "$PYTHON_REMAP_BOUNDARY_STDOUT"
+grep -Fq "python_family_twp_nutating_inventory=1" "$PYTHON_REMAP_BOUNDARY_STDOUT"
+grep -Fq "python_family_axis_remap_cycle_inventory=1" "$PYTHON_REMAP_BOUNDARY_STDOUT"
+grep -Fq "python_family_gmoccapy_stdglue_inventory=1" "$PYTHON_REMAP_BOUNDARY_STDOUT"
+grep -Fq "python_remap_native_source_inventory_proof=1" "$PYTHON_REMAP_BOUNDARY_STDOUT"
+grep -Fq "python_remap_execution_enabled=0" "$PYTHON_REMAP_BOUNDARY_STDOUT"
+grep -Fq "python_remap_promotion_allowed=0" "$PYTHON_REMAP_BOUNDARY_STDOUT"
+
+PYTHON_REMAP_RUNTIME_STDOUT="$BUILD_DIR/linuxcnc_python_remap_runtime_probe.run.stdout.log"
+grep -Fq "python_remap_runtime_fixture_family=axis/remap/stop-lookahead/nc_files" \
+  "$PYTHON_REMAP_RUNTIME_STDOUT"
+grep -Fq "python_remap_runtime_fixture_id=stop_lookahead_python_runtime_lifecycle" \
+  "$PYTHON_REMAP_RUNTIME_STDOUT"
+grep -Fq "python_remap_runtime_fixture_scope=no_python_callables_no_ngc_only_subpaths" \
+  "$PYTHON_REMAP_RUNTIME_STDOUT"
+grep -Fq "python_remap_runtime_requirements=" "$PYTHON_REMAP_RUNTIME_STDOUT"
+grep -Fq "python_remap_runtime_modules=axis/remap/stop-lookahead/python/remap.py,axis/remap/stop-lookahead/python/toplevel.py" \
+  "$PYTHON_REMAP_RUNTIME_STDOUT"
+grep -Fq "python_remap_source_proof_ready=1" "$PYTHON_REMAP_RUNTIME_STDOUT"
+grep -Fq "python_remap_execution_enabled=0" "$PYTHON_REMAP_RUNTIME_STDOUT"
+grep -Fq "python_remap_promotion_allowed=0" "$PYTHON_REMAP_RUNTIME_STDOUT"
+if grep -Fq "python_remap_runtime_ready=1" "$PYTHON_REMAP_RUNTIME_STDOUT"; then
+  grep -Eq "python_remap_runtime_probe_status=(ready_disabled_by_default|runtime_lifecycle_probe_passed)" \
+    "$PYTHON_REMAP_RUNTIME_STDOUT"
+  if grep -Fq "python_remap_runtime_probe_status=runtime_lifecycle_probe_passed" "$PYTHON_REMAP_RUNTIME_STDOUT"; then
+    grep -Fq "python_remap_runtime_lifecycle_probe_ok=1" "$PYTHON_REMAP_RUNTIME_STDOUT"
+    grep -Fq "python_remap_lifecycle_interpreter_sentinel_ok=1" "$PYTHON_REMAP_RUNTIME_STDOUT"
+    grep -Fq "python_remap_lifecycle_toplevel_imported=1" "$PYTHON_REMAP_RUNTIME_STDOUT"
+    grep -Fq "python_remap_lifecycle_remap_imported=1" "$PYTHON_REMAP_RUNTIME_STDOUT"
+    grep -Fq "python_remap_lifecycle_callable_lookup_ok=1" "$PYTHON_REMAP_RUNTIME_STDOUT"
+    grep -Fq "python_remap_lifecycle_generator_returned=1" "$PYTHON_REMAP_RUNTIME_STDOUT"
+    grep -Fq "python_remap_lifecycle_generator_first_yield=2" "$PYTHON_REMAP_RUNTIME_STDOUT"
+    grep -Fq "python_remap_lifecycle_generator_finish_ok=1" "$PYTHON_REMAP_RUNTIME_STDOUT"
+  fi
+else
+  grep -Fq "python_remap_runtime_ready=0" "$PYTHON_REMAP_RUNTIME_STDOUT"
+  grep -Fq "python_remap_runtime_probe_status=skipped_missing_host_runtime" \
+    "$PYTHON_REMAP_RUNTIME_STDOUT"
+fi
+
 REMAP_PARSE_STDOUT="$BUILD_DIR/linuxcnc_remap_parse_harness.run.stdout.log"
 
 check_remap_descriptor() {
diff --git a/wasm-port/tests/native/verify_sim_configs.sh b/wasm-port/tests/native/verify_sim_configs.sh
index 210a687..de85f6d 100755
--- a/wasm-port/tests/native/verify_sim_configs.sh
+++ b/wasm-port/tests/native/verify_sim_configs.sh
@@ -22,7 +22,8 @@ while [[ $# -gt 0 ]]; do
 Usage: $0 [--only PATH_SUBSTRING]
 
 Runs LinuxCNC configs/sim .ngc programs through LinuxCNC's rs274 standalone
-entry point and writes logs plus summary.tsv under:
+entry point and writes logs plus summary.tsv, class-summary.tsv, and
+path-matrix.tsv under:
   $BUILD_DIR
 EOF
       exit 0
@@ -44,6 +45,10 @@ if [[ ! -d "$SIM_DIR" ]]; then
   exit 1
 fi
 
+mkdir -p "$BUILD_DIR"
+exec 9>"$BUILD_DIR/inventory.lock"
+flock 9
+
 "$ROOT_DIR/tools/build_native_probes.sh"
 
 export LD_LIBRARY_PATH="$LINUXCNC_DIR/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
@@ -52,6 +57,8 @@ export PYTHONPATH="$LINUXCNC_DIR/lib/python${PYTHONPATH:+:$PYTHONPATH}"
 mkdir -p "$BUILD_DIR"/{logs,out,wrapped,params}
 : > "$BUILD_DIR/skipped.tsv"
 SUMMARY_FILE="$BUILD_DIR/summary.tsv"
+CLASS_SUMMARY_FILE="$BUILD_DIR/class-summary.tsv"
+PATH_MATRIX_FILE="$BUILD_DIR/path-matrix.tsv"
 printf 'path\tclass\tstatus\texpected_failure\texit_code\tseconds\tini\ttbl\toutput_lines\tstderr_summary\n' > "$SUMMARY_FILE"
 
 relpath() {
@@ -392,9 +399,69 @@ while IFS= read -r ngc; do
     "$stderr_summary" >> "$SUMMARY_FILE"
 done < <(find "$SIM_DIR" -type f -name '*.ngc' | sort)
 
+{
+  printf 'class\tstatus\texpected_failure\tcount\n'
+  awk -F '\t' '
+    NR > 1 {
+      class[$2] += 1
+      status[$2 "\t" $3] += 1
+      if ($4 != "") {
+        expected[$2 "\t" $4] += 1
+      }
+    }
+    END {
+      for (key in class) {
+        print key "\tALL\t-\t" class[key]
+      }
+      for (key in status) {
+        split(key, parts, "\t")
+        print parts[1] "\t" parts[2] "\t-\t" status[key]
+      }
+      for (key in expected) {
+        split(key, parts, "\t")
+        print parts[1] "\tEXPECTED_FAIL\t" parts[2] "\t" expected[key]
+      }
+    }
+  ' "$SUMMARY_FILE" | sort
+} > "$CLASS_SUMMARY_FILE"
+
+awk -F '\t' '
+  BEGIN {
+    OFS = "\t"
+    print "path", "class", "status", "expected_failure", "ini", "tbl", "runtime_family", "blocked"
+  }
+  NR > 1 {
+    runtime_family = $1
+    sub("/[^/]+$", "", runtime_family)
+    blocked = ""
+    if ($1 ~ /^axis\/db_demo\//) {
+      blocked = "L4-TOOL-DB"
+    } else if ($1 ~ /^axis\/vismach\/millturn\// && $2 == "main") {
+      blocked = "L4-USER-M-PROCESS"
+    } else if ($4 == "upstream-demo-missing-motion-gcode") {
+      blocked = "UPSTREAM-DEMO"
+    } else if ($1 ~ /^axis\/remap\// && $2 == "main") {
+      blocked = "L4-PYTHON-REMAP"
+    } else if ($1 ~ /^axis\/vismach\/VMC_toolchange\// && $2 == "main") {
+      blocked = "L4-PYTHON-REMAP"
+    } else if ($1 ~ /^gmoccapy\//) {
+      blocked = "L4-PYTHON-REMAP"
+    } else if ($1 ~ /^axis\/laser\//) {
+      blocked = "L4-PYTHON-REMAP"
+    } else if ($1 ~ /^axis\/vismach\/5axis\/table-rotary_spindle-rotary-nutating\/demos\//) {
+      blocked = "L4-PYTHON-REMAP"
+    } else if ($2 == "remap_subroutine") {
+      blocked = "ASSET-ONLY"
+    }
+    print $1, $2, $3, ($4 == "" ? "-" : $4), $7, $8, runtime_family, (blocked == "" ? "-" : blocked)
+  }
+' "$SUMMARY_FILE" > "$PATH_MATRIX_FILE"
+
 {
   printf 'sim config harness summary\n'
   printf 'summary: %s\n' "$SUMMARY_FILE"
+  printf 'class_summary: %s\n' "$CLASS_SUMMARY_FILE"
+  printf 'path_matrix: %s\n' "$PATH_MATRIX_FILE"
   printf 'total: %s\n' "$total"
   printf 'pass: %s\n' "$pass"
   printf 'fail: %s\n' "$fail"
diff --git a/wasm-port/tests/wasm/node/verify_sim_configs_inventory_wasm.mjs b/wasm-port/tests/wasm/node/verify_sim_configs_inventory_wasm.mjs
new file mode 100644
index 0000000..7296349
--- /dev/null
+++ b/wasm-port/tests/wasm/node/verify_sim_configs_inventory_wasm.mjs
@@ -0,0 +1,8648 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { basename, dirname, posix, resolve } from "node:path";
+import assert from "node:assert/strict";
+
+import {
+  analyzeIniRuntimeBoundaries,
+  createLinuxCncInterpSdk,
+  planSimConfigStaging,
+} from "../../../runtime/sdk/src/index.js";
+
+function parseTsv(text, expectedHeaders = null) {
+  const [headerLine, ...rows] = text.trim().split("\n");
+  const headers = headerLine.split("\t");
+  if (expectedHeaders) {
+    assert.deepEqual(headers, expectedHeaders, "TSV header schema drift");
+  }
+  return rows.filter(Boolean).map((row) => {
+    const values = row.split("\t");
+    return Object.fromEntries(headers.map((header, index) => [header, values[index] ?? ""]));
+  });
+}
+
+function verifyExpectedOutput(fixtureName, output, expectedText) {
+  const expectedLines = expectedText.split("\n").filter(Boolean);
+
+  for (const expectedLine of expectedLines) {
+    if (expectedLine.startsWith("absent=")) {
+      const forbidden = expectedLine.slice("absent=".length);
+      assert.equal(
+        output.includes(forbidden),
+        false,
+        `${fixtureName}: unexpected ${forbidden}`,
+      );
+      continue;
+    }
+
+    assert.equal(
+      output.includes(expectedLine),
+      true,
+      `${fixtureName}: ${expectedLine}`,
+    );
+  }
+}
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const rootDir = resolve(__dirname, "../../..");
+const workspaceRoot = resolve(rootDir, "..");
+const wasmPath = resolve(rootDir, "build/wasm/core/linuxcnc_interp.wasm");
+const vendorRoot = resolve(rootDir, "vendor/linuxcnc");
+const linuxCncSimRoot = resolve(workspaceRoot, "linuxcnc/configs/sim");
+const manifestText = readFileSync(resolve(rootDir, "tools/source-manifest.txt"), "utf8");
+const nativeSummaryPath = resolve(rootDir, "build/native/sim-configs/summary.tsv");
+const nativeClassSummaryPath = resolve(rootDir, "build/native/sim-configs/class-summary.tsv");
+const nativePathMatrixPath = resolve(rootDir, "build/native/sim-configs/path-matrix.tsv");
+const nativeSourceProofSummaryPath = resolve(rootDir, "build/native/native-source-proof-summary.tsv");
+const nativeRuntimeProbeSummarySourcePath = resolve(rootDir, "build/native/native-runtime-probe-summary.tsv");
+const trackedMatrixPath = resolve(rootDir, "docs/sim-configs-coverage-matrix.md");
+const fullProcessBoundaryDesignPath = resolve(rootDir, "docs/full-process-boundary-design.md");
+const buildDir = resolve(rootDir, "build/wasm/sim-configs-inventory");
+const summaryPath = resolve(buildDir, "summary.tsv");
+const skipSummaryPath = resolve(buildDir, "skip-summary.tsv");
+const boundarySummaryPath = resolve(buildDir, "boundary-summary.tsv");
+const iniBoundarySummaryPath = resolve(buildDir, "ini-boundary-summary.tsv");
+const blockedDependencySummaryPath = resolve(buildDir, "blocked-dependency-summary.tsv");
+const fullProcessBoundarySummaryPath = resolve(buildDir, "full-process-boundary-summary.tsv");
+const userMProcessBoundarySummaryPath = resolve(buildDir, "user-m-process-boundary-summary.tsv");
+const userMProcessStateTargetsPath = resolve(buildDir, "user-m-process-state-targets.tsv");
+const userMProcessTransitionPlanPath = resolve(buildDir, "user-m-process-transition-plan.tsv");
+const userMProcessNativeStateAlignmentPath = resolve(buildDir, "user-m-process-native-state-alignment.tsv");
+const userMProcessNativeTransitionAlignmentPath = resolve(buildDir, "user-m-process-native-transition-alignment.tsv");
+const userMProcessNativeRuntimeStatePlanPath = resolve(buildDir, "user-m-process-native-runtime-state-plan.tsv");
+const userMProcessNativeRuntimeReadinessPath = resolve(buildDir, "user-m-process-native-runtime-readiness.tsv");
+const userMProcessNativeRuntimeProbeGatePath = resolve(buildDir, "user-m-process-native-runtime-probe-gate.tsv");
+const toolDbProcessBoundarySummaryPath = resolve(buildDir, "tool-db-process-boundary-summary.tsv");
+const toolDbProcessProtocolGatesPath = resolve(buildDir, "tool-db-process-protocol-gates.tsv");
+const toolDbProcessTransactionPlanPath = resolve(buildDir, "tool-db-process-transaction-plan.tsv");
+const toolDbProcessNativeProtocolAlignmentPath = resolve(buildDir, "tool-db-process-native-protocol-alignment.tsv");
+const toolDbProcessNativeRuntimeReadinessPath = resolve(buildDir, "tool-db-process-native-runtime-readiness.tsv");
+const pythonRemapBoundarySummaryPath = resolve(buildDir, "python-remap-boundary-summary.tsv");
+const pythonRemapRuntimeGatesPath = resolve(buildDir, "python-remap-runtime-gates.tsv");
+const pythonRemapNativeRuntimeAlignmentPath = resolve(buildDir, "python-remap-native-runtime-alignment.tsv");
+const pythonRemapNativeRuntimeReadinessPath = resolve(buildDir, "python-remap-native-runtime-readiness.tsv");
+const pythonRemapNativeRuntimeStatePlanPath = resolve(buildDir, "python-remap-native-runtime-state-plan.tsv");
+const pythonRemapNativeRuntimeFixturePlanPath = resolve(buildDir, "python-remap-native-runtime-fixture-plan.tsv");
+const pythonRemapFamilySummaryPath = resolve(buildDir, "python-remap-family-summary.tsv");
+const pythonRemapRuntimeContractPath = resolve(buildDir, "python-remap-runtime-contract.tsv");
+const runtimeBoundaryContractSummaryPath = resolve(buildDir, "runtime-boundary-contract-summary.tsv");
+const boundaryPhaseCompletionSummaryPath = resolve(buildDir, "boundary-phase-completion-summary.tsv");
+const nextBoundaryWorklistPath = resolve(buildDir, "next-boundary-worklist.tsv");
+const boundaryProofGatesPath = resolve(buildDir, "boundary-proof-gates.tsv");
+const nativeProofAlignmentSummaryPath = resolve(buildDir, "native-proof-alignment-summary.tsv");
+const nativeRuntimeProbeSummaryPath = resolve(buildDir, "native-runtime-probe-summary.tsv");
+const runtimeBoundaryNativeAlignmentSummaryPath = resolve(buildDir, "runtime-boundary-native-alignment-summary.tsv");
+const blockedRuntimePromotionLockPath = resolve(buildDir, "blocked-runtime-promotion-lock.tsv");
+const nextBoundaryRecommendationsPath = resolve(buildDir, "next-boundary-recommendations.tsv");
+
+mkdirSync(buildDir, { recursive: true });
+
+const interp = await createLinuxCncInterpSdk({
+  wasmBinary: readFileSync(wasmPath),
+  print() {},
+  printErr(message) {
+    console.error(message);
+  },
+});
+
+function simMachine(machineRel, iniFile, programFile, nativeToolTableRel) {
+  const iniText = readFileSync(
+    resolve(vendorRoot, `configs/sim/${machineRel}/${iniFile}`),
+    "utf8",
+  );
+  const plan = planSimConfigStaging({
+    manifestText,
+    machineRel,
+    iniFile,
+    iniText,
+    programFile,
+    wasmDir: `/work/sim-inventory/${machineRel}`,
+  });
+  const machine = {
+    ...plan,
+    files: plan.files.map((file) => ({
+      path: file.path,
+      text: readFileSync(resolve(vendorRoot, file.sourceRel), "utf8"),
+      executable:
+        file.executable || (statSync(resolve(vendorRoot, file.sourceRel)).mode & 0o111) !== 0,
+    })),
+  };
+  return withNativeToolTableFallback(machine, iniText, nativeToolTableRel);
+}
+
+function firstIniValue(iniText, section, key) {
+  let activeSection = "";
+  for (const rawLine of iniText.split("\n")) {
+    const sectionMatch = rawLine.match(/^\s*\[([^\]]+)\]/);
+    if (sectionMatch) {
+      activeSection = sectionMatch[1].trim().toUpperCase();
+      continue;
+    }
+
+    if (activeSection !== section.toUpperCase()) {
+      continue;
+    }
+
+    const line = rawLine.replace(/[;#].*$/, "");
+    const equals = line.indexOf("=");
+    if (equals === -1) {
+      continue;
+    }
+    const name = line.slice(0, equals).trim().toUpperCase();
+    if (name === key.toUpperCase()) {
+      return line.slice(equals + 1).trim();
+    }
+  }
+  return "";
+}
+
+function withNativeToolTableFallback(machine, iniText, nativeToolTableRel) {
+  const toolTable = firstIniValue(iniText, "EMCIO", "TOOL_TABLE");
+  if (!toolTable || toolTable.startsWith("/") || !nativeToolTableRel) {
+    return machine;
+  }
+
+  const targetPath = `${machine.wasmDir}/${posix.normalize(toolTable)}`;
+  if (machine.files.some((file) => file.path === targetPath)) {
+    return machine;
+  }
+
+  const sourceRel = `configs/sim/${nativeToolTableRel}`;
+  if (!vendoredConfigPathExists(sourceRel)) {
+    return machine;
+  }
+
+  return {
+    ...machine,
+    files: [
+      ...machine.files,
+      {
+        path: targetPath,
+        text: readFileSync(resolve(vendorRoot, sourceRel), "utf8"),
+        executable: false,
+      },
+    ],
+  };
+}
+
+function vendoredConfigPathExists(relPath) {
+  try {
+    statSync(resolve(vendorRoot, relPath));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function sortedPaths(records) {
+  return records.map((record) => record.path).sort();
+}
+
+function verifyUniquePaths(label, records) {
+  const counts = new Map();
+  for (const record of records) {
+    counts.set(record.path, (counts.get(record.path) ?? 0) + 1);
+  }
+  const duplicates = [...counts.entries()]
+    .filter(([, count]) => count > 1)
+    .map(([path, count]) => `${path}:${count}`);
+  assert.deepEqual(duplicates, [], `${label}: duplicate paths are not allowed`);
+}
+
+function parseTrackedMatrix(markdownText) {
+  return markdownText
+    .split("\n")
+    .map((line) => {
+      const match = line.match(
+        /^\| `([^`]+\.ngc)` \| `([^`]+)` \| `([^`]+)` \| `([^`]+)` \| `([^`]+)` \| `([^`]+)` \| `([^`]+)` \| `([^`]+)` \| `([^`]+)` \| (.+) \|$/,
+      );
+      if (!match) {
+        return null;
+      }
+      return {
+        path: match[1],
+        family: match[2],
+        class: match[3],
+        nativeStatus: match[4],
+        expectedFailure: match[5],
+        layer3: match[6],
+        layer4Node: match[7],
+        layer4Browser: match[8],
+        blocked: match[9],
+        notes: match[10].trim(),
+      };
+    })
+    .filter(Boolean);
+}
+
+function parseTrackedSummaryTable(markdownText, sectionTitle, keyName) {
+  const lines = markdownText.split("\n");
+  const sectionIndex = lines.findIndex((line) => line.trim() === `## ${sectionTitle}`);
+  assert.notEqual(sectionIndex, -1, `tracked matrix missing ${sectionTitle}`);
+  const rows = [];
+
+  for (let index = sectionIndex + 1; index < lines.length; index += 1) {
+    const line = lines[index].trim();
+    if (line.startsWith("## ") && rows.length > 0) {
+      break;
+    }
+    const match = line.match(/^\| `([^`]+)` \| `([0-9]+)` \|$/);
+    if (match) {
+      rows.push({ [keyName]: match[1], count: match[2] });
+    }
+  }
+
+  assert.notEqual(rows.length, 0, `tracked matrix ${sectionTitle} is empty`);
+  return rows;
+}
+
+function numberFromTrackedBaseline(markdownText, pattern, label) {
+  const match = markdownText.match(pattern);
+  assert.ok(match, `tracked matrix baseline missing ${label}`);
+  return Number(match[1]);
+}
+
+function verifySamePathSet(label, expectedPaths, actualPaths) {
+  assert.deepEqual(
+    actualPaths,
+    expectedPaths,
+    `${label}: path set must match native summary.tsv`,
+  );
+}
+
+function verifyTrackedMatrixFields(trackedRecords, pathMatrixByPath) {
+  const trackedByPath = new Map(trackedRecords.map((record) => [record.path, record]));
+
+  for (const [path, generated] of pathMatrixByPath) {
+    const tracked = trackedByPath.get(path);
+    assert.ok(tracked, `tracked matrix missing generated path: ${path}`);
+    assert.ok(
+      generated.runtime_family === tracked.family ||
+        generated.runtime_family.startsWith(`${tracked.family}/`),
+      `${path}: tracked family ${tracked.family} does not cover runtime family ${generated.runtime_family}`,
+    );
+    assert.equal(tracked.class, generated.class, `${path}: tracked class drift`);
+    assert.equal(tracked.nativeStatus, generated.status, `${path}: tracked native status drift`);
+    assert.equal(
+      tracked.expectedFailure,
+      generated.expected_failure,
+      `${path}: tracked expected failure drift`,
+    );
+    assert.equal(tracked.blocked, generated.blocked, `${path}: tracked blocked kind drift`);
+  }
+}
+
+function verifyPathMatrixFields(nativeRecords, pathMatrixByPath) {
+  for (const nativeRecord of nativeRecords) {
+    const generated = pathMatrixByPath.get(nativeRecord.path);
+    assert.ok(generated, `path matrix missing native path ${nativeRecord.path}`);
+    assert.equal(generated.class, nativeRecord.class, `${nativeRecord.path}: class drift`);
+    assert.equal(generated.status, nativeRecord.status, `${nativeRecord.path}: status drift`);
+    assert.equal(
+      generated.expected_failure,
+      nativeRecord.expected_failure || "-",
+      `${nativeRecord.path}: expected failure drift`,
+    );
+    assert.equal(generated.ini, nativeRecord.ini, `${nativeRecord.path}: INI drift`);
+    assert.equal(generated.tbl, nativeRecord.tbl, `${nativeRecord.path}: tool table drift`);
+    assert.equal(
+      generated.runtime_family,
+      posix.dirname(nativeRecord.path),
+      `${nativeRecord.path}: runtime family drift`,
+    );
+  }
+}
+
+function verifyClassesAndStatuses(records) {
+  const allowedClasses = new Set(["main", "macro_load", "remap_subroutine"]);
+  const allowedStatuses = new Set(["PASS", "FAIL", "TIMEOUT"]);
+
+  for (const record of records) {
+    const status = record.status ?? record.nativeStatus;
+    assert.ok(allowedClasses.has(record.class), `${record.path}: unknown class ${record.class}`);
+    assert.ok(allowedStatuses.has(status), `${record.path}: unknown native status ${status}`);
+  }
+}
+
+function verifyBlockedKinds(records) {
+  const allowedBlockedKinds = new Set([
+    "-",
+    "ASSET-ONLY",
+    "L4-TOOL-DB",
+    "L4-USER-M-PROCESS",
+    "L4-PYTHON-REMAP",
+    "UPSTREAM-DEMO",
+  ]);
+  for (const record of records) {
+    assert.ok(
+      allowedBlockedKinds.has(record.blocked),
+      `${record.path}: unknown blocked kind ${record.blocked}`,
+    );
+  }
+}
+
+function verifyLayerMarkers(records) {
+  const allowedLayer3Markers = new Set([
+    "-",
+    "5AX-EXEC",
+    "SIM-BRIDGE,5AX-EXEC",
+    "SIM-EOFF",
+    "SIM-FOAM",
+    "SIM-XYZC",
+  ]);
+  const allowedLayer4NodeMarkers = new Set(["-", "INV", "N/A", "REP"]);
+  const allowedLayer4BrowserMarkers = new Set(["-", "N/A", "REP"]);
+
+  for (const record of records) {
+    assert.ok(
+      allowedLayer3Markers.has(record.layer3),
+      `${record.path}: unknown Layer 3 marker ${record.layer3}`,
+    );
+    assert.ok(
+      allowedLayer4NodeMarkers.has(record.layer4Node),
+      `${record.path}: unknown Layer 4 Node marker ${record.layer4Node}`,
+    );
+    assert.ok(
+      allowedLayer4BrowserMarkers.has(record.layer4Browser),
+      `${record.path}: unknown Layer 4 Browser marker ${record.layer4Browser}`,
+    );
+    if (record.layer4Browser === "REP") {
+      assert.equal(record.layer4Node, "REP", `${record.path}: browser REP must also be Node REP`);
+    }
+    if (record.layer4Node === "N/A" || record.layer4Browser === "N/A") {
+      assert.equal(record.class, "remap_subroutine", `${record.path}: N/A marker requires subroutine class`);
+      assert.equal(record.blocked, "ASSET-ONLY", `${record.path}: N/A marker requires ASSET-ONLY`);
+    }
+    if (record.layer4Node === "REP" || record.layer4Node === "INV" || record.layer4Browser === "REP") {
+      assert.equal(record.blocked, "-", `${record.path}: covered row must not be blocked`);
+    }
+  }
+}
+
+function verifyTrackedMatrixNotes(records) {
+  for (const record of records) {
+    assert.notEqual(record.notes, "", `${record.path}: tracked matrix note is required`);
+  }
+}
+
+function verifyTrackedSummaryTables(trackedRecords, classSummaryRows, familySummaryRows) {
+  const classCounts = new Map();
+  const familyCounts = new Map();
+
+  for (const record of trackedRecords) {
+    classCounts.set(record.class, (classCounts.get(record.class) ?? 0) + 1);
+    familyCounts.set(record.family, (familyCounts.get(record.family) ?? 0) + 1);
+  }
+
+  assert.deepEqual(
+    classSummaryRows.map((row) => `${row.class}\t${row.count}`).sort(),
+    [...classCounts.entries()].map(([className, count]) => `${className}\t${count}`).sort(),
+    "tracked matrix class summary must match program matrix",
+  );
+  assert.deepEqual(
+    familySummaryRows.map((row) => `${row.family}\t${row.count}`).sort(),
+    [...familyCounts.entries()].map(([family, count]) => `${family}\t${count}`).sort(),
+    "tracked matrix family summary must match program matrix",
+  );
+}
+
+function verifyTrackedBaselineText(markdownText, nativeRecords, inventory, skipReasonCounts) {
+  const nativePass = nativeRecords.filter((record) => record.status === "PASS").length;
+  const nativeExpectedFail = nativeRecords.filter((record) => record.expected_failure).length;
+  const nativeUnexpectedFail = nativeRecords.filter(
+    (record) => record.status !== "PASS" && !record.expected_failure,
+  ).length;
+
+  assert.equal(
+    numberFromTrackedBaseline(markdownText, /- Total records: `([0-9]+)`/, "total records"),
+    nativeRecords.length,
+    "tracked matrix total records drift",
+  );
+  assert.equal(
+    numberFromTrackedBaseline(markdownText, /Native result: `pass ([0-9]+)`/, "native pass"),
+    nativePass,
+    "tracked matrix native pass drift",
+  );
+  assert.equal(
+    numberFromTrackedBaseline(markdownText, /`expected_fail ([0-9]+)`/, "native expected_fail"),
+    nativeExpectedFail,
+    "tracked matrix native expected_fail drift",
+  );
+  assert.equal(
+    numberFromTrackedBaseline(markdownText, /`unexpected_fail ([0-9]+)`/, "native unexpected_fail"),
+    nativeUnexpectedFail,
+    "tracked matrix native unexpected_fail drift",
+  );
+  assert.equal(
+    numberFromTrackedBaseline(markdownText, /Current Node inventory: `executed ([0-9]+)`/, "Node executed"),
+    inventory.executed,
+    "tracked matrix Node executed drift",
+  );
+  assert.equal(
+    numberFromTrackedBaseline(markdownText, /`passed ([0-9]+)`/, "Node passed"),
+    inventory.passed,
+    "tracked matrix Node passed drift",
+  );
+  assert.equal(
+    numberFromTrackedBaseline(markdownText, /`skipped ([0-9]+)`/, "Node skipped"),
+    inventory.skipped,
+    "tracked matrix Node skipped drift",
+  );
+  assert.equal(
+    numberFromTrackedBaseline(markdownText, /`unexpected_fail ([0-9]+)`/, "Node unexpected_fail"),
+    inventory.unexpectedFail,
+    "tracked matrix Node unexpected_fail drift",
+  );
+
+  for (const [reason, count] of skipReasonCounts) {
+    const escapedReason = reason.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    assert.equal(
+      numberFromTrackedBaseline(
+        markdownText,
+        new RegExp(`${escapedReason} ([0-9]+)`),
+        `Node skip ${reason}`,
+      ),
+      count,
+      `tracked matrix Node skip count drift for ${reason}`,
+    );
+  }
+}
+
+function verifyRequiredClassRepresentatives(records) {
+  const byPath = new Map(records.map((record) => [record.path, record]));
+  const requiredBrowserReps = [
+    "axis/external_offsets/circles.ngc",
+    "axis/foam/foam.ngc",
+    "axis/geometry/xyzc.ngc",
+    "axis/gladevcp/probe.ngc",
+    "axis/vismach/5axis/bridgemill/5axisgui.ngc",
+    "axis/vismach/5axis/table-dual-rotary/demos/xyzab-tdr-demo.ngc",
+    "axis/vismach/5axis/table-rotary-tilting/demos/xyzac_switchkins.ngc",
+    "axis/vismach/melfa-sim/example.ngc",
+    "axis/vismach/puma/puma_cube.ngc",
+    "woodpecker/on_abort.ngc",
+  ];
+  const requiredPythonRemapBlocked = [
+    "axis/laser/raster_test.ngc",
+    "axis/vismach/5axis/table-rotary_spindle-rotary-nutating/demos/circular_pocket.ngc",
+    "gmoccapy/macros/on_abort.ngc",
+  ];
+  const requiredFullProcessBlocked = new Map([
+    ["axis/db_demo/base.ngc", "L4-TOOL-DB"],
+    ["axis/vismach/millturn/example.ngc", "L4-USER-M-PROCESS"],
+  ]);
+
+  for (const path of requiredBrowserReps) {
+    const record = byPath.get(path);
+    assert.ok(record, `${path}: required browser representative missing`);
+    assert.equal(record.layer4Node, "REP", `${path}: required Node representative marker`);
+    assert.equal(record.layer4Browser, "REP", `${path}: required browser representative marker`);
+    assert.equal(record.blocked, "-", `${path}: browser representative must not be blocked`);
+  }
+
+  for (const path of requiredPythonRemapBlocked) {
+    const record = byPath.get(path);
+    assert.ok(record, `${path}: required Python-remap blocked row missing`);
+    assert.equal(record.layer4Node, "-", `${path}: Python-remap blocked row is not Node REP`);
+    assert.equal(record.layer4Browser, "-", `${path}: Python-remap blocked row is not browser REP`);
+    assert.equal(record.blocked, "L4-PYTHON-REMAP", `${path}: Python-remap blocked kind drift`);
+  }
+
+  for (const [path, blocked] of requiredFullProcessBlocked) {
+    const record = byPath.get(path);
+    assert.ok(record, `${path}: required full-process blocked row missing`);
+    assert.equal(record.layer4Node, "-", `${path}: full-process blocked row is not Node REP`);
+    assert.equal(record.layer4Browser, "-", `${path}: full-process blocked row is not browser REP`);
+    assert.equal(record.blocked, blocked, `${path}: full-process blocked kind drift`);
+  }
+}
+
+function verifyNativeExpectedFailures(records) {
+  const allowedExpectedFailures = new Set([
+    "ini-axis-mask-UV",
+    "ini-axis-mask-W",
+    "user-m-code-M110",
+    "user-m-code-M111",
+    "upstream-demo-missing-motion-gcode",
+  ]);
+
+  for (const record of records) {
+    if (record.status === "PASS") {
+      assert.equal(record.expected_failure, "", `${record.path}: PASS row has expected failure`);
+      continue;
+    }
+
+    assert.ok(
+      allowedExpectedFailures.has(record.expected_failure),
+      `${record.path}: unknown native expected failure ${record.expected_failure}`,
+    );
+  }
+}
+
+function verifyMatrixExpectedFailures(records) {
+  const allowedExpectedFailures = new Set([
+    "-",
+    "ini-axis-mask-UV",
+    "ini-axis-mask-W",
+    "user-m-code-M110",
+    "user-m-code-M111",
+    "upstream-demo-missing-motion-gcode",
+  ]);
+
+  for (const record of records) {
+    const status = record.status ?? record.nativeStatus;
+    const expectedFailure = record.expected_failure ?? record.expectedFailure;
+    assert.ok(
+      allowedExpectedFailures.has(expectedFailure),
+      `${record.path}: unknown matrix expected failure ${expectedFailure}`,
+    );
+    if (status === "PASS") {
+      assert.equal(expectedFailure, "-", `${record.path}: PASS row has expected failure`);
+    } else {
+      assert.notEqual(expectedFailure, "-", `${record.path}: non-PASS row lacks expected failure`);
+    }
+  }
+}
+
+function classSummaryRowsFromNativeRecords(records) {
+  const counts = new Map();
+
+  function increment(className, status, expectedFailure) {
+    const key = [className, status, expectedFailure].join("\t");
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+
+  for (const record of records) {
+    increment(record.class, "ALL", "-");
+    increment(record.class, record.status, "-");
+    if (record.expected_failure) {
+      increment(record.class, "EXPECTED_FAIL", record.expected_failure);
+    }
+  }
+
+  return [...counts.entries()]
+    .map(([key, count]) => `${key}\t${count}`)
+    .sort();
+}
+
+function classSummaryRowsFromGenerated(records) {
+  return records
+    .map((record) =>
+      [
+        record.class,
+        record.status,
+        record.expected_failure || "-",
+        record.count,
+      ].join("\t"),
+    )
+    .sort();
+}
+
+function verifyClassSummaryRows(records) {
+  const allowedClasses = new Set(["main", "macro_load", "remap_subroutine"]);
+  const allowedStatuses = new Set(["ALL", "EXPECTED_FAIL", "PASS", "FAIL", "TIMEOUT"]);
+  const allowedExpectedFailures = new Set([
+    "-",
+    "ini-axis-mask-UV",
+    "ini-axis-mask-W",
+    "user-m-code-M110",
+    "user-m-code-M111",
+    "upstream-demo-missing-motion-gcode",
+  ]);
+
+  for (const record of records) {
+    assert.ok(allowedClasses.has(record.class), `${record.class}: unknown class-summary class`);
+    assert.ok(
+      allowedStatuses.has(record.status),
+      `${record.class}: unknown class-summary status ${record.status}`,
+    );
+    assert.ok(
+      allowedExpectedFailures.has(record.expected_failure),
+      `${record.class}: unknown class-summary expected failure ${record.expected_failure}`,
+    );
+    assert.ok(
+      /^[1-9][0-9]*$/.test(record.count),
+      `${record.class}/${record.status}: invalid class-summary count ${record.count}`,
+    );
+
+    if (record.status === "EXPECTED_FAIL") {
+      assert.notEqual(
+        record.expected_failure,
+        "-",
+        `${record.class}: EXPECTED_FAIL row lacks expected failure`,
+      );
+    } else {
+      assert.equal(
+        record.expected_failure,
+        "-",
+        `${record.class}/${record.status}: non-EXPECTED_FAIL row has expected failure`,
+      );
+    }
+  }
+}
+
+function blockedKind(record, pathMatrixByPath) {
+  const generatedBlocked = pathMatrixByPath.get(record.path)?.blocked ?? "-";
+  if (generatedBlocked !== "-") {
+    return generatedBlocked;
+  }
+  if (record.class !== "main") {
+    return "NON_MAIN_CLASS";
+  }
+  return "";
+}
+
+function missingVendoredConfig(record) {
+  const iniRel = `configs/sim/${record.ini}`;
+  if (!vendoredConfigPathExists(iniRel)) {
+    return iniRel;
+  }
+  return "";
+}
+
+function executionTextsForBoundary(record) {
+  const rels = [record.path];
+  if (record.path === "axis/external_offsets/opa_demo.ngc") {
+    rels.push("axis/external_offsets/circles.ngc");
+  }
+  if (record.path === "axis/vismach/millturn/example.ngc") {
+    rels.push(
+      "axis/vismach/millturn/remap_subs/428remap.ngc",
+      "axis/vismach/millturn/remap_subs/429remap.ngc",
+    );
+  }
+  return rels
+    .filter((rel) => vendoredConfigPathExists(`configs/sim/${rel}`))
+    .map((rel) => readFileSync(resolve(vendorRoot, `configs/sim/${rel}`), "utf8"));
+}
+
+function runtimeBoundaryForRecord(record) {
+  const missingVendoredRel = missingVendoredConfig(record);
+  if (missingVendoredRel) {
+    return {
+      available: false,
+      missingVendoredRel,
+      boundary: null,
+    };
+  }
+
+  const machineRel = posix.dirname(record.ini);
+  const iniFile = basename(record.ini);
+  const iniRel = `configs/sim/${machineRel}/${iniFile}`;
+  if (!vendoredConfigPathExists(iniRel)) {
+    return {
+      available: false,
+      missingVendoredRel: iniRel,
+      boundary: null,
+    };
+  }
+
+  return {
+    available: true,
+    missingVendoredRel: "",
+    boundary: analyzeIniRuntimeBoundaries({
+      manifestText,
+      sourceRootRel: `configs/sim/${machineRel}`,
+      sourceSearchRootRel: "configs/sim",
+      iniFile,
+      iniText: readFileSync(resolve(vendorRoot, iniRel), "utf8"),
+      executionTexts: executionTextsForBoundary(record),
+    }),
+  };
+}
+
+function verifyRuntimeBoundaryPolicy(nativeRecords, pathMatrixByPath) {
+  for (const record of nativeRecords) {
+    const boundaryReport = runtimeBoundaryForRecord(record);
+    if (!boundaryReport.available) {
+      continue;
+    }
+
+    const boundary = boundaryReport.boundary;
+    const matrixBlocked = pathMatrixByPath.get(record.path)?.blocked ?? "-";
+
+    if (matrixBlocked === "ASSET-ONLY") {
+      continue;
+    }
+
+    if (boundary.recommendedBlockedKind !== "-") {
+      assert.equal(
+        matrixBlocked,
+        boundary.recommendedBlockedKind,
+        `${record.path}: runtime-boundary policy drift`,
+      );
+    }
+    if (matrixBlocked === "L4-TOOL-DB") {
+      assert.equal(
+        boundary.toolDatabaseProgram !== "",
+        true,
+        `${record.path}: L4-TOOL-DB row must declare DB_PROGRAM`,
+      );
+    }
+    if (matrixBlocked === "L4-USER-M-PROCESS") {
+      assert.equal(
+        boundary.userMRuntime.requiresExternalProcess,
+        true,
+        `${record.path}: L4-USER-M-PROCESS row must execute unstaged user-M process`,
+      );
+    }
+  }
+}
+
+function listValue(values) {
+  return values.length > 0 ? values.join(",") : "-";
+}
+
+function flagValue(value) {
+  return value ? "1" : "0";
+}
+
+function tsvValue(value) {
+  const text = String(value ?? "-").replace(/\s+/g, " ").trim();
+  return text || "-";
+}
+
+function sourceConfigPathExists(relPath) {
+  try {
+    statSync(resolve(linuxCncSimRoot, relPath));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function linuxCncSourcePathExists(relPath) {
+  try {
+    statSync(resolve(workspaceRoot, "linuxcnc", relPath));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function verifyLinuxCncOwnerPaths(label, linuxCncOwner) {
+  assert.notEqual(linuxCncOwner, "-", `${label}: LinuxCNC owner is required`);
+  for (const ownerPath of linuxCncOwner.split(",").filter(Boolean)) {
+    if (ownerPath.includes("*")) {
+      continue;
+    }
+    assert.ok(
+      linuxCncSourcePathExists(ownerPath),
+      `${label}: LinuxCNC owner path does not exist: ${ownerPath}`,
+    );
+  }
+}
+
+function readSourceConfigText(relPath) {
+  return readFileSync(resolve(linuxCncSimRoot, relPath), "utf8");
+}
+
+function readLinuxCncSourceText(relPath) {
+  return readFileSync(resolve(workspaceRoot, "linuxcnc", relPath), "utf8");
+}
+
+function stripIniLineComment(line) {
+  return line.replace(/[;#].*$/, "");
+}
+
+function parseIniEntries(iniText) {
+  const entries = [];
+  let section = "";
+  for (const rawLine of iniText.split("\n")) {
+    const sectionMatch = rawLine.match(/^\s*\[([^\]]+)\]/);
+    if (sectionMatch) {
+      section = sectionMatch[1].trim().toUpperCase();
+      continue;
+    }
+    const line = stripIniLineComment(rawLine);
+    const equals = line.indexOf("=");
+    if (equals === -1 || !section) {
+      continue;
+    }
+    const key = line.slice(0, equals).trim().toUpperCase();
+    const value = line.slice(equals + 1).trim();
+    if (key && value) {
+      entries.push({ section, key, value });
+    }
+  }
+  return entries;
+}
+
+function iniValues(entries, section, key) {
+  return entries
+    .filter((entry) => entry.section === section.toUpperCase() && entry.key === key.toUpperCase())
+    .map((entry) => entry.value);
+}
+
+function iniSectionValues(entries, section) {
+  return entries.filter((entry) => entry.section === section.toUpperCase());
+}
+
+function normalizeSourceRel(relPath) {
+  return posix.normalize(relPath).replace(/^(\.\.\/)+/, "");
+}
+
+function sourceRelForIniReference(iniRel, reference) {
+  if (!reference || reference.startsWith("/") || reference.startsWith("LIB:")) {
+    return "";
+  }
+  return normalizeSourceRel(posix.join(posix.dirname(iniRel), reference));
+}
+
+function sourceDirPythonFiles(dirRel) {
+  const absDir = resolve(linuxCncSimRoot, dirRel);
+  try {
+    return readdirSync(absDir, { withFileTypes: true })
+      .filter((entry) => entry.isFile() && entry.name.endsWith(".py"))
+      .map((entry) => normalizeSourceRel(posix.join(dirRel, entry.name)))
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+function uniqueSorted(values) {
+  return [...new Set(values.filter(Boolean))].sort();
+}
+
+function remapDetails(entries) {
+  return iniValues(entries, "RS274NGC", "REMAP").map((value) => {
+    const code = value.match(/^\s*([A-Z][0-9]+(?:\.[0-9]+)?)/i)?.[1]?.toUpperCase() ?? "";
+    return {
+      value,
+      code,
+      python: value.match(/(?:^|\s)python=([^\s]+)/i)?.[1] ?? "",
+      prolog: value.match(/(?:^|\s)prolog=([^\s]+)/i)?.[1] ?? "",
+      epilog: value.match(/(?:^|\s)epilog=([^\s]+)/i)?.[1] ?? "",
+      ngc: value.match(/(?:^|\s)ngc=([^\s]+)/i)?.[1] ?? "",
+    };
+  });
+}
+
+function pythonFilesForIni(iniRel, entries) {
+  const explicitFiles = [];
+  const pythonDirs = [];
+  const iniDir = posix.dirname(iniRel);
+
+  for (const entry of iniSectionValues(entries, "PYTHON")) {
+    if (entry.key === "PATH_APPEND" || entry.key === "PATH_PREPEND") {
+      for (const dirEntry of entry.value.split(":").map((value) => value.trim()).filter(Boolean)) {
+        const dirRel = sourceRelForIniReference(iniRel, dirEntry);
+        if (dirRel) {
+          pythonDirs.push(dirRel);
+        }
+      }
+    } else if (entry.value.endsWith(".py")) {
+      const fileRel = sourceRelForIniReference(iniRel, entry.value);
+      if (fileRel) {
+        explicitFiles.push(fileRel);
+      }
+    }
+  }
+
+  for (const entry of [
+    ...iniSectionValues(entries, "DISPLAY"),
+    ...iniSectionValues(entries, "EMCIO"),
+  ]) {
+    const match = entry.value.match(/(?:^|\s)([^"'\s]+\.py)(?:\s|$)/i);
+    if (match) {
+      const fileRel = sourceRelForIniReference(iniRel, match[1]);
+      if (fileRel) {
+        explicitFiles.push(fileRel);
+      }
+    }
+  }
+
+  return uniqueSorted([
+    ...explicitFiles,
+    ...pythonDirs.flatMap(sourceDirPythonFiles),
+    ...sourceDirPythonFiles(posix.join(iniDir, "python")),
+  ]);
+}
+
+function functionOwners(functionNames, pythonFiles) {
+  return uniqueSorted(functionNames.map((functionName) => {
+    const pattern = new RegExp(`^\\s*def\\s+${functionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\(`, "m");
+    const owner = pythonFiles.find((fileRel) =>
+      sourceConfigPathExists(fileRel) && pattern.test(readSourceConfigText(fileRel)),
+    );
+    return `${functionName}@${owner || "UNRESOLVED"}`;
+  }));
+}
+
+function remapNgcSourceFiles(iniRel, entries, details) {
+  const subroutineDirs = iniValues(entries, "RS274NGC", "SUBROUTINE_PATH")
+    .flatMap((value) => value.split(":"))
+    .map((value) => value.trim())
+    .filter(Boolean);
+  const iniDir = posix.dirname(iniRel);
+
+  return uniqueSorted(details.map((detail) => {
+    if (!detail.ngc) {
+      return "";
+    }
+    const fileName = `${detail.ngc}.ngc`;
+    for (const dirEntry of subroutineDirs) {
+      const sourceRel = sourceRelForIniReference(iniRel, posix.join(dirEntry, fileName));
+      if (sourceRel && sourceConfigPathExists(sourceRel)) {
+        return sourceRel;
+      }
+    }
+    const sameDirRel = normalizeSourceRel(posix.join(iniDir, fileName));
+    return sourceConfigPathExists(sameDirRel) ? sameDirRel : `${fileName}@UNRESOLVED`;
+  }));
+}
+
+function sourceExecutionTextsForBlocked(record) {
+  const rels = [record.path];
+  if (record.path === "axis/vismach/millturn/example.ngc") {
+    rels.push(
+      "axis/vismach/millturn/remap_subs/428remap.ngc",
+      "axis/vismach/millturn/remap_subs/429remap.ngc",
+    );
+  }
+  return rels
+    .filter(sourceConfigPathExists)
+    .map(readSourceConfigText);
+}
+
+function userMCodesInExecutionText(text) {
+  const codes = new Set();
+  for (const match of text.matchAll(/(?<![A-Za-z0-9_])M\s*(1\d\d)(?![0-9])/gi)) {
+    codes.add(`M${match[1]}`);
+  }
+  return [...codes].sort();
+}
+
+function userMProcessFilesForCodes(iniRel, entries, userMCodes) {
+  const userMPathValues = iniValues(entries, "RS274NGC", "USER_M_PATH")
+    .flatMap((value) => value.split(":"))
+    .map((value) => value.trim())
+    .filter(Boolean);
+  return uniqueSorted(userMCodes.map((code) => {
+    for (const dirEntry of userMPathValues) {
+      const sourceRel = sourceRelForIniReference(iniRel, posix.join(dirEntry, code));
+      if (sourceRel && sourceConfigPathExists(sourceRel)) {
+        return sourceRel;
+      }
+    }
+    return `${code}@UNRESOLVED`;
+  }));
+}
+
+function userMProcessEffectsForFile(sourceRel) {
+  if (!sourceRel || sourceRel.includes("@UNRESOLVED") || !sourceConfigPathExists(sourceRel)) {
+    return [];
+  }
+
+  const text = readSourceConfigText(sourceRel);
+  const effects = [];
+  if (
+    text.includes("#!/usr/bin/tclsh") &&
+    text.includes("package require Linuxcnc") &&
+    text.includes("package require Hal")
+  ) {
+    effects.push("tcl_hal_runtime");
+  }
+  if (text.includes("parse_ini $::env(INI_FILE_NAME)")) {
+    effects.push("ini_file_parse");
+  }
+  if (/hal\s+getp\s+kinstype\.is-[01]/.test(text)) {
+    effects.push("kinstype_guard");
+  }
+  if (
+    text.includes("hal setp ini.$l.min_limit") &&
+    text.includes("hal setp ini.$l.max_limit") &&
+    text.includes("hal setp ini.$l.min_velocity") &&
+    text.includes("hal setp ini.$l.max_acceleration")
+  ) {
+    effects.push("ini_axis_limit_hal_setp");
+  }
+  if (text.includes("MIN_LIMIT_TURN") && text.includes("MAX_LIMIT_TURN")) {
+    effects.push("turn_limit_values");
+  }
+  if (
+    text.includes("(MIN_LIMIT)") &&
+    text.includes("(MAX_LIMIT)") &&
+    !text.includes("MIN_LIMIT_TURN")
+  ) {
+    effects.push("mill_limit_values");
+  }
+  return effects;
+}
+
+function userMProcessEffectsForFiles(sourceRels) {
+  return uniqueSorted(sourceRels.flatMap((sourceRel) =>
+    userMProcessEffectsForFile(sourceRel).map((effect) => `${basename(sourceRel)}:${effect}`),
+  ));
+}
+
+function userMRemapCallsForCode(record, code) {
+  return sourceExecutionTextsForBlocked(record)
+    .map((text, index) => {
+      if (!new RegExp(`(?:^|[^A-Za-z0-9_])${code}(?:[^0-9]|$)`, "i").test(text)) {
+        return "";
+      }
+      if (index === 0) {
+        return record.path;
+      }
+      if (record.path === "axis/vismach/millturn/example.ngc") {
+        return [
+          "axis/vismach/millturn/remap_subs/428remap.ngc",
+          "axis/vismach/millturn/remap_subs/429remap.ngc",
+        ][index - 1] ?? "";
+      }
+      return "";
+    })
+    .filter(Boolean);
+}
+
+function userMProcessStateTargetsForFile(sourceRel, iniRel) {
+  if (!sourceRel || sourceRel.includes("@UNRESOLVED") || !sourceConfigPathExists(sourceRel)) {
+    return [];
+  }
+
+  const text = readSourceConfigText(sourceRel);
+  const entries = parseIniEntries(readSourceConfigText(iniRel));
+  const code = basename(sourceRel).toUpperCase();
+  const stateMode = text.includes("MIN_LIMIT_TURN") ? "turn" : "mill";
+  const guard = text.match(/hal\s+getp\s+(kinstype\.is-[01])/i)?.[1] ?? "";
+  const sourceField = stateMode === "turn" ? "MIN_LIMIT_TURN/MAX_LIMIT_TURN" : "MIN_LIMIT/MAX_LIMIT";
+  const targets = [];
+
+  for (const axis of ["x", "y", "z"]) {
+    const section = `AXIS_${axis.toUpperCase()}`;
+    const minLimit = iniValues(entries, section, stateMode === "turn" ? "MIN_LIMIT_TURN" : "MIN_LIMIT")[0] ?? "";
+    const maxLimit = iniValues(entries, section, stateMode === "turn" ? "MAX_LIMIT_TURN" : "MAX_LIMIT")[0] ?? "";
+    const maxVelocity = iniValues(entries, section, "MAX_VELOCITY")[0] ?? "";
+    const maxAcceleration = iniValues(entries, section, "MAX_ACCELERATION")[0] ?? "";
+    for (const [pinSuffix, value, source] of [
+      ["min_limit", minLimit, sourceField],
+      ["max_limit", maxLimit, sourceField],
+      ["min_velocity", maxVelocity, "MAX_VELOCITY"],
+      ["max_acceleration", maxAcceleration, "MAX_ACCELERATION"],
+    ]) {
+      targets.push(`${code}:guard=${guard}:ini.${axis}.${pinSuffix}<=${section}.${source}:${value}`);
+    }
+  }
+
+  return targets;
+}
+
+function userMProcessStateTargetRows(row) {
+  if (row.blocked !== "L4-USER-M-PROCESS") {
+    return [];
+  }
+
+  const entries = parseIniEntries(readSourceConfigText(row.ini));
+  const userMCodes = splitSummaryList(row.user_m_execution_codes);
+  const userMFilesByCode = new Map(
+    userMProcessFilesForCodes(row.ini, entries, userMCodes)
+      .map((sourceRel) => [basename(sourceRel).toUpperCase(), sourceRel]),
+  );
+
+  return userMCodes.flatMap((code) => {
+    const sourceRel = userMFilesByCode.get(code) ?? "";
+    if (!sourceRel || sourceRel.includes("@UNRESOLVED") || !sourceConfigPathExists(sourceRel)) {
+      return [];
+    }
+
+    const text = readSourceConfigText(sourceRel);
+    const stateMode = text.includes("MIN_LIMIT_TURN") ? "turn" : "mill";
+    const guardPin = text.match(/hal\s+getp\s+(kinstype\.is-[01])/i)?.[1] ?? "";
+    const sourceLimitField = stateMode === "turn" ? "MIN_LIMIT_TURN/MAX_LIMIT_TURN" : "MIN_LIMIT/MAX_LIMIT";
+    const remapCallers = userMRemapCallsForCode({ path: row.path, ini: row.ini }, code);
+
+    return ["x", "y", "z"].flatMap((axis) => {
+      const section = `AXIS_${axis.toUpperCase()}`;
+      const minLimit = iniValues(entries, section, stateMode === "turn" ? "MIN_LIMIT_TURN" : "MIN_LIMIT")[0] ?? "";
+      const maxLimit = iniValues(entries, section, stateMode === "turn" ? "MAX_LIMIT_TURN" : "MAX_LIMIT")[0] ?? "";
+      const maxVelocity = iniValues(entries, section, "MAX_VELOCITY")[0] ?? "";
+      const maxAcceleration = iniValues(entries, section, "MAX_ACCELERATION")[0] ?? "";
+      return [
+        ["min_limit", minLimit, sourceLimitField],
+        ["max_limit", maxLimit, sourceLimitField],
+        ["min_velocity", maxVelocity, "MAX_VELOCITY"],
+        ["max_acceleration", maxAcceleration, "MAX_ACCELERATION"],
+      ].map(([pinSuffix, expectedValue, sourceField]) => [
+        row.path,
+        row.ini,
+        row.blocked,
+        code,
+        sourceRel,
+        listValue(remapCallers),
+        stateMode,
+        guardPin,
+        `ini.${axis}.${pinSuffix}`,
+        section,
+        sourceField,
+        expectedValue,
+        "hal_setp_from_config_script",
+        "pending",
+        "0",
+        "0",
+      ].map(tsvValue).join("\t"));
+    });
+  });
+}
+
+function verifyUserMProcessStateTargetRows(rows, blockedRows) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "user_m_code",
+    "source_file",
+    "remap_callers",
+    "state_mode",
+    "guard_pin",
+    "target_pin",
+    "source_section",
+    "source_field",
+    "expected_value",
+    "proof_kind",
+    "proof_status",
+    "execution_enabled",
+    "promotion_allowed",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const expectedBlockedRows = blockedRows.filter((row) => row.blocked === "L4-USER-M-PROCESS");
+
+  assert.equal(expectedBlockedRows.length, 1, "expected one user-M process blocked row");
+  assert.equal(parsedRows.length, 24, "M128/M129 state target rows must cover 2 codes * 3 axes * 4 pins");
+
+  const rowsByCode = new Map();
+  for (const row of parsedRows) {
+    const existing = rowsByCode.get(row.user_m_code) ?? [];
+    existing.push(row);
+    rowsByCode.set(row.user_m_code, existing);
+
+    assert.equal(row.blocked, "L4-USER-M-PROCESS", `${row.target_pin}: blocked kind drift`);
+    assert.ok(["M128", "M129"].includes(row.user_m_code), `${row.target_pin}: unexpected user-M code`);
+    assert.ok(row.source_file.endsWith(`mcodes/${row.user_m_code}`), `${row.target_pin}: source file drift`);
+    assert.ok(row.remap_callers.includes("axis/vismach/millturn/remap_subs/"), `${row.target_pin}: missing remap caller`);
+    assert.ok(["mill", "turn"].includes(row.state_mode), `${row.target_pin}: invalid state mode`);
+    assert.ok(["kinstype.is-0", "kinstype.is-1"].includes(row.guard_pin), `${row.target_pin}: invalid guard pin`);
+    assert.ok(/^ini\.[xyz]\.(min_limit|max_limit|min_velocity|max_acceleration)$/.test(row.target_pin), `${row.target_pin}: invalid target pin`);
+    assert.ok(/^AXIS_[XYZ]$/.test(row.source_section), `${row.target_pin}: invalid source section`);
+    assert.notEqual(row.expected_value, "-", `${row.target_pin}: missing expected value`);
+    assert.equal(row.proof_kind, "hal_setp_from_config_script", `${row.target_pin}: proof kind drift`);
+    assert.equal(row.proof_status, "pending", `${row.target_pin}: state target proof must remain pending`);
+    assert.equal(row.execution_enabled, "0", `${row.target_pin}: state target must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.target_pin}: state target must not allow promotion`);
+  }
+
+  assert.equal(rowsByCode.get("M128")?.length, 12, "M128 must have 12 state target rows");
+  assert.equal(rowsByCode.get("M129")?.length, 12, "M129 must have 12 state target rows");
+  assert.ok(
+    parsedRows.some((row) =>
+      row.user_m_code === "M128" &&
+      row.guard_pin === "kinstype.is-0" &&
+      row.state_mode === "mill" &&
+      row.target_pin === "ini.x.min_limit" &&
+      row.expected_value === "-300",
+    ),
+    "M128 mill X min limit target drift",
+  );
+  assert.ok(
+    parsedRows.some((row) =>
+      row.user_m_code === "M129" &&
+      row.guard_pin === "kinstype.is-1" &&
+      row.state_mode === "turn" &&
+      row.target_pin === "ini.z.max_limit" &&
+      row.expected_value === "300",
+    ),
+    "M129 turn Z max limit target drift",
+  );
+
+  return parsedRows;
+}
+
+function userMProcessTransitionPlanRows(stateTargetRows) {
+  const byCode = new Map();
+  for (const row of stateTargetRows) {
+    const existing = byCode.get(row.user_m_code) ?? [];
+    existing.push(row);
+    byCode.set(row.user_m_code, existing);
+  }
+
+  const transitionRows = [];
+  for (const code of [...byCode.keys()].sort()) {
+    const rows = byCode.get(code);
+    const first = rows[0];
+    const remapCaller = splitSummaryList(first.remap_callers)[0] ?? "";
+    const remapText = remapCaller ? readSourceConfigText(remapCaller) : "";
+    const remapCode = basename(remapCaller).match(/^(\d+)remap\.ngc$/)?.[1] ?? "";
+    const switchkinsTarget = remapText.match(/#<kinstype>\s*=\s*([01])/i)?.[1] ?? "";
+    const switchkinsPin = remapText.match(/#<SWITCHKINS_PIN>\s*=\s*([0-9]+)/i)?.[1] ?? "";
+    const workOffsetPocket = remapText.match(/G10\s+L2\s+P([0-9]+)/i)?.[1] ?? "";
+    const activeG5x = remapText.match(/\b(G59\.[12])\b/i)?.[1]?.toUpperCase() ?? "";
+    const expectedPins = uniqueSorted(rows.map((row) => row.target_pin));
+
+    transitionRows.push([
+      first.path,
+      first.ini,
+      first.blocked,
+      String(transitionRows.length + 1),
+      remapCode ? `M${remapCode}` : "-",
+      code,
+      remapCaller,
+      switchkinsPin ? `motion.analog-out-0${switchkinsPin}` : "-",
+      switchkinsTarget,
+      activeG5x,
+      workOffsetPocket ? `P${workOffsetPocket}` : "-",
+      first.guard_pin,
+      first.state_mode,
+      String(rows.length),
+      listValue(expectedPins),
+      "state_transition_contract_only",
+      "pending",
+      "0",
+      "0",
+      "no_process_execution_no_hal_runtime_promotion",
+    ].map(tsvValue).join("\t"));
+  }
+
+  return transitionRows;
+}
+
+function verifyUserMProcessTransitionPlanRows(rows, stateTargetRows) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "transition_step",
+    "remap_code",
+    "user_m_code",
+    "remap_caller",
+    "switchkins_output_pin",
+    "switchkins_target",
+    "active_g5x",
+    "work_offset_pocket",
+    "guard_pin",
+    "state_mode",
+    "state_target_count",
+    "expected_state_pins",
+    "proof_kind",
+    "proof_status",
+    "execution_enabled",
+    "promotion_allowed",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+
+  assert.equal(parsedRows.length, 2, "millturn user-M transition plan must cover M428/M429");
+  verifySamePathSet(
+    "wasm_user_m_process_transition_plan",
+    uniqueSorted(stateTargetRows.map((row) => row.user_m_code)),
+    parsedRows.map((row) => row.user_m_code).sort(),
+  );
+
+  const expectedByCode = new Map([
+    [
+      "M128",
+      {
+        remapCode: "M428",
+        switchkinsTarget: "0",
+        activeG5x: "G59.1",
+        workOffsetPocket: "P7",
+        guardPin: "kinstype.is-0",
+        stateMode: "mill",
+      },
+    ],
+    [
+      "M129",
+      {
+        remapCode: "M429",
+        switchkinsTarget: "1",
+        activeG5x: "G59.2",
+        workOffsetPocket: "P8",
+        guardPin: "kinstype.is-1",
+        stateMode: "turn",
+      },
+    ],
+  ]);
+
+  for (const row of parsedRows) {
+    const expected = expectedByCode.get(row.user_m_code);
+    assert.ok(expected, `${row.user_m_code}: unexpected transition plan user-M code`);
+    assert.equal(row.path, "axis/vismach/millturn/example.ngc", `${row.user_m_code}: path drift`);
+    assert.equal(row.ini, "axis/vismach/millturn/millturn.ini", `${row.user_m_code}: INI drift`);
+    assert.equal(row.blocked, "L4-USER-M-PROCESS", `${row.user_m_code}: blocked kind drift`);
+    assert.ok(/^[12]$/.test(row.transition_step), `${row.user_m_code}: invalid transition step`);
+    assert.equal(row.remap_code, expected.remapCode, `${row.user_m_code}: remap code drift`);
+    assert.ok(
+      row.remap_caller.endsWith(`${row.remap_code.slice(1)}remap.ngc`),
+      `${row.user_m_code}: remap caller drift`,
+    );
+    assert.equal(row.switchkins_output_pin, "motion.analog-out-03", `${row.user_m_code}: switchkins output pin drift`);
+    assert.equal(row.switchkins_target, expected.switchkinsTarget, `${row.user_m_code}: switchkins target drift`);
+    assert.equal(row.active_g5x, expected.activeG5x, `${row.user_m_code}: active G5x drift`);
+    assert.equal(row.work_offset_pocket, expected.workOffsetPocket, `${row.user_m_code}: work offset pocket drift`);
+    assert.equal(row.guard_pin, expected.guardPin, `${row.user_m_code}: guard pin drift`);
+    assert.equal(row.state_mode, expected.stateMode, `${row.user_m_code}: state mode drift`);
+    assert.equal(row.state_target_count, "12", `${row.user_m_code}: state target count drift`);
+    for (const pin of [
+      "ini.x.min_limit",
+      "ini.x.max_limit",
+      "ini.x.min_velocity",
+      "ini.x.max_acceleration",
+      "ini.y.min_limit",
+      "ini.z.max_limit",
+    ]) {
+      assert.ok(row.expected_state_pins.includes(pin), `${row.user_m_code}: missing state pin ${pin}`);
+    }
+    assert.equal(row.proof_kind, "state_transition_contract_only", `${row.user_m_code}: proof kind drift`);
+    assert.equal(row.proof_status, "pending", `${row.user_m_code}: proof status must remain pending`);
+    assert.equal(row.execution_enabled, "0", `${row.user_m_code}: transition plan must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.user_m_code}: transition plan must not allow promotion`);
+    assert.ok(row.notes.includes("no_process_execution"), `${row.user_m_code}: missing non-execution note`);
+  }
+
+  return parsedRows;
+}
+
+function userMProcessBoundarySummaryRow(row) {
+  if (row.blocked !== "L4-USER-M-PROCESS") {
+    return null;
+  }
+
+  const record = { path: row.path, ini: row.ini };
+  const entries = parseIniEntries(readSourceConfigText(row.ini));
+  const userMCodes = splitSummaryList(row.user_m_execution_codes);
+  const userMFiles = userMProcessFilesForCodes(row.ini, entries, userMCodes);
+  const stateTargets = uniqueSorted(userMFiles.flatMap((sourceRel) =>
+    userMProcessStateTargetsForFile(sourceRel, row.ini),
+  ));
+  const remapCallChain = uniqueSorted(userMCodes.flatMap((code) =>
+    userMRemapCallsForCode(record, code).map((sourceRel) => `${code}@${sourceRel}`),
+  ));
+
+  return [
+    row.path,
+    row.ini,
+    row.blocked,
+    "designed_blocked",
+    "external_user_m_process",
+    row.linuxcnc_owner,
+    row.user_m_execution_codes,
+    listValue(userMFiles),
+    listValue(remapCallChain),
+    listValue(stateTargets),
+    row.user_m_process_effects,
+    "kinstype_guard_and_ini_xyz_hal_pin_state",
+    "linuxcnc_owned_state_boundary_not_user_m_event_only",
+    "browser_after_node_state_proof_no_full_process_claim",
+    "0",
+    "0",
+    "keep_blocked_until_m128_m129_state_proof",
+  ].map(tsvValue).join("\t");
+}
+
+function verifyUserMProcessBoundarySummaryRows(rows, blockedRows) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "design_status",
+    "boundary_kind",
+    "linuxcnc_owner",
+    "user_m_execution_codes",
+    "user_m_process_files",
+    "remap_call_chain",
+    "state_targets",
+    "runtime_owner_evidence",
+    "required_native_proof",
+    "required_node_proof",
+    "required_browser_proof",
+    "execution_enabled",
+    "promotion_allowed",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const expectedRows = blockedRows.filter((row) => row.blocked === "L4-USER-M-PROCESS");
+
+  verifySamePathSet(
+    "wasm_user_m_process_boundary_summary",
+    expectedRows.map((row) => row.path).sort(),
+    parsedRows.map((row) => row.path).sort(),
+  );
+
+  for (const row of parsedRows) {
+    assert.equal(row.design_status, "designed_blocked", `${row.path}: user-M design status drift`);
+    assert.equal(row.boundary_kind, "external_user_m_process", `${row.path}: user-M boundary kind drift`);
+    assert.equal(row.execution_enabled, "0", `${row.path}: user-M boundary must remain disabled`);
+    assert.equal(row.promotion_allowed, "0", `${row.path}: user-M boundary must not allow promotion`);
+    verifyLinuxCncOwnerPaths(row.path, row.linuxcnc_owner);
+    for (const token of ["M128", "M129"]) {
+      assert.ok(row.user_m_execution_codes.includes(token), `${row.path}: missing execution code ${token}`);
+      assert.ok(row.user_m_process_files.includes(`mcodes/${token}`), `${row.path}: missing process file ${token}`);
+      assert.ok(row.remap_call_chain.includes(`${token}@axis/vismach/millturn/remap_subs/`), `${row.path}: missing remap caller ${token}`);
+    }
+    for (const token of [
+      "M128:guard=kinstype.is-0:ini.x.min_limit<=AXIS_X.MIN_LIMIT/MAX_LIMIT:-300",
+      "M128:guard=kinstype.is-0:ini.z.max_limit<=AXIS_Z.MIN_LIMIT/MAX_LIMIT:0",
+      "M129:guard=kinstype.is-1:ini.x.min_limit<=AXIS_X.MIN_LIMIT_TURN/MAX_LIMIT_TURN:-240",
+      "M129:guard=kinstype.is-1:ini.z.max_limit<=AXIS_Z.MIN_LIMIT_TURN/MAX_LIMIT_TURN:300",
+      "ini.y.min_velocity<=AXIS_Y.MAX_VELOCITY:60.0",
+      "ini.z.max_acceleration<=AXIS_Z.MAX_ACCELERATION:400.0",
+    ]) {
+      assert.ok(row.state_targets.includes(token), `${row.path}: missing state target ${token}`);
+    }
+    assert.ok(
+      row.runtime_owner_evidence.includes("tcl_hal_runtime") &&
+        row.runtime_owner_evidence.includes("ini_axis_limit_hal_setp"),
+      `${row.path}: user-M row lacks runtime owner evidence`,
+    );
+    assert.ok(row.required_node_proof.includes("not_user_m_event_only"), `${row.path}: event-only proof is insufficient`);
+    assert.ok(row.notes.includes("m128_m129_state_proof"), `${row.path}: missing M128/M129 proof note`);
+  }
+
+  return parsedRows;
+}
+
+function toolDbProtocolEvidence({ iniText, dbProgram }) {
+  if (!dbProgram) {
+    return [];
+  }
+
+  const taskText = readLinuxCncSourceText("src/emc/task/taskclass.cc");
+  const tooldataDbText = readLinuxCncSourceText("src/emc/tooldata/tooldata_db.cc");
+  const dbProgramText = readSourceConfigText("axis/db_demo/db.py");
+  const evidence = [];
+
+  if (iniText.includes("DB_PROGRAM") && dbProgram.includes("db_nonran.py")) {
+    evidence.push("ini_db_program_declared");
+  }
+  if (iniText.includes("TOOL_TABLE= is not used with DB_PROGRAM")) {
+    evidence.push("ini_tool_table_replaced");
+  }
+  if (
+    taskText.includes('findString("DB_PROGRAM", "EMCIO")') &&
+    taskText.includes("tooldata_set_db(db_mode)") &&
+    taskText.includes("tooldata_db_init(db_program, random_toolchanger)")
+  ) {
+    evidence.push("task_db_mode_init");
+  }
+  if (
+    taskText.includes("tooldata_db_notify(SPINDLE_UNLOAD") &&
+    taskText.includes("tooldata_db_notify(SPINDLE_LOAD")
+  ) {
+    evidence.push("task_load_unload_notify");
+  }
+  if (
+    tooldataDbText.includes('#define DB_VERSION "v2.1"') &&
+    tooldataDbText.includes("read_reply(reply,sizeof(reply))") &&
+    tooldataDbText.includes("strncmp(reply,DB_VERSION")
+  ) {
+    evidence.push("tooldata_db_v2_1_handshake");
+  }
+  if (
+    tooldataDbText.includes("pipe2(pipes[PARENT_READ_PIPE]") &&
+    tooldataDbText.includes("pipe2(pipes[PARENT_WRITE_PIPE]") &&
+    tooldataDbText.includes("execv(myargv[0], myargv)")
+  ) {
+    evidence.push("tooldata_db_child_process");
+  }
+  if (
+    tooldataDbText.includes('send_request((char*)"g\\n")') &&
+    tooldataDbText.includes('strstr(reply,"FINI")') &&
+    tooldataDbText.includes("tooldata_read_entry(reply)")
+  ) {
+    evidence.push("tooldata_db_getall_g_fini");
+  }
+  if (
+    tooldataDbText.includes('snprintf(msg,sizeof(msg),"l %s\\n",buffer)') &&
+    tooldataDbText.includes('snprintf(msg,sizeof(msg),"u %s\\n",buffer)') &&
+    tooldataDbText.includes('snprintf(msg,sizeof(msg),"p %s\\n",buffer)')
+  ) {
+    evidence.push("tooldata_db_notify_l_u_p");
+  }
+  if (
+    dbProgramText.includes("from tooldb import tooldb_callbacks") &&
+    dbProgramText.includes("from tooldb import tooldb_tools") &&
+    dbProgramText.includes("from tooldb import tooldb_loop")
+  ) {
+    evidence.push("db_program_tooldb_module");
+  }
+  if (
+    dbProgramText.includes("def user_get_tool(tno):") &&
+    dbProgramText.includes("def user_put_tool(tno,params):")
+  ) {
+    evidence.push("db_program_get_put_callbacks");
+  }
+  if (
+    dbProgramText.includes("def user_load_spindle_nonran_tc(tno,params):") &&
+    dbProgramText.includes("def user_unload_spindle_nonran_tc(tno,params):")
+  ) {
+    evidence.push("db_program_nonran_load_unload_callbacks");
+  }
+  if (
+    dbProgramText.includes('db_nonran_savefile = "/tmp/db_nonran_file"') &&
+    dbProgramText.includes("save_tools_to_file(db_savefile")
+  ) {
+    evidence.push("db_program_persistent_flatfile_state");
+  }
+  if (
+    dbProgramText.includes("tooldb_callbacks(user_get_tool") &&
+    dbProgramText.includes("tooldb_tools(toollist)")
+  ) {
+    evidence.push("db_program_callback_registration");
+  }
+
+  return uniqueSorted(evidence);
+}
+
+function toolDbProtocolMessages() {
+  const tooldataDbText = readLinuxCncSourceText("src/emc/tooldata/tooldata_db.cc");
+  const messages = [];
+
+  if (
+    tooldataDbText.includes('#define DB_VERSION "v2.1"') &&
+    tooldataDbText.includes("strncmp(reply,DB_VERSION")
+  ) {
+    messages.push("startup:expect_reply=v2.1");
+  }
+  if (
+    tooldataDbText.includes('send_request((char*)"g\\n")') &&
+    tooldataDbText.includes('strstr(reply,"FINI")')
+  ) {
+    messages.push("request:g:get_all_until_FINI");
+  }
+  if (tooldataDbText.includes('snprintf(msg,sizeof(msg),"l %s\\n",buffer)')) {
+    messages.push("notify:l:SPINDLE_LOAD");
+  }
+  if (tooldataDbText.includes('snprintf(msg,sizeof(msg),"u %s\\n",buffer)')) {
+    messages.push("notify:u:SPINDLE_UNLOAD");
+  }
+  if (tooldataDbText.includes('snprintf(msg,sizeof(msg),"p %s\\n",buffer)')) {
+    messages.push("notify:p:TOOL_OFFSET");
+  }
+
+  return uniqueSorted(messages);
+}
+
+function toolDbProgramCallbacks() {
+  const dbProgramText = readSourceConfigText("axis/db_demo/db.py");
+  const callbacks = [];
+
+  if (
+    dbProgramText.includes("tooldb_callbacks(user_get_tool") &&
+    dbProgramText.includes("tooldb_tools(toollist)") &&
+    dbProgramText.includes("tooldb_loop()")
+  ) {
+    callbacks.push("registration:tooldb_callbacks_tools_loop");
+  }
+  for (const [command, functionName] of [
+    ["g", "user_get_tool"],
+    ["p", "user_put_tool"],
+    ["l", "user_load_spindle_nonran_tc"],
+    ["u", "user_unload_spindle_nonran_tc"],
+  ]) {
+    if (dbProgramText.includes(`def ${functionName}(`)) {
+      callbacks.push(`${command}:${functionName}`);
+    }
+  }
+
+  return uniqueSorted(callbacks);
+}
+
+function toolDbStateTargets(row) {
+  const iniText = readSourceConfigText(row.ini);
+  const entries = parseIniEntries(iniText);
+  const dbProgramText = readSourceConfigText("axis/db_demo/db.py");
+  const randomToolchanger = iniValues(entries, "EMCIO", "RANDOM_TOOLCHANGER")[0] ?? "";
+  const dbProgram = iniValues(entries, "EMCIO", "DB_PROGRAM")[0] ?? "";
+  const targets = [];
+
+  if (randomToolchanger) {
+    targets.push(`ini.EMCIO.RANDOM_TOOLCHANGER=${randomToolchanger}`);
+  }
+  if (dbProgram) {
+    targets.push(`ini.EMCIO.DB_PROGRAM=${dbProgram}`);
+  }
+  if (iniText.includes("TOOL_TABLE= is not used with DB_PROGRAM")) {
+    targets.push("ini.EMCIO.TOOL_TABLE_IGNORED_WITH_DB_PROGRAM=1");
+  }
+  if (dbProgramText.includes('db_nonran_savefile = "/tmp/db_nonran_file"')) {
+    targets.push("db_program.savefile=/tmp/db_nonran_file");
+  }
+  if (dbProgramText.includes("toolno_min = 10") && dbProgramText.includes("toolno_max = 19")) {
+    targets.push("db_program.initial_tools=T10..T19");
+  }
+  if (dbProgramText.includes("nonran_pno(tno)") && dbProgramText.includes("pocket_offset      = 100")) {
+    targets.push("db_program.nonrandom_startup_pockets=tno+100");
+  }
+  if (
+    dbProgramText.includes("D['P'] = \"0\"") &&
+    dbProgramText.includes("nonran_restore_pocket(spindle_tool)")
+  ) {
+    targets.push("db_program.nonrandom_load_sets_spindle_pocket_0_and_unload_restores_pocket");
+  }
+  if (dbProgramText.includes("apply_db_rules()") && dbProgramText.includes("G10L0")) {
+    targets.push("db_program.reload_applies_db_rules");
+  }
+  if (dbProgramText.includes("linuxcnc.command().load_tool_table")) {
+    targets.push("db_program.host_sync=linuxcnc.command.load_tool_table");
+  }
+
+  return uniqueSorted(targets);
+}
+
+function toolDbProcessProtocolGateRows(row) {
+  if (row.blocked !== "L4-TOOL-DB") {
+    return [];
+  }
+
+  const gateRows = [];
+  for (const message of toolDbProtocolMessages()) {
+    gateRows.push([
+      row.path,
+      row.ini,
+      row.blocked,
+      "protocol_message",
+      message,
+      row.db_program,
+      row.linuxcnc_owner,
+      row.tool_db_protocol_evidence,
+      "linuxcnc_tooldata_db_protocol",
+      "pending",
+      "0",
+      "0",
+    ].map(tsvValue).join("\t"));
+  }
+  for (const callback of toolDbProgramCallbacks()) {
+    gateRows.push([
+      row.path,
+      row.ini,
+      row.blocked,
+      "db_program_callback",
+      callback,
+      row.db_program,
+      row.linuxcnc_owner,
+      row.tool_db_protocol_evidence,
+      "config_db_program_callback",
+      "pending",
+      "0",
+      "0",
+    ].map(tsvValue).join("\t"));
+  }
+  for (const target of toolDbStateTargets(row)) {
+    gateRows.push([
+      row.path,
+      row.ini,
+      row.blocked,
+      "state_target",
+      target,
+      row.db_program,
+      row.linuxcnc_owner,
+      row.tool_db_protocol_evidence,
+      "db_protocol_state_target",
+      "pending",
+      "0",
+      "0",
+    ].map(tsvValue).join("\t"));
+  }
+
+  return gateRows;
+}
+
+function verifyToolDbProcessProtocolGateRows(rows, blockedRows) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "gate_kind",
+    "gate",
+    "db_program",
+    "linuxcnc_owner",
+    "runtime_owner_evidence",
+    "proof_kind",
+    "proof_status",
+    "execution_enabled",
+    "promotion_allowed",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const expectedRows = blockedRows.filter((row) => row.blocked === "L4-TOOL-DB");
+
+  assert.equal(expectedRows.length, 1, "expected one tool DB blocked row");
+  assert.ok(parsedRows.length >= 18, "tool DB protocol gates must cover protocol, callbacks, and state targets");
+
+  const byKind = new Map();
+  for (const row of parsedRows) {
+    const existing = byKind.get(row.gate_kind) ?? [];
+    existing.push(row);
+    byKind.set(row.gate_kind, existing);
+
+    assert.equal(row.blocked, "L4-TOOL-DB", `${row.gate}: blocked kind drift`);
+    assert.equal(row.db_program, "./db_nonran.py", `${row.gate}: DB_PROGRAM drift`);
+    verifyLinuxCncOwnerPaths(row.gate, row.linuxcnc_owner);
+    assert.notEqual(row.runtime_owner_evidence, "-", `${row.gate}: missing runtime owner evidence`);
+    assert.equal(row.proof_status, "pending", `${row.gate}: tool DB proof gate must remain pending`);
+    assert.equal(row.execution_enabled, "0", `${row.gate}: tool DB proof gate must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.gate}: tool DB proof gate must not allow promotion`);
+  }
+
+  assert.equal(byKind.get("protocol_message")?.length, 5, "tool DB protocol message gate count drift");
+  assert.equal(byKind.get("db_program_callback")?.length, 5, "tool DB callback gate count drift");
+  assert.ok((byKind.get("state_target")?.length ?? 0) >= 8, "tool DB state target gate count drift");
+
+  for (const gate of [
+    "startup:expect_reply=v2.1",
+    "request:g:get_all_until_FINI",
+    "notify:l:SPINDLE_LOAD",
+    "notify:u:SPINDLE_UNLOAD",
+    "notify:p:TOOL_OFFSET",
+    "registration:tooldb_callbacks_tools_loop",
+    "g:user_get_tool",
+    "p:user_put_tool",
+    "l:user_load_spindle_nonran_tc",
+    "u:user_unload_spindle_nonran_tc",
+    "ini.EMCIO.TOOL_TABLE_IGNORED_WITH_DB_PROGRAM=1",
+    "db_program.initial_tools=T10..T19",
+    "db_program.nonrandom_startup_pockets=tno+100",
+    "db_program.nonrandom_load_sets_spindle_pocket_0_and_unload_restores_pocket",
+    "db_program.host_sync=linuxcnc.command.load_tool_table",
+  ]) {
+    assert.ok(parsedRows.some((row) => row.gate === gate), `tool DB protocol gate missing ${gate}`);
+  }
+
+  for (const row of parsedRows.filter((entry) => entry.gate_kind === "protocol_message")) {
+    assert.equal(row.proof_kind, "linuxcnc_tooldata_db_protocol", `${row.gate}: protocol proof kind drift`);
+  }
+  for (const row of parsedRows.filter((entry) => entry.gate_kind === "db_program_callback")) {
+    assert.equal(row.proof_kind, "config_db_program_callback", `${row.gate}: callback proof kind drift`);
+  }
+  for (const row of parsedRows.filter((entry) => entry.gate_kind === "state_target")) {
+    assert.equal(row.proof_kind, "db_protocol_state_target", `${row.gate}: state proof kind drift`);
+  }
+
+  return parsedRows;
+}
+
+function toolDbProcessTransactionPlanRows(gateRows) {
+  const first = gateRows[0];
+  if (!first) {
+    return [];
+  }
+
+  const gates = new Set(gateRows.map((row) => row.gate));
+  const stateTargets = (values) => values.filter((value) => gates.has(value));
+  const steps = [
+    {
+      phase: "startup_handshake",
+      protocolMessage: "startup:expect_reply=v2.1",
+      callback: "registration:tooldb_callbacks_tools_loop",
+      stateTargets: [
+        "ini.EMCIO.DB_PROGRAM=./db_nonran.py",
+        "ini.EMCIO.RANDOM_TOOLCHANGER=0",
+        "ini.EMCIO.TOOL_TABLE_IGNORED_WITH_DB_PROGRAM=1",
+        "db_program.savefile=/tmp/db_nonran_file",
+      ],
+      nativeProof: "tool_db_v2_1_handshake",
+      nodeProof: "linuxcnc_tooldata_db_protocol_not_tbl_fallback",
+      browserProof: "opfs_persistence_only_no_db_process_claim",
+    },
+    {
+      phase: "initial_get_all",
+      protocolMessage: "request:g:get_all_until_FINI",
+      callback: "g:user_get_tool",
+      stateTargets: [
+        "db_program.initial_tools=T10..T19",
+        "db_program.nonrandom_startup_pockets=tno+100",
+      ],
+      nativeProof: "tool_db_getall_g_until_fini",
+      nodeProof: "get_all_uses_db_protocol_not_tbl_load",
+      browserProof: "browser_after_node_protocol_proof_only",
+    },
+    {
+      phase: "spindle_load_notify",
+      protocolMessage: "notify:l:SPINDLE_LOAD",
+      callback: "l:user_load_spindle_nonran_tc",
+      stateTargets: [
+        "db_program.nonrandom_load_sets_spindle_pocket_0_and_unload_restores_pocket",
+      ],
+      nativeProof: "tool_db_notify_l_u_p_protocol",
+      nodeProof: "load_notify_uses_db_protocol",
+      browserProof: "browser_after_node_protocol_proof_only",
+    },
+    {
+      phase: "tool_offset_notify",
+      protocolMessage: "notify:p:TOOL_OFFSET",
+      callback: "p:user_put_tool",
+      stateTargets: [
+        "db_program.reload_applies_db_rules",
+        "db_program.host_sync=linuxcnc.command.load_tool_table",
+      ],
+      nativeProof: "tool_db_notify_l_u_p_protocol",
+      nodeProof: "put_notify_uses_db_protocol",
+      browserProof: "browser_after_node_protocol_proof_only",
+    },
+    {
+      phase: "spindle_unload_notify",
+      protocolMessage: "notify:u:SPINDLE_UNLOAD",
+      callback: "u:user_unload_spindle_nonran_tc",
+      stateTargets: [
+        "db_program.nonrandom_load_sets_spindle_pocket_0_and_unload_restores_pocket",
+        "db_program.host_sync=linuxcnc.command.load_tool_table",
+      ],
+      nativeProof: "tool_db_notify_l_u_p_protocol",
+      nodeProof: "unload_notify_uses_db_protocol",
+      browserProof: "browser_after_node_protocol_proof_only",
+    },
+  ];
+
+  return steps.map((step, index) => [
+    first.path,
+    first.ini,
+    first.blocked,
+    String(index + 1),
+    step.phase,
+    step.protocolMessage,
+    step.callback,
+    listValue(stateTargets(step.stateTargets)),
+    first.db_program,
+    step.nativeProof,
+    step.nodeProof,
+    step.browserProof,
+    "db_protocol_transaction_contract_only",
+    "pending",
+    "0",
+    "0",
+    "no_db_process_execution_no_tool_table_fallback_no_promotion",
+  ].map(tsvValue).join("\t"));
+}
+
+function verifyToolDbProcessTransactionPlanRows(rows, gateRows) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "transaction_step",
+    "transaction_phase",
+    "protocol_message",
+    "db_program_callback",
+    "state_targets",
+    "db_program",
+    "required_native_proof",
+    "required_node_proof",
+    "required_browser_proof",
+    "proof_kind",
+    "proof_status",
+    "execution_enabled",
+    "promotion_allowed",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const gateKeys = new Set(gateRows.map((row) => row.gate));
+  const expectedPhases = [
+    "startup_handshake",
+    "initial_get_all",
+    "spindle_load_notify",
+    "tool_offset_notify",
+    "spindle_unload_notify",
+  ];
+  const expectedProtocolByPhase = new Map([
+    ["startup_handshake", "startup:expect_reply=v2.1"],
+    ["initial_get_all", "request:g:get_all_until_FINI"],
+    ["spindle_load_notify", "notify:l:SPINDLE_LOAD"],
+    ["tool_offset_notify", "notify:p:TOOL_OFFSET"],
+    ["spindle_unload_notify", "notify:u:SPINDLE_UNLOAD"],
+  ]);
+  const expectedCallbackByPhase = new Map([
+    ["startup_handshake", "registration:tooldb_callbacks_tools_loop"],
+    ["initial_get_all", "g:user_get_tool"],
+    ["spindle_load_notify", "l:user_load_spindle_nonran_tc"],
+    ["tool_offset_notify", "p:user_put_tool"],
+    ["spindle_unload_notify", "u:user_unload_spindle_nonran_tc"],
+  ]);
+
+  assert.equal(parsedRows.length, 5, "tool DB transaction plan must cover startup/get/load/put/unload");
+  assert.deepEqual(
+    parsedRows.map((row) => row.transaction_phase),
+    expectedPhases,
+    "tool DB transaction phase order drift",
+  );
+
+  for (const [index, row] of parsedRows.entries()) {
+    assert.equal(row.path, "axis/db_demo/base.ngc", `${row.transaction_phase}: path drift`);
+    assert.equal(row.ini, "axis/db_demo/db_nonran.ini", `${row.transaction_phase}: INI drift`);
+    assert.equal(row.blocked, "L4-TOOL-DB", `${row.transaction_phase}: blocked kind drift`);
+    assert.equal(row.transaction_step, String(index + 1), `${row.transaction_phase}: step drift`);
+    assert.equal(row.db_program, "./db_nonran.py", `${row.transaction_phase}: DB_PROGRAM drift`);
+    assert.equal(
+      row.protocol_message,
+      expectedProtocolByPhase.get(row.transaction_phase),
+      `${row.transaction_phase}: protocol message drift`,
+    );
+    assert.equal(
+      row.db_program_callback,
+      expectedCallbackByPhase.get(row.transaction_phase),
+      `${row.transaction_phase}: DB callback drift`,
+    );
+    assert.ok(gateKeys.has(row.protocol_message), `${row.transaction_phase}: protocol gate missing`);
+    assert.ok(gateKeys.has(row.db_program_callback), `${row.transaction_phase}: callback gate missing`);
+    assert.notEqual(row.state_targets, "-", `${row.transaction_phase}: missing transaction state targets`);
+    for (const target of splitSummaryList(row.state_targets)) {
+      assert.ok(gateKeys.has(target), `${row.transaction_phase}: state target lacks gate ${target}`);
+    }
+    assert.notEqual(row.required_native_proof, "-", `${row.transaction_phase}: missing native proof`);
+    assert.notEqual(row.required_node_proof, "-", `${row.transaction_phase}: missing Node proof`);
+    assert.notEqual(row.required_browser_proof, "-", `${row.transaction_phase}: missing browser proof`);
+    assert.equal(row.proof_kind, "db_protocol_transaction_contract_only", `${row.transaction_phase}: proof kind drift`);
+    assert.equal(row.proof_status, "pending", `${row.transaction_phase}: proof status must remain pending`);
+    assert.equal(row.execution_enabled, "0", `${row.transaction_phase}: transaction plan must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.transaction_phase}: transaction plan must not allow promotion`);
+    assert.ok(row.notes.includes("no_db_process_execution"), `${row.transaction_phase}: missing non-execution note`);
+    assert.ok(row.notes.includes("no_tool_table_fallback"), `${row.transaction_phase}: missing no-fallback note`);
+  }
+
+  return parsedRows;
+}
+
+function sourceConfigExecutable(relPath) {
+  try {
+    return (statSync(resolve(linuxCncSimRoot, relPath)).mode & 0o111) !== 0;
+  } catch {
+    return false;
+  }
+}
+
+function linuxCncSourceExecutable(relPath) {
+  try {
+    return (statSync(resolve(workspaceRoot, "linuxcnc", relPath)).mode & 0o111) !== 0;
+  } catch {
+    return false;
+  }
+}
+
+function toolDbProcessNativeRuntimeReadinessRows(transactionRows) {
+  const first = transactionRows[0];
+  if (!first) {
+    return [];
+  }
+
+  const requirements = [
+    {
+      kind: "host_command",
+      requirement: "python3",
+      purpose: "execute_config_db_program_shebang",
+      available: commandPath("python3") !== "",
+      evidence: commandPath("python3"),
+    },
+    {
+      kind: "host_command",
+      requirement: "linuxcnc",
+      purpose: "provide_linuxcnc_python_runtime_and_task_context",
+      available: commandPath("linuxcnc") !== "",
+      evidence: commandPath("linuxcnc"),
+    },
+    {
+      kind: "host_command",
+      requirement: "milltask",
+      purpose: "own_db_program_startup_and_tooldata_protocol",
+      available: commandPath("milltask") !== "",
+      evidence: commandPath("milltask"),
+    },
+    {
+      kind: "host_command",
+      requirement: "halcmd",
+      purpose: "provide_linuxcnc_runtime_environment_for_db_program_sync",
+      available: commandPath("halcmd") !== "",
+      evidence: commandPath("halcmd"),
+    },
+    {
+      kind: "source_config_file",
+      requirement: "axis/db_demo/db_nonran.py",
+      purpose: "configured_db_program",
+      available: sourceConfigPathExists("axis/db_demo/db_nonran.py") &&
+        sourceConfigExecutable("axis/db_demo/db_nonran.py"),
+      evidence: "configs/sim/axis/db_demo/db_nonran.py",
+    },
+    {
+      kind: "linuxcnc_python_module",
+      requirement: "linuxcnc.so",
+      purpose: "db_program_import_linuxcnc",
+      available: linuxCncSourcePathExists("lib/python/linuxcnc.so"),
+      evidence: "lib/python/linuxcnc.so",
+    },
+    {
+      kind: "linuxcnc_python_module",
+      requirement: "tooldb.py",
+      purpose: "db_program_protocol_callbacks",
+      available: linuxCncSourcePathExists("lib/python/tooldb.py"),
+      evidence: "lib/python/tooldb.py",
+    },
+  ];
+  const allAvailable = requirements.every((row) => row.available);
+  const nativeRuntimeStatus = allAvailable
+    ? "host_runtime_available_probe_not_implemented"
+    : "blocked_missing_host_runtime";
+
+  return requirements.map((row) => [
+    first.path,
+    first.ini,
+    first.blocked,
+    "linuxcnc_tooldata_db_process",
+    row.kind,
+    row.requirement,
+    row.purpose,
+    flagValue(row.available),
+    row.available ? row.evidence : "-",
+    first.db_program,
+    nativeRuntimeStatus,
+    "native_db_process_protocol_probe_required",
+    "pending",
+    "0",
+    "0",
+    allAvailable
+      ? "runtime_requirements_available_but_probe_still_not_implemented"
+      : "missing_host_runtime_keep_tool_db_blocked",
+  ].map(tsvValue).join("\t"));
+}
+
+function verifyToolDbProcessNativeRuntimeReadinessRows(rows) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "required_runtime",
+    "requirement_kind",
+    "requirement",
+    "purpose",
+    "available",
+    "evidence",
+    "db_program",
+    "native_runtime_status",
+    "proof_kind",
+    "proof_status",
+    "execution_enabled",
+    "promotion_allowed",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const expectedRequirements = [
+    "python3",
+    "linuxcnc",
+    "milltask",
+    "halcmd",
+    "axis/db_demo/db_nonran.py",
+    "linuxcnc.so",
+    "tooldb.py",
+  ];
+
+  assert.deepEqual(
+    parsedRows.map((row) => row.requirement),
+    expectedRequirements,
+    "tool DB native runtime readiness requirements drift",
+  );
+
+  for (const row of parsedRows) {
+    assert.equal(row.path, "axis/db_demo/base.ngc", `${row.requirement}: path drift`);
+    assert.equal(row.ini, "axis/db_demo/db_nonran.ini", `${row.requirement}: INI drift`);
+    assert.equal(row.blocked, "L4-TOOL-DB", `${row.requirement}: blocked kind drift`);
+    assert.equal(row.required_runtime, "linuxcnc_tooldata_db_process", `${row.requirement}: runtime drift`);
+    assert.ok(
+      ["host_command", "source_config_file", "linuxcnc_python_module"].includes(row.requirement_kind),
+      `${row.requirement}: readiness kind drift`,
+    );
+    assert.ok(["0", "1"].includes(row.available), `${row.requirement}: invalid availability`);
+    assert.notEqual(row.purpose, "-", `${row.requirement}: missing purpose`);
+    if (row.available === "1") {
+      assert.notEqual(row.evidence, "-", `${row.requirement}: available requirement lacks evidence`);
+    }
+    assert.equal(row.db_program, "./db_nonran.py", `${row.requirement}: DB_PROGRAM drift`);
+    assert.ok(
+      ["blocked_missing_host_runtime", "host_runtime_available_probe_not_implemented"].includes(row.native_runtime_status),
+      `${row.requirement}: invalid runtime status`,
+    );
+    assert.equal(row.proof_kind, "native_db_process_protocol_probe_required", `${row.requirement}: proof kind drift`);
+    assert.equal(row.proof_status, "pending", `${row.requirement}: readiness proof must remain pending`);
+    assert.equal(row.execution_enabled, "0", `${row.requirement}: readiness must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.requirement}: readiness must not allow promotion`);
+    assert.ok(
+      row.notes.includes("keep_tool_db_blocked") ||
+        row.notes.includes("probe_still_not_implemented"),
+      `${row.requirement}: missing blocked/probe note`,
+    );
+  }
+
+  assert.ok(
+    parsedRows.some((row) => row.requirement === "python3" && row.available === "1"),
+    "python3 must be available for the DB program readiness check",
+  );
+  assert.ok(
+    parsedRows.some((row) =>
+      row.requirement === "axis/db_demo/db_nonran.py" && row.available === "1",
+    ),
+    "db_nonran.py must be available for the DB program readiness check",
+  );
+  assert.ok(
+    parsedRows.some((row) => row.requirement === "tooldb.py" && row.available === "1"),
+    "tooldb.py must be available for the DB program readiness check",
+  );
+
+  return parsedRows;
+}
+
+function toolDbNativeProofKeyForGate(row) {
+  if (row.gate_kind === "protocol_message") {
+    if (row.gate === "startup:expect_reply=v2.1") {
+      return "tool_db_v2_1_handshake";
+    }
+    if (row.gate === "request:g:get_all_until_FINI") {
+      return "tool_db_getall_g_until_fini";
+    }
+    if (row.gate.startsWith("notify:")) {
+      return "tool_db_notify_l_u_p_protocol";
+    }
+  }
+
+  if (row.gate_kind === "db_program_callback") {
+    if (row.gate === "registration:tooldb_callbacks_tools_loop") {
+      return "tool_db_program_tooldb_module";
+    }
+    return "tool_db_program_nonran_callbacks";
+  }
+
+  if (row.gate_kind === "state_target") {
+    if (row.gate === "ini.EMCIO.RANDOM_TOOLCHANGER=0") {
+      return "db_nonran_EMCIO.RANDOM_TOOLCHANGER_ok";
+    }
+    if (row.gate === "ini.EMCIO.DB_PROGRAM=./db_nonran.py") {
+      return "db_nonran_EMCIO.DB_PROGRAM_ok";
+    }
+    if (row.gate === "ini.EMCIO.TOOL_TABLE_IGNORED_WITH_DB_PROGRAM=1") {
+      return "db_nonran_tool_table_ignored_with_db_program";
+    }
+    if (row.gate === "db_program.reload_applies_db_rules") {
+      return "tool_db_program_reload_rules";
+    }
+    return "tool_db_program_nonran_state_targets";
+  }
+
+  return "";
+}
+
+function toolDbProcessNativeProtocolAlignmentRows(gateRows) {
+  const nativeProofUnavailableRows = () => gateRows.map((row) => [
+    row.path,
+    row.ini,
+    row.blocked,
+    row.gate_kind,
+    row.gate,
+    row.proof_kind,
+    "0",
+    "-",
+    "-",
+    "-",
+    "0",
+    row.execution_enabled,
+    row.promotion_allowed,
+    "pending",
+    "native_tool_db_probe_stdout_unavailable",
+  ].map(tsvValue).join("\t"));
+
+  if (!existsSync(nativeSourceProofSummaryPath)) {
+    return nativeProofUnavailableRows();
+  }
+
+  const nativeProofRows = parseTsv(
+    readFileSync(nativeSourceProofSummaryPath, "utf8"),
+    [
+      "boundary_class",
+      "proof_key",
+      "proof_value",
+      "execution_enabled",
+      "promotion_allowed",
+      "stdout_log",
+    ],
+  );
+  const toolDbProof = nativeProofRows.find((row) => row.boundary_class === "L4-TOOL-DB");
+  if (!toolDbProof?.stdout_log) {
+    return nativeProofUnavailableRows();
+  }
+
+  const stdoutPath = resolve(dirname(nativeSourceProofSummaryPath), toolDbProof.stdout_log);
+  if (!existsSync(stdoutPath)) {
+    return nativeProofUnavailableRows();
+  }
+
+  const stdoutValues = keyValuesFromText(readFileSync(stdoutPath, "utf8"));
+  return gateRows.map((row) => {
+    const nativeProofKey = toolDbNativeProofKeyForGate(row);
+    const nativeProofValue = stdoutValues.get(nativeProofKey) ?? "-";
+    const aligned = (
+      toolDbProof.proof_key === "tool_db_native_source_protocol_proof" &&
+      toolDbProof.proof_value === "1" &&
+      toolDbProof.execution_enabled === "0" &&
+      toolDbProof.promotion_allowed === "0" &&
+      nativeProofKey !== "" &&
+      nativeProofValue === "1" &&
+      row.execution_enabled === "0" &&
+      row.promotion_allowed === "0"
+    );
+
+    return [
+      row.path,
+      row.ini,
+      row.blocked,
+      row.gate_kind,
+      row.gate,
+      row.proof_kind,
+      "1",
+      nativeProofKey,
+      nativeProofValue,
+      "tool_db_native_source_protocol_proof",
+      flagValue(aligned),
+      row.execution_enabled,
+      row.promotion_allowed,
+      "pending",
+      "native_source_protocol_alignment_only_no_db_process_execution",
+    ].map(tsvValue).join("\t");
+  });
+}
+
+function verifyToolDbProcessNativeProtocolAlignmentRows(rows, gateRows) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "gate_kind",
+    "gate",
+    "proof_kind",
+    "native_stdout_available",
+    "native_proof_key",
+    "native_proof_value",
+    "source_proof_key",
+    "alignment_ok",
+    "execution_enabled",
+    "promotion_allowed",
+    "proof_status",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+
+  verifySamePathSet(
+    "wasm_tool_db_process_native_protocol_alignment",
+    gateRows.map((row) => `${row.path}:${row.gate_kind}:${row.gate}`).sort(),
+    parsedRows.map((row) => `${row.path}:${row.gate_kind}:${row.gate}`).sort(),
+  );
+  assert.ok(parsedRows.length >= 18, "tool DB native protocol alignment must cover every generated gate");
+
+  const stdoutAvailable = parsedRows.some((row) => row.native_stdout_available === "1");
+  if (!stdoutAvailable) {
+    for (const row of parsedRows) {
+      assert.equal(row.native_stdout_available, "0", `${row.gate}: mixed native stdout availability`);
+      assert.equal(row.alignment_ok, "0", `${row.gate}: unavailable native stdout cannot align`);
+      assert.equal(row.execution_enabled, "0", `${row.gate}: alignment must not enable execution`);
+      assert.equal(row.promotion_allowed, "0", `${row.gate}: alignment must not allow promotion`);
+      assert.equal(row.proof_status, "pending", `${row.gate}: proof must remain pending`);
+    }
+    return parsedRows;
+  }
+
+  const byKind = new Map();
+  for (const row of parsedRows) {
+    const existing = byKind.get(row.gate_kind) ?? [];
+    existing.push(row);
+    byKind.set(row.gate_kind, existing);
+
+    assert.equal(row.native_stdout_available, "1", `${row.gate}: native stdout must be available`);
+    assert.equal(row.blocked, "L4-TOOL-DB", `${row.gate}: blocked kind drift`);
+    assert.ok(
+      ["protocol_message", "db_program_callback", "state_target"].includes(row.gate_kind),
+      `${row.gate}: invalid gate kind`,
+    );
+    assert.notEqual(row.native_proof_key, "-", `${row.gate}: missing native proof key`);
+    assert.equal(row.native_proof_value, "1", `${row.gate}: native proof value drift`);
+    assert.equal(row.source_proof_key, "tool_db_native_source_protocol_proof", `${row.gate}: source proof key drift`);
+    assert.equal(row.alignment_ok, "1", `${row.gate}: native protocol alignment failed`);
+    assert.equal(row.execution_enabled, "0", `${row.gate}: alignment must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.gate}: alignment must not allow promotion`);
+    assert.equal(row.proof_status, "pending", `${row.gate}: proof must remain pending`);
+    assert.ok(
+      row.notes.includes("no_db_process_execution"),
+      `${row.gate}: alignment row must remain non-executing`,
+    );
+  }
+
+  assert.equal(byKind.get("protocol_message")?.length, 5, "tool DB protocol alignment count drift");
+  assert.equal(byKind.get("db_program_callback")?.length, 5, "tool DB callback alignment count drift");
+  assert.ok((byKind.get("state_target")?.length ?? 0) >= 8, "tool DB state target alignment count drift");
+
+  for (const row of parsedRows.filter((entry) => entry.gate_kind === "protocol_message")) {
+    assert.ok(
+      [
+        "tool_db_v2_1_handshake",
+        "tool_db_getall_g_until_fini",
+        "tool_db_notify_l_u_p_protocol",
+      ].includes(row.native_proof_key),
+      `${row.gate}: protocol gate native proof key drift`,
+    );
+  }
+  for (const row of parsedRows.filter((entry) => entry.gate_kind === "db_program_callback")) {
+    assert.ok(
+      [
+        "tool_db_program_tooldb_module",
+        "tool_db_program_nonran_callbacks",
+      ].includes(row.native_proof_key),
+      `${row.gate}: callback gate native proof key drift`,
+    );
+  }
+  for (const row of parsedRows.filter((entry) => entry.gate_kind === "state_target")) {
+    assert.ok(
+      [
+        "db_nonran_EMCIO.RANDOM_TOOLCHANGER_ok",
+        "db_nonran_EMCIO.DB_PROGRAM_ok",
+        "db_nonran_tool_table_ignored_with_db_program",
+        "tool_db_program_nonran_state_targets",
+        "tool_db_program_reload_rules",
+      ].includes(row.native_proof_key),
+      `${row.gate}: state target native proof key drift`,
+    );
+  }
+
+  return parsedRows;
+}
+
+function toolDbProcessBoundarySummaryRow(row) {
+  if (row.blocked !== "L4-TOOL-DB") {
+    return null;
+  }
+
+  return [
+    row.path,
+    row.ini,
+    row.blocked,
+    "designed_blocked",
+    "tool_database_process",
+    row.linuxcnc_owner,
+    row.db_program,
+    listValue(toolDbProtocolMessages()),
+    listValue(toolDbProgramCallbacks()),
+    listValue(toolDbStateTargets(row)),
+    row.tool_db_protocol_evidence,
+    "db_program_v2_1_handshake_getall_load_unload_or_put",
+    "linuxcnc_tooldata_db_protocol_not_tbl_fallback",
+    "browser_after_node_protocol_proof_opfs_persistence_only",
+    "0",
+    "0",
+    "keep_blocked_until_db_protocol_state_proof",
+  ].map(tsvValue).join("\t");
+}
+
+function verifyToolDbProcessBoundarySummaryRows(rows, blockedRows) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "design_status",
+    "boundary_kind",
+    "linuxcnc_owner",
+    "db_program",
+    "protocol_messages",
+    "db_program_callbacks",
+    "state_targets",
+    "runtime_owner_evidence",
+    "required_native_proof",
+    "required_node_proof",
+    "required_browser_proof",
+    "execution_enabled",
+    "promotion_allowed",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const expectedRows = blockedRows.filter((row) => row.blocked === "L4-TOOL-DB");
+
+  verifySamePathSet(
+    "wasm_tool_db_process_boundary_summary",
+    expectedRows.map((row) => row.path).sort(),
+    parsedRows.map((row) => row.path).sort(),
+  );
+
+  for (const row of parsedRows) {
+    assert.equal(row.design_status, "designed_blocked", `${row.path}: tool DB design status drift`);
+    assert.equal(row.boundary_kind, "tool_database_process", `${row.path}: tool DB boundary kind drift`);
+    assert.equal(row.execution_enabled, "0", `${row.path}: tool DB boundary must remain disabled`);
+    assert.equal(row.promotion_allowed, "0", `${row.path}: tool DB boundary must not allow promotion`);
+    assert.equal(row.db_program, "./db_nonran.py", `${row.path}: DB_PROGRAM drift`);
+    verifyLinuxCncOwnerPaths(row.path, row.linuxcnc_owner);
+    for (const token of [
+      "startup:expect_reply=v2.1",
+      "request:g:get_all_until_FINI",
+      "notify:l:SPINDLE_LOAD",
+      "notify:u:SPINDLE_UNLOAD",
+      "notify:p:TOOL_OFFSET",
+    ]) {
+      assert.ok(row.protocol_messages.includes(token), `${row.path}: missing protocol message ${token}`);
+    }
+    for (const token of [
+      "registration:tooldb_callbacks_tools_loop",
+      "g:user_get_tool",
+      "p:user_put_tool",
+      "l:user_load_spindle_nonran_tc",
+      "u:user_unload_spindle_nonran_tc",
+    ]) {
+      assert.ok(row.db_program_callbacks.includes(token), `${row.path}: missing DB callback ${token}`);
+    }
+    for (const token of [
+      "ini.EMCIO.RANDOM_TOOLCHANGER=0",
+      "ini.EMCIO.DB_PROGRAM=./db_nonran.py",
+      "ini.EMCIO.TOOL_TABLE_IGNORED_WITH_DB_PROGRAM=1",
+      "db_program.savefile=/tmp/db_nonran_file",
+      "db_program.initial_tools=T10..T19",
+      "db_program.nonrandom_startup_pockets=tno+100",
+      "db_program.nonrandom_load_sets_spindle_pocket_0_and_unload_restores_pocket",
+      "db_program.host_sync=linuxcnc.command.load_tool_table",
+    ]) {
+      assert.ok(row.state_targets.includes(token), `${row.path}: missing state target ${token}`);
+    }
+    assert.ok(
+      row.runtime_owner_evidence.includes("tooldata_db_v2_1_handshake") &&
+        row.runtime_owner_evidence.includes("tooldata_db_notify_l_u_p") &&
+        row.runtime_owner_evidence.includes("db_program_nonran_load_unload_callbacks"),
+      `${row.path}: tool DB row lacks runtime owner evidence`,
+    );
+    assert.ok(row.required_node_proof.includes("not_tbl_fallback"), `${row.path}: tbl fallback proof is insufficient`);
+    assert.ok(row.notes.includes("db_protocol_state_proof"), `${row.path}: missing DB protocol proof note`);
+  }
+
+  return parsedRows;
+}
+
+function pythonRuntimeEvidence() {
+  const interpPythonText = readLinuxCncSourceText("src/emc/rs274ngc/interp_python.cc");
+  const pythonPluginText = readLinuxCncSourceText("src/emc/pythonplugin/python_plugin.cc");
+  const evidence = [];
+
+  if (
+    interpPythonText.includes("PythonPlugin *python_plugin") &&
+    interpPythonText.includes("Interp::pycall") &&
+    interpPythonText.includes("python_plugin->call(module,funcname")
+  ) {
+    evidence.push("interp_python_pycall_dispatch");
+  }
+  if (
+    interpPythonText.includes("PY_PROLOG") &&
+    interpPythonText.includes("PY_BODY") &&
+    interpPythonText.includes("PY_EPILOG")
+  ) {
+    evidence.push("interp_python_remap_phases");
+  }
+  if (
+    interpPythonText.includes("PyGen_Check(retval.ptr())") &&
+    interpPythonText.includes("PY_FINISH_PROLOG") &&
+    interpPythonText.includes("PY_FINISH_EPILOG")
+  ) {
+    evidence.push("interp_python_generator_finish");
+  }
+  if (
+    interpPythonText.includes("Interp::is_pycallable") &&
+    interpPythonText.includes("python_plugin->is_callable(module,funcname)")
+  ) {
+    evidence.push("interp_python_callable_lookup");
+  }
+  if (
+    interpPythonText.includes("Interp::py_execute") &&
+    interpPythonText.includes("python_plugin->run_string(cmd, retval, as_file)")
+  ) {
+    evidence.push("interp_python_execute_runtime");
+  }
+  if (
+    pythonPluginText.includes("Py_InitializeFromConfig(&config)") &&
+    pythonPluginText.includes("PyConfig_InitPythonConfig(&config)")
+  ) {
+    evidence.push("python_plugin_initializes_python");
+  }
+  if (
+    pythonPluginText.includes('findString("TOPLEVEL", section)') &&
+    pythonPluginText.includes("bp::exec_file(abs_path, main_namespace, main_namespace)")
+  ) {
+    evidence.push("python_plugin_toplevel_exec_file");
+  }
+  if (
+    pythonPluginText.includes('findString(n, "PATH_PREPEND", "PYTHON")') &&
+    pythonPluginText.includes('findString(n, "PATH_APPEND", "PYTHON")') &&
+    pythonPluginText.includes("PyRun_SimpleString(pycmd)")
+  ) {
+    evidence.push("python_plugin_ini_python_path");
+  }
+  if (
+    pythonPluginText.includes("PythonPlugin::call") &&
+    pythonPluginText.includes("PyObject_Call(function.ptr(), tupleargs.ptr(), kwargs.ptr())")
+  ) {
+    evidence.push("python_plugin_callable_invoke");
+  }
+  if (
+    pythonPluginText.includes("PythonPlugin::reload") &&
+    pythonPluginText.includes("reload_on_change")
+  ) {
+    evidence.push("python_plugin_reload_on_change");
+  }
+
+  return uniqueSorted(evidence);
+}
+
+function linuxCncOwnerForBlockedKind(blocked) {
+  if (blocked === "L4-TOOL-DB") {
+    return [
+      "src/emc/task/taskclass.cc",
+      "src/emc/tooldata/tooldata_db.cc",
+      "src/emc/tooldata/tooldata_common.cc",
+      "configs/sim/axis/db_demo/db.py",
+    ].join(",");
+  }
+  if (blocked === "L4-USER-M-PROCESS") {
+    return [
+      "src/emc/task/emctask.cc",
+      "src/emc/usr_intf/halui.cc",
+      "configs/sim/axis/vismach/millturn/mcodes/M128",
+      "configs/sim/axis/vismach/millturn/mcodes/M129",
+    ].join(",");
+  }
+  if (blocked === "L4-PYTHON-REMAP") {
+    return "src/emc/rs274ngc/interp_python.cc,src/emc/pythonplugin/python_plugin.cc,configs/sim/*/python/*.py";
+  }
+  return "-";
+}
+
+function blockedDependencySummaryRow(record, pathMatrixByPath) {
+  const blocked = pathMatrixByPath.get(record.path)?.blocked ?? "-";
+  const sourceAvailable = sourceConfigPathExists(record.ini);
+  if (!sourceAvailable) {
+    return [
+      record.path,
+      record.ini,
+      blocked,
+      posix.dirname(record.path),
+      "0",
+      "-",
+      "-",
+      "-",
+      "-",
+      "-",
+      "-",
+      "0",
+      "0",
+      "0",
+      "-",
+      "-",
+      "-",
+      "-",
+      "-",
+      "-",
+      "missing_source_ini",
+    ].map(tsvValue).join("\t");
+  }
+
+  const iniText = readSourceConfigText(record.ini);
+  const entries = parseIniEntries(iniText);
+  const details = remapDetails(entries);
+  const pythonFiles = pythonFilesForIni(record.ini, entries);
+  const pythonRemapFunctions = uniqueSorted(details.map((detail) => detail.python));
+  const prologFunctions = uniqueSorted(details.map((detail) => detail.prolog));
+  const epilogFunctions = uniqueSorted(details.map((detail) => detail.epilog));
+  const remapNgcFiles = remapNgcSourceFiles(record.ini, entries, details);
+  const ngcOnlyRemaps = remapNgcSourceFiles(
+    record.ini,
+    entries,
+    details.filter((detail) => detail.ngc && !detail.python && !detail.prolog && !detail.epilog),
+  );
+  const halProcess = [
+    ...iniValues(entries, "HAL", "HALFILE"),
+    ...iniValues(entries, "HAL", "HALCMD"),
+    ...iniValues(entries, "HAL", "POSTGUI_HALFILE"),
+    ...iniValues(entries, "HAL", "HALUI"),
+  ].length > 0;
+  const displayValues = [
+    ...iniValues(entries, "DISPLAY", "DISPLAY"),
+    ...iniValues(entries, "DISPLAY", "PYVCP"),
+    ...iniValues(entries, "DISPLAY", "GLADEVCP"),
+    ...iniValues(entries, "DISPLAY", "EMBED_TAB_COMMAND"),
+  ];
+  const uiProcess = displayValues.some((value) => !/^axis$/i.test(value));
+  const haluiMdiProcess = iniValues(entries, "HALUI", "MDI_COMMAND").length > 0;
+  const dbProgram = iniValues(entries, "EMCIO", "DB_PROGRAM")[0] ?? "";
+  const toolDbEvidence = toolDbProtocolEvidence({ iniText, dbProgram });
+  const userMCodes = uniqueSorted(sourceExecutionTextsForBlocked(record).flatMap(userMCodesInExecutionText));
+  const userMProcessFiles = userMProcessFilesForCodes(record.ini, entries, userMCodes);
+  const userMProcessEffects = userMProcessEffectsForFiles(userMProcessFiles);
+  const notes = [];
+
+  if (blocked === "L4-PYTHON-REMAP") {
+    notes.push("dependency_inventory_only_no_execution");
+  }
+  if (blocked === "L4-TOOL-DB") {
+    notes.push("tool_database_process_boundary_required");
+  }
+  if (blocked === "L4-USER-M-PROCESS") {
+    notes.push("external_user_m_process_boundary_required");
+  }
+  if (ngcOnlyRemaps.length > 0 && (pythonRemapFunctions.length > 0 || prologFunctions.length > 0 || epilogFunctions.length > 0)) {
+    notes.push("mixed_ngc_and_python_remaps_do_not_promote_subpaths_blindly");
+  }
+
+  return [
+    record.path,
+    record.ini,
+    blocked,
+    posix.dirname(record.path),
+    "1",
+    listValue(pythonFiles),
+    listValue(functionOwners(pythonRemapFunctions, pythonFiles)),
+    listValue(functionOwners(prologFunctions, pythonFiles)),
+    listValue(functionOwners(epilogFunctions, pythonFiles)),
+    listValue(remapNgcFiles),
+    listValue(ngcOnlyRemaps),
+    flagValue(halProcess),
+    flagValue(uiProcess),
+    flagValue(haluiMdiProcess),
+    dbProgram || "-",
+    listValue(toolDbEvidence),
+    listValue(userMCodes),
+    listValue(userMProcessFiles),
+    listValue(userMProcessEffects),
+    linuxCncOwnerForBlockedKind(blocked),
+    listValue(notes),
+  ].map(tsvValue).join("\t");
+}
+
+function verifyBlockedDependencySummaryRows(rows, expectedRecords) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "family",
+    "source_available",
+    "python_modules",
+    "python_remap_functions",
+    "prolog_functions",
+    "epilog_functions",
+    "remap_ngc_files",
+    "ngc_only_subpaths",
+    "hal_process",
+    "ui_process",
+    "halui_mdi_process",
+    "db_program",
+    "tool_db_protocol_evidence",
+    "user_m_execution_codes",
+    "user_m_process_files",
+    "user_m_process_effects",
+    "linuxcnc_owner",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const expectedPaths = expectedRecords.map((record) => record.path).sort();
+
+  verifySamePathSet(
+    "wasm_blocked_dependency_summary",
+    expectedPaths,
+    parsedRows.map((record) => record.path).sort(),
+  );
+
+  for (const row of parsedRows) {
+    assert.equal(row.source_available, "1", `${row.path}: blocked source INI must be readable`);
+    for (const field of ["hal_process", "ui_process", "halui_mdi_process"]) {
+      assert.ok(["0", "1"].includes(row[field]), `${row.path}: invalid ${field} flag`);
+    }
+    assert.notEqual(row.linuxcnc_owner, "-", `${row.path}: blocked row lacks LinuxCNC owner`);
+    for (const ownerPath of row.linuxcnc_owner.split(",").filter(Boolean)) {
+      if (ownerPath.includes("*")) {
+        continue;
+      }
+      assert.ok(
+        linuxCncSourcePathExists(ownerPath),
+        `${row.path}: LinuxCNC owner path does not exist: ${ownerPath}`,
+      );
+    }
+    if (row.blocked === "L4-PYTHON-REMAP") {
+      assert.notEqual(
+        [row.python_modules, row.python_remap_functions, row.prolog_functions, row.epilog_functions]
+          .join(","),
+        "-,-,-,-",
+        `${row.path}: Python-remap row lacks Python dependency evidence`,
+      );
+      assert.equal(
+        [row.python_remap_functions, row.prolog_functions, row.epilog_functions]
+          .join(",")
+          .includes("@UNRESOLVED"),
+        false,
+        `${row.path}: Python-remap row has unresolved callable owner`,
+      );
+      assert.ok(
+        row.notes.includes("dependency_inventory_only_no_execution"),
+        `${row.path}: Python-remap row must remain inventory-only`,
+      );
+    }
+    if (row.blocked === "L4-TOOL-DB") {
+      assert.notEqual(row.db_program, "-", `${row.path}: tool DB row lacks DB_PROGRAM`);
+      assert.notEqual(row.tool_db_protocol_evidence, "-", `${row.path}: tool DB row lacks protocol evidence`);
+      for (const evidence of [
+        "ini_db_program_declared",
+        "ini_tool_table_replaced",
+        "task_db_mode_init",
+        "task_load_unload_notify",
+        "tooldata_db_v2_1_handshake",
+        "tooldata_db_child_process",
+        "tooldata_db_getall_g_fini",
+        "tooldata_db_notify_l_u_p",
+        "db_program_tooldb_module",
+        "db_program_get_put_callbacks",
+        "db_program_nonran_load_unload_callbacks",
+        "db_program_persistent_flatfile_state",
+        "db_program_callback_registration",
+      ]) {
+        assert.ok(
+          row.tool_db_protocol_evidence.includes(evidence),
+          `${row.path}: tool DB row lacks ${evidence} evidence`,
+        );
+      }
+      assert.ok(
+        row.linuxcnc_owner.includes("src/emc/tooldata/tooldata_db.cc"),
+        `${row.path}: tool DB row lacks LinuxCNC owner`,
+      );
+    }
+    if (row.blocked === "L4-USER-M-PROCESS") {
+      assert.notEqual(row.user_m_execution_codes, "-", `${row.path}: user-M process row lacks M-code evidence`);
+      assert.notEqual(row.user_m_process_files, "-", `${row.path}: user-M process row lacks process file evidence`);
+      assert.notEqual(row.user_m_process_effects, "-", `${row.path}: user-M process row lacks side-effect evidence`);
+      assert.ok(
+        row.user_m_process_files.includes("mcodes/M128") &&
+          row.user_m_process_files.includes("mcodes/M129"),
+        `${row.path}: user-M process row lacks M128/M129 source files`,
+      );
+      for (const effect of [
+        "M128:tcl_hal_runtime",
+        "M128:ini_file_parse",
+        "M128:kinstype_guard",
+        "M128:ini_axis_limit_hal_setp",
+        "M128:mill_limit_values",
+        "M129:tcl_hal_runtime",
+        "M129:ini_file_parse",
+        "M129:kinstype_guard",
+        "M129:ini_axis_limit_hal_setp",
+        "M129:turn_limit_values",
+      ]) {
+        assert.ok(
+          row.user_m_process_effects.includes(effect),
+          `${row.path}: user-M process row lacks ${effect} evidence`,
+        );
+      }
+      assert.ok(
+        row.linuxcnc_owner.includes("src/emc/task/emctask.cc"),
+        `${row.path}: user-M process row lacks LinuxCNC task owner`,
+      );
+      assert.equal(row.hal_process, "1", `${row.path}: user-M process row lacks HAL dependency`);
+      assert.equal(row.halui_mdi_process, "1", `${row.path}: user-M process row lacks HALUI dependency`);
+    }
+  }
+
+  return parsedRows;
+}
+
+function verifyFullProcessBoundaryDesign(markdownText, rows) {
+  const rowsByPath = new Map(rows.map((row) => [row.path, row]));
+  const requiredRows = [
+    {
+      path: "axis/vismach/millturn/example.ngc",
+      blocked: "L4-USER-M-PROCESS",
+      tokens: [
+        "External User-M Process Boundary",
+        "configs/sim/axis/vismach/millturn/mcodes/M128",
+        "configs/sim/axis/vismach/millturn/mcodes/M129",
+        "src/emc/task/emctask.cc",
+        "src/emc/task/emctaskmain.cc",
+        "src/emc/usr_intf/halui.cc",
+        "user-m-process-boundary-summary.tsv",
+        "kinstype.is-0",
+        "kinstype.is-1",
+        "ini.[xyz].min_limit",
+        "ini.[xyz].max_acceleration",
+        "promotion_allowed=0",
+        "`USER_M_COMMAND` event alone is not sufficient",
+      ],
+    },
+    {
+      path: "axis/db_demo/base.ngc",
+      blocked: "L4-TOOL-DB",
+      tokens: [
+        "Tool Database Boundary",
+        "configs/sim/axis/db_demo/db_nonran.ini",
+        "configs/sim/axis/db_demo/db.py",
+        "src/emc/task/taskclass.cc",
+        "src/emc/tooldata/tooldata_db.cc",
+        "src/emc/tooldata/tooldata_common.cc",
+        "tool-db-process-boundary-summary.tsv",
+        "v2.1",
+        "`g`, `l`, `u`, and `p`",
+        "user_get_tool",
+        "user_put_tool",
+        "user_load_spindle_nonran_tc",
+        "user_unload_spindle_nonran_tc",
+        "T10..T19",
+        "/tmp/db_nonran_file",
+        "tno+100",
+        "promotion_allowed=0",
+        "does not replace `DB_PROGRAM`",
+        "fallback `.tbl`",
+      ],
+    },
+  ];
+
+  for (const required of requiredRows) {
+    const row = rowsByPath.get(required.path);
+    assert.ok(row, `${required.path}: blocked dependency row missing for design guard`);
+    assert.equal(row.blocked, required.blocked, `${required.path}: design guard blocked kind drift`);
+    assert.ok(
+      markdownText.includes(`\`${required.path}\``),
+      `${required.path}: full-process boundary design missing path`,
+    );
+    assert.ok(
+      markdownText.includes(required.blocked),
+      `${required.path}: full-process boundary design missing blocked kind`,
+    );
+    for (const token of required.tokens) {
+      assert.ok(
+        markdownText.includes(token),
+        `${required.path}: full-process boundary design missing token ${token}`,
+      );
+    }
+  }
+
+  assert.ok(
+    markdownText.includes("Python-remap rows remain inventory-only"),
+    "full-process boundary design must keep Python-remap rows inventory-only",
+  );
+  for (const token of [
+    "next-boundary-worklist.tsv",
+    "`execution_enabled=0`",
+    "`promotion_allowed=0`",
+    "records the LinuxCNC owner set",
+    "names the next boundary-design",
+    "action before promotion",
+    "native-proof-alignment-summary.tsv",
+    "consumed by generated worklist and native proof-gate",
+    "`external_user_m_process` for `axis/vismach/millturn/example.ngc`",
+    "`tool_database_process` for `axis/db_demo/base.ngc`",
+    "Python runtime family rows follow as inventory-only targets",
+  ]) {
+    assert.ok(
+      markdownText.includes(token),
+      `full-process boundary design missing next-worklist token ${token}`,
+    );
+  }
+  assert.ok(
+    markdownText.includes("Do not implement HAL, task, HALUI, Tcl, Python, tool-database, or external"),
+    "full-process boundary design must preserve non-goal guard",
+  );
+}
+
+function fullProcessBoundarySummaryRow(row) {
+  if (row.blocked === "L4-USER-M-PROCESS") {
+    return [
+      row.path,
+      row.ini,
+      row.blocked,
+      "designed_blocked",
+      "external_user_m_process",
+      row.linuxcnc_owner,
+      row.user_m_process_effects,
+      "kinstype_guard_and_ini_xyz_hal_pin_state",
+      "linuxcnc_owned_state_boundary_not_user_m_event_only",
+      "sdk_wasm_boundary_after_node_state_proof",
+      "browser_after_node_state_proof_no_full_process_claim",
+      "0",
+      "keep_blocked_until_m128_m129_state_proof",
+    ].map(tsvValue).join("\t");
+  }
+
+  if (row.blocked === "L4-TOOL-DB") {
+    return [
+      row.path,
+      row.ini,
+      row.blocked,
+      "designed_blocked",
+      "tool_database_process",
+      row.linuxcnc_owner,
+      row.tool_db_protocol_evidence,
+      "db_program_v2_1_handshake_getall_load_unload_or_put",
+      "linuxcnc_tooldata_db_protocol_not_tbl_fallback",
+      "sdk_wasm_boundary_after_protocol_proof",
+      "browser_after_node_protocol_proof_opfs_persistence_only",
+      "0",
+      "keep_blocked_until_db_protocol_state_proof",
+    ].map(tsvValue).join("\t");
+  }
+
+  return null;
+}
+
+function verifyFullProcessBoundarySummaryRows(rows, blockedRows) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "design_status",
+    "boundary_kind",
+    "linuxcnc_owner",
+    "runtime_owner_evidence",
+    "required_native_proof",
+    "required_node_proof",
+    "required_browser_proof",
+    "browser_policy",
+    "execution_enabled",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const expectedRows = blockedRows.filter((row) =>
+    ["L4-TOOL-DB", "L4-USER-M-PROCESS"].includes(row.blocked),
+  );
+
+  verifySamePathSet(
+    "wasm_full_process_boundary_summary",
+    expectedRows.map((row) => row.path).sort(),
+    parsedRows.map((row) => row.path).sort(),
+  );
+
+  for (const row of parsedRows) {
+    assert.equal(row.design_status, "designed_blocked", `${row.path}: design status drift`);
+    assert.equal(row.execution_enabled, "0", `${row.path}: full-process boundary must remain disabled`);
+    assert.notEqual(row.linuxcnc_owner, "-", `${row.path}: full-process row lacks owner`);
+
+    if (row.blocked === "L4-USER-M-PROCESS") {
+      assert.equal(
+        row.boundary_kind,
+        "external_user_m_process",
+        `${row.path}: user-M boundary kind drift`,
+      );
+      assert.ok(
+        row.required_native_proof.includes("ini_xyz_hal_pin_state"),
+        `${row.path}: user-M row lacks HAL pin state proof`,
+      );
+      assert.ok(
+        row.runtime_owner_evidence.includes("tcl_hal_runtime") &&
+          row.runtime_owner_evidence.includes("kinstype_guard") &&
+          row.runtime_owner_evidence.includes("ini_axis_limit_hal_setp"),
+        `${row.path}: user-M row lacks runtime owner evidence`,
+      );
+      assert.ok(
+        row.required_node_proof.includes("not_user_m_event_only"),
+        `${row.path}: user-M row must reject event-only proof`,
+      );
+      assert.ok(
+        row.notes.includes("m128_m129_state_proof"),
+        `${row.path}: user-M row lacks M128/M129 proof note`,
+      );
+    } else if (row.blocked === "L4-TOOL-DB") {
+      assert.equal(
+        row.boundary_kind,
+        "tool_database_process",
+        `${row.path}: tool DB boundary kind drift`,
+      );
+      assert.ok(
+        row.required_native_proof.includes("v2_1_handshake"),
+        `${row.path}: tool DB row lacks protocol handshake proof`,
+      );
+      assert.ok(
+        row.runtime_owner_evidence.includes("tooldata_db_v2_1_handshake") &&
+          row.runtime_owner_evidence.includes("tooldata_db_getall_g_fini") &&
+          row.runtime_owner_evidence.includes("tooldata_db_notify_l_u_p"),
+        `${row.path}: tool DB row lacks runtime owner evidence`,
+      );
+      assert.ok(
+        row.required_node_proof.includes("not_tbl_fallback"),
+        `${row.path}: tool DB row must reject tbl fallback proof`,
+      );
+      assert.ok(
+        row.notes.includes("db_protocol_state_proof"),
+        `${row.path}: tool DB row lacks protocol proof note`,
+      );
+    } else {
+      throw new Error(`${row.path}: unexpected full-process blocked kind ${row.blocked}`);
+    }
+  }
+
+  return parsedRows;
+}
+
+function pythonRemapBoundarySummaryRow(row) {
+  if (row.blocked !== "L4-PYTHON-REMAP") {
+    return null;
+  }
+
+  return [
+    row.path,
+    row.ini,
+    row.blocked,
+    "inventory_only",
+    row.python_modules,
+    row.python_remap_functions,
+    row.prolog_functions,
+    row.epilog_functions,
+    row.remap_ngc_files,
+    row.ngc_only_subpaths,
+    row.hal_process,
+    row.ui_process,
+    row.halui_mdi_process,
+    row.linuxcnc_owner,
+    listValue(pythonRuntimeEvidence()),
+    "python_runtime_boundary_required",
+    "0",
+    row.notes,
+  ].map(tsvValue).join("\t");
+}
+
+function verifyPythonRemapBoundarySummaryRows(rows, blockedRows) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "design_status",
+    "python_modules",
+    "python_remap_functions",
+    "prolog_functions",
+    "epilog_functions",
+    "remap_ngc_files",
+    "ngc_only_subpaths",
+    "hal_process",
+    "ui_process",
+    "halui_mdi_process",
+    "linuxcnc_owner",
+    "python_runtime_evidence",
+    "required_boundary",
+    "execution_enabled",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const expectedRows = blockedRows.filter((row) => row.blocked === "L4-PYTHON-REMAP");
+
+  verifySamePathSet(
+    "wasm_python_remap_boundary_summary",
+    expectedRows.map((row) => row.path).sort(),
+    parsedRows.map((row) => row.path).sort(),
+  );
+
+  for (const row of parsedRows) {
+    assert.equal(row.blocked, "L4-PYTHON-REMAP", `${row.path}: Python boundary blocked kind drift`);
+    assert.equal(row.design_status, "inventory_only", `${row.path}: Python boundary design status drift`);
+    assert.equal(row.required_boundary, "python_runtime_boundary_required", `${row.path}: Python boundary type drift`);
+    assert.equal(row.execution_enabled, "0", `${row.path}: Python remap execution must remain disabled`);
+    assert.ok(
+      row.notes.includes("dependency_inventory_only_no_execution"),
+      `${row.path}: Python boundary row must remain inventory-only`,
+    );
+    assert.notEqual(
+      [row.python_modules, row.python_remap_functions, row.prolog_functions, row.epilog_functions]
+        .join(","),
+      "-,-,-,-",
+      `${row.path}: Python boundary row lacks Python dependency evidence`,
+    );
+    assert.ok(
+      row.linuxcnc_owner.includes("src/emc/rs274ngc/interp_python.cc"),
+      `${row.path}: Python boundary row lacks interpreter Python owner`,
+    );
+    assert.notEqual(
+      row.python_runtime_evidence,
+      "-",
+      `${row.path}: Python boundary row lacks runtime owner evidence`,
+    );
+    for (const evidence of [
+      "interp_python_pycall_dispatch",
+      "interp_python_remap_phases",
+      "interp_python_generator_finish",
+      "interp_python_callable_lookup",
+      "interp_python_execute_runtime",
+      "python_plugin_initializes_python",
+      "python_plugin_toplevel_exec_file",
+      "python_plugin_ini_python_path",
+      "python_plugin_callable_invoke",
+      "python_plugin_reload_on_change",
+    ]) {
+      assert.ok(
+        row.python_runtime_evidence.includes(evidence),
+        `${row.path}: Python boundary row lacks ${evidence} evidence`,
+      );
+    }
+    for (const field of ["hal_process", "ui_process", "halui_mdi_process"]) {
+      assert.ok(["0", "1"].includes(row[field]), `${row.path}: invalid ${field} flag`);
+    }
+  }
+
+  return parsedRows;
+}
+
+function pythonRemapRuntimeGateRows(row) {
+  if (row.blocked !== "L4-PYTHON-REMAP") {
+    return [];
+  }
+
+  const gateRows = [];
+  const addGates = (gateKind, values, proofKind) => {
+    for (const value of splitSummaryList(values)) {
+      gateRows.push([
+        row.path,
+        row.ini,
+        row.blocked,
+        gateKind,
+        value,
+        row.linuxcnc_owner,
+        row.python_runtime_evidence,
+        proofKind,
+        "pending",
+        "0",
+        "0",
+        row.notes,
+      ].map(tsvValue).join("\t"));
+    }
+  };
+
+  addGates("python_module", row.python_modules, "python_module_dependency");
+  addGates("python_remap_callable", row.python_remap_functions, "python_runtime_callable");
+  addGates("python_prolog_callable", row.prolog_functions, "python_runtime_callable");
+  addGates("python_epilog_callable", row.epilog_functions, "python_runtime_callable");
+  addGates("remap_ngc_file", row.remap_ngc_files, "linuxcnc_ngc_remap_subpath");
+  addGates("ngc_only_subpath", row.ngc_only_subpaths, "separable_ngc_subpath_inventory_only");
+
+  for (const [field, enabled] of [
+    ["hal_process", row.hal_process],
+    ["ui_process", row.ui_process],
+    ["halui_mdi_process", row.halui_mdi_process],
+  ]) {
+    if (enabled === "1") {
+      gateRows.push([
+        row.path,
+        row.ini,
+        row.blocked,
+        "process_assumption",
+        field,
+        row.linuxcnc_owner,
+        row.python_runtime_evidence,
+        "full_process_dependency_assumption",
+        "pending",
+        "0",
+        "0",
+        row.notes,
+      ].map(tsvValue).join("\t"));
+    }
+  }
+
+  for (const evidence of splitSummaryList(row.python_runtime_evidence)) {
+    gateRows.push([
+      row.path,
+      row.ini,
+      row.blocked,
+      "python_runtime_owner_evidence",
+      evidence,
+      row.linuxcnc_owner,
+      row.python_runtime_evidence,
+      "linuxcnc_python_runtime_owner",
+      "pending",
+      "0",
+      "0",
+      row.notes,
+    ].map(tsvValue).join("\t"));
+  }
+
+  return gateRows;
+}
+
+function verifyPythonRemapRuntimeGateRows(rows, pythonRows) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "gate_kind",
+    "gate",
+    "linuxcnc_owner",
+    "runtime_owner_evidence",
+    "proof_kind",
+    "proof_status",
+    "execution_enabled",
+    "promotion_allowed",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const expectedPaths = pythonRows.map((row) => row.path).sort();
+  const actualPaths = uniqueSorted(parsedRows.map((row) => row.path));
+
+  assert.deepEqual(actualPaths, expectedPaths, "Python runtime gates must cover every Python-remap row");
+  assert.ok(parsedRows.length > pythonRows.length, "Python runtime gates must expand dependency rows");
+
+  const allowedGateKinds = new Set([
+    "python_module",
+    "python_remap_callable",
+    "python_prolog_callable",
+    "python_epilog_callable",
+    "remap_ngc_file",
+    "ngc_only_subpath",
+    "process_assumption",
+    "python_runtime_owner_evidence",
+  ]);
+  const allowedProofKinds = new Set([
+    "python_module_dependency",
+    "python_runtime_callable",
+    "linuxcnc_ngc_remap_subpath",
+    "separable_ngc_subpath_inventory_only",
+    "full_process_dependency_assumption",
+    "linuxcnc_python_runtime_owner",
+  ]);
+
+  const rowsByPath = new Map();
+  for (const row of parsedRows) {
+    const existing = rowsByPath.get(row.path) ?? [];
+    existing.push(row);
+    rowsByPath.set(row.path, existing);
+
+    assert.equal(row.blocked, "L4-PYTHON-REMAP", `${row.path}: Python runtime gate blocked kind drift`);
+    assert.ok(allowedGateKinds.has(row.gate_kind), `${row.path}: unknown Python runtime gate kind ${row.gate_kind}`);
+    assert.notEqual(row.gate, "-", `${row.path}: Python runtime gate missing value`);
+    verifyLinuxCncOwnerPaths(row.path, row.linuxcnc_owner);
+    assert.notEqual(row.runtime_owner_evidence, "-", `${row.path}: Python runtime gate lacks owner evidence`);
+    assert.ok(allowedProofKinds.has(row.proof_kind), `${row.path}: unknown Python runtime proof kind ${row.proof_kind}`);
+    assert.equal(row.proof_status, "pending", `${row.path}: Python runtime proof gate must remain pending`);
+    assert.equal(row.execution_enabled, "0", `${row.path}: Python runtime gate must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.path}: Python runtime gate must not allow promotion`);
+    assert.ok(
+      row.notes.includes("dependency_inventory_only_no_execution"),
+      `${row.path}: Python runtime gate must remain inventory-only`,
+    );
+  }
+
+  for (const row of pythonRows) {
+    const pathRows = rowsByPath.get(row.path) ?? [];
+    assert.ok(
+      pathRows.some((gate) => gate.gate_kind === "python_runtime_owner_evidence"),
+      `${row.path}: Python runtime owner gate missing`,
+    );
+    assert.ok(
+      pathRows.some((gate) =>
+        ["python_module", "python_remap_callable", "python_prolog_callable", "python_epilog_callable"].includes(gate.gate_kind),
+      ),
+      `${row.path}: Python dependency gate missing`,
+    );
+    if (row.ngc_only_subpaths !== "-") {
+      assert.ok(
+        pathRows.some((gate) => gate.gate_kind === "ngc_only_subpath"),
+        `${row.path}: NGC-only subpath gate missing`,
+      );
+      assert.ok(
+        row.notes.includes("mixed_ngc_and_python_remaps_do_not_promote_subpaths_blindly") ||
+          (row.python_remap_functions === "-" && row.prolog_functions === "-" && row.epilog_functions === "-"),
+        `${row.path}: NGC-only subpaths require mixed-remap note or pure NGC accounting`,
+      );
+    }
+    for (const field of ["hal_process", "ui_process", "halui_mdi_process"]) {
+      if (row[field] === "1") {
+        assert.ok(
+          pathRows.some((gate) => gate.gate_kind === "process_assumption" && gate.gate === field),
+          `${row.path}: missing ${field} process-assumption gate`,
+        );
+      }
+    }
+  }
+
+  return parsedRows;
+}
+
+function pythonNativeRuntimeKeyForEvidence(evidence) {
+  return new Map([
+    ["interp_python_pycall_dispatch", "python_runtime_pycall_dispatch"],
+    ["interp_python_remap_phases", "python_runtime_remap_phases"],
+    ["interp_python_generator_finish", "python_runtime_generator_finish"],
+    ["interp_python_callable_lookup", "python_runtime_callable_lookup"],
+    ["interp_python_execute_runtime", "python_runtime_execute_runtime"],
+    ["python_plugin_initializes_python", "python_plugin_initializes_python"],
+    ["python_plugin_toplevel_exec_file", "python_plugin_toplevel_exec_file"],
+    ["python_plugin_ini_python_path", "python_plugin_ini_python_path"],
+    ["python_plugin_callable_invoke", "python_plugin_callable_invoke"],
+    ["python_plugin_reload_on_change", "python_plugin_reload_on_change"],
+  ]).get(evidence) ?? "";
+}
+
+function pythonNativeInventoryKeyForGate(row) {
+  if (row.path.startsWith("axis/laser/")) {
+    return "python_family_axis_laser_inventory";
+  }
+  if (row.path.startsWith("axis/vismach/5axis/table-rotary_spindle-rotary-nutating/")) {
+    return "python_family_twp_nutating_inventory";
+  }
+  if (row.path.startsWith("axis/remap/cycle/")) {
+    return "python_family_axis_remap_cycle_inventory";
+  }
+  if (row.path.startsWith("gmoccapy/")) {
+    return "python_family_gmoccapy_stdglue_inventory";
+  }
+  return "python_remap_native_source_inventory_proof";
+}
+
+function pythonRemapNativeRuntimeAlignmentRows(gateRows) {
+  const nativeProofUnavailableRows = () => gateRows.map((row) => [
+    row.path,
+    row.ini,
+    row.blocked,
+    row.gate_kind,
+    row.gate,
+    row.proof_kind,
+    "0",
+    "-",
+    "-",
+    "-",
+    "0",
+    row.execution_enabled,
+    row.promotion_allowed,
+    "pending",
+    "native_python_probe_stdout_unavailable",
+  ].map(tsvValue).join("\t"));
+
+  if (!existsSync(nativeSourceProofSummaryPath)) {
+    return nativeProofUnavailableRows();
+  }
+
+  const nativeProofRows = parseTsv(
+    readFileSync(nativeSourceProofSummaryPath, "utf8"),
+    [
+      "boundary_class",
+      "proof_key",
+      "proof_value",
+      "execution_enabled",
+      "promotion_allowed",
+      "stdout_log",
+    ],
+  );
+  const pythonProof = nativeProofRows.find((row) => row.boundary_class === "L4-PYTHON-REMAP");
+  if (!pythonProof?.stdout_log) {
+    return nativeProofUnavailableRows();
+  }
+
+  const stdoutPath = resolve(dirname(nativeSourceProofSummaryPath), pythonProof.stdout_log);
+  if (!existsSync(stdoutPath)) {
+    return nativeProofUnavailableRows();
+  }
+
+  const stdoutValues = keyValuesFromText(readFileSync(stdoutPath, "utf8"));
+  return gateRows.map((row) => {
+    const nativeProofKey = row.gate_kind === "python_runtime_owner_evidence"
+      ? pythonNativeRuntimeKeyForEvidence(row.gate)
+      : pythonNativeInventoryKeyForGate(row);
+    const nativeProofValue = stdoutValues.get(nativeProofKey) ?? "-";
+    const aligned = (
+      pythonProof.proof_key === "python_remap_native_source_inventory_proof" &&
+      pythonProof.proof_value === "1" &&
+      pythonProof.execution_enabled === "0" &&
+      pythonProof.promotion_allowed === "0" &&
+      nativeProofKey !== "" &&
+      nativeProofValue === "1" &&
+      row.execution_enabled === "0" &&
+      row.promotion_allowed === "0"
+    );
+
+    return [
+      row.path,
+      row.ini,
+      row.blocked,
+      row.gate_kind,
+      row.gate,
+      row.proof_kind,
+      "1",
+      nativeProofKey,
+      nativeProofValue,
+      "python_remap_native_source_inventory_proof",
+      flagValue(aligned),
+      row.execution_enabled,
+      row.promotion_allowed,
+      "pending",
+      "native_source_python_runtime_alignment_only_no_python_execution",
+    ].map(tsvValue).join("\t");
+  });
+}
+
+function verifyPythonRemapNativeRuntimeAlignmentRows(rows, gateRows) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "gate_kind",
+    "gate",
+    "proof_kind",
+    "native_stdout_available",
+    "native_proof_key",
+    "native_proof_value",
+    "source_proof_key",
+    "alignment_ok",
+    "execution_enabled",
+    "promotion_allowed",
+    "proof_status",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+
+  verifySamePathSet(
+    "wasm_python_remap_native_runtime_alignment",
+    gateRows.map((row) => `${row.path}:${row.gate_kind}:${row.gate}`).sort(),
+    parsedRows.map((row) => `${row.path}:${row.gate_kind}:${row.gate}`).sort(),
+  );
+  assert.ok(parsedRows.length > gateRows.length - 1, "Python native runtime alignment must cover every generated gate");
+
+  const stdoutAvailable = parsedRows.some((row) => row.native_stdout_available === "1");
+  if (!stdoutAvailable) {
+    for (const row of parsedRows) {
+      assert.equal(row.native_stdout_available, "0", `${row.gate}: mixed native stdout availability`);
+      assert.equal(row.alignment_ok, "0", `${row.gate}: unavailable native stdout cannot align`);
+      assert.equal(row.execution_enabled, "0", `${row.gate}: alignment must not enable execution`);
+      assert.equal(row.promotion_allowed, "0", `${row.gate}: alignment must not allow promotion`);
+      assert.equal(row.proof_status, "pending", `${row.gate}: proof must remain pending`);
+    }
+    return parsedRows;
+  }
+
+  const runtimeOwnerRows = parsedRows.filter((row) => row.gate_kind === "python_runtime_owner_evidence");
+  assert.ok(runtimeOwnerRows.length > 0, "Python runtime owner alignment rows are required");
+
+  for (const row of parsedRows) {
+    assert.equal(row.native_stdout_available, "1", `${row.gate}: native stdout must be available`);
+    assert.equal(row.blocked, "L4-PYTHON-REMAP", `${row.gate}: blocked kind drift`);
+    assert.notEqual(row.native_proof_key, "-", `${row.gate}: missing native proof key`);
+    assert.equal(row.native_proof_value, "1", `${row.gate}: native proof value drift`);
+    assert.equal(
+      row.source_proof_key,
+      "python_remap_native_source_inventory_proof",
+      `${row.gate}: source proof key drift`,
+    );
+    assert.equal(row.alignment_ok, "1", `${row.gate}: native Python runtime alignment failed`);
+    assert.equal(row.execution_enabled, "0", `${row.gate}: alignment must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.gate}: alignment must not allow promotion`);
+    assert.equal(row.proof_status, "pending", `${row.gate}: proof must remain pending`);
+    assert.ok(
+      row.notes.includes("no_python_execution"),
+      `${row.gate}: alignment row must remain non-executing`,
+    );
+
+    if (row.gate_kind === "python_runtime_owner_evidence") {
+      assert.equal(
+        row.native_proof_key,
+        pythonNativeRuntimeKeyForEvidence(row.gate),
+        `${row.gate}: runtime owner native key drift`,
+      );
+    } else {
+      assert.ok(
+        [
+          "python_family_axis_laser_inventory",
+          "python_family_twp_nutating_inventory",
+          "python_family_axis_remap_cycle_inventory",
+          "python_family_gmoccapy_stdglue_inventory",
+          "python_remap_native_source_inventory_proof",
+        ].includes(row.native_proof_key),
+        `${row.gate}: dependency native inventory key drift`,
+      );
+    }
+  }
+
+  for (const key of [
+    "python_runtime_pycall_dispatch",
+    "python_runtime_remap_phases",
+    "python_runtime_generator_finish",
+    "python_runtime_callable_lookup",
+    "python_runtime_execute_runtime",
+    "python_plugin_initializes_python",
+    "python_plugin_toplevel_exec_file",
+    "python_plugin_ini_python_path",
+    "python_plugin_callable_invoke",
+    "python_plugin_reload_on_change",
+  ]) {
+    assert.ok(
+      runtimeOwnerRows.some((row) => row.native_proof_key === key),
+      `Python runtime owner alignment missing ${key}`,
+    );
+  }
+
+  return parsedRows;
+}
+
+function splitSummaryList(value) {
+  return value === "-" ? [] : value.split(",").filter(Boolean);
+}
+
+function pythonRemapFamilySummaryRows(rows) {
+  const byFamily = new Map();
+  for (const row of rows) {
+    const family = posix.dirname(row.path);
+    const existing = byFamily.get(family) ?? [];
+    existing.push(row);
+    byFamily.set(family, existing);
+  }
+
+  return [...byFamily.entries()]
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([family, familyRows]) => {
+      const aggregateField = (field) =>
+        listValue(uniqueSorted(familyRows.flatMap((row) => splitSummaryList(row[field]))));
+      return [
+        family,
+        familyRows.length,
+        new Set(familyRows.map((row) => row.ini)).size,
+        aggregateField("python_modules"),
+        aggregateField("python_remap_functions"),
+        aggregateField("prolog_functions"),
+        aggregateField("epilog_functions"),
+        aggregateField("ngc_only_subpaths"),
+        aggregateField("python_runtime_evidence"),
+        flagValue(familyRows.some((row) => row.hal_process === "1")),
+        flagValue(familyRows.some((row) => row.ui_process === "1")),
+        flagValue(familyRows.some((row) => row.halui_mdi_process === "1")),
+        flagValue(familyRows.some((row) => row.execution_enabled !== "0")),
+        listValue(uniqueSorted(familyRows.flatMap((row) => splitSummaryList(row.notes)))),
+      ].map(tsvValue).join("\t");
+    });
+}
+
+function verifyPythonRemapFamilySummaryRows(rows, pythonRows) {
+  const expectedHeaders = [
+    "family",
+    "row_count",
+    "ini_count",
+    "python_modules",
+    "python_remap_functions",
+    "prolog_functions",
+    "epilog_functions",
+    "ngc_only_subpaths",
+    "python_runtime_evidence",
+    "hal_process",
+    "ui_process",
+    "halui_mdi_process",
+    "execution_enabled",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const expectedFamilies = uniqueSorted(pythonRows.map((row) => posix.dirname(row.path)));
+
+  assert.deepEqual(
+    parsedRows.map((row) => row.family).sort(),
+    expectedFamilies,
+    "python-remap family summary family set drift",
+  );
+  assert.equal(
+    parsedRows.reduce((count, row) => count + Number(row.row_count), 0),
+    pythonRows.length,
+    "python-remap family summary row counts must cover all Python rows",
+  );
+
+  const requiredFamilies = new Set([
+    "axis/laser",
+    "axis/remap/extend-builtins/nc_files",
+    "axis/vismach/5axis/table-rotary_spindle-rotary-nutating/demos",
+    "gmoccapy/macros",
+  ]);
+  for (const family of requiredFamilies) {
+    assert.ok(
+      parsedRows.some((row) => row.family === family),
+      `${family}: required Python-remap family summary row missing`,
+    );
+  }
+
+  for (const row of parsedRows) {
+    assert.ok(/^[1-9][0-9]*$/.test(row.row_count), `${row.family}: invalid row count`);
+    assert.ok(/^[1-9][0-9]*$/.test(row.ini_count), `${row.family}: invalid INI count`);
+    assert.notEqual(row.python_modules, "-", `${row.family}: family lacks Python module evidence`);
+    assert.equal(
+      [row.python_remap_functions, row.prolog_functions, row.epilog_functions]
+        .join(",")
+        .includes("@UNRESOLVED"),
+      false,
+      `${row.family}: family has unresolved Python callable owner`,
+    );
+    assert.notEqual(row.python_runtime_evidence, "-", `${row.family}: family lacks Python runtime evidence`);
+    assert.ok(
+      row.python_runtime_evidence.includes("interp_python_pycall_dispatch") &&
+        row.python_runtime_evidence.includes("python_plugin_callable_invoke"),
+      `${row.family}: family lacks LinuxCNC Python runtime owner evidence`,
+    );
+    assert.equal(row.execution_enabled, "0", `${row.family}: Python family execution must remain disabled`);
+    assert.ok(
+      row.notes.includes("dependency_inventory_only_no_execution"),
+      `${row.family}: Python family must remain inventory-only`,
+    );
+    for (const field of ["hal_process", "ui_process", "halui_mdi_process"]) {
+      assert.ok(["0", "1"].includes(row[field]), `${row.family}: invalid ${field} flag`);
+    }
+    if (row.ngc_only_subpaths !== "-") {
+      assert.ok(
+        row.notes.includes("mixed_ngc_and_python_remaps_do_not_promote_subpaths_blindly") ||
+          row.python_remap_functions === "-" && row.prolog_functions === "-" && row.epilog_functions === "-",
+        `${row.family}: NGC-only subpaths need mixed-remap note or pure NGC accounting`,
+      );
+    }
+  }
+
+  return parsedRows;
+}
+
+function pythonRuntimePhases(evidenceText) {
+  const evidence = new Set(splitSummaryList(evidenceText));
+  const phases = [];
+  const add = (evidenceKey, phase) => {
+    if (evidence.has(evidenceKey)) {
+      phases.push(phase);
+    }
+  };
+
+  add("python_plugin_initializes_python", "initialize_python");
+  add("python_plugin_ini_python_path", "apply_ini_python_path");
+  add("python_plugin_toplevel_exec_file", "execute_toplevel");
+  add("interp_python_callable_lookup", "callable_lookup");
+  add("interp_python_pycall_dispatch", "pycall_dispatch");
+  add("python_plugin_callable_invoke", "callable_invoke");
+  add("interp_python_remap_phases", "remap_phase_dispatch");
+  add("interp_python_generator_finish", "generator_finish");
+  add("interp_python_execute_runtime", "execute_python_runtime");
+  add("python_plugin_reload_on_change", "reload_on_change");
+
+  return phases;
+}
+
+function pythonRemapRuntimeContractRows(familyRows) {
+  return familyRows.map((row) => {
+    const callables = uniqueSorted([
+      ...splitSummaryList(row.python_remap_functions),
+      ...splitSummaryList(row.prolog_functions),
+      ...splitSummaryList(row.epilog_functions),
+    ]);
+    const processAssumptions = [];
+    if (row.hal_process === "1") {
+      processAssumptions.push("hal_process");
+    }
+    if (row.ui_process === "1") {
+      processAssumptions.push("ui_process");
+    }
+    if (row.halui_mdi_process === "1") {
+      processAssumptions.push("halui_mdi_process");
+    }
+    const notes = uniqueSorted([
+      ...splitSummaryList(row.notes),
+      "python_runtime_contract_only_no_execution",
+    ]);
+
+    return [
+      row.family,
+      "L4-PYTHON-REMAP",
+      "inventory_only",
+      row.row_count,
+      row.ini_count,
+      listValue(pythonRuntimePhases(row.python_runtime_evidence)),
+      row.python_modules,
+      listValue(callables),
+      row.ngc_only_subpaths,
+      listValue(processAssumptions),
+      row.python_runtime_evidence,
+      "python_runtime_owner_and_fixture",
+      "linuxcnc_python_runtime_boundary_not_js_semantics",
+      "browser_after_node_python_boundary_no_full_process_claim",
+      "pending",
+      "0",
+      "0",
+      listValue(notes),
+    ].map(tsvValue).join("\t");
+  });
+}
+
+function verifyPythonRemapRuntimeContractRows(rows, familyRows) {
+  const expectedHeaders = [
+    "family",
+    "blocked",
+    "design_status",
+    "row_count",
+    "ini_count",
+    "runtime_phases",
+    "python_modules",
+    "python_callables",
+    "ngc_only_subpaths",
+    "process_assumptions",
+    "runtime_owner_evidence",
+    "required_native_proof",
+    "required_node_proof",
+    "required_browser_proof",
+    "proof_status",
+    "execution_enabled",
+    "promotion_allowed",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+
+  assert.deepEqual(
+    parsedRows.map((row) => row.family).sort(),
+    familyRows.map((row) => row.family).sort(),
+    "Python runtime contract family set drift",
+  );
+
+  const requiredFamilies = new Set([
+    "axis/laser",
+    "axis/remap/extend-builtins/nc_files",
+    "axis/vismach/5axis/table-rotary_spindle-rotary-nutating/demos",
+    "gmoccapy/macros",
+  ]);
+  for (const family of requiredFamilies) {
+    assert.ok(
+      parsedRows.some((row) => row.family === family),
+      `${family}: required Python runtime contract row missing`,
+    );
+  }
+
+  const familyByName = new Map(familyRows.map((row) => [row.family, row]));
+  for (const row of parsedRows) {
+    const family = familyByName.get(row.family);
+    assert.ok(family, `${row.family}: contract row lacks family summary`);
+    assert.equal(row.blocked, "L4-PYTHON-REMAP", `${row.family}: blocked kind drift`);
+    assert.equal(row.design_status, "inventory_only", `${row.family}: design status drift`);
+    assert.equal(row.row_count, family.row_count, `${row.family}: row count drift`);
+    assert.equal(row.ini_count, family.ini_count, `${row.family}: INI count drift`);
+    assert.notEqual(row.runtime_phases, "-", `${row.family}: missing runtime phases`);
+    for (const phase of [
+      "initialize_python",
+      "apply_ini_python_path",
+      "execute_toplevel",
+      "callable_lookup",
+      "pycall_dispatch",
+      "callable_invoke",
+      "remap_phase_dispatch",
+    ]) {
+      assert.ok(row.runtime_phases.includes(phase), `${row.family}: missing runtime phase ${phase}`);
+    }
+    assert.notEqual(row.python_modules, "-", `${row.family}: contract lacks Python modules`);
+    assert.notEqual(row.runtime_owner_evidence, "-", `${row.family}: contract lacks runtime owner evidence`);
+    assert.equal(row.required_native_proof, "python_runtime_owner_and_fixture", `${row.family}: native proof drift`);
+    assert.equal(row.required_node_proof, "linuxcnc_python_runtime_boundary_not_js_semantics", `${row.family}: Node proof drift`);
+    assert.equal(row.required_browser_proof, "browser_after_node_python_boundary_no_full_process_claim", `${row.family}: browser proof drift`);
+    assert.equal(row.proof_status, "pending", `${row.family}: proof status must remain pending`);
+    assert.equal(row.execution_enabled, "0", `${row.family}: Python contract must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.family}: Python contract must not allow promotion`);
+    assert.ok(
+      row.notes.includes("python_runtime_contract_only_no_execution") &&
+        row.notes.includes("dependency_inventory_only_no_execution"),
+      `${row.family}: missing non-execution notes`,
+    );
+    if (
+      family.python_remap_functions !== "-" ||
+      family.prolog_functions !== "-" ||
+      family.epilog_functions !== "-"
+    ) {
+      assert.notEqual(row.python_callables, "-", `${row.family}: contract lacks callable inventory`);
+    }
+    if (family.ngc_only_subpaths !== "-") {
+      assert.equal(row.ngc_only_subpaths, family.ngc_only_subpaths, `${row.family}: NGC-only subpath drift`);
+    }
+    const expectedProcessAssumptions = [];
+    if (family.hal_process === "1") {
+      expectedProcessAssumptions.push("hal_process");
+    }
+    if (family.ui_process === "1") {
+      expectedProcessAssumptions.push("ui_process");
+    }
+    if (family.halui_mdi_process === "1") {
+      expectedProcessAssumptions.push("halui_mdi_process");
+    }
+    assert.equal(
+      row.process_assumptions,
+      listValue(expectedProcessAssumptions),
+      `${row.family}: process assumption drift`,
+    );
+  }
+
+  return parsedRows;
+}
+
+function pythonRemapNativeRuntimeReadinessRows(contractRows) {
+  return contractRows.flatMap((contract) => {
+    const requirements = [
+      {
+        kind: "host_command",
+        requirement: "python3",
+        purpose: "provide_embedded_python_runtime_for_future_probe",
+        available: commandPath("python3") !== "",
+        evidence: commandPath("python3"),
+      },
+      {
+        kind: "host_command",
+        requirement: "linuxcnc",
+        purpose: "provide_linuxcnc_task_interpreter_python_context",
+        available: commandPath("linuxcnc") !== "",
+        evidence: commandPath("linuxcnc"),
+      },
+      {
+        kind: "linuxcnc_source_file",
+        requirement: "src/emc/rs274ngc/interp_python.cc",
+        purpose: "own_python_remap_phase_dispatch",
+        available: linuxCncSourcePathExists("src/emc/rs274ngc/interp_python.cc"),
+        evidence: "src/emc/rs274ngc/interp_python.cc",
+      },
+      {
+        kind: "linuxcnc_source_file",
+        requirement: "src/emc/pythonplugin/python_plugin.cc",
+        purpose: "own_python_plugin_lifecycle_and_callable_dispatch",
+        available: linuxCncSourcePathExists("src/emc/pythonplugin/python_plugin.cc"),
+        evidence: "src/emc/pythonplugin/python_plugin.cc",
+      },
+      ...splitSummaryList(contract.python_modules).map((modulePath) => ({
+        kind: "source_config_python_module",
+        requirement: modulePath,
+        purpose: "configured_python_module_dependency",
+        available: sourceConfigPathExists(modulePath),
+        evidence: `configs/sim/${modulePath}`,
+      })),
+    ];
+    const allAvailable = requirements.every((row) => row.available);
+    const nativeRuntimeStatus = allAvailable
+      ? "host_runtime_available_probe_not_implemented"
+      : "blocked_missing_host_runtime";
+
+    return requirements.map((row) => [
+      contract.family,
+      contract.blocked,
+      "linuxcnc_python_remap_runtime",
+      row.kind,
+      row.requirement,
+      row.purpose,
+      flagValue(row.available),
+      row.available ? row.evidence : "-",
+      nativeRuntimeStatus,
+      "native_python_runtime_probe_required",
+      "pending",
+      "0",
+      "0",
+      allAvailable
+        ? "runtime_requirements_available_but_probe_still_not_implemented"
+        : "missing_host_runtime_keep_python_remap_blocked",
+    ].map(tsvValue).join("\t"));
+  });
+}
+
+function verifyPythonRemapNativeRuntimeReadinessRows(rows, contractRows) {
+  const expectedHeaders = [
+    "family",
+    "blocked",
+    "required_runtime",
+    "requirement_kind",
+    "requirement",
+    "purpose",
+    "available",
+    "evidence",
+    "native_runtime_status",
+    "proof_kind",
+    "proof_status",
+    "execution_enabled",
+    "promotion_allowed",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const contractFamilies = contractRows.map((row) => row.family).sort();
+  const readinessFamilies = uniqueSorted(parsedRows.map((row) => row.family));
+
+  assert.deepEqual(
+    readinessFamilies,
+    contractFamilies,
+    "Python native runtime readiness family set drift",
+  );
+  assert.ok(
+    parsedRows.length > contractRows.length * 4,
+    "Python native runtime readiness must include host/source and module rows",
+  );
+
+  const rowsByFamily = new Map();
+  for (const row of parsedRows) {
+    const existing = rowsByFamily.get(row.family) ?? [];
+    existing.push(row);
+    rowsByFamily.set(row.family, existing);
+
+    assert.equal(row.blocked, "L4-PYTHON-REMAP", `${row.family}: Python readiness blocked kind drift`);
+    assert.equal(row.required_runtime, "linuxcnc_python_remap_runtime", `${row.family}: Python runtime drift`);
+    assert.ok(
+      [
+        "host_command",
+        "linuxcnc_source_file",
+        "source_config_python_module",
+      ].includes(row.requirement_kind),
+      `${row.family}: readiness kind drift`,
+    );
+    assert.notEqual(row.requirement, "-", `${row.family}: readiness requirement missing`);
+    assert.notEqual(row.purpose, "-", `${row.family}: readiness purpose missing`);
+    assert.ok(["0", "1"].includes(row.available), `${row.family}: invalid readiness availability`);
+    if (row.available === "1") {
+      assert.notEqual(row.evidence, "-", `${row.family}: available readiness row lacks evidence`);
+    }
+    assert.ok(
+      ["blocked_missing_host_runtime", "host_runtime_available_probe_not_implemented"].includes(row.native_runtime_status),
+      `${row.family}: invalid Python runtime readiness status`,
+    );
+    assert.equal(row.proof_kind, "native_python_runtime_probe_required", `${row.family}: proof kind drift`);
+    assert.equal(row.proof_status, "pending", `${row.family}: readiness proof must remain pending`);
+    assert.equal(row.execution_enabled, "0", `${row.family}: readiness must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.family}: readiness must not allow promotion`);
+    assert.ok(
+      row.notes.includes("keep_python_remap_blocked") ||
+        row.notes.includes("probe_still_not_implemented"),
+      `${row.family}: readiness must keep Python-remap blocked`,
+    );
+  }
+
+  const contractByFamily = new Map(contractRows.map((row) => [row.family, row]));
+  for (const [family, familyRows] of rowsByFamily) {
+    const contract = contractByFamily.get(family);
+    assert.ok(contract, `${family}: readiness row lacks contract`);
+    const requirements = new Set(familyRows.map((row) => row.requirement));
+    for (const requirement of [
+      "python3",
+      "linuxcnc",
+      "src/emc/rs274ngc/interp_python.cc",
+      "src/emc/pythonplugin/python_plugin.cc",
+      ...splitSummaryList(contract.python_modules),
+    ]) {
+      assert.ok(requirements.has(requirement), `${family}: missing readiness requirement ${requirement}`);
+    }
+    assert.ok(
+      familyRows.some((row) => row.requirement === "python3" && row.available === "1"),
+      `${family}: python3 must be available for Python runtime readiness`,
+    );
+    assert.ok(
+      familyRows.some((row) =>
+        row.requirement === "src/emc/rs274ngc/interp_python.cc" && row.available === "1",
+      ),
+      `${family}: interp_python.cc must be available for Python runtime readiness`,
+    );
+    assert.ok(
+      familyRows.some((row) =>
+        row.requirement === "src/emc/pythonplugin/python_plugin.cc" && row.available === "1",
+      ),
+      `${family}: python_plugin.cc must be available for Python runtime readiness`,
+    );
+    for (const modulePath of splitSummaryList(contract.python_modules)) {
+      assert.ok(
+        familyRows.some((row) => row.requirement === modulePath && row.available === "1"),
+        `${family}: configured Python module missing from source tree: ${modulePath}`,
+      );
+    }
+  }
+
+  return parsedRows;
+}
+
+function pythonRemapNativeRuntimeStatePlanRows({
+  contractRows,
+  readinessRows,
+  alignmentRows,
+}) {
+  const readinessByFamily = new Map();
+  for (const row of readinessRows) {
+    const existing = readinessByFamily.get(row.family) ?? [];
+    existing.push(row);
+    readinessByFamily.set(row.family, existing);
+  }
+
+  const alignmentByFamily = new Map();
+  for (const row of alignmentRows) {
+    for (const contract of contractRows) {
+      if (row.path === contract.family || row.path.startsWith(`${contract.family}/`)) {
+        const existing = alignmentByFamily.get(contract.family) ?? [];
+        existing.push(row);
+        alignmentByFamily.set(contract.family, existing);
+      }
+    }
+  }
+
+  return contractRows.map((contract) => {
+    const readiness = readinessByFamily.get(contract.family) ?? [];
+    const alignment = alignmentByFamily.get(contract.family) ?? [];
+    const readinessAvailableCount = readiness.filter((row) => row.available === "1").length;
+    const sourceAlignmentOk = (
+      alignment.length > 0 &&
+      alignment.every((row) =>
+        row.native_stdout_available === "1" &&
+          row.alignment_ok === "1" &&
+          row.execution_enabled === "0" &&
+          row.promotion_allowed === "0",
+      )
+    );
+    const requiredStateProbe = uniqueSorted([
+      ...splitSummaryList(contract.runtime_phases).map((phase) => `phase:${phase}`),
+      ...splitSummaryList(contract.python_modules).map((modulePath) => `module:${modulePath}`),
+      ...splitSummaryList(contract.python_callables).map((callable) => `callable:${callable}`),
+      ...splitSummaryList(contract.ngc_only_subpaths).map((subpath) => `ngc_only:${subpath}`),
+      ...splitSummaryList(contract.process_assumptions).map((process) => `process:${process}`),
+    ]);
+
+    return [
+      contract.family,
+      contract.blocked,
+      "linuxcnc_python_remap_runtime",
+      contract.runtime_phases,
+      contract.python_modules,
+      contract.python_callables,
+      contract.ngc_only_subpaths,
+      contract.process_assumptions,
+      "python3,linuxcnc,interp_python.cc,python_plugin.cc,configured_python_modules",
+      String(readiness.length),
+      String(readinessAvailableCount),
+      "python-remap-native-runtime-alignment.tsv,python-remap-native-runtime-readiness.tsv",
+      flagValue(sourceAlignmentOk),
+      "pending_native_python_runtime_probe",
+      listValue(requiredStateProbe),
+      "native_python_runtime_state_probe_required",
+      "pending",
+      "0",
+      "0",
+      listValue(uniqueSorted([
+        ...splitSummaryList(contract.notes),
+        "native_runtime_not_executed_keep_python_remap_blocked",
+      ])),
+    ].map(tsvValue).join("\t");
+  });
+}
+
+function verifyPythonRemapNativeRuntimeStatePlanRows({
+  rows,
+  contractRows,
+  readinessRows,
+}) {
+  const expectedHeaders = [
+    "family",
+    "blocked",
+    "required_runtime",
+    "runtime_phases",
+    "python_modules",
+    "python_callables",
+    "ngc_only_subpaths",
+    "process_assumptions",
+    "required_environment",
+    "readiness_requirement_count",
+    "readiness_available_count",
+    "source_alignment_artifacts",
+    "source_alignment_ok",
+    "native_runtime_status",
+    "required_state_probe",
+    "proof_kind",
+    "proof_status",
+    "execution_enabled",
+    "promotion_allowed",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const readinessCountByFamily = new Map();
+  for (const row of readinessRows) {
+    readinessCountByFamily.set(row.family, (readinessCountByFamily.get(row.family) ?? 0) + 1);
+  }
+  const readinessAvailableByFamily = new Map();
+  for (const row of readinessRows.filter((entry) => entry.available === "1")) {
+    readinessAvailableByFamily.set(row.family, (readinessAvailableByFamily.get(row.family) ?? 0) + 1);
+  }
+
+  assert.deepEqual(
+    parsedRows.map((row) => row.family).sort(),
+    contractRows.map((row) => row.family).sort(),
+    "Python native runtime state plan family set drift",
+  );
+  assert.equal(parsedRows.length, 12, "Python native runtime state plan must cover every blocked family");
+
+  const contractByFamily = new Map(contractRows.map((row) => [row.family, row]));
+  for (const row of parsedRows) {
+    const contract = contractByFamily.get(row.family);
+    assert.ok(contract, `${row.family}: state plan lacks contract row`);
+    assert.equal(row.blocked, "L4-PYTHON-REMAP", `${row.family}: state plan blocked kind drift`);
+    assert.equal(row.required_runtime, "linuxcnc_python_remap_runtime", `${row.family}: required runtime drift`);
+    assert.equal(row.runtime_phases, contract.runtime_phases, `${row.family}: runtime phase drift`);
+    assert.equal(row.python_modules, contract.python_modules, `${row.family}: Python module drift`);
+    assert.equal(row.python_callables, contract.python_callables, `${row.family}: Python callable drift`);
+    assert.equal(row.ngc_only_subpaths, contract.ngc_only_subpaths, `${row.family}: NGC-only subpath drift`);
+    assert.equal(row.process_assumptions, contract.process_assumptions, `${row.family}: process assumption drift`);
+    for (const token of [
+      "python3",
+      "linuxcnc",
+      "interp_python.cc",
+      "python_plugin.cc",
+      "configured_python_modules",
+    ]) {
+      assert.ok(row.required_environment.includes(token), `${row.family}: missing environment token ${token}`);
+    }
+    assert.equal(
+      row.readiness_requirement_count,
+      String(readinessCountByFamily.get(row.family) ?? 0),
+      `${row.family}: readiness requirement count drift`,
+    );
+    assert.equal(
+      row.readiness_available_count,
+      String(readinessAvailableByFamily.get(row.family) ?? 0),
+      `${row.family}: readiness available count drift`,
+    );
+    assert.ok(
+      row.source_alignment_artifacts.includes("python-remap-native-runtime-alignment.tsv") &&
+        row.source_alignment_artifacts.includes("python-remap-native-runtime-readiness.tsv"),
+      `${row.family}: missing source alignment artifact references`,
+    );
+    assert.equal(row.source_alignment_ok, "1", `${row.family}: source alignment must be complete before runtime plan`);
+    assert.equal(row.native_runtime_status, "pending_native_python_runtime_probe", `${row.family}: runtime status drift`);
+    for (const phase of [
+      "phase:initialize_python",
+      "phase:apply_ini_python_path",
+      "phase:execute_toplevel",
+      "phase:callable_lookup",
+      "phase:pycall_dispatch",
+      "phase:callable_invoke",
+      "phase:remap_phase_dispatch",
+    ]) {
+      assert.ok(row.required_state_probe.includes(phase), `${row.family}: missing required probe ${phase}`);
+    }
+    assert.ok(row.required_state_probe.includes("module:"), `${row.family}: state plan lacks module proof target`);
+    if (contract.python_callables !== "-") {
+      assert.ok(row.required_state_probe.includes("callable:"), `${row.family}: state plan lacks callable proof target`);
+    }
+    if (contract.ngc_only_subpaths !== "-") {
+      assert.ok(row.required_state_probe.includes("ngc_only:"), `${row.family}: state plan lacks NGC-only proof target`);
+    }
+    assert.equal(row.proof_kind, "native_python_runtime_state_probe_required", `${row.family}: proof kind drift`);
+    assert.equal(row.proof_status, "pending", `${row.family}: runtime state plan must remain pending`);
+    assert.equal(row.execution_enabled, "0", `${row.family}: runtime state plan must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.family}: runtime state plan must not allow promotion`);
+    assert.ok(
+      row.notes.includes("native_runtime_not_executed_keep_python_remap_blocked"),
+      `${row.family}: runtime state plan must keep Python-remap blocked`,
+    );
+  }
+
+  return parsedRows;
+}
+
+function pythonRemapNativeRuntimeFixturePlanRows(statePlanRows) {
+  const selectedFamily = "axis/remap/stop-lookahead/nc_files";
+  const row = statePlanRows.find((entry) => entry.family === selectedFamily);
+  assert.ok(row, `${selectedFamily}: missing Python runtime state-plan row`);
+
+  return [[
+    row.family,
+    row.blocked,
+    row.required_runtime,
+    "selected_minimal_python_runtime_lifecycle_fixture",
+    "stop_lookahead_python_runtime_lifecycle",
+    "no_python_callables_no_ngc_only_subpaths",
+    row.runtime_phases,
+    row.python_modules,
+    row.process_assumptions,
+    row.required_environment,
+    row.readiness_requirement_count,
+    row.readiness_available_count,
+    row.source_alignment_artifacts,
+    row.source_alignment_ok,
+    listValue([
+      "initialize_python",
+      "apply_ini_python_path",
+      "execute_toplevel",
+      "callable_lookup",
+      "pycall_dispatch",
+      "callable_invoke",
+      "remap_phase_dispatch",
+      "generator_finish",
+      "execute_python_runtime",
+      "reload_on_change",
+    ]),
+    listValue(splitSummaryList(row.python_modules).map((modulePath) => `module:${modulePath}`)),
+    "linuxcnc_python_runtime_lifecycle_probe_required",
+    "pending",
+    "0",
+    "0",
+    "fixture_plan_only_no_python_execution_no_promotion",
+  ].map(tsvValue).join("\t")];
+}
+
+function verifyPythonRemapNativeRuntimeFixturePlanRows(rows, statePlanRows) {
+  const expectedHeaders = [
+    "family",
+    "blocked",
+    "required_runtime",
+    "selection_reason",
+    "fixture_id",
+    "fixture_scope",
+    "runtime_phases",
+    "python_modules",
+    "process_assumptions",
+    "required_environment",
+    "readiness_requirement_count",
+    "readiness_available_count",
+    "source_alignment_artifacts",
+    "source_alignment_ok",
+    "expected_runtime_observations",
+    "expected_module_inputs",
+    "proof_kind",
+    "proof_status",
+    "execution_enabled",
+    "promotion_allowed",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+
+  assert.equal(parsedRows.length, 1, "Python runtime fixture plan must start with one fixture");
+  const row = parsedRows[0];
+  const statePlan = statePlanRows.find((entry) => entry.family === row.family);
+  assert.ok(statePlan, `${row.family}: fixture plan lacks state-plan source row`);
+  assert.equal(row.family, "axis/remap/stop-lookahead/nc_files", "Python fixture family drift");
+  assert.equal(row.blocked, "L4-PYTHON-REMAP", `${row.family}: fixture blocked kind drift`);
+  assert.equal(row.required_runtime, "linuxcnc_python_remap_runtime", `${row.family}: fixture runtime drift`);
+  assert.equal(
+    row.selection_reason,
+    "selected_minimal_python_runtime_lifecycle_fixture",
+    `${row.family}: fixture selection reason drift`,
+  );
+  assert.equal(row.fixture_id, "stop_lookahead_python_runtime_lifecycle", `${row.family}: fixture id drift`);
+  assert.equal(row.fixture_scope, "no_python_callables_no_ngc_only_subpaths", `${row.family}: fixture scope drift`);
+  assert.equal(row.runtime_phases, statePlan.runtime_phases, `${row.family}: fixture runtime phase drift`);
+  assert.equal(row.python_modules, statePlan.python_modules, `${row.family}: fixture module drift`);
+  assert.equal(row.process_assumptions, "hal_process", `${row.family}: fixture process assumption drift`);
+  assert.equal(statePlan.python_callables, "-", `${row.family}: fixture must avoid Python callable rows`);
+  assert.equal(statePlan.ngc_only_subpaths, "-", `${row.family}: fixture must avoid NGC-only subpaths`);
+  for (const token of [
+    "python3",
+    "linuxcnc",
+    "interp_python.cc",
+    "python_plugin.cc",
+    "configured_python_modules",
+  ]) {
+    assert.ok(row.required_environment.includes(token), `${row.family}: missing fixture environment ${token}`);
+  }
+  assert.equal(row.readiness_requirement_count, statePlan.readiness_requirement_count, `${row.family}: readiness count drift`);
+  assert.equal(row.readiness_available_count, statePlan.readiness_available_count, `${row.family}: readiness availability drift`);
+  assert.ok(
+    row.source_alignment_artifacts.includes("python-remap-native-runtime-alignment.tsv") &&
+      row.source_alignment_artifacts.includes("python-remap-native-runtime-readiness.tsv"),
+    `${row.family}: fixture source artifacts drift`,
+  );
+  assert.equal(row.source_alignment_ok, "1", `${row.family}: fixture source alignment must be ready`);
+  for (const observation of [
+    "initialize_python",
+    "apply_ini_python_path",
+    "execute_toplevel",
+    "callable_lookup",
+    "pycall_dispatch",
+    "callable_invoke",
+    "remap_phase_dispatch",
+  ]) {
+    assert.ok(row.expected_runtime_observations.includes(observation), `${row.family}: missing observation ${observation}`);
+  }
+  for (const modulePath of splitSummaryList(row.python_modules)) {
+    assert.ok(
+      row.expected_module_inputs.includes(`module:${modulePath}`),
+      `${row.family}: missing module input ${modulePath}`,
+    );
+  }
+  assert.equal(row.proof_kind, "linuxcnc_python_runtime_lifecycle_probe_required", `${row.family}: fixture proof kind drift`);
+  assert.equal(row.proof_status, "pending", `${row.family}: fixture proof must remain pending`);
+  assert.equal(row.execution_enabled, "0", `${row.family}: fixture must not enable execution`);
+  assert.equal(row.promotion_allowed, "0", `${row.family}: fixture must not allow promotion`);
+  assert.ok(row.notes.includes("no_python_execution"), `${row.family}: fixture must remain non-executing`);
+
+  return parsedRows;
+}
+
+function runtimeBoundaryNativeAlignmentSummaryRows({
+  userMRows,
+  toolDbRows,
+  pythonRows,
+}) {
+  const groups = [
+    {
+      boundaryClass: "L4-USER-M-PROCESS",
+      boundaryKind: "external_user_m_process",
+      artifact: "user-m-process-native-state-alignment.tsv",
+      rows: userMRows,
+    },
+    {
+      boundaryClass: "L4-TOOL-DB",
+      boundaryKind: "tool_database_process",
+      artifact: "tool-db-process-native-protocol-alignment.tsv",
+      rows: toolDbRows,
+    },
+    {
+      boundaryClass: "L4-PYTHON-REMAP",
+      boundaryKind: "python_runtime",
+      artifact: "python-remap-native-runtime-alignment.tsv",
+      rows: pythonRows,
+    },
+  ];
+
+  return groups.map((group) => {
+    const nativeAvailableCount = group.rows.filter((row) => row.native_stdout_available === "1").length;
+    const alignmentOkCount = group.rows.filter((row) => row.alignment_ok === "1").length;
+    const pendingCount = group.rows.filter((row) => row.proof_status === "pending").length;
+    const executionDisabledCount = group.rows.filter((row) => row.execution_enabled === "0").length;
+    const promotionDisabledCount = group.rows.filter((row) => row.promotion_allowed === "0").length;
+    const rowCount = group.rows.length;
+    const summaryOk = (
+      rowCount > 0 &&
+      nativeAvailableCount === rowCount &&
+      alignmentOkCount === rowCount &&
+      pendingCount === rowCount &&
+      executionDisabledCount === rowCount &&
+      promotionDisabledCount === rowCount
+    );
+
+    return [
+      group.boundaryClass,
+      group.boundaryKind,
+      String(rowCount),
+      String(nativeAvailableCount),
+      String(alignmentOkCount),
+      String(pendingCount),
+      String(executionDisabledCount),
+      String(promotionDisabledCount),
+      group.artifact,
+      flagValue(summaryOk),
+      "native_alignment_summary_only_no_runtime_execution",
+    ].map(tsvValue).join("\t");
+  });
+}
+
+function verifyRuntimeBoundaryNativeAlignmentSummaryRows(rows) {
+  const expectedHeaders = [
+    "boundary_class",
+    "boundary_kind",
+    "row_count",
+    "native_stdout_available_count",
+    "alignment_ok_count",
+    "pending_count",
+    "execution_disabled_count",
+    "promotion_disabled_count",
+    "artifact",
+    "summary_ok",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const expectedClasses = [
+    "L4-USER-M-PROCESS",
+    "L4-TOOL-DB",
+    "L4-PYTHON-REMAP",
+  ];
+
+  assert.deepEqual(
+    parsedRows.map((row) => row.boundary_class),
+    expectedClasses,
+    "runtime native alignment summary class order drift",
+  );
+
+  for (const row of parsedRows) {
+    assert.ok(/^[1-9][0-9]*$/.test(row.row_count), `${row.boundary_class}: invalid row count`);
+    assert.equal(row.native_stdout_available_count, row.row_count, `${row.boundary_class}: native stdout availability incomplete`);
+    assert.equal(row.alignment_ok_count, row.row_count, `${row.boundary_class}: native alignment incomplete`);
+    assert.equal(row.pending_count, row.row_count, `${row.boundary_class}: native alignment rows must remain pending`);
+    assert.equal(row.execution_disabled_count, row.row_count, `${row.boundary_class}: native alignment rows must not enable execution`);
+    assert.equal(row.promotion_disabled_count, row.row_count, `${row.boundary_class}: native alignment rows must not allow promotion`);
+    assert.equal(row.summary_ok, "1", `${row.boundary_class}: runtime native alignment summary failed`);
+    assert.ok(row.artifact.endsWith(".tsv"), `${row.boundary_class}: alignment artifact missing`);
+    assert.ok(
+      row.notes.includes("no_runtime_execution"),
+      `${row.boundary_class}: alignment summary must remain non-executing`,
+    );
+  }
+
+  return parsedRows;
+}
+
+function runtimeBoundaryContractSummaryRows({
+  userMRows,
+  toolDbRows,
+  pythonRows,
+  runtimeNativeAlignmentRows,
+}) {
+  const runtimeAlignmentByKind = new Map(
+    runtimeNativeAlignmentRows.map((row) => [row.boundary_kind, row]),
+  );
+  const groups = [
+    {
+      boundaryClass: "L4-USER-M-PROCESS",
+      boundaryKind: "external_user_m_process",
+      contractArtifact: "user-m-process-transition-plan.tsv",
+      contractScope: "millturn_m428_m429_state_transition",
+      rows: userMRows,
+    },
+    {
+      boundaryClass: "L4-TOOL-DB",
+      boundaryKind: "tool_database_process",
+      contractArtifact: "tool-db-process-transaction-plan.tsv",
+      contractScope: "db_demo_tooldata_transaction_protocol",
+      rows: toolDbRows,
+    },
+    {
+      boundaryClass: "L4-PYTHON-REMAP",
+      boundaryKind: "python_runtime",
+      contractArtifact: "python-remap-runtime-contract.tsv",
+      contractScope: "python_remap_family_runtime_contracts",
+      rows: pythonRows,
+    },
+  ];
+
+  return groups.map((group) => {
+    const runtimeAlignment = runtimeAlignmentByKind.get(group.boundaryKind);
+    const rowCount = group.rows.length;
+    const pendingCount = group.rows.filter((row) => row.proof_status === "pending").length;
+    const executionDisabledCount = group.rows.filter((row) => row.execution_enabled === "0").length;
+    const promotionDisabledCount = group.rows.filter((row) => row.promotion_allowed === "0").length;
+    const contractOk = (
+      rowCount > 0 &&
+      pendingCount === rowCount &&
+      executionDisabledCount === rowCount &&
+      promotionDisabledCount === rowCount &&
+      runtimeAlignment?.summary_ok === "1"
+    );
+
+    return [
+      group.boundaryClass,
+      group.boundaryKind,
+      group.contractArtifact,
+      group.contractScope,
+      String(rowCount),
+      String(pendingCount),
+      String(executionDisabledCount),
+      String(promotionDisabledCount),
+      runtimeAlignment?.artifact ?? "-",
+      runtimeAlignment?.row_count ?? "0",
+      runtimeAlignment?.summary_ok ?? "0",
+      flagValue(contractOk),
+      "contract_summary_only_no_runtime_execution_no_promotion",
+    ].map(tsvValue).join("\t");
+  });
+}
+
+function verifyRuntimeBoundaryContractSummaryRows(rows) {
+  const expectedHeaders = [
+    "boundary_class",
+    "boundary_kind",
+    "contract_artifact",
+    "contract_scope",
+    "contract_row_count",
+    "pending_count",
+    "execution_disabled_count",
+    "promotion_disabled_count",
+    "runtime_alignment_artifact",
+    "runtime_alignment_row_count",
+    "runtime_alignment_ok",
+    "contract_ok",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const expected = new Map([
+    [
+      "L4-USER-M-PROCESS",
+      {
+        boundaryKind: "external_user_m_process",
+        contractArtifact: "user-m-process-transition-plan.tsv",
+        contractScope: "millturn_m428_m429_state_transition",
+        rowCount: "2",
+        runtimeArtifact: "user-m-process-native-state-alignment.tsv",
+      },
+    ],
+    [
+      "L4-TOOL-DB",
+      {
+        boundaryKind: "tool_database_process",
+        contractArtifact: "tool-db-process-transaction-plan.tsv",
+        contractScope: "db_demo_tooldata_transaction_protocol",
+        rowCount: "5",
+        runtimeArtifact: "tool-db-process-native-protocol-alignment.tsv",
+      },
+    ],
+    [
+      "L4-PYTHON-REMAP",
+      {
+        boundaryKind: "python_runtime",
+        contractArtifact: "python-remap-runtime-contract.tsv",
+        contractScope: "python_remap_family_runtime_contracts",
+        rowCount: "12",
+        runtimeArtifact: "python-remap-native-runtime-alignment.tsv",
+      },
+    ],
+  ]);
+
+  assert.deepEqual(
+    parsedRows.map((row) => row.boundary_class),
+    [...expected.keys()],
+    "runtime boundary contract summary class order drift",
+  );
+
+  for (const row of parsedRows) {
+    const expectedRow = expected.get(row.boundary_class);
+    assert.ok(expectedRow, `${row.boundary_class}: unexpected contract summary row`);
+    assert.equal(row.boundary_kind, expectedRow.boundaryKind, `${row.boundary_class}: boundary kind drift`);
+    assert.equal(row.contract_artifact, expectedRow.contractArtifact, `${row.boundary_class}: contract artifact drift`);
+    assert.equal(row.contract_scope, expectedRow.contractScope, `${row.boundary_class}: contract scope drift`);
+    assert.equal(row.contract_row_count, expectedRow.rowCount, `${row.boundary_class}: contract row count drift`);
+    assert.equal(row.pending_count, row.contract_row_count, `${row.boundary_class}: contract rows must remain pending`);
+    assert.equal(row.execution_disabled_count, row.contract_row_count, `${row.boundary_class}: contract rows must not enable execution`);
+    assert.equal(row.promotion_disabled_count, row.contract_row_count, `${row.boundary_class}: contract rows must not allow promotion`);
+    assert.equal(row.runtime_alignment_artifact, expectedRow.runtimeArtifact, `${row.boundary_class}: runtime alignment artifact drift`);
+    assert.ok(/^[1-9][0-9]*$/.test(row.runtime_alignment_row_count), `${row.boundary_class}: invalid runtime alignment row count`);
+    assert.equal(row.runtime_alignment_ok, "1", `${row.boundary_class}: runtime alignment summary failed`);
+    assert.equal(row.contract_ok, "1", `${row.boundary_class}: contract summary failed`);
+    assert.ok(
+      row.notes.includes("no_runtime_execution") && row.notes.includes("no_promotion"),
+      `${row.boundary_class}: contract summary must remain non-executing`,
+    );
+  }
+
+  return parsedRows;
+}
+
+function boundaryPhaseCompletionSummaryRows({
+  boundaryRows,
+  iniBoundaryRows,
+  blockedRows,
+  fullProcessRows,
+  userMTransitionRows,
+  userMRuntimeStatePlanRows,
+  userMRuntimeReadinessRows,
+  userMRuntimeProbeGateRows,
+  toolDbTransactionRows,
+  toolDbRuntimeReadinessRows,
+  pythonFamilyRows,
+  pythonRuntimeContractRows,
+  pythonRuntimeReadinessRows,
+  pythonRuntimeStatePlanRows,
+  pythonRuntimeFixturePlanRows,
+  runtimeContractSummaryRows,
+  nativeProofAlignmentRows,
+  nativeRuntimeProbeRows,
+  runtimeNativeAlignmentRows,
+  trackedRows,
+  inventoryRows,
+}) {
+  const hardBlockedKinds = new Set([
+    "L4-TOOL-DB",
+    "L4-USER-M-PROCESS",
+    "L4-PYTHON-REMAP",
+  ]);
+  const vendoredBoundaryRows = iniBoundaryRows.filter((row) => row.vendored === "1");
+  const hardBlockedRows = blockedRows.filter((row) => hardBlockedKinds.has(row.blocked));
+  const safeRepresentatives = [
+    "axis/gladevcp/probe.ngc",
+    "woodpecker/on_abort.ngc",
+    "axis/vismach/puma/puma_cube.ngc",
+    "axis/vismach/melfa-sim/example.ngc",
+  ];
+  const trackedByPath = new Map(trackedRows.map((row) => [row.path, row]));
+  const inventoryByPath = new Map(inventoryRows.map((row) => {
+    const [path, inventoryStatus, reason] = row.split("\t");
+    return [path, { inventoryStatus, reason }];
+  }));
+
+  const vendoredBoundaryOk = vendoredBoundaryRows.every((row) => row.report_available === "1");
+  const hardBlockedEvidenceOk = hardBlockedRows.every((row) => {
+    if (row.blocked === "L4-TOOL-DB") {
+      return row.db_program !== "-" && row.tool_db_protocol_evidence !== "-";
+    }
+    if (row.blocked === "L4-USER-M-PROCESS") {
+      return (
+        row.user_m_execution_codes !== "-" &&
+        row.user_m_process_files !== "-" &&
+        row.user_m_process_effects !== "-"
+      );
+    }
+    if (row.blocked === "L4-PYTHON-REMAP") {
+      return (
+        row.python_modules !== "-" ||
+        row.python_remap_functions !== "-" ||
+        row.prolog_functions !== "-" ||
+        row.epilog_functions !== "-"
+      );
+    }
+    return false;
+  });
+  const safeRepresentativeOk = safeRepresentatives.every((path) => {
+    const boundary = boundaryRows.find((row) => row.path === path);
+    const tracked = trackedByPath.get(path);
+    return (
+      boundary &&
+      tracked &&
+      boundary.blocked === "-" &&
+      boundary.dependencies !== "-" &&
+      tracked.layer4Node === "REP" &&
+      tracked.layer4Browser === "REP"
+    );
+  });
+  const blockedFamiliesUnpromotedOk = hardBlockedRows.every((row) => {
+    const tracked = trackedByPath.get(row.path);
+    const inventory = inventoryByPath.get(row.path);
+    return (
+      tracked &&
+      inventory &&
+      tracked.layer4Node === "-" &&
+      tracked.layer4Browser === "-" &&
+      inventory.inventoryStatus === "SKIP" &&
+      inventory.reason === row.blocked
+    );
+  }) && fullProcessRows.every((row) => row.execution_enabled === "0") &&
+    pythonFamilyRows.every((row) => row.execution_enabled === "0");
+  const linuxCncRuntimeOwnerProofOk = (
+    hardBlockedRows
+      .filter((row) => row.blocked === "L4-USER-M-PROCESS")
+      .every((row) =>
+        row.user_m_process_effects.includes("tcl_hal_runtime") &&
+        row.user_m_process_effects.includes("kinstype_guard") &&
+        row.user_m_process_effects.includes("ini_axis_limit_hal_setp"),
+      ) &&
+    hardBlockedRows
+      .filter((row) => row.blocked === "L4-TOOL-DB")
+      .every((row) =>
+        row.tool_db_protocol_evidence.includes("tooldata_db_v2_1_handshake") &&
+        row.tool_db_protocol_evidence.includes("tooldata_db_getall_g_fini") &&
+        row.tool_db_protocol_evidence.includes("tooldata_db_notify_l_u_p"),
+      ) &&
+    pythonFamilyRows.every((row) =>
+      row.python_runtime_evidence.includes("interp_python_pycall_dispatch") &&
+      row.python_runtime_evidence.includes("python_plugin_callable_invoke"),
+    )
+  );
+  const nativeSourceProofAlignmentOk = nativeProofAlignmentRows.every((row) => {
+    if (row.native_summary_available === "0") {
+      return row.alignment_ok === "0" &&
+        row.notes === "native_source_proof_summary_unavailable";
+    }
+    return row.alignment_ok === "1" &&
+      row.proof_value === "1" &&
+      row.execution_enabled === "0" &&
+      row.promotion_allowed === "0" &&
+      row.matching_worklist_count !== "0" &&
+      row.matching_native_gate_count !== "0";
+  });
+  const runtimeNativeAlignmentOk = runtimeNativeAlignmentRows.every((row) =>
+    row.summary_ok === "1" &&
+      row.row_count !== "0" &&
+      row.native_stdout_available_count === row.row_count &&
+      row.alignment_ok_count === row.row_count &&
+      row.pending_count === row.row_count &&
+      row.execution_disabled_count === row.row_count &&
+      row.promotion_disabled_count === row.row_count,
+  );
+  const userMTransitionContractOk = (
+    userMTransitionRows.length === 2 &&
+    userMTransitionRows.every((row) =>
+      row.blocked === "L4-USER-M-PROCESS" &&
+        row.proof_status === "pending" &&
+        row.execution_enabled === "0" &&
+        row.promotion_allowed === "0" &&
+        row.switchkins_output_pin === "motion.analog-out-03" &&
+        row.expected_state_pins !== "-",
+    )
+  );
+  const userMRuntimeStatePlanOk = (
+    userMRuntimeStatePlanRows.length === 2 &&
+    userMRuntimeStatePlanRows.every((row) =>
+      row.blocked === "L4-USER-M-PROCESS" &&
+        row.required_runtime === "linuxcnc_task_hal_tcl_user_m_process" &&
+        row.source_alignment_ok === "1" &&
+        row.native_runtime_status === "pending_native_hal_tcl_process_probe" &&
+        row.proof_status === "pending" &&
+        row.execution_enabled === "0" &&
+        row.promotion_allowed === "0" &&
+        row.expected_state_values !== "-",
+    )
+  );
+  const userMRuntimeReadinessOk = (
+    userMRuntimeReadinessRows.length === 4 &&
+    userMRuntimeReadinessRows.every((row) =>
+      row.blocked === "L4-USER-M-PROCESS" &&
+        row.required_runtime === "linuxcnc_task_hal_tcl_user_m_process" &&
+        row.requirement_kind === "host_command" &&
+        ["0", "1"].includes(row.available) &&
+        row.proof_status === "pending" &&
+        row.execution_enabled === "0" &&
+        row.promotion_allowed === "0",
+    )
+  );
+  const userMRuntimeProbeGateOk = (
+    userMRuntimeProbeGateRows.length === 2 &&
+    userMRuntimeProbeGateRows.every((row) =>
+      row.blocked === "L4-USER-M-PROCESS" &&
+        row.required_runtime === "linuxcnc_task_hal_tcl_user_m_process" &&
+        row.source_proof_ready === "1" &&
+        ["0", "1"].includes(row.runtime_ready) &&
+        ["blocked_missing_host_runtime", "ready_to_implement_probe"].includes(row.gate_status) &&
+        row.proof_status === "pending" &&
+        row.execution_enabled === "0" &&
+        row.promotion_allowed === "0",
+    )
+  );
+  const toolDbTransactionContractOk = (
+    toolDbTransactionRows.length === 5 &&
+    toolDbTransactionRows.every((row) =>
+      row.blocked === "L4-TOOL-DB" &&
+        row.proof_status === "pending" &&
+        row.execution_enabled === "0" &&
+        row.promotion_allowed === "0" &&
+        row.db_program === "./db_nonran.py" &&
+        row.protocol_message !== "-" &&
+        row.db_program_callback !== "-" &&
+        row.state_targets !== "-",
+    )
+  );
+  const toolDbRuntimeReadinessOk = (
+    toolDbRuntimeReadinessRows.length === 7 &&
+    toolDbRuntimeReadinessRows.every((row) =>
+      row.blocked === "L4-TOOL-DB" &&
+        row.required_runtime === "linuxcnc_tooldata_db_process" &&
+        ["host_command", "source_config_file", "linuxcnc_python_module"].includes(row.requirement_kind) &&
+        ["0", "1"].includes(row.available) &&
+        row.proof_status === "pending" &&
+        row.execution_enabled === "0" &&
+        row.promotion_allowed === "0",
+    )
+  );
+  const pythonRuntimeContractOk = (
+    pythonRuntimeContractRows.length === pythonFamilyRows.length &&
+    pythonRuntimeContractRows.every((row) =>
+      row.blocked === "L4-PYTHON-REMAP" &&
+        row.design_status === "inventory_only" &&
+        row.proof_status === "pending" &&
+        row.execution_enabled === "0" &&
+        row.promotion_allowed === "0" &&
+        row.runtime_phases !== "-" &&
+        row.python_modules !== "-" &&
+        row.runtime_owner_evidence !== "-",
+    )
+  );
+  const pythonRuntimeReadinessOk = (
+    pythonRuntimeReadinessRows.length > pythonRuntimeContractRows.length * 4 &&
+    pythonRuntimeReadinessRows.every((row) =>
+      row.blocked === "L4-PYTHON-REMAP" &&
+        row.required_runtime === "linuxcnc_python_remap_runtime" &&
+        ["host_command", "linuxcnc_source_file", "source_config_python_module"].includes(row.requirement_kind) &&
+        ["0", "1"].includes(row.available) &&
+        row.proof_status === "pending" &&
+        row.execution_enabled === "0" &&
+        row.promotion_allowed === "0",
+    )
+  );
+  const pythonRuntimeStatePlanOk = (
+    pythonRuntimeStatePlanRows.length === pythonRuntimeContractRows.length &&
+    pythonRuntimeStatePlanRows.every((row) =>
+      row.blocked === "L4-PYTHON-REMAP" &&
+        row.required_runtime === "linuxcnc_python_remap_runtime" &&
+        row.source_alignment_ok === "1" &&
+        row.native_runtime_status === "pending_native_python_runtime_probe" &&
+        row.required_state_probe !== "-" &&
+        row.proof_status === "pending" &&
+        row.execution_enabled === "0" &&
+        row.promotion_allowed === "0",
+    )
+  );
+  const pythonRuntimeFixturePlanOk = (
+    pythonRuntimeFixturePlanRows.length === 1 &&
+    pythonRuntimeFixturePlanRows.every((row) =>
+      row.family === "axis/remap/stop-lookahead/nc_files" &&
+        row.blocked === "L4-PYTHON-REMAP" &&
+        row.required_runtime === "linuxcnc_python_remap_runtime" &&
+        row.fixture_id === "stop_lookahead_python_runtime_lifecycle" &&
+        row.proof_status === "pending" &&
+        row.execution_enabled === "0" &&
+        row.promotion_allowed === "0",
+    )
+  );
+  const runtimeContractSummaryOk = (
+    runtimeContractSummaryRows.length === 3 &&
+    runtimeContractSummaryRows.every((row) =>
+      row.contract_ok === "1" &&
+        row.pending_count === row.contract_row_count &&
+        row.execution_disabled_count === row.contract_row_count &&
+        row.promotion_disabled_count === row.contract_row_count &&
+        row.runtime_alignment_ok === "1",
+    )
+  );
+  const nativeRuntimeProbeSummaryOk = (
+    nativeRuntimeProbeRows.length === 3 &&
+    nativeRuntimeProbeRows.every((row) =>
+      row.source_proof_ready === "1" &&
+        ["0", "1"].includes(row.runtime_ready) &&
+        [
+          "skipped_missing_host_runtime",
+          "ready_disabled_by_default",
+          "not_implemented_full_process_guard",
+          "runtime_state_probe_passed",
+          "runtime_protocol_probe_passed",
+          "runtime_lifecycle_probe_passed",
+        ].includes(row.probe_status) &&
+        row.execution_enabled === "0" &&
+        row.promotion_allowed === "0",
+    )
+  );
+
+  return [
+    [
+      "vendored_runtime_boundary_reports",
+      flagValue(vendoredBoundaryOk),
+      String(vendoredBoundaryRows.length),
+      "vendored INI rows have classifier reports in ini-boundary-summary.tsv",
+    ],
+    [
+      "hard_block_dependency_evidence",
+      flagValue(hardBlockedEvidenceOk),
+      String(hardBlockedRows.length),
+      "hard blocked rows carry dependency-backed evidence, not path-only labels",
+    ],
+    [
+      "safe_hal_ui_representatives",
+      flagValue(safeRepresentativeOk),
+      String(safeRepresentatives.length),
+      "safe HAL/UI representatives remain Node/browser reps with declared process dependencies",
+    ],
+    [
+      "blocked_families_not_promoted",
+      flagValue(blockedFamiliesUnpromotedOk),
+      String(hardBlockedRows.length),
+      "blocked families remain skipped/non-representative with execution disabled until a LinuxCNC-owned boundary exists",
+    ],
+    [
+      "linuxcnc_runtime_owner_proof",
+      flagValue(linuxCncRuntimeOwnerProofOk),
+      String(hardBlockedRows.length + pythonFamilyRows.length),
+      "blocked runtime families carry LinuxCNC-owned user-M, tool DB, and Python runtime proof fields",
+    ],
+    [
+      "native_source_proof_alignment",
+      flagValue(nativeSourceProofAlignmentOk),
+      String(nativeProofAlignmentRows.length),
+      "native source proof summary is consumed by generated worklist/native proof gates when available",
+    ],
+    [
+      "runtime_native_alignment_artifacts",
+      flagValue(runtimeNativeAlignmentOk),
+      String(runtimeNativeAlignmentRows.length),
+      "native stdout alignment artifacts cover user-M, tool DB, and Python runtime gates without enabling execution",
+    ],
+    [
+      "native_runtime_probe_summary",
+      flagValue(nativeRuntimeProbeSummaryOk),
+      String(nativeRuntimeProbeRows.length),
+      "native runtime probe summary records current host readiness and disabled runtime probe status",
+    ],
+    [
+      "user_m_transition_contract",
+      flagValue(userMTransitionContractOk),
+      String(userMTransitionRows.length),
+      "millturn M428/M429 transition contract records switchkins, G5x, guard pins, and state outputs without execution",
+    ],
+    [
+      "user_m_native_runtime_state_plan",
+      flagValue(userMRuntimeStatePlanOk),
+      String(userMRuntimeStatePlanRows.length),
+      "millturn native runnable state probe plan records required LinuxCNC task/HAL/Tcl runtime and expected state outputs while remaining disabled",
+    ],
+    [
+      "user_m_native_runtime_readiness",
+      flagValue(userMRuntimeReadinessOk),
+      String(userMRuntimeReadinessRows.length),
+      "millturn native runtime readiness records required host commands without enabling execution or promotion",
+    ],
+    [
+      "user_m_native_runtime_probe_gate",
+      flagValue(userMRuntimeProbeGateOk),
+      String(userMRuntimeProbeGateRows.length),
+      "millturn native runtime probe gate records host readiness and keeps M128/M129 blocked until HAL/Tcl runtime is available",
+    ],
+    [
+      "tool_db_transaction_contract",
+      flagValue(toolDbTransactionContractOk),
+      String(toolDbTransactionRows.length),
+      "db_demo tool DB transaction contract records v2.1, get-all, load, put, unload, callbacks, and state targets without execution",
+    ],
+    [
+      "tool_db_native_runtime_readiness",
+      flagValue(toolDbRuntimeReadinessOk),
+      String(toolDbRuntimeReadinessRows.length),
+      "db_demo native runtime readiness records required DB process commands and Python modules without enabling execution or promotion",
+    ],
+    [
+      "python_runtime_contract",
+      flagValue(pythonRuntimeContractOk),
+      String(pythonRuntimeContractRows.length),
+      "Python-remap family runtime contracts record LinuxCNC Python phases, dependencies, process assumptions, and proof requirements without execution",
+    ],
+    [
+      "python_native_runtime_readiness",
+      flagValue(pythonRuntimeReadinessOk),
+      String(pythonRuntimeReadinessRows.length),
+      "Python-remap native runtime readiness records host commands, LinuxCNC Python owner source, and configured Python modules without enabling execution or promotion",
+    ],
+    [
+      "python_native_runtime_state_plan",
+      flagValue(pythonRuntimeStatePlanOk),
+      String(pythonRuntimeStatePlanRows.length),
+      "Python-remap native runtime state plan records required runtime phases, modules, callables, process assumptions, and proof targets without executing Python",
+    ],
+    [
+      "python_native_runtime_fixture_plan",
+      flagValue(pythonRuntimeFixturePlanOk),
+      String(pythonRuntimeFixturePlanRows.length),
+      "Python-remap native runtime fixture plan selects the minimal stop-lookahead lifecycle fixture without executing Python or enabling promotion",
+    ],
+    [
+      "runtime_contract_summary",
+      flagValue(runtimeContractSummaryOk),
+      String(runtimeContractSummaryRows.length),
+      "Runtime boundary contract summary unifies user-M, tool DB, and Python contracts with pending disabled proof state",
+    ],
+  ].map((row) => row.map(tsvValue).join("\t"));
+}
+
+function verifyBoundaryPhaseCompletionSummaryRows(rows) {
+  const expectedHeaders = ["criterion", "passed", "count", "evidence"];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const expectedCriteria = [
+    "vendored_runtime_boundary_reports",
+    "hard_block_dependency_evidence",
+    "safe_hal_ui_representatives",
+    "blocked_families_not_promoted",
+    "linuxcnc_runtime_owner_proof",
+    "native_source_proof_alignment",
+    "runtime_native_alignment_artifacts",
+    "native_runtime_probe_summary",
+    "user_m_transition_contract",
+    "user_m_native_runtime_state_plan",
+    "user_m_native_runtime_readiness",
+    "user_m_native_runtime_probe_gate",
+    "tool_db_transaction_contract",
+    "tool_db_native_runtime_readiness",
+    "python_runtime_contract",
+    "python_native_runtime_readiness",
+    "python_native_runtime_state_plan",
+    "python_native_runtime_fixture_plan",
+    "runtime_contract_summary",
+  ];
+
+  assert.deepEqual(
+    parsedRows.map((row) => row.criterion),
+    expectedCriteria,
+    "boundary phase completion criteria drift",
+  );
+  for (const row of parsedRows) {
+    assert.equal(row.passed, "1", `${row.criterion}: completion criterion failed`);
+    assert.ok(/^[1-9][0-9]*$/.test(row.count), `${row.criterion}: invalid criterion count`);
+    assert.notEqual(row.evidence, "-", `${row.criterion}: missing criterion evidence`);
+  }
+
+  return parsedRows;
+}
+
+function nextBoundaryWorklistRows({ fullProcessRows, pythonFamilyRows }) {
+  const fullProcessPriority = new Map([
+    ["external_user_m_process", 1],
+    ["tool_database_process", 2],
+  ]);
+  const fullProcessNextAction = new Map([
+    ["external_user_m_process", "design_m128_m129_linuxcnc_state_boundary"],
+    ["tool_database_process", "design_tooldata_db_protocol_boundary"],
+  ]);
+  const fullProcessItems = fullProcessRows
+    .map((row) => [
+      String(fullProcessPriority.get(row.boundary_kind) ?? 50),
+      row.boundary_kind,
+      row.path,
+      row.blocked,
+      row.design_status,
+      row.linuxcnc_owner,
+      row.runtime_owner_evidence,
+      row.required_native_proof,
+      row.required_node_proof,
+      listValue(uniqueSorted([row.required_browser_proof, row.browser_policy])),
+      row.execution_enabled,
+      "0",
+      fullProcessNextAction.get(row.boundary_kind) ?? "design_linuxcnc_owned_runtime_boundary",
+      row.notes,
+    ]);
+  const pythonItems = [...pythonFamilyRows]
+    .sort((left, right) =>
+      Number(right.row_count) - Number(left.row_count) || left.family.localeCompare(right.family),
+    )
+    .map((row, index) => [
+      String(100 + index),
+      "python_runtime",
+      row.family,
+      "L4-PYTHON-REMAP",
+      "inventory_only",
+      "src/emc/rs274ngc/interp_python.cc,src/emc/pythonplugin/python_plugin.cc,configs/sim/*/python/*.py",
+      row.python_runtime_evidence,
+      "python_runtime_owner_and_fixture",
+      "linuxcnc_python_runtime_boundary_not_js_semantics",
+      "browser_after_node_python_boundary_no_full_process_claim",
+      row.execution_enabled,
+      "0",
+      "design_linuxcnc_python_runtime_boundary",
+      row.notes,
+    ]);
+
+  return [...fullProcessItems, ...pythonItems]
+    .sort((left, right) => Number(left[0]) - Number(right[0]))
+    .map((row) => row.map(tsvValue).join("\t"));
+}
+
+function verifyNextBoundaryWorklistRows(rows, fullProcessRows, pythonFamilyRows) {
+  const expectedHeaders = [
+    "priority",
+    "boundary_kind",
+    "target",
+    "blocked",
+    "design_status",
+    "linuxcnc_owner",
+    "runtime_owner_evidence",
+    "required_native_proof",
+    "required_node_proof",
+    "required_browser_proof",
+    "execution_enabled",
+    "promotion_allowed",
+    "next_action",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+
+  assert.equal(
+    parsedRows.length,
+    fullProcessRows.length + pythonFamilyRows.length,
+    "next boundary worklist must cover full-process rows and Python families",
+  );
+  assert.deepEqual(
+    parsedRows.map((row) => row.priority),
+    parsedRows.map((row) => row.priority).sort((left, right) => Number(left) - Number(right)),
+    "next boundary worklist priorities must be sorted",
+  );
+  assert.deepEqual(
+    parsedRows.slice(0, 2).map((row) => [row.boundary_kind, row.blocked, row.execution_enabled]),
+    [
+      ["external_user_m_process", "L4-USER-M-PROCESS", "0"],
+      ["tool_database_process", "L4-TOOL-DB", "0"],
+    ],
+    "next boundary worklist must keep current full-process blockers first",
+  );
+  for (const row of parsedRows) {
+    assert.equal(row.execution_enabled, "0", `${row.target}: worklist item must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.target}: worklist item must not allow promotion yet`);
+    assert.notEqual(row.next_action, "-", `${row.target}: worklist item lacks next action`);
+    verifyLinuxCncOwnerPaths(row.target, row.linuxcnc_owner);
+    assert.notEqual(row.runtime_owner_evidence, "-", `${row.target}: worklist item lacks runtime owner evidence`);
+    assert.notEqual(row.required_native_proof, "-", `${row.target}: worklist item lacks native proof`);
+    assert.notEqual(row.required_node_proof, "-", `${row.target}: worklist item lacks Node proof`);
+    assert.notEqual(row.required_browser_proof, "-", `${row.target}: worklist item lacks browser proof`);
+    if (row.boundary_kind === "external_user_m_process") {
+      assert.ok(
+        row.runtime_owner_evidence.includes("kinstype_guard") &&
+          row.runtime_owner_evidence.includes("ini_axis_limit_hal_setp"),
+        `${row.target}: user-M work item lacks side-effect evidence`,
+      );
+    }
+    if (row.boundary_kind === "tool_database_process") {
+      assert.ok(
+        row.runtime_owner_evidence.includes("tooldata_db_v2_1_handshake") &&
+          row.runtime_owner_evidence.includes("tooldata_db_notify_l_u_p"),
+        `${row.target}: tool DB work item lacks protocol evidence`,
+      );
+    }
+    if (row.boundary_kind === "python_runtime") {
+      assert.equal(row.blocked, "L4-PYTHON-REMAP", `${row.target}: Python work item block drift`);
+      assert.equal(row.design_status, "inventory_only", `${row.target}: Python work item design drift`);
+      assert.ok(
+        row.runtime_owner_evidence.includes("interp_python_pycall_dispatch") &&
+          row.runtime_owner_evidence.includes("python_plugin_callable_invoke"),
+        `${row.target}: Python work item lacks runtime evidence`,
+      );
+      assert.equal(
+        row.next_action,
+        "design_linuxcnc_python_runtime_boundary",
+        `${row.target}: Python work item next action drift`,
+      );
+      assert.ok(
+        row.linuxcnc_owner.includes("src/emc/rs274ngc/interp_python.cc"),
+        `${row.target}: Python work item lacks interpreter Python owner`,
+      );
+      assert.ok(
+        row.notes.includes("dependency_inventory_only_no_execution"),
+        `${row.target}: Python work item must remain inventory-only`,
+      );
+    }
+  }
+
+  return parsedRows;
+}
+
+function boundaryProofGateRows(worklistRows) {
+  const layerField = new Map([
+    ["native", "required_native_proof"],
+    ["node", "required_node_proof"],
+    ["browser", "required_browser_proof"],
+  ]);
+
+  return worklistRows.flatMap((row) =>
+    [...layerField.entries()].map(([layer, proofField]) => {
+      const requiredProof = layer === "browser"
+        ? listValue(uniqueSorted([
+            row[proofField],
+            row.browser_policy,
+          ]))
+        : row[proofField];
+      return [
+      row.priority,
+      row.boundary_kind,
+      row.target,
+      layer,
+      row.blocked,
+      row.design_status,
+      row.linuxcnc_owner,
+      row.runtime_owner_evidence,
+      requiredProof,
+      "pending",
+      row.execution_enabled,
+      row.promotion_allowed,
+      row.next_action,
+      row.notes,
+      ].map(tsvValue).join("\t");
+    }),
+  );
+}
+
+function verifyBoundaryProofGateRows(rows, worklistRows) {
+  const expectedHeaders = [
+    "priority",
+    "boundary_kind",
+    "target",
+    "proof_layer",
+    "blocked",
+    "design_status",
+    "linuxcnc_owner",
+    "runtime_owner_evidence",
+    "required_proof",
+    "proof_status",
+    "execution_enabled",
+    "promotion_allowed",
+    "next_action",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const expectedTargets = new Set(worklistRows.map((row) => row.target));
+  const expectedLayers = ["native", "node", "browser"];
+
+  assert.equal(
+    parsedRows.length,
+    worklistRows.length * expectedLayers.length,
+    "boundary proof gates must include native, Node, and browser rows for every worklist item",
+  );
+
+  for (const target of expectedTargets) {
+    const targetRows = parsedRows.filter((row) => row.target === target);
+    assert.deepEqual(
+      targetRows.map((row) => row.proof_layer).sort(),
+      [...expectedLayers].sort(),
+      `${target}: proof gate layer set drift`,
+    );
+  }
+
+  for (const row of parsedRows) {
+    assert.ok(expectedLayers.includes(row.proof_layer), `${row.target}: invalid proof layer ${row.proof_layer}`);
+    assert.equal(row.proof_status, "pending", `${row.target}/${row.proof_layer}: proof gate must remain pending`);
+    assert.equal(row.execution_enabled, "0", `${row.target}/${row.proof_layer}: proof gate must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.target}/${row.proof_layer}: proof gate must not allow promotion`);
+    verifyLinuxCncOwnerPaths(row.target, row.linuxcnc_owner);
+    assert.notEqual(row.runtime_owner_evidence, "-", `${row.target}/${row.proof_layer}: missing runtime owner evidence`);
+    assert.notEqual(row.required_proof, "-", `${row.target}/${row.proof_layer}: missing required proof`);
+    assert.notEqual(row.next_action, "-", `${row.target}/${row.proof_layer}: missing next action`);
+
+    if (row.boundary_kind === "external_user_m_process") {
+      if (row.proof_layer === "native") {
+        assert.ok(
+          row.required_proof.includes("ini_xyz_hal_pin_state"),
+          `${row.target}: native user-M proof must require HAL pin state`,
+        );
+      }
+      if (row.proof_layer === "node") {
+        assert.ok(
+          row.required_proof.includes("not_user_m_event_only"),
+          `${row.target}: Node user-M proof must reject event-only coverage`,
+        );
+      }
+      if (row.proof_layer === "browser") {
+        assert.ok(
+          row.required_proof.includes("no_full_process_claim"),
+          `${row.target}: browser user-M proof must avoid full-process claim`,
+        );
+      }
+    }
+
+    if (row.boundary_kind === "tool_database_process") {
+      if (row.proof_layer === "native") {
+        assert.ok(
+          row.required_proof.includes("v2_1_handshake"),
+          `${row.target}: native tool DB proof must require protocol handshake`,
+        );
+      }
+      if (row.proof_layer === "node") {
+        assert.ok(
+          row.required_proof.includes("not_tbl_fallback"),
+          `${row.target}: Node tool DB proof must reject tbl fallback`,
+        );
+      }
+      if (row.proof_layer === "browser") {
+        assert.ok(
+          row.required_proof.includes("opfs_persistence_only"),
+          `${row.target}: browser tool DB proof must constrain OPFS to persistence`,
+        );
+      }
+    }
+
+    if (row.boundary_kind === "python_runtime") {
+      assert.equal(row.blocked, "L4-PYTHON-REMAP", `${row.target}: Python proof gate blocked kind drift`);
+      assert.equal(row.design_status, "inventory_only", `${row.target}: Python proof gate design status drift`);
+      if (row.proof_layer === "native") {
+        assert.ok(
+          row.required_proof.includes("python_runtime_owner"),
+          `${row.target}: native Python proof must require runtime owner`,
+        );
+      }
+      if (row.proof_layer === "node") {
+        assert.ok(
+          row.required_proof.includes("not_js_semantics"),
+          `${row.target}: Node Python proof must reject JS semantics`,
+        );
+      }
+      if (row.proof_layer === "browser") {
+        assert.ok(
+          row.required_proof.includes("no_full_process_claim"),
+          `${row.target}: browser Python proof must avoid full-process claim`,
+        );
+      }
+    }
+  }
+
+  return parsedRows;
+}
+
+function blockedRuntimePromotionLockRows({
+  worklistRows,
+  proofGateRows,
+  runtimeNativeAlignmentRows,
+}) {
+  const runtimeAlignmentByKind = new Map(
+    runtimeNativeAlignmentRows.map((row) => [row.boundary_kind, row]),
+  );
+
+  return worklistRows.map((row) => {
+    const gateRows = proofGateRows.filter((gate) =>
+      gate.boundary_kind === row.boundary_kind && gate.target === row.target,
+    );
+    const runtimeAlignment = runtimeAlignmentByKind.get(row.boundary_kind);
+    const nativeGatePending = gateRows.some((gate) =>
+      gate.proof_layer === "native" &&
+        gate.proof_status === "pending" &&
+        gate.execution_enabled === "0" &&
+        gate.promotion_allowed === "0",
+    );
+    const nodeGatePending = gateRows.some((gate) =>
+      gate.proof_layer === "node" &&
+        gate.proof_status === "pending" &&
+        gate.execution_enabled === "0" &&
+        gate.promotion_allowed === "0",
+    );
+    const browserGatePending = gateRows.some((gate) =>
+      gate.proof_layer === "browser" &&
+        gate.proof_status === "pending" &&
+        gate.execution_enabled === "0" &&
+        gate.promotion_allowed === "0",
+    );
+    const runtimeAlignmentOk = Boolean(runtimeAlignment) &&
+      runtimeAlignment.summary_ok === "1" &&
+      runtimeAlignment.pending_count === runtimeAlignment.row_count &&
+      runtimeAlignment.execution_disabled_count === runtimeAlignment.row_count &&
+      runtimeAlignment.promotion_disabled_count === runtimeAlignment.row_count;
+    const lockActive = (
+      row.execution_enabled === "0" &&
+      row.promotion_allowed === "0" &&
+      nativeGatePending &&
+      nodeGatePending &&
+      browserGatePending &&
+      runtimeAlignmentOk
+    );
+
+    return [
+      row.priority,
+      row.boundary_kind,
+      row.target,
+      row.blocked,
+      row.design_status,
+      row.execution_enabled,
+      row.promotion_allowed,
+      flagValue(nativeGatePending),
+      flagValue(nodeGatePending),
+      flagValue(browserGatePending),
+      runtimeAlignment?.artifact ?? "-",
+      runtimeAlignment?.row_count ?? "0",
+      flagValue(runtimeAlignmentOk),
+      row.next_action,
+      flagValue(lockActive),
+      "blocked_until_linuxcnc_owned_runtime_boundary_replaces_pending_gates",
+    ].map(tsvValue).join("\t");
+  });
+}
+
+function verifyBlockedRuntimePromotionLockRows(rows, worklistRows) {
+  const expectedHeaders = [
+    "priority",
+    "boundary_kind",
+    "target",
+    "blocked",
+    "design_status",
+    "execution_enabled",
+    "promotion_allowed",
+    "native_gate_pending",
+    "node_gate_pending",
+    "browser_gate_pending",
+    "runtime_alignment_artifact",
+    "runtime_alignment_row_count",
+    "runtime_alignment_ok",
+    "next_action",
+    "lock_active",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+
+  verifySamePathSet(
+    "wasm_blocked_runtime_promotion_lock",
+    worklistRows.map((row) => row.target).sort(),
+    parsedRows.map((row) => row.target).sort(),
+  );
+
+  for (const row of parsedRows) {
+    assert.equal(row.execution_enabled, "0", `${row.target}: promotion lock must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.target}: promotion lock must not allow promotion`);
+    assert.equal(row.native_gate_pending, "1", `${row.target}: native gate must remain pending`);
+    assert.equal(row.node_gate_pending, "1", `${row.target}: Node gate must remain pending`);
+    assert.equal(row.browser_gate_pending, "1", `${row.target}: browser gate must remain pending`);
+    assert.notEqual(row.runtime_alignment_artifact, "-", `${row.target}: missing runtime alignment artifact`);
+    assert.ok(/^[1-9][0-9]*$/.test(row.runtime_alignment_row_count), `${row.target}: invalid runtime alignment count`);
+    assert.equal(row.runtime_alignment_ok, "1", `${row.target}: runtime alignment summary failed`);
+    assert.notEqual(row.next_action, "-", `${row.target}: promotion lock lacks next action`);
+    assert.equal(row.lock_active, "1", `${row.target}: promotion lock is inactive`);
+    assert.ok(
+      row.notes.includes("blocked_until_linuxcnc_owned_runtime_boundary"),
+      `${row.target}: promotion lock note drift`,
+    );
+
+    if (row.boundary_kind === "external_user_m_process") {
+      assert.equal(row.blocked, "L4-USER-M-PROCESS", `${row.target}: user-M promotion lock blocked kind drift`);
+      assert.equal(row.runtime_alignment_artifact, "user-m-process-native-state-alignment.tsv", `${row.target}: user-M alignment artifact drift`);
+    } else if (row.boundary_kind === "tool_database_process") {
+      assert.equal(row.blocked, "L4-TOOL-DB", `${row.target}: tool DB promotion lock blocked kind drift`);
+      assert.equal(row.runtime_alignment_artifact, "tool-db-process-native-protocol-alignment.tsv", `${row.target}: tool DB alignment artifact drift`);
+    } else if (row.boundary_kind === "python_runtime") {
+      assert.equal(row.blocked, "L4-PYTHON-REMAP", `${row.target}: Python promotion lock blocked kind drift`);
+      assert.equal(row.runtime_alignment_artifact, "python-remap-native-runtime-alignment.tsv", `${row.target}: Python alignment artifact drift`);
+      assert.equal(row.design_status, "inventory_only", `${row.target}: Python promotion lock design status drift`);
+    } else {
+      throw new Error(`${row.target}: unexpected promotion lock boundary kind ${row.boundary_kind}`);
+    }
+  }
+
+  return parsedRows;
+}
+
+function nextBoundaryRecommendationRows({
+  worklistRows,
+  promotionLockRows,
+  runtimeContractRows,
+  userMRuntimeProbeGateRows,
+  toolDbTransactionRows,
+  pythonFixturePlanRows,
+}) {
+  const lockByKind = new Map(promotionLockRows.map((row) => [row.boundary_kind, row]));
+  const contractByKind = new Map(runtimeContractRows.map((row) => [row.boundary_kind, row]));
+  const worklistByKind = new Map();
+  for (const row of worklistRows) {
+    const existing = worklistByKind.get(row.boundary_kind) ?? [];
+    existing.push(row);
+    worklistByKind.set(row.boundary_kind, existing);
+  }
+
+  const userMWork = worklistByKind.get("external_user_m_process")?.[0];
+  const toolDbWork = worklistByKind.get("tool_database_process")?.[0];
+  const pythonFixture = pythonFixturePlanRows[0];
+  const pythonRows = worklistByKind.get("python_runtime") ?? [];
+  const pythonContract = contractByKind.get("python_runtime");
+
+  return [
+    [
+      "1",
+      "external_user_m_process",
+      userMWork?.target ?? "-",
+      userMWork?.blocked ?? "L4-USER-M-PROCESS",
+      "implement_native_m128_m129_state_probe",
+      "user-m-process-native-runtime-probe-gate.tsv",
+      String(userMRuntimeProbeGateRows.length),
+      "native_runtime_state_probe_required",
+      userMWork?.required_node_proof ?? "linuxcnc_owned_state_boundary_not_user_m_event_only",
+      userMWork?.required_browser_proof ?? "browser_after_node_state_proof_no_full_process_claim",
+      lockByKind.get("external_user_m_process")?.lock_active ?? "0",
+      contractByKind.get("external_user_m_process")?.contract_ok ?? "0",
+      "0",
+      "0",
+      "run LinuxCNC-owned millturn M128/M129 HAL/Tcl state probe after host runtime gate is ready",
+      "next-boundary-worklist.tsv,blocked-runtime-promotion-lock.tsv,user-m-process-transition-plan.tsv,user-m-process-native-runtime-state-plan.tsv,user-m-process-native-runtime-probe-gate.tsv",
+    ],
+    [
+      "2",
+      "tool_database_process",
+      toolDbWork?.target ?? "-",
+      toolDbWork?.blocked ?? "L4-TOOL-DB",
+      "implement_tooldata_db_protocol_probe",
+      "tool-db-process-transaction-plan.tsv",
+      String(toolDbTransactionRows.length),
+      "native_db_process_protocol_probe_required",
+      toolDbWork?.required_node_proof ?? "linuxcnc_tooldata_db_protocol_not_tbl_fallback",
+      toolDbWork?.required_browser_proof ?? "browser_after_node_protocol_proof_opfs_persistence_only",
+      lockByKind.get("tool_database_process")?.lock_active ?? "0",
+      contractByKind.get("tool_database_process")?.contract_ok ?? "0",
+      "0",
+      "0",
+      "prove DB_PROGRAM v2.1/get/load/put/unload protocol before replacing the blocked row",
+      "next-boundary-worklist.tsv,blocked-runtime-promotion-lock.tsv,tool-db-process-transaction-plan.tsv,tool-db-process-native-runtime-readiness.tsv",
+    ],
+    [
+      "3",
+      "python_runtime",
+      pythonFixture?.family ?? "axis/remap/stop-lookahead/nc_files",
+      "L4-PYTHON-REMAP",
+      "implement_minimal_python_runtime_lifecycle_probe",
+      "python-remap-native-runtime-fixture-plan.tsv",
+      pythonContract?.contract_row_count ?? String(pythonRows.length),
+      pythonFixture?.proof_kind ?? "linuxcnc_python_runtime_lifecycle_probe_required",
+      "linuxcnc_python_runtime_boundary_not_js_semantics",
+      "browser_after_node_python_boundary_no_full_process_claim",
+      lockByKind.get("python_runtime")?.lock_active ?? "0",
+      pythonContract?.contract_ok ?? "0",
+      "0",
+      "0",
+      "start with stop-lookahead fixture; keep all Python-remap families inventory-only until runtime proof exists",
+      "next-boundary-worklist.tsv,blocked-runtime-promotion-lock.tsv,python-remap-runtime-contract.tsv,python-remap-native-runtime-fixture-plan.tsv",
+    ],
+  ].map((row) => row.map(tsvValue).join("\t"));
+}
+
+function verifyNextBoundaryRecommendationRows(rows) {
+  const expectedHeaders = [
+    "priority",
+    "boundary_kind",
+    "target",
+    "blocked",
+    "recommendation",
+    "primary_artifact",
+    "artifact_row_count",
+    "required_native_proof",
+    "required_node_proof",
+    "required_browser_proof",
+    "promotion_lock_active",
+    "contract_ok",
+    "execution_enabled",
+    "promotion_allowed",
+    "next_step",
+    "source_artifacts",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+
+  assert.deepEqual(
+    parsedRows.map((row) => row.boundary_kind),
+    ["external_user_m_process", "tool_database_process", "python_runtime"],
+    "next boundary recommendations must stay ordered by current boundary priority",
+  );
+
+  for (const row of parsedRows) {
+    assert.ok(/^[1-9][0-9]*$/.test(row.priority), `${row.target}: invalid recommendation priority`);
+    assert.ok(/^[1-9][0-9]*$/.test(row.artifact_row_count), `${row.target}: invalid artifact row count`);
+    assert.equal(row.promotion_lock_active, "1", `${row.target}: recommendation lacks active promotion lock`);
+    assert.equal(row.contract_ok, "1", `${row.target}: recommendation lacks passing contract summary`);
+    assert.equal(row.execution_enabled, "0", `${row.target}: recommendation must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.target}: recommendation must not allow promotion`);
+    assert.notEqual(row.required_native_proof, "-", `${row.target}: recommendation lacks native proof`);
+    assert.notEqual(row.required_node_proof, "-", `${row.target}: recommendation lacks Node proof`);
+    assert.notEqual(row.required_browser_proof, "-", `${row.target}: recommendation lacks browser proof`);
+    assert.notEqual(row.next_step, "-", `${row.target}: recommendation lacks next step`);
+    assert.ok(
+      row.source_artifacts.includes("next-boundary-worklist.tsv") &&
+        row.source_artifacts.includes("blocked-runtime-promotion-lock.tsv"),
+      `${row.target}: recommendation lacks source artifact trace`,
+    );
+
+    if (row.boundary_kind === "external_user_m_process") {
+      assert.equal(row.target, "axis/vismach/millturn/example.ngc", "user-M recommendation target drift");
+      assert.equal(row.blocked, "L4-USER-M-PROCESS", "user-M recommendation blocked kind drift");
+      assert.equal(row.recommendation, "implement_native_m128_m129_state_probe", "user-M recommendation drift");
+      assert.equal(row.primary_artifact, "user-m-process-native-runtime-probe-gate.tsv", "user-M artifact drift");
+      assert.ok(row.required_node_proof.includes("not_user_m_event_only"), "user-M recommendation must reject event-only proof");
+      assert.ok(row.next_step.includes("M128/M129"), "user-M recommendation lacks M128/M129 next step");
+    } else if (row.boundary_kind === "tool_database_process") {
+      assert.equal(row.target, "axis/db_demo/base.ngc", "tool DB recommendation target drift");
+      assert.equal(row.blocked, "L4-TOOL-DB", "tool DB recommendation blocked kind drift");
+      assert.equal(row.recommendation, "implement_tooldata_db_protocol_probe", "tool DB recommendation drift");
+      assert.equal(row.primary_artifact, "tool-db-process-transaction-plan.tsv", "tool DB artifact drift");
+      assert.ok(row.required_native_proof.includes("native_db_process_protocol_probe"), "tool DB recommendation must require native DB process proof");
+      assert.ok(row.next_step.includes("DB_PROGRAM"), "tool DB recommendation lacks DB_PROGRAM next step");
+    } else if (row.boundary_kind === "python_runtime") {
+      assert.equal(row.target, "axis/remap/stop-lookahead/nc_files", "Python recommendation target drift");
+      assert.equal(row.blocked, "L4-PYTHON-REMAP", "Python recommendation blocked kind drift");
+      assert.equal(row.recommendation, "implement_minimal_python_runtime_lifecycle_probe", "Python recommendation drift");
+      assert.equal(row.primary_artifact, "python-remap-native-runtime-fixture-plan.tsv", "Python artifact drift");
+      assert.ok(row.required_node_proof.includes("not_js_semantics"), "Python recommendation must reject JS semantics");
+      assert.ok(row.next_step.includes("stop-lookahead"), "Python recommendation lacks fixture next step");
+    } else {
+      throw new Error(`${row.target}: unexpected recommendation boundary kind ${row.boundary_kind}`);
+    }
+  }
+
+  return parsedRows;
+}
+
+function nativeProofAlignmentRows(worklistRows, proofGateRows) {
+  const expectedProofs = [
+    {
+      boundaryClass: "L4-USER-M-PROCESS",
+      boundaryKind: "external_user_m_process",
+      target: "axis/vismach/millturn/example.ngc",
+      proofKey: "millturn_user_m_native_source_state_proof",
+      requiredProofToken: "ini_xyz_hal_pin_state",
+      note: "native_source_state_proof_consumed_by_boundary_worklist",
+    },
+    {
+      boundaryClass: "L4-TOOL-DB",
+      boundaryKind: "tool_database_process",
+      target: "axis/db_demo/base.ngc",
+      proofKey: "tool_db_native_source_protocol_proof",
+      requiredProofToken: "v2_1_handshake",
+      note: "native_source_protocol_proof_consumed_by_boundary_worklist",
+    },
+    {
+      boundaryClass: "L4-PYTHON-REMAP",
+      boundaryKind: "python_runtime",
+      target: "*",
+      proofKey: "python_remap_native_source_inventory_proof",
+      requiredProofToken: "python_runtime_owner",
+      note: "native_source_inventory_proof_consumed_by_python_family_worklist",
+    },
+  ];
+
+  if (!existsSync(nativeSourceProofSummaryPath)) {
+    return expectedProofs.map((expected) => [
+      expected.boundaryClass,
+      expected.boundaryKind,
+      expected.target,
+      expected.proofKey,
+      "0",
+      "-",
+      "-",
+      "-",
+      "0",
+      "0",
+      "0",
+      "native_source_proof_summary_unavailable",
+    ].map(tsvValue).join("\t"));
+  }
+
+  const nativeProofRows = parseTsv(
+    readFileSync(nativeSourceProofSummaryPath, "utf8"),
+    [
+      "boundary_class",
+      "proof_key",
+      "proof_value",
+      "execution_enabled",
+      "promotion_allowed",
+      "stdout_log",
+    ],
+  );
+  const nativeProofByClass = new Map(nativeProofRows.map((row) => [row.boundary_class, row]));
+
+  return expectedProofs.map((expected) => {
+    const nativeProof = nativeProofByClass.get(expected.boundaryClass);
+    const matchingWorklistRows = worklistRows.filter((row) =>
+      row.boundary_kind === expected.boundaryKind &&
+        (expected.target === "*" || row.target === expected.target),
+    );
+    const matchingNativeGateRows = proofGateRows.filter((row) =>
+      row.boundary_kind === expected.boundaryKind &&
+        row.proof_layer === "native" &&
+        row.required_proof.includes(expected.requiredProofToken) &&
+        (expected.target === "*" || row.target === expected.target),
+    );
+    const alignmentOk = Boolean(nativeProof) &&
+      nativeProof.proof_key === expected.proofKey &&
+      nativeProof.proof_value === "1" &&
+      nativeProof.execution_enabled === "0" &&
+      nativeProof.promotion_allowed === "0" &&
+      matchingWorklistRows.length > 0 &&
+      matchingNativeGateRows.length > 0;
+
+    return [
+      expected.boundaryClass,
+      expected.boundaryKind,
+      expected.target,
+      expected.proofKey,
+      "1",
+      nativeProof?.proof_value ?? "-",
+      nativeProof?.execution_enabled ?? "-",
+      nativeProof?.promotion_allowed ?? "-",
+      String(matchingWorklistRows.length),
+      String(matchingNativeGateRows.length),
+      flagValue(alignmentOk),
+      expected.note,
+    ].map(tsvValue).join("\t");
+  });
+}
+
+function verifyNativeProofAlignmentRows(rows) {
+  const expectedHeaders = [
+    "boundary_class",
+    "boundary_kind",
+    "target",
+    "proof_key",
+    "native_summary_available",
+    "proof_value",
+    "execution_enabled",
+    "promotion_allowed",
+    "matching_worklist_count",
+    "matching_native_gate_count",
+    "alignment_ok",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const expectedClasses = [
+    "L4-USER-M-PROCESS",
+    "L4-TOOL-DB",
+    "L4-PYTHON-REMAP",
+  ];
+
+  assert.deepEqual(
+    parsedRows.map((row) => row.boundary_class),
+    expectedClasses,
+    "native proof alignment class order drift",
+  );
+
+  for (const row of parsedRows) {
+    assert.ok(["0", "1"].includes(row.native_summary_available), `${row.boundary_class}: invalid native availability`);
+    assert.ok(["0", "1"].includes(row.alignment_ok), `${row.boundary_class}: invalid alignment flag`);
+    assert.ok(/^[0-9]+$/.test(row.matching_worklist_count), `${row.boundary_class}: invalid worklist count`);
+    assert.ok(/^[0-9]+$/.test(row.matching_native_gate_count), `${row.boundary_class}: invalid native gate count`);
+
+    if (row.native_summary_available === "0") {
+      assert.equal(row.alignment_ok, "0", `${row.boundary_class}: unavailable native proof cannot align`);
+      assert.equal(row.notes, "native_source_proof_summary_unavailable", `${row.boundary_class}: missing unavailable note`);
+      continue;
+    }
+
+    assert.equal(row.proof_value, "1", `${row.boundary_class}: native proof incomplete`);
+    assert.equal(row.execution_enabled, "0", `${row.boundary_class}: native proof must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.boundary_class}: native proof must not allow promotion`);
+    assert.notEqual(row.matching_worklist_count, "0", `${row.boundary_class}: native proof lacks worklist consumer`);
+    assert.notEqual(row.matching_native_gate_count, "0", `${row.boundary_class}: native proof lacks native gate consumer`);
+    assert.equal(row.alignment_ok, "1", `${row.boundary_class}: native proof alignment failed`);
+  }
+
+  return parsedRows;
+}
+
+function nativeRuntimeProbeSummaryRows() {
+  const expectedHeaders = [
+    "boundary_class",
+    "boundary_kind",
+    "target",
+    "runtime_probe",
+    "runtime_ready",
+    "source_proof_ready",
+    "probe_status",
+    "execution_enabled",
+    "promotion_allowed",
+    "missing_requirements",
+    "stdout_log",
+  ];
+  assert.ok(
+    existsSync(nativeRuntimeProbeSummarySourcePath),
+    "native runtime probe summary is required before WASM inventory generation",
+  );
+  const parsedRows = parseTsv(
+    readFileSync(nativeRuntimeProbeSummarySourcePath, "utf8"),
+    expectedHeaders,
+  );
+  const expectedRows = new Map([
+    [
+      "L4-USER-M-PROCESS",
+      {
+        boundaryKind: "external_user_m_process",
+        target: "axis/vismach/millturn/example.ngc",
+        runtimeProbe: "linuxcnc_millturn_user_m_runtime_probe",
+      },
+    ],
+    [
+      "L4-TOOL-DB",
+      {
+        boundaryKind: "tool_database_process",
+        target: "axis/db_demo/base.ngc",
+        runtimeProbe: "linuxcnc_tool_db_runtime_probe",
+      },
+    ],
+    [
+      "L4-PYTHON-REMAP",
+      {
+        boundaryKind: "python_runtime",
+        target: "axis/remap/stop-lookahead/nc_files",
+        runtimeProbe: "linuxcnc_python_remap_runtime_probe",
+      },
+    ],
+  ]);
+  const rowsByClass = new Map(parsedRows.map((row) => [row.boundary_class, row]));
+
+  assert.equal(parsedRows.length, expectedRows.size, "native runtime probe summary row count drift");
+  assert.deepEqual(
+    parsedRows.map((row) => row.boundary_class),
+    [...expectedRows.keys()],
+    "native runtime probe summary class order drift",
+  );
+
+  for (const [boundaryClass, expected] of expectedRows) {
+    const row = rowsByClass.get(boundaryClass);
+    assert.ok(row, `${boundaryClass}: missing native runtime probe summary row`);
+    assert.equal(row.boundary_kind, expected.boundaryKind, `${boundaryClass}: runtime probe boundary kind drift`);
+    assert.equal(row.target, expected.target, `${boundaryClass}: runtime probe target drift`);
+    assert.equal(row.runtime_probe, expected.runtimeProbe, `${boundaryClass}: runtime probe name drift`);
+    assert.ok(["0", "1"].includes(row.runtime_ready), `${boundaryClass}: invalid runtime_ready`);
+    assert.equal(row.source_proof_ready, "1", `${boundaryClass}: source proof must be ready before runtime probe`);
+    assert.ok(
+      [
+        "skipped_missing_host_runtime",
+        "ready_disabled_by_default",
+        "not_implemented_full_process_guard",
+        "runtime_state_probe_passed",
+        "runtime_protocol_probe_passed",
+        "runtime_lifecycle_probe_passed",
+      ].includes(row.probe_status),
+      `${boundaryClass}: invalid runtime probe status`,
+    );
+    if (row.runtime_ready === "0") {
+      assert.equal(row.probe_status, "skipped_missing_host_runtime", `${boundaryClass}: non-ready runtime must skip`);
+      assert.notEqual(row.missing_requirements, "-", `${boundaryClass}: non-ready runtime must record missing requirements`);
+    } else {
+      assert.equal(row.missing_requirements, "-", `${boundaryClass}: ready runtime must not record missing requirements`);
+    }
+    assert.equal(row.execution_enabled, "0", `${boundaryClass}: native runtime probe must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${boundaryClass}: native runtime probe must not allow promotion`);
+    assert.notEqual(row.stdout_log, "-", `${boundaryClass}: runtime probe must reference stdout log`);
+    assert.ok(
+      existsSync(resolve(dirname(nativeRuntimeProbeSummarySourcePath), row.stdout_log)),
+      `${boundaryClass}: runtime probe stdout log is missing`,
+    );
+  }
+
+  return parsedRows.map((row) => expectedHeaders.map((header) => row[header]).map(tsvValue).join("\t"));
+}
+
+function verifyNativeRuntimeProbeSummaryRows(rows) {
+  const expectedHeaders = [
+    "boundary_class",
+    "boundary_kind",
+    "target",
+    "runtime_probe",
+    "runtime_ready",
+    "source_proof_ready",
+    "probe_status",
+    "execution_enabled",
+    "promotion_allowed",
+    "missing_requirements",
+    "stdout_log",
+  ];
+  return parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+}
+
+function keyValuesFromText(text) {
+  const values = new Map();
+  for (const line of text.split("\n")) {
+    const equals = line.indexOf("=");
+    if (equals === -1) {
+      continue;
+    }
+    values.set(line.slice(0, equals).trim(), line.slice(equals + 1).trim());
+  }
+  return values;
+}
+
+function userMNativeFieldForTarget(row) {
+  const targetSuffix = row.target_pin.split(".").pop();
+  if (targetSuffix === "min_velocity") {
+    return "MAX_VELOCITY";
+  }
+  if (targetSuffix === "max_acceleration") {
+    return "MAX_ACCELERATION";
+  }
+  if (targetSuffix === "min_limit") {
+    return row.source_field === "MIN_LIMIT_TURN/MAX_LIMIT_TURN" ? "MIN_LIMIT_TURN" : "MIN_LIMIT";
+  }
+  if (targetSuffix === "max_limit") {
+    return row.source_field === "MIN_LIMIT_TURN/MAX_LIMIT_TURN" ? "MAX_LIMIT_TURN" : "MAX_LIMIT";
+  }
+  return "";
+}
+
+function userMProcessNativeStateAlignmentRows(stateTargetRows) {
+  const nativeProofUnavailableRows = () => stateTargetRows.map((row) => [
+    row.path,
+    row.ini,
+    row.blocked,
+    row.user_m_code,
+    row.target_pin,
+    row.source_section,
+    row.source_field,
+    row.expected_value,
+    "0",
+    "-",
+    "-",
+    "-",
+    "-",
+    "-",
+    "-",
+    "0",
+    row.execution_enabled,
+    row.promotion_allowed,
+    "pending",
+    "native_user_m_probe_stdout_unavailable",
+  ].map(tsvValue).join("\t"));
+
+  if (!existsSync(nativeSourceProofSummaryPath)) {
+    return nativeProofUnavailableRows();
+  }
+
+  const nativeProofRows = parseTsv(
+    readFileSync(nativeSourceProofSummaryPath, "utf8"),
+    [
+      "boundary_class",
+      "proof_key",
+      "proof_value",
+      "execution_enabled",
+      "promotion_allowed",
+      "stdout_log",
+    ],
+  );
+  const userMProof = nativeProofRows.find((row) => row.boundary_class === "L4-USER-M-PROCESS");
+  if (!userMProof?.stdout_log) {
+    return nativeProofUnavailableRows();
+  }
+
+  const stdoutPath = resolve(dirname(nativeSourceProofSummaryPath), userMProof.stdout_log);
+  if (!existsSync(stdoutPath)) {
+    return nativeProofUnavailableRows();
+  }
+
+  const stdoutValues = keyValuesFromText(readFileSync(stdoutPath, "utf8"));
+  return stateTargetRows.map((row) => {
+    const axis = row.source_section.slice("AXIS_".length);
+    const nativeField = userMNativeFieldForTarget(row);
+    const nativeValueKey = `${row.user_m_code}_${axis}_${row.source_section}.${nativeField}`;
+    const nativeOkKey = `${nativeValueKey}_ok`;
+    const sourceProofKey = `${row.user_m_code}_source_state_targets_from_linuxcnc`;
+    const nativeValue = stdoutValues.get(nativeValueKey) ?? "-";
+    const nativeOkValue = stdoutValues.get(nativeOkKey) ?? "-";
+    const sourceProofValue = stdoutValues.get(sourceProofKey) ?? "-";
+    const aligned = (
+      userMProof.proof_key === "millturn_user_m_native_source_state_proof" &&
+      userMProof.proof_value === "1" &&
+      userMProof.execution_enabled === "0" &&
+      userMProof.promotion_allowed === "0" &&
+      nativeField !== "" &&
+      nativeValue === row.expected_value &&
+      nativeOkValue === "1" &&
+      sourceProofValue === "1" &&
+      row.execution_enabled === "0" &&
+      row.promotion_allowed === "0"
+    );
+
+    return [
+      row.path,
+      row.ini,
+      row.blocked,
+      row.user_m_code,
+      row.target_pin,
+      row.source_section,
+      row.source_field,
+      row.expected_value,
+      "1",
+      nativeValueKey,
+      nativeValue,
+      nativeOkKey,
+      nativeOkValue,
+      sourceProofKey,
+      sourceProofValue,
+      flagValue(aligned),
+      row.execution_enabled,
+      row.promotion_allowed,
+      "pending",
+      "native_source_target_alignment_only_no_process_execution",
+    ].map(tsvValue).join("\t");
+  });
+}
+
+function verifyUserMProcessNativeStateAlignmentRows(rows, stateTargetRows) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "user_m_code",
+    "target_pin",
+    "source_section",
+    "source_field",
+    "expected_value",
+    "native_stdout_available",
+    "native_value_key",
+    "native_value",
+    "native_ok_key",
+    "native_ok_value",
+    "source_proof_key",
+    "source_proof_value",
+    "alignment_ok",
+    "execution_enabled",
+    "promotion_allowed",
+    "proof_status",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+
+  verifySamePathSet(
+    "wasm_user_m_process_native_state_alignment",
+    stateTargetRows.map((row) => `${row.path}:${row.user_m_code}:${row.target_pin}`).sort(),
+    parsedRows.map((row) => `${row.path}:${row.user_m_code}:${row.target_pin}`).sort(),
+  );
+  assert.equal(parsedRows.length, 24, "user-M native state alignment must cover every generated state target");
+
+  const stdoutAvailable = parsedRows.some((row) => row.native_stdout_available === "1");
+  if (!stdoutAvailable) {
+    for (const row of parsedRows) {
+      assert.equal(row.native_stdout_available, "0", `${row.target_pin}: mixed native stdout availability`);
+      assert.equal(row.alignment_ok, "0", `${row.target_pin}: unavailable native stdout cannot align`);
+      assert.equal(row.execution_enabled, "0", `${row.target_pin}: alignment must not enable execution`);
+      assert.equal(row.promotion_allowed, "0", `${row.target_pin}: alignment must not allow promotion`);
+      assert.equal(row.proof_status, "pending", `${row.target_pin}: proof must remain pending`);
+    }
+    return parsedRows;
+  }
+
+  for (const row of parsedRows) {
+    assert.equal(row.native_stdout_available, "1", `${row.target_pin}: native stdout must be available`);
+    assert.ok(["M128", "M129"].includes(row.user_m_code), `${row.target_pin}: unexpected user-M code`);
+    assert.ok(/^ini\.[xyz]\.(min_limit|max_limit|min_velocity|max_acceleration)$/.test(row.target_pin), `${row.target_pin}: invalid target pin`);
+    assert.ok(row.native_value_key.startsWith(`${row.user_m_code}_`), `${row.target_pin}: native value key code drift`);
+    assert.ok(row.native_ok_key.endsWith("_ok"), `${row.target_pin}: native ok key drift`);
+    assert.equal(row.native_ok_value, "1", `${row.target_pin}: native ok value drift`);
+    assert.equal(row.native_value, row.expected_value, `${row.target_pin}: native value does not match generated target`);
+    assert.equal(row.source_proof_value, "1", `${row.target_pin}: source state proof missing`);
+    assert.equal(row.alignment_ok, "1", `${row.target_pin}: native target alignment failed`);
+    assert.equal(row.execution_enabled, "0", `${row.target_pin}: alignment must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.target_pin}: alignment must not allow promotion`);
+    assert.equal(row.proof_status, "pending", `${row.target_pin}: proof must remain pending`);
+    assert.ok(
+      row.notes.includes("no_process_execution"),
+      `${row.target_pin}: alignment row must remain non-executing`,
+    );
+  }
+
+  return parsedRows;
+}
+
+function userMProcessNativeTransitionAlignmentRows(transitionRows) {
+  const nativeProofUnavailableRows = () => transitionRows.map((row) => [
+    row.path,
+    row.ini,
+    row.blocked,
+    row.remap_code,
+    row.user_m_code,
+    row.switchkins_output_pin,
+    row.switchkins_target,
+    row.active_g5x,
+    row.work_offset_pocket,
+    "0",
+    "-",
+    "-",
+    "-",
+    "-",
+    "-",
+    "-",
+    "-",
+    "-",
+    "0",
+    row.execution_enabled,
+    row.promotion_allowed,
+    "pending",
+    "native_user_m_probe_stdout_unavailable",
+  ].map(tsvValue).join("\t"));
+
+  if (!existsSync(nativeSourceProofSummaryPath)) {
+    return nativeProofUnavailableRows();
+  }
+
+  const nativeProofRows = parseTsv(
+    readFileSync(nativeSourceProofSummaryPath, "utf8"),
+    [
+      "boundary_class",
+      "proof_key",
+      "proof_value",
+      "execution_enabled",
+      "promotion_allowed",
+      "stdout_log",
+    ],
+  );
+  const userMProof = nativeProofRows.find((row) => row.boundary_class === "L4-USER-M-PROCESS");
+  if (!userMProof?.stdout_log) {
+    return nativeProofUnavailableRows();
+  }
+
+  const stdoutPath = resolve(dirname(nativeSourceProofSummaryPath), userMProof.stdout_log);
+  if (!existsSync(stdoutPath)) {
+    return nativeProofUnavailableRows();
+  }
+
+  const stdoutValues = keyValuesFromText(readFileSync(stdoutPath, "utf8"));
+  return transitionRows.map((row) => {
+    const callKey = `${row.remap_code}_calls_${row.user_m_code}`;
+    const transitionKey = `${row.remap_code}_source_transition_from_linuxcnc`;
+    const nativeOutputPin = stdoutValues.get(`${row.remap_code}_switchkins_output_pin`) ?? "-";
+    const nativeTarget = stdoutValues.get(`${row.remap_code}_switchkins_target`) ?? "-";
+    const nativeActiveG5x = stdoutValues.get(`${row.remap_code}_active_g5x`) ?? "-";
+    const nativePocket = stdoutValues.get(`${row.remap_code}_work_offset_pocket`) ?? "-";
+    const callValue = stdoutValues.get(callKey) ?? "-";
+    const transitionValue = stdoutValues.get(transitionKey) ?? "-";
+    const aligned = (
+      userMProof.proof_key === "millturn_user_m_native_source_state_proof" &&
+      userMProof.proof_value === "1" &&
+      userMProof.execution_enabled === "0" &&
+      userMProof.promotion_allowed === "0" &&
+      nativeOutputPin === row.switchkins_output_pin &&
+      nativeTarget === row.switchkins_target &&
+      nativeActiveG5x === row.active_g5x &&
+      nativePocket === row.work_offset_pocket &&
+      callValue === "1" &&
+      transitionValue === "1" &&
+      row.execution_enabled === "0" &&
+      row.promotion_allowed === "0"
+    );
+
+    return [
+      row.path,
+      row.ini,
+      row.blocked,
+      row.remap_code,
+      row.user_m_code,
+      row.switchkins_output_pin,
+      row.switchkins_target,
+      row.active_g5x,
+      row.work_offset_pocket,
+      "1",
+      nativeOutputPin,
+      nativeTarget,
+      nativeActiveG5x,
+      nativePocket,
+      callKey,
+      callValue,
+      transitionKey,
+      transitionValue,
+      flagValue(aligned),
+      row.execution_enabled,
+      row.promotion_allowed,
+      "pending",
+      "native_source_transition_alignment_only_no_process_execution",
+    ].map(tsvValue).join("\t");
+  });
+}
+
+function verifyUserMProcessNativeTransitionAlignmentRows(rows, transitionRows) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "remap_code",
+    "user_m_code",
+    "switchkins_output_pin",
+    "switchkins_target",
+    "active_g5x",
+    "work_offset_pocket",
+    "native_stdout_available",
+    "native_switchkins_output_pin",
+    "native_switchkins_target",
+    "native_active_g5x",
+    "native_work_offset_pocket",
+    "native_call_key",
+    "native_call_value",
+    "native_transition_key",
+    "native_transition_value",
+    "alignment_ok",
+    "execution_enabled",
+    "promotion_allowed",
+    "proof_status",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+
+  verifySamePathSet(
+    "wasm_user_m_process_native_transition_alignment",
+    transitionRows.map((row) => `${row.path}:${row.remap_code}:${row.user_m_code}`).sort(),
+    parsedRows.map((row) => `${row.path}:${row.remap_code}:${row.user_m_code}`).sort(),
+  );
+  assert.equal(parsedRows.length, 2, "user-M native transition alignment must cover M428/M429");
+
+  const expectedByRemap = new Map([
+    ["M428", { userMCode: "M128", target: "0", g5x: "G59.1", pocket: "P7" }],
+    ["M429", { userMCode: "M129", target: "1", g5x: "G59.2", pocket: "P8" }],
+  ]);
+  const stdoutAvailable = parsedRows.some((row) => row.native_stdout_available === "1");
+  if (!stdoutAvailable) {
+    for (const row of parsedRows) {
+      assert.equal(row.native_stdout_available, "0", `${row.remap_code}: mixed native stdout availability`);
+      assert.equal(row.alignment_ok, "0", `${row.remap_code}: unavailable native stdout cannot align`);
+      assert.equal(row.execution_enabled, "0", `${row.remap_code}: transition alignment must not enable execution`);
+      assert.equal(row.promotion_allowed, "0", `${row.remap_code}: transition alignment must not allow promotion`);
+      assert.equal(row.proof_status, "pending", `${row.remap_code}: transition proof must remain pending`);
+    }
+    return parsedRows;
+  }
+
+  for (const row of parsedRows) {
+    const expected = expectedByRemap.get(row.remap_code);
+    assert.ok(expected, `${row.remap_code}: unexpected remap code`);
+    assert.equal(row.native_stdout_available, "1", `${row.remap_code}: native stdout must be available`);
+    assert.equal(row.user_m_code, expected.userMCode, `${row.remap_code}: user-M call drift`);
+    assert.equal(row.switchkins_output_pin, "motion.analog-out-03", `${row.remap_code}: output pin drift`);
+    assert.equal(row.switchkins_target, expected.target, `${row.remap_code}: target drift`);
+    assert.equal(row.active_g5x, expected.g5x, `${row.remap_code}: G5x drift`);
+    assert.equal(row.work_offset_pocket, expected.pocket, `${row.remap_code}: work offset pocket drift`);
+    assert.equal(row.native_switchkins_output_pin, row.switchkins_output_pin, `${row.remap_code}: native output pin mismatch`);
+    assert.equal(row.native_switchkins_target, row.switchkins_target, `${row.remap_code}: native target mismatch`);
+    assert.equal(row.native_active_g5x, row.active_g5x, `${row.remap_code}: native G5x mismatch`);
+    assert.equal(row.native_work_offset_pocket, row.work_offset_pocket, `${row.remap_code}: native pocket mismatch`);
+    assert.equal(row.native_call_key, `${row.remap_code}_calls_${row.user_m_code}`, `${row.remap_code}: call key drift`);
+    assert.equal(row.native_call_value, "1", `${row.remap_code}: call proof missing`);
+    assert.equal(row.native_transition_key, `${row.remap_code}_source_transition_from_linuxcnc`, `${row.remap_code}: transition key drift`);
+    assert.equal(row.native_transition_value, "1", `${row.remap_code}: transition proof missing`);
+    assert.equal(row.alignment_ok, "1", `${row.remap_code}: transition alignment failed`);
+    assert.equal(row.execution_enabled, "0", `${row.remap_code}: transition alignment must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.remap_code}: transition alignment must not allow promotion`);
+    assert.equal(row.proof_status, "pending", `${row.remap_code}: transition proof must remain pending`);
+    assert.ok(
+      row.notes.includes("no_process_execution"),
+      `${row.remap_code}: transition alignment row must remain non-executing`,
+    );
+  }
+
+  return parsedRows;
+}
+
+function userMProcessNativeRuntimeStatePlanRows({
+  transitionRows,
+  stateTargetRows,
+  transitionAlignmentRows,
+}) {
+  const stateTargetsByCode = new Map();
+  for (const row of stateTargetRows) {
+    const existing = stateTargetsByCode.get(row.user_m_code) ?? [];
+    existing.push(row);
+    stateTargetsByCode.set(row.user_m_code, existing);
+  }
+  const transitionAlignmentByRemap = new Map(
+    transitionAlignmentRows.map((row) => [row.remap_code, row]),
+  );
+
+  return transitionRows.map((row) => {
+    const targetRows = stateTargetsByCode.get(row.user_m_code) ?? [];
+    const transitionAlignment = transitionAlignmentByRemap.get(row.remap_code);
+    const expectedStateValues = uniqueSorted(targetRows.map((target) =>
+      `${target.target_pin}=${target.expected_value}`,
+    ));
+    const sourceAlignmentOk = (
+      transitionAlignment?.alignment_ok === "1" &&
+      targetRows.length === Number(row.state_target_count)
+    );
+
+    return [
+      row.path,
+      row.ini,
+      row.blocked,
+      row.transition_step,
+      row.remap_code,
+      row.user_m_code,
+      "linuxcnc_task_hal_tcl_user_m_process",
+      "INI_FILE_NAME,motion.switchkins-type,kinstype.is-0,kinstype.is-1,ini.[xyz].*",
+      row.switchkins_output_pin,
+      row.switchkins_target,
+      row.active_g5x,
+      row.work_offset_pocket,
+      row.guard_pin,
+      row.state_mode,
+      row.state_target_count,
+      row.expected_state_pins,
+      listValue(expectedStateValues),
+      "user-m-process-native-transition-alignment.tsv,user-m-process-native-state-alignment.tsv",
+      flagValue(sourceAlignmentOk),
+      "pending_native_hal_tcl_process_probe",
+      "native_runtime_state_probe_required",
+      "pending",
+      "0",
+      "0",
+      "native_runtime_not_executed_keep_millturn_blocked",
+    ].map(tsvValue).join("\t");
+  });
+}
+
+function verifyUserMProcessNativeRuntimeStatePlanRows(rows, transitionRows) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "runtime_step",
+    "remap_code",
+    "user_m_code",
+    "required_runtime",
+    "required_environment",
+    "switchkins_output_pin",
+    "switchkins_target",
+    "active_g5x",
+    "work_offset_pocket",
+    "guard_pin",
+    "state_mode",
+    "state_target_count",
+    "expected_state_pins",
+    "expected_state_values",
+    "source_alignment_artifacts",
+    "source_alignment_ok",
+    "native_runtime_status",
+    "proof_kind",
+    "proof_status",
+    "execution_enabled",
+    "promotion_allowed",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+
+  verifySamePathSet(
+    "wasm_user_m_process_native_runtime_state_plan",
+    transitionRows.map((row) => `${row.path}:${row.remap_code}:${row.user_m_code}`).sort(),
+    parsedRows.map((row) => `${row.path}:${row.remap_code}:${row.user_m_code}`).sort(),
+  );
+  assert.equal(parsedRows.length, 2, "user-M native runtime state plan must cover M428/M429");
+
+  const expectedByRemap = new Map([
+    ["M428", { userMCode: "M128", target: "0", g5x: "G59.1", pocket: "P7", stateMode: "mill" }],
+    ["M429", { userMCode: "M129", target: "1", g5x: "G59.2", pocket: "P8", stateMode: "turn" }],
+  ]);
+
+  for (const row of parsedRows) {
+    const expected = expectedByRemap.get(row.remap_code);
+    assert.ok(expected, `${row.remap_code}: unexpected runtime plan remap code`);
+    assert.equal(row.path, "axis/vismach/millturn/example.ngc", `${row.remap_code}: path drift`);
+    assert.equal(row.ini, "axis/vismach/millturn/millturn.ini", `${row.remap_code}: INI drift`);
+    assert.equal(row.blocked, "L4-USER-M-PROCESS", `${row.remap_code}: blocked kind drift`);
+    assert.equal(row.user_m_code, expected.userMCode, `${row.remap_code}: user-M code drift`);
+    assert.equal(row.required_runtime, "linuxcnc_task_hal_tcl_user_m_process", `${row.remap_code}: runtime drift`);
+    for (const token of ["INI_FILE_NAME", "motion.switchkins-type", "kinstype.is-0", "kinstype.is-1", "ini.[xyz].*"]) {
+      assert.ok(row.required_environment.includes(token), `${row.remap_code}: missing runtime environment ${token}`);
+    }
+    assert.equal(row.switchkins_output_pin, "motion.analog-out-03", `${row.remap_code}: output pin drift`);
+    assert.equal(row.switchkins_target, expected.target, `${row.remap_code}: target drift`);
+    assert.equal(row.active_g5x, expected.g5x, `${row.remap_code}: G5x drift`);
+    assert.equal(row.work_offset_pocket, expected.pocket, `${row.remap_code}: pocket drift`);
+    assert.equal(row.state_mode, expected.stateMode, `${row.remap_code}: state mode drift`);
+    assert.equal(row.state_target_count, "12", `${row.remap_code}: state target count drift`);
+    for (const pin of ["ini.x.min_limit", "ini.y.min_velocity", "ini.z.max_acceleration"]) {
+      assert.ok(row.expected_state_pins.includes(pin), `${row.remap_code}: missing expected pin ${pin}`);
+    }
+    assert.ok(row.expected_state_values.includes("ini.x.min_limit="), `${row.remap_code}: missing expected X limit value`);
+    assert.ok(row.expected_state_values.includes("ini.z.max_acceleration=400.0"), `${row.remap_code}: missing expected Z acceleration`);
+    assert.ok(
+      row.source_alignment_artifacts.includes("user-m-process-native-transition-alignment.tsv") &&
+        row.source_alignment_artifacts.includes("user-m-process-native-state-alignment.tsv"),
+      `${row.remap_code}: missing source alignment artifact references`,
+    );
+    assert.equal(row.source_alignment_ok, "1", `${row.remap_code}: source alignment must be complete before runtime plan`);
+    assert.equal(row.native_runtime_status, "pending_native_hal_tcl_process_probe", `${row.remap_code}: runtime status drift`);
+    assert.equal(row.proof_kind, "native_runtime_state_probe_required", `${row.remap_code}: proof kind drift`);
+    assert.equal(row.proof_status, "pending", `${row.remap_code}: runtime plan must remain pending`);
+    assert.equal(row.execution_enabled, "0", `${row.remap_code}: runtime plan must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.remap_code}: runtime plan must not allow promotion`);
+    assert.ok(row.notes.includes("keep_millturn_blocked"), `${row.remap_code}: runtime plan must keep millturn blocked`);
+  }
+
+  return parsedRows;
+}
+
+function commandPath(command) {
+  for (const dir of (process.env.PATH ?? "").split(":").filter(Boolean)) {
+    const candidate = resolve(dir, command);
+    try {
+      const stat = statSync(candidate);
+      if (stat.isFile() && (stat.mode & 0o111) !== 0) {
+        return candidate;
+      }
+    } catch {
+      // Continue searching PATH.
+    }
+  }
+  return "";
+}
+
+function userMProcessNativeRuntimeReadinessRows(runtimeStatePlanRows) {
+  const first = runtimeStatePlanRows[0];
+  if (!first) {
+    return [];
+  }
+
+  const requirements = [
+    ["host_command", "tclsh", "execute_config_user_m_tcl_scripts"],
+    ["host_command", "halrun", "start_isolated_hal_runtime"],
+    ["host_command", "halcmd", "create_and_read_hal_pins"],
+    ["host_command", "linuxcnc", "run_linuxcnc_owned_task_hal_environment"],
+  ];
+  const commandAvailability = new Map(
+    requirements.map(([, requirement]) => [requirement, commandPath(requirement)]),
+  );
+  const allAvailable = requirements.every(([, requirement]) =>
+    commandAvailability.get(requirement),
+  );
+  const nativeRuntimeStatus = allAvailable
+    ? "host_runtime_available_probe_not_implemented"
+    : "blocked_missing_host_runtime";
+
+  return requirements.map(([kind, requirement, purpose]) => {
+    const path = commandAvailability.get(requirement) ?? "";
+    return [
+      first.path,
+      first.ini,
+      first.blocked,
+      first.required_runtime,
+      kind,
+      requirement,
+      purpose,
+      flagValue(path !== ""),
+      path || "-",
+      nativeRuntimeStatus,
+      "native_runtime_state_probe_required",
+      "pending",
+      "0",
+      "0",
+      allAvailable
+        ? "runtime_commands_available_but_probe_still_not_implemented"
+        : "missing_host_runtime_keep_millturn_blocked",
+    ].map(tsvValue).join("\t");
+  });
+}
+
+function verifyUserMProcessNativeRuntimeReadinessRows(rows) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "required_runtime",
+    "requirement_kind",
+    "requirement",
+    "purpose",
+    "available",
+    "evidence",
+    "native_runtime_status",
+    "proof_kind",
+    "proof_status",
+    "execution_enabled",
+    "promotion_allowed",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const expectedRequirements = ["tclsh", "halrun", "halcmd", "linuxcnc"];
+
+  assert.deepEqual(
+    parsedRows.map((row) => row.requirement),
+    expectedRequirements,
+    "user-M native runtime readiness requirements drift",
+  );
+
+  for (const row of parsedRows) {
+    assert.equal(row.path, "axis/vismach/millturn/example.ngc", `${row.requirement}: path drift`);
+    assert.equal(row.ini, "axis/vismach/millturn/millturn.ini", `${row.requirement}: INI drift`);
+    assert.equal(row.blocked, "L4-USER-M-PROCESS", `${row.requirement}: blocked kind drift`);
+    assert.equal(row.required_runtime, "linuxcnc_task_hal_tcl_user_m_process", `${row.requirement}: runtime drift`);
+    assert.equal(row.requirement_kind, "host_command", `${row.requirement}: readiness kind drift`);
+    assert.ok(["0", "1"].includes(row.available), `${row.requirement}: invalid availability`);
+    assert.notEqual(row.purpose, "-", `${row.requirement}: missing purpose`);
+    if (row.available === "1") {
+      assert.notEqual(row.evidence, "-", `${row.requirement}: available command lacks evidence`);
+    }
+    assert.ok(
+      ["blocked_missing_host_runtime", "host_runtime_available_probe_not_implemented"].includes(row.native_runtime_status),
+      `${row.requirement}: invalid runtime status`,
+    );
+    assert.equal(row.proof_kind, "native_runtime_state_probe_required", `${row.requirement}: proof kind drift`);
+    assert.equal(row.proof_status, "pending", `${row.requirement}: readiness proof must remain pending`);
+    assert.equal(row.execution_enabled, "0", `${row.requirement}: readiness must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.requirement}: readiness must not allow promotion`);
+    assert.ok(
+      row.notes.includes("keep_millturn_blocked") ||
+        row.notes.includes("probe_still_not_implemented"),
+      `${row.requirement}: missing blocked/probe note`,
+    );
+  }
+
+  assert.ok(
+    parsedRows.some((row) => row.requirement === "tclsh" && row.available === "1"),
+    "tclsh must be available for the Tcl user-M readiness check",
+  );
+
+  return parsedRows;
+}
+
+function userMProcessNativeRuntimeProbeGateRows({ runtimeStatePlanRows, runtimeReadinessRows }) {
+  const readinessByRequirement = new Map(
+    runtimeReadinessRows.map((row) => [row.requirement, row]),
+  );
+
+  return runtimeStatePlanRows.map((row) => {
+    const missingRequirements = ["tclsh", "halrun", "halcmd", "linuxcnc"]
+      .filter((requirement) => readinessByRequirement.get(requirement)?.available !== "1");
+    const runtimeReady = missingRequirements.length === 0;
+    const sourceProofReady = (
+      row.source_alignment_ok === "1" &&
+      row.execution_enabled === "0" &&
+      row.promotion_allowed === "0"
+    );
+    const gateStatus = runtimeReady && sourceProofReady
+      ? "ready_to_implement_probe"
+      : "blocked_missing_host_runtime";
+
+    return [
+      row.path,
+      row.ini,
+      row.blocked,
+      row.runtime_step,
+      row.remap_code,
+      row.user_m_code,
+      row.required_runtime,
+      listValue(["tclsh", "halrun", "halcmd", "linuxcnc"].map((requirement) =>
+        `${requirement}:${readinessByRequirement.get(requirement)?.available ?? "0"}`,
+      )),
+      listValue(missingRequirements),
+      flagValue(runtimeReady),
+      flagValue(sourceProofReady),
+      row.proof_kind,
+      gateStatus,
+      "pending",
+      "0",
+      "0",
+      runtimeReady
+        ? "host_runtime_available_write_native_hal_tcl_state_probe"
+        : "missing_host_runtime_keep_millturn_blocked",
+    ].map(tsvValue).join("\t");
+  });
+}
+
+function verifyUserMProcessNativeRuntimeProbeGateRows({
+  rows,
+  runtimeStatePlanRows,
+  runtimeReadinessRows,
+}) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "runtime_step",
+    "remap_code",
+    "user_m_code",
+    "required_runtime",
+    "runtime_requirements",
+    "missing_requirements",
+    "runtime_ready",
+    "source_proof_ready",
+    "required_native_proof",
+    "gate_status",
+    "proof_status",
+    "execution_enabled",
+    "promotion_allowed",
+    "notes",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+
+  verifySamePathSet(
+    "wasm_user_m_process_native_runtime_probe_gate",
+    runtimeStatePlanRows.map((row) => `${row.remap_code}:${row.user_m_code}`).sort(),
+    parsedRows.map((row) => `${row.remap_code}:${row.user_m_code}`).sort(),
+  );
+
+  const allRuntimeReady = runtimeReadinessRows.every((row) => row.available === "1");
+  const expectedMissing = runtimeReadinessRows
+    .filter((row) => row.available !== "1")
+    .map((row) => row.requirement)
+    .sort();
+
+  for (const row of parsedRows) {
+    assert.equal(row.path, "axis/vismach/millturn/example.ngc", `${row.user_m_code}: path drift`);
+    assert.equal(row.ini, "axis/vismach/millturn/millturn.ini", `${row.user_m_code}: INI drift`);
+    assert.equal(row.blocked, "L4-USER-M-PROCESS", `${row.user_m_code}: blocked kind drift`);
+    assert.equal(row.required_runtime, "linuxcnc_task_hal_tcl_user_m_process", `${row.user_m_code}: runtime drift`);
+    assert.ok(["M428", "M429"].includes(row.remap_code), `${row.user_m_code}: remap code drift`);
+    assert.ok(["M128", "M129"].includes(row.user_m_code), `${row.user_m_code}: user-M code drift`);
+    for (const requirement of ["tclsh", "halrun", "halcmd", "linuxcnc"]) {
+      assert.ok(row.runtime_requirements.includes(`${requirement}:`), `${row.user_m_code}: missing runtime requirement ${requirement}`);
+    }
+    assert.equal(row.runtime_ready, flagValue(allRuntimeReady), `${row.user_m_code}: runtime readiness drift`);
+    assert.equal(row.source_proof_ready, "1", `${row.user_m_code}: source proof must be ready before runtime probe`);
+    assert.equal(row.required_native_proof, "native_runtime_state_probe_required", `${row.user_m_code}: proof kind drift`);
+    assert.equal(row.proof_status, "pending", `${row.user_m_code}: probe gate must remain pending`);
+    assert.equal(row.execution_enabled, "0", `${row.user_m_code}: probe gate must not enable execution`);
+    assert.equal(row.promotion_allowed, "0", `${row.user_m_code}: probe gate must not allow promotion`);
+
+    if (allRuntimeReady) {
+      assert.equal(row.missing_requirements, "-", `${row.user_m_code}: ready runtime has missing requirements`);
+      assert.equal(row.gate_status, "ready_to_implement_probe", `${row.user_m_code}: ready runtime gate status drift`);
+      assert.ok(row.notes.includes("write_native_hal_tcl_state_probe"), `${row.user_m_code}: ready runtime note drift`);
+    } else {
+      assert.deepEqual(
+        splitSummaryList(row.missing_requirements).sort(),
+        expectedMissing,
+        `${row.user_m_code}: missing runtime requirements drift`,
+      );
+      assert.equal(row.gate_status, "blocked_missing_host_runtime", `${row.user_m_code}: missing runtime gate status drift`);
+      assert.ok(row.notes.includes("keep_millturn_blocked"), `${row.user_m_code}: missing runtime note drift`);
+    }
+  }
+
+  return parsedRows;
+}
+
+function boundarySummaryRow(record, pathMatrixByPath) {
+  const matrixBlocked = pathMatrixByPath.get(record.path)?.blocked ?? "-";
+  const boundaryReport = runtimeBoundaryForRecord(record);
+
+  if (!boundaryReport.available) {
+    return [
+      record.path,
+      record.ini,
+      matrixBlocked,
+      "UNAVAILABLE",
+      `missing_vendored_ini:${boundaryReport.missingVendoredRel}`,
+      "-",
+      "-",
+      "0",
+      "-",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+    ].map(tsvValue).join("\t");
+  }
+
+  const boundary = boundaryReport.boundary;
+  return [
+    record.path,
+    record.ini,
+    matrixBlocked,
+    boundary.recommendedBlockedKind,
+    listValue(boundary.dependencies),
+    listValue(boundary.userMRuntime.executionCodes),
+    listValue(boundary.userMRuntime.unstagedExecutionCodes),
+    boundary.userMRuntime.vendoredExecutableCount,
+    boundary.toolDatabaseProgram || "-",
+    flagValue(boundary.halRuntime.requiresProcess),
+    flagValue(boundary.uiRuntime.requiresProcess),
+    flagValue(boundary.haluiRuntime.requiresProcess),
+    flagValue(boundary.pythonRuntime.requiresProcess),
+    flagValue(boundary.pythonRuntime.uiReferences.length > 0),
+    flagValue(boundary.pythonRuntime.remapReferences.length > 0),
+  ].map(tsvValue).join("\t");
+}
+
+function verifyBoundarySummaryRows(rows, expectedPaths, trackedMatrixByPath) {
+  const expectedHeaders = [
+    "path",
+    "ini",
+    "blocked",
+    "recommended_blocked",
+    "dependencies",
+    "user_m_execution_codes",
+    "user_m_unstaged_execution_codes",
+    "user_m_vendored_count",
+    "db_program",
+    "hal_process",
+    "ui_process",
+    "halui_mdi_process",
+    "python_process",
+    "python_ui_db_process",
+    "python_remap_process",
+  ];
+  const hardBlockedKinds = new Set([
+    "L4-TOOL-DB",
+    "L4-USER-M-PROCESS",
+    "L4-PYTHON-REMAP",
+  ]);
+  const allowedRecommendations = new Set(["-", "UNAVAILABLE", ...hardBlockedKinds]);
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+
+  verifySamePathSet(
+    "wasm_boundary_summary",
+    expectedPaths,
+    parsedRows.map((record) => record.path).sort(),
+  );
+
+  const requiredSafeProcessRepresentatives = new Map([
+    [
+      "axis/gladevcp/probe.ngc",
+      {
+        dependencies: "hal_process,python_runtime,ui_process",
+        hal_process: "1",
+        ui_process: "1",
+        halui_mdi_process: "0",
+        python_process: "1",
+        python_ui_db_process: "1",
+        python_remap_process: "0",
+      },
+    ],
+    [
+      "axis/vismach/melfa-sim/example.ngc",
+      {
+        dependencies: "hal_process,halui_mdi_process,ui_process",
+        hal_process: "1",
+        ui_process: "1",
+        halui_mdi_process: "1",
+        python_process: "0",
+        python_ui_db_process: "0",
+        python_remap_process: "0",
+      },
+    ],
+    [
+      "axis/vismach/puma/puma_cube.ngc",
+      {
+        dependencies: "hal_process,halui_mdi_process,ui_process",
+        hal_process: "1",
+        ui_process: "1",
+        halui_mdi_process: "1",
+        python_process: "0",
+        python_ui_db_process: "0",
+        python_remap_process: "0",
+      },
+    ],
+    [
+      "woodpecker/on_abort.ngc",
+      {
+        dependencies: "hal_process,ui_process",
+        hal_process: "1",
+        ui_process: "1",
+        halui_mdi_process: "0",
+        python_process: "0",
+        python_ui_db_process: "0",
+        python_remap_process: "0",
+      },
+    ],
+  ]);
+  const requiredDeterministicUserMRepresentatives = new Map([
+    ["axis/geometry/xyzc.ngc", "M110"],
+    ["axis/external_offsets/circles.ngc", "M111"],
+    ["axis/external_offsets/dyn_demo.ngc", "M111"],
+    ["axis/external_offsets/eoffsets.ngc", "M111"],
+    ["axis/external_offsets/jwp_z.ngc", "M111"],
+    ["axis/external_offsets/opa_demo.ngc", "M111"],
+  ]);
+
+  for (const row of parsedRows) {
+    assert.ok(allowedRecommendations.has(row.recommended_blocked), `${row.path}: unknown recommended block ${row.recommended_blocked}`);
+    assert.ok(/^[0-9]+$/.test(row.user_m_vendored_count), `${row.path}: invalid user-M count`);
+    for (const field of [
+      "hal_process",
+      "ui_process",
+      "halui_mdi_process",
+      "python_process",
+      "python_ui_db_process",
+      "python_remap_process",
+    ]) {
+      assert.ok(["0", "1"].includes(row[field]), `${row.path}: invalid ${field} flag`);
+    }
+    if (vendoredConfigPathExists(`configs/sim/${row.ini}`)) {
+      assert.notEqual(
+        row.recommended_blocked,
+        "UNAVAILABLE",
+        `${row.path}: vendored INI lacks runtime-boundary report`,
+      );
+    }
+    if (row.recommended_blocked === "UNAVAILABLE") {
+      assert.ok(
+        row.dependencies.startsWith("missing_vendored_ini:"),
+        `${row.path}: unavailable boundary row lacks missing INI evidence`,
+      );
+    }
+
+    if (
+      hardBlockedKinds.has(row.blocked) &&
+      row.recommended_blocked !== "UNAVAILABLE"
+    ) {
+      assert.equal(
+        row.recommended_blocked,
+        row.blocked,
+        `${row.path}: boundary-summary hard blocked drift`,
+      );
+    }
+    if (hardBlockedKinds.has(row.recommended_blocked) && row.blocked !== "ASSET-ONLY") {
+      assert.equal(
+        row.blocked,
+        row.recommended_blocked,
+        `${row.path}: classifier recommended hard block not reflected in matrix`,
+      );
+    }
+    if (row.recommended_blocked === "L4-TOOL-DB") {
+      assert.notEqual(row.db_program, "-", `${row.path}: tool DB block requires DB_PROGRAM`);
+    }
+    if (row.recommended_blocked === "L4-USER-M-PROCESS") {
+      assert.notEqual(
+        row.user_m_execution_codes,
+        "-",
+        `${row.path}: user-M process block requires execution codes`,
+      );
+      assert.notEqual(
+        row.user_m_unstaged_execution_codes,
+        "-",
+        `${row.path}: user-M process block requires unstaged execution codes`,
+      );
+    }
+    if (row.recommended_blocked === "L4-PYTHON-REMAP") {
+      assert.equal(
+        row.python_remap_process,
+        "1",
+        `${row.path}: Python remap block requires Python remap process evidence`,
+      );
+    }
+
+    if (requiredSafeProcessRepresentatives.has(row.path)) {
+      const expected = requiredSafeProcessRepresentatives.get(row.path);
+      const tracked = trackedMatrixByPath.get(row.path);
+      assert.ok(tracked, `${row.path}: safe process representative missing tracked row`);
+      assert.equal(row.blocked, "-", `${row.path}: safe process representative must not be blocked`);
+      assert.equal(
+        row.recommended_blocked,
+        "-",
+        `${row.path}: safe process representative must not recommend hard block`,
+      );
+      assert.equal(
+        tracked.layer4Node,
+        "REP",
+        `${row.path}: safe process representative must remain Node REP`,
+      );
+      assert.equal(
+        tracked.layer4Browser,
+        "REP",
+        `${row.path}: safe process representative must remain browser REP`,
+      );
+      assert.notEqual(
+        row.dependencies,
+        "-",
+        `${row.path}: safe process representative should declare its process dependencies`,
+      );
+      assert.equal(
+        row.dependencies,
+        expected.dependencies,
+        `${row.path}: safe process representative dependency drift`,
+      );
+      for (const field of [
+        "hal_process",
+        "ui_process",
+        "halui_mdi_process",
+        "python_process",
+        "python_ui_db_process",
+        "python_remap_process",
+      ]) {
+        assert.equal(
+          row[field],
+          expected[field],
+          `${row.path}: safe process representative ${field} drift`,
+        );
+      }
+    }
+
+    if (requiredDeterministicUserMRepresentatives.has(row.path)) {
+      const expectedCode = requiredDeterministicUserMRepresentatives.get(row.path);
+      assert.equal(row.blocked, "-", `${row.path}: deterministic user-M representative must not be blocked`);
+      assert.equal(
+        row.recommended_blocked,
+        "-",
+        `${row.path}: deterministic user-M representative must not recommend hard block`,
+      );
+      assert.equal(
+        row.user_m_execution_codes,
+        expectedCode,
+        `${row.path}: deterministic user-M execution code drift`,
+      );
+      assert.equal(
+        row.user_m_unstaged_execution_codes,
+        "-",
+        `${row.path}: deterministic user-M representative must not call unstaged user-M files`,
+      );
+      assert.notEqual(
+        row.user_m_vendored_count,
+        "0",
+        `${row.path}: deterministic user-M representative lacks vendored user-M file`,
+      );
+    }
+  }
+
+  return parsedRows;
+}
+
+function iniBoundarySummaryRows(boundaryRows) {
+  const byIni = new Map();
+  for (const row of boundaryRows) {
+    const entry = byIni.get(row.ini) ?? [];
+    entry.push(row);
+    byIni.set(row.ini, entry);
+  }
+
+  return [...byIni.entries()]
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([ini, rows]) => {
+      const vendored = vendoredConfigPathExists(`configs/sim/${ini}`);
+      const recommendations = uniqueSorted(rows.map((row) => row.recommended_blocked));
+      const hardRecommendations = recommendations.filter((value) =>
+        ["L4-TOOL-DB", "L4-USER-M-PROCESS", "L4-PYTHON-REMAP"].includes(value),
+      );
+      const blockedKinds = uniqueSorted(rows.map((row) => row.blocked));
+      return [
+        ini,
+        String(rows.length),
+        flagValue(vendored),
+        flagValue(vendored && rows.every((row) => row.recommended_blocked !== "UNAVAILABLE")),
+        listValue(blockedKinds),
+        listValue(recommendations),
+        listValue(uniqueSorted(rows.flatMap((row) =>
+          row.dependencies === "-" ? [] : row.dependencies.split(","),
+        ))),
+        listValue(uniqueSorted(rows.flatMap((row) =>
+          row.user_m_execution_codes === "-" ? [] : row.user_m_execution_codes.split(","),
+        ))),
+        listValue(uniqueSorted(rows.flatMap((row) =>
+          row.user_m_unstaged_execution_codes === "-" ? [] : row.user_m_unstaged_execution_codes.split(","),
+        ))),
+        String(Math.max(...rows.map((row) => Number(row.user_m_vendored_count)))),
+        listValue(uniqueSorted(rows.map((row) => row.db_program).filter((value) => value !== "-"))),
+        flagValue(rows.some((row) => row.hal_process === "1")),
+        flagValue(rows.some((row) => row.ui_process === "1")),
+        flagValue(rows.some((row) => row.halui_mdi_process === "1")),
+        flagValue(rows.some((row) => row.python_process === "1")),
+        flagValue(rows.some((row) => row.python_ui_db_process === "1")),
+        flagValue(rows.some((row) => row.python_remap_process === "1")),
+        flagValue(hardRecommendations.length === 0 || rows.some((row) => row.blocked === hardRecommendations[0])),
+      ].map(tsvValue).join("\t");
+    });
+}
+
+function verifyIniBoundarySummaryRows(rows, boundaryRows) {
+  const expectedHeaders = [
+    "ini",
+    "path_count",
+    "vendored",
+    "report_available",
+    "blocked",
+    "recommended_blocked",
+    "dependencies",
+    "user_m_execution_codes",
+    "user_m_unstaged_execution_codes",
+    "user_m_vendored_count",
+    "db_program",
+    "hal_process",
+    "ui_process",
+    "halui_mdi_process",
+    "python_process",
+    "python_ui_db_process",
+    "python_remap_process",
+    "hard_block_policy_aligned",
+  ];
+  const parsedRows = parseTsv(
+    `${expectedHeaders.join("\t")}\n${rows.join("\n")}\n`,
+    expectedHeaders,
+  );
+  const expectedInis = uniqueSorted(boundaryRows.map((row) => row.ini));
+
+  verifySamePathSet(
+    "wasm_ini_boundary_summary",
+    expectedInis,
+    parsedRows.map((row) => row.ini).sort(),
+  );
+
+  for (const row of parsedRows) {
+    assert.ok(/^[1-9][0-9]*$/.test(row.path_count), `${row.ini}: invalid path count`);
+    for (const field of [
+      "vendored",
+      "report_available",
+      "hal_process",
+      "ui_process",
+      "halui_mdi_process",
+      "python_process",
+      "python_ui_db_process",
+      "python_remap_process",
+      "hard_block_policy_aligned",
+    ]) {
+      assert.ok(["0", "1"].includes(row[field]), `${row.ini}: invalid ${field}`);
+    }
+    assert.ok(/^[0-9]+$/.test(row.user_m_vendored_count), `${row.ini}: invalid user-M count`);
+    if (row.vendored === "1") {
+      assert.equal(row.report_available, "1", `${row.ini}: vendored INI lacks classifier report`);
+    }
+    assert.equal(row.hard_block_policy_aligned, "1", `${row.ini}: hard block recommendation lacks matrix alignment`);
+    if (row.recommended_blocked.split(",").includes("L4-TOOL-DB")) {
+      assert.notEqual(row.db_program, "-", `${row.ini}: tool DB recommendation lacks DB_PROGRAM`);
+    }
+    if (row.recommended_blocked.split(",").includes("L4-USER-M-PROCESS")) {
+      assert.notEqual(row.user_m_unstaged_execution_codes, "-", `${row.ini}: user-M recommendation lacks unstaged codes`);
+    }
+    if (row.recommended_blocked.split(",").includes("L4-PYTHON-REMAP")) {
+      assert.equal(row.python_remap_process, "1", `${row.ini}: Python-remap recommendation lacks remap process flag`);
+    }
+  }
+
+  return parsedRows;
+}
+
+function isRuntimeEdgeExpectedFail(record) {
+  return [
+    "ini-axis-mask-UV",
+    "ini-axis-mask-W",
+    "user-m-code-M110",
+    "user-m-code-M111",
+  ].includes(record.expected_failure);
+}
+
+function executionModeFor(record) {
+  if (
+    record.path === "axis/vismach/5axis/bridgemill/5axisgui.ngc" ||
+    record.path.startsWith("axis/vismach/5axis/table-dual-rotary/") ||
+    record.path.startsWith("axis/vismach/5axis/table-rotary-tilting/") ||
+    record.path.startsWith("axis/vismach/melfa-sim/")
+  ) {
+    return "fiveAxisRemap";
+  }
+  return "fileWithIni";
+}
+
+function verifyInventoryCase(record, output, executionMode) {
+  if (record.status === "PASS") {
+    if (executionMode === "fiveAxisRemap") {
+      verifyExpectedOutput(
+        `inventory_${record.path}`,
+        output,
+        [
+          "fiveaxis_ini_open=1",
+          "fiveaxis_tool_table_load=0",
+          "fiveaxis_file_open=0",
+          "fiveaxis_file_reached_exit=1",
+          "fiveaxis_linuxcnc_remap_file_execute=1",
+        ].join("\n"),
+      );
+      return;
+    }
+
+    verifyExpectedOutput(
+      `inventory_${record.path}`,
+      output,
+      [
+        "file_open=0",
+        "file_saw_error=0",
+        "canon_event=PROGRAM_END",
+        "absent=file_error_text=",
+      ].join("\n"),
+    );
+    return;
+  }
+
+  if (record.path === "axis/foam/foam.ngc") {
+    verifyExpectedOutput(
+      "inventory_axis_foam",
+      output,
+      [
+        "file_open=0",
+        "file_saw_error=0",
+        "canon_event=PROGRAM_END",
+        "absent=Bad character 'u' used",
+        "absent=Bad character 'v' used",
+      ].join("\n"),
+    );
+    return;
+  }
+
+  if (record.path === "axis/geometry/xyzc.ngc") {
+    verifyExpectedOutput(
+      "inventory_axis_geometry_xyzc",
+      output,
+      [
+        "file_open=0",
+        "file_saw_error=0",
+        "canon_event=USER_M_COMMAND code=M110",
+        "canon_event=PROGRAM_END",
+        "absent=Unknown m code used: M110",
+      ].join("\n"),
+    );
+    return;
+  }
+
+  if (record.path.startsWith("axis/external_offsets/")) {
+    verifyExpectedOutput(
+      `inventory_${record.path}`,
+      output,
+      [
+        "file_open=0",
+        "file_saw_error=0",
+        "canon_event=USER_M_COMMAND code=M111",
+        "canon_event=PROGRAM_END",
+        "absent=Unknown m code used: M111",
+        "absent=Bad character",
+        "absent=Cannot use axis values",
+      ].join("\n"),
+    );
+    return;
+  }
+
+  if (record.path === "axis/vismach/5axis/bridgemill/5axisgui.ngc") {
+    verifyExpectedOutput(
+      "inventory_axis_bridgemill",
+      output,
+      [
+        "fiveaxis_ini_open=1",
+        "fiveaxis_tool_table_load=0",
+        "fiveaxis_parse_remap_1=0",
+        "fiveaxis_parse_remap_2=0",
+        "fiveaxis_parse_remap_3=0",
+        "fiveaxis_parsed_remap_count=3",
+        "fiveaxis_remaps_ready=1",
+        "fiveaxis_file_open=0",
+        "fiveaxis_file_reached_exit=1",
+        "fiveaxis_linuxcnc_remap_file_execute=1",
+        "absent=Bad character 'w' used",
+      ].join("\n"),
+    );
+    return;
+  }
+
+  throw new Error(`unexpected expected-fail inventory case: ${record.path}`);
+}
+
+const nativeRecords = parseTsv(readFileSync(nativeSummaryPath, "utf8"), [
+  "path",
+  "class",
+  "status",
+  "expected_failure",
+  "exit_code",
+  "seconds",
+  "ini",
+  "tbl",
+  "output_lines",
+  "stderr_summary",
+]);
+const classSummaryRecords = parseTsv(readFileSync(nativeClassSummaryPath, "utf8"), [
+  "class",
+  "status",
+  "expected_failure",
+  "count",
+]);
+const pathMatrixRecords = parseTsv(readFileSync(nativePathMatrixPath, "utf8"), [
+  "path",
+  "class",
+  "status",
+  "expected_failure",
+  "ini",
+  "tbl",
+  "runtime_family",
+  "blocked",
+]);
+const pathMatrixByPath = new Map(pathMatrixRecords.map((record) => [record.path, record]));
+const nativePaths = sortedPaths(nativeRecords);
+const trackedMatrixText = readFileSync(trackedMatrixPath, "utf8");
+const trackedMatrixRecords = parseTrackedMatrix(trackedMatrixText);
+const trackedMatrixByPath = new Map(trackedMatrixRecords.map((record) => [record.path, record]));
+const trackedClassSummaryRows = parseTrackedSummaryTable(trackedMatrixText, "Summary", "class");
+const trackedFamilySummaryRows = parseTrackedSummaryTable(
+  trackedMatrixText,
+  "Family Summary",
+  "family",
+);
+verifyUniquePaths("native_summary", nativeRecords);
+verifyUniquePaths("native_path_matrix", pathMatrixRecords);
+verifyUniquePaths("tracked_sim_configs_coverage_matrix", trackedMatrixRecords);
+verifySamePathSet(
+  "native_path_matrix",
+  nativePaths,
+  sortedPaths(pathMatrixRecords),
+);
+verifySamePathSet(
+  "tracked_sim_configs_coverage_matrix",
+  nativePaths,
+  trackedMatrixRecords.map((record) => record.path).sort(),
+);
+verifyClassesAndStatuses(nativeRecords);
+verifyClassesAndStatuses(pathMatrixRecords);
+verifyClassesAndStatuses(trackedMatrixRecords);
+verifyNativeExpectedFailures(nativeRecords);
+verifyMatrixExpectedFailures(pathMatrixRecords);
+verifyMatrixExpectedFailures(trackedMatrixRecords);
+verifyBlockedKinds(pathMatrixRecords);
+verifyBlockedKinds(trackedMatrixRecords);
+verifyLayerMarkers(trackedMatrixRecords);
+verifyTrackedMatrixNotes(trackedMatrixRecords);
+verifyTrackedSummaryTables(trackedMatrixRecords, trackedClassSummaryRows, trackedFamilySummaryRows);
+verifyRequiredClassRepresentatives(trackedMatrixRecords);
+verifyPathMatrixFields(nativeRecords, pathMatrixByPath);
+verifyTrackedMatrixFields(trackedMatrixRecords, pathMatrixByPath);
+verifyRuntimeBoundaryPolicy(nativeRecords, pathMatrixByPath);
+verifyClassSummaryRows(classSummaryRecords);
+assert.deepEqual(
+  classSummaryRowsFromGenerated(classSummaryRecords),
+  classSummaryRowsFromNativeRecords(nativeRecords),
+  "native class-summary.tsv must match summary.tsv-derived counts",
+);
+
+const boundarySummaryRows = nativeRecords.map((record) =>
+  boundarySummaryRow(record, pathMatrixByPath),
+);
+const boundarySummaryRecords = verifyBoundarySummaryRows(
+  boundarySummaryRows,
+  nativePaths,
+  trackedMatrixByPath,
+);
+const iniBoundarySummaryRowsGenerated = iniBoundarySummaryRows(boundarySummaryRecords);
+const iniBoundarySummaryRecords = verifyIniBoundarySummaryRows(
+  iniBoundarySummaryRowsGenerated,
+  boundarySummaryRecords,
+);
+
+const blockedDependencyRecords = nativeRecords.filter((record) =>
+  ["L4-PYTHON-REMAP", "L4-TOOL-DB", "L4-USER-M-PROCESS"].includes(
+    pathMatrixByPath.get(record.path)?.blocked ?? "-",
+  ),
+);
+const blockedDependencySummaryRows = blockedDependencyRecords.map((record) =>
+  blockedDependencySummaryRow(record, pathMatrixByPath),
+);
+const blockedDependencySummaryRecords = verifyBlockedDependencySummaryRows(
+  blockedDependencySummaryRows,
+  blockedDependencyRecords,
+);
+verifyFullProcessBoundaryDesign(
+  readFileSync(fullProcessBoundaryDesignPath, "utf8"),
+  blockedDependencySummaryRecords,
+);
+const fullProcessBoundarySummaryRows = blockedDependencySummaryRecords
+  .map(fullProcessBoundarySummaryRow)
+  .filter(Boolean);
+const fullProcessBoundarySummaryRecords = verifyFullProcessBoundarySummaryRows(
+  fullProcessBoundarySummaryRows,
+  blockedDependencySummaryRecords,
+);
+const userMProcessBoundarySummaryRows = blockedDependencySummaryRecords
+  .map(userMProcessBoundarySummaryRow)
+  .filter(Boolean);
+const userMProcessBoundarySummaryRecords = verifyUserMProcessBoundarySummaryRows(
+  userMProcessBoundarySummaryRows,
+  blockedDependencySummaryRecords,
+);
+const userMProcessStateTargetRowsGenerated = blockedDependencySummaryRecords
+  .flatMap(userMProcessStateTargetRows);
+const userMProcessStateTargetRecords = verifyUserMProcessStateTargetRows(
+  userMProcessStateTargetRowsGenerated,
+  blockedDependencySummaryRecords,
+);
+const userMProcessTransitionPlanRowsGenerated = userMProcessTransitionPlanRows(
+  userMProcessStateTargetRecords,
+);
+const userMProcessTransitionPlanRecords = verifyUserMProcessTransitionPlanRows(
+  userMProcessTransitionPlanRowsGenerated,
+  userMProcessStateTargetRecords,
+);
+const userMProcessNativeStateAlignmentRowsGenerated =
+  userMProcessNativeStateAlignmentRows(userMProcessStateTargetRecords);
+const userMProcessNativeStateAlignmentRecords = verifyUserMProcessNativeStateAlignmentRows(
+  userMProcessNativeStateAlignmentRowsGenerated,
+  userMProcessStateTargetRecords,
+);
+const userMProcessNativeTransitionAlignmentRowsGenerated =
+  userMProcessNativeTransitionAlignmentRows(userMProcessTransitionPlanRecords);
+const userMProcessNativeTransitionAlignmentRecords = verifyUserMProcessNativeTransitionAlignmentRows(
+  userMProcessNativeTransitionAlignmentRowsGenerated,
+  userMProcessTransitionPlanRecords,
+);
+const userMProcessNativeRuntimeStatePlanRowsGenerated =
+  userMProcessNativeRuntimeStatePlanRows({
+    transitionRows: userMProcessTransitionPlanRecords,
+    stateTargetRows: userMProcessStateTargetRecords,
+    transitionAlignmentRows: userMProcessNativeTransitionAlignmentRecords,
+  });
+const userMProcessNativeRuntimeStatePlanRecords = verifyUserMProcessNativeRuntimeStatePlanRows(
+  userMProcessNativeRuntimeStatePlanRowsGenerated,
+  userMProcessTransitionPlanRecords,
+);
+const userMProcessNativeRuntimeReadinessRowsGenerated =
+  userMProcessNativeRuntimeReadinessRows(userMProcessNativeRuntimeStatePlanRecords);
+const userMProcessNativeRuntimeReadinessRecords = verifyUserMProcessNativeRuntimeReadinessRows(
+  userMProcessNativeRuntimeReadinessRowsGenerated,
+);
+const userMProcessNativeRuntimeProbeGateRowsGenerated =
+  userMProcessNativeRuntimeProbeGateRows({
+    runtimeStatePlanRows: userMProcessNativeRuntimeStatePlanRecords,
+    runtimeReadinessRows: userMProcessNativeRuntimeReadinessRecords,
+  });
+const userMProcessNativeRuntimeProbeGateRecords =
+  verifyUserMProcessNativeRuntimeProbeGateRows({
+    rows: userMProcessNativeRuntimeProbeGateRowsGenerated,
+    runtimeStatePlanRows: userMProcessNativeRuntimeStatePlanRecords,
+    runtimeReadinessRows: userMProcessNativeRuntimeReadinessRecords,
+  });
+const toolDbProcessBoundarySummaryRows = blockedDependencySummaryRecords
+  .map(toolDbProcessBoundarySummaryRow)
+  .filter(Boolean);
+const toolDbProcessBoundarySummaryRecords = verifyToolDbProcessBoundarySummaryRows(
+  toolDbProcessBoundarySummaryRows,
+  blockedDependencySummaryRecords,
+);
+const toolDbProcessProtocolGateRowsGenerated = blockedDependencySummaryRecords
+  .flatMap(toolDbProcessProtocolGateRows);
+const toolDbProcessProtocolGateRecords = verifyToolDbProcessProtocolGateRows(
+  toolDbProcessProtocolGateRowsGenerated,
+  blockedDependencySummaryRecords,
+);
+const toolDbProcessTransactionPlanRowsGenerated = toolDbProcessTransactionPlanRows(
+  toolDbProcessProtocolGateRecords,
+);
+const toolDbProcessTransactionPlanRecords = verifyToolDbProcessTransactionPlanRows(
+  toolDbProcessTransactionPlanRowsGenerated,
+  toolDbProcessProtocolGateRecords,
+);
+const toolDbProcessNativeProtocolAlignmentRowsGenerated =
+  toolDbProcessNativeProtocolAlignmentRows(toolDbProcessProtocolGateRecords);
+const toolDbProcessNativeProtocolAlignmentRecords = verifyToolDbProcessNativeProtocolAlignmentRows(
+  toolDbProcessNativeProtocolAlignmentRowsGenerated,
+  toolDbProcessProtocolGateRecords,
+);
+const toolDbProcessNativeRuntimeReadinessRowsGenerated =
+  toolDbProcessNativeRuntimeReadinessRows(toolDbProcessTransactionPlanRecords);
+const toolDbProcessNativeRuntimeReadinessRecords = verifyToolDbProcessNativeRuntimeReadinessRows(
+  toolDbProcessNativeRuntimeReadinessRowsGenerated,
+);
+const pythonRemapBoundarySummaryRows = blockedDependencySummaryRecords
+  .map(pythonRemapBoundarySummaryRow)
+  .filter(Boolean);
+const pythonRemapBoundarySummaryRecords = verifyPythonRemapBoundarySummaryRows(
+  pythonRemapBoundarySummaryRows,
+  blockedDependencySummaryRecords,
+);
+const pythonRemapRuntimeGateRowsGenerated = pythonRemapBoundarySummaryRecords
+  .flatMap(pythonRemapRuntimeGateRows);
+const pythonRemapRuntimeGateRecords = verifyPythonRemapRuntimeGateRows(
+  pythonRemapRuntimeGateRowsGenerated,
+  pythonRemapBoundarySummaryRecords,
+);
+const pythonRemapNativeRuntimeAlignmentRowsGenerated =
+  pythonRemapNativeRuntimeAlignmentRows(pythonRemapRuntimeGateRecords);
+const pythonRemapNativeRuntimeAlignmentRecords = verifyPythonRemapNativeRuntimeAlignmentRows(
+  pythonRemapNativeRuntimeAlignmentRowsGenerated,
+  pythonRemapRuntimeGateRecords,
+);
+const pythonRemapFamilyRows = pythonRemapFamilySummaryRows(
+  pythonRemapBoundarySummaryRecords,
+);
+const pythonRemapFamilyRecords = verifyPythonRemapFamilySummaryRows(
+  pythonRemapFamilyRows,
+  pythonRemapBoundarySummaryRecords,
+);
+const pythonRemapRuntimeContractRowsGenerated = pythonRemapRuntimeContractRows(
+  pythonRemapFamilyRecords,
+);
+const pythonRemapRuntimeContractRecords = verifyPythonRemapRuntimeContractRows(
+  pythonRemapRuntimeContractRowsGenerated,
+  pythonRemapFamilyRecords,
+);
+const pythonRemapNativeRuntimeReadinessRowsGenerated =
+  pythonRemapNativeRuntimeReadinessRows(pythonRemapRuntimeContractRecords);
+const pythonRemapNativeRuntimeReadinessRecords = verifyPythonRemapNativeRuntimeReadinessRows(
+  pythonRemapNativeRuntimeReadinessRowsGenerated,
+  pythonRemapRuntimeContractRecords,
+);
+const pythonRemapNativeRuntimeStatePlanRowsGenerated =
+  pythonRemapNativeRuntimeStatePlanRows({
+    contractRows: pythonRemapRuntimeContractRecords,
+    readinessRows: pythonRemapNativeRuntimeReadinessRecords,
+    alignmentRows: pythonRemapNativeRuntimeAlignmentRecords,
+  });
+const pythonRemapNativeRuntimeStatePlanRecords = verifyPythonRemapNativeRuntimeStatePlanRows({
+  rows: pythonRemapNativeRuntimeStatePlanRowsGenerated,
+  contractRows: pythonRemapRuntimeContractRecords,
+  readinessRows: pythonRemapNativeRuntimeReadinessRecords,
+});
+const pythonRemapNativeRuntimeFixturePlanRowsGenerated =
+  pythonRemapNativeRuntimeFixturePlanRows(pythonRemapNativeRuntimeStatePlanRecords);
+const pythonRemapNativeRuntimeFixturePlanRecords = verifyPythonRemapNativeRuntimeFixturePlanRows(
+  pythonRemapNativeRuntimeFixturePlanRowsGenerated,
+  pythonRemapNativeRuntimeStatePlanRecords,
+);
+
+const summaryRows = [];
+const skipReasonCounts = new Map();
+let executed = 0;
+let passed = 0;
+let skipped = 0;
+let unexpectedFail = 0;
+
+function recordSkip(reason) {
+  skipped += 1;
+  skipReasonCounts.set(reason, (skipReasonCounts.get(reason) ?? 0) + 1);
+}
+
+function skipReasonLogKey(reason) {
+  return reason.replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+
+function verifyInventorySummaryRows(rows, trackedMatrixByPath) {
+  const allowedInventoryStatuses = new Set(["PASS", "SKIP", "FAIL"]);
+  const allowedSkipReasons = new Set([
+    "ASSET-ONLY",
+    "L4-PYTHON-REMAP",
+    "L4-TOOL-DB",
+    "L4-USER-M-PROCESS",
+    "NON_MAIN_CLASS",
+    "UNMAPPED_EXPECTED_FAILURE",
+    "UPSTREAM-DEMO",
+  ]);
+
+  for (const row of rows) {
+    const [
+      path,
+      inventoryStatus,
+      reason,
+      className,
+      nativeStatus,
+      nativeExpectedFailure,
+    ] = row.split("\t");
+    assert.ok(path, "Node inventory summary row missing path");
+    assert.ok(
+      allowedInventoryStatuses.has(inventoryStatus),
+      `${path}: unknown inventory status ${inventoryStatus}`,
+    );
+    verifyClassesAndStatuses([{ path, class: className, status: nativeStatus }]);
+    verifyMatrixExpectedFailures([
+      { path, status: nativeStatus, expected_failure: nativeExpectedFailure },
+    ]);
+
+    if (inventoryStatus === "PASS") {
+      assert.equal(reason, "-", `${path}: PASS inventory row has reason ${reason}`);
+      const tracked = trackedMatrixByPath.get(path);
+      assert.ok(tracked, `${path}: PASS inventory row missing tracked matrix record`);
+      assert.ok(
+        ["REP", "INV"].includes(tracked.layer4Node),
+        `${path}: PASS inventory row must be marked REP or INV in Layer 4 Node`,
+      );
+    } else if (inventoryStatus === "SKIP") {
+      assert.ok(allowedSkipReasons.has(reason), `${path}: unknown skip reason ${reason}`);
+    } else {
+      assert.notEqual(reason, "-", `${path}: FAIL inventory row lacks reason`);
+    }
+  }
+}
+
+function verifySkipSummaryRows(rows, expectedSkipped, nativeRecords, pathMatrixByPath) {
+  const allowedSkipReasons = new Set([
+    "ASSET-ONLY",
+    "L4-PYTHON-REMAP",
+    "L4-TOOL-DB",
+    "L4-USER-M-PROCESS",
+    "NON_MAIN_CLASS",
+    "UNMAPPED_EXPECTED_FAILURE",
+    "UPSTREAM-DEMO",
+  ]);
+  let total = 0;
+
+  const actualCounts = new Map();
+  for (const row of rows) {
+    const [reason, countText] = row.split("\t");
+    assert.ok(allowedSkipReasons.has(reason), `unknown skip-summary reason ${reason}`);
+    assert.ok(/^[1-9][0-9]*$/.test(countText), `${reason}: invalid skip count ${countText}`);
+    const count = Number(countText);
+    actualCounts.set(reason, count);
+    total += count;
+  }
+
+  assert.equal(total, expectedSkipped, "skip-summary rows must add up to skipped count");
+
+  const expectedCounts = new Map();
+  for (const record of nativeRecords) {
+    const reason = blockedKind(record, pathMatrixByPath);
+    if (!reason) {
+      continue;
+    }
+    expectedCounts.set(reason, (expectedCounts.get(reason) ?? 0) + 1);
+  }
+
+  assert.deepEqual(
+    [...actualCounts.entries()].sort(),
+    [...expectedCounts.entries()].sort(),
+    "skip-summary rows must match matrix-derived blocked and class counts",
+  );
+}
+
+function verifyHardBlockedInventorySkips(rows, pathMatrixByPath) {
+  const hardBlockedKinds = new Set([
+    "L4-PYTHON-REMAP",
+    "L4-TOOL-DB",
+    "L4-USER-M-PROCESS",
+  ]);
+  const byPath = new Map(rows.map((row) => {
+    const [path, inventoryStatus, reason] = row.split("\t");
+    return [path, { inventoryStatus, reason }];
+  }));
+
+  for (const [path, matrixRecord] of pathMatrixByPath) {
+    const reason = matrixRecord.blocked;
+    if (!hardBlockedKinds.has(reason)) {
+      continue;
+    }
+    const row = byPath.get(path);
+    assert.ok(row, `${path}: hard-blocked inventory row missing`);
+    assert.equal(row.inventoryStatus, "SKIP", `${path}: blocked row must stay skipped`);
+    assert.equal(row.reason, reason, `${path}: blocked row skip reason drift`);
+  }
+}
+
+for (const record of nativeRecords) {
+  const skipReason = blockedKind(record, pathMatrixByPath);
+  if (skipReason) {
+    recordSkip(skipReason);
+    summaryRows.push(
+      [
+        record.path,
+        "SKIP",
+        skipReason,
+        record.class,
+        record.status,
+        record.expected_failure || "-",
+      ].join("\t"),
+    );
+    continue;
+  }
+
+  const missingVendoredRel = missingVendoredConfig(record);
+  if (missingVendoredRel) {
+    unexpectedFail += 1;
+    summaryRows.push(
+      [
+        record.path,
+        "FAIL",
+        `MISSING_VENDORED_CONFIG:${missingVendoredRel}`,
+        record.class,
+        record.status,
+        record.expected_failure || "-",
+      ].join("\t"),
+    );
+    continue;
+  }
+
+  if (record.status !== "PASS" && !isRuntimeEdgeExpectedFail(record)) {
+    recordSkip("UNMAPPED_EXPECTED_FAILURE");
+    summaryRows.push(
+      [
+        record.path,
+        "SKIP",
+        "UNMAPPED_EXPECTED_FAILURE",
+        record.class,
+        record.status,
+        record.expected_failure || "-",
+      ].join("\t"),
+    );
+    continue;
+  }
+
+  const machineRel = posix.dirname(record.ini);
+  const iniFile = basename(record.ini);
+  const programFile = posix.relative(machineRel, record.path);
+  const executionMode = executionModeFor(record);
+
+  try {
+    const machine = simMachine(machineRel, iniFile, programFile, record.tbl);
+    const output = interp.runSimConfigProgram({
+      files: machine.files,
+      programPath: machine.programPath,
+      iniPath: machine.iniPath,
+      executionMode,
+    });
+    verifyInventoryCase(record, output, executionMode);
+    executed += 1;
+    passed += 1;
+    summaryRows.push(
+      [
+        record.path,
+        "PASS",
+        "-",
+        record.class,
+        record.status,
+        record.expected_failure || "-",
+      ].join("\t"),
+    );
+  } catch (error) {
+    executed += 1;
+    unexpectedFail += 1;
+    summaryRows.push(
+      [
+        record.path,
+        "FAIL",
+        error instanceof Error ? error.message.replace(/\s+/g, " ").trim() : String(error),
+        record.class,
+        record.status,
+        record.expected_failure || "-",
+      ].join("\t"),
+    );
+  }
+}
+
+assert.equal(
+  summaryRows.length,
+  nativeRecords.length,
+  "Node inventory summary must contain exactly one row per native sim-config record",
+);
+assert.equal(
+  executed + skipped,
+  nativeRecords.length,
+  "Node inventory executed plus skipped rows must cover every native sim-config record",
+);
+assert.equal(
+  [...skipReasonCounts.values()].reduce((total, count) => total + count, 0),
+  skipped,
+  "Node inventory skip-summary counts must match skipped row count",
+);
+verifyInventorySummaryRows(summaryRows, trackedMatrixByPath);
+verifyHardBlockedInventorySkips(summaryRows, pathMatrixByPath);
+verifyTrackedBaselineText(
+  trackedMatrixText,
+  nativeRecords,
+  { executed, passed, skipped, unexpectedFail },
+  skipReasonCounts,
+);
+
+const nextBoundaryRows = nextBoundaryWorklistRows({
+  fullProcessRows: fullProcessBoundarySummaryRecords,
+  pythonFamilyRows: pythonRemapFamilyRecords,
+});
+const nextBoundaryRecords = verifyNextBoundaryWorklistRows(
+  nextBoundaryRows,
+  fullProcessBoundarySummaryRecords,
+  pythonRemapFamilyRecords,
+);
+const boundaryProofGateRowsGenerated = boundaryProofGateRows(nextBoundaryRecords);
+const boundaryProofGateRecords = verifyBoundaryProofGateRows(
+  boundaryProofGateRowsGenerated,
+  nextBoundaryRecords,
+);
+const nativeProofAlignmentRowsGenerated = nativeProofAlignmentRows(
+  nextBoundaryRecords,
+  boundaryProofGateRecords,
+);
+const nativeProofAlignmentRecords = verifyNativeProofAlignmentRows(
+  nativeProofAlignmentRowsGenerated,
+);
+const nativeRuntimeProbeSummaryRowsGenerated = nativeRuntimeProbeSummaryRows();
+const nativeRuntimeProbeSummaryRecords = verifyNativeRuntimeProbeSummaryRows(
+  nativeRuntimeProbeSummaryRowsGenerated,
+);
+const runtimeBoundaryNativeAlignmentSummaryRowsGenerated = runtimeBoundaryNativeAlignmentSummaryRows({
+  userMRows: userMProcessNativeStateAlignmentRecords,
+  toolDbRows: toolDbProcessNativeProtocolAlignmentRecords,
+  pythonRows: pythonRemapNativeRuntimeAlignmentRecords,
+});
+const runtimeBoundaryNativeAlignmentSummaryRecords =
+  verifyRuntimeBoundaryNativeAlignmentSummaryRows(
+    runtimeBoundaryNativeAlignmentSummaryRowsGenerated,
+  );
+const runtimeBoundaryContractSummaryRowsGenerated = runtimeBoundaryContractSummaryRows({
+  userMRows: userMProcessTransitionPlanRecords,
+  toolDbRows: toolDbProcessTransactionPlanRecords,
+  pythonRows: pythonRemapRuntimeContractRecords,
+  runtimeNativeAlignmentRows: runtimeBoundaryNativeAlignmentSummaryRecords,
+});
+const runtimeBoundaryContractSummaryRecords = verifyRuntimeBoundaryContractSummaryRows(
+  runtimeBoundaryContractSummaryRowsGenerated,
+);
+const blockedRuntimePromotionLockRowsGenerated = blockedRuntimePromotionLockRows({
+  worklistRows: nextBoundaryRecords,
+  proofGateRows: boundaryProofGateRecords,
+  runtimeNativeAlignmentRows: runtimeBoundaryNativeAlignmentSummaryRecords,
+});
+const blockedRuntimePromotionLockRecords = verifyBlockedRuntimePromotionLockRows(
+  blockedRuntimePromotionLockRowsGenerated,
+  nextBoundaryRecords,
+);
+const nextBoundaryRecommendationRowsGenerated = nextBoundaryRecommendationRows({
+  worklistRows: nextBoundaryRecords,
+  promotionLockRows: blockedRuntimePromotionLockRecords,
+  runtimeContractRows: runtimeBoundaryContractSummaryRecords,
+  userMRuntimeProbeGateRows: userMProcessNativeRuntimeProbeGateRecords,
+  toolDbTransactionRows: toolDbProcessTransactionPlanRecords,
+  pythonFixturePlanRows: pythonRemapNativeRuntimeFixturePlanRecords,
+});
+verifyNextBoundaryRecommendationRows(nextBoundaryRecommendationRowsGenerated);
+const boundaryPhaseCompletionRows = boundaryPhaseCompletionSummaryRows({
+  boundaryRows: boundarySummaryRecords,
+  iniBoundaryRows: iniBoundarySummaryRecords,
+  blockedRows: blockedDependencySummaryRecords,
+  fullProcessRows: fullProcessBoundarySummaryRecords,
+  userMTransitionRows: userMProcessTransitionPlanRecords,
+  userMRuntimeStatePlanRows: userMProcessNativeRuntimeStatePlanRecords,
+  userMRuntimeReadinessRows: userMProcessNativeRuntimeReadinessRecords,
+  userMRuntimeProbeGateRows: userMProcessNativeRuntimeProbeGateRecords,
+  toolDbTransactionRows: toolDbProcessTransactionPlanRecords,
+  toolDbRuntimeReadinessRows: toolDbProcessNativeRuntimeReadinessRecords,
+  pythonFamilyRows: pythonRemapFamilyRecords,
+  pythonRuntimeContractRows: pythonRemapRuntimeContractRecords,
+  pythonRuntimeReadinessRows: pythonRemapNativeRuntimeReadinessRecords,
+  pythonRuntimeStatePlanRows: pythonRemapNativeRuntimeStatePlanRecords,
+  pythonRuntimeFixturePlanRows: pythonRemapNativeRuntimeFixturePlanRecords,
+  runtimeContractSummaryRows: runtimeBoundaryContractSummaryRecords,
+  nativeProofAlignmentRows: nativeProofAlignmentRecords,
+  nativeRuntimeProbeRows: nativeRuntimeProbeSummaryRecords,
+  runtimeNativeAlignmentRows: runtimeBoundaryNativeAlignmentSummaryRecords,
+  trackedRows: trackedMatrixRecords,
+  inventoryRows: summaryRows,
+});
+verifyBoundaryPhaseCompletionSummaryRows(boundaryPhaseCompletionRows);
+
+writeFileSync(
+  summaryPath,
+  `${[
+    "path\tinventory_status\tskip_or_fail_reason\tclass\tnative_status\tnative_expected_failure",
+    ...summaryRows,
+  ].join("\n")}\n`,
+);
+
+const skipSummaryRows = [...skipReasonCounts.entries()]
+  .sort(([left], [right]) => left.localeCompare(right))
+  .map(([reason, count]) => `${reason}\t${count}`);
+verifySkipSummaryRows(skipSummaryRows, skipped, nativeRecords, pathMatrixByPath);
+writeFileSync(
+  skipSummaryPath,
+  `${[
+    "skip_or_block_reason\tcount",
+    ...skipSummaryRows,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  boundarySummaryPath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "recommended_blocked",
+      "dependencies",
+      "user_m_execution_codes",
+      "user_m_unstaged_execution_codes",
+      "user_m_vendored_count",
+      "db_program",
+      "hal_process",
+      "ui_process",
+      "halui_mdi_process",
+      "python_process",
+      "python_ui_db_process",
+      "python_remap_process",
+    ].join("\t"),
+    ...boundarySummaryRows,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  iniBoundarySummaryPath,
+  `${[
+    [
+      "ini",
+      "path_count",
+      "vendored",
+      "report_available",
+      "blocked",
+      "recommended_blocked",
+      "dependencies",
+      "user_m_execution_codes",
+      "user_m_unstaged_execution_codes",
+      "user_m_vendored_count",
+      "db_program",
+      "hal_process",
+      "ui_process",
+      "halui_mdi_process",
+      "python_process",
+      "python_ui_db_process",
+      "python_remap_process",
+      "hard_block_policy_aligned",
+    ].join("\t"),
+    ...iniBoundarySummaryRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  blockedDependencySummaryPath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "family",
+      "source_available",
+      "python_modules",
+      "python_remap_functions",
+      "prolog_functions",
+      "epilog_functions",
+      "remap_ngc_files",
+      "ngc_only_subpaths",
+      "hal_process",
+      "ui_process",
+      "halui_mdi_process",
+      "db_program",
+      "tool_db_protocol_evidence",
+      "user_m_execution_codes",
+      "user_m_process_files",
+      "user_m_process_effects",
+      "linuxcnc_owner",
+      "notes",
+    ].join("\t"),
+    ...blockedDependencySummaryRows,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  fullProcessBoundarySummaryPath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "design_status",
+      "boundary_kind",
+      "linuxcnc_owner",
+      "runtime_owner_evidence",
+      "required_native_proof",
+      "required_node_proof",
+      "required_browser_proof",
+      "browser_policy",
+      "execution_enabled",
+      "notes",
+    ].join("\t"),
+    ...fullProcessBoundarySummaryRows,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  userMProcessBoundarySummaryPath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "design_status",
+      "boundary_kind",
+      "linuxcnc_owner",
+      "user_m_execution_codes",
+      "user_m_process_files",
+      "remap_call_chain",
+      "state_targets",
+      "runtime_owner_evidence",
+      "required_native_proof",
+      "required_node_proof",
+      "required_browser_proof",
+      "execution_enabled",
+      "promotion_allowed",
+      "notes",
+    ].join("\t"),
+    ...userMProcessBoundarySummaryRows,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  userMProcessStateTargetsPath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "user_m_code",
+      "source_file",
+      "remap_callers",
+      "state_mode",
+      "guard_pin",
+      "target_pin",
+      "source_section",
+      "source_field",
+      "expected_value",
+      "proof_kind",
+      "proof_status",
+      "execution_enabled",
+      "promotion_allowed",
+    ].join("\t"),
+    ...userMProcessStateTargetRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  userMProcessTransitionPlanPath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "transition_step",
+      "remap_code",
+      "user_m_code",
+      "remap_caller",
+      "switchkins_output_pin",
+      "switchkins_target",
+      "active_g5x",
+      "work_offset_pocket",
+      "guard_pin",
+      "state_mode",
+      "state_target_count",
+      "expected_state_pins",
+      "proof_kind",
+      "proof_status",
+      "execution_enabled",
+      "promotion_allowed",
+      "notes",
+    ].join("\t"),
+    ...userMProcessTransitionPlanRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  userMProcessNativeStateAlignmentPath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "user_m_code",
+      "target_pin",
+      "source_section",
+      "source_field",
+      "expected_value",
+      "native_stdout_available",
+      "native_value_key",
+      "native_value",
+      "native_ok_key",
+      "native_ok_value",
+      "source_proof_key",
+      "source_proof_value",
+      "alignment_ok",
+      "execution_enabled",
+      "promotion_allowed",
+      "proof_status",
+      "notes",
+    ].join("\t"),
+    ...userMProcessNativeStateAlignmentRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  userMProcessNativeTransitionAlignmentPath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "remap_code",
+      "user_m_code",
+      "switchkins_output_pin",
+      "switchkins_target",
+      "active_g5x",
+      "work_offset_pocket",
+      "native_stdout_available",
+      "native_switchkins_output_pin",
+      "native_switchkins_target",
+      "native_active_g5x",
+      "native_work_offset_pocket",
+      "native_call_key",
+      "native_call_value",
+      "native_transition_key",
+      "native_transition_value",
+      "alignment_ok",
+      "execution_enabled",
+      "promotion_allowed",
+      "proof_status",
+      "notes",
+    ].join("\t"),
+    ...userMProcessNativeTransitionAlignmentRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  userMProcessNativeRuntimeStatePlanPath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "runtime_step",
+      "remap_code",
+      "user_m_code",
+      "required_runtime",
+      "required_environment",
+      "switchkins_output_pin",
+      "switchkins_target",
+      "active_g5x",
+      "work_offset_pocket",
+      "guard_pin",
+      "state_mode",
+      "state_target_count",
+      "expected_state_pins",
+      "expected_state_values",
+      "source_alignment_artifacts",
+      "source_alignment_ok",
+      "native_runtime_status",
+      "proof_kind",
+      "proof_status",
+      "execution_enabled",
+      "promotion_allowed",
+      "notes",
+    ].join("\t"),
+    ...userMProcessNativeRuntimeStatePlanRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  userMProcessNativeRuntimeReadinessPath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "required_runtime",
+      "requirement_kind",
+      "requirement",
+      "purpose",
+      "available",
+      "evidence",
+      "native_runtime_status",
+      "proof_kind",
+      "proof_status",
+      "execution_enabled",
+      "promotion_allowed",
+      "notes",
+    ].join("\t"),
+    ...userMProcessNativeRuntimeReadinessRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  userMProcessNativeRuntimeProbeGatePath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "runtime_step",
+      "remap_code",
+      "user_m_code",
+      "required_runtime",
+      "runtime_requirements",
+      "missing_requirements",
+      "runtime_ready",
+      "source_proof_ready",
+      "required_native_proof",
+      "gate_status",
+      "proof_status",
+      "execution_enabled",
+      "promotion_allowed",
+      "notes",
+    ].join("\t"),
+    ...userMProcessNativeRuntimeProbeGateRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  toolDbProcessBoundarySummaryPath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "design_status",
+      "boundary_kind",
+      "linuxcnc_owner",
+      "db_program",
+      "protocol_messages",
+      "db_program_callbacks",
+      "state_targets",
+      "runtime_owner_evidence",
+      "required_native_proof",
+      "required_node_proof",
+      "required_browser_proof",
+      "execution_enabled",
+      "promotion_allowed",
+      "notes",
+    ].join("\t"),
+    ...toolDbProcessBoundarySummaryRows,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  toolDbProcessProtocolGatesPath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "gate_kind",
+      "gate",
+      "db_program",
+      "linuxcnc_owner",
+      "runtime_owner_evidence",
+      "proof_kind",
+      "proof_status",
+      "execution_enabled",
+      "promotion_allowed",
+    ].join("\t"),
+    ...toolDbProcessProtocolGateRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  toolDbProcessTransactionPlanPath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "transaction_step",
+      "transaction_phase",
+      "protocol_message",
+      "db_program_callback",
+      "state_targets",
+      "db_program",
+      "required_native_proof",
+      "required_node_proof",
+      "required_browser_proof",
+      "proof_kind",
+      "proof_status",
+      "execution_enabled",
+      "promotion_allowed",
+      "notes",
+    ].join("\t"),
+    ...toolDbProcessTransactionPlanRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  toolDbProcessNativeProtocolAlignmentPath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "gate_kind",
+      "gate",
+      "proof_kind",
+      "native_stdout_available",
+      "native_proof_key",
+      "native_proof_value",
+      "source_proof_key",
+      "alignment_ok",
+      "execution_enabled",
+      "promotion_allowed",
+      "proof_status",
+      "notes",
+    ].join("\t"),
+    ...toolDbProcessNativeProtocolAlignmentRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  toolDbProcessNativeRuntimeReadinessPath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "required_runtime",
+      "requirement_kind",
+      "requirement",
+      "purpose",
+      "available",
+      "evidence",
+      "db_program",
+      "native_runtime_status",
+      "proof_kind",
+      "proof_status",
+      "execution_enabled",
+      "promotion_allowed",
+      "notes",
+    ].join("\t"),
+    ...toolDbProcessNativeRuntimeReadinessRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  pythonRemapBoundarySummaryPath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "design_status",
+      "python_modules",
+      "python_remap_functions",
+      "prolog_functions",
+      "epilog_functions",
+      "remap_ngc_files",
+      "ngc_only_subpaths",
+      "hal_process",
+      "ui_process",
+      "halui_mdi_process",
+      "linuxcnc_owner",
+      "python_runtime_evidence",
+      "required_boundary",
+      "execution_enabled",
+      "notes",
+    ].join("\t"),
+    ...pythonRemapBoundarySummaryRows,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  pythonRemapRuntimeGatesPath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "gate_kind",
+      "gate",
+      "linuxcnc_owner",
+      "runtime_owner_evidence",
+      "proof_kind",
+      "proof_status",
+      "execution_enabled",
+      "promotion_allowed",
+      "notes",
+    ].join("\t"),
+    ...pythonRemapRuntimeGateRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  pythonRemapNativeRuntimeAlignmentPath,
+  `${[
+    [
+      "path",
+      "ini",
+      "blocked",
+      "gate_kind",
+      "gate",
+      "proof_kind",
+      "native_stdout_available",
+      "native_proof_key",
+      "native_proof_value",
+      "source_proof_key",
+      "alignment_ok",
+      "execution_enabled",
+      "promotion_allowed",
+      "proof_status",
+      "notes",
+    ].join("\t"),
+    ...pythonRemapNativeRuntimeAlignmentRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  pythonRemapFamilySummaryPath,
+  `${[
+    [
+      "family",
+      "row_count",
+      "ini_count",
+      "python_modules",
+      "python_remap_functions",
+      "prolog_functions",
+      "epilog_functions",
+      "ngc_only_subpaths",
+      "python_runtime_evidence",
+      "hal_process",
+      "ui_process",
+      "halui_mdi_process",
+      "execution_enabled",
+      "notes",
+    ].join("\t"),
+    ...pythonRemapFamilyRows,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  pythonRemapRuntimeContractPath,
+  `${[
+    [
+      "family",
+      "blocked",
+      "design_status",
+      "row_count",
+      "ini_count",
+      "runtime_phases",
+      "python_modules",
+      "python_callables",
+      "ngc_only_subpaths",
+      "process_assumptions",
+      "runtime_owner_evidence",
+      "required_native_proof",
+      "required_node_proof",
+      "required_browser_proof",
+      "proof_status",
+      "execution_enabled",
+      "promotion_allowed",
+      "notes",
+    ].join("\t"),
+    ...pythonRemapRuntimeContractRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  pythonRemapNativeRuntimeReadinessPath,
+  `${[
+    [
+      "family",
+      "blocked",
+      "required_runtime",
+      "requirement_kind",
+      "requirement",
+      "purpose",
+      "available",
+      "evidence",
+      "native_runtime_status",
+      "proof_kind",
+      "proof_status",
+      "execution_enabled",
+      "promotion_allowed",
+      "notes",
+    ].join("\t"),
+    ...pythonRemapNativeRuntimeReadinessRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  pythonRemapNativeRuntimeStatePlanPath,
+  `${[
+    [
+      "family",
+      "blocked",
+      "required_runtime",
+      "runtime_phases",
+      "python_modules",
+      "python_callables",
+      "ngc_only_subpaths",
+      "process_assumptions",
+      "required_environment",
+      "readiness_requirement_count",
+      "readiness_available_count",
+      "source_alignment_artifacts",
+      "source_alignment_ok",
+      "native_runtime_status",
+      "required_state_probe",
+      "proof_kind",
+      "proof_status",
+      "execution_enabled",
+      "promotion_allowed",
+      "notes",
+    ].join("\t"),
+    ...pythonRemapNativeRuntimeStatePlanRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  pythonRemapNativeRuntimeFixturePlanPath,
+  `${[
+    [
+      "family",
+      "blocked",
+      "required_runtime",
+      "selection_reason",
+      "fixture_id",
+      "fixture_scope",
+      "runtime_phases",
+      "python_modules",
+      "process_assumptions",
+      "required_environment",
+      "readiness_requirement_count",
+      "readiness_available_count",
+      "source_alignment_artifacts",
+      "source_alignment_ok",
+      "expected_runtime_observations",
+      "expected_module_inputs",
+      "proof_kind",
+      "proof_status",
+      "execution_enabled",
+      "promotion_allowed",
+      "notes",
+    ].join("\t"),
+    ...pythonRemapNativeRuntimeFixturePlanRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  runtimeBoundaryContractSummaryPath,
+  `${[
+    [
+      "boundary_class",
+      "boundary_kind",
+      "contract_artifact",
+      "contract_scope",
+      "contract_row_count",
+      "pending_count",
+      "execution_disabled_count",
+      "promotion_disabled_count",
+      "runtime_alignment_artifact",
+      "runtime_alignment_row_count",
+      "runtime_alignment_ok",
+      "contract_ok",
+      "notes",
+    ].join("\t"),
+    ...runtimeBoundaryContractSummaryRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  boundaryPhaseCompletionSummaryPath,
+  `${[
+    [
+      "criterion",
+      "passed",
+      "count",
+      "evidence",
+    ].join("\t"),
+    ...boundaryPhaseCompletionRows,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  nextBoundaryWorklistPath,
+  `${[
+    [
+      "priority",
+      "boundary_kind",
+      "target",
+      "blocked",
+      "design_status",
+      "linuxcnc_owner",
+      "runtime_owner_evidence",
+      "required_native_proof",
+      "required_node_proof",
+      "required_browser_proof",
+      "execution_enabled",
+      "promotion_allowed",
+      "next_action",
+      "notes",
+    ].join("\t"),
+    ...nextBoundaryRows,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  boundaryProofGatesPath,
+  `${[
+    [
+      "priority",
+      "boundary_kind",
+      "target",
+      "proof_layer",
+      "blocked",
+      "design_status",
+      "linuxcnc_owner",
+      "runtime_owner_evidence",
+      "required_proof",
+      "proof_status",
+      "execution_enabled",
+      "promotion_allowed",
+      "next_action",
+      "notes",
+    ].join("\t"),
+    ...boundaryProofGateRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  nativeProofAlignmentSummaryPath,
+  `${[
+    [
+      "boundary_class",
+      "boundary_kind",
+      "target",
+      "proof_key",
+      "native_summary_available",
+      "proof_value",
+      "execution_enabled",
+      "promotion_allowed",
+      "matching_worklist_count",
+      "matching_native_gate_count",
+      "alignment_ok",
+      "notes",
+    ].join("\t"),
+    ...nativeProofAlignmentRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  nativeRuntimeProbeSummaryPath,
+  `${[
+    [
+      "boundary_class",
+      "boundary_kind",
+      "target",
+      "runtime_probe",
+      "runtime_ready",
+      "source_proof_ready",
+      "probe_status",
+      "execution_enabled",
+      "promotion_allowed",
+      "missing_requirements",
+      "stdout_log",
+    ].join("\t"),
+    ...nativeRuntimeProbeSummaryRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  runtimeBoundaryNativeAlignmentSummaryPath,
+  `${[
+    [
+      "boundary_class",
+      "boundary_kind",
+      "row_count",
+      "native_stdout_available_count",
+      "alignment_ok_count",
+      "pending_count",
+      "execution_disabled_count",
+      "promotion_disabled_count",
+      "artifact",
+      "summary_ok",
+      "notes",
+    ].join("\t"),
+    ...runtimeBoundaryNativeAlignmentSummaryRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  blockedRuntimePromotionLockPath,
+  `${[
+    [
+      "priority",
+      "boundary_kind",
+      "target",
+      "blocked",
+      "design_status",
+      "execution_enabled",
+      "promotion_allowed",
+      "native_gate_pending",
+      "node_gate_pending",
+      "browser_gate_pending",
+      "runtime_alignment_artifact",
+      "runtime_alignment_row_count",
+      "runtime_alignment_ok",
+      "next_action",
+      "lock_active",
+      "notes",
+    ].join("\t"),
+    ...blockedRuntimePromotionLockRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+writeFileSync(
+  nextBoundaryRecommendationsPath,
+  `${[
+    [
+      "priority",
+      "boundary_kind",
+      "target",
+      "blocked",
+      "recommendation",
+      "primary_artifact",
+      "artifact_row_count",
+      "required_native_proof",
+      "required_node_proof",
+      "required_browser_proof",
+      "promotion_lock_active",
+      "contract_ok",
+      "execution_enabled",
+      "promotion_allowed",
+      "next_step",
+      "source_artifacts",
+    ].join("\t"),
+    ...nextBoundaryRecommendationRowsGenerated,
+  ].join("\n")}\n`,
+);
+
+console.log(`sim_configs_wasm_node_inventory_executed=${executed}`);
+console.log(`sim_configs_wasm_node_inventory_passed=${passed}`);
+console.log(`sim_configs_wasm_node_inventory_skipped=${skipped}`);
+console.log(`sim_configs_wasm_node_inventory_unexpected_fail=${unexpectedFail}`);
+const skipReasonLogCounts = new Map();
+for (const [reason, count] of skipReasonCounts) {
+  const key = skipReasonLogKey(reason);
+  skipReasonLogCounts.set(key, (skipReasonLogCounts.get(key) ?? 0) + count);
+}
+for (const [reason, count] of [...skipReasonLogCounts.entries()].sort(([left], [right]) =>
+  left.localeCompare(right)
+)) {
+  console.log(`sim_configs_wasm_node_inventory_skip_${reason}=${count}`);
+}
+
+if (unexpectedFail !== 0) {
+  throw new Error(`sim_configs inventory unexpected failures: ${unexpectedFail}`);
+}
+
+console.log("sim_configs_wasm_node_inventory=ok");
diff --git a/wasm-port/tests/wasm/node/verify_sim_configs_inventory_wasm.sh b/wasm-port/tests/wasm/node/verify_sim_configs_inventory_wasm.sh
new file mode 100755
index 0000000..36249ea
--- /dev/null
+++ b/wasm-port/tests/wasm/node/verify_sim_configs_inventory_wasm.sh
@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/../../.." && pwd)"
+NATIVE_SUMMARY="$ROOT_DIR/build/native/sim-configs/summary.tsv"
+NATIVE_CLASS_SUMMARY="$ROOT_DIR/build/native/sim-configs/class-summary.tsv"
+NATIVE_PATH_MATRIX="$ROOT_DIR/build/native/sim-configs/path-matrix.tsv"
+NATIVE_SOURCE_PROOF_SUMMARY="$ROOT_DIR/build/native/native-source-proof-summary.tsv"
+NATIVE_BUILD_DIR="$ROOT_DIR/build/native/sim-configs"
+NATIVE_SOURCE_PROOF_INPUTS=(
+  "$ROOT_DIR/tools/build_native_probes.sh"
+  "$ROOT_DIR/tools/source-manifest.txt"
+  "$ROOT_DIR/runtime/core/linuxcnc_wrap/linuxcnc_millturn_user_m_boundary_probe.cpp"
+  "$ROOT_DIR/runtime/core/linuxcnc_wrap/linuxcnc_tool_db_boundary_probe.cpp"
+  "$ROOT_DIR/runtime/core/linuxcnc_wrap/linuxcnc_python_remap_boundary_probe.cpp"
+)
+
+native_source_proof_refresh_required() {
+  if [[ ! -f "$NATIVE_SOURCE_PROOF_SUMMARY" ]]; then
+    return 0
+  fi
+  for input in "${NATIVE_SOURCE_PROOF_INPUTS[@]}"; do
+    if [[ "$input" -nt "$NATIVE_SOURCE_PROOF_SUMMARY" ]]; then
+      return 0
+    fi
+  done
+  return 1
+}
+
+if [[ ! -f "$NATIVE_SUMMARY" || ! -f "$NATIVE_CLASS_SUMMARY" || ! -f "$NATIVE_PATH_MATRIX" ]]; then
+  "$ROOT_DIR/tests/native/verify_sim_configs.sh"
+fi
+if native_source_proof_refresh_required; then
+  "$ROOT_DIR/tools/build_native_probes.sh"
+fi
+
+mkdir -p "$NATIVE_BUILD_DIR"
+exec 9>"$NATIVE_BUILD_DIR/inventory.lock"
+flock 9
+
+if [[ "${SKIP_INTERP_BUILD:-0}" != "1" ]]; then
+  "$ROOT_DIR/tools/build_wasm_core.sh"
+fi
+
+node "$ROOT_DIR/tests/wasm/node/verify_sim_configs_inventory_wasm.mjs"
diff --git a/wasm-port/tests/wasm/node/verify_sim_configs_wasm.mjs b/wasm-port/tests/wasm/node/verify_sim_configs_wasm.mjs
index b910118..ff3d4a7 100644
--- a/wasm-port/tests/wasm/node/verify_sim_configs_wasm.mjs
+++ b/wasm-port/tests/wasm/node/verify_sim_configs_wasm.mjs
@@ -4,6 +4,7 @@ import { dirname, resolve } from "node:path";
 import assert from "node:assert/strict";
 
 import {
+  analyzeIniRuntimeBoundaries,
   createLinuxCncInterpSdk,
   planIniFileContextStaging,
   planSimConfigStaging,
@@ -46,6 +47,10 @@ const interp = await createLinuxCncInterpSdk({
   },
 });
 
+function readSimIni(machineRel, iniFile) {
+  return readFileSync(resolve(vendorRoot, `configs/sim/${machineRel}/${iniFile}`), "utf8");
+}
+
 const syntheticPlan = planSimConfigStaging({
   manifestText: [
     "configs/sim/example/test.ini",
@@ -80,6 +85,80 @@ assert.deepEqual(
   ],
   "synthetic sim-config staging plan",
 );
+
+const syntheticBoundary = analyzeIniRuntimeBoundaries({
+  manifestText: [
+    "configs/sim/example/test.ini",
+    "configs/sim/example/test.ngc",
+    "configs/sim/example/tool.tbl",
+    "configs/sim/example/M123",
+  ].join("\n"),
+  sourceRootRel: "configs/sim/example",
+  sourceSearchRootRel: "configs/sim",
+  iniFile: "test.ini",
+  iniText: [
+    "[DISPLAY]",
+    "DISPLAY = axis",
+    "OPEN_FILE = test.ngc",
+    "[RS274NGC]",
+    "USER_M_PATH = .",
+    "[EMCIO]",
+    "TOOL_TABLE = tool.tbl",
+  ].join("\n"),
+});
+assert.deepEqual(
+  syntheticBoundary,
+  {
+    dependencies: [],
+    recommendedBlockedKind: "-",
+    toolDatabaseProgram: "",
+    halRuntime: { values: [], requiresProcess: false },
+    uiRuntime: { values: ["axis"], requiresProcess: false },
+    haluiRuntime: { mdiCommands: [], requiresProcess: false },
+    userMRuntime: {
+      paths: ["."],
+      vendoredExecutableCount: 1,
+      executionCodes: [],
+      unstagedExecutionCodes: [],
+      requiresExternalProcess: false,
+    },
+    pythonRuntime: { references: [], remapReferences: [], uiReferences: [], requiresProcess: false },
+  },
+  "synthetic runtime-boundary analysis",
+);
+
+const mixedUserMBoundary = analyzeIniRuntimeBoundaries({
+  manifestText: [
+    "configs/sim/example/test.ini",
+    "configs/sim/example/test.ngc",
+    "configs/sim/example/M123",
+  ].join("\n"),
+  sourceRootRel: "configs/sim/example",
+  sourceSearchRootRel: "configs/sim",
+  iniFile: "test.ini",
+  iniText: [
+    "[DISPLAY]",
+    "DISPLAY = axis",
+    "[RS274NGC]",
+    "USER_M_PATH = .",
+  ].join("\n"),
+  executionTexts: ["M123\nM124\n"],
+});
+assert.equal(
+  mixedUserMBoundary.recommendedBlockedKind,
+  "L4-USER-M-PROCESS",
+  "mixed vendored and unstaged user-M calls must block",
+);
+assert.deepEqual(
+  mixedUserMBoundary.userMRuntime.executionCodes,
+  ["M123", "M124"],
+  "mixed user-M execution codes",
+);
+assert.deepEqual(
+  mixedUserMBoundary.userMRuntime.unstagedExecutionCodes,
+  ["M124"],
+  "only unstaged user-M execution codes require the external process boundary",
+);
 assert.deepEqual(
   syntheticPlan.files.map((file) => [file.sourceRel, file.wasmPath]).sort(),
   [
@@ -134,6 +213,111 @@ assert.deepEqual(
   "generic INI file-context staging plan",
 );
 
+function simBoundary(machineRel, iniFile, executionRelFiles = []) {
+  return analyzeIniRuntimeBoundaries({
+    manifestText,
+    sourceRootRel: `configs/sim/${machineRel}`,
+    sourceSearchRootRel: "configs/sim",
+    iniFile,
+    iniText: readSimIni(machineRel, iniFile),
+    executionTexts: executionRelFiles.map((relFile) =>
+      readFileSync(resolve(vendorRoot, `configs/sim/${machineRel}/${relFile}`), "utf8"),
+    ),
+  });
+}
+
+const dbDemoBoundary = simBoundary("axis/db_demo", "db_nonran.ini");
+assert.deepEqual(
+  dbDemoBoundary.dependencies,
+  ["python_runtime", "tool_database_process"],
+  "db_demo tool database boundary dependencies",
+);
+assert.equal(dbDemoBoundary.recommendedBlockedKind, "L4-TOOL-DB", "db_demo blocked kind");
+assert.equal(dbDemoBoundary.toolDatabaseProgram, "./db_nonran.py", "db_demo DB_PROGRAM");
+assert.deepEqual(
+  dbDemoBoundary.pythonRuntime.uiReferences,
+  ["./db_nonran.py"],
+  "db_demo Python dependency is the DB program process",
+);
+assert.deepEqual(
+  dbDemoBoundary.pythonRuntime.remapReferences,
+  [],
+  "db_demo does not declare Python remap runtime",
+);
+
+const millturnBoundary = simBoundary("axis/vismach/millturn", "millturn.ini", [
+  "example.ngc",
+  "remap_subs/428remap.ngc",
+  "remap_subs/429remap.ngc",
+]);
+assert.equal(
+  millturnBoundary.recommendedBlockedKind,
+  "L4-USER-M-PROCESS",
+  "millturn blocked kind",
+);
+assert.deepEqual(
+  millturnBoundary.dependencies,
+  ["external_user_m_process", "hal_process", "halui_mdi_process", "ui_process"],
+  "millturn full-process boundary dependencies",
+);
+assert.equal(
+  millturnBoundary.userMRuntime.vendoredExecutableCount,
+  0,
+  "millturn external user-M files are not staged",
+);
+assert.deepEqual(
+  millturnBoundary.userMRuntime.executionCodes,
+  ["M128", "M129"],
+  "millturn execution chain calls external user-M processes",
+);
+assert.deepEqual(
+  millturnBoundary.userMRuntime.unstagedExecutionCodes,
+  ["M128", "M129"],
+  "millturn execution chain calls unstaged user-M processes",
+);
+
+const pumaBoundary = simBoundary("axis/vismach/puma", "puma_cube.ini");
+assert.equal(pumaBoundary.recommendedBlockedKind, "-", "puma_cube representative is not blocked");
+assert.equal(pumaBoundary.userMRuntime.vendoredExecutableCount, 0, "puma_cube has no vendored user-M processes");
+assert.equal(pumaBoundary.halRuntime.requiresProcess, true, "puma_cube declares HAL process files");
+assert.equal(pumaBoundary.haluiRuntime.requiresProcess, true, "puma_cube declares HALUI MDI commands");
+
+const melfaBoundary = simBoundary("axis/vismach/melfa-sim", "melfa.ini");
+assert.equal(melfaBoundary.recommendedBlockedKind, "-", "melfa representative is not blocked");
+assert.deepEqual(
+  melfaBoundary.dependencies,
+  ["hal_process", "halui_mdi_process", "ui_process"],
+  "melfa declares HAL/UI/HALUI process dependencies",
+);
+assert.equal(melfaBoundary.pythonRuntime.requiresProcess, false, "melfa representative has no Python runtime");
+
+const woodpeckerBoundary = simBoundary("woodpecker", "woodpecker.ini");
+assert.equal(woodpeckerBoundary.recommendedBlockedKind, "-", "woodpecker representative is not blocked");
+assert.deepEqual(
+  woodpeckerBoundary.dependencies,
+  ["hal_process", "ui_process"],
+  "woodpecker declares HAL/UI process dependencies",
+);
+assert.equal(woodpeckerBoundary.haluiRuntime.requiresProcess, false, "woodpecker representative has no HALUI MDI");
+
+const gladevcpBoundary = simBoundary("axis/gladevcp", "gladevcp_panel.ini");
+assert.equal(gladevcpBoundary.recommendedBlockedKind, "-", "gladevcp probe representative is not blocked");
+assert.ok(
+  gladevcpBoundary.dependencies.includes("ui_process"),
+  "gladevcp declares UI process dependency",
+);
+assert.equal(gladevcpBoundary.pythonRuntime.requiresProcess, true, "gladevcp declares Python UI handler");
+assert.deepEqual(
+  gladevcpBoundary.pythonRuntime.uiReferences,
+  ["-u hitcounter.py manual-example.ui"],
+  "gladevcp Python dependency is a UI handler",
+);
+assert.deepEqual(
+  gladevcpBoundary.pythonRuntime.remapReferences,
+  [],
+  "gladevcp representative must not be treated as Python remap runtime",
+);
+
 function simMachine(machineRel, iniFile, programFile = null) {
   const iniText = readFileSync(
     resolve(vendorRoot, `configs/sim/${machineRel}/${iniFile}`),
@@ -158,6 +342,23 @@ function simMachine(machineRel, iniFile, programFile = null) {
   };
 }
 
+function wrapSimProgram(machine, wrappedName) {
+  const sourceFile = machine.files.find((file) => file.path === machine.programPath);
+  assert.ok(sourceFile, `${machine.programPath}: wrapped source file`);
+  return {
+    ...machine,
+    programPath: `${machine.wasmDir}/${wrappedName}`,
+    files: [
+      ...machine.files,
+      {
+        path: `${machine.wasmDir}/${wrappedName}`,
+        text: `${sourceFile.text}\nM2\n`,
+        executable: false,
+      },
+    ],
+  };
+}
+
 const foam = simMachine("axis/foam", "axis_foam.ini", "foam.ngc");
 verifyExpectedOutput(
   "sim_axis_foam_uv_wasm",
@@ -225,6 +426,49 @@ verifyExpectedOutput(
   ].join("\n"),
 );
 
+const gladevcpProbe = simMachine("axis/gladevcp", "gladevcp_panel.ini", "probe.ngc");
+verifyExpectedOutput(
+  "sim_axis_gladevcp_probe_wasm",
+  interp.runSimConfigProgram({
+    files: gladevcpProbe.files,
+    programPath: gladevcpProbe.programPath,
+    iniPath: gladevcpProbe.iniPath,
+  }),
+  [
+    "file_open=0",
+    "file_saw_error=0",
+    "canon_event=PROGRAM_END",
+    "absent=file_error_text=",
+  ].join("\n"),
+);
+
+const externalOffsetsMacro = wrapSimProgram(
+  simMachine("axis/external_offsets", "dynamic_offsets.ini", "circles.ngc"),
+  "__wrapped_circles.ngc",
+);
+verifyExpectedOutput(
+  "sim_axis_external_offsets_circles_macro_wasm",
+  interp.runSimConfigProgram({
+    files: externalOffsetsMacro.files,
+    programPath: externalOffsetsMacro.programPath,
+    iniPath: externalOffsetsMacro.iniPath,
+  }),
+  [
+    "file_open=0",
+    "file_execute_45=1",
+    "statement_uri=M2",
+    "file_read_count=45",
+    "file_execute_count=45",
+    "file_saw_error=0",
+    "canon_event=COMMENT: info: Multiple circles at radius R, use 0 for current val",
+    "canon_event=PROGRAM_END",
+    "post_execute.origin_index=1",
+    "post_execute.mist=0",
+    "post_execute.flood=0",
+    "absent=file_error_text=",
+  ].join("\n"),
+);
+
 for (const externalOffsetCase of [
   {
     name: "dyn_demo",
@@ -287,4 +531,62 @@ for (const externalOffsetCase of [
   );
 }
 
+const melfaSim = simMachine("axis/vismach/melfa-sim", "melfa.ini", "example.ngc");
+verifyExpectedOutput(
+  "sim_axis_vismach_melfa_wasm",
+  interp.runSimConfigProgram({
+    files: melfaSim.files,
+    programPath: melfaSim.programPath,
+    iniPath: melfaSim.iniPath,
+    executionMode: "fiveAxisRemap",
+  }),
+  [
+    "fiveaxis_ini_open=1",
+    "fiveaxis_tool_table_load=0",
+    "fiveaxis_file_open=0",
+    "fiveaxis_file_reached_exit=1",
+    "fiveaxis_linuxcnc_remap_file_execute=1",
+  ].join("\n"),
+);
+
+const pumaCube = simMachine("axis/vismach/puma", "puma_cube.ini", "puma_cube.ngc");
+verifyExpectedOutput(
+  "sim_axis_vismach_puma_cube_wasm",
+  interp.runSimConfigProgram({
+    files: pumaCube.files,
+    programPath: pumaCube.programPath,
+    iniPath: pumaCube.iniPath,
+  }),
+  [
+    "file_open=0",
+    "file_saw_error=0",
+    "canon_event=PROGRAM_END",
+    "absent=file_error_text=",
+  ].join("\n"),
+);
+
+const woodpeckerOnAbort = simMachine("woodpecker", "woodpecker.ini", "on_abort.ngc");
+verifyExpectedOutput(
+  "sim_woodpecker_on_abort_wasm",
+  interp.runSimConfigProgram({
+    files: woodpeckerOnAbort.files,
+    programPath: woodpeckerOnAbort.programPath,
+    iniPath: woodpeckerOnAbort.iniPath,
+  }),
+  [
+    "file_open=0",
+    "run_step phase=execute step=17 rc=1 line=17",
+    "statement_uri=m2",
+    "file_read_count=17",
+    "file_execute_count=17",
+    "file_saw_error=0",
+    "canon_event=ON_RESET",
+    "canon_event=PROGRAM_END",
+    "post_execute.origin_index=1",
+    "post_execute.mist=0",
+    "post_execute.flood=0",
+    "absent=file_error_text=",
+  ].join("\n"),
+);
+
 console.log("sim_configs_wasm_node_smoke=ok");
diff --git a/wasm-port/tools/build_native_probes.sh b/wasm-port/tools/build_native_probes.sh
index 9d6e16e..4d7a0f3 100755
--- a/wasm-port/tools/build_native_probes.sh
+++ b/wasm-port/tools/build_native_probes.sh
@@ -8,6 +8,11 @@ WRAP_DIR="$ROOT_DIR/runtime/core/linuxcnc_wrap"
 SHIM_DIR="$ROOT_DIR/runtime/core/shims"
 INCLUDE_DIR="$ROOT_DIR/runtime/core/include"
 SOURCE_PROBE_MAP="$BUILD_DIR/source-probes.tsv"
+NATIVE_SOURCE_PROOF_SUMMARY="$BUILD_DIR/native-source-proof-summary.tsv"
+NATIVE_RUNTIME_PROBE_SUMMARY="$BUILD_DIR/native-runtime-probe-summary.tsv"
+MILLTURN_USER_M_RUNTIME_PROBE="$ROOT_DIR/tests/native/probe_millturn_user_m_runtime.sh"
+TOOL_DB_RUNTIME_PROBE="$ROOT_DIR/tests/native/probe_tool_db_runtime.sh"
+PYTHON_REMAP_RUNTIME_PROBE="$ROOT_DIR/tests/native/probe_python_remap_runtime.sh"
 MINIMAL_GCODE_FIXTURE="$ROOT_DIR/tests/fixtures/gcode/minimal_linear.ngc"
 DO_WHILE_BREAK_FIXTURE="$ROOT_DIR/vendor/linuxcnc/tests/interp/do-while-break/test.ngc"
 OWORD_BUG315_FIXTURE="$ROOT_DIR/vendor/linuxcnc/tests/interp/oword-bug315/test.ngc"
@@ -175,6 +180,31 @@ native_input_fingerprint() {
       "$SHIM_DIR" \
       "$INCLUDE_DIR" \
       "$ROOT_DIR/tests/fixtures"
+    hash_tree \
+      "$ROOT_DIR/../linuxcnc/configs/sim/axis/vismach/millturn/mcodes" \
+      "$ROOT_DIR/../linuxcnc/configs/sim/axis/vismach/millturn/remap_subs"
+    sha256sum \
+      "$MILLTURN_USER_M_RUNTIME_PROBE" \
+      "$ROOT_DIR/../linuxcnc/configs/sim/axis/vismach/millturn/millturn.ini"
+    hash_tree \
+      "$ROOT_DIR/../linuxcnc/configs/sim/axis/db_demo"
+    sha256sum \
+      "$TOOL_DB_RUNTIME_PROBE" \
+      "$ROOT_DIR/../linuxcnc/src/emc/task/taskclass.cc" \
+      "$ROOT_DIR/../linuxcnc/src/emc/tooldata/tooldata_db.cc" \
+      "$ROOT_DIR/../linuxcnc/src/emc/tooldata/tooldata_common.cc"
+    hash_tree \
+      "$ROOT_DIR/../linuxcnc/configs/sim/axis/laser" \
+      "$ROOT_DIR/../linuxcnc/configs/sim/axis/remap/cycle" \
+      "$ROOT_DIR/../linuxcnc/configs/sim/axis/nc_files/remap_lib/python-stdglue" \
+      "$ROOT_DIR/../linuxcnc/configs/sim/axis/vismach/5axis/table-rotary_spindle-rotary-nutating" \
+      "$ROOT_DIR/../linuxcnc/configs/sim/gmoccapy/python"
+    sha256sum \
+      "$ROOT_DIR/../linuxcnc/src/emc/rs274ngc/interp_python.cc" \
+      "$ROOT_DIR/../linuxcnc/src/emc/pythonplugin/python_plugin.cc" \
+      "$PYTHON_REMAP_RUNTIME_PROBE"
+    hash_tree \
+      "$ROOT_DIR/../linuxcnc/configs/sim/axis/remap/stop-lookahead"
   } | sha256sum | awk '{ print $1 }'
 }
 
@@ -245,6 +275,12 @@ VENDOR_ASSET_FLAGS=(
   -DLINUXCNC_VENDOR_DIR=\"$VENDOR_DIR\"
 )
 
+SOURCE_CONFIG_ASSET_FLAGS=(
+  "${COMMON_INI_FLAGS[@]}"
+  -DLINUXCNC_SOURCE_DIR=\"$ROOT_DIR/../linuxcnc\"
+  -DLINUXCNC_SOURCE_CONFIG_DIR=\"$ROOT_DIR/../linuxcnc/configs/sim\"
+)
+
 MINIMAL_FLAGS=(
   "${COMMON_INI_FLAGS[@]}"
   -ffunction-sections
@@ -309,6 +345,165 @@ write_file_if_changed() {
   mv "$tmp" "$file"
 }
 
+stdout_value() {
+  local file="$1"
+  local key="$2"
+
+  awk -F= -v key="$key" '$1 == key { value = substr($0, length(key) + 2) } END { print value }' "$file"
+}
+
+append_native_source_proof_summary_row() {
+  local tmp="$1"
+  local boundary="$2"
+  local proof_key="$3"
+  local execution_key="$4"
+  local promotion_key="$5"
+  local stdout_log="$6"
+
+  local proof_value
+  local execution_enabled
+  local promotion_allowed
+  proof_value="$(stdout_value "$stdout_log" "$proof_key")"
+  execution_enabled="$(stdout_value "$stdout_log" "$execution_key")"
+  promotion_allowed="$(stdout_value "$stdout_log" "$promotion_key")"
+
+  printf '%s\t%s\t%s\t%s\t%s\t%s\n' \
+    "$boundary" \
+    "$proof_key" \
+    "$proof_value" \
+    "$execution_enabled" \
+    "$promotion_allowed" \
+    "${stdout_log#"$BUILD_DIR"/}" >> "$tmp"
+}
+
+write_native_source_proof_summary() {
+  local tmp
+  tmp="$(mktemp)"
+  printf '%s\t%s\t%s\t%s\t%s\t%s\n' \
+    boundary_class \
+    proof_key \
+    proof_value \
+    execution_enabled \
+    promotion_allowed \
+    stdout_log > "$tmp"
+
+  append_native_source_proof_summary_row \
+    "$tmp" \
+    L4-USER-M-PROCESS \
+    millturn_user_m_native_source_state_proof \
+    millturn_user_m_execution_enabled \
+    millturn_user_m_promotion_allowed \
+    "$BUILD_DIR/linuxcnc_millturn_user_m_boundary_probe.run.stdout.log"
+
+  append_native_source_proof_summary_row \
+    "$tmp" \
+    L4-TOOL-DB \
+    tool_db_native_source_protocol_proof \
+    tool_db_execution_enabled \
+    tool_db_promotion_allowed \
+    "$BUILD_DIR/linuxcnc_tool_db_boundary_probe.run.stdout.log"
+
+  append_native_source_proof_summary_row \
+    "$tmp" \
+    L4-PYTHON-REMAP \
+    python_remap_native_source_inventory_proof \
+    python_remap_execution_enabled \
+    python_remap_promotion_allowed \
+    "$BUILD_DIR/linuxcnc_python_remap_boundary_probe.run.stdout.log"
+
+  if [[ -f "$NATIVE_SOURCE_PROOF_SUMMARY" ]] && cmp -s "$tmp" "$NATIVE_SOURCE_PROOF_SUMMARY"; then
+    rm -f "$tmp"
+    return 0
+  fi
+  mv "$tmp" "$NATIVE_SOURCE_PROOF_SUMMARY"
+}
+
+append_native_runtime_probe_summary_row() {
+  local tmp="$1"
+  local boundary_class="$2"
+  local boundary_kind="$3"
+  local target="$4"
+  local runtime_probe="$5"
+  local prefix="$6"
+  local stdout_log="$7"
+
+  local runtime_ready
+  local source_proof_ready
+  local probe_status
+  local execution_enabled
+  local promotion_allowed
+  local missing_requirements
+  runtime_ready="$(stdout_value "$stdout_log" "${prefix}_runtime_ready")"
+  source_proof_ready="$(stdout_value "$stdout_log" "${prefix}_source_proof_ready")"
+  probe_status="$(stdout_value "$stdout_log" "${prefix}_runtime_probe_status")"
+  execution_enabled="$(stdout_value "$stdout_log" "${prefix}_execution_enabled")"
+  promotion_allowed="$(stdout_value "$stdout_log" "${prefix}_promotion_allowed")"
+  missing_requirements="$(stdout_value "$stdout_log" "${prefix}_missing_requirements")"
+
+  printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n' \
+    "$boundary_class" \
+    "$boundary_kind" \
+    "$target" \
+    "$runtime_probe" \
+    "$runtime_ready" \
+    "$source_proof_ready" \
+    "$probe_status" \
+    "$execution_enabled" \
+    "$promotion_allowed" \
+    "${missing_requirements:-"-"}" \
+    "${stdout_log#"$BUILD_DIR"/}" >> "$tmp"
+}
+
+write_native_runtime_probe_summary() {
+  local tmp
+  tmp="$(mktemp)"
+  printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n' \
+    boundary_class \
+    boundary_kind \
+    target \
+    runtime_probe \
+    runtime_ready \
+    source_proof_ready \
+    probe_status \
+    execution_enabled \
+    promotion_allowed \
+    missing_requirements \
+    stdout_log > "$tmp"
+
+  append_native_runtime_probe_summary_row \
+    "$tmp" \
+    L4-USER-M-PROCESS \
+    external_user_m_process \
+    axis/vismach/millturn/example.ngc \
+    linuxcnc_millturn_user_m_runtime_probe \
+    millturn_user_m \
+    "$BUILD_DIR/linuxcnc_millturn_user_m_runtime_probe.run.stdout.log"
+
+  append_native_runtime_probe_summary_row \
+    "$tmp" \
+    L4-TOOL-DB \
+    tool_database_process \
+    axis/db_demo/base.ngc \
+    linuxcnc_tool_db_runtime_probe \
+    tool_db \
+    "$BUILD_DIR/linuxcnc_tool_db_runtime_probe.run.stdout.log"
+
+  append_native_runtime_probe_summary_row \
+    "$tmp" \
+    L4-PYTHON-REMAP \
+    python_runtime \
+    axis/remap/stop-lookahead/nc_files \
+    linuxcnc_python_remap_runtime_probe \
+    python_remap \
+    "$BUILD_DIR/linuxcnc_python_remap_runtime_probe.run.stdout.log"
+
+  if [[ -f "$NATIVE_RUNTIME_PROBE_SUMMARY" ]] && cmp -s "$tmp" "$NATIVE_RUNTIME_PROBE_SUMMARY"; then
+    rm -f "$tmp"
+    return 0
+  fi
+  mv "$tmp" "$NATIVE_RUNTIME_PROBE_SUMMARY"
+}
+
 write_ccomp_ini() {
   local file="$1"
   local tool_table="$2"
@@ -692,6 +887,20 @@ FIVEAXIS_REMAP_ASSET_PROBE_SOURCES=(
   "$WRAP_DIR/linuxcnc_5axis_remap_asset_probe.cpp"
 )
 
+MILLTURN_USER_M_BOUNDARY_PROBE_SOURCES=(
+  "$VENDOR_DIR/src/emc/ini/inifile.cc"
+  "$WRAP_DIR/linuxcnc_millturn_user_m_boundary_probe.cpp"
+)
+
+TOOL_DB_BOUNDARY_PROBE_SOURCES=(
+  "$VENDOR_DIR/src/emc/ini/inifile.cc"
+  "$WRAP_DIR/linuxcnc_tool_db_boundary_probe.cpp"
+)
+
+PYTHON_REMAP_BOUNDARY_PROBE_SOURCES=(
+  "$WRAP_DIR/linuxcnc_python_remap_boundary_probe.cpp"
+)
+
 STATE_PROBE_SOURCES=(
   "$WRAP_DIR/linuxcnc_interp_state_probe.cpp"
 )
@@ -1102,6 +1311,71 @@ else
     "$BUILD_DIR/linuxcnc_5axis_remap_asset_probe.run.stderr.log"
 fi
 
+build_binary_target \
+  linuxcnc_millturn_user_m_boundary_probe \
+  "$BUILD_DIR/linuxcnc_millturn_user_m_boundary_probe" \
+  SOURCE_CONFIG_ASSET_FLAGS \
+  MILLTURN_USER_M_BOUNDARY_PROBE_SOURCES \
+  NO_LINK_FLAGS \
+  -lfmt
+
+if [[ "$(tr -d '[:space:]' < "$BUILD_DIR/linuxcnc_millturn_user_m_boundary_probe.exitcode")" == "0" ]]; then
+  run_logged_command \
+    linuxcnc_millturn_user_m_boundary_probe \
+    "$BUILD_DIR/linuxcnc_millturn_user_m_boundary_probe"
+  run_logged_command \
+    linuxcnc_millturn_user_m_runtime_probe \
+    bash \
+    "$MILLTURN_USER_M_RUNTIME_PROBE"
+else
+  clear_logged_command linuxcnc_millturn_user_m_boundary_probe
+  clear_logged_command linuxcnc_millturn_user_m_runtime_probe
+fi
+
+build_binary_target \
+  linuxcnc_tool_db_boundary_probe \
+  "$BUILD_DIR/linuxcnc_tool_db_boundary_probe" \
+  SOURCE_CONFIG_ASSET_FLAGS \
+  TOOL_DB_BOUNDARY_PROBE_SOURCES \
+  NO_LINK_FLAGS \
+  -lfmt
+
+if [[ "$(tr -d '[:space:]' < "$BUILD_DIR/linuxcnc_tool_db_boundary_probe.exitcode")" == "0" ]]; then
+  run_logged_command \
+    linuxcnc_tool_db_boundary_probe \
+    "$BUILD_DIR/linuxcnc_tool_db_boundary_probe"
+  run_logged_command \
+    linuxcnc_tool_db_runtime_probe \
+    bash \
+    "$TOOL_DB_RUNTIME_PROBE"
+else
+  clear_logged_command linuxcnc_tool_db_boundary_probe
+  clear_logged_command linuxcnc_tool_db_runtime_probe
+fi
+
+build_binary_target \
+  linuxcnc_python_remap_boundary_probe \
+  "$BUILD_DIR/linuxcnc_python_remap_boundary_probe" \
+  SOURCE_CONFIG_ASSET_FLAGS \
+  PYTHON_REMAP_BOUNDARY_PROBE_SOURCES \
+  NO_LINK_FLAGS
+
+if [[ "$(tr -d '[:space:]' < "$BUILD_DIR/linuxcnc_python_remap_boundary_probe.exitcode")" == "0" ]]; then
+  run_logged_command \
+    linuxcnc_python_remap_boundary_probe \
+    "$BUILD_DIR/linuxcnc_python_remap_boundary_probe"
+  run_logged_command \
+    linuxcnc_python_remap_runtime_probe \
+    bash \
+    "$PYTHON_REMAP_RUNTIME_PROBE"
+else
+  clear_logged_command linuxcnc_python_remap_boundary_probe
+  clear_logged_command linuxcnc_python_remap_runtime_probe
+fi
+
+write_native_source_proof_summary
+write_native_runtime_probe_summary
+
 build_object_target \
   linuxcnc_inifile_source_probe \
   "$BUILD_DIR/linuxcnc_inifile_source_probe.o" \
diff --git a/wasm-port/tools/source-manifest.txt b/wasm-port/tools/source-manifest.txt
index 658511d..d6a0b86 100644
--- a/wasm-port/tools/source-manifest.txt
+++ b/wasm-port/tools/source-manifest.txt
@@ -496,11 +496,19 @@ configs/sim/axis/external_offsets/jwp_z.ini
 configs/sim/axis/external_offsets/jwp_z.ngc
 configs/sim/axis/external_offsets/opa.ini
 configs/sim/axis/external_offsets/opa_demo.ngc
+configs/sim/axis/db_demo/base.ngc
+configs/sim/axis/db_demo/db_nonran.ini
 configs/sim/axis/foam/axis_foam.ini
 configs/sim/axis/foam/foam.ngc
+configs/sim/axis/gladevcp/gladevcp_panel.ini
+configs/sim/axis/gladevcp/probe.ngc
+configs/sim/axis/gladevcp/sim.tbl
 configs/sim/axis/geometry/M110
 configs/sim/axis/geometry/xyzc.ini
 configs/sim/axis/geometry/xyzc.ngc
+configs/sim/axis/rose_engine/rcone.ngc
+configs/sim/axis/rose_engine/rcone_demo.ngc
+configs/sim/axis/rose_engine/rose_engine.ini
 configs/sim/axis/vismach/5axis/bridgemill/5axis.ini
 configs/sim/axis/vismach/5axis/bridgemill/5axis.tbl
 configs/sim/axis/vismach/5axis/bridgemill/5axis.xml
@@ -511,6 +519,25 @@ configs/sim/axis/vismach/5axis/bridgemill/README
 configs/sim/axis/vismach/5axis/bridgemill/remap_subs/428remap.ngc
 configs/sim/axis/vismach/5axis/bridgemill/remap_subs/429remap.ngc
 configs/sim/axis/vismach/5axis/bridgemill/remap_subs/430remap.ngc
+configs/sim/axis/vismach/melfa-sim/example.ngc
+configs/sim/axis/vismach/melfa-sim/melfa.ini
+configs/sim/axis/vismach/melfa-sim/melfa.tbl
+configs/sim/axis/vismach/melfa-sim/remap_subs/428remap.ngc
+configs/sim/axis/vismach/melfa-sim/remap_subs/429remap.ngc
+configs/sim/axis/vismach/melfa-sim/remap_subs/430remap.ngc
+configs/sim/axis/vismach/millturn/example.ngc
+configs/sim/axis/vismach/millturn/millturn.ini
+configs/sim/axis/vismach/millturn/millturn.tbl
+configs/sim/axis/vismach/millturn/remap_subs/428remap.ngc
+configs/sim/axis/vismach/millturn/remap_subs/429remap.ngc
+configs/sim/axis/vismach/puma/puma.ini
+configs/sim/axis/vismach/puma/puma.tbl
+configs/sim/axis/vismach/puma/puma_cube.ini
+configs/sim/axis/vismach/puma/puma_cube.ngc
+configs/sim/axis/vismach/puma/puma_seam_weld.ngc
+configs/sim/axis/vismach/puma/remap_subs/428remap.ngc
+configs/sim/axis/vismach/puma/remap_subs/429remap.ngc
+configs/sim/axis/vismach/puma/remap_subs/430remap.ngc
 configs/sim/axis/vismach/5axis/table-dual-rotary/README
 configs/sim/axis/vismach/5axis/table-dual-rotary/demos/xyzab-tdr-demo.ngc
 configs/sim/axis/vismach/5axis/table-dual-rotary/remap_subs/428remap.ngc
@@ -550,6 +577,27 @@ configs/sim/axis/vismach/5axis/table-rotary-tilting/xyzbc-trt.ini
 configs/sim/axis/vismach/5axis/table-rotary-tilting/xyzbc-trt.tbl
 configs/sim/axis/vismach/5axis/table-rotary-tilting/xyzbc-trt.txt
 configs/sim/axis/vismach/5axis/table-rotary-tilting/xyzbc-trt.xml
+configs/sim/qtdragon/qtdragon_multi_joint/on_abort.ngc
+configs/sim/qtdragon/qtdragon_multi_joint/qtdragon_xyyz.ini
+configs/sim/qtdragon/qtdragon_multi_joint/tool.tbl
+configs/sim/qtdragon/qtdragon_xyz/on_abort.ngc
+configs/sim/qtdragon/qtdragon_xyz/qtdragon_inch.ini
+configs/sim/qtdragon/qtdragon_xyz/tool.tbl
+configs/sim/qtdragon/qtdragon_xyz45/on_abort.ngc
+configs/sim/qtdragon/qtdragon_xyz45/qtdragon_xyza.ini
+configs/sim/qtdragon/qtdragon_xyz45/tool.tbl
+configs/sim/qtdragon_hd/qtdragon_hd_xyz/on_abort.ngc
+configs/sim/qtdragon_hd/qtdragon_hd_xyz/qtdragon_hd_vertical.ini
+configs/sim/qtdragon_hd/qtdragon_hd_xyz/tool.tbl
+configs/sim/qtdragon_hd/qtdragon_hd_z_compensation/on_abort.ngc
+configs/sim/qtdragon_hd/qtdragon_hd_z_compensation/qtdragon_hd_z_compensation.ini
+configs/sim/qtdragon_hd/qtdragon_hd_z_compensation/tool.tbl
+configs/sim/qtvcp_screens/qtdragon/on_abort.ngc
+configs/sim/qtvcp_screens/qtdragon/qtdragon_mpg.ini
+configs/sim/qtvcp_screens/qtdragon/tool.tbl
+configs/sim/woodpecker/on_abort.ngc
+configs/sim/woodpecker/tool.tbl
+configs/sim/woodpecker/woodpecker.ini
 nc_files/3D_Chips.ngc
 nc_files/arcspiral.ngc
 nc_files/factorial.ngc
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/db_demo/base.ngc b/wasm-port/vendor/linuxcnc/configs/sim/axis/db_demo/base.ngc
new file mode 100644
index 0000000..64d2b29
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/db_demo/base.ngc
@@ -0,0 +1,17 @@
+%
+#<toolno>  = 10
+#<ct>      =  0
+#<howmany> =  5
+
+g49
+o100 while [[#<ct> lt #<howmany>] and [#<_task> ne 0]]
+       #<ct> = [#<ct> +1]
+       t#<toolno> m6 g43
+       (debug,ct=#<ct> zoff=#5403)
+       g4p[0.05*60] ;approx 0.05 minutes
+       t0m6
+       g10l0 ; reload tooldata (apply_db_rules)
+o100 endwhile
+g49
+(debug, fini)
+%
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/db_demo/db_nonran.ini b/wasm-port/vendor/linuxcnc/configs/sim/axis/db_demo/db_nonran.ini
new file mode 100644
index 0000000..abf7f32
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/db_demo/db_nonran.ini
@@ -0,0 +1,17 @@
+#INCLUDE base.inc
+
+[EMC]
+VERSION = 1.1
+MACHINE = db_nonran NONRANDOM toolchanger
+
+[RS274NGC]
+PARAMETER_FILE = db_nonran.var
+SUBROUTINE_PATH = .
+
+[EMCIO]
+RANDOM_TOOLCHANGER   = 0
+DB_PROGRAM           = ./db_nonran.py
+# alternate spec using args:
+# DB_PROGRAM = ./db_nonran.py --period_minutes=10 /tmp/db_nonran_special
+
+# TOOL_TABLE= is not used with DB_PROGRAM
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/gladevcp/gladevcp_panel.ini b/wasm-port/vendor/linuxcnc/configs/sim/axis/gladevcp/gladevcp_panel.ini
new file mode 100644
index 0000000..a8f477b
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/gladevcp/gladevcp_panel.ini
@@ -0,0 +1,125 @@
+[EMC]
+VERSION = 1.1
+MACHINE = LinuxCNC-PANEL-GLADEVCP
+# Debug level, 0 means no messages. See src/emc/nml_int/emcglb.h for others
+DEBUG = 0
+
+[DISPLAY]
+GLADEVCP= -u hitcounter.py manual-example.ui
+DISPLAY = axis
+CYCLE_TIME = 0.100
+HELP_FILE = doc/help.txt
+POSITION_OFFSET = RELATIVE
+POSITION_FEEDBACK = ACTUAL
+MAX_FEED_OVERRIDE = 1.2
+MAX_SPINDLE_OVERRIDE = 1.0
+MAX_LINEAR_VELOCITY = 1.2
+DEFAULT_LINEAR_VELOCITY = .25
+PROGRAM_PREFIX = ../../nc_files/
+INTRO_GRAPHIC = linuxcnc.gif
+INTRO_TIME = 5
+#EDITOR = geany
+TOOL_EDITOR = tooledit
+INCREMENTS = 1 in, 0.1 in, 10 mil, 1 mil, 1mm, .1mm, 1/8000 in
+
+[FILTER]
+PROGRAM_EXTENSION = .png,.gif,.jpg Grayscale Depth Image
+PROGRAM_EXTENSION = .py Python Script
+png = image-to-gcode
+gif = image-to-gcode
+jpg = image-to-gcode
+py = python3
+
+[RS274NGC]
+PARAMETER_FILE = sim.var
+SUBROUTINE_PATH = ../../nc_files/gladevcp_lib
+
+[EMCMOT]
+EMCMOT = motmod
+COMM_TIMEOUT = 1.0
+SERVO_PERIOD = 1000000
+
+[TASK]
+TASK = milltask
+CYCLE_TIME = 0.001
+
+[HAL]
+HALUI = halui
+HALFILE = LIB:basic_sim.tcl
+POSTGUI_HALFILE= manual-example.hal
+
+[TRAJ]
+COORDINATES = X Y Z
+HOME = 0 0 0
+LINEAR_UNITS = inch
+ANGULAR_UNITS = degree
+DEFAULT_LINEAR_VELOCITY = 1.2
+POSITION_FILE = position.txt
+MAX_LINEAR_VELOCITY = 1.2
+NO_FORCE_HOMING = 1
+
+[EMCIO]
+TOOL_TABLE = sim.tbl
+TOOL_CHANGE_POSITION = 0 0 0
+TOOL_CHANGE_QUILL_UP = 1
+
+[KINS]
+KINEMATICS = trivkins
+JOINTS = 3
+
+[AXIS_X]
+HOME = 0.000
+MIN_LIMIT = -40.0
+MAX_LIMIT = 40.0
+MAX_VELOCITY = 4
+MAX_ACCELERATION = 100.0
+
+[JOINT_0]
+TYPE = LINEAR
+HOME = 0.000
+MAX_VELOCITY = 4
+MAX_ACCELERATION = 100.0
+MIN_LIMIT = -40.0
+MAX_LIMIT = 40.0
+HOME_OFFSET = 0.0
+HOME_SEARCH_VEL = 20.0
+HOME_LATCH_VEL = 20.0
+HOME_SEQUENCE = 1
+
+[AXIS_Y]
+HOME = 0.000
+MIN_LIMIT = -40.0
+MAX_LIMIT = 40.0
+MAX_VELOCITY = 4
+MAX_ACCELERATION = 100.0
+
+[JOINT_1]
+TYPE = LINEAR
+HOME = 0.000
+MAX_VELOCITY = 4
+MAX_ACCELERATION = 100.0
+MIN_LIMIT = -40.0
+MAX_LIMIT = 40.0
+HOME_OFFSET = 0.0
+HOME_SEARCH_VEL = 20.0
+HOME_LATCH_VEL = 20.0
+HOME_SEQUENCE = 1
+
+[AXIS_Z]
+HOME = 0.0
+MIN_LIMIT = -8.0
+MAX_LIMIT = 0.0001
+MAX_VELOCITY = 4
+MAX_ACCELERATION = 100.0
+
+[JOINT_2]
+TYPE = LINEAR
+HOME = 0.0
+MAX_VELOCITY = 4
+MAX_ACCELERATION = 100.0
+MIN_LIMIT = -8.0
+MAX_LIMIT = 0.0001
+HOME_OFFSET = 1.0
+HOME_SEARCH_VEL = 20.0
+HOME_LATCH_VEL = 20.0
+HOME_SEQUENCE = 0
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/gladevcp/probe.ngc b/wasm-port/vendor/linuxcnc/configs/sim/axis/gladevcp/probe.ngc
new file mode 100644
index 0000000..85e6afd
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/gladevcp/probe.ngc
@@ -0,0 +1,57 @@
+; caveat - this changes feed and abs/relative mode
+
+O<probe> SUB
+
+(print, _Probe_Axis= #<_Probe_Axis>)
+(print, _Probe_Speed = #<_Probe_Speed>)
+(print, _Probe_Retract = #<_Probe_Retract>)
+(print, _Probe_Distance = #<_Probe_Distance>)
+(print, _Probe_Diameter = #<_Probe_Diameter>)
+(print, _Probe_System = #<_Probe_System>)
+
+
+O<xaxis> if [#<_Probe_Axis> eq 0]
+
+    G91 G38.3 X#<_Probe_Distance> F#<_Probe_Speed>
+    O<xresult> if [#5070]
+       (MSG, probe succeeded)
+       G10 L20 P#<_Probe_System> X#<_Probe_Diameter>
+        G90 G0 X#<_Probe_Retract>
+    O<xresult> else
+        (MSG,probe failed)
+        G91 G0 X[0 - #<_Probe_Distance>]
+    O<xresult> endif
+    G90
+O<xaxis> endif
+
+O<yaxis> if [#<_Probe_Axis> eq 1]
+
+    G91 G38.3 y#<_Probe_Distance> F#<_Probe_Speed>
+    O<yresult> if [#5070]
+       (MSG, probe succeeded)
+       G10 L20 P#<_Probe_System> y#<_Probe_Diameter>
+        G90 G0 y#<_Probe_Retract>
+    O<yresult> else
+        (MSG,probe failed)
+        G91 G0 y[0 - #<_Probe_Distance>]
+    O<yresult> endif
+    G90
+O<yaxis> endif
+
+O<zaxis> if [#<_Probe_Axis> eq 2]
+
+    G91 G38.3 z#<_Probe_Distance> F#<_Probe_Speed>
+    O<zresult> if [#5070]
+       (MSG, probe succeeded)
+       G10 L20 P#<_Probe_System> z#<_Probe_Diameter>
+        G90 G0 z#<_Probe_Retract>
+    O<zresult> else
+        (MSG,probe failed)
+        G91 G0 z[0 - #<_Probe_Distance>]
+    O<zresult> endif
+    G90
+O<zaxis> endif
+
+O<probe> endsub
+
+M2
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/gladevcp/sim.tbl b/wasm-port/vendor/linuxcnc/configs/sim/axis/gladevcp/sim.tbl
new file mode 100644
index 0000000..5bb77ac
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/gladevcp/sim.tbl
@@ -0,0 +1,4 @@
+T1 P1 D0.125000 Z+0.511000 ;1/8 end mill
+T2 P2 D0.062500 Z+0.100000 ;1/16 end mill
+T3 P3 D0.201000 Z+1.273000 ;#7 tap drill
+T98876 P543 Z+0.100000 ;big tool number
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/rose_engine/rcone.ngc b/wasm-port/vendor/linuxcnc/configs/sim/axis/rose_engine/rcone.ngc
new file mode 100644
index 0000000..34ebd60
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/rose_engine/rcone.ngc
@@ -0,0 +1,27 @@
+o<rcone> sub
+   #<rmax>   = #1 (= 10)
+   #<rmin>   = #2 (=  1)
+    #<del_r> = #3 (=  0.001)
+    #<del_z> = #4 (= -0.001)
+#<del_theta> = #5 (= +1 1:CCW -1:CW)
+    #<frate> = #6 (=100)
+
+#<r> = #<rmax>
+#<z> = 0
+#<theta> = 0
+
+f #<frate>
+
+g0 x#<r> y0
+o<10wh> while [#<r> gt #<rmin>]
+         #<r> = [#<r> - #<del_r>]
+         #<theta> = [#<theta> + #<del_theta>]
+         #<x> = [#<r> * cos[#<theta>]]
+         #<y> = [#<r> * sin[#<theta>]]
+         #<z> = [#<z> + #<del_z>]
+         ;#<x> = [#<rmax> * cos[#<theta>]]
+         ;#<y> = [#<rmax> * sin[#<theta>]]
+         ;#<z> = [0 + #<del_z>]
+         g1 x#<x> y#<y> z#<z>
+o<10wh> endwhile
+o<rcone> endsub
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/rose_engine/rcone_demo.ngc b/wasm-port/vendor/linuxcnc/configs/sim/axis/rose_engine/rcone_demo.ngc
new file mode 100644
index 0000000..ae8d18a
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/rose_engine/rcone_demo.ngc
@@ -0,0 +1,11 @@
+f1000
+#<v> = 10
+g0 x  #<v> y   0    z 0
+g1 x  #<v> y  #<v>
+g1 x -#<v> y  #<v>
+g1 x -#<v> y -#<v>
+g1 x  #<v> y -#<v>
+g1 x  #<v> y   0
+g0                  z 0
+o<rcone> call [#<v>][1][0.001][-0.001][+1][100]
+m2
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/rose_engine/rose_engine.ini b/wasm-port/vendor/linuxcnc/configs/sim/axis/rose_engine/rose_engine.ini
new file mode 100644
index 0000000..7ad0172
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/rose_engine/rose_engine.ini
@@ -0,0 +1,84 @@
+[APPLICATIONS]
+APP = halshow rose_engine.halshow
+[HAL]
+HALUI = halui
+HALFILE = LIB:basic_sim.tcl
+
+[TRAJ]
+        COORDINATES = XYZ
+       LINEAR_UNITS = inch
+      ANGULAR_UNITS = degree
+DEFAULT_LINEAR_VELOCITY = 10
+MAX_LINEAR_VELOCITY = 10
+
+[KINS]
+ KINEMATICS = rosekins
+     JOINTS =  3
+
+[EMC]
+VERSION = 1.1
+MACHINE = Roseengine
+
+[DISPLAY]
+                 DISPLAY = axis
+               OPEN_FILE = ./rcone_demo.ngc
+         POSITION_OFFSET = RELATIVE
+     MAX_LINEAR_VELOCITY =  10
+ DEFAULT_LINEAR_VELOCITY =  10
+    MAX_ANGULAR_VELOCITY =  72
+DEFAULT_ANGULAR_VELOCITY =  72
+       MAX_FEED_OVERRIDE =   2
+             TOOL_EDITOR = tooledit
+              INCREMENTS = 1 in,0.1in,10mil,1mil
+                   TKPKG = Ngcgui 1.0
+          NGCGUI_SUBFILE = rcone.ngc
+             NGCGUI_FONT = Helvetica -14 normal
+
+[RS274NGC]
+PARAMETER_FILE = /tmp/rose.var
+SUBROUTINE_PATH = .
+
+[TASK]
+      TASK = milltask
+CYCLE_TIME = 0.001
+
+[EMCMOT]
+      EMCMOT = motmod
+SERVO_PERIOD = 1000000
+
+[EMCIO]
+TOOL_TABLE = rose.tbl
+
+[AXIS_X]
+    MAX_VELOCITY =  3
+MAX_ACCELERATION = 30
+[AXIS_Y]
+    MAX_VELOCITY =  3
+MAX_ACCELERATION = 30
+[AXIS_Z]
+    MAX_VELOCITY =  3
+MAX_ACCELERATION = 30
+
+# Notes:
+# HOME_SEARCH_VEL=0 for immediate homing
+#   HOME_SEQUENCE=0 for homeall in gui
+[JOINT_0]
+              TYPE = LINEAR
+      MAX_VELOCITY =  3
+  MAX_ACCELERATION = 30
+   HOME_SEARCH_VEL =  0
+     HOME_SEQUENCE =  0
+
+[JOINT_1]
+              TYPE = LINEAR
+      MAX_VELOCITY =  3
+  MAX_ACCELERATION = 30
+   HOME_SEARCH_VEL =  0
+     HOME_SEQUENCE =  0
+
+[JOINT_2]
+              TYPE = ANGULAR
+      MAX_VELOCITY =   72
+  MAX_ACCELERATION =  360
+   HOME_SEARCH_VEL =    0
+     HOME_SEQUENCE =    0
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim/example.ngc b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim/example.ngc
new file mode 100644
index 0000000..1bb2f2b
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim/example.ngc
@@ -0,0 +1,93 @@
+(Preamble)
+G90 G64 P0.1 Q1
+
+(Switch to Joint mode trivial kinematics)
+M429
+
+(When using "Joint" mode we need to make sure that)
+(the offsets are set correctly for the pose we used)
+(when we set up the Modified DH-Parameters for the )
+("genserkins" kinematic where we cannot define 'Theta')
+(-values.)
+("M429" sets offsets to "G59.2" and resets those)
+(to "G10 L2 P8 X0 Y-90 Z0 A0 B0 C0" so we match the DH-)
+(Parameter model used in the genserkins kinematics)
+(Note that this pose leaves Joint_3 and Joint_5 collinear)
+(and that will cause the inverse kinematics to fail so we)
+(need to make sure that the wrist does not start out at)
+(zero degrees.)
+(Note that we also change speed settings through HAL when)
+(we switch kinematics)
+
+(Set the start pose to make sure the kinematics can handle it)
+G01 X0 Y0 Z0 A0 B0 C0 F1000
+
+(Switch to Coordinated, i.e. cartesian, world mode)
+M428
+("M428" sets offsets to "G59.1" and resets those)
+(to "G10 L2 P7 X0 Y0 Z0 A0 B0 C0")
+(Origin is at bottom center of the robot base)
+(So to use other, nonzero, offsets we need to declare after)
+(each switch of the kinematics)
+
+
+
+G0 X450 Y200 Z350 B10 C45
+
+(Draw a cube of 150mm)
+G91
+G0 Y150
+X150
+Y-150
+X-150
+Z150
+Y150
+Z-150
+Z150
+X150
+Z-150
+Z150
+Y-150
+Z-150
+Z150
+X-150
+
+(Switch to Joint mode trivial kinematics)
+M429
+
+(Go different pose)
+G90
+G0 X90 Y0 Z0 A0
+
+(Switch to Coordinated, i.e. cartesian, world mode)
+M428
+
+(Draw a cube of 150mm)
+G91
+G0
+Z-150
+Y150
+X150
+Y-150
+X-150
+Z150
+Y150
+Z-150
+Z150
+X150
+Z-150
+Z150
+Y-150
+Z-150
+Z150
+X-150
+
+
+(Switch to Joint mode trivial kinematics)
+M429
+
+(Go to start pose)
+G90
+G0 X0 Y0 Z0 A0
+
+M2
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim/melfa.ini b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim/melfa.ini
new file mode 100644
index 0000000..5bb62b6
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim/melfa.ini
@@ -0,0 +1,143 @@
+[EMC]
+VERSION = 1.1
+MACHINE = melfa (mm)
+DEBUG = 0
+
+[KINS]
+KINEMATICS= genserkins
+JOINTS= 6
+
+[HAL]
+HALUI = halui
+HALFILE = LIB:basic_sim.tcl
+HALFILE = melfa_dh.hal
+HALCMD = loadusr -W melfagui
+HALCMD = net :kinstype-select <= motion.analog-out-03 => motion.switchkins-type
+POSTGUI_HALFILE = melfa-postgui.hal
+
+[RS274NGC]
+PARAMETER_FILE  = melfa.var
+SUBROUTINE_PATH = ./remap_subs
+   HAL_PIN_VARS = 1
+          REMAP = M428  modalgroup=10  ngc=428remap
+          REMAP = M429  modalgroup=10  ngc=429remap
+          REMAP = M430  modalgroup=10  ngc=430remap
+RS274NGC_STARTUP_CODE =    G10 L2 P7 X0 Y0 Z0 A-180 B0 C0 G59.1 (debug, ini: startup offsets)
+
+[HALUI]
+MDI_COMMAND = M429
+MDI_COMMAND = M428
+MDI_COMMAND = M430
+
+
+[DISPLAY]
+DISPLAY = axis
+GEOMETRY = XYZABC
+CYCLE_TIME = 0.200
+POSITION_OFFSET = RELATIVE
+POSITION_FEEDBACK = ACTUAL
+DEFAULT_LINEAR_VELOCITY = 60.0
+DEFAULT_ANGULAR_VELOCITY = 40.0
+MAX_FEED_OVERRIDE = 2.0
+PROGRAM_PREFIX = ./
+INTRO_GRAPHIC = linuxcnc.gif
+INTRO_TIME = 5
+PYVCP = melfa.xml
+EDITOR = geany
+OPEN_FILE = example.ngc
+
+[TASK]
+TASK = milltask
+CYCLE_TIME = 0.010
+
+
+[EMCMOT]
+EMCMOT = motmod
+COMM_TIMEOUT = 1.0
+SERVO_PERIOD = 1000000
+
+[TRAJ]
+COORDINATES = X Y Z A B C
+LINEAR_UNITS = mm
+ANGULAR_UNITS = deg
+DEFAULT_LINEAR_VELOCITY = 60.0
+DEFAULT_ANGULAR_VELOCITY = 60.0
+MAX_LINEAR_VELOCITY = 200.0
+MAX_ANGULAR_VELOCITY = 100.0
+DEFAULT_LINEAR_ACCELERATION = 200.0
+MAX_LINEAR_ACCELERATION = 400.0
+
+[EMCIO]
+TOOL_TABLE = melfa.tbl
+
+[JOINT_0]
+TYPE = ANGULAR
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
+MIN_LIMIT = -170.0
+MAX_LIMIT =  170.0
+HOME_SEQUENCE = 0
+HOME_OFFSET = 0
+HOME = 0
+[JOINT_1]
+TYPE = ANGULAR
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
+MIN_LIMIT = -182.0
+MAX_LIMIT = 45.0
+HOME_OFFSET = 0.0
+HOME_SEQUENCE = 0
+HOME = -90.001
+[JOINT_2]
+TYPE = ANGULAR
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
+MIN_LIMIT = -219.0
+MAX_LIMIT = 76.0
+HOME_OFFSET = 0.0
+HOME_SEQUENCE = 0
+HOME = 0.001
+[JOINT_3]
+TYPE = ANGULAR
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
+MIN_LIMIT = -160.0
+MAX_LIMIT = 160.0
+HOME_OFFSET = 0.0
+HOME_SEQUENCE = 0
+HOME = 0.001
+[JOINT_4]
+TYPE = ANGULAR
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
+MIN_LIMIT = -120.0
+MAX_LIMIT = 120.0
+HOME_OFFSET = 0.0
+HOME_SEQUENCE = 0
+HOME = 90.001
+[JOINT_5]
+TYPE = ANGULAR
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
+HOME_OFFSET = 0.0
+HOME_SEQUENCE = 0
+HOME = 0.001
+
+[AXIS_X]
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
+[AXIS_Y]
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
+[AXIS_Z]
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
+[AXIS_A]
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
+[AXIS_B]
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
+[AXIS_C]
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim/melfa.tbl b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim/melfa.tbl
new file mode 100644
index 0000000..acc8f0c
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim/melfa.tbl
@@ -0,0 +1,4 @@
+T1 P1 Z100 D0.125 ;1/8 end mill
+T2 P2 Z0.1 D0.0625 ;1/16 end mill
+T3 P3 Z1.273 D0.201 ;#7 tap drill
+T99999 P99999 Z0.1 ;big tool number
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim/remap_subs/428remap.ngc b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim/remap_subs/428remap.ngc
new file mode 100644
index 0000000..8669ac0
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim/remap_subs/428remap.ngc
@@ -0,0 +1,28 @@
+;M428 by remap: select genserkins
+o<428remap>sub
+  #<SWITCHKINS_PIN> = 3  ; set N as required: motion.analog-out-0N
+  #<kinstype> = 0        ; genserkins
+
+o1 if [exists [#<_hal[motion.switchkins-type]>]]
+o1 else
+     (debug,M428:Missing [RS274NGC]FEATURE==8)
+     (debug,STOP)
+     M2
+o1 endif
+
+   M66  E0 L0                           ; force synch
+   M68  E#<SWITCHKINS_PIN> Q#<kinstype> ; set kinstype value
+   G10 L2 P7 X0 Y0 Z0 A-180 B0 C0
+   G59.1
+   M66  E0 L0                           ; force synch
+;   (debug, M428:genserkins)
+
+o2 if [[#<_task> EQ 1] AND [#<_hal[motion.switchkins-type]> NE 0]]
+     (debug,M428: Wrong motion.switchkins-type)
+     (debug,or missing hal net to analog-out-0x)
+     (debug,STOP)
+     M2
+o2 else
+o2 endif
+
+o<428remap>endsub
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim/remap_subs/429remap.ngc b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim/remap_subs/429remap.ngc
new file mode 100644
index 0000000..32dff4d
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim/remap_subs/429remap.ngc
@@ -0,0 +1,28 @@
+;M429 by remap: select identity kins
+o<429remap>sub
+  #<SWITCHKINS_PIN> = 3  ; set N as required: motion.analog-out-0N
+  #<kinstype> = 1        ; identity kins
+
+o1 if [exists [#<_hal[motion.switchkins-type]>]]
+o1 else
+     (debug,M429:Missing [RS274NGC]FEATURE==8)
+     (debug,STOP)
+     M2
+o1 endif
+
+   M66  E0 L0                           ; force synch
+   M68  E#<SWITCHKINS_PIN> Q#<kinstype> ; set kinstype value
+   G10 L2 P8 X0 Y-90 Z0 A0 B90 C0
+   G59.2
+   M66  E0 L0                           ; force synch
+;   (debug, M429:identity kins)
+
+o2 if [[#<_task> EQ 1] AND [#<_hal[motion.switchkins-type]> NE 1]]
+     (debug,M429:Wrong motion.switchkins-type)
+     (debug,or missing hal net to analog-out-0x)
+     (debug,STOP)
+     M2
+o2 else
+o2 endif
+
+o<429remap>endsub
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim/remap_subs/430remap.ngc b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim/remap_subs/430remap.ngc
new file mode 100644
index 0000000..c7d0874
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/melfa-sim/remap_subs/430remap.ngc
@@ -0,0 +1,26 @@
+;M430 by remap: select gensertool kins
+o<430remap>sub
+  #<SWITCHKINS_PIN> = 3  ; set N as required: motion.analog-out-0N
+  #<kinstype> = 2        ; gensertool kins
+
+o1 if [exists [#<_hal[motion.switchkins-type]>]]
+o1 else
+     (debug,M430:Missing [RS274NGC]FEATURE==8)
+     (debug,STOP)
+     M2
+o1 endif
+
+   M66  E0 L0                           ; force synch
+   M68  E#<SWITCHKINS_PIN> Q#<kinstype> ; set kinstype value
+   M66  E0 L0                           ; force synch
+;   (debug, M429:identity kins)
+
+o2 if [[#<_task> EQ 1] AND [#<_hal[motion.switchkins-type]> NE 2]]
+     (debug,M430:Wrong motion.switchkins-type)
+     (debug,or missing hal net to analog-out-0x)
+     (debug,STOP)
+     M2
+o2 else
+o2 endif
+
+o<430remap>endsub
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/millturn/example.ngc b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/millturn/example.ngc
new file mode 100644
index 0000000..5034df1
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/millturn/example.ngc
@@ -0,0 +1,212 @@
+(setup work offsets to run sim w/o .var file)
+G10 L2 P1 X-160 Y0 Z-230 (setup G54 for mill)
+G10 L2 P2 X-275 Y0 Z-140 (setup G55 for turn)
+
+(actual code starts here)
+G21
+G40
+G64
+
+M429 (turning)
+G18 G8
+G54
+T05 M6 G43
+G00 X20 Z25
+G00 X13.5 Z1.0 S1000 M3
+Z0.488
+G94 G01 X-1.0 F1000.0
+Z0.975
+G00 X0.383 Z1.269
+X13.5
+Z0.0
+G01 X-1.0
+Z0.488
+G00 X0.383 Z0.782
+X13.5
+Z1.0
+Z2.0
+X11.237
+G01 Z-34.973 F1000.0
+X12.2 Z-35.95
+Z-37.95
+X12.625
+G00 X13.625 Z-36.95
+Z2.0
+X9.849
+G01 Z-19.832
+G00 X10.849 Z-18.832
+Z2.0
+X8.461
+G01 Z-19.832
+X9.849
+G00 X10.849 Z-18.832
+Z2.0
+X7.073
+G01 Z-10.296
+G00 X8.073 Z-9.296
+Z2.0
+X5.685
+G01 Z-8.784
+G03 X7.073 Z-10.296 I-0.98513 K-2.29772
+G00 X8.073 Z-9.296
+Z2.0
+X4.297
+G01 Z-8.582
+X4.7
+G03 X5.685 Z-8.784 I-0.0 K-2.5
+G00 X6.685 Z-7.784
+Z2.0
+X2.909
+G01 Z-0.559
+G00 X3.909 Z0.441
+Z2.0
+X1.521
+G01 Z0.829
+X2.909 Z-0.559
+G00 X4.909 Z1.441
+Z0.441
+X2.909
+G01 Z-0.559
+X3.2 Z-0.85
+Z-4.15
+X2.909 Z-4.654
+Z-8.11
+G02 X4.2 Z-8.582 I1.29082 K1.52767
+G01 X4.297
+G00 X5.297 Z-7.582
+Z-4.654
+X3.909
+G01 X2.909
+X2.468 Z-5.418
+G02 X2.2 Z-6.418 I1.73205 K-1.0
+G01 Z-6.582
+G02 X2.909 Z-8.11 I2.0 K0.0
+G00 X3.909 Z-7.11
+X7.073
+Z-9.296
+G01 Z-10.296
+G03 X7.2 Z-11.082 I-2.3731 K-0.78638
+G01 Z-11.382
+G03 X7.073 Z-12.168 I-2.5 K0.0
+G01 Z-19.832
+X8.461
+G00 X9.461 Z-18.832
+Z-12.168
+X8.073
+G01 X7.073
+G03 X6.485 Z-13.132 I-2.3731 K0.78638
+G02 X5.685 Z-14.204 I3.57071 K-3.5
+G01 Z-18.76
+G02 X6.485 Z-19.832 I4.37094 K2.42793
+G01 X7.073
+G00 X8.073 Z-18.832
+Z-14.204
+X6.685
+G01 X5.685
+G02 X5.058 Z-16.482 I4.37075 K-2.42793
+G02 X5.685 Z-18.76 I4.99775 K0.15
+G00 X6.685 Z-17.76
+X9.849
+Z-18.832
+G01 Z-19.832
+X10.2
+Z-20.132
+X9.849 Z-20.74
+Z-24.42
+G00 X10.849 Z-23.42
+Z-20.74
+G01 X9.849
+X8.787 Z-22.58
+X9.849 Z-24.42
+G00 X10.849 Z-23.42
+X9.849
+G01 Z-24.42
+X10.2 Z-25.028
+Z-27.328
+G02 X9.849 Z-28.029 I5.70735 K-3.29514
+G01 Z-32.917
+G02 X11.214 Z-34.95 I6.0583 K2.594
+G01 X11.237 Z-34.973
+G00 X12.237 Z-33.973
+Z-28.029
+X10.849
+G01 X9.849
+G02 X9.319 Z-30.473 I6.05858 K-2.594
+G02 X9.849 Z-32.917 I6.58858 K0.15
+G00 X10.849 Z-31.917
+Z-29.029
+X11.237
+Z2.0
+X0.534 Z3.241
+G01 X0.202 Z3.041 F150.0
+G02 X1.081 Z0.919 I3.0 K0.0
+G01 X3.0 Z-1.0
+Z-4.0
+X2.268 Z-5.268
+G02 X2.0 Z-6.268 I1.73205 K-1.0
+G01 Z-6.732
+G02 X4.0 Z-8.732 I2.0 K0.0
+G01 X4.5
+G03 X6.285 Z-12.982 I-0.0 K-2.5
+G02 Z-19.982 I3.57071 K-3.5
+G01 X10.0
+X8.5 Z-22.58
+X10.0 Z-25.178
+Z-27.178
+G02 X11.014 Z-35.1 I5.70735 K-3.29514
+G01 X12.0 Z-36.1
+Z-38.1
+G00 X15.0
+Z10.0
+
+M428 (milling)
+g55
+T10 m6 G43
+g21 g17 g64 g90
+s3400 m3
+
+g0 z10
+g0 x5 y0
+g2 x-5 y0 i-5 j0 z-1 f500
+g2 x5 y0 i5 j0 z-2
+g2 x-5 y0 i-5 j0 z-3
+g2 x5 y0 i5 j0 z-4
+g2 x-5 y0 i-5 j0 z-4
+
+g0 z10
+g0 a90
+g0 x5 y0
+g2 x-5 y0 i-5 j0 z-1
+g2 x5 y0 i5 j0 z-2
+g2 x-5 y0 i-5 j0 z-3
+g2 x5 y0 i5 j0 z-4
+g2 x-5 y0 i-5 j0 z-4
+
+
+g0 z10
+g0 a180
+g0 x5 y0
+g2 x-5 y0 i-5 j0 z-1
+g2 x5 y0 i5 j0 z-2
+g2 x-5 y0 i-5 j0 z-3
+g2 x5 y0 i5 j0 z-4
+g2 x-5 y0 i-5 j0 z-4
+
+g0 z10
+g0 a270
+g0 x5 y0
+g2 x-5 y0 i-5 j0 z-1
+g2 x5 y0 i5 j0 z-2
+g2 x-5 y0 i-5 j0 z-3
+g2 x5 y0 i5 j0 z-4
+g2 x-5 y0 i-5 j0 z-4
+
+g0 z10
+g0 a360
+
+M428 (milling)
+G54
+G0 X0 Z100 A0
+
+M2
+%
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/millturn/millturn.ini b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/millturn/millturn.ini
new file mode 100644
index 0000000..57776ee
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/millturn/millturn.ini
@@ -0,0 +1,145 @@
+[APPLICATIONS]
+APP = halshow ./millturn.halshow
+
+[EMC]
+VERSION = 1.1
+MACHINE = millturn (mm)
+DEBUG = 0
+
+[KINS]
+KINEMATICS = millturn
+JOINTS= 4
+
+[HAL]
+HALUI = halui
+HALFILE = LIB:basic_sim.tcl
+HALFILE = millturn.hal
+HALCMD = net :kinstype-select <= motion.analog-out-03 => motion.switchkins-type
+POSTGUI_HALFILE = millturn-postgui.hal
+
+[RS274NGC]
+    USER_M_PATH = ./mcodes
+PARAMETER_FILE  = millturn.var
+SUBROUTINE_PATH = ./remap_subs
+   HAL_PIN_VARS = 1
+          REMAP = M428  modalgroup=10  ngc=428remap
+          REMAP = M429  modalgroup=10  ngc=429remap
+# Set startup offsets
+RS274NGC_STARTUP_CODE =    G10 L2 P7 X-290 Y0 Z-160 A0 G59.1
+
+
+[HALUI]
+# MDI-COMMANDS 00, 01 (remapped) for switching kinematics and limits:
+# M428: mill (kinstype==0 startupDEFAULT)
+# M429: turn (kinstype==1)
+MDI_COMMAND = M428
+MDI_COMMAND = M429
+# MDI-COMMANDS 02, 03 are for altering limits when switching
+# Note that M129 and M129 are not meant to be called directly.
+MDI_COMMAND = M128
+MDI_COMMAND = M129
+
+[DISPLAY]
+DISPLAY = axis
+GEOMETRY = XYZA
+CYCLE_TIME = 0.200
+POSITION_OFFSET = RELATIVE
+POSITION_FEEDBACK = ACTUAL
+DEFAULT_LINEAR_VELOCITY = 60.0
+DEFAULT_ANGULAR_VELOCITY = 40.0
+MAX_FEED_OVERRIDE = 2.0
+PROGRAM_PREFIX = ./
+INTRO_GRAPHIC = linuxcnc.gif
+INTRO_TIME = 5
+PYVCP = millturn.xml
+EDITOR = geany
+OPEN_FILE = example.ngc
+
+[TASK]
+TASK = milltask
+CYCLE_TIME = 0.010
+
+[EMCMOT]
+EMCMOT = motmod
+COMM_TIMEOUT = 1.0
+SERVO_PERIOD = 1000000
+
+[TRAJ]
+COORDINATES = X Y Z A
+LINEAR_UNITS = mm
+ANGULAR_UNITS = deg
+DEFAULT_LINEAR_VELOCITY = 60.0
+DEFAULT_ANGULAR_VELOCITY = 60.0
+MAX_LINEAR_VELOCITY = 200.0
+MAX_ANGULAR_VELOCITY = 100.0
+DEFAULT_LINEAR_ACCELERATION = 200.0
+MAX_LINEAR_ACCELERATION = 400.0
+
+[EMCIO]
+TOOL_TABLE = millturn.tbl
+
+[JOINT_0]
+TYPE = LINEAR
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
+MIN_LIMIT = -300
+MAX_LIMIT =  300
+HOME_SEQUENCE = 0
+HOME_OFFSET = 0
+HOME = 0
+[JOINT_1]
+TYPE = LINEAR
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
+MIN_LIMIT = -100
+MAX_LIMIT = 100
+HOME_OFFSET = 0.0
+HOME_SEQUENCE = 0
+HOME = 0
+[JOINT_2]
+TYPE = LINEAR
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
+MIN_LIMIT = -240
+MAX_LIMIT = 0
+HOME_OFFSET = 0.0
+HOME_SEQUENCE = 0
+HOME = 0
+[JOINT_3]
+TYPE = ANGULAR
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
+HOME_OFFSET = 0.0
+HOME_SEQUENCE = 0
+HOME = 0.001
+
+[AXIS_X]
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
+# define softlimits for default kinematic (mill)
+MIN_LIMIT = -300
+MAX_LIMIT = 300
+# define softlimits for alternate kinematic (turn)
+MIN_LIMIT_TURN = -240
+MAX_LIMIT_TURN = 0
+[AXIS_Y]
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
+# define softlimits for default kinematic (mill)
+MIN_LIMIT = -100
+MAX_LIMIT = 100
+# define softlimits for alternate kinematic (turn)
+MIN_LIMIT_TURN = -100
+MAX_LIMIT_TURN = 100
+[AXIS_Z]
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
+# define softlimits for default kinematic (mill)
+MIN_LIMIT = -240
+MAX_LIMIT = 0
+# define softlimits for alternate kinematic (turn)
+MIN_LIMIT_TURN = -300
+MAX_LIMIT_TURN = 300
+[AXIS_A]
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 400.0
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/millturn/millturn.tbl b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/millturn/millturn.tbl
new file mode 100644
index 0000000..aef0baf
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/millturn/millturn.tbl
@@ -0,0 +1,11 @@
+T1 P1 X30 Z30 D0.1 I95.000000 J155.000000 Q1
+T2 P2 X40 Z40 D0.1 I85.000000 J25.000000 Q2
+T3 P3 X50 Z50 D0.1 I275.000000 J335.000000 Q3
+T4 P4 X30 Z30 D0.1 I265.000000 J205.000000 Q4
+T5 P5 X40 Z40 D0.1 I210.000000 J150.000000 Q5
+T6 P6 X50 Z50 D0.1 I120.000000 J60.000000 Q6
+T7 P7 X30 Z30 D0.1 I-30.000000 J30.000000 Q7
+T8 P8 X40 Z40 D0.1 I240.000000 J300.000000 Q8
+T9 P9 X50 Z50 D0.1 Q9
+T10 P10 Z50 D5 ;5 mm end mill
+T11 P11 Z80 D10
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/millturn/remap_subs/428remap.ngc b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/millturn/remap_subs/428remap.ngc
new file mode 100644
index 0000000..ca6225f
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/millturn/remap_subs/428remap.ngc
@@ -0,0 +1,29 @@
+;M428 by remap: select mill kins
+o<428remap>sub
+  #<SWITCHKINS_PIN> = 3  ; set N as required: motion.analog-out-0N
+  #<kinstype> = 0        ; mill
+
+o1 if [exists [#<_hal[motion.switchkins-type]>]]
+o1 else
+     (debug,M428:Missing)
+     (debug,STOP)
+     M2
+o1 endif
+
+   M66  E0 L0                           ; force synch
+   M68  E#<SWITCHKINS_PIN> Q#<kinstype> ; set kinstype value
+   M128                                 ; switch limits
+   G10 L2 P7 X-290 Y0 Z-160 A0          ; reset home offset
+   G59.1                                ; activate home offset
+   M66  E0 L0                           ; force synch
+   ;(debug, M428: mill)
+
+o2 if [[#<_task> EQ 1] AND [#<_hal[motion.switchkins-type]> NE 0]]
+     (debug,M428: Wrong motion.switchkins-type)
+     (debug,or missing hal net to analog-out-0x)
+     (debug,STOP)
+     M2
+o2 else
+o2 endif
+
+o<428remap>endsub
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/millturn/remap_subs/429remap.ngc b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/millturn/remap_subs/429remap.ngc
new file mode 100644
index 0000000..2620743
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/millturn/remap_subs/429remap.ngc
@@ -0,0 +1,29 @@
+;M429 by remap: select turn kins
+o<429remap>sub
+  #<SWITCHKINS_PIN> = 3  ; set N as required: motion.analog-out-0N
+  #<kinstype> = 1        ; turn kins
+
+o1 if [exists [#<_hal[motion.switchkins-type]>]]
+o1 else
+     (debug,M429:Missing [RS274NGC]FEATURE==8)
+     (debug,STOP)
+     M2
+o1 endif
+
+   M66  E0 L0                           ; force synch
+   M68  E#<SWITCHKINS_PIN> Q#<kinstype> ; set kinstype value
+   M129                                 ; switch limits
+   G10 L2 P8 X-160 Y0 Z-290 A0          ; reset home offset
+   G59.2                                ; activate home offset
+   M66  E0 L0                           ; force synch
+   ;(debug, M429: turn)
+
+o2 if [[#<_task> EQ 1] AND [#<_hal[motion.switchkins-type]> NE 1]]
+     (debug,M429:Wrong motion.switchkins-type)
+     (debug,or missing hal net to analog-out-0x)
+     (debug,STOP)
+     M2
+o2 else
+o2 endif
+
+o<429remap>endsub
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/puma.ini b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/puma.ini
new file mode 100644
index 0000000..caa7292
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/puma.ini
@@ -0,0 +1,159 @@
+[EMC]
+VERSION = 1.1
+MACHINE = PUMA (pumakins,switchkins)
+DEBUG = 0
+
+[KINS]
+KINEMATICS = pumakins
+JOINTS = 6
+
+[HAL]
+HALUI   = halui
+HALFILE = LIB:basic_sim.tcl
+HALFILE = puma_dh.hal
+HALCMD  = loadusr -W pumagui
+HALCMD  = net :kinstype-select <= motion.analog-out-03 => motion.switchkins-type
+POSTGUI_HALFILE = puma_postgui.hal
+
+[RS274NGC]
+    USER_M_PATH = ./mcodes
+SUBROUTINE_PATH = ./remap_subs
+   HAL_PIN_VARS = 1
+          REMAP = M428  modalgroup=10  ngc=428remap
+          REMAP = M429  modalgroup=10  ngc=429remap
+          REMAP = M430  modalgroup=10  ngc=430remap
+PARAMETER_FILE = puma.var
+# G21 reqd here since this is mm config and default G20
+RS274NGC_STARTUP_CODE = G21 G10L2P0 x450 y100 z-495 a-180 (debug, ini: startup offsets)
+
+[HALUI]
+# MDI-COMMANDS 00,01,02 (remapped) do not alter limits when switching:
+# M428:pumakins      (kinstype==0 startupDEFAULT)
+# M429:identity kins (kinstype==1)
+# M430:userk kins    (kinstype==2)
+MDI_COMMAND = M428
+MDI_COMMAND = M429
+MDI_COMMAND = M430
+# MDI-COMMANDS 03,04,05 ALTER limits when switching
+MDI_COMMAND = M128
+MDI_COMMAND = M129
+MDI_COMMAND = M130
+
+[DISPLAY]
+DISPLAY = axis
+CYCLE_TIME = 0.200
+POSITION_OFFSET = RELATIVE
+POSITION_FEEDBACK = ACTUAL
+DEFAULT_LINEAR_VELOCITY = 30.0
+DEFAULT_ANGULAR_VELOCITY = 20.0
+MAX_FEED_OVERRIDE = 2.0
+PROGRAM_PREFIX = ../../nc_files/
+INTRO_GRAPHIC = linuxcnc.gif
+INTRO_TIME = 5
+PYVCP = puma.xml
+EDITOR = geany
+
+[EMCMOT]
+EMCMOT = motmod
+COMM_TIMEOUT = 1.0
+SERVO_PERIOD = 1000000
+
+[TASK]
+TASK = milltask
+CYCLE_TIME = 0.010
+
+[TRAJ]
+COORDINATES = X Y Z A B C
+LINEAR_UNITS = mm
+ANGULAR_UNITS = deg
+DEFAULT_LINEAR_VELOCITY = 30.0
+DEFAULT_ANGULAR_VELOCITY = 30.0
+MAX_LINEAR_VELOCITY = 100.0
+MAX_ANGULAR_VELOCITY = 50.0
+DEFAULT_LINEAR_ACCELERATION = 100.0
+MAX_LINEAR_ACCELERATION = 200.0
+
+[EMCIO]
+TOOL_TABLE = puma.tbl
+
+[JOINT_0]
+TYPE = ANGULAR
+MAX_VELOCITY = 30.0
+MAX_ACCELERATION = 200.0
+MIN_LIMIT = -170.0
+MAX_LIMIT =  170.0
+HOME_SEQUENCE = 0
+HOME_OFFSET = 0
+HOME = 0
+[JOINT_1]
+TYPE = ANGULAR
+MAX_VELOCITY = 30.0
+MAX_ACCELERATION = 200.0
+MIN_LIMIT = -85
+MAX_LIMIT =  50
+HOME_OFFSET = 0
+HOME = 0
+HOME_SEQUENCE = 0
+[JOINT_2]
+TYPE = ANGULAR
+MAX_VELOCITY = 30.0
+MAX_ACCELERATION = 200.0
+MIN_LIMIT = -70
+MAX_LIMIT =  75
+HOME_OFFSET = 0
+HOME = 0
+HOME_SEQUENCE = 0
+[JOINT_3]
+TYPE = ANGULAR
+MAX_VELOCITY = 30.0
+MAX_ACCELERATION = 200.0
+MIN_LIMIT = -250
+MAX_LIMIT =  250
+HOME_SEQUENCE = 0
+HOME = 0.000
+[JOINT_4]
+TYPE = ANGULAR
+MAX_VELOCITY = 30.0
+MAX_ACCELERATION = 200.0
+MIN_LIMIT = -120
+MAX_LIMIT =  120
+HOME = 0.000
+HOME_SEQUENCE = 0
+[JOINT_5]
+TYPE = ANGULAR
+MAX_VELOCITY = 30.0
+MAX_ACCELERATION = 200.0
+MIN_LIMIT = -250
+HOME = 0.000
+HOME_SEQUENCE = 0
+
+[AXIS_X]
+MIN_LIMIT =   0
+MAX_LIMIT = 650
+MAX_VELOCITY = 30.0
+MAX_ACCELERATION = 200.0
+[AXIS_Y]
+MIN_LIMIT = -400
+MAX_LIMIT =  400
+MAX_VELOCITY = 30.0
+MAX_ACCELERATION = 200.0
+[AXIS_Z]
+MIN_LIMIT = -600
+MAX_LIMIT =  400
+MAX_VELOCITY = 30.0
+MAX_ACCELERATION = 200.0
+[AXIS_A]
+MIN_LIMIT = -250.0
+MAX_LIMIT =  250.0
+MAX_VELOCITY = 30.0
+MAX_ACCELERATION = 200.0
+[AXIS_B]
+MIN_LIMIT = -135.0
+MAX_LIMIT =  135.0
+MAX_VELOCITY = 30.0
+MAX_ACCELERATION = 200.0
+[AXIS_C]
+MIN_LIMIT = -250.0
+MAX_LIMIT =  250.0
+MAX_VELOCITY = 30.0
+MAX_ACCELERATION = 200.0
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/puma.tbl b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/puma.tbl
new file mode 100644
index 0000000..c0b72de
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/puma.tbl
@@ -0,0 +1,4 @@
+T1 P1 D0.125000 Z+0.511000 ;1/8 end mill
+T2 P2 D0.062500 Z+0.100000 ;1/16 end mill
+T3 P3 D0.201000 Z+1.273000 ;#7 tap drill
+T99999 P99999 Z+0.100000 ;big tool number
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/puma_cube.ini b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/puma_cube.ini
new file mode 100644
index 0000000..9c2d4a1
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/puma_cube.ini
@@ -0,0 +1,138 @@
+# NOTES:
+#  1) [JOINT_4]HOME is a small value to avoid a singularity detected by pumakins
+#  2) No [JOINT_N] or [AXIS_L] MIN_LIMIT,MAX_LIMIT items are used so that
+#     big system defaults apply and allow operation for many conditions that
+#     may not be representative of real hardware
+#  3) ini vel/accel settings are for convenience and not realistic
+#  4) To offset the initial homed position (0,0,0,0,0,0) for the coordinate
+#     coordinate system (p0), use coordinate setting commands:
+#     g10l2p0 x   450
+#     g10l2p0 y   100
+#     g10l2p0 z  -495
+#     g10l2p0 a   180
+#     g10l2p0 b     0
+#     g10l2p0 c     0
+
+[JOINT_0]
+TYPE = ANGULAR
+MAX_VELOCITY = 300.0
+MAX_ACCELERATION = 2000.0
+HOME_SEQUENCE = 0
+[JOINT_1]
+TYPE = ANGULAR
+MAX_VELOCITY = 300.0
+MAX_ACCELERATION = 2000.0
+HOME_SEQUENCE = 0
+[JOINT_2]
+TYPE = ANGULAR
+MAX_VELOCITY = 300.0
+MAX_ACCELERATION = 2000.0
+HOME_SEQUENCE = 0
+[JOINT_3]
+TYPE= ANGULAR
+MAX_VELOCITY = 300.0
+MAX_ACCELERATION = 2000.0
+HOME_SEQUENCE = 0
+[JOINT_4]
+TYPE = ANGULAR
+MAX_VELOCITY = 300.0
+MAX_ACCELERATION = 2000.0
+HOME_SEQUENCE = 0
+[JOINT_5]
+TYPE = ANGULAR
+MAX_VELOCITY = 300.0
+MAX_ACCELERATION = 2000.0
+HOME_SEQUENCE = 0
+
+[AXIS_X]
+MAX_VELOCITY = 30.0
+MAX_ACCELERATION = 200.0
+[AXIS_Y]
+MAX_VELOCITY = 30.0
+MAX_ACCELERATION = 200.0
+[AXIS_Z]
+MAX_VELOCITY = 30.0
+MAX_ACCELERATION = 200.0
+[AXIS_A]
+MAX_VELOCITY = 30.0
+MAX_ACCELERATION = 200.0
+[AXIS_B]
+MAX_VELOCITY = 30.0
+MAX_ACCELERATION = 200.0
+[AXIS_C]
+MAX_VELOCITY = 30.0
+MAX_ACCELERATION = 200.0
+
+[DISPLAY]
+OPEN_FILE = ./puma_cube.ngc
+#alternate: OPEN_FILE = ./puma_seam_weld.ngc
+DISPLAY = axis
+CYCLE_TIME = 0.200
+POSITION_OFFSET = RELATIVE
+POSITION_FEEDBACK = ACTUAL
+MAX_FEED_OVERRIDE = 2.0
+PROGRAM_PREFIX = ../../nc_files
+INTRO_GRAPHIC = linuxcnc.gif
+INTRO_TIME = 1
+PYVCP = puma.xml
+
+[EMC]
+VERSION = 1.1
+MACHINE = puma_cube.ini (pumakins)
+
+[RS274NGC]
+    USER_M_PATH = ./mcodes
+SUBROUTINE_PATH = ./remap_subs
+   HAL_PIN_VARS = 1
+          REMAP = M428  modalgroup=10  ngc=428remap
+          REMAP = M429  modalgroup=10  ngc=429remap
+          REMAP = M430  modalgroup=10  ngc=430remap
+PARAMETER_FILE = puma.var
+
+[EMCMOT]
+EMCMOT = motmod
+COMM_TIMEOUT = 1.0
+SERVO_PERIOD = 1000000
+
+[TASK]
+TASK = milltask
+CYCLE_TIME = 0.010
+
+[HAL]
+HALUI   = halui
+HALFILE = LIB:basic_sim.tcl
+HALFILE = puma_dh.hal
+HALCMD  = loadusr -W pumagui
+HALCMD  = net :kinstype-select <= motion.analog-out-03 => motion.switchkins-type
+POSTGUI_HALFILE = puma_postgui.hal
+
+[HALUI]
+# MDI-COMMANDS 00,01,02 (remapped) do not alter limits when switching:
+# M428:pumakins      (kinstype==0 startupDEFAULT)
+# M429:identity kins (kinstype==1)
+# M430:userk kins    (kinstype==2)
+MDI_COMMAND = M428
+MDI_COMMAND = M429
+MDI_COMMAND = M430
+# MDI-COMMANDS 03,04,05 ALTER limits when switching
+MDI_COMMAND = M128
+MDI_COMMAND = M129
+MDI_COMMAND = M130
+
+
+[TRAJ]
+COORDINATES = X Y Z A B C
+LINEAR_UNITS = mm
+ANGULAR_UNITS = deg
+DEFAULT_LINEAR_VELOCITY = 30.0
+MAX_LINEAR_VELOCITY = 1000.0
+MAX_ANGULAR_VELOCITY = 10
+DEFAULT_LINEAR_ACCELERATION = 100.0
+MAX_LINEAR_ACCELERATION = 2000.0
+
+[EMCIO]
+TOOL_TABLE = puma.tbl
+
+[KINS]
+KINEMATICS = pumakins
+JOINTS = 6
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/puma_cube.ngc b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/puma_cube.ngc
new file mode 100644
index 0000000..269f808
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/puma_cube.ngc
@@ -0,0 +1,57 @@
+; set offsets for current coordinate system (p0)
+; pumakins JOINT HOME positions:
+;          [JOINT_0]HOME=0
+;          [JOINT_1]HOME=0
+;          [JOINT_2]HOME=0
+;          [JOINT_3]HOME=0
+;          [JOINT_4]HOME=0
+;          [JOINT_5]HOME=0
+; pumakins hal settings:
+;          400  pumakins.A2
+;           50  pumakins.A3
+;          100  pumakins.D3
+;          400  pumakins.D4
+;           95  pumakins.D6
+;
+; The following g10l2 commands set offsets for the
+; above HOME positions and hal settings to establish
+; (x,y,z,a,b,c)=(0,0,0,0,0,0) for the current system (p0):
+
+g10l2p0 x   450
+g10l2p0 y   100
+g10l2p0 z  -495
+g10l2p0 a   180
+g10l2p0 b     0
+g10l2p0 c     0
+(debug, puma_cube.ngc Set G54 offsets)
+
+    #<xmin> = -100
+    #<xmax> =  100
+    #<ymin> = -100
+    #<ymax> =  100
+    #<zmin> = -100 
+    #<zmax> =  100
+#<feedrate> = 1000
+
+f #<feedrate>
+g0 x#<xmin> y#<ymin> z#<zmin>
+
+g1 x#<xmax> 
+g1          y#<ymax>
+g1 x#<xmin> 
+g1          y#<ymin>
+g1                   z#<zmax>
+g1 x#<xmax> 
+g1          y#<ymax>
+g1 x#<xmin> 
+g1          y#<ymin>
+
+g0 x#<xmax> y#<ymax>
+g1                   z#<zmin>
+g0 x#<xmin>
+g1                   z#<zmax>
+g0 x#<xmax> y#<ymin>
+g1                   z#<zmin>
+g0 x#<xmin> y#<ymin> z#<zmin>
+ 
+m2
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/puma_seam_weld.ngc b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/puma_seam_weld.ngc
new file mode 100644
index 0000000..6ab214b
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/puma_seam_weld.ngc
@@ -0,0 +1,20 @@
+;useable with sim config: puma.ini
+;This is a test plot nc program to be run on backplot
+;Author Rdp 21-Dec-2017
+
+g0 x0 y0 z10
+g0 x50 y50
+a-30 
+g1 z-10 f500
+x-50
+a0 b-30
+y-50
+a30 b0
+x50
+a0 b30
+y50
+a-30 b0
+g0 z30
+x0 y0 a0 b0
+m30
+
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/remap_subs/428remap.ngc b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/remap_subs/428remap.ngc
new file mode 100644
index 0000000..36f8ee3
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/remap_subs/428remap.ngc
@@ -0,0 +1,24 @@
+;M428 by remap: select kinstype=0 (default)
+o<428remap>sub
+  #<kinstype> = 0
+  #<SWITCHKINS_PIN> = 3  ; set N as required: motion.analog-out-0N
+
+o1 if [exists [#<_hal[motion.switchkins-type]>]]
+o1 else
+     (debug,M428:Missing [RS274NGC]HAL_PIN_VARS=1)
+     (debug,STOP)
+     M2
+o1 endif
+
+   M68  E#<SWITCHKINS_PIN> Q#<kinstype> ; set kinstype value
+   M66  E0 L0                           ; force synch
+
+o2 if [[#<_task> EQ 1] AND [#<_hal[motion.switchkins-type]> NE #<kinstype>]]
+     (debug,M428: Wrong motion.switchkins-type)
+     (debug,or missing hal net to analog-out-0x)
+     (debug,STOP)
+     M2
+o2 else
+o2 endif
+
+o<428remap>endsub
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/remap_subs/429remap.ngc b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/remap_subs/429remap.ngc
new file mode 100644
index 0000000..627d547
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/remap_subs/429remap.ngc
@@ -0,0 +1,24 @@
+;M429 by remap: select kinstype==1 (Identity kinematics)
+o<429remap>sub
+  #<kinstype> = 1
+  #<SWITCHKINS_PIN> = 3  ; set N as required: motion.analog-out-0N
+
+o1 if [exists [#<_hal[motion.switchkins-type]>]]
+o1 else
+     (debug,M429:Missing [RS274NGC]HAL_PIN_VARS=1)
+     (debug,STOP)
+     M2
+o1 endif
+
+   M68  E#<SWITCHKINS_PIN> Q#<kinstype> ; set kinstype value
+   M66  E0 L0                           ; force synch
+
+o2 if [[#<_task> EQ 1] AND [#<_hal[motion.switchkins-type]> NE #<kinstype>]]
+     (debug,M429:Wrong motion.switchkins-type)
+     (debug,or missing hal net to analog-out-0x)
+     (debug,STOP)
+     M2
+o2 else
+o2 endif
+
+o<429remap>endsub
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/remap_subs/430remap.ngc b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/remap_subs/430remap.ngc
new file mode 100644
index 0000000..5af12f4
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/axis/vismach/puma/remap_subs/430remap.ngc
@@ -0,0 +1,24 @@
+;M430 by remap: select kinstype==2 (userk kins)
+o<430remap>sub
+  #<kinstype> = 2
+  #<SWITCHKINS_PIN> = 3  ; set N as required: motion.analog-out-0N
+
+o1 if [exists [#<_hal[motion.switchkins-type]>]]
+o1 else
+     (debug,M30:Missing [RS274NGC]HAL_PIN_VARS=1)
+     (debug,STOP)
+     M2
+o1 endif
+
+   M68  E#<SWITCHKINS_PIN> Q#<kinstype> ; set kinstype value
+   M66  E0 L0                           ; force synch
+
+o2 if [[#<_task> EQ 1] AND [#<_hal[motion.switchkins-type]> NE #<kinstype>]]
+     (debug,M430:Wrong motion.switchkins-type)
+     (debug,or missing hal net to analog-out-0x)
+     (debug,STOP)
+     M2
+o2 else
+o2 endif
+
+o<430remap>endsub
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_multi_joint/on_abort.ngc b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_multi_joint/on_abort.ngc
new file mode 100644
index 0000000..c2e6b36
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_multi_joint/on_abort.ngc
@@ -0,0 +1,31 @@
+o<on_abort> sub
+
+
+o100 if [#1 eq 5]
+    (machine on)
+o100 elseif [#1 eq 6]
+    (machine off)
+o100 elseif [#1 eq 7]
+    (estopped)
+o100 elseif [#1 eq 8]
+    (msg,Process Aborted)
+o100 else
+    (DEBUG,Abort Parameter is %d[#1])
+o100 endif
+
+o<on_abort> endsub
+m2
+
+These are potential abort number:
+
+        EMC_ABORT_TASK_EXEC_ERROR = 1,
+        EMC_ABORT_AUX_ESTOP = 2,
+        EMC_ABORT_MOTION_OR_IO_RCS_ERROR = 3,
+        EMC_ABORT_TASK_STATE_OFF = 4,
+        EMC_ABORT_TASK_STATE_ESTOP_RESET = 5,
+        EMC_ABORT_TASK_STATE_ESTOP = 6,
+        EMC_ABORT_TASK_STATE_NOT_ON = 7,
+        EMC_ABORT_TASK_ABORT = 8,
+        EMC_ABORT_INTERPRETER_ERROR = 9,        // interpreter failed during readahead
+        EMC_ABORT_INTERPRETER_ERROR_MDI = 10,   // interpreter failed during MDI execution
+        EMC_ABORT_USER = 100  // user-defined abort codes start here
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_multi_joint/qtdragon_xyyz.ini b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_multi_joint/qtdragon_xyyz.ini
new file mode 100644
index 0000000..8c16d5e
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_multi_joint/qtdragon_xyyz.ini
@@ -0,0 +1,255 @@
+# This file was created with the 7i96 Wizard on Jun 10 2019 11:12:47
+# Changes to most things are ok and will be read by the wizard
+
+[EMC]
+VERSION = 1.1
+MACHINE = qtdragon
+DEBUG = 0x00000000
+
+[DISPLAY]
+# sets qtdragon as screen. for debug output to terminal add -d or -v
+# sets window title
+# sets icon in task manager
+DISPLAY = qtvcp qtdragon
+TITLE = QtDragon XYYZ
+ICON = silver_dragon.png
+
+# qtdragon saves most preference to this file
+PREFERENCE_FILE_PATH = WORKINGFOLDER/qtdragon.pref
+
+# min/max percentage overrides allowed in qtdragon 1 = 100%
+MAX_FEED_OVERRIDE       = 1.2
+MIN_SPINDLE_0_OVERRIDE    = 0.5
+MAX_SPINDLE_0_OVERRIDE    = 1.2
+
+# manual spindle speed will start at this RPM
+DEFAULT_SPINDLE_0_SPEED   = 12000
+
+# spindle up/down increment in RPM
+SPINDLE_INCREMENT = 200
+
+# min max apindle speed manually allowed 
+MIN_SPINDLE_0_SPEED = 1000
+MAX_SPINDLE_0_SPEED = 20000
+
+# max spindle power in Watts
+MAX_SPINDLE_POWER = 2000
+
+# min/max/default jog velocities in qtdragon in units/sec
+MIN_LINEAR_VELOCITY     = 0
+MAX_LINEAR_VELOCITY     = 60.00
+DEFAULT_LINEAR_VELOCITY = 50.0
+
+# incremental jog step length options
+INCREMENTS = 10 mm, 1.0 mm, 0.10 mm, 0.01 mm, 1.0 inch, 0.1 inch, 0.01 inch
+
+CYCLE_TIME = 100
+INTRO_GRAPHIC = silver_dragon.png
+INTRO_TIME = 2
+
+# default program search path
+PROGRAM_PREFIX = ~/linuxcnc/nc_files
+
+# NGCGUI subroutine path.
+# Thr path must also  be in [RS274NGC] SUBROUTINE_PATH
+NGCGUI_SUBFILE_PATH = ../../../nc_files/ngcgui_lib/
+# pre selected programs tabs
+# specify filenames only, files must be in the NGCGUI_SUBFILE_PATH
+NGCGUI_SUBFILE = slot.ngc
+NGCGUI_SUBFILE = qpocket.ngc
+
+# qtdragon saves MDI cxommands to this file
+MDI_HISTORY_FILE = mdi_history.dat
+# qtdragon saves rnning logs to this file
+LOG_FILE = qtdragon.log
+
+[MDI_COMMAND_LIST]
+# for macro buttons on main oage up to 10 possible
+MDI_COMMAND_MACRO0 = G0 Z25;X0 Y0;Z0, Goto\nUser\nZero
+MDI_COMMAND_MACRO1 = G53 G0 Z0;G53 G0 X0 Y0,Goto\nMachn\nZero
+
+[FILTER]
+# Controls what programs are shown inqtdragon file manager
+PROGRAM_EXTENSION = .ngc,.nc,.tap G-Code File (*.ngc,*.nc,*.tap)
+PROGRAM_EXTENSION = .png,.gif,.jpg Greyscale Depth Image
+PROGRAM_EXTENSION = .py Python Script
+
+# specifies what special 'filter' programs runs based on program ending
+png = image-to-gcode
+gif = image-to-gcode
+jpg = image-to-gcode
+py = python3
+
+[KINS]
+KINEMATICS = trivkins coordinates=XYYZ kinstype=BOTH
+JOINTS = 4
+
+[EMCIO]
+TOOL_TABLE = tool.tbl
+
+[RS274NGC]
+# motion controller saves parameters to this file
+PARAMETER_FILE = qtdragon.var
+
+# start up G/M codes when first loaded
+RS274NGC_STARTUP_CODE = G17 G21 G40 G43H0 G54 G64P0.0127 G80 G90 G94 G97 M5 M9
+
+# subroutine/remap path list
+SUBROUTINE_PATH = ../../../../nc_files/probe/basic_probe/macros:~/linuxcnc/nc_files/examples/ngcgui_lib:~/linuxcnc/nc_files/examples/ngcgui_lib/utilitysubs
+
+# on abort, this ngc file is called. required for basic/versa probe
+ON_ABORT_COMMAND=O <on_abort> call
+
+[EMCMOT]
+EMCMOT = motmod
+SERVO_PERIOD = 1000000
+COMM_TIMEOUT = 1.0
+COMM_WAIT = 0.010
+BASE_PERIOD = 100000
+
+[TASK]
+TASK = milltask
+CYCLE_TIME = 0.010
+
+[TRAJ]
+COORDINATES = XYYZ
+LINEAR_UNITS = metric
+ANGULAR_UNITS = degree
+MAX_LINEAR_VELOCITY = 60.00
+DEFAULT_LINEAR_VELOCITY = 50.00
+SPINDLES = 1
+
+[HAL]
+HALUI = halui
+HALBRIDGE = hal_bridge
+
+# loads the HAL machine simulation
+HALFILE = gantrysim.hal
+HALFILE = simulated-xyyz-home.hal
+
+# this file is loaded after qtdragon has made it's HAl pins
+# you can add multiple entries
+POSTGUI_HALFILE = qtdragon_postgui.hal
+
+# this command is run after qtdragon has made it's HAl pins
+# any HAL conmmand can be used
+# you can add multiple entries
+# uncomment this one to print all HAL pins that start with qt
+#POSTGUI_HALCMD = show pin qt
+
+[HALUI]
+# no content
+
+[PROBE]
+# pick basic probe or versa probe or remove for none
+#USE_PROBE = versaprobe
+USE_PROBE = basicprobe
+
+[AXIS_X]
+MIN_LIMIT = -0.001
+MAX_LIMIT = 520.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+
+[AXIS_Y]
+MIN_LIMIT = -0.001
+MAX_LIMIT = 630.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+
+[AXIS_Z]
+# used by external offsets for auto spindle lift
+OFFSET_AV_RATIO  = 0.2
+MIN_LIMIT = -115.0
+MAX_LIMIT = 10.0
+MAX_VELOCITY = 40.0
+MAX_ACCELERATION = 500.0
+
+[JOINT_0]
+AXIS = X
+MIN_LIMIT = -0.001
+MAX_LIMIT = 520.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 72.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = 20.0
+HOME_OFFSET = -0.1
+HOME_SEARCH_VEL = -20.000000
+HOME_LATCH_VEL = 10.000
+HOME_SEQUENCE = 2
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
+[JOINT_1]
+AXIS = Y
+MIN_LIMIT = -0.001
+MAX_LIMIT = 630.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 72.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = 20.0
+HOME_OFFSET = -0.1
+HOME_SEARCH_VEL = -20.00
+HOME_LATCH_VEL = 10.00
+HOME_SEQUENCE = -1
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
+[JOINT_2]
+AXIS = Y
+MIN_LIMIT = -0.001
+MAX_LIMIT = 630.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 72.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = 20.0
+HOME_OFFSET = -0.1
+HOME_SEARCH_VEL = -20.00
+HOME_LATCH_VEL = 10.00
+HOME_SEQUENCE = -1
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
+[JOINT_3]
+AXIS = Z
+MIN_LIMIT = -115.0
+MAX_LIMIT = 10.0
+MAX_VELOCITY = 40.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 48.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = -10.0
+HOME_OFFSET = 0.1
+HOME_SEARCH_VEL = 20.000000
+HOME_LATCH_VEL = 10.00
+HOME_SEQUENCE = 0
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_multi_joint/tool.tbl b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_multi_joint/tool.tbl
new file mode 100644
index 0000000..801fbcb
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_multi_joint/tool.tbl
@@ -0,0 +1,4 @@
+T1 P1 X0 Y0 Z0.51100 A0 B0 C0 U0 V0 W0 D10.00000 I0 J0 Q0 ;1/8 end mill 
+T2 P2 X0 Y0 Z0.10000 A0 B0 C0 U0 V0 W0 D0.06250 I0 J0 Q0 ;1/16 end mill 
+T3 P3 X0 Y0 Z1.27300 A0 B0 C0 U0 V0 W0 D0.20100 I0 J0 Q0 ;#7 tap drill 
+T4 P4 X0 Y0 Z3.00000 A0 B0 C0 U0 V0 W0 D4.00000 I0 J0 Q0 ;4" Face Mill 
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_xyz/on_abort.ngc b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_xyz/on_abort.ngc
new file mode 100644
index 0000000..c2e6b36
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_xyz/on_abort.ngc
@@ -0,0 +1,31 @@
+o<on_abort> sub
+
+
+o100 if [#1 eq 5]
+    (machine on)
+o100 elseif [#1 eq 6]
+    (machine off)
+o100 elseif [#1 eq 7]
+    (estopped)
+o100 elseif [#1 eq 8]
+    (msg,Process Aborted)
+o100 else
+    (DEBUG,Abort Parameter is %d[#1])
+o100 endif
+
+o<on_abort> endsub
+m2
+
+These are potential abort number:
+
+        EMC_ABORT_TASK_EXEC_ERROR = 1,
+        EMC_ABORT_AUX_ESTOP = 2,
+        EMC_ABORT_MOTION_OR_IO_RCS_ERROR = 3,
+        EMC_ABORT_TASK_STATE_OFF = 4,
+        EMC_ABORT_TASK_STATE_ESTOP_RESET = 5,
+        EMC_ABORT_TASK_STATE_ESTOP = 6,
+        EMC_ABORT_TASK_STATE_NOT_ON = 7,
+        EMC_ABORT_TASK_ABORT = 8,
+        EMC_ABORT_INTERPRETER_ERROR = 9,        // interpreter failed during readahead
+        EMC_ABORT_INTERPRETER_ERROR_MDI = 10,   // interpreter failed during MDI execution
+        EMC_ABORT_USER = 100  // user-defined abort codes start here
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_xyz/qtdragon_inch.ini b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_xyz/qtdragon_inch.ini
new file mode 100644
index 0000000..4be20c9
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_xyz/qtdragon_inch.ini
@@ -0,0 +1,266 @@
+# This file was created with the 7i96 Wizard on Jun 10 2019 11:12:47
+# Changes to most things are ok and will be read by the wizard
+
+[EMC]
+VERSION = 1.1
+MACHINE = qtdragon_inch
+DEBUG = 0x00000000
+
+[DISPLAY]
+# sets qtdragon as screen. for debug output to terminal add -d or -v
+# sets window title
+# sets icon in task manager
+DISPLAY = qtvcp qtdragon
+TITLE = QtDragon XYZ Inch
+ICON = silver_dragon.png
+
+# qtdragon saves most preference to this file
+PREFERENCE_FILE_PATH = WORKINGFOLDER/qtdragon.pref
+
+# min/max percentage overrides allowed in qtdragon 1 = 100%
+MAX_FEED_OVERRIDE       = 1.2
+MIN_SPINDLE_0_OVERRIDE    = 0.5
+MAX_SPINDLE_0_OVERRIDE    = 1.2
+
+# manual spindle speed will start at this RPM
+DEFAULT_SPINDLE_0_SPEED   = 12000
+
+# spindle up/down increment in RPM
+SPINDLE_INCREMENT = 200
+
+# min max apindle speed manually allowed 
+MIN_SPINDLE_0_SPEED = 1000
+MAX_SPINDLE_0_SPEED = 20000
+
+# max spindle power in Watts
+MAX_SPINDLE_POWER = 2000
+
+# min/max/default jog velocities in qtdragon in units/second
+MIN_LINEAR_VELOCITY     = 0
+MAX_LINEAR_VELOCITY     = 1.00
+DEFAULT_LINEAR_VELOCITY = 0.25
+
+# incremental jog step length options
+INCREMENTS = 10 mm, 1.0 mm, 0.10 mm, 0.01 mm, 1.0 inch, 0.1 inch, 0.01 inch
+
+# Display grid increments
+GRIDS = 0, .1 mm, 1 mm, 2 mm, 5 mm, 10 mm, .25 in, .5 in
+
+CYCLE_TIME = 100
+INTRO_GRAPHIC = silver_dragon.png
+INTRO_TIME = 2
+
+# default program search path
+PROGRAM_PREFIX = ~/linuxcnc/nc_files
+
+# NGCGUI subroutine path.
+# Thr path must also  be in [RS274NGC] SUBROUTINE_PATH
+NGCGUI_SUBFILE_PATH = ../../../nc_files/ngcgui_lib/
+# pre selected programs tabs
+# specify filenames only, files must be in the NGCGUI_SUBFILE_PATH
+NGCGUI_SUBFILE = slot.ngc
+NGCGUI_SUBFILE = qpocket.ngc
+
+# qtdragon saves MDI cxommands to this file
+MDI_HISTORY_FILE = mdi_history.dat
+# qtdragon saves rnning logs to this file
+LOG_FILE = qtdragon.log
+
+# optional user dialogs (3), controlled by HAL pins
+# persistent
+MESSAGE_BOLDTEXT = Critical and Persistent
+MESSAGE_TEXT = This is a persistent dialog test
+MESSAGE_DETAILS = There seems to be something wrong\n You must fix it to clear message
+MESSAGE_TYPE = nonedialog
+MESSAGE_PINNAME = nonedialogtest
+MESSAGE_ICON = CRITICAL
+
+# yes no choice
+MESSAGE_BOLDTEXT = Do You Want To Make A Choice?
+MESSAGE_TEXT = This is a yes no dialog test
+MESSAGE_DETAILS = Y/N DETAILS
+MESSAGE_TYPE = yesnodialog
+MESSAGE_PINNAME = yndialogtest
+MESSAGE_ICON = QUESTION
+
+# acknowledge
+MESSAGE_BOLDTEXT = This is an information message
+MESSAGE_TEXT = This is low priority
+MESSAGE_DETAILS = press ok to clear
+MESSAGE_TYPE = okdialog status
+MESSAGE_PINNAME = bothtest
+MESSAGE_ICON = INFO
+
+# optional tab showing an external qtvcp panel
+EMBED_TAB_NAME=Vismach demo
+EMBED_TAB_COMMAND=qtvcp vismach_mill_xyz
+EMBED_TAB_LOCATION=tabWidget_utilities
+
+[MDI_COMMAND_LIST]
+# for macro buttons on main oage up to 10 possible
+MDI_COMMAND_MACRO0 = G0 Z2;X0 Y0;Z0, Goto\nUser\nZero
+MDI_COMMAND_MACRO1 = G53 G0 Z0;G53 G0 X0 Y0,Goto\nMachn\nZero
+
+[FILTER]
+# Controls what programs are shown inqtdragon file manager
+PROGRAM_EXTENSION = .ngc,.nc,.tap G-Code File (*.ngc,*.nc,*.tap)
+PROGRAM_EXTENSION = .png,.gif,.jpg Greyscale Depth Image
+PROGRAM_EXTENSION = .py Python Script
+
+# specifies what special 'filter' programs runs based on program ending
+png = image-to-gcode
+gif = image-to-gcode
+jpg = image-to-gcode
+py = python3
+
+[KINS]
+KINEMATICS = trivkins coordinates=XYZ
+JOINTS = 3
+
+[EMCIO]
+TOOL_TABLE = tool.tbl
+
+[RS274NGC]
+# motion controller saves parameters to this file
+PARAMETER_FILE = qtdragon.var
+
+# start up G/M codes when first loaded
+RS274NGC_STARTUP_CODE = G17 G20 G40 G43H0 G54 G64P0.0005 G80 G90 G94 G97 M5 M9
+
+# subroutine/remap path list
+SUBROUTINE_PATH = ../../../../nc_files/probe/basic_probe/macros:~/linuxcnc/nc_files/examples/ngcgui_lib:~/linuxcnc/nc_files/examples/ngcgui_lib/utilitysubs
+
+# on abort, this ngc file is called. required for basic/versa probe
+ON_ABORT_COMMAND=O <on_abort> call
+
+[EMCMOT]
+EMCMOT = motmod
+SERVO_PERIOD = 1000000
+COMM_TIMEOUT = 1.0
+COMM_WAIT = 0.010
+BASE_PERIOD = 100000
+
+[TASK]
+TASK = milltask
+CYCLE_TIME = 0.010
+
+[TRAJ]
+COORDINATES = XYZ
+LINEAR_UNITS = inch
+ANGULAR_UNITS = degree
+MAX_LINEAR_VELOCITY = 60.00
+DEFAULT_LINEAR_VELOCITY = 50.00
+SPINDLES = 1
+
+[HAL]
+HALUI = halui
+HALBRIDGE = hal_bridge
+
+# loads the HAL machine simulation
+HALFILE = core_sim.hal
+HALFILE = simulated_home.hal
+
+# this file is loaded after qtdragon has made it's HAl pins
+# you can add multiple entries
+POSTGUI_HALFILE = qtdragon_postgui.hal
+
+# this command is run after qtdragon has made it's HAl pins
+# any HAL conmmand can be used
+# you can add multiple entries
+# uncomment this one to print all HAL pins that start with qt
+#POSTGUI_HALCMD = show pin qt
+
+[HALUI]
+# no content
+
+[PROBE]
+# pick basic probe or versa probe or remove for none
+#USE_PROBE = versaprobe
+USE_PROBE = basicprobe
+
+[AXIS_X]
+MIN_LIMIT = -0.01
+MAX_LIMIT = 20.0
+MAX_VELOCITY = 2.5
+MAX_ACCELERATION = 20
+
+[AXIS_Y]
+MIN_LIMIT = -0.01
+MAX_LIMIT = 25.0
+MAX_VELOCITY = 2.5
+MAX_ACCELERATION = 20.0
+
+[AXIS_Z]
+# used by external offsets for auto spindle lift
+OFFSET_AV_RATIO  = 0.2
+MIN_LIMIT = -4.5
+MAX_LIMIT = 0.5
+MAX_VELOCITY = 1.5
+MAX_ACCELERATION = 20.0
+
+[JOINT_0]
+AXIS = X
+MIN_LIMIT = -0.01
+MAX_LIMIT = 20.0
+MAX_VELOCITY = 2.5
+MAX_ACCELERATION = 20.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 2.75
+STEPGEN_MAX_ACC = 24.0
+FERROR = 0.050
+MIN_FERROR = 0.010
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = 0.75
+HOME_OFFSET = 0.00000
+HOME_SEARCH_VEL = 0.75
+HOME_LATCH_VEL = 0.5
+HOME_SEQUENCE = 1
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
+[JOINT_1]
+AXIS = Y
+MIN_LIMIT = -0.01
+MAX_LIMIT = 25.0
+MAX_VELOCITY = 2.5
+MAX_ACCELERATION = 20.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 2.75
+STEPGEN_MAX_ACC = 24.0
+FERROR = 0.050
+MIN_FERROR = 0.010
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = 0.75
+HOME_OFFSET = 0.000000
+HOME_SEARCH_VEL = 0.75
+HOME_LATCH_VEL = 0.5
+HOME_SEQUENCE = 2
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
+[JOINT_2]
+AXIS = Z
+MIN_LIMIT = -4.5
+MAX_LIMIT = 0.5
+MAX_VELOCITY = 1.5
+MAX_ACCELERATION = 20.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 1.5
+STEPGEN_MAX_ACC = 24.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = -0.5
+HOME_OFFSET = 0.000000
+HOME_SEARCH_VEL = 0.75
+HOME_LATCH_VEL = 0.5
+HOME_SEQUENCE = 0
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_xyz/tool.tbl b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_xyz/tool.tbl
new file mode 100644
index 0000000..801fbcb
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_xyz/tool.tbl
@@ -0,0 +1,4 @@
+T1 P1 X0 Y0 Z0.51100 A0 B0 C0 U0 V0 W0 D10.00000 I0 J0 Q0 ;1/8 end mill 
+T2 P2 X0 Y0 Z0.10000 A0 B0 C0 U0 V0 W0 D0.06250 I0 J0 Q0 ;1/16 end mill 
+T3 P3 X0 Y0 Z1.27300 A0 B0 C0 U0 V0 W0 D0.20100 I0 J0 Q0 ;#7 tap drill 
+T4 P4 X0 Y0 Z3.00000 A0 B0 C0 U0 V0 W0 D4.00000 I0 J0 Q0 ;4" Face Mill 
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_xyz45/on_abort.ngc b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_xyz45/on_abort.ngc
new file mode 100644
index 0000000..c2e6b36
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_xyz45/on_abort.ngc
@@ -0,0 +1,31 @@
+o<on_abort> sub
+
+
+o100 if [#1 eq 5]
+    (machine on)
+o100 elseif [#1 eq 6]
+    (machine off)
+o100 elseif [#1 eq 7]
+    (estopped)
+o100 elseif [#1 eq 8]
+    (msg,Process Aborted)
+o100 else
+    (DEBUG,Abort Parameter is %d[#1])
+o100 endif
+
+o<on_abort> endsub
+m2
+
+These are potential abort number:
+
+        EMC_ABORT_TASK_EXEC_ERROR = 1,
+        EMC_ABORT_AUX_ESTOP = 2,
+        EMC_ABORT_MOTION_OR_IO_RCS_ERROR = 3,
+        EMC_ABORT_TASK_STATE_OFF = 4,
+        EMC_ABORT_TASK_STATE_ESTOP_RESET = 5,
+        EMC_ABORT_TASK_STATE_ESTOP = 6,
+        EMC_ABORT_TASK_STATE_NOT_ON = 7,
+        EMC_ABORT_TASK_ABORT = 8,
+        EMC_ABORT_INTERPRETER_ERROR = 9,        // interpreter failed during readahead
+        EMC_ABORT_INTERPRETER_ERROR_MDI = 10,   // interpreter failed during MDI execution
+        EMC_ABORT_USER = 100  // user-defined abort codes start here
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_xyz45/qtdragon_xyza.ini b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_xyz45/qtdragon_xyza.ini
new file mode 100644
index 0000000..59e43f1
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_xyz45/qtdragon_xyza.ini
@@ -0,0 +1,255 @@
+# This file was created with the 7i96 Wizard on Jun 10 2019 11:12:47
+# Changes to most things are ok and will be read by the wizard
+
+[EMC]
+VERSION = 1.1
+MACHINE = qtdragon
+DEBUG = 0x00000000
+
+[DISPLAY]
+# sets qtdragon as screen. for debug output to terminal add -d or -v
+# sets window title
+# sets icon in task manager
+DISPLAY = qtvcp qtdragon
+TITLE = QtDragon XYZA Rotational Axis
+ICON = silver_dragon.png
+
+# qtdragon saves most preference to this file
+PREFERENCE_FILE_PATH = WORKINGFOLDER/qtdragon.pref
+
+# min/max percentage overrides allowed in qtdragon 1 = 100%
+MAX_FEED_OVERRIDE       = 1.2
+MIN_SPINDLE_0_OVERRIDE    = 0.5
+MAX_SPINDLE_0_OVERRIDE    = 1.2
+
+# manual spindle speed will start at this RPM
+DEFAULT_SPINDLE_0_SPEED   = 12000
+
+# spindle up/down increment in RPM
+SPINDLE_INCREMENT = 200
+
+# min max apindle speed manually allowed 
+MIN_SPINDLE_0_SPEED = 1000
+MAX_SPINDLE_0_SPEED = 20000
+
+# max spindle power in Watts
+MAX_SPINDLE_POWER = 2000
+
+# min/max/default jog velocities in qtdragon in units/sec
+MIN_LINEAR_VELOCITY     = 0
+MAX_LINEAR_VELOCITY     = 60.00
+DEFAULT_LINEAR_VELOCITY = 25.0
+
+DEFAULT_ANGULAR_VELOCITY = 10
+MIN_ANGULAR_VELOCITY = 1
+MAX_ANGULAR_VELOCITY = 360
+
+# incremental jog step length options
+INCREMENTS = 10 mm, 1.0 mm, 0.10 mm, 0.01 mm, 1.0 inch, 0.1 inch, 0.01 inch
+
+CYCLE_TIME = 100
+INTRO_GRAPHIC = silver_dragon.png
+INTRO_TIME = 2
+
+# default program search path
+PROGRAM_PREFIX = ~/linuxcnc/nc_files
+
+# NGCGUI subroutine path.
+# Thr path must also  be in [RS274NGC] SUBROUTINE_PATH
+NGCGUI_SUBFILE_PATH = ../../../nc_files/ngcgui_lib/
+# pre selected programs tabs
+# specify filenames only, files must be in the NGCGUI_SUBFILE_PATH
+NGCGUI_SUBFILE = slot.ngc
+NGCGUI_SUBFILE = qpocket.ngc
+
+# qtdragon saves MDI cxommands to this file
+MDI_HISTORY_FILE = mdi_history.dat
+# qtdragon saves rnning logs to this file
+LOG_FILE = qtdragon.log
+
+[MDI_COMMAND_LIST]
+# for macro buttons on main oage up to 10 possible
+MDI_COMMAND_MACRO0 = G0 Z25;X0 Y0;Z0, Goto\nUser\nZero
+MDI_COMMAND_MACRO1 = G53 G0 Z0;G53 G0 X0 Y0,Goto\nMachn\nZero
+
+[FILTER]
+# Controls what programs are shown inqtdragon file manager
+PROGRAM_EXTENSION = .ngc,.nc,.tap G-Code File (*.ngc,*.nc,*.tap)
+PROGRAM_EXTENSION = .png,.gif,.jpg Greyscale Depth Image
+PROGRAM_EXTENSION = .py Python Script
+
+# specifies what special 'filter' programs runs based on program ending
+png = image-to-gcode
+gif = image-to-gcode
+jpg = image-to-gcode
+py = python3
+
+[KINS]
+KINEMATICS = trivkins coordinates=XYZA
+JOINTS = 4
+
+[EMCIO]
+TOOL_TABLE = tool.tbl
+
+[RS274NGC]
+# motion controller saves parameters to this file
+PARAMETER_FILE = qtdragon.var
+
+# start up G/M codes when first loaded
+RS274NGC_STARTUP_CODE = G17 G21 G40 G43H0 G54 G64P0.0127 G80 G90 G94 G97 M5 M9
+
+# subroutine/remap path list
+SUBROUTINE_PATH = ../../../../nc_files/probe/basic_probe/macros:~/linuxcnc/nc_files/examples/ngcgui_lib:~/linuxcnc/nc_files/examples/ngcgui_lib/utilitysubs
+
+# on abort, this ngc file is called. required for basic/versa probe
+ON_ABORT_COMMAND=O <on_abort> call
+
+[EMCMOT]
+EMCMOT = motmod
+SERVO_PERIOD = 1000000
+COMM_TIMEOUT = 1.0
+COMM_WAIT = 0.010
+BASE_PERIOD = 100000
+#NUM_AIO = 12
+
+[TASK]
+TASK = milltask
+CYCLE_TIME = 0.010
+
+[TRAJ]
+COORDINATES = XYZA
+LINEAR_UNITS = metric
+ANGULAR_UNITS = degree
+MAX_LINEAR_VELOCITY = 60.00
+DEFAULT_LINEAR_VELOCITY = 50.00
+SPINDLES = 1
+
+[HAL]
+HALUI = halui
+HALBRIDGE = hal_bridge
+
+# loads the HAL machine simulation
+HALFILE = gantrysim.hal
+HALFILE = simulated-gantry-home.hal
+
+# this file is loaded after qtdragon has made it's HAl pins
+# you can add multiple entries
+POSTGUI_HALFILE = qtdragon_postgui.hal
+
+# this command is run after qtdragon has made it's HAl pins
+# any HAL conmmand can be used
+# you can add multiple entries
+# uncomment this one to print all HAL pins that start with qt
+#POSTGUI_HALCMD = show pin qt
+
+[HALUI]
+# no content
+
+[PROBE]
+# pick basic probe or versa probe or remove for none
+#USE_PROBE = versaprobe
+USE_PROBE = basicprobe
+
+[AXIS_X]
+MIN_LIMIT = -0.001
+MAX_LIMIT = 520.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+
+[AXIS_Y]
+MIN_LIMIT = -0.001
+MAX_LIMIT = 630.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+
+[AXIS_Z]
+MIN_LIMIT = -115.0
+MAX_LIMIT = 10.0
+MAX_VELOCITY = 40.0
+MAX_ACCELERATION = 500.0
+
+[AXIS_A]
+MAX_VELOCITY = 60
+MAX_ACCELERATION = 500.0
+
+[JOINT_0]
+AXIS = X
+MIN_LIMIT = -0.001
+MAX_LIMIT = 520.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 72.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = 20.0
+HOME_OFFSET = -0.1
+HOME_SEARCH_VEL = -20.000000
+HOME_LATCH_VEL = 10.000
+HOME_SEQUENCE = 2
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
+[JOINT_1]
+AXIS = Y
+MIN_LIMIT = -0.001
+MAX_LIMIT = 630.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 72.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = 20.0
+HOME_OFFSET = -0.1
+HOME_SEARCH_VEL = -20.00
+HOME_LATCH_VEL = 10.00
+HOME_SEQUENCE = -1
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
+[JOINT_2]
+AXIS = Z
+MIN_LIMIT = -115.0
+MAX_LIMIT = 10.0
+MAX_VELOCITY = 40.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 48.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = -10.0
+HOME_OFFSET = 0.1
+HOME_SEARCH_VEL = 20.000000
+HOME_LATCH_VEL = 10.00
+HOME_SEQUENCE = 0
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
+[JOINT_3]
+TYPE = ANGULAR
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+INPUT_SCALE = 40
+OUTPUT_SCALE = 1.0
+FERROR = 5.0
+MIN_FERROR = 1.0
+HOME = 0
+HOME_SEARCH_VEL = 0.0
+HOME_LATCH_VEL = 0.0
+HOME_SEQUENCE = 0
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_xyz45/tool.tbl b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_xyz45/tool.tbl
new file mode 100644
index 0000000..801fbcb
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon/qtdragon_xyz45/tool.tbl
@@ -0,0 +1,4 @@
+T1 P1 X0 Y0 Z0.51100 A0 B0 C0 U0 V0 W0 D10.00000 I0 J0 Q0 ;1/8 end mill 
+T2 P2 X0 Y0 Z0.10000 A0 B0 C0 U0 V0 W0 D0.06250 I0 J0 Q0 ;1/16 end mill 
+T3 P3 X0 Y0 Z1.27300 A0 B0 C0 U0 V0 W0 D0.20100 I0 J0 Q0 ;#7 tap drill 
+T4 P4 X0 Y0 Z3.00000 A0 B0 C0 U0 V0 W0 D4.00000 I0 J0 Q0 ;4" Face Mill 
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/qtdragon_hd/qtdragon_hd_xyz/on_abort.ngc b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon_hd/qtdragon_hd_xyz/on_abort.ngc
new file mode 100644
index 0000000..c2e6b36
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon_hd/qtdragon_hd_xyz/on_abort.ngc
@@ -0,0 +1,31 @@
+o<on_abort> sub
+
+
+o100 if [#1 eq 5]
+    (machine on)
+o100 elseif [#1 eq 6]
+    (machine off)
+o100 elseif [#1 eq 7]
+    (estopped)
+o100 elseif [#1 eq 8]
+    (msg,Process Aborted)
+o100 else
+    (DEBUG,Abort Parameter is %d[#1])
+o100 endif
+
+o<on_abort> endsub
+m2
+
+These are potential abort number:
+
+        EMC_ABORT_TASK_EXEC_ERROR = 1,
+        EMC_ABORT_AUX_ESTOP = 2,
+        EMC_ABORT_MOTION_OR_IO_RCS_ERROR = 3,
+        EMC_ABORT_TASK_STATE_OFF = 4,
+        EMC_ABORT_TASK_STATE_ESTOP_RESET = 5,
+        EMC_ABORT_TASK_STATE_ESTOP = 6,
+        EMC_ABORT_TASK_STATE_NOT_ON = 7,
+        EMC_ABORT_TASK_ABORT = 8,
+        EMC_ABORT_INTERPRETER_ERROR = 9,        // interpreter failed during readahead
+        EMC_ABORT_INTERPRETER_ERROR_MDI = 10,   // interpreter failed during MDI execution
+        EMC_ABORT_USER = 100  // user-defined abort codes start here
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/qtdragon_hd/qtdragon_hd_xyz/qtdragon_hd_vertical.ini b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon_hd/qtdragon_hd_xyz/qtdragon_hd_vertical.ini
new file mode 100644
index 0000000..605f970
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon_hd/qtdragon_hd_xyz/qtdragon_hd_vertical.ini
@@ -0,0 +1,241 @@
+# This file was created with the 7i96 Wizard on Jun 10 2019 11:12:47
+# Changes to most things are ok and will be read by the wizard
+
+[EMC]
+VERSION = 1.1
+MACHINE = qtdragon
+DEBUG = 0x00000000
+
+[DISPLAY]
+# sets qtdragon_hd as screen. for debug output to terminal add -d or -v
+# sets window title
+# sets icon in task manager
+DISPLAY = qtvcp  qtdragon_hd_vert
+TITLE = QtDragon HD Vertical: XYZ
+ICON = silver_dragon.png
+
+# qtdragon saves most preference to this file
+PREFERENCE_FILE_PATH = WORKINGFOLDER/qtdragon_hd_vert.pref
+
+# min/max percentage overrides allowed in qtdragon 1 = 100%
+MAX_FEED_OVERRIDE       = 1.2
+MIN_SPINDLE_0_OVERRIDE    = 0.5
+MAX_SPINDLE_0_OVERRIDE    = 1.2
+
+# manual spindle speed will start at this RPM
+DEFAULT_SPINDLE_0_SPEED   = 12000
+
+# spindle up/down increment in RPM
+SPINDLE_INCREMENT = 200
+
+# min max apindle speed manually allowed 
+MIN_SPINDLE_0_SPEED = 1000
+MAX_SPINDLE_0_SPEED = 20000
+
+# max spindle power in Watts
+MAX_SPINDLE_POWER = 2000
+
+# min/max/default jog velocities in qtdragon in units/sec
+MIN_LINEAR_VELOCITY     = 0
+MAX_LINEAR_VELOCITY     = 60.00
+DEFAULT_LINEAR_VELOCITY = 50.0
+
+#Prevent tool mark disappearing with small tool diameter in g-code preview widget
+GCODE_VIEW_TOOL_MIN_DIA = 2.0
+
+# incremental jog step length options
+INCREMENTS = 10 mm, 1.0 mm, 0.10 mm, 0.01 mm, 1.0 inch, 0.1 inch, 0.01 inch
+
+# Display grid increments
+GRIDS = 0, .1 mm, 1 mm, 2 mm, 5 mm, 10 mm, .25 in, .5 in
+
+CYCLE_TIME = 100
+INTRO_GRAPHIC = silver_dragon.png
+INTRO_TIME = 2
+
+# default program search path
+PROGRAM_PREFIX = ~/linuxcnc/nc_files
+
+# NGCGUI subroutine path.
+# Thr path must also  be in [RS274NGC] SUBROUTINE_PATH
+NGCGUI_SUBFILE_PATH = ../../../nc_files/ngcgui_lib/
+# pre selected programs tabs
+# specify filenames only, files must be in the NGCGUI_SUBFILE_PATH
+NGCGUI_SUBFILE = slot.ngc
+NGCGUI_SUBFILE = qpocket.ngc
+
+# qtdragon saves MDI cxommands to this file
+MDI_HISTORY_FILE = mdi_history.dat
+# qtdragon saves rnning logs to this file
+LOG_FILE = qtdragon_hd.log
+
+[MDI_COMMAND_LIST]
+# for macro buttons
+MDI_COMMAND = G0 Z25 X0 Y0;Z0,Goto\nZero
+MDI_COMMAND = G53 G0 Z0;G53 G0 X0 Y0,Goto\nMach\nZero
+
+[FILTER]
+# Controls what programs are shown inqtdragon file manager
+PROGRAM_EXTENSION = .ngc,.nc,.tap G-Code File (*.ngc,*.nc,*.tap)
+PROGRAM_EXTENSION = .png,.gif,.jpg Greyscale Depth Image
+PROGRAM_EXTENSION = .py Python Script
+
+# specifies what special 'filter' programs runs based on program ending
+png = image-to-gcode
+gif = image-to-gcode
+jpg = image-to-gcode
+py = python3
+
+[KINS]
+KINEMATICS = trivkins coordinates=XYZ
+JOINTS = 3
+
+[EMCIO]
+EMCIO = io
+CYCLE_TIME = 0.100
+TOOL_TABLE = tool.tbl
+
+[RS274NGC]
+# motion controller saves parameters to this file
+PARAMETER_FILE = qtdragon.var
+
+# start up G/M codes when first loaded
+RS274NGC_STARTUP_CODE = G17 G21 G40 G43H0 G54 G64P0.0127 G80 G90 G94 G97 M5 M9
+
+# subroutine/remap path list
+SUBROUTINE_PATH = ../../../../nc_files/probe/basic_probe/macros:~/linuxcnc/nc_files/examples/ngcgui_lib:~/linuxcnc/nc_files/examples/ngcgui_lib/utilitysubs
+
+# on abort, this ngc file is called. required for basic/versa probe
+ON_ABORT_COMMAND=O <on_abort> call
+
+[EMCMOT]
+EMCMOT = motmod
+SERVO_PERIOD = 1000000
+COMM_TIMEOUT = 1.0
+COMM_WAIT = 0.010
+BASE_PERIOD = 100000
+
+[TASK]
+TASK = milltask
+CYCLE_TIME = 0.010
+
+[TRAJ]
+COORDINATES = XYZ
+LINEAR_UNITS = metric
+ANGULAR_UNITS = degree
+MAX_LINEAR_VELOCITY = 60.00
+DEFAULT_LINEAR_VELOCITY = 50.00
+SPINDLES = 1
+
+[HAL]
+HALUI = halui
+HALBRIDGE = hal_bridge
+
+HALFILE = core_sim.hal
+HALFILE = simulated_home.hal
+# this file is loaded after qtdragon has made it's HAl pins
+# you can add multiple entries
+POSTGUI_HALFILE = qtdragon_hd_postgui.hal
+
+# this command is run after qtdragon has made it's HAl pins
+# any HAL conmmand can be used
+# you can add multiple entries
+# uncomment this one to print all HAL pins that start with qt
+#POSTGUI_HALCMD = show pin qt
+# uncomment to simulate probing
+#POSTGUI_HALCMD = loadusr qtvcp test_probe
+
+[HALUI]
+# no content
+
+[PROBE]
+# pick basic probe or versa probe or remove for none
+#USE_PROBE = versaprobe
+USE_PROBE = basicprobe
+
+[AXIS_X]
+MIN_LIMIT = -0.001
+MAX_LIMIT = 520.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+
+[AXIS_Y]
+MIN_LIMIT = -0.001
+MAX_LIMIT = 630.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+
+[AXIS_Z]
+# used by external offsets for auto spindle lift and auto leveling
+OFFSET_AV_RATIO  = 0.2
+MIN_LIMIT = -115.0
+MAX_LIMIT = 10.0
+MAX_VELOCITY = 40.0
+MAX_ACCELERATION = 500.0
+
+[JOINT_0]
+AXIS = X
+MIN_LIMIT = -0.001
+MAX_LIMIT = 520.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 72.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = 20.0
+HOME_OFFSET = 0.00000
+HOME_SEARCH_VEL = 20.000000
+HOME_LATCH_VEL = 10.000
+HOME_SEQUENCE = 1
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
+[JOINT_1]
+AXIS = Y
+MIN_LIMIT = -0.001
+MAX_LIMIT = 630.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 72.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = 20.0
+HOME_OFFSET = 0.000000
+HOME_SEARCH_VEL = 20.00
+HOME_LATCH_VEL = 10.00
+HOME_SEQUENCE = 2
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
+[JOINT_2]
+AXIS = Z
+MIN_LIMIT = -115.0
+MAX_LIMIT = 10.0
+MAX_VELOCITY = 40.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 48.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = -10.0
+HOME_OFFSET = 0.000000
+HOME_SEARCH_VEL = 20.000000
+HOME_LATCH_VEL = 10.00
+HOME_SEQUENCE = 0
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/qtdragon_hd/qtdragon_hd_xyz/tool.tbl b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon_hd/qtdragon_hd_xyz/tool.tbl
new file mode 100644
index 0000000..801fbcb
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon_hd/qtdragon_hd_xyz/tool.tbl
@@ -0,0 +1,4 @@
+T1 P1 X0 Y0 Z0.51100 A0 B0 C0 U0 V0 W0 D10.00000 I0 J0 Q0 ;1/8 end mill 
+T2 P2 X0 Y0 Z0.10000 A0 B0 C0 U0 V0 W0 D0.06250 I0 J0 Q0 ;1/16 end mill 
+T3 P3 X0 Y0 Z1.27300 A0 B0 C0 U0 V0 W0 D0.20100 I0 J0 Q0 ;#7 tap drill 
+T4 P4 X0 Y0 Z3.00000 A0 B0 C0 U0 V0 W0 D4.00000 I0 J0 Q0 ;4" Face Mill 
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/qtdragon_hd/qtdragon_hd_z_compensation/on_abort.ngc b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon_hd/qtdragon_hd_z_compensation/on_abort.ngc
new file mode 100644
index 0000000..c2e6b36
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon_hd/qtdragon_hd_z_compensation/on_abort.ngc
@@ -0,0 +1,31 @@
+o<on_abort> sub
+
+
+o100 if [#1 eq 5]
+    (machine on)
+o100 elseif [#1 eq 6]
+    (machine off)
+o100 elseif [#1 eq 7]
+    (estopped)
+o100 elseif [#1 eq 8]
+    (msg,Process Aborted)
+o100 else
+    (DEBUG,Abort Parameter is %d[#1])
+o100 endif
+
+o<on_abort> endsub
+m2
+
+These are potential abort number:
+
+        EMC_ABORT_TASK_EXEC_ERROR = 1,
+        EMC_ABORT_AUX_ESTOP = 2,
+        EMC_ABORT_MOTION_OR_IO_RCS_ERROR = 3,
+        EMC_ABORT_TASK_STATE_OFF = 4,
+        EMC_ABORT_TASK_STATE_ESTOP_RESET = 5,
+        EMC_ABORT_TASK_STATE_ESTOP = 6,
+        EMC_ABORT_TASK_STATE_NOT_ON = 7,
+        EMC_ABORT_TASK_ABORT = 8,
+        EMC_ABORT_INTERPRETER_ERROR = 9,        // interpreter failed during readahead
+        EMC_ABORT_INTERPRETER_ERROR_MDI = 10,   // interpreter failed during MDI execution
+        EMC_ABORT_USER = 100  // user-defined abort codes start here
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/qtdragon_hd/qtdragon_hd_z_compensation/qtdragon_hd_z_compensation.ini b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon_hd/qtdragon_hd_z_compensation/qtdragon_hd_z_compensation.ini
new file mode 100644
index 0000000..2744439
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon_hd/qtdragon_hd_z_compensation/qtdragon_hd_z_compensation.ini
@@ -0,0 +1,233 @@
+# This file was created with the 7i96 Wizard on Jun 10 2019 11:12:47
+# Changes to most things are ok and will be read by the wizard
+
+[EMC]
+VERSION = 1.1
+MACHINE = qtdragon
+DEBUG = 0x00000000
+
+[DISPLAY]
+# sets qtdragon_hd as screen. for debug output to terminal add -d or -v
+# sets window title
+# sets icon in task manager
+DISPLAY = qtvcp -d qtdragon_hd
+TITLE = QtDragon HD: XYZ
+ICON = silver_dragon.png
+
+# qtdragon saves most preference to this file
+PREFERENCE_FILE_PATH = WORKINGFOLDER/qtdragon_hd.pref
+
+# min/max percentage overrides allowed in qtdragon 1 = 100%
+MAX_FEED_OVERRIDE       = 1.2
+MIN_SPINDLE_0_OVERRIDE    = 0.5
+MAX_SPINDLE_0_OVERRIDE    = 1.2
+
+# manual spindle speed will start at this RPM
+DEFAULT_SPINDLE_0_SPEED   = 12000
+
+# spindle up/down increment in RPM
+SPINDLE_INCREMENT = 200
+
+# min max apindle speed manually allowed 
+MIN_SPINDLE_0_SPEED = 1000
+MAX_SPINDLE_0_SPEED = 20000
+
+# max spindle power in Watts
+MAX_SPINDLE_POWER = 2000
+
+# min/max/default jog velocities in qtdragon in units/sec
+MIN_LINEAR_VELOCITY     = 0
+MAX_LINEAR_VELOCITY     = 60.00
+DEFAULT_LINEAR_VELOCITY = 50.0
+
+# incremental jog step length options
+INCREMENTS = 10 mm, 1.0 mm, 0.10 mm, 0.01 mm, 1.0 inch, 0.1 inch, 0.01 inch
+
+CYCLE_TIME = 100
+INTRO_GRAPHIC = silver_dragon.png
+INTRO_TIME = 2
+
+# default program search path
+PROGRAM_PREFIX = ~/linuxcnc/nc_files
+
+# NGCGUI subroutine path.
+# Thr path must also  be in [RS274NGC] SUBROUTINE_PATH
+NGCGUI_SUBFILE_PATH = ../../../nc_files/ngcgui_lib/
+# pre selected programs tabs
+# specify filenames only, files must be in the NGCGUI_SUBFILE_PATH
+NGCGUI_SUBFILE = slot.ngc
+NGCGUI_SUBFILE = qpocket.ngc
+
+# qtdragon saves MDI cxommands to this file
+MDI_HISTORY_FILE = mdi_history.dat
+# qtdragon saves rnning logs to this file
+LOG_FILE = qtdragon_hd.log
+
+[MDI_COMMAND_LIST]
+# for macro buttons
+MDI_COMMAND_MACRO0 = G0 Z25 X0 Y0;Z0,Goto\nZero
+MDI_COMMAND_MACRO1 = G53 G0 Z0;G53 G0 X0 Y0,Goto\nMach\nZero
+
+[FILTER]
+# Controls what programs are shown inqtdragon file manager
+PROGRAM_EXTENSION = .ngc,.nc,.tap G-Code File (*.ngc,*.nc,*.tap)
+PROGRAM_EXTENSION = .png,.gif,.jpg Greyscale Depth Image
+PROGRAM_EXTENSION = .py Python Script
+
+# specifies what special 'filter' programs runs based on program ending
+png = image-to-gcode
+gif = image-to-gcode
+jpg = image-to-gcode
+py = python
+
+[KINS]
+KINEMATICS = trivkins coordinates=XYZ
+JOINTS = 3
+
+[EMCIO]
+TOOL_TABLE = tool.tbl
+
+[RS274NGC]
+# motion controller saves parameters to this file
+PARAMETER_FILE = qtdragon.var
+
+# start up G/M codes when first loaded
+RS274NGC_STARTUP_CODE = G17 G21 G40 G43H0 G54 G64P0.0127 G80 G90 G94 G97 M5 M9
+
+# subroutine/remap path list
+SUBROUTINE_PATH = ../../../../nc_files/probe/basic_probe/macros:~/linuxcnc/nc_files/examples/ngcgui_lib:~/linuxcnc/nc_files/examples/ngcgui_lib/utilitysubs
+
+# on abort, this ngc file is called. required for basic/versa probe
+ON_ABORT_COMMAND=O <on_abort> call
+
+[EMCMOT]
+EMCMOT = motmod
+SERVO_PERIOD = 1000000
+COMM_TIMEOUT = 1.0
+COMM_WAIT = 0.010
+BASE_PERIOD = 100000
+
+[TASK]
+TASK = milltask
+CYCLE_TIME = 0.010
+
+[TRAJ]
+COORDINATES = XYZ
+LINEAR_UNITS = metric
+ANGULAR_UNITS = degree
+MAX_LINEAR_VELOCITY = 60.00
+DEFAULT_LINEAR_VELOCITY = 50.00
+SPINDLES = 1
+
+[HAL]
+HALUI = halui
+HALBRIDGE = hal_bridge
+
+HALFILE = core_sim.hal
+HALFILE = simulated_home.hal
+# this file is loaded after qtdragon has made it's HAl pins
+# you can add multiple entries
+POSTGUI_HALFILE = qtdragon_hd_postgui.hal
+
+# this command is run after qtdragon has made it's HAl pins
+# any HAL conmmand can be used
+# you can add multiple entries
+# uncomment this one to print all HAL pins that start with qt
+#POSTGUI_HALCMD = show pin qt
+# uncomment to simulate probing
+#POSTGUI_HALCMD = loadusr qtvcp test_probe
+
+[HALUI]
+# no content
+
+[PROBE]
+# pick basic probe or versa probe or remove for none
+#USE_PROBE = versaprobe
+USE_PROBE = basicprobe
+
+[AXIS_X]
+MIN_LIMIT = -0.001
+MAX_LIMIT = 520.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+
+[AXIS_Y]
+MIN_LIMIT = -0.001
+MAX_LIMIT = 630.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+
+[AXIS_Z]
+# used by external offsets for auto spindle lift and auto leveling
+OFFSET_AV_RATIO  = 0.2
+MIN_LIMIT = -115.0
+MAX_LIMIT = 10.0
+MAX_VELOCITY = 40.0
+MAX_ACCELERATION = 500.0
+
+[JOINT_0]
+AXIS = X
+MIN_LIMIT = -0.001
+MAX_LIMIT = 520.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 72.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = 20.0
+HOME_OFFSET = 0.00000
+HOME_SEARCH_VEL = 20.000000
+HOME_LATCH_VEL = 10.000
+HOME_SEQUENCE = 1
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
+[JOINT_1]
+AXIS = Y
+MIN_LIMIT = -0.001
+MAX_LIMIT = 630.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 72.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = 20.0
+HOME_OFFSET = 0.000000
+HOME_SEARCH_VEL = 20.00
+HOME_LATCH_VEL = 10.00
+HOME_SEQUENCE = 2
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
+[JOINT_2]
+AXIS = Z
+MIN_LIMIT = -115.0
+MAX_LIMIT = 10.0
+MAX_VELOCITY = 40.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 48.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = -10.0
+HOME_OFFSET = 0.000000
+HOME_SEARCH_VEL = 20.000000
+HOME_LATCH_VEL = 10.00
+HOME_SEQUENCE = 0
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/qtdragon_hd/qtdragon_hd_z_compensation/tool.tbl b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon_hd/qtdragon_hd_z_compensation/tool.tbl
new file mode 100644
index 0000000..801fbcb
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/qtdragon_hd/qtdragon_hd_z_compensation/tool.tbl
@@ -0,0 +1,4 @@
+T1 P1 X0 Y0 Z0.51100 A0 B0 C0 U0 V0 W0 D10.00000 I0 J0 Q0 ;1/8 end mill 
+T2 P2 X0 Y0 Z0.10000 A0 B0 C0 U0 V0 W0 D0.06250 I0 J0 Q0 ;1/16 end mill 
+T3 P3 X0 Y0 Z1.27300 A0 B0 C0 U0 V0 W0 D0.20100 I0 J0 Q0 ;#7 tap drill 
+T4 P4 X0 Y0 Z3.00000 A0 B0 C0 U0 V0 W0 D4.00000 I0 J0 Q0 ;4" Face Mill 
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/qtvcp_screens/qtdragon/on_abort.ngc b/wasm-port/vendor/linuxcnc/configs/sim/qtvcp_screens/qtdragon/on_abort.ngc
new file mode 100644
index 0000000..c2e6b36
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/qtvcp_screens/qtdragon/on_abort.ngc
@@ -0,0 +1,31 @@
+o<on_abort> sub
+
+
+o100 if [#1 eq 5]
+    (machine on)
+o100 elseif [#1 eq 6]
+    (machine off)
+o100 elseif [#1 eq 7]
+    (estopped)
+o100 elseif [#1 eq 8]
+    (msg,Process Aborted)
+o100 else
+    (DEBUG,Abort Parameter is %d[#1])
+o100 endif
+
+o<on_abort> endsub
+m2
+
+These are potential abort number:
+
+        EMC_ABORT_TASK_EXEC_ERROR = 1,
+        EMC_ABORT_AUX_ESTOP = 2,
+        EMC_ABORT_MOTION_OR_IO_RCS_ERROR = 3,
+        EMC_ABORT_TASK_STATE_OFF = 4,
+        EMC_ABORT_TASK_STATE_ESTOP_RESET = 5,
+        EMC_ABORT_TASK_STATE_ESTOP = 6,
+        EMC_ABORT_TASK_STATE_NOT_ON = 7,
+        EMC_ABORT_TASK_ABORT = 8,
+        EMC_ABORT_INTERPRETER_ERROR = 9,        // interpreter failed during readahead
+        EMC_ABORT_INTERPRETER_ERROR_MDI = 10,   // interpreter failed during MDI execution
+        EMC_ABORT_USER = 100  // user-defined abort codes start here
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/qtvcp_screens/qtdragon/qtdragon_mpg.ini b/wasm-port/vendor/linuxcnc/configs/sim/qtvcp_screens/qtdragon/qtdragon_mpg.ini
new file mode 100644
index 0000000..a28b0a1
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/qtvcp_screens/qtdragon/qtdragon_mpg.ini
@@ -0,0 +1,239 @@
+# This file was created with the 7i96 Wizard on Jun 10 2019 11:12:47
+# Changes to most things are ok and will be read by the wizard
+
+[EMC]
+VERSION = 1.1
+MACHINE = qtdragon
+DEBUG = 0x00000000
+
+[DISPLAY]
+DISPLAY = qtvcp qtdragon
+PREFERENCE_FILE_PATH = WORKINGFOLDER/qtdragon.pref
+POSITION_OFFSET = RELATIVE
+POSITION_FEEDBACK = ACTUAL
+GRIDS = 10mm 20mm 50mm 100mm 1in 2in 5in 10in
+MAX_FEED_OVERRIDE       = 1.2
+MAX_RAPID_OVERRIDE      = 1.2
+MIN_SPINDLE_0_OVERRIDE    = 0.5
+MAX_SPINDLE_0_OVERRIDE    = 1.2
+DEFAULT_SPINDLE_0_SPEED   = 12000
+SPINDLE_INCREMENT = 200
+MIN_SPINDLE_0_SPEED = 1000
+MAX_SPINDLE_0_SPEED = 20000
+MIN_LINEAR_VELOCITY     = 0
+MAX_LINEAR_VELOCITY     = 60.00
+DEFAULT_LINEAR_VELOCITY = 50.0
+DEFAULT_LINEAR_JOG_VEL  = 50.0
+DEFAULT_ANGULAR_VELOCITY = 0
+MIN_ANGULAR_VELOCITY = 0
+MAX_ANGULAR_VELOCITY = 0
+CYCLE_TIME = 100
+INTRO_GRAPHIC = linuxcnc.gif
+INTRO_TIME = 2
+PROGRAM_PREFIX = ~/linuxcnc/nc_files
+INCREMENTS = 10 mm, 1.0 mm, 0.10 mm, 0.01 mm, 1.0 inch, 0.1 inch, 0.01 inch
+MDI_HISTORY_FILE = mdi_history.dat
+LOG_FILE = qtdragon.log
+TOOL_EDITOR = tooledit
+CONFIRM_EXIT = True
+
+MESSAGE_BOLDTEXT = Critical and Persistent
+MESSAGE_TEXT = This is a persistent dialog test
+MESSAGE_DETAILS = There seems to be something wrong\n You must fix it to clear message
+MESSAGE_TYPE = nonedialog
+MESSAGE_PINNAME = nonedialogtest
+MESSAGE_ICON = CRITICAL
+
+MESSAGE_BOLDTEXT = Do You Want To Make A Choice?
+MESSAGE_TEXT = This is a yes no dialog test
+MESSAGE_DETAILS = Y/N DETAILS
+MESSAGE_TYPE = yesnodialog
+MESSAGE_PINNAME = yndialogtest
+MESSAGE_ICON = QUESTION
+
+MESSAGE_BOLDTEXT = This is an information message
+MESSAGE_TEXT = This is low priority
+MESSAGE_DETAILS = press ok to clear
+MESSAGE_TYPE = okdialog status
+MESSAGE_PINNAME = bothtest
+MESSAGE_ICON = INFO
+
+EMBED_TAB_NAME=Vismach demo
+EMBED_TAB_COMMAND=qtvcp vismach_mill_xyz
+EMBED_TAB_LOCATION=tabWidget_utilities
+
+[MDI_COMMAND_LIST]
+# for macro buttons
+MDI_COMMAND = G0 Z25;X0 Y0;Z0, Goto\nUser\nZero
+MDI_COMMAND = G53 G0 Z0;G53 G0 X0 Y0,Goto\nMachn\nZero
+
+[FILTER]
+PROGRAM_EXTENSION = .ngc,.nc,.tap G-Code File (*.ngc,*.nc,*.tap)
+PROGRAM_EXTENSION = .png,.gif,.jpg Greyscale Depth Image
+PROGRAM_EXTENSION = .py Python Script
+png = image-to-gcode
+gif = image-to-gcode
+jpg = image-to-gcode
+py = python
+
+[KINS]
+KINEMATICS = trivkins coordinates=XYZ
+JOINTS = 3
+
+[EMCIO]
+TOOL_TABLE = tool.tbl
+
+[RS274NGC]
+PARAMETER_FILE = qtdragon.var
+RS274NGC_STARTUP_CODE = G17 G21 G40 G43H0 G54 G64P0.005 G80 G90 G94 G97 M5 M9
+SUBROUTINE_PATH = ../../../../nc_files/probe/basic_probe/macros:~/linuxcnc/nc_files/examples/ngcgui_lib
+FEATURES=12
+ON_ABORT_COMMAND=O <on_abort> call
+
+[EMCMOT]
+EMCMOT = motmod
+SERVO_PERIOD = 1000000
+COMM_TIMEOUT = 1.0
+COMM_WAIT = 0.010
+BASE_PERIOD = 100000
+
+[TASK]
+TASK = milltask
+CYCLE_TIME = 0.010
+
+[TRAJ]
+COORDINATES = XYZ
+LINEAR_UNITS = metric
+ANGULAR_UNITS = degree
+MAX_LINEAR_VELOCITY = 60.00
+DEFAULT_LINEAR_VELOCITY = 50.00
+SPINDLES = 1
+
+[HAL]
+HALUI = halui
+HALFILE = core_sim.hal
+HALFILE = simulated_home.hal
+#HALFILE = custom.hal
+POSTGUI_HALFILE = qtdragon_postgui.hal
+
+[HALUI]
+# no content
+
+[PROBE]
+USE_PROBE = versaprobe
+#USE_PROBE = basicprobe
+
+[TOOLSENSOR]
+X = 5.00
+Y = 71.50
+TOUCH_HEIGHT = 29.3
+SENSOR_HEIGHT = 59.8
+MAXPROBE =  -40
+SEARCH_VEL = 200
+PROBE_VEL = 50
+
+[LASER]
+X = 106.9
+Y = -16.85
+
+[AXIS_X]
+MIN_LIMIT = -0.001
+MAX_LIMIT = 520.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+
+[AXIS_Y]
+MIN_LIMIT = -0.001
+MAX_LIMIT = 630.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+
+[AXIS_Z]
+OFFSET_AV_RATIO  = 0.2
+MIN_LIMIT = -115.0
+MAX_LIMIT = 10.0
+MAX_VELOCITY = 40.0
+MAX_ACCELERATION = 500.0
+
+[JOINT_0]
+AXIS = X
+MIN_LIMIT = -0.001
+MAX_LIMIT = 520.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 72.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = 20.0
+HOME_OFFSET = 0.00000
+HOME_SEARCH_VEL = 20.000000
+HOME_LATCH_VEL = 10.000
+HOME_SEQUENCE = 1
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
+[JOINT_1]
+AXIS = Y
+MIN_LIMIT = -0.001
+MAX_LIMIT = 630.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 72.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = 20.0
+HOME_OFFSET = 0.000000
+HOME_SEARCH_VEL = 20.00
+HOME_LATCH_VEL = 10.00
+HOME_SEQUENCE = 2
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
+[JOINT_2]
+AXIS = Z
+MIN_LIMIT = -115.0
+MAX_LIMIT = 10.0
+MAX_VELOCITY = 40.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 48.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = -10.0
+HOME_OFFSET = 0.000000
+HOME_SEARCH_VEL = 20.000000
+HOME_LATCH_VEL = 10.00
+HOME_SEQUENCE = 0
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
+[SPINDLE]
+SPINDLE_TYPE = openLoop
+SCALE = 
+PWM_FREQUENCY = 2000
+MAX_RPM = 18000
+MIN_RPM = 8000
+DEADBAND = 0
+P = 0
+I = 0
+D = 0
+FF0 = 1
+FF1 = 0
+FF2 = 0
+BIAS = 0
+MAX_ERROR = 0
+
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/qtvcp_screens/qtdragon/tool.tbl b/wasm-port/vendor/linuxcnc/configs/sim/qtvcp_screens/qtdragon/tool.tbl
new file mode 100644
index 0000000..801fbcb
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/qtvcp_screens/qtdragon/tool.tbl
@@ -0,0 +1,4 @@
+T1 P1 X0 Y0 Z0.51100 A0 B0 C0 U0 V0 W0 D10.00000 I0 J0 Q0 ;1/8 end mill 
+T2 P2 X0 Y0 Z0.10000 A0 B0 C0 U0 V0 W0 D0.06250 I0 J0 Q0 ;1/16 end mill 
+T3 P3 X0 Y0 Z1.27300 A0 B0 C0 U0 V0 W0 D0.20100 I0 J0 Q0 ;#7 tap drill 
+T4 P4 X0 Y0 Z3.00000 A0 B0 C0 U0 V0 W0 D4.00000 I0 J0 Q0 ;4" Face Mill 
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/woodpecker/on_abort.ngc b/wasm-port/vendor/linuxcnc/configs/sim/woodpecker/on_abort.ngc
new file mode 100644
index 0000000..c2e6b36
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/woodpecker/on_abort.ngc
@@ -0,0 +1,31 @@
+o<on_abort> sub
+
+
+o100 if [#1 eq 5]
+    (machine on)
+o100 elseif [#1 eq 6]
+    (machine off)
+o100 elseif [#1 eq 7]
+    (estopped)
+o100 elseif [#1 eq 8]
+    (msg,Process Aborted)
+o100 else
+    (DEBUG,Abort Parameter is %d[#1])
+o100 endif
+
+o<on_abort> endsub
+m2
+
+These are potential abort number:
+
+        EMC_ABORT_TASK_EXEC_ERROR = 1,
+        EMC_ABORT_AUX_ESTOP = 2,
+        EMC_ABORT_MOTION_OR_IO_RCS_ERROR = 3,
+        EMC_ABORT_TASK_STATE_OFF = 4,
+        EMC_ABORT_TASK_STATE_ESTOP_RESET = 5,
+        EMC_ABORT_TASK_STATE_ESTOP = 6,
+        EMC_ABORT_TASK_STATE_NOT_ON = 7,
+        EMC_ABORT_TASK_ABORT = 8,
+        EMC_ABORT_INTERPRETER_ERROR = 9,        // interpreter failed during readahead
+        EMC_ABORT_INTERPRETER_ERROR_MDI = 10,   // interpreter failed during MDI execution
+        EMC_ABORT_USER = 100  // user-defined abort codes start here
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/woodpecker/tool.tbl b/wasm-port/vendor/linuxcnc/configs/sim/woodpecker/tool.tbl
new file mode 100644
index 0000000..8e41bb0
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/woodpecker/tool.tbl
@@ -0,0 +1,29 @@
+T90 P90 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D3.00000 I0 J0 Q0 ;PROBE 
+T0 P0 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D0 I0 J0 Q0 ;NO TOOL LOADED 
+T1 P1 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D1.58750 I0 J0 Q0 ;1/16" end mill 
+T2 P2 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D3.16000 I0 J0 Q0 ;1/8" end mill 
+T3 P3 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D2.86000 I0 J0 Q0 ;1/8" router bit 
+T4 P4 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D6.35000 I0 J0 Q0 ;1/4" straight router bit 
+T6 P5 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D0.12670 I0 J0 Q0 ;5/16" straight 25 mm flute 
+T6 P6 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D7.93750 I0 J0 Q0 ;5/16" straight 30 mm flute 
+T7 P7 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D12.70000 I0 J0 Q0 ;1/2" straight router bit 
+T8 P8 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D19.05000 I0 J0 Q0 ;3/4" bottom clearing 
+T9 P9 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D6.35000 I0 J0 Q0 ;1/4" single flute 
+T10 P10 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D3.17500 I0 J0 Q0 ;1/8" spot drill 
+T11 P11 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D3.17500 I0 J0 Q0 ;1/8" ball end 
+T12 P12 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D6.35000 I0 J0 Q0 ;1/4" ball end 
+T13 P13 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D9.52500 I0 J0 Q0 ;3/8" ball end 
+T14 P14 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D12.70000 I0 J0 Q0 ;1/2" ball end 
+T15 P15 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D12.70000 I0 J0 Q0 ;90 deg v-bit 
+T16 P16 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D6.35000 I0 J0 Q0 ;45/60 v-bit 
+T17 P17 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D6.35000 I0 J0 Q0 ;45/60 v-bit 
+T21 P21 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D6.00000 I0 J0 Q0 ;6 mm straight ball end 
+T22 P22 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D6.00000 I0 J0 Q0 ;6 mm straight ball end 
+T23 P23 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D1.00000 I0 J0 Q0 ;1 mm tapered ball end 
+T24 P24 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D1.00000 I0 J0 Q0 ;1 mm tapered ball end 
+T25 P25 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D6.00000 I0 J0 Q0 ;60 deg v-bit 6mm shank 
+T26 P26 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D6.00000 I0 J0 Q0 ;60 deg v-bit 6 mm shank 
+T31 P31 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D3.00000 I0 J0 Q0 ;3 mm router bit 
+T32 P32 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D6.00000 I0 J0 Q0 ;6 mm router bit 
+T33 P33 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D6.00000 I0 J0 Q0 ;6 mm drill 
+T34 P34 X0 Y0 Z0 A0 B0 C0 U0 V0 W0 D6.00000 I0 J0 Q0 ;6 mm 4 flute spiral upcut 
diff --git a/wasm-port/vendor/linuxcnc/configs/sim/woodpecker/woodpecker.ini b/wasm-port/vendor/linuxcnc/configs/sim/woodpecker/woodpecker.ini
new file mode 100644
index 0000000..fc6b389
--- /dev/null
+++ b/wasm-port/vendor/linuxcnc/configs/sim/woodpecker/woodpecker.ini
@@ -0,0 +1,202 @@
+# This file was created with the 7i96 Wizard on Jun 10 2019 11:12:47
+# Changes to most things are ok and will be read by the wizard
+
+[EMC]
+VERSION = 1.1
+MACHINE = woodpecker
+DEBUG = 0x00000000
+
+[DISPLAY]
+DISPLAY = qtvcp woodpecker
+PREFERENCE_FILE_PATH = WORKINGFOLDER/woodpecker.pref
+POSITION_OFFSET = RELATIVE
+POSITION_FEEDBACK = ACTUAL
+GRIDS = 10mm 20mm 50mm 100mm 1in 2in 5in 10in
+MAX_FEED_OVERRIDE       = 1.2
+MIN_SPINDLE_0_OVERRIDE    = 0.5
+MAX_SPINDLE_0_OVERRIDE    = 1.2
+DEFAULT_SPINDLE_0_SPEED   = 12000
+SPINDLE_INCREMENT = 200
+MIN_SPINDLE_0_SPEED = 1000
+MAX_SPINDLE_0_SPEED = 20000
+MIN_LINEAR_VELOCITY     = 0
+MAX_LINEAR_VELOCITY     = 60.00
+DEFAULT_LINEAR_VELOCITY = 50.0
+DEFAULT_LINEAR_JOG_VEL  = 50.0
+DEFAULT_ANGULAR_VELOCITY = 0
+MIN_ANGULAR_VELOCITY = 0
+MAX_ANGULAR_VELOCITY = 0
+CYCLE_TIME = 100
+INTRO_GRAPHIC = linuxcnc.gif
+INTRO_TIME = 2
+PROGRAM_PREFIX =  ~/linuxcnc/nc_files
+INCREMENTS = 10 mm, 1.0 mm, 0.10 mm, 0.01 mm, 1.0 inch, 0.1 inch, 0.01 inch
+MDI_HISTORY_FILE = mdi_history.dat
+LOG_FILE = woodpecker.log
+TOOL_EDITOR = tooledit
+CONFIRM_EXIT = True
+
+[FILTER]
+PROGRAM_EXTENSION = .png,.gif,.jpg Greyscale Depth Image
+PROGRAM_EXTENSION = .py Python Script
+PROGRAM_EXTENSION = .nc,.tap G-Code File
+png = image-to-gcode
+gif = image-to-gcode
+jpg = image-to-gcode
+py = python3
+
+[KINS]
+KINEMATICS = trivkins coordinates=XYZ
+JOINTS = 3
+
+[EMCIO]
+TOOL_TABLE = tool.tbl
+
+[RS274NGC]
+PARAMETER_FILE = woodpecker.var
+RS274NGC_STARTUP_CODE = G17 G21 G40 G43H0 G54 G64P0.005 G80 G90 G94 G97 M5 M9
+SUBROUTINE_PATH = ../../../../nc_files/probe/basic_probe/macros
+FEATURES=12
+
+[EMCMOT]
+EMCMOT = motmod
+SERVO_PERIOD = 1000000
+COMM_TIMEOUT = 1.0
+COMM_WAIT = 0.010
+BASE_PERIOD = 100000
+
+[TASK]
+TASK = milltask
+CYCLE_TIME = 0.010
+
+[TRAJ]
+COORDINATES = XYZ
+LINEAR_UNITS = metric
+ANGULAR_UNITS = degree
+MAX_LINEAR_VELOCITY = 60.00
+DEFAULT_LINEAR_VELOCITY = 50.00
+SPINDLES = 1
+
+[HAL]
+HALUI = halui
+HALFILE = core_sim.hal
+HALFILE = simulated_home.hal
+#HALFILE = custom.hal
+POSTGUI_HALFILE = woodpecker_postgui.hal
+
+[HALUI]
+# no content
+
+[TOOLSENSOR]
+X = 5.00
+Y = 71.50
+TOUCH_HEIGHT = 29.3
+SENSOR_HEIGHT = 59.8
+MAXPROBE =  -40
+SEARCH_VEL = 200
+PROBE_VEL = 50
+
+[LASER]
+X = 106.9
+Y = -16.85
+
+[AXIS_X]
+MIN_LIMIT = -0.001
+MAX_LIMIT = 520.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+
+[AXIS_Y]
+MIN_LIMIT = -0.001
+MAX_LIMIT = 630.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+
+[AXIS_Z]
+MIN_LIMIT = -115.0
+MAX_LIMIT = 10.0
+MAX_VELOCITY = 40.0
+MAX_ACCELERATION = 500.0
+
+[JOINT_0]
+AXIS = X
+MIN_LIMIT = -0.001
+MAX_LIMIT = 520.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 72.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = 20.0
+HOME_OFFSET = 0.00000
+HOME_SEARCH_VEL = 20.000000
+HOME_LATCH_VEL = 10.000
+HOME_SEQUENCE = 1
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
+[JOINT_1]
+AXIS = Y
+MIN_LIMIT = -0.001
+MAX_LIMIT = 630.0
+MAX_VELOCITY = 60.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 72.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = 20.0
+HOME_OFFSET = 0.000000
+HOME_SEARCH_VEL = 20.00
+HOME_LATCH_VEL = 10.00
+HOME_SEQUENCE = 2
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
+[JOINT_2]
+AXIS = Z
+MIN_LIMIT = -115.0
+MAX_LIMIT = 10.0
+MAX_VELOCITY = 40.0
+MAX_ACCELERATION = 500.0
+TYPE = LINEAR
+SCALE = 160.0
+STEPGEN_MAX_VEL = 48.0
+STEPGEN_MAX_ACC = 600.0
+FERROR = 1.0
+MIN_FERROR = 0.5
+MAX_OUTPUT = 0
+MAX_ERROR = 0.0127
+HOME = -10.0
+HOME_OFFSET = 0.000000
+HOME_SEARCH_VEL = 20.000000
+HOME_LATCH_VEL = 10.00
+HOME_SEQUENCE = 0
+HOME_USE_INDEX = False
+HOME_IGNORE_LIMITS = False
+
+[SPINDLE]
+SPINDLE_TYPE = openLoop
+SCALE = 
+PWM_FREQUENCY = 2000
+MAX_RPM = 18000
+MIN_RPM = 8000
+DEADBAND = 0
+P = 0
+I = 0
+D = 0
+FF0 = 1
+FF1 = 0
+FF2 = 0
+BIAS = 0
+MAX_ERROR = 0
+