总览 · ← 返回运行 20261003-171955-search-t2-embryo-interp-chain-12h

节点 n52

FRINGEVAC：在 occupancy_dice 度量框架内把「仅 b 侧覆盖」扩张前沿体素（novel 类型主导的保留）的细胞就近迁入核心并 RMS 复原，整片撤离超额占据体素，修复形状组唯一低于地板的 occupancy_dice。

方法说明?节点程序自带的 METHOD.md：这个程序做了什么、为什么。

来自 programs.git 38c8b78e36:solution/METHOD.md

调研员的计划

代码改动?这个节点的程序和父节点程序的逐行差别：绿色是新增，红色是删除。

对比：父节点版本 9a8c0ad76a。改动的文件：solution/METHOD.md +44 −39、solution/README.md +19 −0、solution/run.py +513 −18

diff --git a/solution/METHOD.md b/solution/METHOD.mdindex 8f6aaf6..af3f9df 100644--- a/solution/METHOD.md+++ b/solution/METHOD.md@@ -1,56 +1,61 @@-UNIVAL-P：单侧位移的软基因权重加指数 P=3（位移集中到强阶段效应基因），mmd_u/variogram/邻域三项 raw 同时略优、榜分与父 3 种子打平；PLAN 的类型感知 κ 经 5 种解码 + 等均值对照证否（排序无关，只有平均幅度起作用）。+FRINGEVAC：在 occupancy_dice 度量框架内把「仅 b 侧覆盖」扩张前沿体素（novel 类型主导的保留）的细胞就近迁入核心并 RMS 复原，整片撤离超额占据体素，修复形状组唯一低于地板的 occupancy_dice。 -## 提交内容（family: other，父节点 48）+## 节点 52（improve，父 = 节点 50，T2:embryo:val_interp） -父 48 全部管线不变（mix + procrustes3d 对齐 + 阻尼 log-RMS + α=5 型内收敛位移 + λ=6 投影加权 + 软阈值 + β=0.2 配对收缩 + 不对称相关扩散 + RECAL + DETR + DETRX-SIDE + NBHDCOH + WIRESET + UNIVAL κ=1）。本节点唯一改动（提交默认）：+### 结论摘要 -- **UNIVAL-P**：UNIVAL 位移的软基因权重从 `w_g = clip(|Δ̂_g|/τ,0,1)`（τ=0.25，P=1 时 480/498 基因全参与）改为 `w_g^P`，**P=3.0**。位移集中到强阶段效应基因，弱基因位移按三次方衰减。方向、截断（cap=2）、乘性衰减、池化伪批量中和（g2）全部不变 → DE 通道结构性不动（de_score .3571 / de_direction .3647 在所有 18 次查分中逐位一致）。-- 本节点新增的 PLAN 机制 UNIVAL-TA 及备选 MATCHDELTA、WIRESET-AC 都保留在代码里，**默认全部关闭**（`T2_UNIVAL_TA=0`、`T2_UNIVAL_MATCH=0`、`T2_WIRESET_ADAPT=0`），证否记录见下。+- PLAN 机制 **SIDEFRIM**（16³ 网格稀疏边缘体素 ≤thresh 中的 b 侧细胞删除 + RMS 复原）已按 PLAN 原样实现并查分证否：默认配置 (thresh=2, max_frac=0.04, delete) **65.060 vs 同日父锚点 65.131（−0.07）**；occupancy_dice raw 0.8066→0.8019（不升反降），d2_shape 0.0047→0.0059。+- 按任务书要求改交**针对同一弱项（occupancy_dice）的备选机制 FRINGEVAC**：不是按"稀疏度"识别伪影，而是按**括号覆盖类**识别——把两个输入阶段对齐缩放后的完整云各自投到输出云的 occupancy 度量框架（居中、PCA 主轴、除自身 RMS、±3 RMS 16³ 网格）得到体素集 Va、Vb；输出中**仅被 b 侧（晚阶段）覆盖**且 **b-novel 细胞占比 < 0.5** 的体素（= 晚侧扩张前沿的超额占据）连同**两侧都不覆盖**的 neither 体素，整片撤离：其中所有细胞被**就近迁移**（同型优先的非候选细胞位置 + 0.15 体素抖动）而非删除，随后整体 RMS 复原（scale_log_ratio 逐位不变）。+- A 半 seed 0：**65.402（父 +0.27）**；配对差三种子稳定：seed1 +0.28（64.577 vs 64.296）、seed2 +0.42（64.860 vs 64.443），**均值 +0.32**。occupancy_dice raw 0.8066→0.8494，skill 0.4214→0.5299，**首次越过地板 0.5**（points 3.51→4.42，+0.90）；代价 d2_shape −0.50 pts、nbhd −0.12 pts；表达/组成两组逐位不变（move 模式不删细胞、不改表达值）。 -`--ablate mechanism`：关掉本节点全部新机制（TA、MATCH、ADAPT、P→1、κ_a=κ_b→1），UNIVAL/WIRESET 等父机制保持打开 → 输出与父 48 逐位一致（X digest `56f694d7d8a1a0b2`，本地已验证）。+### 机制生效证据（PLAN mechanism_evidence 要求） -## PLAN 机制 UNIVAL-TA：证否（步骤 1 诊断 + 5 解码 + 等均值对照）+- 实际改变的细胞：seed 0 迁移 669 个细胞（13.4%，其中 b 侧 658、a 侧 11），全部来自被撤离的 79 个体素（b-only nov<0.5 共 70 个 + neither 9 个）；novel 类型主导的 ~10 个 b-only 体素（约 130 细胞，FHF/SHF/D-FG 等新生结构）按设计**保留**（Q10 证明它们是目标真值占据的体素）。+- 占据体素数：243 → 222（本地度量框架复算）；评分器 occupancy_dice raw 0.8066→0.8494。+- d2_shape raw 0.0047→0.00852（迁移把 13% 质量拉入核心，成对距离分布变短）；scale_log_ratio raw 0.0162→0.0162（RMS 复原逐位保尺度，×1.0396）。+- mmd_u / variogram / de_score / de_direction raw 与父**逐位一致**（表达矩阵与细胞集合完全未动，只动坐标）。+- neighborhood_mmd raw 0.0475→0.04863（−0.12 pts，迁移细胞进入核心带来的表达-位置轻度失配；未破 0.5 邻域门，结构门 = 1）。+- `--ablate mechanism`：SIDEFRIM 与 FRINGEVAC 全部关闭，输出与父节点 50 逐位一致（X digest `72f2d76b33921ec6`、坐标 digest `af1088a32c100cb6`）。 -步骤 1 诊断（不查分）：单侧类型的字面 n_other（对侧同名细胞数）**结构性为 0**（22/22 个类型，>80% 判据触发）→ 按 PLAN 切换到标记基因检出率软权重。诊断还显示持久度信号强不对称：a 侧 7 型的标记在对侧（E8.0）检出率比 d_other/d_in≈1.0–1.5（程序普遍仍在表达），b 侧 15 型只有 0.02–0.10（新出现的特化程序）。+### 关键参数（默认值即提交配置） -查分记录（proxy A 半，seed 0，父=65.129；每项为 raw）：+`T2_FRINGEVAC_ENABLE=1`、`MODE=nudge`（就近迁移）、`NOV=0.5`（b-novel 占比阈值）、`ITERS=1`、`JIT=0.15`（体素宽比例抖动）、`MOVE_K=5`（同型目标最少细胞数）、`MAXFRAC=0.25`（细胞预算）、`RESTORE=1`（RMS 复原）、`MINCNT/MAXCNT=0`、`HYBRID_CNT=0`、`SCATTER=0`、`TGT_CORE=0`、`TAN=0`。SIDEFRIM（PLAN 原机制）保留代码、默认关（`T2_SIDEFRIM_ENABLE=0`）。网格 16³、跨度 ±3 RMS 与度量一致。 -| # | 配置 | 榜分 | mmd_u | variogram | nbhd |-|---|---|---:|---|---|---|-| q1 | TA ratio ref=0.1（a 侧 w=1，b 侧分级 0.26–0.97）| 65.009 | .01048 | .007430 | .04900 |-| q3 | 纯 per-side κ_a=1, κ_b=0 | 64.662 | .01065 | .007555 | .05104 |-| q4 | 纯 per-side κ_a=0, κ_b=1 | 65.116 | .01082 | .007362 | .04765 |-| q5 | TA ratio ref=0.1 + κ_b=1.5 | 65.101 | .01080 | .007334 | .04789 |-| q6 | 纯 per-side κ_b=1.5 | 65.084 | .01200 | .007195 | .04606 |-| q7 | 纯 per-side κ_b=2.0 | 64.912 | .01348 | .007031 | .04526 |-| q8 | **等均值对照**：uniform κ_b=0.62（=q1 的 b 侧平均权重）| 65.017 | .01044 | .007458 | .04895 |-| q9 | TA det ref=0.3（PLAN 字面退路信号）| 64.748 | .01053 | .007536 | .05065 |-| q10 | TA inv ref=0.2（反向假设：瞬态型多位移）| 65.064 | .01038 | .007447 | .04872 |+### 查分记录（A 半，seed 0，除注明外；共 17 次，余 3） -**判决性证据是 q1 vs q8**：分级 κ（按持久度排序）与同平均幅度的统一 κ，三项 raw 差 ≤3e-5、榜分差 0.008——持久度**排序不携带信息**，UNIVAL 的 mmd_u–nbhd 交换只由平均位移幅度驱动。q4/q3 进一步显示 b 侧回退承载全部收益（+0.42 vs UNIVAL 关闭的 64.699），a 侧前移净贡献 ≈0；q6/q7 显示 κ_b 放大时 mmd_u 的点损失约为 nbhd+variogram 收益的 2 倍。PLAN 假设（瞬态型的错误位移拖累 mmd_u）不成立：把瞬态型权重调低（q1/q9/q10）或调高（q10）都只沿同一条交换曲线滑动。+| # | 配置 | board | occ raw | d2 raw | nbhd raw | 结论 |+|---|---|---|---|---|---|---|+| 1-2 | 父 50 锚点（同日） | **65.131** | 0.8066 | 0.0047 | 0.0475 | 锚点（第 1 次输出被截断浪费） |+| 3 | SIDEFRIM delete thresh=2 b 侧（PLAN 默认） | 65.060 | 0.8019 | 0.00588 | 0.04768 | **PLAN 机制证否**；variogram +0.18 是唯一亮点 |+| 4 | FRINGEVAC move（同型最近密集细胞落点） | 65.391 | 0.8501 | 0.00875 | 0.04865 | 机制成立 |+| 5 | maxcnt=8（只撤稀疏 b-only，195 细胞） | 64.992 | 0.800 | 0.00491 | 0.04755 | 稀疏 b-only ≈ 真值，撤了掉分 |+| 6 | 切向迁移（保半径） | 64.767 | 0.8413 | 0.01337 | 0.04788 | 长距离横移毁 d2 |+| 7 | **nudge（就近非候选落点，提交）** | **65.402** | 0.8494 | 0.00852 | 0.04863 | 最优 |+| 8 | mincnt=9+核心落点（只撤密集 b-only） | 64.429 | 0.7908 | 0.00799 | 0.04788 | 部分撤离只在边缘内部洗牌，occ 反降 |+| 9 | scatter（同型随机落点分散） | 63.697 | 0.8313 | 0.01769 | 0.05143 | 长距离随机迁移毁 d2/nbhd |+| 10 | nudge nov=1.01（连 novel 主导 b-only 也撤） | 64.944 | 0.8398 | 0.01045 | 0.04866 | novel 主导体素是真值，nov=0.5 过滤正确 |+| 11 | delete 全边缘集（669 细胞删除） | 63.623 | 0.8281 | 0.01847 | 0.04769 | 删除毁 de_score(0.357→0.321)/mmd/d2 |+| 12 | nudge iters=2 | 64.903 | 0.8296 | 0.00839 | 0.04907 | 第二遍撤到真值体素 |+| 13-16 | nudge/父 × seed 1,2 | +0.28/+0.42 | — | — | — | 配对差稳定 |+| 17 | hybrid（稀疏候选删除 26 + 其余 nudge） | 64.465 | 0.8010 | 0.00966 | 0.04765 | 删除稀疏边缘必丢真值体素，Q3 的 variogram 增益未重现 | -## 备选机制（同一弱项 cell_state/local_spatial）+### 为什么备选机制成立（结构性诊断，全部来自视图内数据现场计算） -1. **MATCHDELTA**（类型匹配方向）：单侧型的位移方向改为按表达谱相似度 softmax(β·Pearson) 加权的共有类型 Δ_c 混合（匹配合理：Blood Progenitor→HEM-Endoth、p-EXEM→ExEM-1、PHM/PAM→SOM）。q11（β=3,ρ=1,κ_b=1）65.047：nbhd .04723 为全家族最好，但 mmd_u .01126 更差；q12（+κ_b=1.5）64.959：匹配方向**不保护** mmd_u（.01263 vs 统一方向 .01200）；q14（范数匹配解码）65.049：证明 q11 的 nbhd 收益来自更长步长而非方向。→ 方向也不是 mmd_u 损伤源，证否。-2. **WIRESET-AC**（父 ANALYSIS 建议 3，组大小自适应强度 κ_g=κ·clip(n_g/40,0.25,1)）：q13 = 65.004，mmd_u .01049 改善但 nbhd 同量级损失，证否。-3. **UNIVAL-P**（提交）：见上。P=2（q15）与 P=3（q17）榜分都=65.129；P=3 三项 raw 全部略优于父（mmd_u .01084 vs .01089、variogram .007358 vs .007374、nbhd .04750 vs .04771），P=2 的 nbhd 略差（.04786），故选 P=3。P=2+κ_b=1.3（q16）65.126 亦平。+父输出占据 243 个体素，而两个括号阶段整云在同一框架下分别只占 169/198 个、交集仅 95 个：mix 输出是两个错位形状的**并集**，比目标（≈171 个，由 dice=0.8066 与 I≈167 反解）多出 ~78 个超额体素。按覆盖类分解：both 95（q≈1，核心）、a-only 59（q≈0.77，目标位置而晚侧已退出，**必须保留**）、b-only nov<0.5 70 + neither 9（q≈0：晚侧 ×0.46 降采样的扩张前沿超出 t=0.4 的中间形状 + 抖动伪影，**整片撤离**）、b-only nov≥0.5 ~10（新生结构，Q10 证明为真值，保留）。#3/#5/#8/#17 的失败共同说明：**部分撤离或按稀疏度撤离必然误伤真值边缘**（真实胚胎自身就有 ~24-32 个稀疏边缘体素），只有按覆盖类整片撤离 nov<0.5 的 b-only 边缘才落在超额集上。 -## 提交配置的机制生效证据+### 已验证 / 未验证 -- **改变了哪些细胞**：1815 个单侧型输出细胞（854 a 起源 + 961 b 起源）的位移幅度逐基因改变：|Δ̂_g|≥0.25 的强基因 w_g=1 不变；|Δ̂_g|<0.25 的弱效应基因被三次方压缩（如 |Δ̂|=0.1：w 从 0.4 → 0.064；|Δ̂|=0.05：0.2 → 0.008）。其余 3185 个共有型细胞只受 g2 列缩放影响；坐标逐位不动。X digest 与父不同（`63636e2338b129ae` vs `56f694d7d8a1a0b2`），--ablate 恢复父 digest。-- **四组分变化（A 半 seed 0，vs 父）**：expression_change 62.69=62.69（逐位不变）；shape_scale 77.75=77.75（坐标不动）；cell_state：mmd_u 7.797（+.01）、variogram 6.783（+.005）；local_spatial：nbhd 15.440（+.026）。榜分 65.129 = 65.129。-- **种子稳健性**：seed 1 = 64.295（父 64.294）、seed 2 = 64.445（父 64.439）；机制 raw 与父差 ~1e-5（nbhd .04801/.04730 vs 父 .04803/.04731）。三种子均值 64.623 vs 父 64.621。+- 已验证：默认与 `--ablate` 输出 digest（ablate = 父逐位一致）；seed 0/1/2 确定且配对差同号；伪装视图（文件重命名、manifest 键序打乱、时间 +1 平移）输出与真实视图**逐位一致**；单输入阶段视图（无括号 → copy 退路，FRINGEVAC 不触及该路径）正常且过 vec-check；运行 ~2.5 s / <1 GB（CPU，`EXECUTION.json {"gpu": false}`）。+- 未验证：官方 final 视图（不同括号时机制从 bracket 现场计算 Va/Vb，逻辑通用但未实测）；B 半分数（A 半配对差 +0.27~+0.42，低于 1 分噪声带但机制结构性——occ skill 越地板——且三种子同号）；心脏榜（本节点仅针对 embryo 插值榜）。+- 本地代理指标（免费筛选，不再花查分）：d2 代理 W1(变体,父) ≈ scorer d2 raw − 0.0047，7 个变体上误差 ≤0.001，可用于后续节点筛选迁移策略。 -## 结论与下一步+### 知识来源 -本家族在 proxy A 半 seed 0 的天花板 ≈65.13：17 个配置（幅度、类型分级、per-side、方向匹配、基因选择五个自由度）全部落在同一条 mmd_u↔nbhd 交换曲线上，任何再分配净值不变。UNIVAL-P 是曲线上一个 raw 全面不劣于父的点，按规则提交备选机制而非退回父程序；预期 B 半 ≈ 父 ±0.1。**下一步最值得试的不在表达通道**：occupancy_dice skill .4214 仍低于地板（形状组唯一失分项），兄弟谱系节点 47 的 SIDEFRIM（b 侧稀疏边缘体素切除，shape_scale +0.26）值得移植到本谱系；以及 nbhd 与坐标配对的空间通道（表达-位置重配对，而非继续挤压值级位移）。+无外部生物学常数。判别器只用两类**视图内现场计算**的量：(1) 括号两阶段整云在输出度量框架中的体素覆盖（几何）；(2) b-novel 细胞类型 = 出现在晚侧阶段标签而不在早侧标签中的类型（从 manifest 输入的 `celltype` 列现场求集合差）。其背后的发育学逻辑仅为通用谱系知识（早侧不存在的谱系是两阶段之间新出现的结构，其中间时刻位置更可能真实存在，故保留其主导的体素；共有类型的单侧扩张前沿在 t<1 时刻更可能超程，故撤离），不涉及任何保留阶段的测量值、细胞数、比例或尺寸常数；RMS 复原目标为管线自算的 target_rms，无任何硬编码生长常数。 -## 验证与合规+### 给后续节点的建议 -- 完整视图运行 ~11 s / <1 GB 内存（limits 30 min / 28 GB 内）；`vec-check` 通过；`EXECUTION.json {"gpu": false}`（纯 CPU）。-- **视图无关自检**：+1 天时间平移、输入文件改名、manifest 键序打乱的伪装视图上，seed 0 输出 X 与坐标 digest 与真实视图完全一致（`63636e2338b129ae`/`0bc0cb7bdce1aa58`）。程序不读 board/mode/路径/绝对时间，只用括号数据与相对 t。-- 单输入阶段退路：无括号时走父级 copy 路径（本节点未改动）；UNIVAL/TA/MATCH/AC 均只在括号存在时生效。-- 确定性：无全局随机；--seed 传入 mix 抽样 rng，P 机制本身无随机。-- **知识来源：无外部生物学知识**。所有量（标记基因、检出率、相似度、Δ̂、n_g）都在运行时从 view 的括号阶段现场计算；未使用保留阶段/保留基因型的任何测量值，未硬编码任何统计量。-- 查分用量：18/20（q1–q17 + q1 重复捕获全部分项）；剩余 2 次未用。-- 未验证：B 半与正式分（系统执行）；真实 final 括号（E 输入阶段数不同）上 UNIVAL-P 的行为仅由视图无关性与单输入退路保证结构正确，分数未测。+1. occupancy_dice 的剩余超额 ~51 个体素主要是撤离后 PCA 框架重绑定（轴旋转 3-5°）产生的边界伪影；iters=2 已证明再撤会吃到真值。想继续压 P 需先解决框架稳定性，或接受当前 +0.9 pts 水平。+2. d2_shape 是本机制的固有代价（−0.5 pts，尾部质量入核）；任何"更远/更随机"的落点都更差（#6/#9），"就近同型"已是最优（nudge）。+3. 删除通道彻底关闭：>1% 的细胞删除即触发 de_score 结构性敏感（#11：0.357→0.321），≤0.5% 的删除会丢真值体素（#3/#17）。表达通道维持父结论：饱和。+4. 下一步值得试：把覆盖类框架用于 nbhd（权重 25+门）——nov 主导 b-only 体素内的细胞是"晚侧表达在中间位置"，可做类型匹配的邻域一致性检查挖 local_spatial。diff --git a/solution/README.md b/solution/README.mdindex 83bbd3d..d5e6563 100644--- a/solution/README.md+++ b/solution/README.md@@ -1,3 +1,22 @@+# 节点 52：FRINGEVAC（覆盖类边缘体素整片撤离）— PLAN 的 SIDEFRIM 已证否，提交备选机制++PLAN 机制 SIDEFRIM（b 侧稀疏边缘体素细胞删除 + RMS 复原）按原样实现并查分证否+（默认配置 65.060 < 同日父锚点 65.131；occ raw 0.8066→0.8019 反降；另 4 种删除/部分+撤离解码 63.62–64.99 全部更低）。诊断发现真因：mix 输出是两括号阶段对齐缩放云的+**并集**（243 体素 vs 目标 ≈171），超额占据集中在「仅晚侧覆盖且非 novel 类型主导」的+扩张前沿体素；而**稀疏**边缘体素约一半是真值（真实胚胎自身有稀疏边缘）。++提交机制 FRINGEVAC（`T2_FRINGEVAC_ENABLE=1, MODE=nudge, NOV=0.5`）：在 occupancy_dice+度量框架内把两输入阶段整云投到输出框架得 Va/Vb，对 b-only(nov<0.5)+neither 共 ~79 个+体素**整片撤离**——669 个细胞就近迁移到同型非候选细胞位置（+0.15 体素抖动），随后整体+RMS 复原。表达矩阵与细胞集合逐位不动。A 半：seed 0 **65.402（+0.27）**，配对差+seed1 +0.28、seed2 +0.42（均值 +0.32）；occ raw 0.8494、skill 0.530 首次越过地板；+代价 d2 −0.50 pts、nbhd −0.12 pts。`--ablate mechanism` → 与父 50 逐位一致+（X digest `72f2d76b33921ec6`）；伪装视图 digest 一致；单输入视图退路正常。+17 次查分明细与后续建议见 METHOD.md。++---+ # 节点 48：UNIVAL（单侧类型值级时间对齐）+ WIRESET（型×侧抽样漂移回正）  PLAN 机制 VDEF（型×侧单边方差放气）已实现并在 A 半 seed 0 上 5 配置证否diff --git a/solution/run.py b/solution/run.pyindex f5dca6a..364c4fc 100644--- a/solution/run.py+++ b/solution/run.py@@ -1915,6 +1915,40 @@ VARISO_CLIP = (float(os.environ.get("T2_VARISO_CLIP_LO", "0.3")), VARISO_EPS = float(os.environ.get("T2_VARISO_EPS", "0.01")) VARISO_MIN_CELLS = int(os.environ.get("T2_VARISO_MIN_CELLS", "10")) VARISO_MIN_DE = int(os.environ.get("T2_VARISO_MIN_DE", "10"))+# SIDEFRIM (family T2EI-06, node 52, PLAN mechanism; ported from sibling node+# 47): sparse-edge-voxel trimming inside the occupancy_dice METRIC frame.+# occupancy_dice (weight 8.33 + it gates the shape group through the+# neighborhood skill) is the ONLY metric of the eight that sits below its floor+# on this lineage (raw .8066, skill .421 < .5): the mixed cloud occupies MORE+# voxels than the target cloud (243 occupied of the 16^3 grid over ±3 RMS,+# while dice .8086 implies ≈165 target voxels if the target is a subset). The+# excess voxels are sparse edge artefacts of placing two bracket stages in one+# frame: cells drawn from the LATE side (b, rows >= n_from_a) land in thin+# fringes where the target embryo has no mass. Diagnostic (proxy, seed 0,+# parent output): voxels with <=2 cells: 32 (18 pure-b, 1 mixed, 13 pure-a);+# <=4 cells: 53 (33 pure-b). SIDEFRIM:+#   (a) rebuild the metric frame on the OUTPUT cloud: center, PCA principal+#       axes (deterministic sign), divide by own RMS, 16^3 grid over ±3;+#   (b) flag sparse voxels (0 < count <= SIDEFRIM_THRESH);+#   (c) remove (mode=delete) or relocate (mode=move) the candidate cells in+#       those voxels; with SIDES=b only b-origin cells are touched (a-side+#       expression-position pairing protected), SIDES=all trims both origins;+#   (d) cap the removed/relocated fraction at SIDEFRIM_MAXFRAC (priority:+#       sparsest voxel first, then farthest from the cloud centre, then index);+#   (e) restore the pre-trim RMS radius exactly (uniform scale) so+#       scale_log_ratio does not drift; expression values are NEVER modified.+# mode=move relocates candidates to the centroid of their K nearest cells that+# sit in dense voxels (+ tiny seeded jitter), keeping the cell count fixed.+# SIDEFRIM_ENABLE=0 (or THRESH=0) skips the step → parent node 50 bit-for-bit.+# --ablate also disables ONLY this mechanism (all inherited steps unchanged).+SIDEFRIM_ENABLE = os.environ.get("T2_SIDEFRIM_ENABLE", "0") == "1"+SIDEFRIM_THRESH = int(os.environ.get("T2_SIDEFRIM_THRESH", "2"))+SIDEFRIM_MAXFRAC = float(os.environ.get("T2_SIDEFRIM_MAXFRAC", "0.04"))+SIDEFRIM_SIDES = os.environ.get("T2_SIDEFRIM_SIDES", "b")      # b | all+SIDEFRIM_MODE = os.environ.get("T2_SIDEFRIM_MODE", "delete")   # delete | move+SIDEFRIM_GRID = int(os.environ.get("T2_SIDEFRIM_GRID", "16"))+SIDEFRIM_SPAN = float(os.environ.get("T2_SIDEFRIM_SPAN", "3.0"))+SIDEFRIM_MOVE_K = int(os.environ.get("T2_SIDEFRIM_MOVE_K", "5"))   def load_pathway_sets(view: str, genes: list[str], src: str | None = None):@@ -2249,6 +2283,387 @@ def type_aniso_reshape(coords, labs_out, ca, cb, la_all, lb_all, t: float):     return c, info  +def _frame_basis(ref, grid: int = 16, span: float = 3.0):+    """Metric frame of a reference cloud: centre, PCA axes (deterministic sign), RMS."""+    R = np.asarray(ref, dtype=np.float64)+    mu = R.mean(axis=0)+    Rc = R - mu+    evals, evecs = np.linalg.eigh(Rc.T @ Rc)+    order = np.argsort(evals)[::-1]+    evecs = evecs[:, order]+    for j in range(evecs.shape[1]):+        k = int(np.argmax(np.abs(evecs[:, j])))+        if evecs[k, j] < 0:+            evecs[:, j] = -evecs[:, j]+    rms = float(np.sqrt((Rc * Rc).sum(axis=1).mean())) if R.shape[0] else 0.0+    return mu, evecs, rms+++def frame_voxels(X, mu, evecs, rms: float, grid: int = 16, span: float = 3.0):+    """Voxel ids of X in the frame of a reference cloud (grid^3 bins over ±span RMS)."""+    P = (np.asarray(X, dtype=np.float64) - mu) @ evecs / max(rms, 1e-12)+    edges = np.linspace(-span, span, grid + 1)+    idx = np.clip(np.digitize(P, edges[1:-1]), 0, grid - 1)+    return (idx[:, 0] * grid + idx[:, 1]) * grid + idx[:, 2]+++def occupancy_frame(coords, grid: int = 16, span: float = 3.0):+    """Rebuild the occupancy_dice metric frame on a single cloud.++    Center → PCA principal axes (descending eigenvalues, deterministic sign:+    largest-|.| component positive) → divide by own RMS radius → grid^3 bins+    over ±span. Returns (voxel_id_per_cell, rms, n_occupied_voxels).+    """+    X = np.asarray(coords, dtype=np.float64)+    mu, evecs, rms = _frame_basis(X, grid, span)+    vox = frame_voxels(X, mu, evecs, rms, grid, span)+    return vox, rms, int(np.unique(vox).size)+++def sidefrim_trim(coords, n_from_a: int, thresh: int, max_frac: float,+                  sides: str = "b", mode: str = "delete", seed: int = 0,+                  grid: int = 16, span: float = 3.0, move_k: int = 5):+    """SIDEFRIM (node 52): trim sparse-edge voxels in the occupancy metric frame.++    Cells sitting in voxels with 0 < count <= thresh are candidates; with+    sides='b' only b-origin cells (rows >= n_from_a) qualify. Candidates are+    capped at floor(max_frac*n) with priority (sparsest voxel, farthest from+    centre, lowest index) so the trimming is deterministic. mode='delete' drops+    the rows entirely (keep-mask returned); mode='move' relocates them to the+    centroid of their move_k nearest cells that live in dense voxels plus a+    tiny seeded jitter (cell count fixed, keep=None). After the edit the RMS+    radius is restored EXACTLY to the pre-trim value by a uniform scale+    (scale_log_ratio protected). Expression is never touched here.+    """+    coords = np.asarray(coords, dtype=np.float64)+    n = coords.shape[0]+    info = {"sidefrim_enable": True, "sidefrim_thresh": int(thresh),+            "sidefrim_max_frac": float(max_frac), "sidefrim_sides": sides,+            "sidefrim_mode": mode, "sidefrim_applied": False,+            "sidefrim_n": int(n), "sidefrim_n_from_a": int(n_from_a),+            "sidefrim_voxels_before": None, "sidefrim_voxels_after": None,+            "sidefrim_sparse_voxels": None, "sidefrim_n_candidates": None,+            "sidefrim_n_edited": 0, "sidefrim_n_pure_b_sparse": None,+            "sidefrim_rms_before": None, "sidefrim_rms_after": None,+            "sidefrim_restore_factor": None}+    if n < 50 or thresh <= 0 or max_frac <= 0.0:+        info["sidefrim_enable"] = bool(thresh > 0 and max_frac > 0.0)+        return coords.astype(np.float32), None, info+    vox, rms0, n_occ = occupancy_frame(coords, grid, span)+    uq, inv, counts = np.unique(vox, return_inverse=True, return_counts=True)+    cellcnt = counts[inv]+    sparse = cellcnt <= thresh+    sparse_vox = counts <= thresh+    is_b = np.zeros(n, dtype=bool)+    is_b[int(n_from_a):] = True+    nb_per_vox = np.bincount(inv, weights=is_b.astype(np.float64), minlength=len(uq))+    pure_b_sparse = int((sparse_vox & (nb_per_vox == counts)).sum())+    cand = sparse & is_b if sides == "b" else sparse+    info.update(sidefrim_voxels_before=n_occ,+                sidefrim_sparse_voxels=int(sparse_vox.sum()),+                sidefrim_n_pure_b_sparse=pure_b_sparse,+                sidefrim_n_candidates=int(cand.sum()),+                sidefrim_rms_before=rms0)+    if not cand.any():+        return coords.astype(np.float32), None, info+    ci = np.flatnonzero(cand)+    max_del = int(np.floor(max_frac * n))+    if max_del <= 0:+        return coords.astype(np.float32), None, info+    if ci.size > max_del:+        Xc = coords - coords.mean(axis=0)+        rad = (Xc[ci] * Xc[ci]).sum(axis=1)+        prio = np.lexsort((ci, -rad, cellcnt[ci]))+        ci = ci[prio[:max_del]]+    if mode == "move":+        from scipy.spatial import cKDTree+        dense_cells = np.flatnonzero(~sparse)+        if dense_cells.size < move_k:+            return coords.astype(np.float32), None, info+        tree = cKDTree(coords[dense_cells])+        k = min(int(move_k), dense_cells.size)+        _, nn = tree.query(coords[ci], k=k)+        nn = np.atleast_2d(nn)+        tgt = coords[dense_cells[nn]].mean(axis=1)+        rng = np.random.default_rng(int(seed))+        jit = rng.normal(0.0, 1.0, size=tgt.shape) * (0.02 * max(rms0, 1e-12))+        newc = coords.copy()+        newc[ci] = tgt + jit+        keep = None+    else:+        keep = np.ones(n, dtype=bool)+        keep[ci] = False+        newc = coords[keep]+    if newc.shape[0] >= 10:+        rms_pre = rms_radius(newc)+        restore = float(rms0 / rms_pre) if rms_pre > 1e-9 else 1.0+        newc = scale_to_rms(newc, rms0)+    else:+        restore = 1.0+    _, _, n_occ2 = occupancy_frame(newc, grid, span)+    info.update(sidefrim_applied=True, sidefrim_n_edited=int(ci.size),+                sidefrim_voxels_after=n_occ2,+                sidefrim_rms_after=rms_radius(newc),+                sidefrim_restore_factor=restore)+    return newc.astype(np.float32), keep, info+++# FRINGEVAC (node 52 backup mechanism, same weakness = occupancy_dice):+# class-aware fringe-voxel vacating. Diagnostic on the parent output (proxy,+# seed 0): the mixed cloud occupies 243 voxels while the bracket stages in the+# SAME frame occupy |Va|=169, |Vb|=198 with |Va∩Vb|=95 — the two aligned,+# RMS-matched bracket clouds barely coincide, so the mix is a UNION covering+# ~78 voxels that the (≈170-voxel) target does not have (dice .8066 with+# I≈167 ⇒ target ⊂ pred almost exactly). Voxel classes of the output:+# both-covered 95 (q≈1, core), a-only 59 (q≈.77 — target positions the late+# stage regressed out of; KEEP), b-only 80 (q≈.33 — expansion frontier of the+# ×0.46-downscaled E8.0 cloud overshooting the t=0.4 intermediate; mostly+# excess), neither 9 (jitter/aniso outliers outside both stage clouds; q≈0).+# FRINGEVAC vacates every voxel that is b-only with b-novel cell fraction <+# NOV_THRESH (b-novel = celltype present in stage b but absent from stage a —+# genuinely emerging structures such as heart-field/head voxels are KEPT+# because the target may already contain them) plus all neither voxels, and+# removes (mode=delete) or relocates (mode=move) the cells inside. Whole+# voxels are processed atomically (a partial trim would not vacate the voxel);+# if the cell budget max_frac·n is exceeded, the cheapest (fewest-cell) voxels+# go first. RMS is restored exactly afterwards; expression is never modified.+FRINGEVAC_ENABLE = os.environ.get("T2_FRINGEVAC_ENABLE", "1") == "1"+FRINGEVAC_NOV = float(os.environ.get("T2_FRINGEVAC_NOV", "0.5"))+FRINGEVAC_MODE = os.environ.get("T2_FRINGEVAC_MODE", "nudge")   # delete | move | nudge+FRINGEVAC_MAXFRAC = float(os.environ.get("T2_FRINGEVAC_MAXFRAC", "0.25"))+FRINGEVAC_VAC_A = os.environ.get("T2_FRINGEVAC_VAC_A", "0") == "1"+FRINGEVAC_MOVE_K = int(os.environ.get("T2_FRINGEVAC_MOVE_K", "5"))+FRINGEVAC_DENSE_CNT = int(os.environ.get("T2_FRINGEVAC_DENSE_CNT", "5"))+FRINGEVAC_RESTORE = os.environ.get("T2_FRINGEVAC_RESTORE", "1") == "1"+FRINGEVAC_ITERS = int(os.environ.get("T2_FRINGEVAC_ITERS", "1"))+FRINGEVAC_MAXCNT = int(os.environ.get("T2_FRINGEVAC_MAXCNT", "0"))  # 0 = no cap+FRINGEVAC_MINCNT = int(os.environ.get("T2_FRINGEVAC_MINCNT", "0"))  # 0 = no floor+FRINGEVAC_TGT_CORE = os.environ.get("T2_FRINGEVAC_TGT_CORE", "0") == "1"+FRINGEVAC_SCATTER = os.environ.get("T2_FRINGEVAC_SCATTER", "0") == "1"+FRINGEVAC_JIT = float(os.environ.get("T2_FRINGEVAC_JIT", "0.15"))+# hybrid: candidates in voxels with count <= HYBRID_CNT are DELETED instead of+# relocated (query-3 evidence: removing the ~23 sparse-fringe b cells improved+# variogram raw .007358→.006961 with de/mmd flat). 0 = pure relocation.+FRINGEVAC_HYBRID_CNT = int(os.environ.get("T2_FRINGEVAC_HYBRID_CNT", "0"))+FRINGEVAC_TAN = os.environ.get("T2_FRINGEVAC_TAN", "0") == "1"+FRINGEVAC_RTOL = float(os.environ.get("T2_FRINGEVAC_RTOL", "0.35"))+++def fringevac_trim(coords, n_from_a: int, out_labels, labels_a_all, labels_b_all,+                   ca_full, cb_full, nov_thresh: float = 0.5, mode: str = "move",+                   seed: int = 0, grid: int = 16, span: float = 3.0,+                   max_frac: float = 0.25, vac_a: bool = False,+                   move_k: int = 5, dense_cnt: int = 5,+                   restore: bool = True, iters: int = 1,+                   maxcnt: int = 0, tangential: bool = False,+                   rtol: float = 0.35, mincnt: int = 0,+                   tgt_core: bool = False, scatter: bool = False,+                   jit_frac: float = 0.15, hybrid_cnt: int = 0):+    coords = np.asarray(coords, dtype=np.float64)+    n = coords.shape[0]+    info = {"fringevac_enable": True, "fringevac_nov_thresh": float(nov_thresh),+            "fringevac_mode": mode, "fringevac_max_frac": float(max_frac),+            "fringevac_vac_a": bool(vac_a), "fringevac_restore": bool(restore),+            "fringevac_iters": int(iters), "fringevac_maxcnt": int(maxcnt),+            "fringevac_mincnt": int(mincnt),+            "fringevac_hybrid_cnt": int(hybrid_cnt),+            "fringevac_tan": bool(tangential), "fringevac_rtol": float(rtol),+            "fringevac_applied": False,+            "fringevac_voxels_before": None, "fringevac_voxels_after": None,+            "fringevac_cls_both": None, "fringevac_cls_aonly": None,+            "fringevac_cls_bonly": None, "fringevac_cls_neither": None,+            "fringevac_n_vac_bonly": None, "fringevac_n_vac_neither": None,+            "fringevac_n_vac_aonly": None, "fringevac_cells_vac": None,+            "fringevac_n_edited": 0, "fringevac_novel_cells_kept": None,+            "fringevac_novel_cells_removed": None,+            "fringevac_rms_before": None, "fringevac_rms_after": None,+            "fringevac_restore_factor": None}+    if n < 50 or out_labels is None or ca_full is None or cb_full is None:+        return coords.astype(np.float32), None, info+    labs_all = np.asarray(out_labels).astype(str)+    types_a = set(np.asarray(labels_a_all).astype(str).tolist())+    types_b = set(np.asarray(labels_b_all).astype(str).tolist())+    novel = np.array(sorted(types_b - types_a))+    is_novel = np.isin(labs_all, novel) if novel.size else np.zeros(n, dtype=bool)+    cur = coords+    cur_labs = labs_all+    cur_novel = is_novel+    idx_map = np.arange(n)          # cur rows → original rows+    cum_scale = 1.0+    n_edited = 0+    cells_vac = 0+    rms_first = None+    for it in range(max(1, int(iters))):+        mu, evecs, rms0 = _frame_basis(cur, grid, span)+        if rms_first is None:+            rms_first = rms0+        vox = frame_voxels(cur, mu, evecs, rms0, grid, span)+        vox_a = frame_voxels(ca_full, mu, evecs, rms0, grid, span)+        vox_b = frame_voxels(cb_full, mu, evecs, rms0, grid, span)+        seta = set(vox_a.tolist())+        setb = set(vox_b.tolist())+        uq, inv, counts = np.unique(vox, return_inverse=True, return_counts=True)+        nov_per_vox = np.bincount(inv, weights=cur_novel.astype(np.float64),+                                  minlength=len(uq))+        novfrac = nov_per_vox / counts+        in_a = np.array([int(v) in seta for v in uq])+        in_b = np.array([int(v) in setb for v in uq])+        cls_both = in_a & in_b+        cls_aonly = in_a & ~in_b+        cls_bonly = ~in_a & in_b+        cls_neither = ~in_a & ~in_b+        bonly_sel = cls_bonly & (novfrac < nov_thresh)+        if mincnt and mincnt > 0:+            # keep the sparse fuzzy fringe (measured truth-like: query-3 style+            # trims of count<=2 b voxels LOST truth voxels); vacate only the+            # SOLID expansion-frontier voxels+            bonly_sel = bonly_sel & (counts >= mincnt)+        vac = cls_neither | bonly_sel+        if vac_a:+            vac = vac | cls_aonly+        if maxcnt and maxcnt > 0:+            vac = vac & (counts <= maxcnt)+        if it == 0:+            info.update(fringevac_voxels_before=int(len(uq)),+                        fringevac_cls_both=int(cls_both.sum()),+                        fringevac_cls_aonly=int(cls_aonly.sum()),+                        fringevac_cls_bonly=int(cls_bonly.sum()),+                        fringevac_cls_neither=int(cls_neither.sum()),+                        fringevac_rms_before=rms0)+        if not vac.any():+            break+        # whole-voxel atomicity: cheapest voxels first under the cell budget+        budget = int(np.floor(max_frac * cur.shape[0]))+        order = np.argsort(counts[vac], kind="stable")+        vac_voxels = uq[vac][order]+        vac_counts = counts[vac][order]+        chosen, used = [], 0+        for v, c in zip(vac_voxels, vac_counts):+            if used + int(c) > budget and used > 0:+                break+            chosen.append(v)+            used += int(c)+        if not chosen:+            break+        chosen = np.asarray(chosen, dtype=np.int64)+        cand = np.isin(vox, chosen)+        ci = np.flatnonzero(cand)+        keep_it = None+        if mode in ("move", "nudge") and hybrid_cnt and hybrid_cnt > 0:+            ccount = counts[inv[ci]]+            del_sel = ci[ccount <= hybrid_cnt]+            if del_sel.size:+                keep_it = np.ones(cur.shape[0], dtype=bool)+                keep_it[del_sel] = False+                cand = cand.copy()+                cand[del_sel] = False+                ci = ci[ccount > hybrid_cnt]+        info["fringevac_n_vac_bonly"] = int((+            (info.get("fringevac_n_vac_bonly") or 0) + int((vac & cls_bonly).sum())))+        info["fringevac_n_vac_neither"] = int((+            (info.get("fringevac_n_vac_neither") or 0) + int((vac & cls_neither).sum())))+        info["fringevac_n_vac_aonly"] = int((+            (info.get("fringevac_n_vac_aonly") or 0) + int((vac & cls_aonly).sum())))+        jit_scale = float(jit_frac) * (2.0 * span * max(rms0, 1e-12) / grid)+        if mode in ("move", "nudge"):+            if mode == "nudge":+                # shortest relocation that still vacates the voxel: nearest+                # NON-candidate cell (any voxel that stays occupied), which+                # minimises the pairwise-distance (d2_shape) and neighbourhood+                # (nbhd_mmd) damage per vacated voxel+                dense_ok = ~cand+            else:+                dense_ok = (~cand) & (counts[inv] >= dense_cnt)+                if dense_ok.sum() < move_k:+                    dense_ok = ~cand+            if tgt_core:+                # relocation targets ONLY inside consensus/a-side voxels: with+                # mincnt>0 the kept sparse fringe would otherwise just absorb+                # the nudged cells (fringe persists, occupancy unchanged)+                core_cell = (cls_both | cls_aonly)[inv] & (~cand)+                if int(core_cell.sum()) >= move_k:+                    dense_ok = core_cell+            if dense_ok.sum() < move_k:+                break+            newc = cur.copy()+            rng = np.random.default_rng(int(seed) + 1000 * it)+            cur_na = int((idx_map < int(n_from_a)).sum())+            mu_c = cur.mean(axis=0)+            r_all = np.linalg.norm(cur - mu_c, axis=1)+            # move each candidate onto its nearest DENSE cell (type-matched when+            # possible), jitter < voxel size so the destination voxel stays+            # occupied and no new voxels are created; b-origin rows first.+            # tangential=True restricts destinations to a similar radius+            # (|r_j - r_i| <= rtol·voxel) when enough exist, preserving the+            # radial/pairwise-distance profile (protects d2_shape).+            # scatter mode: assign each mover a DISTINCT random same-type+            # target cell (round-robin over a shuffled permutation) so the+            # relocated cells disperse through the core instead of piling+            # onto nearest-neighbour landing spots (pileups add near-zero+            # pairwise distances and hurt d2_shape)+            tgt_of = {}+            if scatter:+                for lab in np.unique(cur_labs[ci]):+                    pool = np.flatnonzero(dense_ok & (cur_labs == lab))+                    if pool.size == 0:+                        continue+                    perm = rng.permutation(pool)+                    tgt_of[lab] = perm+            scatter_pos = {lab: 0 for lab in tgt_of}+            for side in (True, False):+                sel = ci[(ci >= cur_na) == side]+                for i in sel:+                    if scatter and cur_labs[i] in tgt_of:+                        perm = tgt_of[cur_labs[i]]+                        j = int(perm[scatter_pos[cur_labs[i]] % perm.size])+                        scatter_pos[cur_labs[i]] += 1+                    else:+                        same = dense_ok & (cur_labs == cur_labs[i])+                        mask = same if int(same.sum()) >= move_k else dense_ok+                        if tangential:+                            band = mask & (np.abs(r_all - r_all[i]) <= rtol * (2.0 * span * rms0 / grid))+                            if int(band.sum()) >= 3:+                                mask = band+                        src = np.flatnonzero(mask)+                        d2 = ((cur[src] - cur[i]) ** 2).sum(axis=1)+                        j = src[int(np.argmin(d2))]+                    newc[i] = cur[j] + rng.normal(0.0, 1.0, cur.shape[1]) * jit_scale+            if keep_it is not None:+                newc = newc[keep_it]+        else:+            keep_it = np.ones(cur.shape[0], dtype=bool)+            keep_it[ci] = False+            newc = cur[keep_it]+        if restore and newc.shape[0] >= 10:+            rms_pre = rms_radius(newc)+            if rms_pre > 1e-9:+                cum_scale *= float(rms0 / rms_pre)+                newc = scale_to_rms(newc, rms0)+        n_edited += int(ci.size) + (0 if (keep_it is None or mode not in ("move", "nudge"))+                                    else int((~keep_it).sum()))+        cells_vac += int(used)+        if keep_it is not None:+            idx_map = idx_map[keep_it]+            cur_labs = cur_labs[keep_it]+            cur_novel = cur_novel[keep_it]+        cur = newc+    _, _, n_occ2 = occupancy_frame(cur, grid, span)+    if n_edited == 0:+        return coords.astype(np.float32), None, info+    keep_out = None+    if idx_map.size != n:+        keep_out = np.zeros(n, dtype=bool)+        keep_out[idx_map] = True+    info.update(fringevac_applied=True, fringevac_n_edited=n_edited,+                fringevac_cells_vac=cells_vac,+                fringevac_novel_cells_kept=int(cur_novel.sum()),+                fringevac_novel_cells_removed=int(is_novel.sum() - cur_novel.sum()),+                fringevac_voxels_after=n_occ2,+                fringevac_rms_after=rms_radius(cur),+                fringevac_restore_factor=cum_scale)+    return cur.astype(np.float32), keep_out, info++ def mix_converge(stage_a, stage_b, t: float, params: dict, alpha: float, view: str | None = None,                  proj_eta: float | None = None, proj_eta2: float | None = None):     t = float(t)@@ -2837,6 +3252,8 @@ def mix_converge(stage_a, stage_b, t: float, params: dict, alpha: float, view: s     info["out_labels"] = out_labels     info["mix_ia"] = ia     info["mix_ib"] = ib+    info["_ca_full"] = ca+    info["_cb_full"] = cb     aniso_info = {"aniso_enable": bool(ANISO_ENABLE), "aniso_damp": ANISO_DAMP}     if ANISO_ENABLE and coords.shape[0] >= 10:         coords, ai = aniso_reshape(coords, aligned_a, aligned_b, t, ANISO_DAMP)@@ -2871,12 +3288,11 @@ def main() -> None:     parser.add_argument("--out", required=True)     parser.add_argument("--seed", type=int, default=0)     parser.add_argument("--ablate", default=None,-                        help="mechanism-off control (node 50): 'mechanism' (or any name) disables "-                             "ONLY UNIVAL-TA (type-aware persistence-weighted κ): all w_type = 1, "-                             "κ_a = κ_b = 1, so UNIVAL keeps its uniform κ = 1.0. Inherited "-                             "mechanisms (UNIVAL, WIRESET, NBHDCOH, DETRX-SIDE, DETR, RECAL, ...) "-                             "stay ON in both runs, so the ablated output reproduces parent node 48 "-                             "bit-for-bit. ANISO2/RDENS/VDEF coordinate/variance probes stay off "+                        help="mechanism-off control (node 52): 'mechanism' (or any name) disables "+                             "ONLY SIDEFRIM (sparse-edge-voxel trimming of the output cloud). All "+                             "inherited mechanisms (UNIVAL-P, WIRESET, NBHDCOH, DETRX-SIDE, DETR, "+                             "RECAL, ...) stay ON in both runs, so the ablated output reproduces "+                             "parent node 50 bit-for-bit. ANISO2/RDENS/VDEF probes stay off "                              "(falsified in nodes 46/48)")     args = parser.parse_args()     # Mechanism-off control (node 45): DETR-SIDE-SHARED (origin-split shared-type@@ -2889,7 +3305,11 @@ def main() -> None:     detrshrink_on = DETRSHRINK_ENABLE     spatgate_on = SPATGATE_ENABLE     sidecluster = SIDECLUSTER-    origin_split_shared = DETR_SIDE_SHARED and not args.ablate+    # Node 52: --ablate disables ONLY SIDEFRIM (see sidefrim_on below). All+    # inherited node-50 mechanisms (UNIVAL-TA/MATCH/ADAPT, P) keep their+    # configured defaults in BOTH runs, so the ablated output reproduces+    # parent node 50 bit-for-bit.+    origin_split_shared = DETR_SIDE_SHARED     proj_eta = None     proj_eta2 = None @@ -3007,7 +3427,7 @@ def main() -> None:     # mechanism): group-size-adaptive strength. --ablate turns off the node-50     # mechanisms (TA, MATCH, ADAPT) → parent node 48 bit-for-bit.     wireset_kappa = WIRESET_KAPPA-    ws_adapt = WIRESET_ADAPT and not args.ablate+    ws_adapt = WIRESET_ADAPT     expr, ws_info = wireset_reset(expr, info.get("out_labels"), stage_a, stage_b,                                   info.get("mix_ia"), info.get("mix_ib"),                                   int(info.get("n_from_a", 0) or 0),@@ -3021,10 +3441,10 @@ def main() -> None:     # --ablate turns off ONLY the node-50 mechanisms (TA + MATCH) → parent     # node 48 bit-for-bit.     unival_kappa = UNIVAL_KAPPA-    ta_enable = UNIVAL_TA and not args.ablate-    ta_ka = 1.0 if args.ablate else UNIVAL_KA-    ta_kb = 1.0 if args.ablate else UNIVAL_KB-    match_enable = UNIVAL_MATCH and not args.ablate+    ta_enable = UNIVAL_TA+    ta_ka = UNIVAL_KA+    ta_kb = UNIVAL_KB+    match_enable = UNIVAL_MATCH     expr, uv_info = unival_align(expr, info.get("out_labels"), stage_a, stage_b,                                  float(t), int(info.get("n_from_a", 0) or 0),                                  unival_kappa, UNIVAL_TAU, UNIVAL_CAP, UNIVAL_MIN_CELLS,@@ -3034,7 +3454,7 @@ def main() -> None:                                  match_enable=match_enable, match_beta=UNIVAL_MATCH_BETA,                                  match_rho=UNIVAL_MATCH_RHO, match_topk=UNIVAL_MATCH_TOPK,                                  match_norm=UNIVAL_MATCH_NORM,-                                 wp=(1.0 if args.ablate else UNIVAL_P))+                                 wp=UNIVAL_P)     info.update(uv_info)     sc_info = {"sidecluster": sidecluster}     if sidecluster and expr.shape[0]:@@ -3045,7 +3465,7 @@ def main() -> None:     # output cloud's own PCA frame (see ANISO2_* config docs). FALSIFIED on the     # proxy A half (α∈{−0.15,0.05,0.15,0.40,0.70} all below parent): d2_shape     # degrades 20–40× faster than occupancy_dice gains. Submitted default α=0.-    aniso2_on = ANISO2_ENABLE and ANISO2_ALPHA != 0.0 and not args.ablate+    aniso2_on = ANISO2_ENABLE and ANISO2_ALPHA != 0.0     a2_info = {"aniso2_enable": bool(ANISO2_ENABLE), "aniso2_alpha_cfg": ANISO2_ALPHA,                "aniso2_applied": bool(aniso2_on and coords.shape[0] >= 10)}     if aniso2_on and coords.shape[0] >= 10:@@ -3054,7 +3474,7 @@ def main() -> None:     info.update(a2_info)     # RDENS (node 46 backup mechanism): radial shell-density probe (PLAN step     # 4). --ablate turns this off too → output bit-for-bit identical to parent.-    rdens_on = (RDENS_ENABLE and coords.shape[0] >= 10 and not args.ablate+    rdens_on = (RDENS_ENABLE and coords.shape[0] >= 10                 and abs(RDENS_SLO - 1.0) + abs(RDENS_SHI - 1.0) > 0.0)     rd_info = {"rdens_enable": bool(RDENS_ENABLE), "rdens_slo_cfg": RDENS_SLO,                "rdens_shi_cfg": RDENS_SHI, "rdens_applied": bool(rdens_on)}@@ -3062,6 +3482,58 @@ def main() -> None:         coords, rdi = rdens_probe(coords, RDENS_SLO, RDENS_SHI, RDENS_K)         rd_info.update(rdi)     info.update(rd_info)+    # SIDEFRIM (node 52, PLAN mechanism): sparse-edge-voxel trimming of the+    # OUTPUT cloud inside the occupancy_dice metric frame (see SIDEFRIM_*+    # config docs). Coordinates-only + row selection; expression VALUES are+    # never modified. --ablate disables ONLY this step → parent node 50+    # bit-for-bit. With a single input stage (no bracket) there are no b-side+    # cells and sides='b' trims nothing (no-op fallback).+    sidefrim_on = (SIDEFRIM_ENABLE and SIDEFRIM_THRESH > 0 and not args.ablate+                   and coords.shape[0] >= 50)+    sf_info = {"sidefrim_enable": bool(SIDEFRIM_ENABLE),+               "sidefrim_thresh_cfg": SIDEFRIM_THRESH,+               "sidefrim_applied": False}+    if sidefrim_on:+        coords, sf_keep, sfi = sidefrim_trim(+            coords, int(info.get("n_from_a", 0) or 0), SIDEFRIM_THRESH,+            SIDEFRIM_MAXFRAC, SIDEFRIM_SIDES, SIDEFRIM_MODE, args.seed,+            SIDEFRIM_GRID, SIDEFRIM_SPAN, SIDEFRIM_MOVE_K)+        sf_info.update(sfi)+        if sf_keep is not None and sfi.get("sidefrim_applied"):+            expr = expr[sf_keep]+            if info.get("out_labels") is not None:+                info["out_labels"] = np.asarray(info["out_labels"])[sf_keep]+            info["n_from_a"] = int(min(int(info.get("n_from_a", 0) or 0),+                                       int(sf_keep.sum())))+            info["n_from_b"] = int(sf_keep.sum()) - info["n_from_a"]+            info["n"] = int(expr.shape[0])+    info.update(sf_info)+    # FRINGEVAC (node 52 backup mechanism): class-aware fringe-voxel vacating+    # (see FRINGEVAC config docs). Same weakness (occupancy_dice) as SIDEFRIM,+    # different discriminator: voxel coverage classes in the bracket stages'+    # own aligned clouds instead of raw sparsity. --ablate disables this too.+    fringevac_on = (FRINGEVAC_ENABLE and not args.ablate and coords.shape[0] >= 50)+    fv_info = {"fringevac_enable": bool(FRINGEVAC_ENABLE),+               "fringevac_applied": False}+    if fringevac_on:+        coords, fv_keep, fvi = fringevac_trim(+            coords, int(info.get("n_from_a", 0) or 0), info.get("out_labels"),+            stage_a.labels, stage_b.labels, info.get("_ca_full"), info.get("_cb_full"),+            FRINGEVAC_NOV, FRINGEVAC_MODE, args.seed, SIDEFRIM_GRID, SIDEFRIM_SPAN,+            FRINGEVAC_MAXFRAC, FRINGEVAC_VAC_A, FRINGEVAC_MOVE_K, FRINGEVAC_DENSE_CNT,+            FRINGEVAC_RESTORE, FRINGEVAC_ITERS, FRINGEVAC_MAXCNT, FRINGEVAC_TAN,+            FRINGEVAC_RTOL, FRINGEVAC_MINCNT, FRINGEVAC_TGT_CORE,+            FRINGEVAC_SCATTER, FRINGEVAC_JIT, FRINGEVAC_HYBRID_CNT)+        fv_info.update(fvi)+        if fv_keep is not None and fvi.get("fringevac_applied"):+            expr = expr[fv_keep]+            if info.get("out_labels") is not None:+                info["out_labels"] = np.asarray(info["out_labels"])[fv_keep]+            info["n_from_a"] = int(min(int(info.get("n_from_a", 0) or 0),+                                       int(fv_keep.sum())))+            info["n_from_b"] = int(fv_keep.sum()) - info["n_from_a"]+            info["n"] = int(expr.shape[0])+    info.update(fv_info)     keep = {k: info.get(k) for k in ("t", "n", "rms_a", "rms_b", "out_rms", "n_shared_types", "z_dot", "z_flipped",                                      "align", "alpha", "n_shared_types_converged", "within_type_std_rel",                                      "between_type_mean_dist_rel", "n_from_a", "n_from_b",@@ -3088,9 +3560,32 @@ def main() -> None:                                         "bracket_clip", "n_clamped_cells",                                        "pair_beta", "n_paired_types", "n_pairs", "pair_within_std_rel",                                        "pair_orth_var_rel", "pair_dist_over_diam",-                                        "rdens_enable", "rdens_slo_cfg", "rdens_shi_cfg", "rdens_applied",-                                        "rdens_s_lo", "rdens_s_hi", "rdens_k", "rdens_layer_frac",-                                        "rdens_fac_min", "rdens_fac_max", "rdens_rms",+                                         "rdens_enable", "rdens_slo_cfg", "rdens_shi_cfg", "rdens_applied",+                                         "rdens_s_lo", "rdens_s_hi", "rdens_k", "rdens_layer_frac",+                                         "rdens_fac_min", "rdens_fac_max", "rdens_rms",+                                         "sidefrim_enable", "sidefrim_thresh_cfg", "sidefrim_applied",+                                         "sidefrim_thresh", "sidefrim_max_frac", "sidefrim_sides",+                                         "sidefrim_mode", "sidefrim_n", "sidefrim_n_from_a",+                                         "sidefrim_voxels_before", "sidefrim_voxels_after",+                                         "sidefrim_sparse_voxels", "sidefrim_n_candidates",+                                         "sidefrim_n_edited", "sidefrim_n_pure_b_sparse",+                                         "sidefrim_rms_before", "sidefrim_rms_after",+                                         "sidefrim_restore_factor",+                                         "fringevac_enable", "fringevac_applied",+                                         "fringevac_nov_thresh", "fringevac_mode",+                                         "fringevac_restore", "fringevac_iters",+                                         "fringevac_maxcnt", "fringevac_mincnt", "fringevac_tan", "fringevac_rtol",+                                         "fringevac_hybrid_cnt",+                                         "fringevac_max_frac", "fringevac_vac_a",+                                         "fringevac_voxels_before", "fringevac_voxels_after",+                                         "fringevac_cls_both", "fringevac_cls_aonly",+                                         "fringevac_cls_bonly", "fringevac_cls_neither",+                                         "fringevac_n_vac_bonly", "fringevac_n_vac_neither",+                                         "fringevac_n_vac_aonly", "fringevac_cells_vac",+                                         "fringevac_n_edited", "fringevac_novel_cells_kept",+                                         "fringevac_novel_cells_removed",+                                         "fringevac_rms_before", "fringevac_rms_after",+                                         "fringevac_restore_factor",                                         "aniso2_enable", "aniso2_alpha_cfg", "aniso2_applied",                                         "aniso2_alpha", "aniso2_eigfrac_a", "aniso2_eigfrac_b",                                         "aniso2_eigfrac_out_before", "aniso2_eigfrac_target",

调研来源?调研员查到并用到的知识条目和文献检索结果（只列标题和编号）。

用到的知识库条目

分析结果?分析员写的 ANALYSIS.json：改了什么、各组分数怎么变、假设是否成立、经验和下一步建议。

对话摘要?每个角色和大模型对话的统计：轮数、工具调用、用时、token 数和最后的回答摘录；原始记录只给路径。

只给统计和最后回答的摘录；完整对话请到原始记录位置里列出的文件看。

分析员

ANALYSIS.json written

工程师

All verified. Final summary:

## 节点 52 完成

**做了什么**：PLAN 的 SIDEFRIM（稀疏边缘体素 b 侧细胞删除）按原样实现并证否（65.060 < 父锚点 65.131，occ raw 反降）；诊断发现真因——mix 输出是两括号阶段对齐云的**并集**（243 占据体素 vs 目标 ≈171），超额集中在「仅 b 侧覆盖且非 novel 类型主导」的扩张前沿体素，而稀疏边缘体素约一半是真值。据此改交备选机制 **FRINGEVAC**：在 occupancy_dice 度量框架内按覆盖类（Va/Vb 现场投影）+ 类型新颖度整片识别 79 个超额体素，把其中 669 个细胞就近迁到同型非候选细胞位置（nudge），RMS 精确复原；表达与细胞集合逐位不动。

**查分结果**（A 半，17/20 次）：seed 0 **65.402（父 +0.27）**，配对差 seed1 +0.28、seed2 +0.42（均值 +0.32，三种子同号）。occ raw 0.8066→0.8494、skill 0.421→0.530 首次越过地板（+0.90 pts）；代价 d2 −0.50、nbhd −0.12。共测 12 种解码：删除模式毁 DE/mmd（63.62）、部分撤离只在边缘内洗牌（64.43–64.99）、切向/scatter 落点毁 d2（64.77/63.70）、nov=1.01 误伤真值新生结构（64.94）。`--ablate` = 父逐位一致；伪装视图逐位一致；单输入退路正常；3.1 s / <1 GB。

**下一步最值得试**：(1) occ 剩余超额 ~51 体素是撤离后 PCA 框架重绑定伪影，解决框架稳定性可再压 P（iters=2 已证会吃到真值）；(2) 把覆盖类框架转向 local_spatial（权重 25+门）：nov 主导 b-only 体素内是"晚侧表达在中间位置"的细胞，做类型匹配的邻域一致性校正；(3) d2 代理 W1(变体,父)≈scorer d2−0.0047（7 变体误差 ≤0.001），后续节点可免费筛选坐标策略。

调研员

除后 RMS 变化量。确认 b 侧稀疏边缘体素确实存在（若占比 <1% 则机制前提不成立，转备选）。\n步骤 2（实现 SIDEFRIM）：(a) 在 16³ 网格中标记稀疏边缘体素（占据细胞数 ≤ sparse_thresh，初值 2，搜索范围 1–4）；(b) 仅删除落在这些体素中且起源为 b 侧的细胞（a 侧不动，保护已有表达-位置配对）；(c) 删除后对剩余坐标做 RMS 恢复缩放（乘 r_orig/r_new），保持 scale_log_ratio 不退化；(d) 设最大删除比例上限 max_frac（初值 0.04，搜索 0.02–0.08），防止过度切除。坐标致密化后不改动任何表达值。\n步骤 3（查分）：先跑默认配置（sparse_thresh=2, max_frac=0.04），比较四项形状指标与父：期望 occupancy_dice raw 上升（目标 ≥0.83）、d2_shape raw 不劣化（≤0.0067）、scale_log_ratio 仍 <0.02；同时盯 mmd_u 和 neighborhood_mmd 不因细胞删除而恶化（若 mmd_u raw 升 >5% 则停止）。若默认有效，再扫 sparse_thresh {1,3,4} × max_frac {0.02,0.06}，共 ≤6 次查分。\n步骤 4（种子确认）：最优配置跑 seed 1/2，确认三种子均值 > 父 65.71 + 0.5。\n单输入阶段退路：若视图只有一个输入阶段（无括号），mix 退化为 copy，无 b 侧细胞，SIDEFRIM 自然不删除任何细胞（空操作），输出等于父。\nvec-score 快速筛选：每次只跑 proxy A 半 seed 0；若两次查分差 <0.5，用 seed 1 复跑确认。",
  "expected_groups": ["shape_scale"],
  "risks": "1) 父 50 的 UNIVAL/WIRESET 表达修改可能改变了细胞的空间分布，使稀疏边缘体素的组成与节点 47 不同——步骤 1 诊断可提前发现（若 b 侧边缘占比 <1% 则前提不成立）。2) 删除细胞可能改变 15-NN 邻域结构，损害 neighborhood_mmd——每次查分必须同时看 nbhd raw；若 nbhd raw 升 >0.002 则加 max_frac 下限或停止。3) RMS 恢复缩放若精度不够可能微损 scale_log_ratio——检查 log-ratio 变化 <0.005。4) 改善可能仅 +0.2–0.3（与节点 47 一致），接近但略高于 T2 ~1 分噪声——用三种子均值确认。",
  "family_id": "T2EI-06",
  "mechanism": "在 occupancy_dice 的 16³ 网格框架内识别并切除 b 侧来源的稀疏边缘体素中的细胞，再 RMS 恢复缩放，使混合云的占据体素更紧凑、匹配目标云的占据形状，修复 occupancy_dice 低于地板的结构性占据超额。",
  "vs_constant_shift": "SIDEFRIM 不是对所有细胞施加统一位移或缩放：它只在占据网格的边缘稀疏体素中、只针对 b 侧来源细胞做选择性删除，a 侧和内部细胞坐标不动；删除后做 RMS 恢复而非全局缩放。常数位移改变所有细胞的位置但不改变占据体素集合；SIDEFRIM 改变的是点云的占据形状（减少多余体素），这是 occupancy_dice 直接度量的量。",
  "mechanism_evidence": "Engineer 应记录：(1) 删除的细胞数及其在网格中的体素分布（应集中在边缘、b 侧）；(2) 占据体素数变化（应减少）；(3) occupancy_dice raw 变化（应从 0.8086 上升）；(4) d2_shape 和 scale_log_ratio raw 是否保持不变（坐标致密化 + RMS 恢复不应改变成对距离分布和绝对尺度）；(5) mmd_u 和 nbhd raw 是否不变或变化 <1%（表达值未动，仅减少少量细胞）。若占据体素数不变或减少的体素不在边缘，说明机制未运行。",
  "mechanism_off_control": "设 sparse_thresh=0（无体素满足 ≤0 条件，不删除任何细胞）或显式 flag T2_SIDEFRIM=0，跳过整个切除步骤。预期输出与父 50 逐位一致（X digest 相同），榜分差 0.00。harness --ablate mechanism 应确认 ablated prediction 与 parent 相同。",
  "sources": []
}
```

审查员