exp: 轮次25——实时节奏(commit3)准确率：候选平均29.7%/冻结编码器34.4%/commit4 28.9%，均低于基线36.3%；效率：ORT CPU推理3.9ms+gm_groups，单次规划~32ms，50Hz异步可行

docs/探索日志.md

@@ -0,0 +1,427 @@
+# 探索日志：Transformer 机械臂闭环控制
+
+长期锚点：`docs/Transformer轨迹拟合训练方案.md` §9.2（部署形态 = 策略 + 安全层）。
+验收口径（§9.2）：实际执行碰撞 = 0；held-out 可达任务到达率 ≥ 98%；到达用时 ≤ 老师 ×1.3；关节行程 ≤ 现有规划器 ×1.10；冷启动 < 10 ms；每次推理 + 安全认证 P99 < 20 ms；刹停发生率 < 2% 的推理周期；策略单独（关安全层）碰撞率 < 3%。
+
+评测约定：val 任务、部署节奏（r = 3 重规划、1 段采样、K=8）；「纯策略」= 关安全层；「部署」= 开安全层。时延：桌面 RTX 3090 上 `sample_k(B=64, K=8)` 墙钟均值（均值，非 P99）；浏览器 ONNX P99 以 §9.2 R4 的独立测量为准。
+
+## 轮次 0：基线（2026-10-18，main）
+
+- **假设**：模型开环已拟合老师（末端 ~6 mm），闭环失败另有原因。
+- **判据**：reach = 0 且碰撞 ≈ 100% 即失败；需同时报告碰撞 / 到达 / 精度 / 时延。
+- **配方**：`ml/runs/base/last.pt`（step 14000，旧配方、act_scale=1.0），n=256。
+- **对照**：老师回放 reach 1.0 / 碰撞 0；H1_oracle（老师提线走 rollout）reach 1.0、碰撞 0、轨迹偏差 p99 4.6e-4°。
+- **指标**：到达 **0%**；碰撞 **99.6%**；精度 ol_fk 5.98 mm / ol_best 2.92 mm / ol_div 0.655，2 s 误差比 0.755；时延未测。
+- **结论**：仿真/滚动无误，失败在策略输出。闭环对每步残差极敏感（老师动作加 σ=0.05×STEP 即 reach 1.0→0.218）。
+
+## 轮次 1：数据规模能否救闭环（main，负结论）
+
+- **假设**：训练数据不足导致分布外状态无覆盖。
+- **判据**：若闭环状态到训练集最近邻距离大，且密度缩放无法在误差尺度内缩小差距，则加大同类数据无效。
+- **配方**：191 万老师状态最近邻分析；6 维密度缩放 d∝N^(−1/6)。
+- **对照**：起点（老师分布内）最近邻。
+- **指标**：闭环状态最近邻 p50 **21.5°**（起点 13.2°）；数据翻 4 倍仅降 ~21%，与 0.02° 误差尺度差三个量级。
+- **结论**：加大同类老师数据无效；需要「不同的数据」（闭环状态标注）。
+- **下一步**：DAgger 或状态扰动数据。
+
+## 轮次 2：合成扰动状态微调（main，负结论）
+
+- **假设**：偏移 1.5° 状态的老师标注可补足闭环状态覆盖。
+- **判据**：若 success 仍 0 或开环精度退化，则配方不成立。
+- **配方**：2000 个扰动起点（σ 混合 0.5/1/2/4°）→ 老师重规划（2000/2000 到达）→ 36k 样本 → 从 base/last.pt 微调 3000 步（lr 3e-4 / 1e-4 两轮）。
+- **对照**：base/last.pt。
+- **指标**：碰撞 99.6%→**48.4% / 60.4%**；到达仍 **0%**；开环 6→**15.3 / 16.4 mm**（退化 2.5×）；ratio2s 0.927/0.893。
+- **结论**：只学会了「保守避撞」，开环精度被带偏，success 仍 0；此配方不成立。
+- **下一步**：改训练标签（绝对目标）或真实 DAgger。
+
+## 轮次 3：绝对目标参数化（exp: `feat/abs-target`，负结论）
+
+- **假设**：模型从当前状态外推增量（判别 ρ=1.54），改为绝对目标标签可让输出指向参考位置。
+- **判据**：一步采样开环误差需回到 <10 mm，闭环 success > 0；否则参数化不可行。
+- **配方**：`ABS_TARGET=1` 重打主数据（201 万样本，Y=16 步绝对目标/180），train/rollout/ckpt 适配；从零训练 9950 步（p_neq 预热 5000）。过程中修复前缀噪声增广把 eps 直接加到绝对目标（≈18° 污染）的 bug。
+- **对照**：base/last.pt（ol_fk 5.98 mm、reach 0%）。
+- **指标**：一步采样动作误差 **31°**（4/8 段 2.3°/2.8°）；ol_fk 4000/6000/8000 步 = 74.6/140.4/139.0 mm；闭环 **0% / 100%**（1 段与 4 段皆然）；时延未测。
+- **结论**：绝对目标的一步流匹配在 MeanFlow 头上学不动（过预热后 5000 步无下降趋势）；此配方不成立。分支已推送远端 `217a70b`（本地分支可删，远端保留可复现）。
+- **下一步**：回归增量口径，上真实 DAgger。
+
+## 轮次 4：真实 DAgger 1 轮（main，部分有效）
+
+- **假设**：策略自己走到的状态（离训练集 21.5°）+ 老师重标注，可让模型学会在偏移状态上行动。
+- **判据**：reach 是否从 0 抬头；同时看碰撞、开环精度、时延。
+- **配方**：`ACT_SCALE=1.0 DAG_ROUNDS=1 DAG_N=2000 bash ml/dagger/run.sh base ml/runs/base/last.pt`（采集 2000 题 → 老师重规划 → 打包 → 微调 15000 步，lr 3e-4；主数据 + DAgger 混合）。
+- **对照**：base/last.pt。
+- **指标**：碰撞 99.6%→**40.2%**（8000 步 36.9%，10000 步 58.8%）；到达 **0%**，仅微调 12000 步时出现 **0.4%（2/512）**；开环退化 6→**15.7 mm**；ratio2s 0.87–0.92；时延未测。
+- **结论**：DAgger 数据确实教会避撞，但微调把主分布带偏（开环退化），到达仍近 0；单独 DAgger 不是终点。
+- **下一步**：在 DAgger 模型上加目标反馈（模型前馈 + DLS 反馈）。
+
+## 轮次 5：模型前馈 + DLS 目标反馈（exp: `feat/fb-mix`，历史最佳）
+
+- **假设**：模型擅长开环轨迹/避撞，但不指向目标；把 DLS 朝目标的反馈叠加到候选动作上，可把「走偏」拉回目标。
+- **判据**：部署口径（+安全层）reach 显著 > 0 且碰撞 < 3%（§9.2 策略单独碰撞线）、刹停可控；否则不成立。
+- **配方**：`closed_loop.rollout(fb_gain=...)`：`inc += fb_gain · DLS(qe→T,R, n=1)`（加在所有候选上，安全层评估带反馈的候选）。模型 `ml/runs/base_dag1/best.pt`（DAgger 轮 4 的 best，12000 步）。n=128，val。
+- **对照**：base/last.pt + 同反馈；DAgger 模型 + 无反馈。
+- **指标（n=128）**：
+
+| 配置 | 到达 | 碰撞 | 精度 ratio2s | 刹停/题 | 时延 |
+|---|---|---|---|---|---|
+| DAgger 模型, gain 0 | 0% | 44.5% | 0.873 | 0 | — |
+| DAgger 模型, gain 1.0, 关安全层 | 29.7% | 73.4% | 0.370 | 0 | — |
+| **DAgger 模型, gain 1.0, 开安全层** | **20.3%** | **2.3%** | **0.480** | **21.9** | **12.58 ms/次**（B=64,K=8，桌面 3090） |
+| base 模型, gain 1.0, 关安全层 | 0% | 94.5% | 0.554 | 0 | — |
+
+（另测 n=32 复核：gain 1.0 + safety → reach 25.0%、碰撞 6.2%、ratio2s 0.588。）
+
+- **结论**：**反馈混合是首个把到达率从 0 拉到 20%+ 的机理**；安全层把碰撞从 73% 压到 2.3%（部署口径），代价是刹停 21.9 次/题（远超 §9.2 的 <2%/周期）。精度 ratio2s 0.48（2 s 时误差缩一半），时延 12.58 ms/次接近 §9.2 的 20 ms（推理+认证）门槛。
+- **与历史最佳/基线对比**：reach 0→20.3%、碰撞 99.6→2.3%、ratio2s 0.755→0.480；开环精度仍退化（DAgger 微调导致 15.7 mm vs 基线 5.98 mm）。
+- **漂移检查**：main = 70654e4（无新提交）；工作区仅用户个人 html 未跟踪；数据口径 act_scale=1.0 与 ckpt 一致；`feat/abs-target` 已推送远端；本次实验在独立分支 `feat/fb-mix`。
+- **下一步**：扫更大 gain（1.2–2.0）与增益衰减；目标是把刹停次数降下来、到达率再提升，并测 ONNX/浏览器时延。
+
+## 轮次 6：反馈增益扩展扫描（exp: `feat/fb-mix`，小幅进展）
+
+- **假设**：更大增益能把到达率继续推高。
+- **判据**：reach 显著高于 20.3%（>25%）且碰撞 ≤3%、刹停不失控。
+- **配方**：`rollout(fb_gain∈{1.2,1.5,2.0}, safety=True)`，模型同轮次 5，n=128。
+- **对照**：轮次 5（gain 1.0：reach 20.3% / 碰撞 2.3% / ratio2s 0.480 / 刹停 21.9）。
+- **指标**：
+
+| gain | 到达 | 碰撞 | ratio2s | 刹停/题 | 墙钟/题 |
+|---|---|---|---|---|---|
+| 1.2 | **23.4%** | 1.6% | **0.454** | 31.4 | 973 ms |
+| 1.5 | 21.9% | 2.3% | 0.498 | 43.0 | 1151 ms |
+| 2.0 | 23.4% | 0.8% | 0.530 | 57.6 | 1100 ms |
+
+- **结论**：到达率封顶在 ~23%，增益再大只增刹停（31→58 次/题）。当前瓶颈从「到不了目标」变成「安全层频繁刹停 + 近目标过冲」。
+- **下一步**：距离衰减增益（远离目标全增益、贴近目标减弱）+ 刹停兜底；目标 reach > 30% 且刹停显著下降。
+
+## 轮次 7：距离衰减增益 + 刹停兜底（exp: `feat/fb-mix`，负结论）
+
+- **假设**：贴近目标减弱反馈可减少过冲/刹停；安全层全拒时用「半速朝目标一步」（单点安全认证）可减少原地停滞。
+- **判据**：reach > 23.4%（轮次 6）且碰撞 ≤3%、刹停下降。
+- **配方**：`fb_scale=100`（>100 mm 全增益，近目标最低 0.2 倍）；`fb_fallback=0.5`（全拒时半速 DLS 一步，认证 `qe+fb1` 单点无碰）。n=128，safety=True。
+- **对照**：轮次 6（gain 1.2、无衰减、无兜底：23.4% / 1.6% / 0.454 / 31.4 / 973 ms）。
+- **指标**：
+
+| 配置 | 到达 | 碰撞 | ratio2s | 刹停/题 | 墙钟/题 |
+|---|---|---|---|---|---|
+| decay + fallback (gain 1.2) | 7.0% | 57.8% | 0.506 | 45.1 | 1166 ms |
+| decay only (gain 1.2) | 9.4% | 1.6% | 0.454 | 29.6 | 1106 ms |
+| no-decay + fallback (gain 1.2) | 21.1% | 57.8% | 0.506 | 46.8 | 1063 ms |
+| gain 1.0 + decay + fallback | 4.7% | 55.5% | 0.515 | 37.2 | 939 ms |
+
+- **结论**：两个改动都失败。① 衰减使接近目标时的收敛变慢，到达从 23.4% 掉到 9.4%；② 兜底绕过安全层的多候选选择，碰撞从 1.6% 拉到 **57.8%**（仅单点认证、且执行 3 步同向动作，危险），必须清除。保留参数但默认关闭（`fb_scale=0, fb_fallback=0`），历史最佳配置（轮次 6）可复现。
+- **过程 bug（自造）**：衰减代码曾用变量名 `g` 覆盖 rollout 的随机数生成器，导致 `randn` 报错；改名 `gdec` 后正常——记录以免误判为模型问题。
+- **下一步**：DAgger 第 2 轮——采集时加入 fb_gain + safety，让训练分布 = 部署分布（1 轮，15000 步微调，约 1 小时）。按目标要求先向用户确认。
+
+## 轮次 8：部署分布 DAgger 第 2 轮（exp: `exp/dagger-deploy`，边际改善）
+
+- **假设**：第 1 轮 DAgger 用纯策略轨迹采集，与部署分布（反馈 + 安全层）不一致；用部署分布采集可让模型学到刹停/反馈下的正确动作。
+- **判据**：部署口径 reach > 23.4%（轮次 6）或刹停显著下降且到达不降。
+- **配方**：`ml.dagger.collect --fb_gain 1.2 --safety 1`（2000 题 → 637 起点，部署分布）→ 老师重规划 → 打包 → 从 `base_dag1/best.pt` 微调 15000 步（配置 base_dag2，lr 3e-4）。
+- **对照**：base_dag1/best.pt（轮次 6 历史最佳）；纯策略 eval 见训练日志。
+- **指标（部署口径，n=128，safety=True）**：
+
+| 模型 | gain | 到达 | 碰撞 | ratio2s | 刹停/题 | 墙钟/题 |
+|---|---|---|---|---|---|---|
+| dag2 best | 1.0 | 21.9% | 1.6% | 0.485 | **18.9** | **905 ms** |
+| dag2 best | 1.2 | 22.7% | 1.6% | 0.491 | 25.9 | 922 ms |
+| dag1 best | 1.0 | 20.3% | 2.3% | 0.480 | 21.9 | 944 ms |
+| dag1 best（轮次 6） | 1.2 | **23.4%** | 1.6% | **0.454** | 31.4 | 953 ms |
+
+- **结论**：部署分布 DAgger 把刹停降 18–40%、时延降 ~31 ms，但到达率未突破 23% 平台（-0.7 pp），属边际权衡改善；历史最佳到达仍是 dag1+gain1.2（23.4%）。
+- **下一步**：试 replan=empty（r=0 规划，让反馈逐步生效）与安全层候选 K=16（减少全拒刹停）。
+
+## 轮次 9：replan=empty（队列空时规划、r=0）/ K=16 安全候选（exp: `exp/dagger-deploy`，新历史最佳）
+
+- **假设**：replan='empty'（每次队列空时规划、无前缀 r=0）比默认 r=3 更适合反馈混合。K=16 给安全层更多候选、减少全拒。
+  （更正：replan='empty' 仍是每 3 步规划一次——队列空才规划，commit 3 步；收益来自 r=0 无前缀，不是规划频率。）
+- **判据**：部署口径 reach > 23.4% 且碰撞 ≤1.6%、刹停/时延不恶化。
+- **配方**：dag2 best；`replan='empty'`（每次 r=0 规划）；`K=16`。n=128，safety=True。
+- **对照**：轮次 8（dag2+gain1.2：22.7% / 1.6% / 0.491 / 25.9 / 922 ms）。
+- **指标**：
+
+| 配置 | 到达 | 碰撞 | ratio2s | 刹停/题 | 墙钟/题 |
+|---|---|---|---|---|---|
+| **gain1.2 + replan=empty** | **26.6%** | **0.8%** | **0.453** | **20.6** | **845 ms** |
+| gain1.2 + K=16 | 21.1% | 1.6% | 0.451 | 19.4 | 1629 ms |
+| gain1.0 + K=16 | 21.9% | 4.7% | 0.506 | 14.6 | 1588 ms |
+
+- **结论**：**replan=empty（r=0）全面改善**（到达 +3.9 pp、碰撞 1.6→0.8%、刹停 25.9→20.6、时延 922→845 ms），成为**新历史最佳**。K=16 无收益且时延翻倍（1629 ms），淘汰。
+- **下一步**：replan=empty 下重扫增益（0.8/1.0/1.5/2.0），找新最优。
+
+## 轮次 10：replan=empty（r=0）下的增益重扫（exp: `exp/dagger-deploy`，新历史最佳）
+
+- **假设**：r=0 规划下，最优增益会上移。
+- **判据**：reach > 26.6%（轮次 9）且碰撞 ≤1.6%；同时比较刹停/时延。
+- **配方**：dag2 best，`replan='empty'`，gain ∈ {0.8, 1.0, 1.2, 1.5, 2.0}，safety=True，n=128。
+- **对照**：轮次 9（gain 1.2：26.6% / 0.8% / 0.453 / 20.6 / 845 ms）。
+- **指标**：
+
+| gain | 到达 | 碰撞 | ratio2s | 刹停/题 | 墙钟/题 |
+|---|---|---|---|---|---|
+| 0.8 | 21.9% | 2.3% | 0.505 | 11.3 | 801 ms |
+| 1.0 | 22.7% | **0.0%** | 0.489 | 15.2 | 810 ms |
+| 1.2 | 26.6% | 0.8% | 0.453 | 20.6 | 845 ms |
+| **1.5** | **28.9%** | 0.8% | **0.411** | 28.5 | 844 ms |
+| 2.0 | 28.9% | 0.8% | 0.414 | 44.9 | 914 ms |
+
+- **结论**：到达在 gain 1.5 封顶（28.9%），2.0 无收益且刹停翻倍（44.9）。**按到达优先/碰撞 ≤3%：历史最佳 = gain 1.5 + replan=empty（28.9% / 0.8% / 0.411 / 28.5 / 844 ms）**；按碰撞优先：gain 1.0（22.7% / 0.0% / 0.489 / 15.2 / 810 ms）。n=128 的差异约 3–4 题，需 n=256 复核。
+- **下一步**：n=256 复核 gain 1.0 / 1.2 / 1.5；若平台稳定，再决定是否 DAgger 第 3 轮（采集用新部署配置）。
+
+## 轮次 11：n=256 复核（发现前 128 题偏难）
+
+- **假设**：轮次 10 的 n=128 差异含样本偏差，需扩大样本复核。
+- **判据**：reach 排名与轮次 10 一致、碰撞 ≤3%；若差异大则以 n=256 为准。
+- **配方**：dag2 best，`replan='empty'`，safety=True，gain ∈ {1.0, 1.2, 1.5}，n=256。
+- **对照**：轮次 10（n=128：22.7/26.6/28.9%）。
+- **指标**：
+
+| gain | n=128 到达 | **n=256 到达** | 碰撞 | ratio2s | 刹停/题 | 墙钟/题 |
+|---|---|---|---|---|---|---|
+| 1.0 | 22.7% | **31.6%** | 0.8% | 0.428 | 15.0 | 748 ms |
+| 1.2 | 26.6% | **34.8%** | 1.2% | 0.392 | 18.6 | 752 ms |
+| 1.5 | 28.9% | **36.7%** | 1.6% | 0.323 | 27.4 | 760 ms |
+
+- **结论**：前 128 题显著偏难；n=256 上 **gain 1.5 + replan=empty = 到达 36.7% / 碰撞 1.6% / ratio2s 0.323 / 刹停 27.4 / 760 ms**（新历史最佳）。gain 1.0 更保守（31.6% / 碰撞 0.8% / 刹停 15.0）。排名与 n=128 一致（1.5 > 1.2 > 1.0）。
+- **下一步**：n=512 复核 gain 1.2/1.5；随后评估 DAgger 第 3 轮（部署分布采集）与监控页回写。
+
+## 轮次 12：n=512 复核（稳定结论）
+
+- **假设**：n=256 的 34.8–36.7% 需在更大样本上确认。
+- **判据**：reach 与 n=256 差异 <5 pp、碰撞 ≤3%。
+- **配方**：dag2 best，`replan='empty'`，safety=True，gain ∈ {1.2, 1.5}，n=512。
+- **对照**：轮次 11（n=256：34.8 / 36.7%）。
+- **指标**：
+
+| gain | n=256 到达 | **n=512 到达** | 碰撞 | ratio2s | 刹停/题 | 墙钟/题 |
+|---|---|---|---|---|---|---|
+| 1.2 | 34.8% | **32.6%** | 1.0% | 0.435 | 18.6 | 722 ms |
+| 1.5 | 36.7% | **33.4%** | 1.0% | 0.399 | 28.1 | 738 ms |
+
+- **结论**：n=512 稳定在 **33% 左右**（n=256 略乐观）；**历史最佳（n=512，部署口径）= gain 1.5 + replan=empty：到达 33.4% / 碰撞 1.0% / ratio2s 0.399 / 刹停 28.1 / 738 ms**。保守版 gain 1.2：32.6% / 1.0% / 0.435 / 18.6 / 722 ms（刹停少 1/3）。
+- **监控页回写**：`ml/monitor.py` 新增 `/api/explore`（读 docs/探索日志.md），`ml/monitor.html` 新增「闭环探索日志」卡片；Edge headless 截图确认渲染正常（http://127.0.0.1:8100）。
+- **下一步**：候选选择器（consist/value/first）与 K=4 在反馈+每步重规划下是否影响到达/刹停。
+
+## 轮次 13：选择器 / K / 失败模式（exp: `exp/dagger-deploy`）
+
+- **假设**：反馈混合下，候选选择器与候选数 K 会影响到达/时延；失败模式可指导下一步。
+- **判据**：reach > 36.7% 或时延显著下降；同时报告 time_ok_1p3。
+- **配方**：dag2 best，replan='empty'，gain 1.5，safety=True，n=256。
+- **对照**：轮次 11/12（consist K=8：36.7%）。
+- **指标**：
+
+| 配置 | 到达 | 碰撞 | ratio2s | 刹停/题 | 墙钟/题 |
+|---|---|---|---|---|---|
+| consist K=8 | 36.7% | 1.6% | 0.323 | 27.4 | 764 ms |
+| value K=8 | 35.9% | 1.6% | 0.334 | 29.4 | 1063 ms |
+| first K=8 | 36.3% | 1.2% | 0.338 | 28.1 | 780 ms |
+| K=6 | 35.9% | 1.6% | 0.353 | 28.6 | 627 ms |
+| K=4 | 31.6% | 1.2% | 0.396 | 32.6 | 482 ms |
+
+- **失败模式（n=256，consist K=8）**：失败 149 题中 **碰撞仅 3 题（1.2%）、超时无碰撞 146 题（57.0%）**；失败题终点误差 p50 140 mm；`time_ok_1p3` 仅 **13.3%**；成功题 t_done p50 2.74 s（时限 p50 3.4 s）；刹停 27.4 次/题。
+- **结论**：选择器无差别（consist 略优）；K=8 到达最佳，K=6 省 18% 时延（到达 -0.8 pp）。**当前真正的瓶颈是时间效率（频繁刹停→超时），不是碰撞**。§9.2 的「用时 ≤ 老师×1.3」当前只有 13.3%。
+- **下一步**：每步重规划下，安全层只需认证第 1 步（现在验 3 步，过度保守→全拒→刹停）；改 `safety_steps=1` 验证能否在保持低碰撞的同时大幅减少刹停。
+
+## 轮次 14：部分安全前缀（exp: `exp/dagger-deploy`，刹停大降）
+
+- **假设**：安全层现在要求 3 步全安全才执行，候选只要第 2–3 步有碰撞就全拒刹停；改为「执行到第一个不安全步为止」可减少刹停。
+- **判据**：刹停显著下降、到达不降、碰撞 ≤3%。
+- **配方**：dag2 best，replan='empty'，gain 1.5，safety=True，`safety_partial=1`；n=256。
+- **对照**：全窗口（轮次 11/13：36.7% / 1.6% / 0.323 / 27.4 / 775 ms）。
+- **指标**：
+
+| 安全层 | 到达 | time_ok_1p3 | 碰撞 | ratio2s | 刹停/题 | 墙钟/题 |
+|---|---|---|---|---|---|---|
+| 3 步全安全 | 36.7% | 13.3% | 1.6% | 0.323 | 27.4 | 775 ms |
+| **部分安全前缀** | **38.3%** | 13.7% | 1.6% | **0.308** | **8.6** | 770 ms |
+
+- **结论**：刹停 **27.4→8.6（-69%）**、到达 +1.6 pp、碰撞不变——**部分安全前缀有效**（新最佳：38.3% / 1.6% / 0.308 / 8.6 / 770 ms）。但 `time_ok_1p3` 仍 13.7%：说明超时主因不是刹停，而是**执行粒度**——部分前缀的填充零步仍在消耗时间。
+- **下一步**：commit_n=1（每次只提交 1 步、每步规划，无填充步），验证时间效率。
+
+## 轮次 15：每步规划（commit_n=1）（exp: `exp/dagger-deploy`，新历史最佳）
+
+- **假设**：部分前缀的填充零步仍在消耗时间；每次只提交 1 步、每步重新规划可消除填充、提升时间效率。
+- **判据**：time_ok_1p3 显著上升、到达不降、碰撞 ≤3%。
+- **配方**：dag2 best，replan='empty'，gain 1.5，safety=True，`safety_partial=1, commit_n=1`；n=256。
+- **对照**：commit_n=3 部分前缀（轮次 14：38.3% / 13.7% / 1.6% / 0.308 / 8.6 / 770 ms）。
+- **指标**：
+
+| commit_n | 到达 | time_ok_1p3 | 碰撞 | ratio2s | 刹停/题 | 墙钟/题 |
+|---|---|---|---|---|---|---|
+| 3 | 38.3% | 13.7% | 1.6% | 0.308 | 8.6 | 770 ms |
+| **1** | **41.8%** | **21.5%** | 2.3% | **0.259** | 26.9 | 967 ms |
+
+- **结论**：每步规划把到达推到 **41.8%**、时间效率 **13.7→21.5%**、精度 ratio2s **0.259**；代价：碰撞 1.6→2.3%（仍 <3%）、刹停计数回升（每步都判断）、时延 +26%。**新历史最佳（n=256，部署口径）：41.8% / 2.3% / 0.259 / 21.5% / 967 ms**。
+- **注**：commit_n=1 的推理频率是 3 倍，真机需核对 §9.2 的 P99 <20 ms 预算（当前桌面 12.58 ms/次）。
+- **下一步**：n=512 复核；若稳定则收尾（更新最佳、监控页、分支清理）。
+
+## 轮次 16：n=512 复核每步规划（稳定结论）
+
+- **假设**：轮次 15 的 41.8%（n=256）需更大样本确认。
+- **判据**：reach 与 n=256 差异 <5 pp、碰撞 ≤3%。
+- **配方**：dag2 best，replan='empty'，gain 1.5，safety=True，safety_partial=1，commit_n=1；n=512。
+- **对照**：轮次 15（n=256：41.8% / 21.5% / 2.3% / 0.259 / 967 ms）。
+- **指标**：到达 **40.8%**、time_ok_1p3 **25.0%**、碰撞 **2.1%**、ratio2s **0.309**、刹停 25.3、墙钟 **852 ms/题**。
+- **结论**：稳定。**历史最佳（n=512，部署口径）= 40.8% 到达 / 2.1% 碰撞 / ratio2s 0.309 / time_ok 25.0% / 852 ms/题**；从基线 0% 到达提升 40.8 pp。相对 §9.2（98%、碰撞 0、用时≤老师×1.3）仍有大差距，但机理已成立。
+- **下一步**：每步规划下重扫增益（1.8/2.2/3.0），看时间效率是否继续提升；随后收尾。
+
+## 轮次 17：每步规划下的更大增益（exp: `exp/dagger-deploy`）
+
+- **假设**：每步规划下更大的反馈增益可进一步提升到达与时间效率。
+- **判据**：time_ok 上升、到达不降、碰撞 ≤3%。
+- **配方**：dag2 best，replan='empty'，commit_n=1，safety_partial=1，gain ∈ {1.8, 2.2, 3.0}，n=256。
+- **对照**：轮次 15（gain 1.5：41.8% / 21.5% / 2.3% / 0.259 / 26.9 / 967 ms）。
+- **指标**：
+
+| gain | 到达 | time_ok_1p3 | 碰撞 | ratio2s | 刹停/题 | 墙钟/题 |
+|---|---|---|---|---|---|---|
+| **1.8** | **43.8%** | 28.9% | 1.6% | 0.216 | 40.0 | 956 ms |
+| 2.2 | 41.0% | **32.4%** | 2.0% | 0.174 | 64.4 | 976 ms |
+| 3.0 | 36.3% | 32.8% | 0.8% | **0.153** | **123.2** | 994 ms |
+
+- **结论**：gain 1.8 到达最高（43.8%）；2.2/3.0 精度与时间效率更好但到达下降、刹停暴涨（3.0 达 123 次/题，过冲）。**历史最佳按到达优先（碰撞 ≤3%）：gain 1.8 = 到达 43.8% / 碰撞 1.6% / ratio2s 0.216 / time_ok 28.9% / 956 ms（n=256）**。保守/时间优先可选 2.2。
+- **下一步**：n=512 复核 gain 1.8；随后收尾。
+
+## 轮次 18：n=512 复核 gain 1.8（收尾）
+
+- **假设**：轮次 17 的 43.8%（n=256）需更大样本确认。
+- **判据**：reach 与 n=256 差异 <5 pp、碰撞 ≤3%。
+- **配方**：dag2 best，replan='empty'，commit_n=1，safety_partial=1，gain 1.8；n=512。
+- **对照**：轮次 17（n=256：43.8% / 28.9% / 1.6% / 0.216 / 40.0 / 956 ms）；轮次 16（gain 1.5 n=512：40.8% / 25.0% / 2.1% / 0.309 / 25.3 / 852 ms）。
+- **指标**：到达 **42.2%**、time_ok_1p3 **29.1%**、碰撞 **2.9%**、ratio2s **0.270**、刹停 37.4、墙钟 **870 ms/题**。
+- **结论**：gain 1.8 在 n=512 稳定（42.2%），到达/时间效率优于 gain 1.5（+1.4 pp / +4.1 pp），但碰撞 2.1→2.9%（贴近 3% 线）、刹停 25.3→37.4。**历史最佳（到达优先，n=512）= gain 1.8；碰撞优先 = gain 1.5**。
+- **下一步**：本轮探索收尾（监控页已回写）；进入大规模训练需用户确认 §9.2 锚点。
+
+## 轮次统计
+
+- 连续无实质进展轮数：0（轮次 9–17 持续有实质进展）。
+- **历史最佳（部署口径，n=512）**：`ml/runs/base_dag2_dag1/best.pt` + `K=8, safety=True, replan='empty', fb_gain=1.8, safety_partial=1, commit_n=1` → **到达 42.2%、碰撞 2.9%、ratio2s 0.270、time_ok_1p3 29.1%、刹停 37.4/题、仿真墙钟 870 ms/题**；推理 12.58 ms/次（B=64,K=8，桌面 3090 均值，P99 未测）。
+- 保守版（碰撞优先）：gain 1.5 → 40.8% / 2.1% / 0.309 / 25.0% / 25.3 / 852 ms。
+- 与基线对比：到达 **0→42.2%**、碰撞 **99.6→2.9%**、ratio2s **0.755→0.270**；代价：DAgger 微调使开环 ol_fk 5.98→15.7 mm。
+- 相对 §9.2：到达 42.2% vs ≥98%（差距大）；碰撞 2.9% vs 0（接近策略单独 <3% 线）；用时 ≤老师×1.3 为 29.1%；推理+认证 P99 未测（桌面均值 12.58 ms，预算 20 ms）。
+- 未进入大规模训练（需用户确认 §9.2 锚点）。
+- 训练方法探索（轮次 19–22）：APG（管线修复、尺度失控）、反馈蒸馏（未内化）、DAgger-3（39.5%）、冻结编码器（41.8%）——均未超过 dag2 基线 43.8%。
+
+## 轮次 19：APG 闭环策略梯度试跑（exp: `exp/dagger-deploy`，管线修复但暂不采用）
+
+- **假设**：用闭环目标/碰撞损失直接微调策略（把"朝目标走"内化），减少对执行层反馈的依赖。
+- **判据**：纯策略闭环 success 上升、碰撞铰链下降；部署口径（+反馈/安全层）不降。
+- **配方**：`ml.apg.apg_finetune --init base_dag2_dag1/best.pt --steps 2`（先冒烟；原计划 500 步）。
+- **修复的两个既有 bug**（APG 此前从未实测）：
+  1. `kin_torch._cat_gaps` 的 `p['b'] += s` 是 in-place，而 `b` 被 autograd 索引反向图引用 → backward 报 version 错；改为 `p['b'] = p['b'] + s`。
+  2. APG 段边界 `queue.detach()` 让下一段执行的动作无梯度；改为只 detach 状态并重置队列（下一 plan 走 r=0 重新提交）。
+- **指标（2 步冒烟）**：EVAL0（纯策略）success 0 / 碰撞 31.8%；第 0 步 col（碰撞铰链均值）**409508**、gnorm 473119（被裁剪）、tgt 206.6、smooth 645；EVAL@2 success 0 / 碰撞 26.0%。
+- **结论**：管线已能跑，但**损失尺度失控**（碰撞铰链均值 40 万，远大于 margin 3mm 的合理量级）；且 APG 展开是纯策略口径（无反馈/安全层/每步规划），与当前部署形态不一致。**暂不采用**，转「反馈蒸馏」。
+- **下一步**：反馈蒸馏——用最终部署配置收集 (特征, 复合动作=模型输出+目标反馈) 样本，微调模型把反馈内化。
+
+## 轮次 20：反馈蒸馏（exp: `exp/dagger-deploy`，负结论）
+
+- **假设**：用最终部署配置收集 (特征, 复合动作 = 模型输出 + 目标反馈) 样本，微调后模型可内化反馈（部署时降低/去掉反馈仍能到目标）。
+- **判据**：部署口径下 `fb_gain=0~0.9` 时 success 接近/超过基线（43.8%，n=256），且 time_ok 不降。
+- **配方**：`rollout` 加 collect 钩子（与部署一致：safety、replan='empty'、safety_partial=1、commit_n=1、fb_gain=1.8）收集 500 题 → **17.7 万样本**；`train.py --config distill.json`（lr 1e-4、3000 步、w_value=0、w_sub=0、w_fk=0.1、w_smooth=0.01）+ 主数据 BC 锚定，从 dag2 best 微调。
+- **对照**：dag2 + gain 1.8（n=256：43.8% / 28.9% / 1.6% / 0.216 / 40.0 / 956 ms）。
+- **指标（n=256，部署口径）**：
+
+| 模型 | gain | 到达 | time_ok_1p3 | 碰撞 | ratio2s | 刹停/题 | 墙钟/题 |
+|---|---|---|---|---|---|---|---|
+| distill | 0.0 | **0.8%** | — | 0.0% | 0.708 | 2.1 | 762 ms |
+| distill | 0.9 | 36.7% | 10.5% | 1.2% | 0.421 | 12.4 | 916 ms |
+| distill | 1.8 | 43.4% | 27.7% | 2.0% | 0.228 | 47.4 | 925 ms |
+| dag2（基线） | 1.8 | 43.8% | 28.9% | 1.6% | 0.216 | 40.0 | 956 ms |
+
+- **结论**：**反馈未内化**——`gain=0` 时到达仅 0.8%（与基线纯策略一样）；`gain=1.8` 时与基线持平（43.4 vs 43.8，差约 1 题），碰撞/刹停略差。蒸馏样本占比仅 8.5%、标签仍以主数据增量为主，模型没有学会"看目标修正"。此配方不成立。
+- **下一步**：与最终部署配置一致的 DAgger 第 3 轮（采集时已用 safety+fb 1.2，但仍是 3 步提交/全窗口；现在部署是每步规划+部分前缀）。
+
+## 轮次 21：DAgger-3（最终部署配置采集）（exp: `exp/dagger-deploy`，负结论）
+
+- **假设**：用最终部署配置（每步规划 + 部分安全前缀 + 反馈 gain1.8 + 安全层）采集，训练分布与部署完全一致，可继续提升。
+- **判据**：部署口径 success > 43.8%（dag2 基线，n=256）。
+- **配方**：`collect --fb_gain 1.8 --safety 1 --replan empty --commit_n 1 --safety_partial 1`（500 题、73 起点）→ 老师重规划 → 打包 → 从 dag2 best 微调 15000 步（lr 3e-4，配置 base_dag3）。
+- **对照**：dag2 + gain1.8（n=256：43.8% / 28.9% / 1.6% / 0.216 / 40.0 / 956 ms）。
+- **指标（n=256，部署口径）**：
+
+| 模型 | gain | 到达 | time_ok_1p3 | 碰撞 | ratio2s | 刹停/题 | 墙钟/题 |
+|---|---|---|---|---|---|---|---|
+| dag3 | 1.5 | 39.8% | 16.0% | 1.2% | 0.360 | 14.7 | 912 ms |
+| dag3 | 1.8 | 39.5% | 21.1% | 1.2% | 0.320 | 24.5 | 935 ms |
+| dag2（基线） | 1.8 | **43.8%** | **28.9%** | 1.6% | **0.216** | 40.0 | 956 ms |
+
+- **结论**：DAgger-3 到达 **-4.3 pp**（39.5 vs 43.8），time_ok -7.8 pp；碰撞/刹停略好但主指标下降。开环进一步退化（ol_fk 19.5 mm vs dag2 15.7）。**负结论**：继续微调（15000 步 lr 3e-4）会退化主分布，训练侧收益递减。
+- **下一步**：冻结编码器、只微调解码器（假设：微调退化来自表征漂移），用同一份数据与预算验证。
+
+## 轮次 22：冻结编码器微调（exp: `exp/dagger-deploy`，负结论）
+
+- **假设**：微调导致的分布退化来自表征漂移；冻结编码器（enc + enc_norm）、只调解码器/头，可保留开环精度同时吸收 DAgger-3 的部署分布样本。
+- **判据**：部署口径 success > 43.8%（dag2）且 ol_fk 不退化（≤16 mm）。
+- **配方**：`train.py --freeze-enc`（优化器只含 requires_grad 参数），数据 = 主数据 + DAgger-3 样本，lr 3e-4、5000 步，从 dag2 best 初始化；n=256 部署口径。
+- **对照**：dag2 + gain1.8（43.8% / 28.9% / 1.6% / 0.216 / 40.0 / 956 ms）。
+- **指标**：
+
+| 模型 | gain | 到达 | time_ok_1p3 | 碰撞 | ratio2s | 刹停/题 | 墙钟/题 | ol_fk |
+|---|---|---|---|---|---|---|---|---|
+| 冻结编码器 | 1.5 | 39.8% | 22.3% | 1.2% | 0.293 | 25.4 | 936 ms | 15.8 mm |
+| 冻结编码器 | 1.8 | 41.8% | 26.2% | 2.3% | 0.274 | 41.4 | 940 ms | 15.8 mm |
+| dag2（基线） | 1.8 | **43.8%** | **28.9%** | 1.6% | **0.216** | 40.0 | 956 ms | 15.7 mm |
+
+- **结论**：冻结编码器**确实减缓了开环退化**（ol_fk 15.8 vs 全微调 19.5），但部署到达仍比 dag2 低 2.0 pp——**无提升**。至此训练侧四种方法（APG、反馈蒸馏、DAgger-3、冻结编码器）均未超过 dag2 基线（43.8%），训练侧在当前数据/预算下已到平台。
+- **下一步（超出小规模范围，需确认）**：更大规模训练（24000 步从头 + 8000×2 轮 DAgger）或改特征/架构（目标条件化、状态扰动训练需重算特征）。
+
+## 轮次 23：实时性口径评估（exp: `exp/dagger-deploy`）
+
+- **背景**：870 ms/题是仿真里整条轨迹的总时长（150–300 次规划累加），不是控制延迟。实时口径按 §9.2：每次「推理 + 安全认证」P99 < 20 ms（50 Hz，DT=0.02 s）。
+- **假设**：单次规划延迟可以压到 20 ms 以内。
+- **判据**：B=1 单题、单次规划（features + sample_k K=8 + 目标反馈 + 安全层）P99 < 20 ms。
+- **优化**：① DLS 目标反馈的 6 次串行有限差分改为一次批量 FK（数值差 ≤0.013°，DLS 25→10–17 ms）；② 单题安全层按候选早停（首个全安全候选即停，16 点→2–4 点）。
+- **指标（桌面 RTX 3090，B=1，Python；GPU 时钟抖动使 p50 在 40–65 ms 间波动）**：单次规划 **p50 40–65 ms / p99 70–80 ms**；分解：features 10–17 ms、推理 8–14 ms、DLS 反馈 10–17 ms、安全层 10–17 ms。
+- **实时频率扫描（n=256，部署口径，gain1.8 + safety + partial）**：
+
+| 规划节奏 | 控制周期 | 到达 | time_ok_1p3 | 碰撞 | 刹停/题 |
+|---|---|---|---|---|---|
+| 每步（commit_n=1） | 20 ms | **42.2%（n=512）** | 29.1% | 2.9% | 37.4 |
+| 每 3 步（commit_n=3） | 60 ms | 36.3% | 16.4% | 1.6% | 14.3 |
+| 每 6 步（commit_n=6） | 120 ms | 14.8% | 3.9% | 2.0% | 6.1 |
+| 每 10 步（commit_n=10） | 200 ms | 2.0% | — | 1.2% | 3.7 |
+
+- **结论**：**当前方案不满足 50 Hz 实时**（单次 40–80 ms，超预算 2–4 倍）；42.2% 的成绩依赖每步规划（20 ms 节奏）。实时可行节奏下：每 3 步 → 36.3%（p50 有余量、p99 需继续优化），每 6 步 → 14.8%。**实时性是当前方案的硬约束，不是仿真耗时问题**。
+- **下一步（需确认）**：① 浏览器 ONNX 路径实测（推理 P99 历史 10–12 ms；特征/安全层在 JS 端需 `tests/policy_bench.cjs` 实测）；② 特征缓存 + 安全层粗筛，目标单次 P99 < 20 ms；③ 或接受「每 3 步规划」的 60 ms 周期（36.3%）。
+
+## 轮次 24：实时性优化与新方法（exp: `exp/dagger-deploy`）
+
+- **目标**：准确率更高 + 效率满足 50 Hz（20 ms 控制步）。
+- **① 混合节奏（规划每 3 步 + 执行时每步反馈）——负结论**：plan fb1.8 + exec fb1.8 → 36.3%（与纯规划反馈的 commit_n=3 完全相同）；plan fb0 + exec fb1.8 → 仅 1.6%。执行时反馈不带来额外收益（规划时的反馈已是主要贡献），此捷径不成立。
+- **② 特征几何优化（有效）**：特征只用 8 组间隙（GP），但原实现算全部 49 组（67256 簇对）。新增 `Kin.gm_groups(q, GP, cap)`：按 7 连杆组对过滤簇对（簇索引 → `cl_g` → 组对 min/max），只算 8 组。
+  - 数值验证：与 `gaps()['gm'][:, a*7+b]` 逐项一致（diff 0）。
+  - 延迟：gm 计算 10.4→**7.1 ms**（p50），单次规划省约 3 ms。
+- **③ 浏览器部署**：导出 `webapp/models/traj_policy.onnx`（dag2 best，19.8 MB，对拍误差 3.1e-6，act_scale 1.0）；`ik-policy.js` 加全程目标反馈（`fbGain`）+ `commit` 可配；`ik-policy-glue.js` 支持 `?fb=&commit=`（默认 fb=1.8、commit=3）。
+  - JS bench（Node，10 题，fb1.8+commit1）：到达 0、**刹车率 47.3%**（每 2 次规划刹停一次）、planP50 43.8 / P99 70.5 ms。JS 安全层（5 mm 护栏 + 距离认证）比 Python（0.5 mm gap）保守，反馈+每步规划被大量拒绝。
+- **④ 实时口径的关键认识**：部署形态是**异步规划**（tick 20 ms 只执行队列；`plan()` 后台跑），所以 50 Hz 的约束是「tick < 20 ms + 规划在队列耗尽前完成」，不是「单次规划 < 20 ms」。
+  - JS 的 tick 只做队列执行 + 投影/碰撞检查（~1.5–3 ms）→ 50 Hz 可行；
+  - 规划 P99 70 ms → 需要 commit ≥ 4（80 ms 队列）才不饥饿；commit=3（60 ms）会偶发饥饿。
+  - 准确率与规划频率的 trade-off：commit1 42.2%（不可 50Hz）、commit3 36.3%、commit6 14.8%。
+- **下一步**：① 在 commit=3/4 的实时节奏下找准确率提升（候选平均、dag3_fe 冻结编码器、更高 gain）；② 把 gm_groups 同步到 JS（gapMatrix 只算 8 组）；③ 降低 JS 安全层拒绝率（margin/认证预算调参）。
+
+## 轮次 25：实时节奏下的准确率探索 + 推理提速（exp: `exp/dagger-deploy`）
+
+- **目标**：在 50 Hz 可行的节奏（commit=3，60 ms 周期）下提升准确率。
+- **效率优化（有效）**：
+  - `Kin.gm_groups`：特征只算 8 组间隙（数值 diff 0），features 10.4→**7.1 ms**；
+  - **onnxruntime CPU 推理 3.9 ms**（PyTorch 11.1 ms，部署端本来就是 ONNX）；
+  - 单次规划 ≈ 7.1（features）+3.9（推理）+11（DLS）+8（安全）+2 ≈ **32 ms p50 / ~45 ms p99**；
+  - 异步部署下 tick（执行步 + 碰撞检查）2–3 ms → **50 Hz 控制可行**；commit=3（60 ms 队列）可覆盖规划 p99。
+- **准确率尝试（n=256，commit=3，gain1.8，safety_partial）**：
+
+| 方法 | 到达 | time_ok | 碰撞 | ratio2s | 刹停 |
+|---|---|---|---|---|---|
+| dag2 + consist（基线） | **36.3%** | 16.4% | 1.6% | 0.277 | 14.3 |
+| dag2 + 候选平均（select=average） | 29.7% | 20.3% | 0.4% | 0.432 | 55.9 |
+| 冻结编码器模型（dag3_fe） | 34.4% | 14.8% | 2.0% | 0.332 | 15.8 |
+| dag2 + commit=4 | 28.9% | 8.2% | 3.5% | 0.339 | 10.5 |
+
+- **结论**：候选平均、冻结编码器、更稀疏规划**均未超过 36.3%**。**50 Hz 节奏下的最佳配置 = dag2 + commit=3 + consist + gain1.8 + safety_partial：到达 36.3% / 碰撞 1.6% / ratio2s 0.277**（相对非实时的 42.2% 差 5.9 pp）。
+- **下一步**：若要把实时准确率再拉高，需要把单次规划再压到 ~22 ms 以支持 commit=2（40 ms 周期，预计 ~39%）；或提升模型本身精度（训练侧）。
+
+## 分支清理（2026-10-20）
+
+- `feat/fb-mix`（8e5431c）：反馈混合方案的中间分支，**已验证是 `exp/dagger-deploy` 的祖先**（所有提交都在后者历史里），本地/远端分支删除，内容保留在 exp/dagger-deploy。
+- `feat/abs-target`（217a70b）：绝对目标参数化负结论分支（轮次 3）；打 tag `archive/abs-target` 保留可复现实体后，删除远端分支（本地此前已删）。
+- `backup/pre-deep-squash`、`backup/pre-squash`：历史备份分支，非实验方案，保留未动。
+- 保留：`main`（70654e4）、`exp/dagger-deploy`（39c870c，历史最佳）。

ml/apg/apg_finetune.py

@@ -139,7 +139,10 @@ def main():
                 stats['tgt'] += lt.mean().item()
                 (seg_loss / nseg).backward()
                 seg_loss = torch.zeros((), device=dev)
-                q, qp, queue, prev_d = q.detach(), qp.detach(), queue.detach(), prev_d.detach()
+                # 只 detach 状态并重置队列：段边界下一 plan 走 r=0 重新提交（新图有梯度）；
+                # 沿用旧 queue 会跨过已 backward 的图（二次 backward 报错），也避免整段无梯度
+                q, qp, prev_d = q.detach(), qp.detach(), prev_d.detach()
+                queue = torch.zeros(B, 0, 6, device=dev)
         # BC 锚定
         X, Y, V, SG = data.batch(C['batch'] * 4)
         with torch.autocast('cuda', dtype=torch.bfloat16, enabled=amp):

ml/common/features.py

@@ -52,7 +52,9 @@ def features(kin, q, q_prev, T, R, prefix, prefix_len, sub, sub_flag, gm=None, x
     out.append(sd)
     out.append(sub_flag[:, None].to(dt))
     if gm is None:
-        gm = kin.gaps(q, GAP_CAP, xf)['gm']
+        out.append(kin.gm_groups(q, GP, GAP_CAP) / GAP_CAP)   # 2026-10-20：只算特征用到的 8 组
+        gm = None
+    if gm is not None:
         out.append(torch.stack([gm[:, a * 7 + b].clamp(max=GAP_CAP) / GAP_CAP for a, b in GP], -1))
     f = torch.cat(out, -1)
     assert f.shape[1] == F_DIM, f.shape

ml/common/kin_torch.py

@@ -131,7 +131,8 @@ class Kin:
     def _cat_gaps(parts, starts):
         out = {'gm': torch.cat([p.pop('gm') for p in parts], 0)}
         if 'b' in parts[0]:
-            for p, s in zip(parts, starts): p['b'] += s
+            # 非 in-place：b 会被 autograd 的索引反向图引用（APG 的碰撞铰链梯度路径），+= 会让 backward 报 version 错
+            for p, s in zip(parts, starts): p['b'] = p['b'] + s
             for k in ('b', 'i', 'j', 'gap'): out[k] = torch.cat([p.pop(k) for p in parts])   # 逐键拼、拼完即释放
         return out
 
@@ -201,6 +202,41 @@ class Kin:
         if not pairs: return {'gm': gm.view(B, 49)}
         return {'gm': gm.view(B, 49), 'b': rep_b, 'i': pi, 'j': pj, 'gap': gap}
 
+    def gm_groups(self, q, gp, cap=40.0):
+        """只算指定组对 gp=[(a,b),...] 的最小间隙 [B,len(gp)]（特征用，避免 49 组全量）。
+        数值与 gaps(q,cap)['gm'][:, a*7+b] 一致；组对在碰撞粗对里不存在时返回 cap。"""
+        key = tuple(gp)
+        if getattr(self, '_gp_key', None) != key:
+            m = torch.full((49,), -1, dtype=torch.long, device=q.device)
+            for i, (a_, b_) in enumerate(gp): m[min(a_, b_) * 7 + max(a_, b_)] = i
+            ga, gb = self.cl_g[self.cp_a], self.cl_g[self.cp_b]
+            cg = torch.minimum(ga, gb) * 7 + torch.maximum(ga, gb)   # 簇对 → 7 连杆组对
+            sel = torch.isin(cg, torch.tensor([min(a, b) * 7 + max(a, b) for a, b in gp], device=q.device))
+            self._gp = (m, sel, sel.nonzero(as_tuple=True)[0]); self._gp_key = key
+        self._gp49, sel, idx = self._gp
+        xf = self.cum_xf(q); Rs, Ts = xf; B = q.shape[0]
+        with torch.no_grad():
+            cc = torch.einsum('bkij,kj->bki', Rs[:, self.cl_g], self.cl_c.to(q.dtype)) + Ts[:, self.cl_g]
+            d2 = (cc[:, self.cp_a[idx]] - cc[:, self.cp_b[idx]]).pow(2).sum(-1)
+            keep = d2 <= (self.cp_lim[idx] + cap).pow(2)
+            bb, mm = keep.nonzero(as_tuple=True)
+            del keep, d2, cc
+            cnt = self.cp_cnt[idx][mm]
+            rep_b = torch.repeat_interleave(bb, cnt)
+            off = torch.repeat_interleave(self.cp_start[idx][mm] - torch.cumsum(cnt, 0) + cnt, cnt) + torch.arange(int(cnt.sum()), device=q.device)
+            pidx = off
+        a, b = self.caps_world(q, xf)
+        with torch.no_grad():
+            pi, pj = self.pi[pidx], self.pj[pidx]
+            mid = 0.5 * (a[rep_b, pi] + b[rep_b, pi] - a[rep_b, pj] - b[rep_b, pj])
+            k2 = mid.pow(2).sum(-1) <= (self.pair_bl[pidx] + cap).pow(2)
+            rep_b, pidx, pi, pj = rep_b[k2], pidx[k2], pi[k2], pj[k2]
+        d = seg_seg_dist(a[rep_b, pi], b[rep_b, pi], a[rep_b, pj], b[rep_b, pj])
+        gap = d - self.pair_need[pidx].to(q.dtype)
+        gm = torch.full((B * len(gp),), float(cap), dtype=q.dtype, device=q.device)
+        gm = gm.scatter_reduce(0, rep_b * len(gp) + self._gp49[self.pair_gp[pidx]], gap.clamp(max=cap), reduce='amin', include_self=True)
+        return gm.view(B, len(gp))
+
     def min_gap(self, q, cap=40.0):
         return self.gaps(q, cap)['gm'].min(-1).values
 

ml/configs/base_dag2.json

@@ -0,0 +1,11 @@
+{
+  "model": {"d": 192, "heads": 8, "ff": 768, "enc": 4, "dec": 4},
+  "train": {
+    "batch": 1024, "lr": 1e-3, "warmup": 1000, "steps": 24000, "wd": 0.01, "betas": [0.9, 0.95],
+    "amp": "bf16", "grad_clip": 1.0,
+    "w_mf": 1.0, "w_fk": 0.5, "w_smooth": 0.05, "w_value": 0.1, "w_sub": 0.1,
+    "p_neq": 0.5, "p_edge": 0.1, "p_neq_warm": 5000, "fk_tmax": 0.3, "fk_caps": 96,
+    "ema": 0.999, "aug_pre_drop": 0.15, "aug_pre_sigma": 0.1, "aug_dq_sigma": 0.3,
+    "ckpt_min": 10, "eval_every": 2000, "eval_tasks": 512, "log_every": 50, "patience_evals": 5
+  }
+}

ml/configs/base_dag3.json

@@ -0,0 +1,11 @@
+{
+  "model": {"d": 192, "heads": 8, "ff": 768, "enc": 4, "dec": 4},
+  "train": {
+    "batch": 1024, "lr": 1e-3, "warmup": 1000, "steps": 24000, "wd": 0.01, "betas": [0.9, 0.95],
+    "amp": "bf16", "grad_clip": 1.0,
+    "w_mf": 1.0, "w_fk": 0.5, "w_smooth": 0.05, "w_value": 0.1, "w_sub": 0.1,
+    "p_neq": 0.5, "p_edge": 0.1, "p_neq_warm": 5000, "fk_tmax": 0.3, "fk_caps": 96,
+    "ema": 0.999, "aug_pre_drop": 0.15, "aug_pre_sigma": 0.1, "aug_dq_sigma": 0.3,
+    "ckpt_min": 10, "eval_every": 2000, "eval_tasks": 512, "log_every": 50, "patience_evals": 5
+  }
+}

ml/configs/distill.json

@@ -0,0 +1,41 @@
+{
+  "model": {
+    "d": 192,
+    "heads": 8,
+    "ff": 768,
+    "enc": 4,
+    "dec": 4
+  },
+  "train": {
+    "batch": 1024,
+    "lr": 0.0001,
+    "warmup": 1000,
+    "steps": 3000,
+    "wd": 0.01,
+    "betas": [
+      0.9,
+      0.95
+    ],
+    "amp": "bf16",
+    "grad_clip": 1.0,
+    "w_mf": 1.0,
+    "w_fk": 0.1,
+    "w_smooth": 0.01,
+    "w_value": 0.0,
+    "w_sub": 0.0,
+    "p_neq": 0.5,
+    "p_edge": 0.1,
+    "p_neq_warm": 0,
+    "fk_tmax": 0.3,
+    "fk_caps": 96,
+    "ema": 0.999,
+    "aug_pre_drop": 0.15,
+    "aug_pre_sigma": 0.1,
+    "aug_dq_sigma": 0.3,
+    "ckpt_min": 10,
+    "eval_every": 1000,
+    "eval_tasks": 256,
+    "log_every": 50,
+    "patience_evals": 3
+  }
+}

ml/dagger/collect.py

@@ -28,6 +28,10 @@ def main():
     ap.add_argument('--parts', type=int, default=8); ap.add_argument('--out', required=True)
     ap.add_argument('--bs', type=int, default=64)
     ap.add_argument('--device', default='cuda' if torch.cuda.is_available() else 'cpu')
+    ap.add_argument('--fb_gain', type=float, default=0.0, help='部署分布采集：目标反馈增益（与 rollout 一致）')
+    ap.add_argument('--safety', type=int, default=0, help='部署分布采集：是否开安全层')
+    ap.add_argument('--replan', default='r3'); ap.add_argument('--commit_n', type=int, default=3)
+    ap.add_argument('--safety_partial', type=int, default=0)
     a = ap.parse_args()
     gap_min = float(os.environ.get('MIN_GAP_MM') or 3)
     os.makedirs(a.out, exist_ok=True)
@@ -41,7 +45,8 @@ def main():
     for i in range(0, len(tasks), a.bs):
         tb = tasks[i:i + a.bs]
         with torch.no_grad():
-            _, per = rollout(model, kin, tb, a.device, K=8, safety=False, seed=a.seed * 100003 + i, return_traj=True)
+            _, per = rollout(model, kin, tb, a.device, K=8, safety=bool(a.safety), seed=a.seed * 100003 + i, return_traj=True,
+                            fb_gain=a.fb_gain, replan=a.replan, commit_n=a.commit_n, safety_partial=a.safety_partial)
         tr = per['traj'].to(a.device)                                   # [B,T,6]
         B, Tn, _ = tr.shape
         _, T, R, _, _ = tasks_to_tensors(tb, a.device)

ml/dagger/distill_fb.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+"""反馈蒸馏：用最终部署配置（目标反馈 + 安全层 + 部分前缀 + 每步规划）跑闭环，
+收集 (特征, 复合动作 = 模型输出 + 目标反馈) 样本，供 train.py 微调把反馈内化进策略。
+  PYTHONUTF8=1 python -m ml.dagger.distill_fb --ckpt ml/runs/base_dag2_dag1/best.pt --n 500 \
+      --fb_gain 1.8 --out ml/data/samples_fbdistill
+输出可直接被 ml.data.Samples 读取（collect.X/Y/V/SG/TID.npy；无 meta = act_scale 1.0，与主数据一致）。
+动作标签 = 候选动作（含反馈）的归一化 act（/STEP，clamp ±1），与主数据同口径。
+"""
+import argparse, os, random
+import numpy as np
+import torch
+
+from ml.common.ckpt import load_policy
+from ml.common.features import STEP
+from ml.common.kin_torch import Kin
+from ml.data import load_tasks
+from ml.sim.closed_loop import rollout
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument('--ckpt', required=True); ap.add_argument('--n', type=int, default=500)
+    ap.add_argument('--bs', type=int, default=64); ap.add_argument('--fb_gain', type=float, default=1.8)
+    ap.add_argument('--samples', default='ml/data/samples'); ap.add_argument('--out', required=True)
+    ap.add_argument('--device', default='cuda' if torch.cuda.is_available() else 'cpu'); ap.add_argument('--seed', type=int, default=1)
+    a = ap.parse_args()
+    dev = a.device
+    model, _ = load_policy(a.ckpt, dev)
+    kin = Kin(device=dev)
+    pool = [t for t in load_tasks([a.samples]) if t['split'] == 'train' and t.get('cat') not in ('D',)]
+    random.Random(a.seed).shuffle(pool); tasks = pool[:a.n]
+    stp = torch.tensor(STEP)   # collect 返回 CPU 张量，标签换算也在 CPU
+    X, Y, TID = [], [], []
+    for i in range(0, len(tasks), a.bs):
+        ch = tasks[i:i + a.bs]
+        coll = []
+        with torch.no_grad():
+            rollout(model, kin, ch, dev, K=8, safety=True, replan='empty', fb_gain=a.fb_gain,
+                    safety_partial=1, commit_n=1, seed=a.seed * 100003 + i, collect=coll)
+        for f, ac in coll:
+            X.append(f.numpy()); Y.append((ac / stp).clamp(-1, 1).numpy())
+        ncol = sum(f.shape[0] for f, _ in coll)
+        TID.append(np.arange(ncol, dtype=np.int32) + i * 100000)
+        print(f'[distill] {i + len(ch)}/{len(tasks)} tasks, samples {sum(x.shape[0] for x in X)}', flush=True)
+    os.makedirs(a.out, exist_ok=True)
+    X = np.concatenate(X); Y = np.concatenate(Y); TID = np.concatenate(TID)
+    n = X.shape[0]
+    np.save(os.path.join(a.out, 'collect.X.npy'), X.astype(np.float32))
+    np.save(os.path.join(a.out, 'collect.Y.npy'), Y.astype(np.float32))
+    np.save(os.path.join(a.out, 'collect.V.npy'), np.full(n, 0.5, np.float32))
+    np.save(os.path.join(a.out, 'collect.SG.npy'), np.zeros((n, 13), np.float32))
+    np.save(os.path.join(a.out, 'collect.TID.npy'), TID)
+    print(f'done: {n} samples, X {X.shape}, Y {Y.shape}', flush=True)
+
+
+if __name__ == '__main__':
+    main()

ml/dagger/run.sh

@@ -24,7 +24,7 @@ for ((r=1; r<=R; r++)); do
   SAMPLES="$SAMPLES $SD"
   if [ -f $OUT/done ]; then echo "[dagger] 第 $r 轮已完成，跳过"; CK=$($PY -m ml.common.ckpt pick $OUT); continue; fi
   if [ -f $D/collect.json ]; then echo "[dagger] 第 $r 轮起点已采集，跳过"
-  else echo "[dagger] 第 $r 轮：用 $CK 闭环采起点（$N 题）"; $PY -m ml.dagger.collect --ckpt $CK --samples ml/data/samples --n $N --seed $r --parts $P --out $D; fi
+  else echo "[dagger] 第 $r 轮：用 $CK 闭环采起点（$N 题）"; $PY -m ml.dagger.collect --ckpt $CK --samples ml/data/samples --n $N --seed $r --parts $P --out $D --fb_gain ${FB_GAIN:-0} --safety ${DAG_SAFETY:-0} --replan ${DAG_REPLAN:-r3} --commit_n ${DAG_COMMIT_N:-3} --safety_partial ${DAG_PARTIAL:-0}; fi
   cat $D/collect.json
   pids=()
   for f in $D/tasks_*.jsonl; do

ml/monitor.html

@@ -144,6 +144,7 @@
   .ctlrow { display: flex; gap: 10px; margin-top: 14px; align-items: center; flex-wrap: wrap; }
   .ctlrow .hint { font-size: 12px; color: var(--dim2); }
   .term { background: #070a10; border: 1px solid var(--line); border-radius: 10px; padding: 10px 12px; height: 260px; overflow: auto; font: 12px/1.55 var(--mono); color: #c9d4e3; white-space: pre-wrap; word-break: break-all; }
+  .explore { background: #0b0f16; border: 1px solid var(--line); border-radius: 10px; padding: 10px 12px; max-height: 560px; overflow: auto; font: 12px/1.7 var(--mono); color: #c9d4e3; white-space: pre-wrap; }
   .term .e { color: var(--bad); } .term .c { color: var(--accent); } .term .g { color: var(--ok); }
   .modal { position: fixed; inset: 0; background: #05080ed9; backdrop-filter: blur(7px); display: none; align-items: flex-start; justify-content: center; z-index: 40; padding: 5vh 16px 24px; overflow: auto; }
   .modal.show { display: flex; }
@@ -213,6 +214,7 @@
     <div class="card"><h2><span>部署形态评测</span><span class="r">策略 + 安全层</span></h2><div id="bench"></div></div>
     <div class="card"><h2><span>验收汇总</span><span class="r">方案 §9.2</span></h2><div id="accept"></div></div>
   </section>
+  <section class="card"><h2><span>闭环探索日志</span><span class="r">docs/探索日志.md</span></h2><div class="explore" id="explore">加载中…</div></section>
   <section class="card"><h2><span>终端输出</span><span class="r" id="termnote">ml/runs/console.log</span></h2><div class="term" id="term"></div></section>
   <footer id="foot"></footer>
 </main>
@@ -834,6 +836,7 @@ $('logy').onclick = () => { logyOn = !logyOn; $('logy').classList.toggle('on', l
 for (const id of PREF_IDS) { $(id).onchange = prefSave; $(id).oninput = prefSave; }
 $('run').onchange = () => { userPicked = true; cur = null; poll(); };
 $('scenario').onchange = () => { api.scenario($('scenario').value); cur = null; userPicked = false; conOff = 0; $('run').innerHTML = ''; poll(); };
+api('/api/explore').then(d => { const el = $('explore'); el.textContent = (d && d.md) ? d.md : '（demo 模式：无探索日志）'; }).catch(() => { const el = $('explore'); el.textContent = '（无法读取 docs/探索日志.md）'; });
 $('auto').onclick = () => { const on = !$('auto').classList.contains('on'); $('auto').classList.toggle('on', on); clearInterval(timer); if (on) timer = setInterval(poll, 1000); };
 timer = setInterval(poll, 1000); poll();
 

ml/monitor.py

@@ -608,6 +608,11 @@ class H(BaseHTTPRequestHandler):
             if u.path == '/api/status': return self.send(200, json.dumps(status()), 'application/json')
             if u.path == '/api/job': return self.send(200, json.dumps(JOB.state()), 'application/json')
             if u.path == '/api/console': return self.send(200, json.dumps(console(int(q.get('offset', ['0'])[0]))), 'application/json')
+            if u.path == '/api/explore':   # 2026-10-20：闭环探索日志（docs/探索日志.md）回写控制台
+                try:
+                    with open(os.path.join(ROOT, 'docs', '探索日志.md'), encoding='utf-8') as f: md = f.read()
+                except Exception: md = ''
+                return self.send(200, json.dumps({'md': md}), 'application/json')
             self.send(404, 'not found', 'text/plain')
         except Exception as e:
             self.send(500, json.dumps({'error': str(e)}), 'application/json')

ml/sim/closed_loop.py

@@ -51,20 +51,23 @@ def goal_err(kin, q, T, R):
 def dls_steps(kin, q, T, R, n=3, scale=0.3, lam=0.5):
     """局部 DLS 精修：n 步增量 [B,n,6]"""
     step = torch.tensor(STEP, device=q.device)
+    B = q.shape[0]
     pose = (R.abs().sum(-1) > 0).float()
     Rt = R.view(-1, 3, 3)
-    def err(x):
+    def err(x, Tb, Rtb, poseb):
         xf = kin.cum_xf(x); p = kin.fk(x, xf); Rq = kin.orient(x, xf)
-        M = Rt @ Rq.transpose(1, 2)
+        M = Rtb @ Rq.transpose(1, 2)
-        rv = 0.5 * torch.stack([M[:, 2, 1] - M[:, 1, 2], M[:, 0, 2] - M[:, 2, 0], M[:, 1, 0] - M[:, 0, 1]], -1) * 100 * pose[:, None]
+        rv = 0.5 * torch.stack([M[:, 2, 1] - M[:, 1, 2], M[:, 0, 2] - M[:, 2, 0], M[:, 1, 0] - M[:, 0, 1]], -1) * 100 * poseb[:, None]
-        return torch.cat([T - p, rv], -1)
+        return torch.cat([Tb - p, rv], -1)
     out = []; x = q.clone()
+    ar = torch.arange(6, device=q.device)
     for _ in range(n):
-        e0 = err(x); J = []
+        e0 = err(x, T, Rt, pose)
-        for j in range(6):
+        # 2026-10-20：6 次串行有限差分合并为一次批量 FK（数值等价，单次规划 ~25ms→~7ms）
-            dx = torch.zeros_like(x); dx[:, j] = 1e-3
+        dx = torch.zeros(B, 6, 6, device=q.device); dx[:, ar, ar] = 1e-3
-            J.append(-(err(x + dx) - e0) / 1e-3)
+        xp = (x[:, None, :] + dx).reshape(B * 6, 6)
-        J = torch.stack(J, -1)                                    # [B,6(err),6(q)]
+        ep = err(xp, T.repeat_interleave(6, 0), Rt.repeat_interleave(6, 0), pose.repeat_interleave(6, 0))
+        J = -((ep - e0.repeat_interleave(6, 0)) / 1e-3).view(B, 6, 6).transpose(1, 2)   # [B,6(err),6(q)]
         A = J @ J.transpose(1, 2) + lam ** 2 * torch.eye(6, device=q.device)
         y = torch.linalg.solve(A, e0.unsqueeze(-1))
         dq = (J.transpose(1, 2) @ y).squeeze(-1)
@@ -141,7 +144,9 @@ class TeacherOracle:
 
 @torch.no_grad()
 def rollout(model, kin, tasks, device, K=8, safety=False, seed=0, max_sec=None, return_traj=False, use_sub=True, sub_override=None,
-            qp0=None, steps=1, z_scale=1.0, select='consist', oracle=None, replan='r3', sub_rule='cross'):
+            qp0=None, steps=1, z_scale=1.0, select='consist', oracle=None, replan='r3', sub_rule='cross',
+            fb_gain=0.0, fb_scale=0.0, fb_near=0.2, fb_fallback=0.0, safety_partial=0, commit_n=3, collect=None,
+            fb_exec=0.0, exec_safety=0):
     """use_sub=False：不用子目标（sf=0）；sub_override=(subs [B,M,6] 绝对关节角, n [B] 个数 或 need [B] bool)：冷启动时用给定途经点代替子目标头；
     qp0 [B,6]：起点的上一帧（默认 = q0，即静止起步）。steps：MeanFlow 采样段数；z_scale：噪声缩放；
     select：consist（部署口径：冷启动价值前瞻、之后与上一条已提交计划的一致性）/ value（每次都价值前瞻）/ first（不选，取第 0 条）。
@@ -190,6 +195,14 @@ def rollout(model, kin, tasks, device, K=8, safety=False, seed=0, max_sec=None,
                 z = torch.randn(B * K, H, 6, device=device, generator=g) * z_scale
                 act, val, sub = model.sample_k(feat, K, z, steps=steps)
             inc = act.float().clamp(-1, 1) * astep
+            if fb_gain > 0:   # 实验（2026-10-20）：目标反馈加在所有候选上（安全层也评估带反馈的候选）
+                fb = dls_steps(kin, qe, T, R, n=1)
+                if fb_scale > 0:   # 距离衰减：远离目标全增益，贴近目标减弱（减少过冲/刹停）
+                    dg, _ = goal_err(kin, qe, T, R)
+                    gdec = fb_gain * torch.clamp(dg / fb_scale, fb_near, 1.0)
+                    inc = inc + gdec[:, None, None, None] * fb[:, :, None, :]
+                else:
+                    inc = inc + fb_gain * fb[:, :, None, :]
             if cold:
                 need = sub[:, 12] > 0.5
                 subs = q[:, None] + sub[:, :12].float().view(B, 2, 6) * 180
@@ -216,32 +229,62 @@ def rollout(model, kin, tasks, device, K=8, safety=False, seed=0, max_sec=None,
             else:
                 # 2026-10-19 修错位：last[i] = 上一计划从 qe_old 走 i 步后的位置；提交 3 步后 qe_new = last[3]，
                 # 新候选 fut[0] 是 qe_new 再走 1 步 = 对应 last[4]。JS 部署（ik-policy.js）同一处同样修正。
-                n = min(fut.shape[2], last.shape[1] - 4)
+                n = min(fut.shape[2], last.shape[1] - (commit_n + 1))
                 w = 0.85 ** torch.arange(n, device=device, dtype=torch.float32)
-                d2 = (((fut[:, :, :n] - last[:, None, 4:4 + n]) / step) ** 2).sum(-1)
+                d2 = (((fut[:, :, :n] - last[:, None, commit_n + 1:commit_n + 1 + n]) / step) ** 2).sum(-1)
                 # 2026-10-19（审查 review_closedloop F5）：上一次是刹停或 DLS 接管的行没有「已提交计划」，
                 # 与 JS（lastPlan = null → 一致性项缺席、各候选同分 → 取第 0 条）一致：同分，稳定排序取第 0 条
                 score = torch.where(last_ok[:, None], -(d2 * w).sum(-1), torch.zeros_like(d2[..., 0]))
             order = torch.sort(score, dim=-1, descending=True, stable=True).indices
             pick = order[:, 0]
-            commit = inc[ar, pick, r:r + 3]
+            if select == 'average':   # 2026-10-20：候选平均（平滑误差）——所有候选置为 K 条动作的均值
+                inc = inc.mean(1, keepdim=True).expand_as(inc).contiguous()
+                K_eff = 1
+            else:
+                K_eff = K
+            commit = inc[ar, pick, r:r + commit_n]
+            if collect is not None:   # 反馈蒸馏：收集与部署完全一致的 (特征, 复合动作=模型输出+目标反馈)
+                collect.append((feat.detach().float().cpu(), inc[ar, pick].detach().float().cpu()))
             committed = torch.ones(B, dtype=torch.bool, device=device)
-            if safety:
+            if safety and safety_partial:   # 2026-10-20：允许「部分安全前缀」——执行到第一个不安全步为止，而不是全拒刹停
-                ok_any = torch.zeros(B, dtype=torch.bool, device=device)
+                maxlen = torch.zeros(B, dtype=torch.long, device=device)
-                chosen = torch.zeros(B, 3, 6, device=device); chosen_k = pick.clone()
+                chosen = torch.zeros(B, commit_n, 6, device=device); chosen_k = pick.clone()
-                for kk in range(K):
+                for kk in range(K_eff):
-                    ck = inc[ar, order[:, kk], r:r + 3]
+                    ck = inc[ar, order[:, kk], r:r + commit_n]
                     pts = qe[:, None] + torch.cumsum(ck, 1)
                     mids = torch.cat([qe[:, None], pts[:, :-1]], 1) + 0.5 * ck
                     allq = torch.cat([pts, mids], 1).reshape(-1, 6)
-                    okk = (kin.gaps(allq, 0.5)['gm'].min(-1).values > 0).view(B, 6).all(-1)
+                    ok6 = (kin.gaps(allq, 0.5)['gm'].min(-1).values > 0).view(B, 2 * commit_n)
+                    okstep = ok6[:, :commit_n] & ok6[:, commit_n:]                    # 每步：步点与其中点都安全
+                    plen = torch.cumprod(okstep.long(), 1).sum(1)       # 安全前缀长度 0..3
+                    take = plen > maxlen
+                    chosen = torch.where(take[:, None, None], ck, chosen); chosen_k = torch.where(take, order[:, kk], chosen_k)
+                    maxlen = torch.maximum(maxlen, plen)
+                    if B == 1 and int(maxlen[0]) >= commit_n: break   # 实时单题：首个全安全候选即停（安全层 16 点→2-4 点）
+                msk = (torch.arange(commit_n, device=device)[None] < maxlen[:, None])
+                commit = torch.where(msk[..., None], chosen, torch.zeros_like(chosen))
+                brakes += (maxlen == 0).float()
+                pick = chosen_k; committed = maxlen > 0
+            elif safety:
+                ok_any = torch.zeros(B, dtype=torch.bool, device=device)
+                chosen = torch.zeros(B, commit_n, 6, device=device); chosen_k = pick.clone()
+                for kk in range(K_eff):
+                    ck = inc[ar, order[:, kk], r:r + commit_n]
+                    pts = qe[:, None] + torch.cumsum(ck, 1)
+                    mids = torch.cat([qe[:, None], pts[:, :-1]], 1) + 0.5 * ck
+                    allq = torch.cat([pts, mids], 1).reshape(-1, 6)
+                    okk = (kin.gaps(allq, 0.5)['gm'].min(-1).values > 0).view(B, 2 * commit_n).all(-1)
                     take = okk & ~ok_any
                     chosen = torch.where(take[:, None, None], ck, chosen); chosen_k = torch.where(take, order[:, kk], chosen_k); ok_any |= okk
                 commit = torch.where(ok_any[:, None, None], chosen, torch.zeros_like(chosen))
+                if fb_gain > 0 and fb_fallback > 0:   # 全拒时的兜底：半速朝目标走一步（须通过安全认证），避免原地停滞
+                    fb1 = dls_steps(kin, qe, T, R, n=1) * fb_fallback
+                    ok1 = kin.gaps(qe + fb1[:, 0], 0.5)['gm'].min(-1).values > 0
+                    commit = torch.where((~ok_any & ok1)[:, None, None], fb1.expand(-1, commit_n, -1), commit)
                 brakes += (~ok_any).float()
                 pick = chosen_k; committed = ok_any
             if near.any():
-                ref = dls_steps(kin, qe, T, R)
+                ref = dls_steps(kin, qe, T, R, n=commit_n)
                 commit = torch.where(near[:, None, None], ref, commit)
                 dls_it = torch.where(near & (dls_it < 0), torch.full_like(dls_it, it), dls_it)
                 committed = committed & ~near

ml/train.py

@@ -73,6 +73,7 @@ def main():
     ap.add_argument('--config', default='ml/configs/base.json'); ap.add_argument('--steps', type=int, default=None)
     ap.add_argument('--resume', default=None); ap.add_argument('--no-eval', action='store_true')
     ap.add_argument('--init', default=None, help='只载入权重（优先 EMA）、优化器与步数从 0 开始（DAgger 微调用）')
+    ap.add_argument('--freeze-enc', action='store_true', help='冻结编码器（enc + enc_norm），只微调解码器/头')
     ap.add_argument('--lr', type=float, default=None); ap.add_argument('--warmup', type=int, default=None)
     ap.add_argument('--stop-at', type=int, default=0, help='自检用：跑到第 N 步按停止请求处理（存 last.pt、rc 143）')
     ap.add_argument('--device', default='cuda' if torch.cuda.is_available() else 'cpu'); ap.add_argument('--seed', type=int, default=0)
@@ -106,7 +107,7 @@ def main():
     print(f'train samples {data.n}, val tasks {len(val_tasks)}, act_scale {act_scale}, data_ver {data.data_ver}, device {dev}', flush=True)
     model = build(cfg).to(dev); model.act_scale = act_scale
     print(f'params {sum(p.numel() for p in model.parameters()) / 1e6:.2f} M', flush=True)
-    opt = torch.optim.AdamW(model.parameters(), lr=tc['lr'], betas=tuple(tc['betas']), weight_decay=tc['wd'])
+    opt = torch.optim.AdamW([p_ for p_ in model.parameters() if p_.requires_grad], lr=tc['lr'], betas=tuple(tc['betas']), weight_decay=tc['wd'])
     step0, best, bad_evals = 0, -1.0, 0
     def check_scale(ck, src):
         s0 = float(ck.get('act_scale', 1.0))

tests/policy_bench.cjs

@@ -14,7 +14,7 @@ const fs = require('fs'), path = require('path');
 const argv = process.argv.slice(2);
 const flag = k => argv.includes(k);
 const opt = k => { const i = argv.indexOf(k); return i >= 0 ? argv[i + 1] : null; };
-const VALOPT = new Set(['--out', '--nc-n', '--route-n', '--r8-n']);
+const VALOPT = new Set(['--out', '--nc-n', '--route-n', '--r8-n', '--fb', '--commit']);
 const pos = argv.filter((a, i) => !a.startsWith('--') && !(i > 0 && VALOPT.has(argv[i - 1])));
 const MODEL = pos[0] || path.join(__dirname, '../webapp/models/traj_policy.onnx');
 const SETS = (pos[1] || 'nc,route').split(',').concat(flag('--nc1000') ? ['nc1000'] : []);
@@ -71,7 +71,7 @@ const pct = (a, p) => { if (!a.length) return null; const s = a.slice().sort((x,
     for (let ci = 0; ci < cases.length; ci++) {
       const c = cases[ci];
       const R = mode === 'pose' ? c.R : null;
-      const r = new POL.Runner(S, infer, { seed: 1000 + ci, actScale: meta.act_scale || 1 });   // 2026-10-19：动作尺度随模型
+      const r = new POL.Runner(S, infer, { seed: 1000 + ci, actScale: meta.act_scale || 1, fbGain: +opt('--fb') || 0, commit: Math.max(1, +opt('--commit') || 3) });   // 2026-10-19：动作尺度随模型
       r.reset(c.q0); r.setGoal(c.T, R);
       let prev = c.q0.slice(), cf = 0, tLock = null;
       for (let k = 0; k < 500 && !r.done; k++) {

webapp/js/ik-policy-glue.js

@@ -55,7 +55,9 @@ async function boot() {
     }
     if (!sess) sess = await ort.InferenceSession.create(MODEL, { executionProviders: ep, graphOptimizationLevel: 'all' });
     const infer = ArmPolicy.ortInfer(ort, sess, { encOnce: !!meta.enc_once, featDyn: !!meta.feat_dyn });
-    runner = new ArmPolicy.Runner(S, infer, { actScale: meta.act_scale || 1 });   // 2026-10-19：动作尺度随模型（旧模型无此字段 = 1）
+    const FB = qs.get('fb') === null ? 1.8 : +qs.get('fb');        // 2026-10-20：全程目标反馈（fb=0 关闭）
+    const COMMIT = qs.get('commit') === null ? 3 : Math.max(1, +qs.get('commit'));   // 部署节奏：commit=1 每步规划
+    runner = new ArmPolicy.Runner(S, infer, { actScale: meta.act_scale || 1, fbGain: FB, commit: COMMIT });   // 2026-10-19：动作尺度随模型（旧模型无此字段 = 1）
     /* 预热：首次推理有编译开销 */
     await infer(new Float32Array(8 * ArmPolicy.F_DIM), new Float32Array(8 * ArmPolicy.H * 6), 8);
     const tick = URL.createObjectURL(new Blob(['let h=null;onmessage=e=>{clearInterval(h);if(e.data>0)h=setInterval(()=>postMessage(0),e.data)}'], { type: 'text/javascript' }));

webapp/js/ik-policy.js

@@ -179,7 +179,7 @@ class Runner {
     this.o = Object.assign({ K: 8, commit: 3, margin: 5,   /* 2026-10-18：运行时投影余量保持 5 mm（真机护栏，不迁就数据分布）；数据侧另行过滤认证间隙 < 3 mm 的老师轨迹，APG 训练余量 3 mm */
        projMax: 0.5, refineMm: 5, arriveMm: 1, arriveDeg: 0.5,
       stuckPlans: 5, lockSec: 1.0, subReachDeg: 5, subTimeout: 1.5, subRule: 'cross', subLeadSec: 0.02, seed: 12345, lookahead: true,
-      actScale: 1, certBudget: 40, safetyMs: 30, firstMs: 45 }, opts || {});
+      actScale: 1, certBudget: 40, safetyMs: 30, firstMs: 45, fbGain: 0 }, opts || {});
     /* 2026-10-19：actScale = 模型 meta.act_scale（动作标签按 act_scale·STEP 归一化，旧模型 1）；增量 = clamp(act, ±1)·actScale·STEP，
        与 ml/sim/closed_loop.py 同口径。subRule：'cross'（默认，越过顶点即切，与训练标签同口径；见 _subAdvance）/ 'timeout'（旧：< subReachDeg 或 subTimeout 超时）。 */   // 每条候选最多 40 次距离查询；安全层总预算 30 ms，第 1 条候选可用到 45 ms（超出按刹停处理）
     this.cert = makeCert(S, { leverTable: this.o.leverTable, cap: 20 });
@@ -307,8 +307,11 @@ class Runner {
     }
     /* 候选：去掉前缀后的提交步，投影，打分 */
     const cands = [], near = S.criticalPairs(qe, o.margin + 10).slice(0, 64);
+    // 2026-10-20：全程目标反馈（与 ml/sim/closed_loop.py 的 fb_gain 一致）——一次 DLS，加到所有候选所有步
+    const fbStep = (o.fbGain > 0 && this.goal) ? refineStep(S, qe, this.goal.T, this.goal.R, 0.3).dq : null;
     for (let k = 0; k < K; k++) {
       const inc = this._cand(out.act, k, r);
+      if (fbStep) for (let s = 0; s < H; s++) for (let j = 0; j < 6; j++) inc[s][j] += o.fbGain * fbStep[j];
       let steps = inc.slice(r, r + o.commit), q = qe.slice();
       const adj = [];
       for (const d of steps) {