feat(activity-ops): 启动表单两格按芯片类型联动 —— 候选带分组键,先填的那格是锚

契约:launchOption 加 group/groupLabel(x-options.group 从字典表现读人读名)、
launchParam 加 linkGroup(x-link 结组);api-report 已随 --update 入库。
前端 launch-link.ts 纯函数管三条口径:锚摆全量、其余按锚的分组键收窄
(未标类型殿后一组,新增照走);锚粘着 —— 清空只解除收窄不换锚,人改得了主意。
服务端不据此立墙:combo 本就收候选之外的值,类型一致归 S1 收步判据
sub_eval_part_distinct_chip_type_id = 1(数得出来的门)。
W05 清单两格挂上 x-link: chip-type;文档同步。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LKMZDwMbyKzjw6Hembwvet

CLAUDE.md

@@ -1696,7 +1696,15 @@
   写出来的数就得排在后面)/ 方向相反的依赖拆两笔写、中间夹子表 / `gateLedgers` 同时管
   「闸要求非空」与「确认时并进正式表」两件事,漏想一半就会悬空引用或永久卡死。
   `pnpm gates` 退出码 0(2447 passed | 34 skipped)。
-- **W05 数据工单换版面 + 两条渲染机制的实锚**(2026-08-30,`part-substitution-assessment@2.2.2`,
+- **W05 数据工单换版面已退回**(2026-08-31 用户:「改了 ui 之后这个版本我感觉有点问题」):
+  `report.ts` / `target-style.ts` / `activity.test.ts` 三个文件**逐字节恢复**到换版面之前
+  (45cec82 的样子),包版本 **2.3.0**(内容是旧版面 —— `store.manifest` 不传版本时取
+  **最近安装**的那一条,不是版本号最大的,所以退源码必须配一个新号装进去才真生效)。
+  **换版面那一版原样活在分支 `feat/w05-view-swap`**(HEAD `1373eb4`),随时切得回去;
+  下面这条记的是它的账,留着当索引 —— 里面三条渲染机制的实锚(宿主闭合标签 / 行内
+  class-of 只认行作用域 / data-by 回落)与平台侧探针测试**不随退回作废**,它们钉的是
+  平台行为,测试与目标件 html 都还在主支上。
+- **(已退回,见上条)W05 数据工单换版面 + 两条渲染机制的实锚**(2026-08-30,`part-substitution-assessment@2.2.2`,
   用户给了新目标件 `docs/ss02-act-05-new/ACT-WORK-05-数据工单-PN主数据创建.html`):
   `input-supplement` 整张照它重排 —— **两条并列轨道**(每颗料一条:档案卡 + 主数据 + 类型选择)
   + `<details>` 新增类型面板(chip_type / type_param 两张表原样搬入,独立「核心参数字段」区退役)
@@ -1726,6 +1734,112 @@
   终审评审 0 Critical / 0 Important / 1 Minor(注释漂移,已修)。跑完 reset-runs,
   主数据与活动缓存零残留。
 
+- **W05 三张工单件视图层按 C 端重设计**(2026-08-31 用户定:「不要后台管理端的样子,
+  要给客户用的 C 端界面;可加主题 SVG 与动画;只保留功能,视图层可以推翻重新设计」,
+  `part-substitution-assessment@2.6.0`):「精密检测报告」语言 —— 深色电路板夜景 hero
+  三张各一幕(建档台:两颗料的芯片铭牌由 `mine:sub_eval.part` 铺行、不在库虚线描边 /
+  对决量尺:原 PN→候选 PN + 推荐等级徽章 / 落账席:慢转印章环 + 一句话结论),正文瓷白
+  报告版面(丝印小标 / 比对光谱分布带 / 落账三卡大数);动画全 transform/opacity、
+  reduced-motion 全静;验收两件仍是验收绿 #0aa294。**功能绑定逐项保留**:可编辑表 DOM
+  结构逐字节不动(收值链路按结构认元素),机制规则(计数器/种子行显隐/gate-bar :has/
+  overflow-x)逐字保留仍被测试钉着。设计系统收进 `views/style.ts`,`target-style.ts`
+  退役(目标件时代的锚),report.ts 的 vtok/badgeCss 收归 badge.ts(销一笔 debt)。
+  离线预览自审(真 renderView + 造景数据,不碰测试台)逮到并修掉三洞:kv 占位破折号
+  连嵌套徽标一起吃(改只认直接子级)、光谱条里渗计数字、加行钮没 base display:none。
+  104 包内测 + 2516 全仓绿,两条新锚变异验证过,2.6.0 装库 SQL 核过。
+  (2.5.0 是同日另一会话的启动表单芯片类型联动 —— 两会话同 checkout,版本号先问库。)
+
+- **W05 数据工单三病一改:档案卡上桌,prune 跳过已落地**(2026-08-31 用户实测三连 +
+  「设计只是头上加了动画」,`part-substitution-assessment@2.7.0`):
+  ①「类型自己给上了」= data-by 行缺键落回外层(debt I3 原样咬人)—— 查名 pill 摆出案卷锚
+  (原 PN)的类型;治:守卫认 `selectCurrent` 按**行作用域**写的 `option[selected]`,
+  真选上才摆名、没选摆「待选择」胶囊。**守卫必须单层 `:has`** —— `:has()` 里嵌 `:has()`
+  是非法选择器,整条被浏览器静默丢弃(第一版就栽在这,预览截图逮回),挂共同祖先上写。
+  ②「品牌…点保存根本不会保存」= 块① 行源是 `sub_eval.part` 而那张案卷表没有主数据列,
+  `renderTemplate` 只认行作用域 —— 保存真落草稿、显示与孪生件永远空白(四步重写后的潜伏缺陷,
+  真人一填才现形;e2e 走 API、旧浏览器走查在 swap 版上,两条线都照不到)。治:行源改
+  `mine:parts.profile` 本身(S1 ④ prune:true 恒有两行),行里天生有全部列。
+  ③「改回同一类型,下面还是两个类型」= ②③ 自投影为绕「已落地行撤不掉」的死锁特意不带
+  prune,没落地的陈旧行也跟着积。治在平台:`draftDrop` 加配方专用旗 `skipLanded`
+  (跳过并出声「N 行已随数据工单入库、这一笔不清它」,不炸),②③ 恢复 prune:true ——
+  H35 案例 2 不再死锁,debt「prune 与确认即入库的架构性冲突」销账。quiet 拍仍不撤行(F3),
+  清理落在每次确认工单那一拍。
+  ④设计:块① 从 11 列横滑表推翻成**电路板工作台** —— 深色板底上两张可就地编辑的芯片
+  档案卡(SOIC 封装 SVG + 角色/在库徽 + 类型选择行 + 双栏主数据格),编辑态整卡变表单;
+  三级占位(必填红/建议橘)上卡与参数值表(徽标包装的必填格用单层 `:has` 认裸 class 补胶囊);
+  参数值表所属料号列加角色徽。测:107 包内(守卫/行源/嵌套零 data-col 三锚变异验证)+
+  auto-runner skipLanded(变异验证)+ 2520 全仓;2.7.0 装库 SQL 核过。
+  另:1838474「在库」是真的 —— 用户此前某单 land_master 落过它(正式表 chip_type_id 为空)。
+
+- **W05 第二轮:比对基准合一卡 + `prune:'live'` + 蓝图板底**(2026-08-31 用户:「类型和字段
+  合并成一个卡…两个芯片同类型就只显示一种,现在只变多不变少」「卡片容器黑色和页面不搭」,
+  `part-substitution-assessment@2.8.1`):①类型+字段并成**比对基准卡**(只读、跟手)——
+  不列 mine: 镜像(积旧选择,撤行只在确认拍跑),按案卷锚嵌套查字典,保存即换脸、同类型
+  恰显一种;新建类型收进 details 抽屉(零脚本),编辑表原样在抽屉里。②契约新增
+  `prune:'live'`(quiet 拍也撤,**只给人加不了行的表**用 —— F3 防「人刚加的行被撤」,
+  这种表没有该风险;有加行钮的表永远不许用):W05 参数骨架改 'live',改类型参数行跟手换;
+  static-audit 盖住 'live',规范 §4.6 纪律 5 补反面特例。③档案卡板底深色→**浅色蓝图**
+  (强调色晕染+淡格线),整页只剩 hero 一处深色。锚测各变异验证;2.8.1 装库核过;
+  :8787 watcher 又断,应急手起 node dist/main.js(14:41)。
+
+- **W05 第三轮:数据工单去表格化 —— 翻面芯片卡 + 平台多宿主收值**(2026-08-31 用户:
+  「界面东西太多做成几个区域;类型与字段做成和芯片卡差不多的卡片;芯片卡与核心参数值
+  合并,点击翻转、背面写参数、悬浮看得出能翻;这个界面都不再需要表格展示数据」,
+  `part-substitution-assessment@2.9.0`):主画面零表格 —— 基准卡瓷贴化(类型丸+字段
+  瓷贴),芯片卡纯 CSS 翻面(checkbox+:has 零脚本,悬浮提示丸+侧倾;主数据编辑锁正面、
+  参数编辑自动翻背面),背面参数瓷贴就地可改;说明四条收折叠;表格只剩新建类型抽屉
+  (加行机制认 tr)。**平台扩面:ui-kit ViewContainer 多宿主收值** —— 同一地址
+  querySelectorAll 全数进来,**格子只归最近的 data-edit 祖先**(嵌套异地址排除;不带
+  data-edit 的嵌套 data-rows 行为原样,两条 collect 旧钉测不动);addRow 仍单宿主。
+  三脚各留一条:CSS 注释写「data-col=」原文会踩翻别件的字面断言(选择器与注释都不许);
+  `.flip-cue i` 特异度压过 `.cue-back{display:none}`;host 计数断言别拿渲染后的数去数
+  模版源码。ui-kit multihost 3 测(变异验证)+ 包内 110 + 2528 全仓;2.9.0 装库核过;
+  浏览器实测点卡真翻、参数编辑双卡自动翻背成表单。
+
+- **W05 第四轮九连改:笔↔软盘卡角编辑 + 只选不建**(2026-08-31 用户一次点齐九件,
+  `part-substitution-assessment@2.10.0`):①编辑闸两行退役 → 卡右上角笔(开当前面)↔
+  软盘(存)+叉(弃),按钮即 data-edit-open/save/cancel 触发器,按面显隐全在样式表;
+  ②ui-kit `mirrorTwins` 修「保存一瞬间下拉变数字」—— 镜选项文案不镜 value,顺手把
+  selected 拨到人选项(守卫 CSS 认它);③渲染器 twinInputs 认 `data-ph` 落 placeholder;
+  ④参数说明空着什么都不摆;⑤芯片档案区提到比对基准前;⑥**新建芯片类型整条路移除**
+  (只选已有):抽屉/种子行/Critical-1 修法/thead 回归网退役,S1 配方八笔→六笔(②③
+  自投影删),gateLedgers 收窄 profile+parameter,e2e 案例 0 改选既有 type_1,七条退役
+  钉测 it.skip 留墓志铭;⑦题头回原目标件浅蓝渐变(hd-light,夜景只留验收两件);
+  ⑧对话区执行卡不摆「参考信息」(basis 随卡数据照旧);⑨比对基准降噪:字段丸 +
+  说明悬浮气泡。2525 全仓四门绿,2.10.0 装库六探针核过,:8787 重启载入新渲染器。
+
+- **W05 第五轮:按卡独立编辑 + 顶条合并点名**(2026-08-31 用户四连,
+  `part-substitution-assessment@2.11.0`):①「不要做联动」—— ui-kit 新增 `scopedTargets`:
+  开合作用域跟着触发钮走(钮在本地址宿主的行里→只这一行;钮在别的宿主行里→行内的
+  本地址宿主;外部闸→全宿主老行为),收值仍按地址全量、「只写真改了的行」服务端把关;
+  编辑态 CSS 全改按卡(.dossier.on),同地址同时只开一张卡(快照键按地址,双开互踩)。
+  ②逐块「还差 N 行必填」红带撤下,_missing/_missing_keys 并进顶条「还差什么」两行子行
+  (v-0 自收)。③比对基准/芯片档案区序换回(基准在前)。④比对基准换层叠双封装 SVG
+  (t-ghost 淡剪影 —— 一类而非一颗)。ui-kit 35 测 + 包内 105 + 2528 全仓;2.11.0 装库
+  五探针核过;浏览器实证单卡独立翻背编辑。
+
+- **W05 第六轮:确认闸条件档 + 量高可缩 + 互换动画**(2026-08-31 用户三连,
+  `part-substitution-assessment@2.12.0`):①「类型不一致还能确认」—— 平台加**确认闸
+  条件档**:配方 card 声明 `gateWhen`(S-FEEL 只读基座读数)+`gateWhenSay`,受理回传前
+  `submitGate` 按声明表现读 rows/missing/tally/distinct 现算,为假 400 用发卡人那句话;
+  静态审同 when 一套;评估不出的条件不成墙。W05 钉 `parts_profile_distinct_chip_type_id
+  <= 1`(钉 profile 本表零滞后 —— 钉 sub_eval.part 要等配方 tick 会误拦刚存完就确认的人),
+  profile.chip_type_id 加 distinct。②「底部没东西还能滑一截」—— ViewContainer 量高
+  documentElement.scrollHeight 以 iframe 高为下限,**只涨不缩**;改 body 优先(margin 0
+  的 body 才是内容自己的高)。③卡间动画换「可替换」语义:对向双信号点互穿(卡后走、
+  缝里现身)+ 中央 ⇄ 徽呼吸。2531 全仓;2.12.0 装库核过;:8787 重建重启。
+
+- **W05 互换动画第二稿:与卡同级的实体动画道**(2026-08-31 用户:「不要做到背景板上会被
+  卡片覆盖,和卡片做到一级,压缩一点卡片」,`part-substitution-assessment@2.12.1`):
+  .dossiers 三列网格(1fr·76px·1fr),中间列是实体动画道 —— ⇄ 徽呼吸 + 双点绕徽轨道
+  对转(sw-orbit),总线虚线在道里连两卡;窄屏单列收道。浏览器两帧相位实证。
+
+- **W05 红条可灭:gate_state 开关列**(2026-08-31 用户:「没有必填了红色区域就不要显示」,
+  `part-substitution-assessment@2.13.0`):病根 —— gate_reason 清空串按列归型不落笔
+  (jsonb 保旧值),红条亮过灭不了。治:案卷加 `gate_state`(tally open/clear,双向真写),
+  与发卡条件共用 GATE_OPEN_WHEN 一处真源;红条 data-class-of 投影 v-clear 收起。
+  **教训:要用「清成空串」表达状态翻转的列,空值不落笔会把它焊死 —— 开关就该是开关列。**
+
 ## 文档权威地图
 
 | 层 | 文件 | 说明 |

activities/part-substitution-assessment/__tests__/activity.test.ts

@@ -287,6 +287,28 @@ describe('契约', () => {
     }
   });
 
+  /*
+   * 按芯片类型联动(2026-08-31 用户定):候选带上分组键与人读名,两格结成一组。
+   * 分组键指的那一列必须是候选表**真有**的列(`parts.profile.chip_type_id`),
+   * 字典指的那一张表也得是本活动声明过的 —— 写错地址不会炸,只会静默不联动(服务端 warn 一句),
+   * 而「静默不联动」正是没人会发现的那种坏。
+   */
+  it('两格按芯片类型联动:候选带分组键 + 字典换人读名,x-link 同名结成一组', () => {
+    const props = manifest.contract.input.data['properties'] as Record<string, Record<string, unknown>>;
+    const ledgerOf = (address: string) => manifest.declarations.ledger.find((l) => `${l.domain}.${l.object}` === address);
+    for (const key of ['originalInternalPn', 'candidateInternalPn']) {
+      expect(props[key]?.['x-link']).toBe('chip-type');
+      const options = props[key]?.['x-options'] as { group?: { column?: string; ledger?: string; value?: string; label?: string } };
+      expect(options.group).toEqual({ column: 'chip_type_id', ledger: 'parts.chip_type', value: 'type_id', label: 'type_name' });
+      // 分组键那一列在候选表上真的存在
+      expect(ledgerOf('parts.profile')?.fields.some((f) => f.name === options.group?.column)).toBe(true);
+      // 换名字典的两列也真的存在
+      const dict = ledgerOf('parts.chip_type');
+      expect(dict?.fields.some((f) => f.name === options.group?.value)).toBe(true);
+      expect(dict?.fields.some((f) => f.name === options.group?.label)).toBe(true);
+    }
+  });
+
   it('零工具 —— 这是这次重写的立场,不是疏漏', () => {
     expect(manifest.contract.resources.tools).toEqual([]);
     expect(manifest.declarations.tools).toEqual([]);
@@ -450,8 +472,9 @@ describe('报告模版:编辑面与只读面各就各位', () => {
 
   it('每个可编辑格子的 data-col 都在对应台账对象的声明里(input-supplement 一屏四张表,四张台账对象的声明并起来看;difference-review 一张表)', () => {
     const cases: Array<[string, Array<[string, string]>]> = [
-      ['input-supplement', [['parts', 'profile'], ['parts', 'chip_type'], ['parts', 'type_param'], ['parts', 'parameter']]],
-      ['difference-review', [['substitution', 'difference_item']]],
+      ['input-supplement', [['parts', 'profile'], ['parts', 'parameter']]],
+      /* 件② 2026-08-31 起多一张:收口四格可就地改,写向 substitution.relation */
+      ['difference-review', [['substitution', 'difference_item'], ['substitution', 'relation']]],
     ];
     for (const [view, objects] of cases) {
       const cols = new Set([...viewHtml(view).matchAll(/data-col="([^"]+)"/g)].map((m) => m[1] ?? ''));
@@ -485,12 +508,17 @@ describe('报告模版:编辑面与只读面各就各位', () => {
     await expect(host.base.interaction.pushHtml('<div><script>x()</script></div>')).rejects.toThrow(/无脚本执行权/);
   });
 
-  /* 解封(2026-08-29,Task 9):`landing-confirm` 补齐,三张全能验了 —— 都走同一个 `doc()` 壳。 */
-  it('三张模版的外壳都是搬自目标件的 page/card,不再含 E04/I01 那套视觉底(.proto-root)的痕迹', () => {
+  /*
+   * 解封(2026-08-29,Task 9):三张全走同一个 `doc()` 壳。2026-08-31 视图层重设计后,
+   * 壳不再「搬自目标件」而是活动自己的设计系统(style.ts),但骨架类名不变:
+   * card-head 是电路板夜景 hero,card-foot 是丝印条;E04/I01 那套视觉底(.proto-root)仍不许出现。
+   */
+  it('三张模版共用同一个 page/card 外壳(card-head hero + card-foot),不含 E04/I01 视觉底(.proto-root)', () => {
     for (const view of VIEWS) {
       const html = viewHtml(view);
       expect(html, view).toContain('class="card-head"');
       expect(html, view).toContain('class="card-foot"');
+      expect(html, view).toContain('class="hero-title"');
       expect(html, view).not.toContain('proto-root');
     }
   });
@@ -527,11 +555,10 @@ describe('报告模版:编辑面与只读面各就各位', () => {
 });
 
 /*
- * 件① 评估输入补全(2026-08-29 Task 7/7b;**2026-08-30 照新目标件换版面**):S1 的配方
- * 缺什么就发一张数据工单,`view: 'input-supplement'` 指向它。新版面 —— 两条并列轨道
- * (每颗料一条:档案卡 + 主数据 + 类型选择)/ `<details>` 新增类型面板(chip_type +
- * type_param 两张表,即「每行四格」的核心参数字段清单)/ 核心参数值瓷贴(单块平铺);
- * 顶部一条红带摆配方算好的 `gate_reason`。台账绑定面与换版面前一个不差。
+ * 件① 评估输入补全(2026-08-29,Task 7;Task 7b 补②a 块):S1 的配方缺什么就发一张数据工单,
+ * `view: 'input-supplement'` 指向它。四块竖排——要评估什么(两颗料的存在性 + 主数据)/
+ * 芯片类型(选型 + 新建类型)/ 核心参数字段清单(新建类型时要填)/ 参数值(逐条实测/规格值);
+ * 顶部一条红带摆配方算好的 `gate_reason`。
  * 复用文件顶部已有的 `viewHtml` 短写(与 brief 草稿里的 `viewOf` 同一件事,不重复定义一个)。
  */
 describe('件① 评估输入补全', () => {
@@ -543,29 +570,117 @@ describe('件① 评估输入补全', () => {
     expect(steps.find((s) => s.item === 'S1_inputs')?.view).toBe('input-supplement');
   });
 
-  it('四块都在,行都绑本单草稿(不是整表)', () => {
+  it('三块都在,行都绑本单草稿(不是整表);档案卡行源是 parts.profile 本身(类型字典只读整表,不再有 mine: 镜像)', () => {
     expect(html).toContain('data-rows="mine:sub_eval.part"');
+    expect(html).toContain('data-rows="mine:parts.profile"');
     expect(html).toContain('data-rows="mine:parts.parameter"');
-    expect(html).toContain('data-rows="mine:parts.chip_type"');
-    expect(html).toContain('data-rows="mine:parts.type_param"');
+    expect(html).not.toContain('data-rows="mine:parts.chip_type"');
+    expect(html).not.toContain('data-rows="mine:parts.type_param"');
   });
 
-  it('芯片类型是从台账现读的下拉 —— 写死等于「只能选出包那天就有的那几种」(块①的 chip_type_id 与块②b 的 type_id 都是)', () => {
+  /*
+   * 2026-08-31 用户实测三连的回归网(视图侧两条,配方侧第三条在 steps.test.ts):
+   * ① 「品牌…点保存根本不会保存」—— 病根:块① 行源曾是 `mine:sub_eval.part`,那张案卷表
+   *   没有品牌这些列,renderTemplate 只认行作用域,显示与孪生件的值永远空白。行源必须是
+   *   `mine:parts.profile` 本身(S1 第④笔 prune:true 保证恒有两行)。
+   * ② 「明明没选类型,界面自己给上了」—— data-by 行里缺键落回外层同名字段(debt I3),
+   *   查名 pill 摆出这一行没有的类型。守卫认 selectCurrent 按这一行自己的值写下的
+   *   option[selected]:真选上才摆名,没选摆「待选择」。
+   */
+  it('档案卡:行源 = mine:parts.profile、一个宿主一道闸;嵌套的角色/在库查表全只读(嵌套行里有 data-col 会被 collect 并成一条)', () => {
+    expect((html.match(/data-edit="parts\.profile"/g) ?? []).length).toBe(1);
+    expect(html).toContain('data-rows="mine:parts.profile" data-edit="parts.profile"');
+    expect(html).not.toContain('data-rows="mine:sub_eval.part" data-edit="parts.profile"');
+    const nested = [...html.matchAll(/<span data-rows="mine:sub_eval\.part" data-by="internal_pn=internal_pn">((?:(?!<\/span>)[\s\S])*?)<\/span>/g)];
+    expect(nested.length).toBeGreaterThanOrEqual(1);
+    for (const m of nested) expect(m[1] ?? '').not.toContain('data-col');
+  });
+
+  it('类型名带守卫:这一行的下拉真有选中项才摆名,没选摆「待选择」—— data-by 外层回落的谎话进不了屏(单层 :has,嵌套 :has 是非法选择器会被整条丢弃)', () => {
+    expect(html).toContain('.dz-type:not(:has(option[selected])) .tsel > span{display:none}');
+    expect(html).toContain('待选择');
+    /* 回归网:不许再写回嵌套 :has 的形 —— 那条选择器非法,浏览器静默丢弃,守卫等于没有 */
+    expect(html).not.toContain(':has(+ select.jc-cell:not(:has(');
+  });
+
+  /*
+   * 2026-08-31 用户第二轮:「芯片类型列表和核心参数字段,不能合并成一个卡片吗…两个芯片都
+   * 选一样的,就应该只显示一种」。合并 = 比对基准卡(类型名 + 字段清单一张只读卡);
+   * 「只显示一种、跟手」= 不列 mine: 草稿镜像(会积旧选择),按案卷锚(case.chip_type_id,
+   * 配方每拍现算)嵌套查字典 —— quiet 拍 project 照跑,保存即换脸。
+   * 新建类型收进 details 抽屉(零脚本),两张编辑表原样在抽屉里(种子行/加行机制不动)。
+   */
+  it('比对基准卡:case 锚嵌套查字典,类型与字段合一、全只读;编辑表收进抽屉', () => {
+    expect(html).toContain('data-rows="mine:sub_eval.case"');
+    const basis = /<article class="basis"[\s\S]*?<\/article>/.exec(html)?.[0] ?? '';
+    expect(basis).not.toBe('');
+    expect(basis).toContain('data-rows="parts.chip_type" data-by="type_id=chip_type_id"');
+    expect(basis).toContain('data-rows="parts.type_param" data-by="type_id=chip_type_id"');
+    /* 全只读:选类型在档案卡,建类型在抽屉 —— 基准卡上一个编辑面都不许有 */
+    expect(basis).not.toContain('data-col');
+    expect(basis).not.toContain('data-edit');
+    /* 基准卡不再有表格:类型 + 字段全是瓷贴;说明藏进悬浮气泡(降噪,2026-08-31) */
+    expect(basis).not.toContain('<table');
+    expect(basis).toContain('class="ftiles"');
+    expect(html).toContain('.ftile:hover .ft-desc');
+    /* 新建类型抽屉已随「只选不建」退役(2026-08-31 用户定)—— 只剩说明折叠那一只 details */
+    expect(html).not.toContain('<details class="lab">');
+    expect(html).not.toContain('data-edit="parts.chip_type"');
+    expect(html).not.toContain('data-edit="parts.type_param"');
+  });
+
+  /*
+   * 2026-08-31 用户第三轮:「芯片卡片需要和该芯片的核心参数值合并…点击后卡片翻转,背面写
+   * 核心参数,悬浮要看得出可以翻;这个界面都不再需要表格来展示数据」。
+   * 背面就地可改 = 两张卡背各住一个 parts.parameter 宿主 —— 多宿主收值是同日的平台扩面
+   * (ViewContainer hostsOf + 格子只归最近的 data-edit 祖先,ui-kit multihost 测试钉着)。
+   */
+  it('翻面卡:背面住着参数宿主、按料过滤(渲染时随行复制成每卡一个 —— 多宿主收值由 ui-kit multihost 测试钉);翻转是无 data-col 的 checkbox;编辑态锁面', () => {
+    expect((html.match(/data-edit="parts\.parameter"/g) ?? []).length).toBe(1);
+    expect(html).toContain('data-rows="mine:parts.parameter" data-by="internal_pn=internal_pn" data-edit="parts.parameter"');
+    const flip = /<input class="flip-tg"[^>]*>/.exec(html)?.[0] ?? '';
+    expect(flip).not.toBe('');
+    expect(flip).toContain('type="checkbox"');
+    expect(flip).not.toContain('data-col');
+    expect(html).toContain('class="face front"');
+    expect(html).toContain('class="face back"');
+    /* 编辑锁面:主数据编辑停正面,参数编辑翻背面 —— 判断全在样式表 */
+    /* 按卡锁面(2026-08-31「不要做联动」):.on 由 scopedTargets 落在这张卡的行上 */
+    expect(html).toContain('.dossier.on .flip-in{transform:rotateY(0deg)}');
+    expect(html).toContain('.dossier:has(.pback.on) .flip-in{transform:rotateY(180deg)}');
+    /* 悬浮提示丸:看得出点击可翻 */
+    expect(html).toContain('点击翻面');
+    /* 「可替换」动画与卡同级(2026-08-31 第二稿:不做背景板 —— 会被卡盖住):
+       三列网格中间留实体动画道,⇄ 徽 + 双点轨道对转 */
+    expect(html).toContain('class="swapfx"');
+    expect(html).toContain('class="sw-orbit"');
+    expect(html).toContain('@keyframes sworbit');
+    expect(html).toContain('grid-template-columns:minmax(0,1fr) 76px minmax(0,1fr)');
+    expect(html).toContain('.dossiers > .dossier:nth-of-type(even){grid-column:3}');
+  });
+
+  it('整件零表格(2026-08-31 用户:「这个界面都不再需要表格来展示数据了」;抽屉连表带功能一并退役)', () => {
+    expect(html).not.toContain('<table');
+    expect(html).not.toContain('class="jc-tbl-wrap"');
+  });
+
+  it('占位口径:正面必填红/建议橘;卡背值必填红,说明空着**什么都不摆**(2026-08-31 用户:「没写就什么都不要展示」)', () => {
+    expect(html).toContain('.fcell.req .jc-vcell:empty::after{content:"必填"');
+    expect(html).toContain('.fcell.sug .jc-vcell:empty::after{content:"建议"');
+    expect(html).toContain('.ptile .pv .jc-vcell:empty::after{content:"必填"');
+    expect(html).toContain('.ptile .sg .jc-vcell:empty{display:none}');
+    expect(html).not.toContain('.ptile .sg .jc-vcell:empty::after');
+  });
+
+  it('芯片类型是从台账现读的下拉 —— 写死等于「只能选出包那天就有的那几种」', () => {
     expect(html).toContain('data-options="parts.chip_type"');
     expect(html).toContain('data-option-value="type_id"');
     expect(html).toContain('data-option-label="type_name"');
     /* data-options 与 data-slot 不能共存(渲染时 data-slot 会被剥掉)—— 当下值由 data-col 定 */
     expect(/data-options="[^"]*"[^>]*data-slot=/.test(html)).toBe(false);
-    /* 块①(sub_eval.part 行模版,只有一份行模版,被 data-rows 迭代)绑 chip_type_id 下拉 */
+    /* 档案卡正面绑 chip_type_id 下拉 —— 只选不建(2026-08-31 用户定),type_id 的写入下拉已随抽屉退役 */
     expect(html).toContain('data-col="chip_type_id" required data-options="parts.chip_type"');
-    /*
-     * 块②b(type_param)绑 type_id 下拉的地方**该出现两次**——已有行的行模版(data-rows
-     * 迭代)一份、种子行(字面量静态行,不受行数所限)一份;只数子串存在会被「只剩其中一份」
-     * 这种退化蒙混过去(已用变异验证逮到:只把动态行模版那份换回裸文本输入,这条子串断言
-     * 仍然为真,因为种子行那份还在——按出现次数数才钉得住两处都在)。
-     */
-    const typeIdSelectCount = (html.match(/data-col="type_id" required data-options="parts\.chip_type"/g) ?? []).length;
-    expect(typeIdSelectCount).toBe(2);
+    expect(html).not.toContain('data-col="type_id"');
   });
 
   /*
@@ -574,18 +689,14 @@ describe('件① 评估输入补全', () => {
    * (查证见 Task 7b 报告)。补一条**不受 `data-rows` 管辖的静态种子行**——两张表各一条,
    * 字面量手写 `data-col` 输入格,不经 `cell()`/`data-slot`,行数再少也在。
    */
-  it('**零行也加得出第一行**:两张表各带一条静态种子行(class="jc-row-static"),不靠 data-rows 生成', () => {
-    const staticRows = html.match(/<tr class="jc-row-static">/g) ?? [];
-    expect(staticRows).toHaveLength(2);
-    /* 种子行里的输入格是手写的,不经 twinInputs —— 直接断言 data-col 存在即可 */
-    expect(html).toContain('<input class="jc-cell" data-col="type_name" placeholder="新类型名称">');
-    expect(html).toContain('<input class="jc-cell" data-col="description"');
-    expect(html).toContain('<input class="jc-cell" data-col="param_name" placeholder="参数名">');
-    expect(html).toContain('<input class="jc-cell" data-col="param_desc"');
-    expect(html).toContain('<select class="jc-cell" data-col="constraint_type">');
-    expect(html).toContain('<input class="jc-cell" data-col="param_unit"');
-    /* 种子行只在编辑态露面 —— 读的时候不该看见一行空壳子(界面不撒谎) */
-    expect(html).toContain('table:not(.on) tr.jc-row-static { display: none; }');
+  /*
+   * SKIP(2026-08-31 用户定「把添加芯片类型的功能从这个活动中移除,只能选择已有类型」):
+   * 新建类型抽屉连同两张编辑表(静态种子行 / type_id 禁用 data-col 的 Critical-1 修法 /
+   * thead 后置回归网 / data-edit 双写)整体退役 —— 这些钉的是已移除的创建路径,不是被放松的
+   * 断言。平台侧机制钉测(view-render-addrow-thead / view-table-edit)不随本活动退役。
+   */
+  it.skip('**零行也加得出第一行**:两张表各带一条静态种子行(class="jc-row-static"),不靠 data-rows 生成', () => {
+    expect(true).toBe(true);
   });
 
   /*
@@ -603,17 +714,14 @@ describe('件① 评估输入补全', () => {
    * 钉住修法:`type_id` 必须挂 `data-col`,且必须是禁用的 —— 人看得见「由系统生成」
    * 这句占位,但怎么点都改不了它的值。
    */
-  it('**新建类型的种子行:type_id 挂 data-col、但禁用恒空**(2026-08-30 修 Critical 1 —— 漏挂会让 resolveRowKey 的"全表一致"把新建的类型误判成既有那一行,静默覆盖它)', () => {
-    expect(html).toContain('由系统生成');
-    // 「由系统生成」只出现在 chip_type 那条种子行里 —— 精确抓出那一行
-    const chipTypeStaticRow = /<tr class="jc-row-static">(?:(?!<\/tr>)[\s\S])*?由系统生成(?:(?!<\/tr>)[\s\S])*?<\/tr>/.exec(html)?.[0] ?? '';
-    expect(chipTypeStaticRow).not.toBe('');
-    /* 必须是一个真的 <input data-col>(collect() 只认 input/select/textarea[data-col]),
-       不能是纯文本 <span> —— 否则这一格永远不会出现在回传的 cells 里,barred 的保护无从谈起 */
-    expect(chipTypeStaticRow).toMatch(/<input[^>]*data-col="type_id"[^>]*disabled/);
-    /* disabled 意味着人怎么点都改不了它的值 —— 保存时这一格恒是空串,才谈得上「barred」 */
-    expect(chipTypeStaticRow).toContain('data-col="type_name"');
-    expect(chipTypeStaticRow).toContain('data-col="description"');
+  /*
+   * SKIP(2026-08-31 用户定「把添加芯片类型的功能从这个活动中移除,只能选择已有类型」):
+   * 新建类型抽屉连同两张编辑表(静态种子行 / type_id 禁用 data-col 的 Critical-1 修法 /
+   * thead 后置回归网 / data-edit 双写)整体退役 —— 这些钉的是已移除的创建路径,不是被放松的
+   * 断言。平台侧机制钉测(view-render-addrow-thead / view-table-edit)不随本活动退役。
+   */
+  it.skip('**新建类型的种子行:type_id 挂 data-col、但禁用恒空**(2026-08-30 修 Critical 1 —— 漏挂会让 resolveRowKey 的"全表一致"把新建的类型误判成既有那一行,静默覆盖它)', () => {
+    expect(true).toBe(true);
   });
 
   it('**主键列必挂 `data-col`** —— 它不是编辑面,是行的钥匙(漏了会把人改的行错配到别行上)', () => {
@@ -621,12 +729,28 @@ describe('件① 评估输入补全', () => {
     expect(html).toContain('data-col="param_name"');
   });
 
-  it('可改的四张表各有一道编辑闸 —— 查的是闸([data-edit-for] + 开钮),不是宿主:2026-08-30 换版面第一版恰好漏掉 profile 的闸,宿主在而闸不在,轨道打不开编辑,XL 的必填永远补不上(Task 7 那颗「按不下去的确认钮」同款),旧断言只查宿主没逮到', () => {
-    for (const address of ['parts.profile', 'parts.chip_type', 'parts.type_param', 'parts.parameter']) {
-      expect(html).toContain(`data-edit="${address}"`);
-      expect(html).toContain(`data-edit-for="${address}"`);
+  /*
+   * 2026-08-31 用户定:两行编辑闸退役,换成卡右上角的笔↔软盘 —— 笔开当前这一面的编辑
+   * (正面=主数据 / 背面=参数值),软盘保存,叉放弃。按钮就是平台认的 data-edit-open /
+   * data-edit-save / data-edit-cancel 触发器,快照与取消机制原样。
+   */
+  it('编辑收进卡角:笔(open)/软盘(save)/叉(cancel)正反两面各一套;地址只剩 profile 与 parameter', () => {
+    for (const address of ['parts.profile', 'parts.parameter']) {
       expect(html).toContain(`data-edit-open="${address}"`);
+      expect(html).toContain(`data-edit-save="${address}"`);
+      expect(html).toContain(`data-edit-cancel="${address}"`);
     }
+    /* 老的闸行不再出现在正文里(样式表里的基座规则给 ② 用,不算) */
+    expect(html.slice(html.indexOf('</style>'))).not.toContain('jc-editgate');
+    /* 笔↔软盘的按面显隐由样式表判 */
+    expect(html).toContain('.dossier.on .disk-f{display:grid}');
+    expect(html).toContain(".dossier:has(.pback.on) .disk-b{display:grid}");
+    /* 参数瓷贴的输入孪生件带占位提示(渲染器认 data-ph) */
+    expect(html).toContain('data-ph="规格书上的值 · 查不到留空"');
+    expect(html).toContain('data-ph="补充说明 · 选填"');
+    /* 题头回浅蓝渐变(2026-08-31 用户:「标题背景还是改成之前的那种蓝色渐变」) */
+    expect(html).toContain('class="card hd-light"');
+    expect(html).toContain('linear-gradient(120deg,#f0f5ff 0%,#fff 55%,#eef4ff 100%)');
   });
 
   /*
@@ -636,11 +760,14 @@ describe('件① 评估输入补全', () => {
    * 内层 `data-rows` 那个 `<tbody>` 一处(给 `renderRows` 的 `editable` 检测看,
    * 它只认与 `data-rows` 同一个标签自带的属性,不看祖先)。
    */
-  it('新建类型 / 新建字段两张表的 data-edit 各出现两次(外层 table + 内层 data-rows tbody)', () => {
-    for (const address of ['parts.chip_type', 'parts.type_param']) {
-      const count = (html.match(new RegExp(`data-edit="${address}"`, 'g')) ?? []).length;
-      expect(count, address).toBe(2);
-    }
+  /*
+   * SKIP(2026-08-31 用户定「把添加芯片类型的功能从这个活动中移除,只能选择已有类型」):
+   * 新建类型抽屉连同两张编辑表(静态种子行 / type_id 禁用 data-col 的 Critical-1 修法 /
+   * thead 后置回归网 / data-edit 双写)整体退役 —— 这些钉的是已移除的创建路径,不是被放松的
+   * 断言。平台侧机制钉测(view-render-addrow-thead / view-table-edit)不随本活动退役。
+   */
+  it.skip('新建类型 / 新建字段两张表的 data-edit 各出现两次(外层 table + 内层 data-rows tbody)', () => {
+    expect(true).toBe(true);
   });
 
   /*
@@ -667,20 +794,14 @@ describe('件① 评估输入补全', () => {
    * 谁若把 `<thead>` 挪回两个 `<tbody>` 之前(哪怕只改一张表),这条测试立刻标红,
    * 提醒去核对 `view-render-addrow-thead.test.ts` 是否也需要同步。
    */
-  it('**回归安全网**:两张新表的 <thead> 都排在两个 <tbody> 之后(不是最前面)—— 与 view-render-addrow-thead.test.ts 的假设锁在一起', () => {
-    for (const address of ['parts.chip_type', 'parts.type_param']) {
-      const tableStart = html.indexOf(`<table data-edit="${address}">`);
-      expect(tableStart, address).toBeGreaterThanOrEqual(0);
-      const tableEnd = html.indexOf('</table>', tableStart);
-      const tableHtml = html.slice(tableStart, tableEnd);
-      const theadAt = tableHtml.indexOf('<thead>');
-      const tbodyPositions = [...tableHtml.matchAll(/<tbody/g)].map((m) => m.index ?? -1);
-      expect(theadAt, `${address}: 找不到 <thead>`).toBeGreaterThanOrEqual(0);
-      expect(tbodyPositions.length, `${address}: 应有两个 <tbody>`).toBe(2);
-      // <thead> 必须排在两个 <tbody> 的开标签**之后**(源码序;视觉呈现由 CSS 的
-      // table-header-group 保证仍在最前,与源码序无关)
-      for (const pos of tbodyPositions) expect(theadAt, address).toBeGreaterThan(pos);
-    }
+  /*
+   * SKIP(2026-08-31 用户定「把添加芯片类型的功能从这个活动中移除,只能选择已有类型」):
+   * 新建类型抽屉连同两张编辑表(静态种子行 / type_id 禁用 data-col 的 Critical-1 修法 /
+   * thead 后置回归网 / data-edit 双写)整体退役 —— 这些钉的是已移除的创建路径,不是被放松的
+   * 断言。平台侧机制钉测(view-render-addrow-thead / view-table-edit)不随本活动退役。
+   */
+  it.skip('**回归安全网**:两张新表的 <thead> 都排在两个 <tbody> 之后(不是最前面)—— 与 view-render-addrow-thead.test.ts 的假设锁在一起', () => {
+    expect(true).toBe(true);
   });
 
   /*
@@ -697,113 +818,44 @@ describe('件① 评估输入补全', () => {
     expect(html).toContain('.jc-gate-bar:has(.jc-gate-text:empty)');
   });
 
+  /*
+   * 2026-08-31 用户:「页面上所有的问题都合并到最上面的还差什么,不要在某一个板块显示
+   * 类似还差 1 行必填没填这种提示」—— 逐块 gapbar 撤下,点名并进顶条(同一批基座读数,
+   * 数值 0 的那行由样式表自己收起来)。
+   */
+  it('都齐了红条整条收起:开关是案卷真数据 gate_state(v-clear),不看那句话空不空', () => {
+    expect(html).toContain('class="jc-gate-bar" data-class-of="gate_state"');
+    expect(html).toContain('.jc-gate-bar.v-clear{display:none}');
+    expect(colOf('sub_eval.case', 'gate_state')?.tally).toEqual(['open', 'clear']);
+  });
+
+  it('缺项点名全并进顶条「还差什么」,正文不再有逐块红带', () => {
+    expect(html).toContain('class="jc-gate-sub" data-class-of="parts_profile_missing"');
+    expect(html).toContain('data-slot="parts_profile_missing_keys"');
+    expect(html).toContain('data-slot="parts_parameter_missing_keys"');
+    expect(html).toContain('html.editable .jc-gate-sub.v-0{display:none}');
+    expect(html.slice(html.indexOf('</style>'))).not.toContain('jc-gapbar');
+  });
+
   it('表宽超出要能横着滑 —— 不许写成 overflow:hidden(E04/I01 抄错过一次)', () => {
     expect(html).not.toMatch(/\.jc-tbl-wrap\s*\{[^}]*overflow\s*:\s*hidden/);
   });
 
   /*
-   * 2026-08-29 评审 Important:BIND_COMMON 的序号计数器规则原来只认 `.tbl-wrap`,而工单件的表
-   * 走平台的 `.jc-tbl-wrap` —— 两个 class 对不上,计数器永不触发,「#」列逐行空白。
-   * 2026-08-30 换版面后这张件只剩面板里两张表(chip_type / type_param),包装是
-   * `jc-tbl-wrap tbl-wrap` 双类(平台钩子 + 目标件的边框圆角);轨道与瓷贴没有 # 列,
-   * 不走计数器。钉死:五条计数器规则还在,且两张表的双类包装恰好两处。
+   * 2026-08-29 评审 Important:BIND_COMMON 的序号计数器规则原来只认 `.tbl-wrap`
+   * (继承自已删除的旧 P08_MASTER_CREATE,同一个 wrapper class,同一个坑),
+   * 而这张件的三张表全用平台的 `.jc-tbl-wrap` —— 两个 class 对不上,计数器永不触发,
+   * 只读态与编辑态下「#」列逐行都是空白。钉死 `.jc-tbl-wrap` 现在也接了这五条规则,
+   * 且这张件确实只用 `.jc-tbl-wrap`(没有表在用没打这条补丁就会数不出来的 `.tbl-wrap`)。
    */
-  it('面板两张表的序号列真的会数:计数器规则在,双类包装恰两处', () => {
-    expect(html).toMatch(/\.jc-tbl-wrap\s+table\s*,\s*\.tbl-wrap\s+table\s*\{\s*counter-reset:\s*rn;?\s*\}/);
-    expect(html).toMatch(/\.jc-tbl-wrap\s+table\s+td\.rn\s*,\s*\.tbl-wrap\s+table\s+td\.rn\s*\{\s*counter-increment:\s*rn;?\s*\}/);
-    expect(html).toMatch(/\.jc-tbl-wrap\s+table\s+td\.rn\s+\.jc-rn-num::before\s*,\s*\.tbl-wrap\s+table\s+td\.rn\s+\.jc-rn-num::before\s*\{\s*content:\s*counter\(rn\);?\s*\}/);
-    const wrapCount = html.match(/class="jc-tbl-wrap tbl-wrap"/g)?.length ?? 0;
-    expect(wrapCount).toBe(2);
-    // 不许再有单类的表包装 —— 单 .jc-tbl-wrap 缺目标件的边框,单 .tbl-wrap 缺平台的 :has 加行钩子
-    expect(html).not.toMatch(/class="jc-tbl-wrap"/);
-    expect(html).not.toMatch(/class="tbl-wrap"/);
-  });
-
-  /* ==================== 2026-08-30 换版面(照 docs/ss02-act-05-new 新目标件)专属的钉子 ==================== */
-
-  it('**每个台账地址恰一个收值宿主**(chip_type/type_param 的两处是「外层 table + 内层 tbody」同宿主写法):bodyOf 是单 querySelector,同一地址挂两个各自独立的宿主,第二个的值一格都收不上去且不报错(终审 C1 / Task 7b 的族坑)', () => {
-    const countOf = (addr: string): number => (html.match(new RegExp(`data-edit="${addr.replace('.', '\\.')}"`, 'g')) ?? []).length;
-    expect(countOf('parts.profile')).toBe(1);
-    expect(countOf('parts.parameter')).toBe(1);
-    expect(countOf('parts.chip_type')).toBe(2);
-    expect(countOf('parts.type_param')).toBe(2);
-  });
-
-  it('**两条轨道:行源与写向同一元素,行模版是宿主直接子元素**(rowOf 认宿主直接子元素 —— 一条 lane = 一行;行模版里不许再有 <section>,行展开按第一个同名闭合标签截行内容)', () => {
-    expect(html).toMatch(/<article class="lanes" data-rows="mine:sub_eval\.part" data-edit="parts\.profile">\s*<section class="lane">/);
-    const laneBody = /<section class="lane">([\s\S]*?)<\/section>/.exec(html)?.[1] ?? '';
-    expect(laneBody).not.toBe('');
-    expect(laneBody).not.toContain('<section');
-  });
-
-  it('**参数瓷贴单块平铺,瓷贴是宿主直接子元素** —— 按料嵌一层分栏会把一颗料的所有参数格并成一条记录(ui-kit view-container-collect-div-rows.test.ts 用真实 renderView+collect 钉死的「必然归并」)', () => {
-    expect(html).toMatch(/<article class="pvgrid" data-rows="mine:parts\.parameter" data-edit="parts\.parameter"><section class="pv">/);
-    const pvBody = /<section class="pv">([\s\S]*?)<\/section>/.exec(html)?.[1] ?? '';
-    expect(pvBody).not.toBe('');
-    expect(pvBody).not.toContain('<section');
-    /* 瓷贴的主键钥匙(internal_pn / param_name)收在 .rowkey 里 —— 藏起来但必须真挂 data-col */
-    expect(pvBody).toContain('class="rowkey"');
-    expect(pvBody).toContain('data-col="internal_pn"');
-    expect(pvBody).toContain('data-col="param_name"');
-    expect(html).toContain('.pv .rowkey{display:none}');
-  });
-
-  it('**data-rows 宿主的闭合标签不许出现在自己的行模版里** —— renderRows 的正则按宿主闭合标签非贪婪截取,撞上就把行模版截半、后一行嵌进前一行没闭合的标签里(2026-08-30 浏览器走查逮到:<div class="lanes"> 被 lab 那格的 </div> 截断,档案卡串行)。判法:照 ROWS 正则同款截取,截出来的行模版必须**标签配平**(截断必然留下没闭合的标签 —— 直接查「不含闭合标签」是空话,非贪婪截取本来就停在闭合标签之前)', () => {
-    const hosts = [...html.matchAll(/<([a-zA-Z][\w-]*)\b[^>]*\bdata-rows="[^"]+"[^>]*>([\s\S]*?)<\/\1>/g)];
-    expect(hosts.length).toBeGreaterThanOrEqual(2);
-    const VOID = new Set(['input', 'br', 'img', 'hr', 'meta', 'link']);
-    for (const m of hosts) {
-      const inner = m[2] ?? '';
-      const opens = new Map<string, number>();
-      for (const tm of inner.matchAll(/<(\/?)([a-zA-Z][\w-]*)\b/g)) {
-        const tag = (tm[2] ?? '').toLowerCase();
-        if (VOID.has(tag)) continue;
-        opens.set(tag, (opens.get(tag) ?? 0) + (tm[1] === '/' ? -1 : 1));
-      }
-      for (const [tag, n] of opens) {
-        expect(n, `data-rows 宿主 <${m[1]}> 截出的行模版里 <${tag}> 开 ${n} 个没闭合 —— 宿主的闭合标签把模版截半了`).toBe(0);
-      }
-    }
-  });
-
-  it('**类型不一致护栏**:distinct 是基座数,红带只在 v-2 档现身,模版不算不判', () => {
-    expect(html).toMatch(/class="jc-typewarn" data-class-of="sub_eval_part_distinct_chip_type_id"/);
-    expect(html).toContain('.jc-typewarn{display:none}');
-    expect(html).toContain('.jc-typewarn.v-2{display:flex');
-  });
-
-  it('**步骤圆点只按基座数点亮,投影挂在行外的包裹层** —— 行内 data-class-of 只认行作用域,作用域级读数在行内投不出(实测圆点永远不亮);圆点自己不许再挂 data-class-of(挂了也是死属性)', () => {
-    expect(html).toContain('class="pj pj-profile" data-class-of="parts_profile_missing"');
-    expect(html).toContain('class="pj pj-type" data-class-of="sub_eval_part_distinct_chip_type_id"');
-    expect(html).toContain('class="pj pj-param" data-class-of="parts_parameter_missing"');
-    expect(html).toContain('.pj-profile.v-0 .sdot.sd-1,.pj-type.v-1 .sdot.sd-2,.pj-param.v-0 .sdot.sd-3{background:var(--data)');
-    expect(html).not.toMatch(/class="sdot[^"]*" data-class-of=/);
-  });
-
-  it('**类型查名有诚实守卫**(data-by 行缺键落回外层同名字段,终审 I3):行里没真选上类型(selectCurrent 没写下 option[selected]),查名 pill 与字段行的名字都不摆', () => {
-    expect(html).toContain('.lane:not(:has(select[data-col="chip_type_id"] option[selected])) .idcard .tpill{display:none}');
-    expect(html).toContain('.lane:not(:has(select[data-col="chip_type_id"] option[selected])) .tywrap span{display:none}');
-    expect(html).toContain('class="jc-vcell tywrap"');
-  });
-
-  it('**新增类型面板是 <details>,且绑定层把抽取样式的 display:none 让开** —— 少了这条让位规则,整个面板(含两道闸与两张表)永远不可见', () => {
-    expect(html).toContain('<details class="newtype">');
-    expect(html).toContain('details.newtype{display:block');
-  });
-
-  it('**目标件里靠脚本驱动的两样,搬过来时如实退掉**:进度条 gateprog 的分母不是基座现有的数(编一个就是界面撒谎);viewarea/editarea 双区靠 body.editing 切换,沙箱零脚本切不动 —— 抽取的 CSS 里留着它们的规则,但标记一处都不许用', () => {
-    const body = html.slice(html.indexOf('</style>'));
-    expect(body).not.toContain('gateprog');
-    expect(body).not.toContain('class="viewarea"');
-    expect(body).not.toContain('class="editarea"');
-    /* .editarea{display:none} 还在 CSS 里 —— 谁把内容包进它,那块就永远消失 */
-    expect(html).toContain('.editarea{display:none}');
-  });
-
-  it('**保存即铺格之前的空态**:pvnull 按 parts_parameter_rows 的 v-0 档现身(零行才摆提示,有行不摆 —— 界面不撒谎)', () => {
-    expect(html).toContain('class="pv-empty pvnull" data-class-of="parts_parameter_rows"');
-    expect(html).toContain('.pvnull{display:none}');
-    expect(html).toContain('.pv-empty.pvnull.v-0{display:block}');
+  /*
+   * SKIP(2026-08-31 用户定「把添加芯片类型的功能从这个活动中移除,只能选择已有类型」):
+   * 新建类型抽屉连同两张编辑表(静态种子行 / type_id 禁用 data-col 的 Critical-1 修法 /
+   * thead 后置回归网 / data-edit 双写)整体退役 —— 这些钉的是已移除的创建路径,不是被放松的
+   * 断言。平台侧机制钉测(view-render-addrow-thead / view-table-edit)不随本活动退役。
+   */
+  it.skip('抽屉里两张表的序号列真的会数:.jc-tbl-wrap 也接了 CSS 计数器(不再只认 .tbl-wrap)', () => {
+    expect(true).toBe(true);
   });
 });
 
@@ -835,12 +887,30 @@ describe('件② 差异评估结论审核', () => {
     expect(html).toContain('data-col="difference_item_id"');
   });
 
-  it('**推荐理由 / 摘要 / 风险 / 验证要求只读** —— 让人直接改摘要,等于让他给自己没做的判断盖章', () => {
+  /**
+   * **收口四格可就地改**(2026-08-31 用户:「差异评估结论审核这个界面的收口结论下面这 4 个
+   * 字段也需要可以编辑」)。此前是只读的,理由是「让人直接改,等于给自己没做的判断盖章」——
+   * 用户改了这个口径:审核人对结论有最终发言权。
+   *
+   * **配方那一侧必须一起改,否则等于没开**:`RELATION_PROJECTION` 每跑一次就把这四列按规则
+   * 重写一遍,而人在件上按保存会触发 quiet 拍、quiet 恰恰跑 project —— 人改完一保存就被冲掉。
+   * S3 因此换成只重算判定的 `RELATION_RECOMPUTE`(那一组断言在「S3 只重算判定」里)。
+   */
+  it('**收口四格可就地改**:三句话走 cell(只读份 + 孪生输入)、风险走徽标 + select,整块一个宿主一道闸', () => {
     for (const col of ['recommendation_reason', 'difference_summary', 'verification_requirement']) {
-      expect(html).toContain(`data-slot="${col}"`);
-      expect(html).not.toContain(`data-col="${col}"`);
+      expect(html, col).toContain(`data-slot="${col}"`);
+      expect(html, col).toContain(`data-col="${col}"`);
     }
-    expect(html).not.toContain('data-edit="substitution.relation"');
+    /* 风险是枚举:只读态摆徽标(不裸显 low/medium/high),编辑态换 select */
+    expect(html).toContain('class="risk-badge" data-class-of="risk_level"');
+    expect(html).toMatch(/<select class="jc-cell" data-col="risk_level" required>/);
+    /* 一个地址一个宿主(bodyOf 是单 querySelector),且必须配一道闸 —— 闸不在就打不开(Task 7 那颗按不下去的钮) */
+    expect((html.match(/data-edit="substitution\.relation"/g) ?? []).length).toBe(1);
+    expect(html).toContain('data-edit-for="substitution.relation"');
+    expect(html).toContain('data-edit-open="substitution.relation"');
+    /* 主键钥匙在场且藏起来 —— 漏了钥匙这一行凑不出主键(2026-08-02 栽过) */
+    expect(html).toContain('data-col="substitution_relation_id"');
+    expect(html).toContain('.summary-box .rowkey{display:none}');
   });
 
   it('等级与四态用 data-class-of 上色 —— 判断留在样式表,模版不判', () => {
@@ -862,7 +932,9 @@ describe('件② 差异评估结论审核', () => {
     for (const col of [
       'parameter_name', 'parameter_desc', 'constraint_type',
       'original_value', 'candidate_value', 'parameter_unit',
-      'recommendation_level', 'risk_level',
+      /* 推荐等级**仍然只读**:它是规则按四态分布算出来的判据核心,人改四态即改它,不容手改。
+         风险(risk_level)2026-08-31 起交给人,已从这份名单里移出 —— 见「收口四格可就地改」。 */
+      'recommendation_level',
     ]) {
       expect(html, col).not.toContain(`data-col="${col}"`);
     }
@@ -1045,10 +1117,9 @@ describe.skip('徽标别名与值域相关的坑(2026-08-27 实测账,回归网)
  */
 describe('可编辑件的主键与必填列(2026-08-27 复审:主键丢钥匙 / 必填填不了,两条 Critical 回归;Task 7b 补 parts.chip_type)', () => {
   /** input-supplement 一屏四张真能编辑的表与它们各自绑定的台账对象(Task 7b 加入 parts.chip_type) */
+  /* 2026-08-31「只选不建」:chip_type / type_param 不再是可编辑面,从名单撤下 */
   const EDITABLE: ReadonlyArray<{ view: string; domain: string; object: string }> = [
     { view: 'input-supplement', domain: 'parts', object: 'profile' },
-    { view: 'input-supplement', domain: 'parts', object: 'chip_type' },
-    { view: 'input-supplement', domain: 'parts', object: 'type_param' },
     { view: 'input-supplement', domain: 'parts', object: 'parameter' },
   ];
 
@@ -1109,19 +1180,25 @@ const CONTRACT = {
   discretion: [],
 } as const;
 
-/* 验收件题头是验收绿(2026-08-27 用户定:与对话区验收卡同色,不再是目标件的红) */
-describe('两张验收件的主题色', () => {
-  it('ACC1 / ACC2 的 --ledger 是验收绿 #0aa294,题头渐变不再带红;CONDITIONAL 徽标保留语义红', async () => {
-    const { ACC1_CSS, ACC2_CSS } = await import('../src/views/target-style.ts');
-    for (const css of [ACC1_CSS, ACC2_CSS]) {
-      expect(css).toContain('--ledger:#0aa294');
-      expect(css).not.toContain('--ledger:#b23a2e');
-      expect(css).not.toContain('#fdf3f1');
-      expect(css).toContain('rgba(10,162,148,.25)');
+/*
+ * 验收件的强调色是验收绿(2026-08-27 用户定:与对话区验收卡同色,不再是目标件的红)。
+ * 2026-08-31 视图层重设计后,样式真源从 target-style.ts(逐字节抽自目标件,随重设计退役)
+ * 换成 style.ts 的强调色令牌 —— 这条钉的用户口径不变:验收两件 #0aa294、数据工单数据蓝、
+ * CONDITIONAL 保持独立语义色(第四态,不与 MATCH 绿 / MISMATCH 红 / UNKNOWN 琥珀混用)、
+ * 目标件时代的题头红 #b23a2e 不再出现。
+ */
+describe('三张件的主题锚', () => {
+  it('验收两件强调色 #0aa294;数据工单数据蓝;CONDITIONAL 独立语义色;目标件的红不再出现', () => {
+    const review = viewHtml('difference-review');
+    const landing = viewHtml('landing-confirm');
+    for (const html of [review, landing]) {
+      expect(html).toContain('--acc:#0aa294');
+      expect(html).toContain('--ledger:#0aa294');
+      expect(html).not.toContain('#b23a2e');
     }
-    // ACC2 的 CONDITIONAL 徽标保留目标件的语义红;ACC1 目标件 2026-08-27 改版把它改成了品牌蓝,照抄
-    expect(ACC2_CSS).toContain('.st.cond{color:#b23a2e');
-    expect(ACC1_CSS).toContain('.st.cond{color:var(--brand-deep)');
+    expect(viewHtml('input-supplement')).toContain('--acc:#2e6bff');
+    expect(review).toContain('--cond:#5661f0');
+    expect(review).toContain('.st.v-conditional');
   });
 });
 

activities/part-substitution-assessment/__tests__/steps.test.ts

@@ -146,10 +146,10 @@ describe('S1 配方', () => {
    * 变成空字符串)见 `apps/api/src/modules/loop-engine/__tests__/w05-gate-reason-order.test.ts`
    * ——这份文件只做结构断言,不跑引擎(活动包不许 import apps/*)。
    */
-  it('八笔,次序是:两颗料 → 类型字典自投 → 字段清单自投 → 主数据骨架 → 参数骨架 → 案卷 → 卡 → 交代', () => {
-    expect(kinds).toEqual(['project', 'project', 'project', 'project', 'project', 'project', 'card', 'say']);
+  it('六笔,次序是:两颗料 → 主数据骨架 → 参数骨架 → 案卷 → 卡 → 交代(类型字典/字段清单两笔自投影已随「只选不建」退役)', () => {
+    expect(kinds).toEqual(['project', 'project', 'project', 'project', 'card', 'say']);
     expect(acts.map((a) => (a.kind === 'project' ? a.into : undefined)).filter(Boolean)).toEqual([
-      'sub_eval.part', 'parts.chip_type', 'parts.type_param', 'parts.profile', 'parts.parameter', 'sub_eval.case',
+      'sub_eval.part', 'parts.profile', 'parts.parameter', 'sub_eval.case',
     ]);
   });
 
@@ -158,27 +158,20 @@ describe('S1 配方', () => {
    * 原样投一遍(值不变,幂等)——目的不是产出新数据,是让 `mine:` 这两张表不再天然为零行,
    * 好让它们能安全回到下面 ⑦ 卡的 `gateLedgers` 上(闸不会再拿「零行」误判)。
    *
-   * **不带 `prune`**(2026-08-30 第二处修正,e2e 案例 2 撞出来的):这两张表在 ⑦ 的
-   * `gateLedgers` 上,一旦人交回数据工单就随「数据工单确认即入库」落进正式表——已落地的行
-   * `draftDrop`(`prune` 的撤行机制)撤不掉,配方原样抛错。字典类的表允许历史选型留在
-   * 草稿层(不算错),不像 `parts.profile`/`parts.parameter` 那几笔(它们仍然 `prune:true`,
-   * 见下面「主数据骨架」那笔)必须清掉不再相关的陈旧行。
+   * **带 `prune`,已落地的行由基座 `skipLanded` 跳过**(2026-08-31 改回)。曾特意不带
+   * `prune`(2026-08-30 e2e 案例 2:已落地的旧类型行撤不掉,配方整单炸)—— 代价是
+   * **没落地的**陈旧行也不清:人把候选从 LDO 改回 DC-DC,LDO 的字典/字段行积在屏上
+   * (2026-08-31 用户实测点名「下面还是显示两个类型」)。现在 `draftDrop` 对配方这一路
+   * 跳过已落地的行(loop-engine/port.ts),prune 回来:没落地的陈旧选型照撤,
+   * 已落地的原地留下 —— 案例 2 不再炸,用户那条路清得干净。
    */
-  it('②③ 两笔自投影都读 sub_eval.part 的 chip_type_id 去查字典/字段清单,原样抄回自己(不带 prune)', () => {
-    const chipType = acts[1];
-    expect(chipType?.kind === 'project' && chipType.into).toBe('parts.chip_type');
-    expect(chipType?.kind === 'project' && chipType.prune).toBeUndefined();
-    expect(chipType?.kind === 'project' && chipType.from).toMatchObject({
-      each: 'mine:sub_eval.part',
-      then: { each: 'parts.chip_type', where: { type_id: { outer: 'chip_type_id' } } },
-    });
-    const typeParam = acts[2];
-    expect(typeParam?.kind === 'project' && typeParam.into).toBe('parts.type_param');
-    expect(typeParam?.kind === 'project' && typeParam.prune).toBeUndefined();
-    expect(typeParam?.kind === 'project' && typeParam.from).toMatchObject({
-      each: 'mine:sub_eval.part',
-      then: { each: 'parts.type_param', where: { type_id: { outer: 'chip_type_id' } } },
-    });
+  /*
+   * SKIP(2026-08-31 用户定「只选不建」):②③ 两笔自投影连同 gateLedgers 上那两张表
+   * 一并退役 —— 类型只许从字典里选,选中的行本来就在正式表里,镜像与落地都失去了对象。
+   * 这条钉的机制(prune + skipLanded)仍活在 auto-runner 测试里,不随本活动退役。
+   */
+  it.skip('②③ 两笔自投影都读 sub_eval.part 的 chip_type_id 去查字典/字段清单,原样抄回自己(带 prune,已落地由基座跳过)', () => {
+    expect(true).toBe(true);
   });
 
   it('案号由 let 铸,只从本单开案时刻取材', () => {
@@ -202,7 +195,7 @@ describe('S1 配方', () => {
    * 「加一行」),必须换成说实情、给真出路的话:没法比出差异,终止重开。
    */
   it('gate_reason 第一档:两参必填之后只剩"填成同一个号"这条残余路径,文案不再指向不存在的"补两格"', () => {
-    const kase = acts[5];
+    const kase = acts[3];
     const fields = kase?.kind === 'project' ? kase.fields : undefined;
     const gateReason = fields?.['gate_reason'] as { when?: string; then?: string } | undefined;
     expect(gateReason?.when).toBe('sub_eval_part_rows < 2');
@@ -212,8 +205,9 @@ describe('S1 配方', () => {
   });
 
   it('参数骨架:两颗料都铺、值回填现值 —— 「在库但当年参数没录全」也要被拦住', () => {
-    const params = acts[4];
-    expect(params?.kind === 'project' && params.prune).toBe(true);
+    const params = acts[2];
+    /* 'live':人加不了行的表,quiet 拍也撤 —— 改类型后旧参数行跟手消失(2026-08-31 用户点名「只会变多不会变少」) */
+    expect(params?.kind === 'project' && params.prune).toBe('live');
     const from = params?.kind === 'project' ? params.from : undefined;
     /* 外层是本单两颗料,里层是该类型的字段清单 —— 人没挑类型时 where 一行不命中,什么也不铺 */
     expect(from).toMatchObject({ each: 'mine:sub_eval.part', then: { each: 'parts.type_param' } });
@@ -222,7 +216,7 @@ describe('S1 配方', () => {
   });
 
   it('**发卡的条件全是基座读数** —— 不许拿 `gate_reason != ""` 当条件', () => {
-    const card = acts[6];
+    const card = acts[4];
     const when = card?.kind === 'card' ? (card.when ?? '') : '';
     /*
      * S-FEEL 里**未绑定的名字 `!= ""` 求值为 true**,而 `gate_reason` 为空串时那一列压根不写、
@@ -243,16 +237,32 @@ describe('S1 配方', () => {
    * (2026-08-30 真跑 e2e 撞见)。现在四张表都在闸上、也都会一起落地。
    */
   it('卡:数据工单、四张表都在闸上(含 parts.chip_type/parts.type_param,Ruling H35)、且有 basis(基座拒发 basis 为空的工单)', () => {
-    const card = acts[6];
+    const card = acts[4];
     expect(card?.kind === 'card' && card.as).toBe('execution');
     expect(card?.kind === 'card' && card.variant).toBe('data');
-    expect(card?.kind === 'card' && card.gateLedgers).toEqual(['parts.chip_type', 'parts.type_param', 'parts.profile', 'parts.parameter']);
+    expect(card?.kind === 'card' && card.gateLedgers).toEqual(['parts.profile', 'parts.parameter']);
+    /*
+     * 类型不一致不许确认(2026-08-31 用户定)。钉 parts.profile 本表的 distinct ——
+     * 提交闸从草稿现读零滞后;钉 sub_eval.part 那份要等配方 tick,人存完就点确认会被误拦。
+     */
+    expect(card?.kind === 'card' && card.gateWhen).toBe('parts_profile_distinct_chip_type_id <= 1');
+    expect(card?.kind === 'card' && typeof card.gateWhenSay === 'string' && card.gateWhenSay.includes('不是同一个芯片类型')).toBe(true);
     expect((card?.kind === 'card' ? card.basis ?? [] : []).length).toBeGreaterThan(0);
     expect((card?.kind === 'card' ? card.guide ?? [] : []).length).toBeGreaterThanOrEqual(3);
   });
 
+  it('红条开关 gate_state 与发卡条件同一句判定(一处真源)—— gate_reason 清空不落笔,开关列两个方向都真写', () => {
+    const kase = acts[3];
+    const fields = kase?.kind === 'project' ? kase.fields : undefined;
+    const gs = fields?.['gate_state'] as { when?: string; then?: string; else?: string } | undefined;
+    const card = acts[4];
+    expect(gs?.then).toBe('open');
+    expect(gs?.else).toBe('clear');
+    expect(card?.kind === 'card' && card.when).toBe(gs?.when);
+  });
+
   it('发卡条件与 doneWhen 是同一件事的正反面', () => {
-    const when = acts[6]?.kind === 'card' ? (acts[6].when ?? '') : '';
+    const when = acts[4]?.kind === 'card' ? (acts[4].when ?? '') : '';
     for (const reading of [
       'sub_eval_part_exists_status_found', 'sub_eval_part_missing',
       'sub_eval_part_distinct_chip_type_id', 'parts_profile_missing', 'parts_parameter_missing',
@@ -401,10 +411,35 @@ describe('S3 / S4 配方', () => {
     expect(s3Fields?.['risk_level']).toBe(s2Fields?.['risk_level']);
   });
 
-  it('**S2 与 S3 用的是同一份投影** —— 各写一份早晚分叉', () => {
-    // S2 的 do 数组里 RELATION_PROJECTION 出现两次(acts[1]/acts[3],同一个引用)——
-    // 与 S3 比对随便挑一个都行,这里挑 acts[3](紧跟在差异明细之后、值是真的那一次)
-    expect(s3[1]).toBe(s2[3]);
+  /**
+   * **S3 的关系笔只重算判定,收口四格一个字不碰**(2026-08-31 用户:「差异评估结论审核这个
+   * 界面的收口结论下面这 4 个字段也需要可以编辑」)。
+   *
+   * 此前 S2 与 S3 共用同一份 `RELATION_PROJECTION`(「各写一份早晚分叉」)。件上把四格打开
+   * 之后那条口径不能再照搬:那一笔每跑一次就按规则重写这四列,而人在件上按保存会触发
+   * quiet 拍、quiet 恰恰跑 `project` —— 人刚写下的话当场被冲掉,等于格子白开。
+   *
+   * 现在 S3 换成 `RELATION_RECOMPUTE`:只列主键 + `recommendation_level`。`patch` 是稀疏的、
+   * DB 侧是 jsonb 浅合并,没列的列原样留着 —— **这条断言的要害就是「没列」**,列了就等于没改。
+   * 而 `recommendation_level` 必须仍在(判据核心:件② 判据表 / 件③ 落账结论 / 出口谓词都读它,
+   * 「人改四态 → 等级跟着变」这条链不能断),且与 S2 那份是**同一个 when 链引用**(不许分叉)。
+   */
+  it('**S3 的关系笔只重算判定** —— 收口四格(理由/摘要/风险/验证要求)一列都不许出现,否则人改完一保存就被冲掉', () => {
+    const relation = s3[1];
+    expect(relation?.kind).toBe('project');
+    const fieldsOf = (act: (typeof s3)[number] | undefined): Readonly<Record<string, unknown>> =>
+      act?.kind === 'project' ? act.fields : {};
+    const fields = fieldsOf(relation);
+    for (const col of ['recommendation_reason', 'difference_summary', 'risk_level', 'verification_requirement']) {
+      expect(Object.keys(fields), col).not.toContain(col);
+    }
+    /* 判定仍要重算,且与 S2 那份共用同一条 when 链 —— 两处各写一份早晚分叉 */
+    const s2Relation = fieldsOf(s2[3]);
+    expect(fields['recommendation_level']).toBeDefined();
+    expect(fields['recommendation_level']).toBe(s2Relation['recommendation_level']);
+    /* 主键带回:同 PK 覆盖,不是新开一行 */
+    expect(fields['substitution_relation_id']).toBeDefined();
+    /* 验证记录那一笔仍与 S2 同一份(它不涉及人可改的格子) */
     expect(s3[2]).toBe(s2[4]);
   });
 

activities/part-substitution-assessment/src/case-model.ts

@@ -267,6 +267,37 @@ const RELATION_PROJECTION = {
   },
 } as const;
 
+/**
+ * **S3 专用的关系重算笔** —— 只重算「判定」,**收口四格一个字不碰**
+ * (2026-08-31 用户:「差异评估结论审核这个界面的收口结论下面这 4 个字段也需要可以编辑」)。
+ *
+ * 那四格(推荐理由 / 差异摘要 / 替代风险 / 验证要求)此前只读,件上打开可编辑之后,
+ * **光开格子等于没开**:`RELATION_PROJECTION` 每跑一次就按规则把它们重写一遍,而人在件上
+ * 按保存会触发 quiet 拍、quiet 恰恰跑 `project` —— 人刚写下的话当场被规则值冲掉。
+ * 那是「让你改、改完被冲掉」,比不给改更糟。
+ *
+ * 与 `DIFFERENCE_ITEM_RECOMPUTE` 同一手法:**只列要重算的列,一个都不多写**。
+ * `draftWrite` 的 `patch` 是稀疏的(只含显式给出的列),DB 侧 `patch = patch || excluded.patch`
+ * 是 jsonb **浅合并** —— 没列的列原样留着,人改过的四格因此保得住。
+ *
+ * **`recommendation_level` 仍然重算,而且不容手改**:它是规则按四态分布算出来的判据核心,
+ * 「人改四态 → 等级跟着变」这条链不能断(件② 的判据表、件③ 的落账结论、出口谓词都读它)。
+ * 于是这一步的分工是:**判定归规则,话归人**。
+ *
+ * 代价说在明处:人改完四态,这四格**不会**自动跟着改口(否则他刚写的话就没了)——
+ * 件上那段说明已如实写清「四态改完,记得回头看看这四格还对不对」。界面不撒谎优先于自动。
+ */
+const RELATION_RECOMPUTE = {
+  kind: 'project' as const,
+  into: 'substitution.relation',
+  from: { once: true as const },
+  fields: {
+    /* 主键原样带回,认的是这一行自己 —— 不是新建,是同 PK 覆盖 */
+    substitution_relation_id: { in: 'relationId' },
+    recommendation_level: RELATION_PROJECTION.fields.recommendation_level,
+  },
+} as const;
+
 /* P-06 **一单固定一条**(用户定)。本活动只写「还得去验什么」,状态一律 `not_started`:它不是实测结果,**不许虚构实测**。 */
 const VALIDATION_PROJECTION = {
   kind: 'project' as const,
@@ -299,6 +330,14 @@ const VALIDATION_PROJECTION = {
  * 两处不给 `doneWhen`:`S3_review`(人拍板且可循环)、`T_release`(签下去)——
  * 判据不许摆在还欠一张卡的那一步眼前(会诱使它去凑判据,2026-08-28 用户实测逼出的立墙)。
  */
+/**
+ * 「输入还差东西」的判定 —— 发卡条件与案卷 `gate_state` 共用同一句(一处真源):
+ * 条件只用基座读数(gate_reason 为空串时那一列压根不写、未绑定名参与比较会翻车)。
+ */
+const GATE_OPEN_WHEN =
+  'sub_eval_part_exists_status_found < 2 or sub_eval_part_missing > 0 or ' +
+  'sub_eval_part_distinct_chip_type_id > 1 or parts_profile_missing > 0 or parts_parameter_missing > 0';
+
 export const ASSESSMENT_STEPS = [
   {
     item: 'S1_inputs' as const,
@@ -308,7 +347,7 @@ export const ASSESSMENT_STEPS = [
        与 auto.do 第 ⑥ 笔 `card` 的 `gateLedgers` 同源(parts.chip_type / parts.type_param /
        parts.profile / parts.parameter —— 四张表都在闸上,理由见那笔 `card` 定义处的注释)。 */
     view: 'input-supplement',
-    writes: ['sub_eval.part', 'sub_eval.case', 'parts.chip_type', 'parts.type_param', 'parts.profile', 'parts.parameter'],
+    writes: ['sub_eval.part', 'sub_eval.case', 'parts.profile', 'parts.parameter'],
     reads: ['originalInternalPn', 'candidateInternalPn', 'case:openedAt', 'parts.profile', 'parts.parameter', 'parts.chip_type', 'parts.type_param'],
     tools: [],
     doneWhen:
@@ -347,85 +386,12 @@ export const ASSESSMENT_STEPS = [
           },
         },
         /*
-         * ② **选中的那一行类型字典,原样投一遍**(2026-08-30,Ruling H35 —— 真跑 e2e 撞见的
-         * 平台侧连带问题:「数据工单确认即入库」按 `gateLedgers` 整表并入正式表,而
-         * `parts.chip_type` 从 Task 7 起就没列在 `gateLedgers` 里 —— 人一旦真的新建一个类型,
-         * `parts.profile`/`parts.type_param` 引用着它一起落地,**字典行本身**却只留在这一单
-         * 草稿里、从没落地过。下一个任务读到同一颗料,查这个 `chip_type_id` 时字典里空空如也,
-         * `refersTo` 当场拒——是一条悬空引用,不是「查无此值」那种输入错误)。
-         *
-         * **这一笔不看「新建还是已有」,统统投一遍**(不选型的选也一样、新建的选也一样):
-         * 读的是 `sub_eval.part` 每一行当下的 `chip_type_id`(空串时下面这层 `each` 天然查
-         * 不到、不产生任何行 —— 人还没选类型的那颗不会被提前铺出假行),按它去
-         * `parts.chip_type` 里找到那一行、原样把 `type_name`/`description` 抄回自己身上。
-         * 值没变,`draftWrite` 同 PK 覆盖静默跳过(幂等,不产生多余的写入痕迹)——
-         * 但**这一单的草稿层从此真的有这一行**,`mine:parts.chip_type` 不再天然为空。
-         *
-         * 这条把 `parts.chip_type` 重新放回下面 ⑥ 的 `gateLedgers` 铺平了路:闸不会再拿
-         * 「零行」的旧理由误拦(那个前提不成立了),而选中的类型(新建的也好、已有的也好)
-         * 会随「数据工单确认入库」一起落进正式表 —— 不再留悬空引用。
+         * ~~② 类型字典自投影 / ③ 字段清单自投影~~(2026-08-31 用户定「本活动只选类型、
+         * 不新增类型」后退役):这两笔当年(Ruling H35)是为「人新建的类型/字段要随数据
+         * 工单确认一起落地、且 mine: 不为空好让闸不误拦」而生 —— 类型只许从字典里选之后,
+         * 选中的类型本来就在正式表里,镜像与落地都失去了对象;`gateLedgers` 同批收窄到
+         * `parts.profile` / `parts.parameter` 两张真被人编辑的表。历史见 git(2.9.0 及更早)。
          */
-        {
-          kind: 'project' as const,
-          into: 'parts.chip_type',
-          /*
-           * **不带 `prune`**(2026-08-30 第二处修正,e2e 案例 2 撞出来的第二个坑)——
-           * `parts.chip_type` 在 ⑦ 的 `gateLedgers` 上,人交回数据工单那一刻这张表就跟着
-           * 「数据工单确认即入库」落进正式表(`landsOnConfirm`);已落地的行 `draftDrop`
-           * (`prune` 的撤行机制)撤不掉,配方原样抛 `AutoRecipeError`(原文:「这一行是本单
-           * 在数据工单里建好、人确认后已入库的,撤不掉」)。案例 2(类型不一致·硬拦)第一次
-           * 提交时 LM2596S-5.0 还在 type_id=1、随首次确认落地;人接着把它改挂到 type_2 后,
-           * 这一笔重投只剩 type_2 一行,`prune:true` 想把已经落地的 type_1 那行撤掉 —— 直接炸。
-           * 去掉 `prune` 就不会再触发这条撤行:陈旧的选型历史留在草稿层不是错误(字典行本就
-           * 该积累、不该因为这一单后来改了主意就被追溯撤销),`parts.profile`/`parts.parameter`
-           * 那几笔**仍然** `prune:true`(它们是这一单自己的骨架,换料/换类型确实要清旧行,
-           * 且它们不会像字典这样跨料共享、也不会被单独确认入库)。
-           */
-          from: {
-            each: 'mine:sub_eval.part',
-            then: { each: 'parts.chip_type', where: { type_id: { outer: 'chip_type_id' } } },
-          },
-          fields: {
-            type_id: { col: 'type_id' },
-            type_name: { col: 'type_name' },
-            description: { col: 'description' },
-          },
-        },
-        /*
-         * ③ **选中类型的核心参数字段清单,同一套道理原样投一遍**(2026-08-30,与 ② 同一次
-         * 发现、同一个技法):`parts.type_param` 只有人在件上「新建类型时加字段」才会写它 ——
-         * 挑一个已有类型时,这张表天然一行都没有,而它此刻仍在 ⑥ 的 `gateLedgers` 上,
-         * 「零行 = 没干完」的闸对这条路一样是误判(2026-08-30 真跑 e2e 五案例实测坐实:
-         * 「归到已有类型」的候选缺库 / 类型不一致 / 原PN缺库 / 两颗都缺库四例,全部卡死在
-         * 同一条「芯片类型核心参数字段 这一单还一行都没有」)。
-         *
-         * 修法与 ② 完全同构:按当下选中的 `chip_type_id` 把那个类型的核心参数字段清单
-         * 整套原样抄回自己身上(值没变,幂等,不产生多余写入)——**新建的类型也走这条路**:
-         * 人在件上新增的字段行本就已经在 `mine:parts.type_param` 里,这一笔重新投一遍
-         * 原样命中、照样幂等跳过,不会覆盖人刚填的内容。
-         *
-         * **同样不带 `prune`**(与 ② 同一处修正,同一个理由:字段清单也在 ⑥ 的
-         * `gateLedgers` 上,人交回数据工单那一刻就会跟着落地;已落地的行 `prune` 撤不掉,
-         * 带上 `prune:true` 会在「先前定过某个类型的字段清单、后来改选了另一个类型」这条
-         * 路上原样复现 H35 e2e 案例 2 那个死锁)。历史选型的陈旧字段行留在草稿层不算错,
-         * 与 ② 的字典行是同一条道理。
-         */
-        {
-          kind: 'project' as const,
-          into: 'parts.type_param',
-          /* 同上一笔同一个理由,同一次修正(含"不带 prune") —— 见 ② 那笔头上的大注释,不重复贴 */
-          from: {
-            each: 'mine:sub_eval.part',
-            then: { each: 'parts.type_param', where: { type_id: { outer: 'chip_type_id' } } },
-          },
-          fields: {
-            type_id: { col: 'type_id' },
-            param_name: { col: 'param_name' },
-            param_desc: { col: 'param_desc' },
-            constraint_type: { col: 'constraint_type' },
-            param_unit: { col: 'param_unit' },
-          },
-        },
         /*
          * ④ 主数据骨架:**两颗料都铺、值回填现值**。
          * 在库那颗回填出它此刻的样子(人不必重填);要建那颗全空等人填。
@@ -464,7 +430,13 @@ export const ASSESSMENT_STEPS = [
         {
           kind: 'project' as const,
           into: 'parts.parameter',
-          prune: true,
+          /*
+           * **`prune: 'live'`(2026-08-31 用户:「切换料号类型时…只会跟着变多,不会跟着变少」)**:
+           * 参数骨架的行集全由这一笔按「料 × 类型字段」铺,人在件上**加不了行**(没有加行钮),
+           * F3 那条「quiet 拍不撤行」防的风险在这张表上不存在 —— 人改了类型、按保存,旧类型的
+           * 参数行当场撤掉,屏上跟手。已落地的行照旧跳过并出声(skipLanded)。
+           */
+          prune: 'live' as const,
           from: {
             each: 'mine:sub_eval.part',
             then: { each: 'parts.type_param', where: { type_id: { outer: 'chip_type_id' } } },
@@ -524,6 +496,11 @@ export const ASSESSMENT_STEPS = [
           fields: {
             eval_ref: { in: 'evalRef' },
             chip_type_id: { lookup: 'mine:sub_eval.part', by: { role: 'original' }, take: 'chip_type_id', else: '' },
+            /*
+             * 红条的开关(2026-08-31):gate_reason 清空时按列归型不落笔(旧话留在草稿里),
+             * 这面开关两个值都非空、两个方向都真写 —— 件上按它收红条,与发卡条件同一句判定。
+             */
+            gate_state: { when: GATE_OPEN_WHEN, then: 'open', else: 'clear' },
             gate_reason: {
               when: 'sub_eval_part_rows < 2',
               then: '原料号与候选料号填成了同一个 —— 没法比出差异,请终止本单,换两个不同的料号重开。',
@@ -532,13 +509,13 @@ export const ASSESSMENT_STEPS = [
                 then: '有料号库里查不到 —— 在下面把它的主数据建起来。',
                 else: {
                   when: 'sub_eval_part_missing > 0',
-                  then: '有料号还没归芯片类型 —— 在下面给它选一个;没有合适的就新建一个,并把它的核心参数字段一并定下来。',
+                  then: '有料号还没归芯片类型 —— 在档案卡上给它选一个;字典里没有合适的,先请数据管理员补进类型字典(本活动只选不建)。',
                   else: {
                     when: 'sub_eval_part_distinct_chip_type_id > 1',
                     then: '两颗料不是同一个芯片类型,逐项比对无从谈起 —— 换一颗料,或者把归错的那颗类型改对。',
                     else: {
                       when: 'parts_profile_missing + parts_parameter_missing > 0',
-                      then: '还有必填格空着 —— 红带点名的那几格填上就能提交。',
+                      then: '还有必填格空着 —— 缺哪几格就点名在下面两行,填上就能提交。',
                       else: '',
                     },
                   },
@@ -554,9 +531,7 @@ export const ASSESSMENT_STEPS = [
          */
         {
           kind: 'card' as const,
-          when:
-            'sub_eval_part_exists_status_found < 2 or sub_eval_part_missing > 0 or ' +
-            'sub_eval_part_distinct_chip_type_id > 1 or parts_profile_missing > 0 or parts_parameter_missing > 0',
+          when: GATE_OPEN_WHEN,
           as: 'execution' as const,
           variant: 'data' as const,
           title: '数据工单 · 差异评估的输入还差几格',
@@ -567,29 +542,27 @@ export const ASSESSMENT_STEPS = [
           ],
           guide: [
             '两颗料必须归到**同一个芯片类型**下 —— 要比的核心参数字段由类型定,类型不同就没有可比的字段。',
-            '类型下拉里没有合适的,就新建一个,并把它的**核心参数字段**一并定下来:每个字段要有名字、一句说明、以及硬约束还是软约束。',
-            '说明写「这个参数为什么要紧」——**它是后面判定差异时唯一的解释来源**,写成参数名的复述等于没写。',
-            '硬约束 = 不满足就不能用(烧芯片、超温域、装不上);软约束 = 影响表现但可权衡(功耗、噪声)。',
+            '类型**只从字典里选,本活动不新增类型**(2026-08-31 用户定)—— 字典里没有合适的,先请数据管理员补进字典,再回来选。',
+            '硬约束 = 不满足就不能用(烧芯片、超温域、装不上);软约束 = 影响表现但可权衡(功耗、噪声)—— 字段的硬软在字典上定死,件上「比对基准」卡可查。',
             '参数值填**原厂规格书上的值**,查不到就留空 —— 留空会被红带点名,但**编一个值比留空坏得多**。',
           ],
           standard: '红带消失、提交钮变绿:两颗料都在库、归了同一个类型、每个核心参数字段都有值。',
           /*
-           * **`parts.chip_type` 与 `parts.type_param` 都在闸上**(2026-08-30 改,Ruling H35)——
-           * 从前 `parts.chip_type` 被永久排除在外,理由是「它没有编辑手段,`mine:` 天然为空,
-           * 列了就永久卡死」;那条理由**从 ②③ 两笔自我投影加上之后就不再成立**——
-           * `mine:parts.chip_type`/`mine:parts.type_param` 现在恒不为空(只要 `sub_eval.part`
-           * 里已经选定了类型),闸不会再误判「一行都没有」。
-           *
-           * **既然要落地就必须在名单里,这不是碰运气**:「数据工单确认即入库」把 `gateLedgers`
-           * 列出的表整批并入正式表;`parts.chip_type` 若不在这份名单里,人新建的类型字典行
-           * 就只留在草稿层,而引用它的 `parts.profile`/`parts.type_param` 却随名单一起落地 ——
-           * 落地那一刻起,正式表里就有一行指着字典里查无此号的悬空引用(2026-08-30 真跑
-           * e2e 撞见的平台侧连带发现:范围放行没有对 `refersTo` 做传递闭包,并一张表却不
-           * 并它引用的表,必然留下悬空引用;那条更普遍的平台缺陷已记 `docs/debt.md`,
-           * 这里只在活动自己的声明层堵住这一处具体触发点)。四张表都在闸上、也都会一起
-           * 落地,才是「选类型」这件事完整、闭环的样子。
+           * **闸只盯人真编辑的两张表**(2026-08-31 随「只选不建」收窄):从前 `parts.chip_type`/
+           * `parts.type_param` 也在名单上 —— 那是给「人新建的类型要随确认一起落地」铺的路
+           * (Ruling H35,史见 git)。类型只许从字典里选之后,字典行本来就在正式表里,
+           * 落地无对象、mine: 恒为空 —— 留在名单上反而会被「零行 = 没干完」的闸误拦死。
            */
-          gateLedgers: ['parts.chip_type', 'parts.type_param', 'parts.profile', 'parts.parameter'],
+          gateLedgers: ['parts.profile', 'parts.parameter'],
+          /*
+           * **类型不一致不许确认**(2026-08-31 用户:「提示两颗料不是同一个芯片类型…就不应该
+           * 能写入并继续下一步」)。缺格闸管不了这件事(它只数必填空不空),条件档在受理
+           * 回传前现算 —— 钉 **parts.profile 本表**的 distinct(提交闸从草稿现读,零滞后;
+           * 钉 sub_eval.part 的那份要等配方 tick 同步,人存完就点确认会被误拦)。
+           * <= 1:两颗同型(1)或都还没选(0,那时缺格闸已经拦着)都放;>= 2 才是这堵墙。
+           */
+          gateWhen: 'parts_profile_distinct_chip_type_id <= 1',
+          gateWhenSay: '两颗料不是同一个芯片类型 —— 逐项比对无从谈起:换一颗料,或把归错的那颗类型改对,再来确认。',
         },
         { kind: 'say' as const, text: '已核对两颗料的在库状态与参数齐备情况。' },
       ],
@@ -742,10 +715,11 @@ export const ASSESSMENT_STEPS = [
     item: 'S3_review' as const,
     intent: '把逐条结论摆给人过目,他就地改四态与影响说明,改到没问题为止',
     guide: '',
-    /* Task 8:人核对结论用的验收工单 —— 对决头(原 PN → 候选 PN)+ 四态分布带 + 推荐等级大徽章
-       只读,逐条明细可就地改(四态 / 影响说明 / 判断依据 / UNKNOWN 去向),收口四格
-       (推荐理由 / 差异摘要 / 风险 / 验证要求)只读——它们是配方按规则算的,人改了上面的四态,
-       这一步的 auto.do 里那两笔投影(RELATION_PROJECTION / VALIDATION_PROJECTION)会重算它们。 */
+    /* Task 8:人核对结论用的验收工单 —— 对决头(原 PN → 候选 PN)+ 四态分布带只读,
+       推荐等级大徽章只读(判据核心,改四态即改它),逐条明细可就地改(四态 / 影响说明 /
+       判断依据 / UNKNOWN 去向);**收口四格(推荐理由 / 差异摘要 / 风险 / 验证要求)
+       2026-08-31 起可就地改**,写下的以人为准 —— 这一步因此用 `RELATION_RECOMPUTE`
+       (只重算判定)而不是 `RELATION_PROJECTION`(会把四格按规则重写、冲掉人写的话)。 */
     view: 'difference-review',
     writes: ['substitution.difference_item', 'substitution.relation', 'validation.record'],
     reads: ['substitution.difference_item', 'substitution.relation'],
@@ -773,7 +747,9 @@ export const ASSESSMENT_STEPS = [
          * 那一笔后面」的又一例 —— 摘要只读,改的是四态。
          */
         DIFFERENCE_ITEM_RECOMPUTE,
-        RELATION_PROJECTION,
+        /* **不是 `RELATION_PROJECTION`** —— 那一笔会把收口四格按规则重写,把人刚改的话冲掉。
+           这一步只重算判定(推荐等级跟着四态走),四格交给人,见 `RELATION_RECOMPUTE` 的头注。 */
+        RELATION_RECOMPUTE,
         VALIDATION_PROJECTION,
         {
           kind: 'card' as const,

activities/part-substitution-assessment/src/manifest.ts

@@ -54,7 +54,7 @@ export const manifest: ActivityManifest = {
     activityId: ACTIVITY_ID,
     name: 'ACT-WORK-05 · 差异评估',
     /* 重写不是改 —— 同版重装是 no-op(静默丢失,踩过) */
-    packageVersion: '2.2.2',
+    packageVersion: '2.13.0',
     category: '需求分析与方案匹配',
     sdkVersion: '0.1.0-m5',
     checksum: 'dev-checksum-part-substitution-assessment',
@@ -89,7 +89,14 @@ export const manifest: ActivityManifest = {
        *
        * 运营端启动表单渲染这两格为「选择 + 新增」下拉(`x-control: combo`),候选从
        * `parts.profile.internal_pn` 现读(`x-options`);`x-order` 定表单次序(清单存在
-       * jsonb 里,书写顺序到不了运营端)。requestDescription / candidateInternalPns(数组)/
+       * jsonb 里,书写顺序到不了运营端)。
+       *
+       * **两格按芯片类型联动**(2026-08-31 用户定):`x-options.group` 让候选带上各自的
+       * `chip_type_id` 与它在 `parts.chip_type` 里的人读名,`x-link: 'chip-type'` 把两格结成一组 ——
+       * 组内**先填的那格是锚**(摆全量),另一格只列同类型的料 + 库里未标类型的(殿后一组)+「新增」。
+       * 锚没有类型、或锚填的是库里没有的新料号 → 不收窄(两颗都还没建档时不该拦着人)。
+       * **这只是表单的引导,不是墙**:服务端照收两格不同类型的组合(`launch-params.ts` 头注),
+       * 类型一致由 S1 的收步判据 `sub_eval_part_distinct_chip_type_id = 1` 管 —— 那才是数得出来的门。requestDescription / candidateInternalPns(数组)/
        * datasheets 三键已随重写撤下 —— 这一版没有「需求主记录」「N 候选并行」「预填
        * datasheet」这几件事。
        */
@@ -103,8 +110,9 @@ export const manifest: ActivityManifest = {
             description: '差异评估基准料号(必填);库里有就选,没有就自己写一个新的 —— 它的主数据(品牌/类型/参数)缺了才由第一步派数据工单补齐。',
             examples: ['LM2596S-5.0'],
             'x-control': 'combo',
-            'x-options': { ledger: 'parts.profile', value: 'internal_pn', label: 'internal_pn' },
+            'x-options': { ledger: 'parts.profile', value: 'internal_pn', label: 'internal_pn', group: { column: 'chip_type_id', ledger: 'parts.chip_type', value: 'type_id', label: 'type_name' } },
             'x-order': 1,
+            'x-link': 'chip-type',
           },
           candidateInternalPn: {
             type: 'string',
@@ -112,8 +120,9 @@ export const manifest: ActivityManifest = {
             description: '被评估的候选料号(必填);库里有就选,没有就自己写一个新的 —— 它的主数据(品牌/类型/参数)缺了才由第一步派数据工单补齐。',
             examples: ['XL2596S-5.0'],
             'x-control': 'combo',
-            'x-options': { ledger: 'parts.profile', value: 'internal_pn', label: 'internal_pn' },
+            'x-options': { ledger: 'parts.profile', value: 'internal_pn', label: 'internal_pn', group: { column: 'chip_type_id', ledger: 'parts.chip_type', value: 'type_id', label: 'type_name' } },
             'x-order': 2,
+            'x-link': 'chip-type',
           },
         },
       },
@@ -347,7 +356,7 @@ export const manifest: ActivityManifest = {
         fields: [
           col({ name: 'internal_pn', type: 'text', label: '内部料号', primaryKey: true }),
           /* 与 `parts.chip_type.type_id` 同一条身份链路,同一个理由改成 text —— 见该字段的大注释 */
-          col({ name: 'chip_type_id', type: 'text', label: '芯片类型', required: true, refersTo: 'parts.chip_type.type_id' }),
+          col({ name: 'chip_type_id', type: 'text', label: '芯片类型', required: true, distinct: true, refersTo: 'parts.chip_type.type_id' }),
           col({ name: 'brand_name', type: 'text', label: '品牌名称', required: true }),
           col({ name: 'lifecycle_status', type: 'text', label: '生命周期状态', required: true, tally: ['active', 'nrnd', 'eol', 'discontinued', 'risk'] }),
           col({ name: 'specification_description', type: 'text', label: '规格描述', expect: true }),
@@ -431,6 +440,13 @@ export const manifest: ActivityManifest = {
           /* 与 `parts.chip_type.type_id` 同一条身份链路,同一个理由改成 text —— 见该字段的大注释 */
           col({ name: 'chip_type_id', type: 'text', label: '本单锁定的芯片类型' }),
           col({ name: 'gate_reason', type: 'text', label: '入参未就绪原因(件上摆的就是它)' }),
+          /*
+           * **红条的开关是真数据,不是那句话空不空**(2026-08-31 用户:「没有必填要警告了,
+           * 红色区域就不要显示」):gate_reason 清成空串时按列归型**不落笔**(空值=不写这一列,
+           * jsonb 合并保旧值)—— 那句话一旦写下就清不掉,红条永远亮着。开关列两个值都非空,
+           * 两个方向都写得动;件上 data-class-of 投影 v-clear 收红条,判断留在样式表。
+           */
+          col({ name: 'gate_state', type: 'text', label: '入参闸门状态', tally: ['open', 'clear'] }),
           col({ name: 'summary', type: 'text', label: '结论摘要' }),
         ],
       },
@@ -568,7 +584,7 @@ export const manifest: ActivityManifest = {
    * LM2596S-3.3 刻意不在库。
    */
   samples: [
-    { name: '候选缺库·新建类型', input: { originalInternalPn: 'LM2596S-5.0', candidateInternalPn: 'XL2596S-5.0' }, expect: { ports: ['assessment-released'] } },
+    { name: '候选缺库·建档定型', input: { originalInternalPn: 'LM2596S-5.0', candidateInternalPn: 'XL2596S-5.0' }, expect: { ports: ['assessment-released'] } },
     { name: '都在库·零卡直分析', input: { originalInternalPn: 'LM2596S-5.0', candidateInternalPn: 'LM2596S-ADJ' }, expect: { ports: ['assessment-released'] } },
     { name: '类型不一致·硬拦', input: { originalInternalPn: 'LM2596S-5.0', candidateInternalPn: 'AMS1117-3.3' }, expect: { ports: ['assessment-released'] } },
     { name: '原PN缺库', input: { originalInternalPn: 'LM2596S-3.3', candidateInternalPn: 'LM2596S-ADJ' }, expect: { ports: ['assessment-released'] } },

activities/part-substitution-assessment/src/views/style.ts

@@ -0,0 +1,462 @@
+/**
+ * ACT-WORK-05 三张工单件的设计系统(2026-08-31 视图层整体重设计。用户定:
+ * 「中间这一块不要搞的像后台管理端,要像给客户使用的 C 端界面;可以按主题加 SVG 图形,
+ * 可以有动画,加强交互 —— 只保留功能,视图层可以推翻重新设计」)。
+ *
+ * 设计语言:「精密检测报告」——
+ *   · 题头是一块深色电路板夜景(hero):芯片封装、铜引脚、流动的走线信号,
+ *     三张件各有一幕对应自己职能的场景(建档台 / 对决量尺 / 落账席);
+ *   · 正文回到瓷白纸面,报告化排版:丝印体小标(silkscreen)、mono 料号、
+ *     引脚号式的序号列 —— 用电子行业自己的版面语汇,不借后台管理端的灰表格;
+ *   · 动画只做 transform / opacity(信号点流动、晶粒呼吸、印章环慢转、入场浮起),
+ *     prefers-reduced-motion 下全部静止 —— 与工作台动画同一条纪律。
+ *
+ * 旧的 target-style.ts(逐字节抽自目标件的三段样式)随本次重设计退役:目标件是
+ * 「照着做」时代的锚,这一版是活动自己的设计,样式只此一处真源。
+ *
+ * **这一整段活在 TS 模板字符串里 —— 不许出现反引号**(一个反引号就把串截断,
+ * esbuild 报在几行之外;本仓踩过)。注释里也别写星号斜杠连排。
+ *
+ * 几条被包内测试钉死的**机制规则逐字保留**,别「顺手整理」:
+ *   · 序号计数器五连(.jc-tbl-wrap table, .tbl-wrap table 成对出现);
+ *   · table:not(.on) tr.jc-row-static { display: none; }(种子行只在编辑态露面);
+ *   · .jc-gate-bar:has(.jc-gate-text:empty) 显隐(gate_reason 是中文自由文本,
+ *     data-class-of 在它上面永远算不出 v-token,显隐只认 data-blank 出的空文本节点);
+ *   · .jc-tbl-wrap 不许 overflow:hidden(表宽超出要能横着滑)。
+ */
+
+/** 件① 数据工单的强调色 —— 数据蓝(与治理台「数据」语义同族) */
+export const ACCENT_DATA = `
+:root{
+  --acc:#2e6bff; --acc-deep:#1f52d6; --acc-soft:#e3ecff; --acc-line:#c2d5ff; --acc-wash:#f3f7ff;
+  --glow:#6fa1ff; --glow-line:rgba(111,161,255,.36); --hero-tint:rgba(46,107,255,.34);
+}
+`;
+
+/** 件②③ 验收工单的强调色 —— 验收绿 #0aa294(2026-08-27 用户定:与对话区验收卡同色) */
+export const ACCENT_LEDGER = `
+:root{
+  --acc:#0aa294; --acc-deep:#07857a; --acc-soft:#dcf5f1; --acc-line:#aee5dd; --acc-wash:#f0fbf9;
+  --glow:#2fd4c2; --glow-line:rgba(47,212,194,.34); --hero-tint:rgba(10,162,148,.32);
+  --ledger:#0aa294;
+}
+`;
+
+export const SHELL_CSS = `
+/* ================= 令牌与底 ================= */
+:root{
+  --ink:#182430; --ink-2:#3d4c5c; --ink-3:#67788a; --ink-4:#97a5b3;
+  --line:#dbe3ea; --line-soft:#e8edf3; --soft:#f5f8fa; --paper:#edf1f5;
+  --board:#0e1b27; --board-2:#15263a;
+  --cu:#d99a5b; --cu-deep:#b57632;
+  --ok:#1e9e56; --ok-soft:#e4f7ec;
+  --danger:#dd4a3a; --danger-soft:#feecea;
+  --amber:#b07a10; --amber-soft:#fdf3d8;
+  --cond:#5661f0; --cond-soft:#e9ebfe;
+  --hero-ink:#f4f8fc; --hero-dim:rgba(226,238,248,.62);
+  --mono:"SF Mono",Menlo,Consolas,monospace;
+}
+*{box-sizing:border-box}
+html,body{margin:0;padding:0}
+body{font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI","PingFang SC","Microsoft YaHei",sans-serif;background:var(--paper);color:var(--ink);font-size:14px;line-height:1.7;-webkit-font-smoothing:antialiased}
+.page{margin:0;padding:0}
+.card{background:#fff;overflow:hidden;border:0;border-radius:0}
+.mono{font-family:var(--mono)}
+i{font-style:normal}
+
+/* ================= 题头:电路板夜景 hero ================= */
+.card-head{
+  position:relative;display:flex;flex-direction:column;gap:12px;padding:20px 22px 22px;color:var(--hero-ink);
+  background:
+    repeating-linear-gradient(0deg, rgba(255,255,255,.03) 0 1px, transparent 1px 28px),
+    repeating-linear-gradient(90deg, rgba(255,255,255,.03) 0 1px, transparent 1px 28px),
+    radial-gradient(900px 340px at 18% -40%, var(--hero-tint), transparent 62%),
+    linear-gradient(158deg, #13212f 0%, var(--board) 56%, #0f1d2b 100%);
+}
+.hero-top{display:flex;align-items:center;gap:10px;flex-wrap:wrap}
+.hero-sys{flex:1 1 auto;min-width:0;font-size:10.5px;font-weight:800;letter-spacing:.17em;color:var(--hero-dim);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.hero-chips{flex:none;display:flex;gap:6px}
+.hero-tag{font-size:11px;font-weight:800;padding:2px 11px;border-radius:999px;color:#fff;background:var(--acc);box-shadow:0 4px 14px var(--glow-line);white-space:nowrap}
+.hero-step{font-size:11px;font-weight:700;padding:2px 11px;border-radius:999px;color:var(--hero-dim);border:1px solid rgba(255,255,255,.22);white-space:nowrap}
+.hero-title{margin:0;font-size:23px;font-weight:800;line-height:1.25;letter-spacing:.01em;color:#fff}
+.hero-meta{font-size:11.5px;color:var(--hero-dim)}
+.hero-meta b{font-weight:700;color:#fff}
+
+/* ── hero 舞台:芯片铭牌 + 信号走线 ── */
+.stage{position:relative;display:flex;align-items:stretch;justify-content:center;gap:clamp(20px,7vw,72px);padding:14px 6px 6px}
+.stage::before{content:"";position:absolute;left:5%;right:5%;top:52%;border-top:2px dashed var(--glow-line)}
+.stage::after{content:"";position:absolute;top:52%;left:5%;width:9px;height:9px;margin-top:-4px;border-radius:999px;background:var(--glow);box-shadow:0 0 14px 3px var(--glow-line),0 0 4px 1px var(--glow);animation:sig 3.4s linear infinite}
+.stage-lab{padding-bottom:8px}
+.stage-duel{padding-top:28px}
+.hchip{position:relative;z-index:1;display:flex;flex-direction:column;align-items:center;gap:6px;flex:0 1 176px;min-width:128px;padding:13px 12px 11px;border-radius:14px;background:rgba(255,255,255,.97);color:var(--ink);box-shadow:0 14px 30px rgba(3,10,18,.5),inset 0 1px 0 rgba(255,255,255,.7)}
+.hchip.v-absent{background:rgba(255,252,246,.97);outline:2px dashed var(--cu);outline-offset:-6px}
+.hchip-role{font-size:10.5px;font-weight:800;letter-spacing:.08em;color:var(--ink-4)}
+.hchip-pn{font-size:14.5px;font-weight:800;color:var(--ink);overflow-wrap:anywhere;text-align:center;line-height:1.3}
+.hchip-badges{display:flex;gap:6px;flex-wrap:wrap;justify-content:center}
+.csvg{width:86px;height:auto;display:block}
+.c-body{fill:var(--board-2);stroke:rgba(217,154,91,.55);stroke-width:1.4}
+.c-pin{fill:var(--cu)}
+.c-die{fill:var(--acc);opacity:.9;animation:breathe 2.8s ease-in-out infinite}
+.c-dot{fill:rgba(255,255,255,.85)}
+.duel-type{position:absolute;z-index:1;left:50%;top:-4px;transform:translateX(-50%);font-size:10.5px;font-weight:800;letter-spacing:.06em;color:var(--hero-dim);border:1px solid rgba(255,255,255,.2);border-radius:999px;padding:2px 12px;background:rgba(10,20,30,.55);white-space:nowrap}
+.duel-type i{font-style:normal;color:#fff}
+.hero-verdict{display:flex;justify-content:center;padding:2px 0 0}
+
+/* ── hero 落账席(件③):印章 + 一句话结论 ── */
+.stage-seal{position:relative;display:flex;align-items:center;justify-content:center;gap:22px;padding:12px 4px 4px;flex-wrap:wrap}
+.seal{position:relative;flex:none;width:112px;height:112px;border-radius:999px;display:grid;place-items:center}
+.seal::before{content:"";position:absolute;inset:0;border:1.6px dashed rgba(255,255,255,.34);border-radius:999px;animation:sealspin 16s linear infinite}
+.seal-core{display:grid;place-items:center;padding:7px 11px;border-radius:999px;background:rgba(255,255,255,.97);box-shadow:0 12px 26px rgba(3,10,18,.5)}
+.seal-sum{flex:1 1 240px;min-width:200px;max-width:420px;margin:0;font-size:13px;line-height:1.85;color:var(--hero-dim)}
+.seal-sum:empty::after{content:"—"}
+
+/* ── 浅色题头变体(件① 2026-08-31 用户:「标题背景还是改成之前的那种蓝色渐变」——
+      渐变取自原目标件 card-head 那一条,深色电路夜景只留给验收两件)── */
+.hd-light .card-head{background:linear-gradient(120deg,#f0f5ff 0%,#fff 55%,#eef4ff 100%);color:var(--ink);border-bottom:2px solid var(--ink)}
+.hd-light .hero-sys{color:var(--ink-4)}
+.hd-light .hero-title{color:var(--ink)}
+.hd-light .hero-step{color:var(--ink-3);border-color:var(--line)}
+.hd-light .hero-meta{color:var(--ink-3)}
+.hd-light .hero-meta b{color:var(--ink)}
+
+/* ================= 正文分区 ================= */
+.card-bd{padding:20px 22px 8px}
+.sec{display:flex;align-items:baseline;gap:9px;margin:26px 0 10px;flex-wrap:wrap}
+.sec:first-child{margin-top:4px}
+.sec-pin{flex:none;align-self:center;width:24px;height:24px;border-radius:8px;display:grid;place-items:center;background:var(--acc-soft);color:var(--acc-deep)}
+.zic{width:13px;height:13px;display:block}
+.sec-t{font-size:13.5px;font-weight:800;color:var(--ink);letter-spacing:.02em}
+.sec-d{flex:1 1 200px;min-width:0;font-size:11.5px;color:var(--ink-3)}
+
+/* 简报卡(做什么 / 纪律…) */
+.brief{border:1px solid var(--line-soft);border-left:3px solid var(--acc);border-radius:10px;background:var(--acc-wash);padding:13px 16px;margin:0 0 4px}
+.brief p{margin:0 0 7px;font-size:12.5px;line-height:1.75;color:var(--ink-2)}
+.brief p:last-child{margin-bottom:0}
+.brief b{color:var(--ink)}
+.done,.need{display:inline-block;font-size:10.5px;font-weight:800;padding:0 8px;border-radius:999px;vertical-align:1px;margin-right:2px}
+.done{color:var(--ok);background:var(--ok-soft)}
+.need{color:var(--acc-deep);background:var(--acc-soft)}
+
+/* 收尾指引 */
+.flow{margin:24px 0 14px;padding:12px 16px;border-radius:10px;border:1px dashed var(--acc-line);background:var(--acc-wash);font-size:12.5px;color:var(--ink-2);line-height:1.8}
+.flow b{color:var(--acc-deep)}
+
+/* 页脚:丝印条 */
+.card-foot{display:flex;justify-content:space-between;align-items:center;gap:12px;padding:12px 22px;border-top:1px solid var(--line-soft);background:var(--soft);font-size:11px;color:var(--ink-4);flex-wrap:wrap}
+.foot-r{letter-spacing:.04em}
+
+/* ================= 顶部「还差什么」红带(机制:显隐认 data-blank 的空文本节点) ================= */
+.jc-gate-bar{display:flex;flex-direction:column;gap:5px;margin:0 0 16px;padding:11px 14px;border-radius:10px;background:var(--danger-soft);border:1px solid #f5c0ba;color:var(--danger);font-size:12.5px;line-height:1.7}
+.jc-gate-bar b{font-weight:800}
+.jc-gate-bar:has(.jc-gate-text:empty){display:none}
+/* 都齐了就整条收起(2026-08-31 用户定)—— 开关是案卷真数据 gate_state(v-clear),
+   不看那句话空不空:gate_reason 清空时按列归型不落笔,旧话会一直留在草稿里 */
+.jc-gate-bar.v-clear{display:none}
+/* 逐块的缺项点名并进这一条(2026-08-31 用户:「页面上所有的问题都合并到最上面的还差什么」)——
+   与提交闸同源的基座读数,数值为 0 的那一行自己消失,只在待处理态出现 */
+.jc-gate-sub{display:none;font-size:12px;color:#a03d34;padding-left:2px}
+html.editable .jc-gate-sub{display:block}
+html.editable .jc-gate-sub.v-0{display:none}
+
+/* 缺项红带 —— 与提交闸同源的必填提示,只在待处理态出现 */
+.jc-gapbar{display:none}
+html.editable .jc-gapbar{display:flex;align-items:flex-start;gap:8px;margin:0 0 10px;padding:9px 13px;border-radius:9px;background:var(--danger-soft);border:1px solid #f5c0ba;color:var(--danger);font-size:12px;line-height:1.7}
+.jc-gapbar b{font-weight:800}
+.jc-gapbar span{color:#a03d34}
+html.editable .jc-gapbar.v-0{display:none}
+
+/* ================= 编辑闸与加行(只在待处理态露面) ================= */
+html:not(.editable) .jc-editgate, html:not(.editable) .jc-addrow { display: none !important; }
+.jc-editgate{display:flex;align-items:center;gap:10px;flex-wrap:wrap;margin:0 0 10px;padding:8px 12px;border-radius:10px;background:var(--soft);border:1px solid var(--line-soft);font-size:12px;color:var(--ink-3)}
+.jc-editgate-t{flex:1 1 auto;min-width:0}
+.jc-editgate-t b{color:var(--ink-2);font-weight:700}
+.jc-egbtn{flex:none;display:inline-flex;align-items:center;gap:5px;cursor:pointer;border:1px solid var(--line);border-radius:999px;padding:6px 15px;font:inherit;font-size:12px;font-weight:700;color:var(--ink-2);background:#fff;transition:border-color .16s,color .16s,background .16s,box-shadow .16s}
+.jc-egbtn:hover{border-color:var(--acc);color:var(--acc-deep);box-shadow:0 0 0 3px var(--acc-soft)}
+.jc-egbtn:active{transform:scale(.96)}
+.jc-egbtn.save{color:#fff;background:var(--acc);border-color:var(--acc)}
+.jc-egbtn.save:hover{filter:brightness(1.06);color:#fff}
+.jc-editgate .eg-cancel,.jc-editgate .eg-save{display:none}
+.jc-editgate.on{background:var(--acc-wash);border-color:var(--acc-line);color:var(--acc-deep)}
+.jc-editgate.on .eg-open{display:none}
+.jc-editgate.on .eg-cancel,.jc-editgate.on .eg-save{display:inline-flex}
+.jc-addrow{display:none;margin:8px 0 0}
+.jc-tbl-wrap:has(table.on) + .jc-addrow { display: flex; align-items: center; gap: 8px; }
+.jc-addrow button{cursor:pointer;border:1px dashed var(--acc-line);border-radius:999px;background:var(--acc-wash);color:var(--acc-deep);font:inherit;font-size:12px;font-weight:700;padding:6px 15px;transition:border-color .16s,box-shadow .16s}
+.jc-addrow button:hover{border-color:var(--acc);box-shadow:0 0 0 3px var(--acc-soft)}
+.jc-addrow button:active{transform:scale(.96)}
+.jc-addrow em{font-style:normal;font-size:11px;color:var(--ink-4)}
+
+/* ================= 报告表格 ================= */
+.jc-tbl-wrap{border:1px solid var(--line-soft);border-radius:12px;background:#fff;overflow-x:auto;overflow-y:hidden}
+.jc-tbl-wrap, .tbl-wrap { overflow-x: auto; overflow-y: hidden; }
+table{width:100%;border-collapse:collapse;font-size:12.5px}
+thead th{position:static;text-align:left;font-size:10.5px;font-weight:800;letter-spacing:.07em;color:var(--ink-4);background:var(--soft);padding:9px 12px;border-bottom:1px solid var(--line);white-space:nowrap}
+th.req::after{content:" ＊";color:var(--danger);font-size:10px}
+tbody td{padding:10px 12px;border-bottom:1px solid var(--line-soft);vertical-align:top;color:var(--ink-2)}
+tbody tr:last-child td{border-bottom:0}
+tbody tr:hover td{background:var(--acc-wash)}
+td.rn,td.num{font-family:var(--mono);font-size:11px;color:var(--ink-4);white-space:nowrap}
+td.mono{font-family:var(--mono);font-size:12px;color:var(--ink-2)}
+td.cust{font-weight:700;color:var(--ink)}
+td.desc,.desc{color:var(--ink-3);font-size:12px;line-height:1.6}
+
+/* 序号列交给 CSS 计数器(沙箱零脚本,增删行后自己数对;两种列名、两种包装类都接) */
+.jc-tbl-wrap table, .tbl-wrap table { counter-reset: rn; }
+.jc-tbl-wrap table td.rn, .tbl-wrap table td.rn { counter-increment: rn; }
+.jc-tbl-wrap table td.rn .jc-rn-num::before, .tbl-wrap table td.rn .jc-rn-num::before { content: counter(rn); }
+.jc-tbl-wrap table td.num, .tbl-wrap table td.num { counter-increment: rn; }
+.jc-tbl-wrap table td.num::before, .tbl-wrap table td.num::before { content: counter(rn); }
+
+/* ── 看与改是两件事:只读份 / 输入孪生件由 .on 二选一 ── */
+.jc-vcell{display:block;font-size:12.5px;color:var(--ink);line-height:1.55;overflow-wrap:anywhere}
+.jc-vcell.mono{font-family:var(--mono);font-size:12px;color:var(--ink-2)}
+.jc-vcell:empty::after{content:"—";color:var(--ink-4)}
+.jc-cell{display:none;width:100%;min-width:72px;border:1px solid var(--line);border-radius:8px;padding:6px 9px;font:inherit;font-size:12.5px;color:var(--ink);background:#fff}
+.jc-cell:focus{border-color:var(--acc);box-shadow:0 0 0 3px var(--acc-soft);outline:none}
+.jc-cell.mono{font-family:var(--mono);font-size:12px}
+input.jc-cell, select.jc-cell { height: 32px; box-sizing: border-box; padding-top: 0; padding-bottom: 0; vertical-align: middle; }
+table.on td>.jc-vcell{display:none}
+table.on td>.jc-vcell.ro{display:block}
+table.on td>.jc-cell{display:block}
+table.on td>.jc-vcell:empty::after{content:none}
+
+/* 增删行的痕(取消还原三件套的可视面) */
+table.on tr.jc-row-new td { background: #f0fbf5; }
+table.on tr.jc-row-gone td { background: #fff6f5; opacity: .55; }
+table.on tr.jc-row-gone .jc-cell { text-decoration: line-through; color: var(--ink-3); }
+.jc-rowdel{display:none;cursor:pointer;border:1px solid var(--line);border-radius:999px;background:#fff;color:var(--ink-3);width:20px;height:20px;line-height:1;font-size:12px;padding:0;margin-left:5px;vertical-align:middle}
+table.on .jc-rowdel{display:inline-grid;place-items:center}
+.jc-rowdel:hover{border-color:var(--danger);color:var(--danger)}
+table.on tr.jc-row-gone .jc-rowdel { border-color: var(--danger); color: var(--danger); background: #fff; }
+
+/* 静态种子行:零行也加得出第一行 —— 只在编辑态露面(读态看见空壳子是界面撒谎) */
+table:not(.on) tr.jc-row-static { display: none; }
+table.on tr.jc-row-static td{background:var(--acc-wash);border-top:1px dashed var(--acc-line)}
+
+/* 主键钥匙格:不给人看,但真挂 data-col(漏了钥匙,这一行凑不出主键) */
+.rowkey{display:none}
+
+/* ================= 徽标基座(取值上色一律 data-class-of 投影,选择器从值算) ================= */
+.stx,.ct,.rl,.st,.risk-badge{display:inline-block;font-size:11px;font-weight:700;padding:1px 9px;border-radius:999px;border:1px solid transparent;white-space:nowrap}
+.rl{background:var(--soft);border-color:var(--line-soft);color:var(--ink-3);font-size:10.5px;letter-spacing:.03em}
+.rec{display:inline-block;font-size:11.5px;font-weight:800;padding:2px 13px;border-radius:999px;border:1px solid transparent;white-space:nowrap}
+.rec.rec-lg{font-size:14.5px;padding:7px 20px;letter-spacing:.03em}
+
+/* kv 行(收口结论 / 待验项共用的键值版式) */
+.kv{display:flex;gap:12px;padding:10px 0;border-bottom:1px solid var(--line-soft);font-size:12.5px}
+.kv:last-child{border-bottom:0}
+.kv i{flex:0 0 84px;font-style:normal;color:var(--ink-4);font-size:11px;font-weight:700;letter-spacing:.05em;padding-top:2px}
+.kv > span{flex:1 1 auto;color:var(--ink-2);line-height:1.7;overflow-wrap:anywhere}
+.kv > span:empty::after{content:"—";color:var(--ink-4)}
+.kv-box{border:1px solid var(--line-soft);border-radius:12px;background:var(--soft);padding:4px 16px;margin-bottom:4px}
+
+/* ================= 动画(全部 transform / opacity;reduced-motion 全静) ================= */
+@keyframes sig{0%{transform:translateX(0);opacity:0}7%{opacity:1}93%{opacity:1}100%{transform:translateX(min(86vw,760px));opacity:0}}
+@keyframes breathe{0%,100%{opacity:.55}50%{opacity:1}}
+@keyframes sealspin{to{transform:rotate(360deg)}}
+@keyframes rise{from{opacity:0;transform:translateY(10px)}to{opacity:1;transform:translateY(0)}}
+.hero-top{animation:rise .5s cubic-bezier(.2,.7,.3,1) both}
+.hero-title{animation:rise .5s .06s cubic-bezier(.2,.7,.3,1) both}
+.stage,.stage-seal{animation:rise .55s .14s cubic-bezier(.2,.7,.3,1) both}
+.hero-verdict,.hero-meta{animation:rise .55s .22s cubic-bezier(.2,.7,.3,1) both}
+@media (prefers-reduced-motion: reduce){
+  *{animation:none !important;transition:none !important}
+}
+
+/* ================= 电路蓝图工作台(件① 的两张档案卡)=================
+   2026-08-31 用户:「卡片下面那个容器黑色和页面背景不搭」—— 深色板底退场,换**浅色蓝图**:
+   底是强调色的极浅晕染 + 淡格线,走线与信号点用强调色 —— 电路语汇留着,纸面色阶不断裂。 */
+.board{position:relative;margin:0 0 6px;padding:18px 14px 16px;border-radius:16px;border:1px solid var(--acc-line);
+  background:
+    repeating-linear-gradient(0deg, rgba(46,107,255,.045) 0 1px, transparent 1px 26px),
+    repeating-linear-gradient(90deg, rgba(46,107,255,.045) 0 1px, transparent 1px 26px),
+    linear-gradient(158deg, var(--acc-wash) 0%, #fff 62%, var(--acc-wash) 100%)}
+.board::before{content:"";position:absolute;left:4%;right:4%;top:50%;border-top:2px dashed var(--acc-line)}
+/* 「可替换」动画(2026-08-31 用户第二稿:「不要做到背景板上,背景板会被卡片覆盖;
+   和卡片做到一级,可以压缩一点卡片的大小」)—— .dossiers 改三列网格,中间留一条
+   **实体动画道**(卡片各占左右列、相应收窄,谁也盖不住它):中央 ⇄ 徽轻呼吸,
+   两枚信号点绕徽**轨道对转**(此上彼下地绕圈 = 两颗料换位),底下横穿的虚线总线
+   在道里露出来把两张卡接起来。 */
+.swapfx{position:absolute;left:50%;top:50%;width:76px;height:76px;transform:translate(-50%,-50%);z-index:1;pointer-events:none}
+.sw-ic{position:absolute;left:50%;top:50%;transform:translate(-50%,-50%);width:36px;height:36px;padding:8px;box-sizing:border-box;color:var(--acc);background:#fff;border:1px solid var(--acc-line);border-radius:999px;box-shadow:0 4px 12px rgba(18,38,63,.16);animation:swbreathe 2.8s ease-in-out infinite}
+.sw-orbit{position:absolute;left:50%;top:50%;width:64px;height:64px;margin:-32px 0 0 -32px;animation:sworbit 4.5s linear infinite}
+.sw-dot{position:absolute;left:50%;width:8px;height:8px;margin-left:-4px;border-radius:999px;background:var(--acc);box-shadow:0 0 8px 2px var(--acc-soft)}
+.sw-d1{top:-4px}
+.sw-d2{bottom:-4px}
+@keyframes sworbit{to{transform:rotate(360deg)}}
+@keyframes swbreathe{0%,100%{transform:translate(-50%,-50%) scale(1)}50%{transform:translate(-50%,-50%) scale(1.1)}}
+/* 三列网格:左右两列给卡,中间 76px 是动画道 —— 与卡同级的真实空间,不被覆盖 */
+.dossiers{position:relative;z-index:1;display:grid;grid-template-columns:minmax(0,1fr) 76px minmax(0,1fr);row-gap:16px}
+.dossiers > .dossier:nth-of-type(odd){grid-column:1}
+.dossiers > .dossier:nth-of-type(even){grid-column:3}
+.dossier{display:flex;flex-direction:column;gap:11px;background:#fff;border:1px solid var(--line-soft);border-radius:16px;padding:15px 16px 14px;box-shadow:0 8px 22px rgba(18,38,63,.09);transition:box-shadow .18s,transform .18s}
+.dossier:hover{transform:translateY(-2px);box-shadow:0 12px 28px rgba(18,38,63,.13)}
+.dz-top{display:flex;align-items:center;gap:12px}
+.dz-top .csvg{width:64px;flex:none}
+.dz-id{display:flex;flex-direction:column;gap:4px;min-width:0}
+.dz-role{display:flex;gap:6px;flex-wrap:wrap}
+.dz-pn{font-size:15px;font-weight:800;overflow-wrap:anywhere;line-height:1.3}
+.dz-pn .jc-vcell{font-size:15px;font-weight:800;color:var(--ink)}
+.dz-type{display:flex;align-items:center;gap:9px;flex-wrap:wrap;padding:8px 10px;border-radius:10px;background:var(--acc-wash);border:1px solid var(--acc-line)}
+.dz-lb{flex:none;font-style:normal;font-size:10.5px;font-weight:800;letter-spacing:.05em;color:var(--ink-4)}
+.dz-type .jc-cell{flex:1 1 140px;width:auto}
+/* 类型名守卫:这一行的下拉真有选中项(selectCurrent 按行作用域写的 option[selected])才摆名 ——
+   行里没选,data-by 落回外层的名一个字都不摆,换「待选择」胶囊。
+   守卫挂在共同祖先 .dz-type 上、单层 :has —— :has() 里再嵌 :has() 是非法选择器,整条会被浏览器
+   静默丢弃(第一版就栽在这:守卫写了等于没写,XL 那张卡照样摆出它没有的类型)。 */
+.tsel{flex:1 1 auto;min-width:0}
+.tsel > span > i{display:inline-block;font-size:11.5px;font-weight:800;color:var(--acc-deep);background:var(--acc-soft);border-radius:999px;padding:1px 11px}
+.dz-type:not(:has(option[selected])) .tsel > span{display:none}
+.dz-type:not(:has(option[selected])) .tsel::after{content:"待选择 · 点「编辑」挑一个";display:inline-block;font-size:11px;font-weight:700;color:var(--amber);background:var(--amber-soft);border:1px dashed #eeda9e;border-radius:999px;padding:1px 10px}
+.dz-grid{display:grid;grid-template-columns:1fr 1fr;gap:9px 12px}
+.fcell{display:flex;flex-direction:column;gap:3px;min-width:0}
+.fcell.wide{grid-column:1 / -1}
+.fcell > i{font-style:normal;font-size:10.5px;font-weight:800;letter-spacing:.05em;color:var(--ink-4)}
+.fcell.req > i::after{content:" ＊";color:var(--danger)}
+.fcell .jc-vcell{font-size:12.5px}
+/* 三级占位:必填红 / 建议橘(空格子直说要不要填,不摆一枚含糊的破折号) */
+.fcell.req .jc-vcell:empty::after{content:"必填";font-size:10.5px;font-weight:800;color:var(--danger);background:var(--danger-soft);border-radius:999px;padding:0 9px}
+/* 徽标包装的必填格(如生命周期):没值时徽标 class 恰为裸 "stx"(class-of 没投出 v-*),
+   wrapper 不为 :empty,上一条够不着 —— 认裸 class 补同一枚胶囊(单层 :has) */
+.fcell.req .jc-vcell:has(> [class="stx"])::after{content:"必填";font-size:10.5px;font-weight:800;color:var(--danger);background:var(--danger-soft);border-radius:999px;padding:0 9px}
+.fcell.sug .jc-vcell:empty::after{content:"建议";font-size:10.5px;font-weight:800;color:var(--amber);background:var(--amber-soft);border-radius:999px;padding:0 9px}
+/* 档案卡的编辑态 —— **按卡开,只点亮这张卡的正面**(2026-08-31 用户:「各自编辑各自的部分,
+   不要做联动」:.on 由 scopedTargets 落在被点那张卡的行 section 上,不再落整个宿主);
+   只圈 .front 是因为卡背住着另一地址的宿主,不圈的话参数输入会被主数据的编辑顺手点亮 */
+.dossier.on .front .jc-vcell{display:none}
+.dossier.on .front .jc-vcell.ro{display:block}
+.dossier.on .front .jc-cell{display:block}
+.dossier.on .front .jc-vcell:empty::after{content:none}
+.dossier.on .dz-role{display:flex}
+
+/* ── 翻面(纯 CSS:checkbox + :has,零脚本;reduced-motion 下瞬时切换)── */
+.dossier{position:relative;perspective:1200px;padding:0;background:none;border:0;box-shadow:none}
+.dossier:hover{transform:none;box-shadow:none}
+.flip-in{display:grid;transform-style:preserve-3d;transition:transform .55s cubic-bezier(.3,.7,.3,1)}
+.face{grid-area:1 / 1;display:flex;flex-direction:column;gap:11px;background:#fff;border:1px solid var(--line-soft);border-radius:16px;padding:15px 16px 14px;box-shadow:0 8px 22px rgba(18,38,63,.09);backface-visibility:hidden;min-width:0}
+.face.back{transform:rotateY(180deg)}
+.flip-tg{position:absolute;opacity:0;pointer-events:none}
+.flip-hit{position:absolute;inset:0;z-index:3;cursor:pointer}
+.flip-cue{position:absolute;z-index:4;bottom:10px;right:10px;pointer-events:none;opacity:.6;transition:opacity .16s,transform .16s}
+.flip-cue i{font-style:normal;display:inline-block;font-size:10.5px;font-weight:800;color:var(--acc-deep);background:var(--acc-soft);border:1px solid var(--acc-line);border-radius:999px;padding:2px 10px}
+.dossier:hover .flip-cue{opacity:1;transform:translateY(-2px)}
+/* 两句提示按面切换 —— 选择器都写到 .flip-cue i 之下的同层级,别被基座那条特异度压回来(踩过) */
+.flip-cue .cue-back{display:none}
+/* 翻转三态,后写的赢:人点的 < 主数据编辑锁正面 < 参数编辑翻背面 */
+.dossier:has(.flip-tg:checked) .flip-in{transform:rotateY(180deg)}
+.dossier:has(.flip-tg:checked) .flip-cue .cue-front{display:none}
+.dossier:has(.flip-tg:checked) .flip-cue .cue-back{display:inline-block}
+.dossier.on .flip-in{transform:rotateY(0deg)}
+.dossier:has(.pback.on) .flip-in{transform:rotateY(180deg)}
+/* 编辑中的**这张卡**不许翻(哪面在编辑锁哪面),点击层与提示丸一起收;另一张卡不受影响 */
+.dossier.on .flip-hit,.dossier:has(.pback.on) .flip-hit{display:none}
+.dossier.on .flip-cue,.dossier:has(.pback.on) .flip-cue{display:none}
+/* 悬浮侧倾:预告「这张卡点了会翻」—— 只在读态、只在真有悬浮的设备、且不嫌动画的人那里 */
+@media (hover:hover) and (prefers-reduced-motion: no-preference){
+  .dossier:hover:not(.on):not(:has(.flip-tg:checked)):not(:has(.pback.on)) .flip-in{transform:rotateY(-12deg)}
+  .dossier:hover:not(.on):has(.flip-tg:checked):not(:has(.pback.on)) .flip-in{transform:rotateY(168deg)}
+}
+
+/* ── 卡角编辑钮:笔=编辑当前这一面,软盘=保存,叉=放弃(2026-08-31 用户定,顶掉两行编辑闸)──
+      笔只在待处理态露面(html.editable,与从前的闸同一条纪律);软盘/叉只在对应面的编辑态露面。 */
+.fabs{position:absolute;top:10px;right:10px;z-index:5;display:flex;gap:6px}
+.fab{display:none;width:32px;height:32px;border-radius:999px;border:1px solid var(--acc-line);background:#fff;color:var(--acc-deep);cursor:pointer;place-items:center;padding:0;box-shadow:0 4px 12px rgba(18,38,63,.14);transition:border-color .16s,color .16s,box-shadow .16s}
+.fab:hover{border-color:var(--acc);box-shadow:0 6px 16px rgba(18,38,63,.22)}
+.fab:active{transform:scale(.94)}
+.fic{width:15px;height:15px;display:block;margin:auto}
+.fab.pen{color:var(--acc-deep)}
+.fab.disk{background:var(--acc);border-color:var(--acc);color:#fff}
+.fab.xbtn{color:var(--ink-3)}
+/* 笔:这张卡当下这一面、且这张卡没在编辑 —— 各卡各开,互不联动 */
+html.editable .dossier:not(.on):not(:has(.pback.on)):not(:has(.flip-tg:checked)) .pen-f{display:grid}
+html.editable .dossier:not(.on):not(:has(.pback.on)):has(.flip-tg:checked) .pen-b{display:grid}
+.dossier.on .disk-f{display:grid}
+.dossier.on .x-f{display:grid}
+.dossier:has(.pback.on) .disk-b{display:grid}
+.dossier:has(.pback.on) .x-b{display:grid}
+
+/* ── 卡背:参数瓷贴 ── */
+.pb-hd{display:flex;align-items:baseline;gap:9px;flex-wrap:wrap}
+.pb-hd b{font-size:14px;font-weight:800;color:var(--ink)}
+.pb-lb{font-size:10.5px;font-weight:800;letter-spacing:.08em;color:var(--ink-4)}
+.pback{display:grid;grid-template-columns:1fr 1fr;gap:8px}
+.ptile{display:flex;flex-direction:column;gap:2px;border:1px solid var(--line-soft);border-radius:10px;background:var(--soft);padding:8px 10px;min-width:0}
+.pt-hd{display:flex;align-items:baseline;gap:6px;min-width:0}
+.pt-hd .jc-vcell{font-size:11px;font-weight:800;color:var(--ink-3)}
+.pt-unit{font-style:normal;font-size:10px;color:var(--ink-4);font-family:var(--mono)}
+.pt-val .jc-vcell{font-size:14px;font-weight:800;color:var(--ink)}
+.pt-note .jc-vcell{font-size:10.5px;color:var(--ink-3)}
+/* 三级占位:值必填红 / 说明建议橘 */
+.ptile .pv .jc-vcell:empty::after{content:"必填";font-size:10.5px;font-weight:800;color:var(--danger);background:var(--danger-soft);border-radius:999px;padding:0 9px}
+/* 说明空着**什么都不摆**(2026-08-31 用户:「没写就什么都不要展示」)—— 连兜底破折号一起收 */
+.ptile .sg .jc-vcell:empty{display:none}
+/* 参数编辑态:值与说明换输入,参数名照旧当标签摆着;两枚主键孪生件藏死(钥匙不是编辑面)。
+   藏钥匙用包装类(.pt-name / .rowkey),不用「data-col 属性选择器」—— 那段选择器文本会原样
+   出现在共享样式表里,把「落账确认全只读」那类字面断言踩翻(2026-08-31 踩过,连注释也不许写)。 */
+.pback.on .pv > .jc-vcell,.pback.on .sg > .jc-vcell{display:none}
+.pback.on .pv > .jc-cell,.pback.on .sg > .jc-cell{display:block}
+.pback .pt-name .jc-cell{display:none}
+.pt-name{display:inline-flex;min-width:0}
+
+/* ================= 比对基准卡(类型 + 字段合一,只读、跟手)================= */
+.basis{display:block;margin:0 0 10px}
+.basis:empty{border:1.5px dashed var(--line);border-radius:12px;padding:16px;display:block}
+.basis:empty::after{content:"还没定比对基准 —— 先在上面任一张档案卡上挑一个芯片类型,或展开下面的抽屉新建一个。";font-size:12.5px;color:var(--ink-3)}
+.basis-in{display:flex;flex-direction:column;gap:10px;border:1px solid var(--acc-line);border-radius:12px;background:var(--acc-wash);padding:12px 14px 14px}
+.basis-hd{display:flex;align-items:center;gap:12px;flex-wrap:wrap}
+.basis-lb{flex:none;font-size:10.5px;font-weight:800;letter-spacing:.08em;color:var(--acc-deep)}
+.basis-chip b{display:inline-block;font-size:13px;font-weight:800;color:#fff;background:var(--acc);border-radius:999px;padding:2px 14px;margin-right:8px}
+.basis-desc{font-style:normal;font-size:11.5px;color:var(--ink-3)}
+.basis-hd:has(.basis-chip:empty)::after{content:"待选择";font-size:11px;font-weight:700;color:var(--amber);background:var(--amber-soft);border:1px dashed #eeda9e;border-radius:999px;padding:1px 10px}
+.basis-hd .csvg{width:56px;flex:none}
+/* 类型图:层叠双封装 —— 后面那枚是「同类的别的芯片」,淡出成剪影 */
+.basis-hd .tsvg{width:60px;flex:none}
+.tsvg{display:block}
+.t-ghost{opacity:.32}
+.basis-id{display:flex;flex-direction:column;gap:5px;min-width:0;flex:1 1 auto}
+.basis-in:has(.ftiles:empty) .ftiles{display:none}
+/* 降噪(2026-08-31 用户:「乱糟糟…没必要显示全就不要显示完全,鼠标指上去后再显示」):
+   字段收成一排丸(名 + 硬/软徽 + 单位),说明藏进悬浮气泡 —— 指上去才现身 */
+.ftiles{display:flex;flex-wrap:wrap;gap:8px}
+.ftile{position:relative;display:flex;flex-direction:row;align-items:center;gap:7px;border:1px solid var(--line-soft);border-radius:999px;background:#fff;padding:6px 13px;min-width:0;transition:border-color .16s,box-shadow .16s}
+.ftile:hover{border-color:var(--acc-line);box-shadow:0 4px 12px rgba(18,38,63,.1)}
+.ft-hd{display:flex;align-items:baseline;gap:7px;white-space:nowrap}
+.ft-hd b{font-size:12px;font-weight:800;color:var(--ink)}
+.ft-unit{font-style:normal;font-size:10px;color:var(--ink-4);font-family:var(--mono)}
+.ft-desc{display:none;position:absolute;z-index:6;top:calc(100% + 7px);left:0;width:max-content;max-width:280px;margin:0;font-size:11px;line-height:1.65;color:var(--ink-2);background:#fff;border:1px solid var(--line);border-radius:9px;padding:8px 11px;box-shadow:0 10px 24px rgba(18,38,63,.16)}
+.ftile:hover .ft-desc:not(:empty){display:block}
+/* 类型说明:默认一行截断,悬浮题头才放开 */
+.basis-desc{display:block;max-width:100%;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.basis-hd:hover .basis-desc{white-space:normal}
+
+/* ================= 新建类型工作抽屉(details,零脚本)================= */
+.lab{margin:0 0 6px;border:1.5px dashed var(--line);border-radius:12px;background:var(--soft)}
+.lab[open]{border-style:solid;background:#fff}
+.lab-sm{cursor:pointer;list-style:none;display:flex;align-items:center;gap:8px;padding:11px 14px;font-size:12.5px;color:var(--ink-3);user-select:none}
+.lab-sm::-webkit-details-marker{display:none}
+.lab-sm b{color:var(--ink-2)}
+.lab-sm:hover{color:var(--acc-deep)}
+.lab-caret{margin-left:auto;flex:none;width:8px;height:8px;border-right:2px solid var(--ink-4);border-bottom:2px solid var(--ink-4);transform:rotate(45deg);transition:transform .16s}
+.lab[open] .lab-caret{transform:rotate(-135deg)}
+.lab-bd{padding:2px 14px 14px}
+.lab-brief{margin:0 0 16px}
+.lab-brief .brief{margin:2px 14px 14px;border-left-width:3px}
+
+/* ================= 窄屏 ================= */
+@media(max-width:620px){
+  .card-head{padding:16px 14px 18px}
+  .dz-grid{grid-template-columns:1fr}
+  .swapfx{display:none}
+  .dossiers{grid-template-columns:1fr}
+  .dossiers > .dossier:nth-of-type(odd),.dossiers > .dossier:nth-of-type(even){grid-column:1}
+  .pback{grid-template-columns:1fr}
+  .ftiles{grid-template-columns:1fr}
+  .card-bd{padding:16px 14px 6px}
+  .hero-title{font-size:19.5px}
+  .stage{gap:14px}
+  .hchip{min-width:108px;padding:10px 8px 9px}
+  .csvg{width:68px}
+  .kv i{flex-basis:72px}
+  .card-foot{padding:10px 14px}
+}
+`;

activities/part-substitution-assessment/src/views/target-style.ts

@@ -1,365 +0,0 @@
-/**
- * ACT-WORK-05 差异评估的目标件样式表 —— **机械抽取,一个数值都不许改**
- * (《HTML报告生成规范》§7:有目标件时「搬」,不要「照着做」;样式表整段搬,标记逐块搬)。
- *
- * 来源:
- *   · `P08_CSS`  ← `docs/ss02-act-05-new/ACT-WORK-05-数据工单-PN主数据创建.html` 的
- *     整段 `<style>`(**2026-08-30 换版面**:用户给了新目标件,`input-supplement`
- *     整张照它重排 —— 步骤轨道 `.steps`/`.stepbox`、档案卡 `.idcard`、参数瓷贴
- *     `.pvgrid`/`.pv`、新增类型面板 `.newtype`。旧来源
- *     `docs/SS02-ACT-WORK-05-html/ACT-WORK-05-数据工单-01-芯片主数据创建.html`
- *     的两段 `<style>` 随之整段退役 —— 那一版带的 `.jc-vcell`/`.jc-cell` 孪生件
- *     显隐规则不在新目标件里,平台绑定所需的那部分改由 `report.ts` 的 `BIND_*`
- *     承载,见那边「编辑机制」一节);抽取与源文件 `<style>` 区间 diff 零差异;
- *   · `ACC1_CSS` ← `ACT-WORK-05-验收工单-01-差异评估结论审核.html` 的 `<style>`;
- *   · `ACC2_CSS` ← `ACT-WORK-05-验收工单-02-评审放行与落账确认.html` 的 `<style>`。
- *
- * `EXEC_CSS`(执行工单-01 的样式)已随 Task 7 删除:它原来专属的 `eval-input-list`
- * 局面已并入 `input-supplement`(改用 `P08_CSS`),此后再没有消费方 —— target-style.ts
- * 只留「没有消费方就删」这条规矩下**还有人用**的常量,ACC1_CSS / ACC2_CSS 虽然此刻
- * 也没有工单件在用,但被 `activity.test.ts`「两张验收件的主题色」那条测试直接导入校验
- * (Task 8 / 9 会把它们重新接回 `difference-review` / `landing-confirm`),留着。
- *
- * `p10-document-create`(P-10 原厂技术资料创建)原来**没有自己的目标件**、复用 `P08_CSS` ——
- * Task 7 重写后 P-10 不再是这个活动的数据工单范围(本活动不碰 P-10),这句历史说明留作背景。
- *
- * 抽取用 `sed -n` 按行号截取 `<style>`/`</style>` 之间的原文,再拿抽出来的内容与
- * 源文件同一行区间做 `diff` 验「零差异」(ACC1/ACC2 的过程在 task-5-report.md;
- * P08 新版 2026-08-30 换版面时同法重验)。
- *
- * 这份文件只装**目标件自己的样式**,不装平台绑定用的开关(三态占位、缺项红带、
- * `data-class-of` 的 `v-*` 别名这类)——那些是本活动自己加出来的东西,活在
- * `report.ts` 的 `BIND_*` 常量里,两处不要混。
- */
-
-export const P08_CSS = `
-:root{
-  --ink:#1f2329; --ink-2:#41464e; --ink-3:#646a73; --ink-4:#8f959e;
-  --line:#dee0e3; --line-soft:#e8eaed; --soft:#f8f9fb;
-  --brand:#3370ff; --brand-deep:#245bdb;
-  --data:#3370ff; --data-deep:#245bdb; --data-soft:#e1eaff; --data-line:#c3d6ff; --data-wash:#f0f4ff;
-  --ok:#278717; --ok-soft:#e8f8e4; --danger:#d83931; --danger-soft:#feeae9;
-  --amber:#8f6a12; --amber-soft:#fdf3d7; --amber-line:#ecd9a0;
-  --mono:"SF Mono",Menlo,Consolas,monospace;
-  /* 8px 间距节奏（dense） */
-  --s1:8px; --s2:16px; --s3:24px; --s4:32px;
-  --r-sm:8px; --r-md:12px;
-  --tr:.22s cubic-bezier(.2,.7,.3,1);
-}
-*{box-sizing:border-box}
-html,body{margin:0;padding:0}
-body{font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI","PingFang SC","Microsoft YaHei",sans-serif;background:#fff;color:var(--ink);font-size:14px;line-height:1.7;-webkit-font-smoothing:antialiased}
-.page{margin:0;padding:0}
-.card{background:#fff;overflow:hidden;border:0;border-radius:0;box-shadow:none}
-
-/* ===== 卡头 ===== */
-.card-head{display:flex;align-items:center;gap:14px;padding:20px 24px;border-bottom:1px solid var(--line-soft);background:linear-gradient(120deg,#f0f4ff 0%,#fff 55%,#eef3ff 100%)}
-.badge{flex:none;width:44px;height:44px;border-radius:11px;display:grid;place-items:center;background:var(--data);color:#fff;font-weight:800;font-size:13px;box-shadow:0 6px 16px rgba(51,112,255,.28)}
-.tit{flex:1;min-width:0}
-.tit .kick{font-size:11px;letter-spacing:.08em;color:var(--ink-4);font-weight:700}
-.tit h1{margin:2px 0 0;font-size:20px;font-weight:800;line-height:1.3;letter-spacing:-.01em}
-.tit .sub{font-size:12px;color:var(--ink-3);margin-top:3px}
-.side{display:flex;flex-direction:column;align-items:flex-end;gap:6px;flex:none}
-.tag{font-size:11px;font-weight:800;padding:2px 10px;border-radius:999px;color:var(--data-deep);background:var(--data-soft);border:1px solid var(--data-line)}
-.step{font-size:12px;color:var(--ink-3)}
-.deadline{font-size:12px;color:var(--ink-3)}
-.deadline b{color:var(--danger)}
-.card-bd{padding:var(--s3) 24px var(--s4)}
-
-/* ===== 区标 / 说明带 ===== */
-.zone{font-size:11px;font-weight:800;letter-spacing:.12em;color:var(--ink-4);margin:0 0 var(--s1)}
-.zone b{color:var(--ink-3)}
-.note{border:1px solid var(--line);border-left:3px solid var(--data);border-radius:var(--r-sm);background:var(--soft);padding:14px 16px;margin-bottom:var(--s2)}
-.note p{margin:0;font-size:13px;color:var(--ink-2)}
-.note p+p{margin-top:6px}
-.note b{color:var(--ink)}
-.note .need{color:var(--data-deep);font-weight:700}
-.mono{font-family:var(--mono);font-size:12px;color:var(--ink-2)}
-.st{display:inline-block;font-size:11px;font-weight:700;padding:1px 8px;border-radius:999px;border:1px solid transparent;white-space:nowrap}
-.st.ok{color:var(--ok);background:var(--ok-soft);border-color:#c9ecc2}
-.st.new{color:var(--data-deep);background:var(--data-soft);border-color:var(--data-line)}
-.st.lock{color:var(--ink-3);background:#eef1f6;border-color:var(--line)}
-
-/* ===== 编辑闸 + 必填进度 ===== */
-.jc-editgate{display:flex;align-items:center;gap:10px;flex-wrap:wrap;margin:0 0 var(--s2);padding:10px 14px;border-radius:10px;background:var(--soft);border:1px solid var(--line-soft);font-size:12px;color:var(--ink-3);transition:background var(--tr),border-color var(--tr)}
-.jc-editgate-t{flex:1 1 auto;min-width:0}
-.jc-editgate-t b{color:var(--ink-2);font-weight:700}
-.gateprog{flex:1 1 100%;display:flex;align-items:center;gap:10px;margin-top:6px}
-.gateprog .track{flex:1;height:5px;border-radius:3px;background:var(--line-soft);overflow:hidden}
-.gateprog .fill{display:block;height:100%;width:0;border-radius:3px;background:linear-gradient(90deg,var(--data),var(--data-deep));transition:width .35s cubic-bezier(.2,.7,.3,1)}
-.gateprog .pct{font-family:var(--mono);font-size:11px;color:var(--ink-4);min-width:64px;text-align:right}
-.jc-egbtn{flex:none;display:inline-flex;align-items:center;gap:5px;cursor:pointer;border:1px solid var(--line);border-radius:8px;padding:7px 14px;font:inherit;font-size:12px;font-weight:700;color:var(--ink-2);background:#fff;transition:border-color var(--tr),color var(--tr),background var(--tr),transform .12s}
-.jc-egbtn:hover{border-color:var(--data);color:var(--data)}
-.jc-egbtn:active{transform:scale(.97)}
-.jc-egbtn.save{color:#fff;background:var(--data);border-color:var(--data)}
-.jc-egbtn.save:hover{filter:brightness(1.06);color:#fff}
-.jc-egbtn:focus-visible{outline:2px solid var(--data-deep);outline-offset:2px}
-.jc-editgate .eg-cancel,.jc-editgate .eg-save{display:none}
-.jc-editgate.on{background:var(--data-wash);border-color:var(--data-line);color:#1e40af}
-.jc-editgate.on .eg-open{display:none}
-.jc-editgate.on .eg-cancel,.jc-editgate.on .eg-save{display:inline-flex}
-
-/* ===== 渲染态：档案卡 ===== */
-.idcard{border:1px solid var(--line-soft);border-radius:var(--r-md);margin-bottom:var(--s2);background:linear-gradient(150deg,#fff 60%,var(--data-wash));display:grid;grid-template-columns:1.2fr 1fr;overflow:hidden}
-.idcard .cell{padding:18px 22px}
-.idcard .cell+.cell{border-left:1px solid var(--line-soft);background:rgba(255,255,255,.55)}
-.idcard .lab{font-size:11.5px;font-weight:800;color:var(--ink-3);letter-spacing:.08em;display:flex;align-items:center;gap:6px}
-.idcard .lab::before{content:"";width:8px;height:8px;border-radius:2.5px;background:var(--data)}
-.idcard .val{margin-top:8px;font-size:24px;font-weight:800;font-family:var(--mono);letter-spacing:-.01em;line-height:1.25;color:var(--ink)}
-.idcard .val.empty{font-size:14px;font-family:inherit;font-weight:400;color:var(--ink-4)}
-.idcard .val .tpill{display:inline-block;font-family:inherit;font-size:15px;font-weight:800;color:var(--data-deep);background:var(--data-soft);border:1px solid var(--data-line);border-radius:999px;padding:4px 14px;vertical-align:2px}
-.idcard .val .st{margin-left:8px;vertical-align:3px}
-
-/* ===== 参数表（渲染态） ===== */
-.tbl-wrap{border:1px solid var(--line-soft);border-radius:10px;overflow:hidden}
-table{width:100%;border-collapse:collapse;font-size:12.5px}
-th{text-align:left;background:var(--soft);font-size:11px;letter-spacing:.04em;font-weight:800;color:var(--ink-3);padding:10px 14px;border-bottom:1px solid var(--line)}
-td{padding:10px 14px;border-bottom:1px solid var(--line-soft);vertical-align:middle}
-tr:last-child td{border-bottom:0}
-tbody tr{transition:background .15s}
-tbody tr:hover{background:var(--data-wash)}
-.empty-row td{color:var(--ink-4);text-align:center;padding:22px}
-.empty-row td:hover{background:#fff}
-
-/* ===== 编辑态：步骤轨道 ===== */
-.editarea{display:none}
-body.editing .editarea{display:block}
-body.editing .viewarea{display:none}
-.steps{position:relative}
-.steps::before{content:"";position:absolute;left:12px;top:20px;bottom:20px;width:2px;background:var(--line-soft);border-radius:1px}
-.stepbox{position:relative;padding-left:36px;margin-bottom:var(--s3)}
-.stepbox:last-child{margin-bottom:0}
-.sdot{position:absolute;left:0;top:0;width:26px;height:26px;border-radius:50%;background:#fff;border:2px solid var(--data-line);color:var(--data-deep);font-size:12px;font-weight:800;display:grid;place-items:center;transition:background var(--tr),border-color var(--tr),color var(--tr)}
-.stepbox.done .sdot{background:var(--data);border-color:var(--data);color:#fff}
-.scard{border:1px solid var(--line-soft);border-radius:var(--r-md);background:#fff;transition:border-color var(--tr),box-shadow var(--tr)}
-.stepbox.done .scard{border-color:var(--data-line)}
-.scard .sh{display:flex;align-items:center;gap:10px;padding:12px 16px;border-bottom:1px solid var(--line-soft);font-size:13.5px;font-weight:800;letter-spacing:-.01em}
-.scard .sh .req-note{margin-left:auto;font-size:11px;color:var(--ink-4);font-weight:400}
-.scard .sb{padding:16px}
-.fld{display:flex;align-items:flex-start;gap:12px;font-size:12.5px}
-.fld .fk{width:88px;flex:none;color:var(--ink-3);font-weight:700;font-size:12px;padding-top:9px}
-.fld .fk.req::after{content:" ＊";color:var(--danger)}
-.fld .fv{flex:1;min-width:0}
-.fld input,.fld select{width:100%;border:1px solid var(--line);border-radius:var(--r-sm);padding:9px 11px;font:inherit;font-size:13px;color:var(--ink);background:#fff;transition:border-color var(--tr),box-shadow var(--tr)}
-.fld input:focus,.fld select:focus{border-color:var(--data);box-shadow:0 0 0 3px var(--data-wash);outline:none}
-.hint{font-size:11.5px;color:var(--ink-4);margin-top:6px}
-
-/* ===== 新增类型面板 ===== */
-.newtype{display:none;margin-top:12px;border:1px dashed var(--data-line);border-radius:10px;background:var(--data-wash);padding:14px 16px}
-.newtype.show{display:block;animation:rise .25s cubic-bezier(.2,.7,.3,1)}
-@keyframes rise{from{opacity:0;transform:translateY(6px)}to{opacity:1;transform:none}}
-.newtype h4{margin:0 0 10px;font-size:12.5px;color:var(--data-deep)}
-.prow{display:flex;gap:8px;align-items:center;margin-top:8px;animation:rise .2s cubic-bezier(.2,.7,.3,1)}
-.prow input{flex:1;border:1px solid var(--line);border-radius:7px;padding:8px 10px;font:inherit;font-size:12.5px;background:#fff;transition:border-color var(--tr),box-shadow var(--tr)}
-.prow input:focus{border-color:var(--data);box-shadow:0 0 0 3px rgba(51,112,255,.12);outline:none}
-.prow .del{flex:none;width:28px;height:28px;cursor:pointer;border:1px solid var(--line);border-radius:7px;background:#fff;color:var(--ink-3);font-size:14px;line-height:1;transition:border-color var(--tr),color var(--tr),background var(--tr)}
-.prow .del:hover{border-color:var(--danger);color:var(--danger);background:var(--danger-soft)}
-.nt-actions{display:flex;gap:8px;margin-top:12px;align-items:center}
-.btn{cursor:pointer;border:1px solid var(--data-line);border-radius:8px;padding:7px 14px;font:inherit;font-size:12px;font-weight:700;color:var(--data-deep);background:#fff;transition:background var(--tr),transform .12s}
-.btn:hover{background:var(--data-soft)}
-.btn:active{transform:scale(.97)}
-.btn.primary{color:#fff;background:var(--data);border-color:var(--data)}
-.btn.primary:hover{filter:brightness(1.07)}
-.btn:focus-visible{outline:2px solid var(--data-deep);outline-offset:2px}
-
-/* ===== 参数值瓷贴 ===== */
-.pvgrid{display:grid;grid-template-columns:repeat(2,1fr);gap:10px}
-.pv{border:1px solid var(--line-soft);border-radius:10px;padding:10px 12px;background:#fff;transition:border-color var(--tr),box-shadow var(--tr)}
-.pv:focus-within{border-color:var(--data-line);box-shadow:0 0 0 3px rgba(51,112,255,.08)}
-.pv .pn2{font-size:12px;font-weight:800;color:var(--ink-2);margin-bottom:6px;display:flex;align-items:baseline;gap:6px}
-.pv .pn2::after{content:"＊";color:var(--danger);font-size:11px}
-.pv input{width:100%;border:1px solid var(--line);border-radius:7px;padding:7px 10px;font:inherit;font-size:12.5px;background:#fff;transition:border-color var(--tr),box-shadow var(--tr)}
-.pv input:focus{border-color:var(--data);box-shadow:0 0 0 3px rgba(51,112,255,.12);outline:none}
-.pv-empty{border:1px dashed var(--line);border-radius:10px;padding:20px;text-align:center;color:var(--ink-4);font-size:12px}
-
-/* ===== 底 ===== */
-.flow{margin-top:var(--s2);padding:10px 14px;border-radius:var(--r-sm);background:var(--soft);border:1px dashed var(--line);font-size:12px;color:var(--ink-3)}
-.flow b{color:var(--ink)}
-.card-foot{padding:14px 24px;border-top:1px solid var(--line-soft);font-size:11.5px;color:var(--ink-4);display:flex;justify-content:space-between;flex-wrap:wrap;gap:8px}
-@media(max-width:760px){.pvgrid{grid-template-columns:1fr}.card-head{flex-wrap:wrap}.side{align-items:flex-start}.idcard{grid-template-columns:1fr}.idcard .cell+.cell{border-left:0;border-top:1px solid var(--line-soft)}}
-@media(prefers-reduced-motion:reduce){*{animation:none!important;transition:none!important}}
-`;
-
-/*
- * 两张验收件(ACC1 差异评估结论审核 / ACC2 评审放行与落账确认)的主题色**不再逐字节等于目标件**:
- * 目标件的题头用 #b23a2e 红(--ledger),2026-08-27 用户定「中央 HTML 模版区域如果是验收工单,
- * 标题部分的红色改为和验收卡一样的绿色」—— 与对话区验收卡同一枚 #0aa294(app.css --st-collab)。
- * 只换主题变量与题头渐变 / 徽章投影;ACC2 的 CONDITIONAL 状态徽标是语义色,保留原红。
- * ACC1 于 2026-08-27 下午随目标件改版整段重搬(「一个候选一张表」:.cand* / .rec* / .stat*,CONDITIONAL 改蓝),
- * 主题色仍取卡的那一枚绿。
- */
-export const ACC1_CSS = `
-:root{
-  --ink:#1f2329; --ink-2:#41464e; --ink-3:#646a73; --ink-4:#8f959e;
-  --line:#dee0e3; --line-soft:#e8eaed; --soft:#f8f9fb;
-  --brand:#3370ff; --brand-deep:#245bdb; --brand-soft:#e1eaff; --brand-wash:#f0f4ff;
-  --ledger:#0aa294; --ledger-soft:#e4f8f5; --ledger-line:#b5e6df; /* 验收绿(2026-08-27 用户定:与对话区验收卡同色;目标件 2026-08-27 改版写的是 #16a34a,这里取卡的那一枚) */
-  --ok:#278717; --ok-soft:#e8f8e4; --danger:#d83931; --danger-soft:#feeae9;
-  --amber:#8f6a12; --amber-soft:#fdf3d7; --amber-line:#ecd9a0;
-  --mono:"SF Mono",Menlo,Consolas,monospace;
-}
-*{box-sizing:border-box}
-html,body{margin:0;padding:0}
-body{font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI","PingFang SC","Microsoft YaHei",sans-serif;background:#eef1f6;color:var(--ink);font-size:14px;line-height:1.7;-webkit-font-smoothing:antialiased}
-.page{margin:0;padding:0}
-.card{background:#fff;overflow:hidden;border:0;border-radius:0;box-shadow:none}
-.card-head{display:flex;align-items:center;gap:14px;padding:18px 22px;border-bottom:2px solid var(--ink);background:linear-gradient(120deg,#eefaf8 0%,#fff 55%,#ecf8f5 100%)}
-.badge{flex:none;width:44px;height:44px;border-radius:10px;display:grid;place-items:center;background:var(--ledger);color:#fff;font-weight:800;font-size:13px;box-shadow:0 6px 16px rgba(10,162,148,.25)}
-.tit{flex:1;min-width:0}
-.tit .kick{font-size:11px;letter-spacing:.08em;color:var(--ink-4);font-weight:700}
-.tit h1{margin:2px 0 0;font-size:19px;font-weight:800;line-height:1.3}
-.tit .sub{font-size:12px;color:var(--ink-3);margin-top:3px}
-.side{display:flex;flex-direction:column;align-items:flex-end;gap:6px;flex:none}
-.tag{font-size:11px;font-weight:800;padding:2px 10px;border-radius:999px;color:var(--ledger);background:var(--ledger-soft);border:1px solid var(--ledger-line)}
-.step{font-size:12px;color:var(--ink-3)}
-.deadline{font-size:12px;color:var(--ink-3)}
-.deadline b{color:var(--danger)}
-.card-bd{padding:20px 22px}
-.zone{font-size:11px;font-weight:800;letter-spacing:.12em;color:var(--ink-4);margin:0 0 8px}
-.zone b{color:var(--ink-3)}
-.note{border:1px solid var(--line);border-left:3px solid var(--ledger);border-radius:8px;background:var(--soft);padding:14px 16px;margin-bottom:16px}
-.note p{margin:0;font-size:13px;color:var(--ink-2)}
-.note b{color:var(--ink)}
-/*
- * 补三条:report.ts 的 zone()/note() 助手把 P08 目标件「视觉补充段 v3」的图标
- * (.zic)与强调色(.note .done / .note .need)跨文档复用到了这两张验收件的
- * 区块头与提示文案上(见 report.ts 的 ZIC_TASK / ZIC_TABLE 常量与 note() 调用处)——
- * 原验收工单目标件自己的 style 段从未定义过它们(核对过
- * docs/SS02-ACT-WORK-05-html/ 下两份验收工单目标件,原型的 zone 段从没带过图标,
- * note 里也没有 done/need 分级)——补两条,值照 P08_CSS 抄
- * (2026-08-30 task-12,缺陷③;--data 这份 :root 没有,用同色的 --brand 顶替,
- * 数值仍是 #3370ff,不算改动目标件写死的颜色)。
- * 漏掉 .zic 的后果曾经是灾难性的:三枚 viewBox="0 0 24 24" 的图标在没有 .zic 约束
- * 宽高时会撑满容器宽、再按比例撑高,量出来是 946×946 像素、把整份文档撑到 4625px 高,
- * 正文全被挤出可视区(人打开只看见三块灰色巨块加大片空白)。
- */
-.zic{width:14px;height:14px;color:var(--ink-3);vertical-align:-2px;margin-right:3px}
-.note .done{color:var(--ok);font-weight:700}
-.note .need{color:var(--brand);font-weight:700}
-.criteria{border:1px solid var(--ledger-line);border-radius:10px;background:var(--ledger-soft);padding:13px 16px;margin-bottom:18px}
-.criteria .c-title{font-size:11px;font-weight:800;letter-spacing:.08em;color:var(--ledger);margin-bottom:7px}
-.criteria ul{margin:0;padding-left:18px;font-size:12.5px;color:var(--ink-2)}
-.criteria li{margin:4px 0}
-.criteria b{color:var(--ink)}
-.tbl-wrap{border:1px solid var(--line-soft);border-radius:10px;overflow:hidden}
-table{width:100%;border-collapse:collapse;font-size:13px}
-th{text-align:left;background:var(--soft);font-size:11px;letter-spacing:.05em;font-weight:800;color:var(--ink-3);padding:9px 12px;border-bottom:1px solid var(--line)}
-td{padding:11px 12px;border-bottom:1px solid var(--line-soft);vertical-align:top}
-tr:last-child td{border-bottom:0}
-.cand .tbl-wrap{border:0;border-radius:0}
-.num{font-family:var(--mono);color:var(--ink-4);white-space:nowrap}
-.cust{font-weight:700}
-.reason{font-size:12.5px;color:var(--ink-2)}
-.flow{margin-top:16px;padding:9px 12px;border-radius:8px;background:var(--soft);border:1px dashed var(--line);font-size:12px;color:var(--ink-3)}
-.flow b{color:var(--ink)}
-.card-foot{padding:13px 22px;border-top:1px solid var(--line-soft);font-size:11.5px;color:var(--ink-4);display:flex;justify-content:space-between;flex-wrap:wrap;gap:8px}
-@media(max-width:600px){.card-head{flex-wrap:wrap}.side{align-items:flex-start}}
-/* 四态结论 pill 与风险等级 */
-.st{display:inline-block;padding:1px 9px;border-radius:999px;font-size:11px;font-weight:800;letter-spacing:.04em;font-family:var(--mono);white-space:nowrap;border:1px solid transparent}
-.st.ok{color:var(--ok);background:var(--ok-soft);border-color:#bfe6b4}
-.st.miss{color:var(--danger);background:#feeae9;border-color:#f3b9b5}
-.st.unknown{color:var(--amber);background:var(--amber-soft);border-color:var(--amber-line)}
-.st.cond{color:var(--brand-deep);background:var(--brand-wash);border-color:var(--brand-soft)}
-.risk{font-weight:800;font-size:12.5px}
-.risk.low{color:var(--ok)}
-.risk.mid{color:var(--amber)}
-.risk.hi{color:var(--danger)}
-.mono{font-family:var(--mono);font-size:12px;color:var(--ink-2)}
-/* 推荐程度 pill */
-.rec{display:inline-block;padding:2px 11px;border-radius:999px;font-size:11.5px;font-weight:800;white-space:nowrap;border:1px solid transparent}
-.rec.yes{color:var(--ok);background:var(--ok-soft);border-color:#bfe6b4}
-.rec.cond{color:var(--amber);background:var(--amber-soft);border-color:var(--amber-line)}
-.rec.no{color:var(--danger);background:#feeae9;border-color:#f3b9b5}
-/* 差异统计（结论表内） */
-.stat{font-family:var(--mono);font-size:11.5px;color:var(--ink-3);white-space:nowrap}
-.stat b{font-weight:800}
-.stat .m{color:var(--ok)} .stat .x{color:var(--danger)} .stat .u{color:var(--amber)} .stat .c{color:var(--brand-deep)}
-/* 候选 PN 明细块：一个候选一张表 */
-.cand{border:1px solid var(--line-soft);border-radius:10px;overflow:hidden;margin-bottom:16px}
-.cand:last-of-type{margin-bottom:0}
-.cand-head{display:flex;align-items:center;gap:10px;padding:11px 14px;background:linear-gradient(120deg,#f6f8fc 0%,#fff 70%);border-bottom:1px solid var(--line);flex-wrap:wrap}
-.cand-idx{flex:none;width:22px;height:22px;border-radius:6px;display:grid;place-items:center;background:var(--ink);color:#fff;font-size:11px;font-weight:800;font-family:var(--mono)}
-.cand-name{font-weight:800;font-size:14px}
-.cand-brand{color:var(--ink-3);font-size:12px}
-.cand-vs{font-family:var(--mono);font-size:11.5px;color:var(--ink-4)}
-.cand-con{margin-left:auto;display:flex;align-items:center;gap:8px}
-`;
-
-export const ACC2_CSS = `
-:root{
-  --ink:#1f2329; --ink-2:#41464e; --ink-3:#646a73; --ink-4:#8f959e;
-  --line:#dee0e3; --line-soft:#e8eaed; --soft:#f8f9fb;
-  --brand:#3370ff; --brand-deep:#245bdb; --brand-soft:#e1eaff; --brand-wash:#f0f4ff;
-  --ledger:#0aa294; --ledger-soft:#e4f8f5; --ledger-line:#b5e6df; /* 验收绿(2026-08-27 用户定:与对话区验收卡同色,原目标件是 #b23a2e 红) */
-  --ok:#278717; --ok-soft:#e8f8e4; --danger:#d83931; --danger-soft:#feeae9;
-  --mono:"SF Mono",Menlo,Consolas,monospace;
-}
-*{box-sizing:border-box}
-html,body{margin:0;padding:0}
-body{font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI","PingFang SC","Microsoft YaHei",sans-serif;background:#eef1f6;color:var(--ink);font-size:14px;line-height:1.7;-webkit-font-smoothing:antialiased}
-.page{margin:0;padding:0}
-.card{background:#fff;overflow:hidden;border:0;border-radius:0;box-shadow:none}
-.card-head{display:flex;align-items:center;gap:14px;padding:18px 22px;border-bottom:2px solid var(--ink);background:linear-gradient(120deg,#eefaf8 0%,#fff 55%,#ecf8f5 100%)}
-.badge{flex:none;width:44px;height:44px;border-radius:10px;display:grid;place-items:center;background:var(--ledger);color:#fff;font-weight:800;font-size:13px;box-shadow:0 6px 16px rgba(10,162,148,.25)}
-.tit{flex:1;min-width:0}
-.tit .kick{font-size:11px;letter-spacing:.08em;color:var(--ink-4);font-weight:700}
-.tit h1{margin:2px 0 0;font-size:19px;font-weight:800;line-height:1.3}
-.tit .sub{font-size:12px;color:var(--ink-3);margin-top:3px}
-.side{display:flex;flex-direction:column;align-items:flex-end;gap:6px;flex:none}
-.tag{font-size:11px;font-weight:800;padding:2px 10px;border-radius:999px;color:var(--ledger);background:var(--ledger-soft);border:1px solid var(--ledger-line)}
-.step{font-size:12px;color:var(--ink-3)}
-.deadline{font-size:12px;color:var(--ink-3)}
-.deadline b{color:var(--danger)}
-.card-bd{padding:20px 22px}
-.zone{font-size:11px;font-weight:800;letter-spacing:.12em;color:var(--ink-4);margin:0 0 8px}
-.zone b{color:var(--ink-3)}
-.note{border:1px solid var(--line);border-left:3px solid var(--ledger);border-radius:8px;background:var(--soft);padding:14px 16px;margin-bottom:16px}
-.note p{margin:0;font-size:13px;color:var(--ink-2)}
-.note b{color:var(--ink)}
-/*
- * 补三条:report.ts 的 zone()/note() 助手把 P08 目标件「视觉补充段 v3」的图标
- * (.zic)与强调色(.note .done / .note .need)跨文档复用到了这两张验收件的
- * 区块头与提示文案上(见 report.ts 的 ZIC_TASK / ZIC_TABLE 常量与 note() 调用处)——
- * 原验收工单目标件自己的 style 段从未定义过它们(核对过
- * docs/SS02-ACT-WORK-05-html/ 下两份验收工单目标件,原型的 zone 段从没带过图标,
- * note 里也没有 done/need 分级)——补两条,值照 P08_CSS 抄
- * (2026-08-30 task-12,缺陷③;--data 这份 :root 没有,用同色的 --brand 顶替,
- * 数值仍是 #3370ff,不算改动目标件写死的颜色)。
- * 漏掉 .zic 的后果曾经是灾难性的:三枚 viewBox="0 0 24 24" 的图标在没有 .zic 约束
- * 宽高时会撑满容器宽、再按比例撑高,量出来是 946×946 像素、把整份文档撑到 4625px 高,
- * 正文全被挤出可视区(人打开只看见三块灰色巨块加大片空白)。
- */
-.zic{width:14px;height:14px;color:var(--ink-3);vertical-align:-2px;margin-right:3px}
-.note .done{color:var(--ok);font-weight:700}
-.note .need{color:var(--brand);font-weight:700}
-.criteria{border:1px solid var(--ledger-line);border-radius:10px;background:var(--ledger-soft);padding:13px 16px;margin-bottom:18px}
-.criteria .c-title{font-size:11px;font-weight:800;letter-spacing:.08em;color:var(--ledger);margin-bottom:7px}
-.criteria ul{margin:0;padding-left:18px;font-size:12.5px;color:var(--ink-2)}
-.criteria li{margin:4px 0}
-.criteria b{color:var(--ink)}
-.tbl-wrap{border:1px solid var(--line-soft);border-radius:10px;overflow:hidden}
-table{width:100%;border-collapse:collapse;font-size:13px}
-th{text-align:left;background:var(--soft);font-size:11px;letter-spacing:.05em;font-weight:800;color:var(--ink-3);padding:9px 12px;border-bottom:1px solid var(--line)}
-td{padding:11px 12px;border-bottom:1px solid var(--line-soft);vertical-align:top}
-tr:last-child td{border-bottom:0}
-.num{font-family:var(--mono);color:var(--ink-4);white-space:nowrap}
-.cust{font-weight:700}
-.prio{font-family:var(--mono);font-weight:800}
-.prio.hi{color:var(--danger)}
-.prio.mid{color:var(--ink-2)}
-.reason{font-size:12.5px;color:var(--ink-2)}
-.flow{margin-top:16px;padding:9px 12px;border-radius:8px;background:var(--soft);border:1px dashed var(--line);font-size:12px;color:var(--ink-3)}
-.flow b{color:var(--ink)}
-.card-foot{padding:13px 22px;border-top:1px solid var(--line-soft);font-size:11.5px;color:var(--ink-4);display:flex;justify-content:space-between;flex-wrap:wrap;gap:8px}
-@media(max-width:600px){.card-head{flex-wrap:wrap}.side{align-items:flex-start}}
-/* 补充：推荐等级 pill 与状态强调（仅追加，不改动基件样式） */
-.st{display:inline-block;padding:1px 9px;border-radius:999px;font-size:11px;font-weight:800;letter-spacing:.04em;font-family:var(--mono);white-space:nowrap;border:1px solid transparent}
-.st.ok{color:var(--ok);background:var(--ok-soft);border-color:#bfe6b4}
-.st.miss{color:var(--danger);background:var(--danger-soft);border-color:#f3b9b5}
-.st.unknown{color:#8f6a12;background:#fdf3d7;border-color:#ecd9a0}
-.st.cond{color:#b23a2e;background:#f7e4e0;border-color:#ecc5bd}
-.risk{font-weight:800;font-size:12.5px}
-.risk.mid{color:#8f6a12}
-.mono{font-family:var(--mono);font-size:12px;color:var(--ink-2)}
-.tbl-gap{margin-top:18px}
-`;

api-report/apps/api/src/modules/loop-engine/port.d.ts

@@ -92,8 +92,21 @@ export type TaskDataGateway = {
         domain: string;
         object: string;
         key: Record<string, string | number>;
+        /**
+         * **已落地的行:跳过,不拒**(2026-08-31,配方专用 —— 与 `draftWrite` 的两个旗同族)。
+         * 「数据工单确认即入库」把行落进正式表后,草稿层那一笔只是「本单写过它」的记号;
+         * 撤记号正式表一个字不动,读面反而少一行 —— 所以对人/模型那一路它是硬拒(拒回是
+         * 行动指南)。而配方 `prune` 的语义是「陈旧的投影行清掉」:已落地 = 已经是世界的
+         * 一部分,不是陈旧草稿 —— 对配方来说跳过是常态,抛错就是整单停摆(2026-08-30
+         * e2e 案例 2 的死锁:人确认入库后改了类型选择,prune 想撤已落地的旧类型行,当场炸;
+         * 当时以「②③ 不带 prune」绕开,代价是**没落地的**陈旧行也跟着不清了 ——
+         * 2026-08-31 用户实测点名的「改回同一类型,下面还是两个类型」正是这半截代价)。
+         * 模型那一路不传这个旗:行为一个字不变。
+         */
+        skipLanded?: boolean | undefined;
     }): Promise<{
         dropped: boolean;
+        landed?: boolean;
     }>;
 };
 /**

api-report/packages/contracts/src/activity-ops.d.ts

@@ -296,9 +296,16 @@ export declare const launchParamTypeSchema: z.ZodEnum<{
     list: "list";
 }>;
 export type LaunchParamType = z.infer<typeof launchParamTypeSchema>;
+/**
+ * 一条候选。`group` 是**联动分组键**(2026-08-31 用户定):清单 `x-options.group` 指了哪一列,
+ * 这颗候选就带上它在那一列的值(如料号的 `chip_type_id`);空串 = 那一列没值(「未标类型」)。
+ * `groupLabel` 是这枚键的人读名(从字典表现读,如「DC-DC 降压稳压器」),读不到就没有 —— 界面退回摆键本身。
+ */
 export declare const launchOptionSchema: z.ZodObject<{
     value: z.ZodString;
     label: z.ZodString;
+    group: z.ZodOptional<z.ZodString>;
+    groupLabel: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type LaunchOption = z.infer<typeof launchOptionSchema>;
 export declare const launchParamSchema: z.ZodObject<{
@@ -317,8 +324,11 @@ export declare const launchParamSchema: z.ZodObject<{
     options: z.ZodOptional<z.ZodArray<z.ZodObject<{
         value: z.ZodString;
         label: z.ZodString;
+        group: z.ZodOptional<z.ZodString>;
+        groupLabel: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    linkGroup: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type LaunchParam = z.infer<typeof launchParamSchema>;
 export declare const launchParamsSchema: z.ZodObject<{
@@ -340,8 +350,11 @@ export declare const launchParamsSchema: z.ZodObject<{
         options: z.ZodOptional<z.ZodArray<z.ZodObject<{
             value: z.ZodString;
             label: z.ZodString;
+            group: z.ZodOptional<z.ZodString>;
+            groupLabel: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
         default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        linkGroup: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type LaunchParams = z.infer<typeof launchParamsSchema>;

api-report/packages/contracts/src/api/activity-ops.d.ts

@@ -176,8 +176,11 @@ export declare const opsLaunchParamsRoute: {
             options: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 value: z.ZodString;
                 label: z.ZodString;
+                group: z.ZodOptional<z.ZodString>;
+                groupLabel: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>>;
             default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+            linkGroup: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
 };

api-report/packages/contracts/src/api/workbench.d.ts

@@ -907,6 +907,8 @@ export declare const taskDetailSchema: z.ZodObject<{
         }, z.core.$strip>>;
         submitLabel: z.ZodOptional<z.ZodString>;
         gateLedgers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        gateWhen: z.ZodOptional<z.ZodString>;
+        gateWhenSay: z.ZodOptional<z.ZodString>;
         gate: z.ZodOptional<z.ZodObject<{
             ready: z.ZodBoolean;
             why: z.ZodString;
@@ -1498,6 +1500,8 @@ export declare const taskDetailSchema: z.ZodObject<{
         }, z.core.$strip>>;
         submitLabel: z.ZodOptional<z.ZodString>;
         gateLedgers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        gateWhen: z.ZodOptional<z.ZodString>;
+        gateWhenSay: z.ZodOptional<z.ZodString>;
         gate: z.ZodOptional<z.ZodObject<{
             ready: z.ZodBoolean;
             why: z.ZodString;
@@ -2831,6 +2835,8 @@ export declare const taskDetailRoute: {
             }, z.core.$strip>>;
             submitLabel: z.ZodOptional<z.ZodString>;
             gateLedgers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            gateWhen: z.ZodOptional<z.ZodString>;
+            gateWhenSay: z.ZodOptional<z.ZodString>;
             gate: z.ZodOptional<z.ZodObject<{
                 ready: z.ZodBoolean;
                 why: z.ZodString;
@@ -3422,6 +3428,8 @@ export declare const taskDetailRoute: {
             }, z.core.$strip>>;
             submitLabel: z.ZodOptional<z.ZodString>;
             gateLedgers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            gateWhen: z.ZodOptional<z.ZodString>;
+            gateWhenSay: z.ZodOptional<z.ZodString>;
             gate: z.ZodOptional<z.ZodObject<{
                 ready: z.ZodBoolean;
                 why: z.ZodString;

api-report/packages/contracts/src/auto-recipe.d.ts

@@ -72,8 +72,16 @@ export type AutoAction = {
     readonly when?: string | undefined;
     /** 台账地址「域.对象」—— 必须在 `declarations.ledger` 里(静态审) */
     readonly into: string;
-    /** 这一笔投影出来的行**就是这张表在本单草稿里的全部**,多出来的撤掉。只动草稿层 */
-    readonly prune?: boolean | undefined;
+    /**
+     * 这一笔投影出来的行**就是这张表在本单草稿里的全部**,多出来的撤掉。只动草稿层。
+     * `true`:只在非 quiet 拍撤 —— 人正对着件编辑的那几拍不动他的行(2026-08-29 终审 F3:
+     * 人刚在件上加的行,配方的数据源里当然没有,quiet 撤行就是静默数据丢失)。
+     * `'live'`(2026-08-31):quiet 拍也撤 —— **只给人不会在件上加行的表用**(行集全由配方铺,
+     * 如 W05 的参数骨架):F3 防的是「人刚加的行被撤」,人加不了行的表没有这个风险,
+     * 而「改了类型,旧类型的参数行还摆在屏上」是另一种撒谎 —— 跟手比守候更诚实。
+     * 已落地的行两档都跳过并出声(draftDrop 的 skipLanded)。
+     */
+    readonly prune?: boolean | 'live' | undefined;
     readonly from: AutoSource;
     readonly fields: Readonly<Record<string, AutoExpr>>;
 } | {
@@ -110,6 +118,9 @@ export type AutoAction = {
     }[] | undefined;
     /** 这张卡的提交闸盯哪几张表 */
     readonly gateLedgers?: readonly string[] | undefined;
+    /** 确认闸的条件档(S-FEEL,只读基座读数;为假不受理确认)+ 拒回那句话 —— 见 card.ts 同名字段 */
+    readonly gateWhen?: string | undefined;
+    readonly gateWhenSay?: string | undefined;
     /** 决策卡的选项;`variant:'review'` 时允许只有一个 */
     readonly options?: readonly {
         readonly value: string;

api-report/packages/contracts/src/card.d.ts

@@ -862,6 +862,8 @@ export declare const executionWorkOrderSchema: z.ZodObject<{
     }, z.core.$strip>>;
     submitLabel: z.ZodOptional<z.ZodString>;
     gateLedgers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    gateWhen: z.ZodOptional<z.ZodString>;
+    gateWhenSay: z.ZodOptional<z.ZodString>;
     gate: z.ZodOptional<z.ZodObject<{
         ready: z.ZodBoolean;
         why: z.ZodString;
@@ -1482,6 +1484,8 @@ export declare const workOrderSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>>;
     submitLabel: z.ZodOptional<z.ZodString>;
     gateLedgers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    gateWhen: z.ZodOptional<z.ZodString>;
+    gateWhenSay: z.ZodOptional<z.ZodString>;
     gate: z.ZodOptional<z.ZodObject<{
         ready: z.ZodBoolean;
         why: z.ZodString;

apps/api/src/app/__tests__/activity-ops-launch-params.test.ts

@@ -208,3 +208,88 @@ describe('validateLaunchParams', () => {
     expect(nan.ok).toBe(false);
   });
 });
+
+/* ── 按分组键联动(2026-08-31 用户定:原料号 / 候选料号按芯片类型互相收窄)────────────
+   派生层只负责把两样东西送到前端:①候选带上它的分组键与人读名(`x-options.group`);
+   ②这一格属于哪个联动组(`x-link`)。收窄怎么摆是前端的事,**服务端不据此立墙**。 */
+describe('x-options.group / x-link', () => {
+  const LINKED = {
+    type: 'object',
+    required: ['originalInternalPn', 'candidateInternalPn'],
+    properties: {
+      originalInternalPn: {
+        type: 'string',
+        title: '原内部料号',
+        'x-control': 'combo',
+        'x-options': {
+          ledger: 'parts.profile',
+          value: 'internal_pn',
+          label: 'internal_pn',
+          group: { column: 'chip_type_id', ledger: 'parts.chip_type', value: 'type_id', label: 'type_name' },
+        },
+        'x-link': 'chip-type',
+        'x-order': 1,
+      },
+      candidateInternalPn: {
+        type: 'string',
+        title: '候选内部料号',
+        'x-control': 'combo',
+        'x-options': { ledger: 'parts.profile', value: 'internal_pn', label: 'internal_pn', group: 'chip_type_id' },
+        'x-link': 'chip-type',
+        'x-order': 2,
+      },
+    },
+  };
+
+  it('分组键两种写法都认:整份声明(带字典)与只写列名;x-link 读成联动组名', () => {
+    const specs = fieldSpecsOf(LINKED);
+    expect(specs[0]?.optionsSource?.group).toEqual({ column: 'chip_type_id', dict: { ledger: 'parts.chip_type', value: 'type_id', label: 'type_name' } });
+    // 只写列名 = 有分组键、没有人读名字典
+    expect(specs[1]?.optionsSource?.group).toEqual({ column: 'chip_type_id', dict: undefined });
+    expect(specs.map((s) => s.linkGroup)).toEqual(['chip-type', 'chip-type']);
+  });
+
+  it('分组键写残(没有 column,或字典缺 ledger/value)就当没声明 —— 候选照出,只是不联动', () => {
+    const bad = fieldSpecsOf({
+      properties: {
+        a: { type: 'string', 'x-control': 'combo', 'x-options': { ledger: 'l.o', value: 'v', group: {} } },
+        b: { type: 'string', 'x-control': 'combo', 'x-options': { ledger: 'l.o', value: 'v', group: { column: 'c', ledger: 'd.t' } } },
+      },
+    });
+    expect(bad[0]?.optionsSource).toEqual({ ledger: 'l.o', value: 'v', label: 'v', group: undefined });
+    // 字典写残 → 只留分组键,人读名没有(不炸)
+    expect(bad[1]?.optionsSource?.group).toEqual({ column: 'c', dict: undefined });
+  });
+
+  it('候选带 group / groupLabel 原样交给前端;有候选才给 linkGroup(一个候选都没有,联动无从谈起)', async () => {
+    const params = await launchParamsOf(LINKED, async (src) =>
+      src.group === undefined
+        ? [{ value: 'AMS1117-3.3', label: 'AMS1117-3.3' }]
+        : [
+            { value: 'LM2596S-5.0', label: 'LM2596S-5.0', group: '1', groupLabel: 'DC-DC 降压稳压器' },
+            { value: 'OLD-001', label: 'OLD-001', group: '' },
+          ],
+    );
+    expect(params[0]).toMatchObject({
+      key: 'originalInternalPn',
+      linkGroup: 'chip-type',
+      options: [
+        { value: 'LM2596S-5.0', label: 'LM2596S-5.0', group: '1', groupLabel: 'DC-DC 降压稳压器' },
+        { value: 'OLD-001', label: 'OLD-001', group: '' },
+      ],
+    });
+    // 候选读不到 → 仍是 combo,但不摆联动组(前端没有可收窄的东西)
+    const empty = await launchParamsOf(LINKED, noResolve);
+    expect(empty[0]?.linkGroup).toBeUndefined();
+    expect(empty[0]?.type).toBe('combo');
+  });
+
+  it('服务端不据分组立墙:两格填不同类型的料号照样收(类型一致归活动的收步判据管)', async () => {
+    const params = await launchParamsOf(LINKED, async () => [
+      { value: 'LM2596S-5.0', label: 'LM2596S-5.0', group: '1' },
+      { value: 'AMS1117-3.3', label: 'AMS1117-3.3', group: '2' },
+    ]);
+    const out = validateLaunchParams(params, { originalInternalPn: 'LM2596S-5.0', candidateInternalPn: 'AMS1117-3.3' }, fieldSpecsOf(LINKED));
+    expect(out).toEqual({ ok: true, data: { originalInternalPn: 'LM2596S-5.0', candidateInternalPn: 'AMS1117-3.3' } });
+  });
+});

apps/api/src/app/__tests__/activity-ops-service.test.ts

@@ -374,6 +374,80 @@ describe('启动', () => {
     expect(table?.params[0]?.options).toEqual([{ value: 'CU-0142', label: 'Itelma' }, { value: 'CU-0001', label: 'CU-0001' }]);
   });
 
+  /* 联动(2026-08-31 用户定):候选行上多取一列当分组键,再从字典表换人读名交给前端 */
+  const LINKED_MANIFEST = (): ManifestFace =>
+    manifest({
+      contract: {
+        input: {
+          data: {
+            type: 'object',
+            required: ['originalInternalPn', 'candidateInternalPn'],
+            properties: {
+              originalInternalPn: {
+                type: 'string',
+                title: '原内部料号',
+                'x-control': 'combo',
+                'x-options': { ledger: 'parts.profile', value: 'internal_pn', label: 'internal_pn', group: { column: 'chip_type_id', ledger: 'parts.chip_type', value: 'type_id', label: 'type_name' } },
+                'x-order': 1,
+                'x-link': 'chip-type',
+              },
+              candidateInternalPn: {
+                type: 'string',
+                title: '候选内部料号',
+                'x-control': 'combo',
+                'x-options': { ledger: 'parts.profile', value: 'internal_pn', label: 'internal_pn', group: { column: 'chip_type_id', ledger: 'parts.chip_type', value: 'type_id', label: 'type_name' } },
+                'x-order': 2,
+                'x-link': 'chip-type',
+              },
+            },
+          },
+        },
+      },
+    });
+  const PARTS: Record<string, Record<string, unknown>[]> = {
+    'parts.profile': [
+      { internal_pn: 'AMS1117-3.3', chip_type_id: '2' },
+      { internal_pn: 'LM2596S-5.0', chip_type_id: '1' },
+      { internal_pn: 'OLD-001', chip_type_id: null },
+    ],
+    'parts.chip_type': [
+      { type_id: '1', type_name: 'DC-DC 降压稳压器' },
+      { type_id: '2', type_name: 'LDO 线性稳压器' },
+    ],
+  };
+  const partsLedger = (over: Partial<ActivityOpsDeps['ledger']> = {}): ActivityOpsDeps['ledger'] => ({
+    describe: async (address) => {
+      const rows = PARTS[`${address.domain}.${address.object}`];
+      return rows === undefined ? undefined : { columns: Object.keys(rows[0] ?? {}).map((name) => ({ name })) };
+    },
+    query: async (q) => ({ rows: PARTS[`${q.address.domain}.${q.address.object}`] ?? [] }),
+    ...over,
+  });
+
+  it('候选带分组键 + 字典换来的人读名;那一列没值就是空串(未标类型),联动组名随参数下发', async () => {
+    const { ops } = harness({ manifest: LINKED_MANIFEST(), ledger: partsLedger() });
+    const table = await ops.launchParams(W05);
+    expect(table?.params.map((p) => p.linkGroup)).toEqual(['chip-type', 'chip-type']);
+    expect(table?.params[0]?.options).toEqual([
+      { value: 'AMS1117-3.3', label: 'AMS1117-3.3', group: '2', groupLabel: 'LDO 线性稳压器' },
+      { value: 'LM2596S-5.0', label: 'LM2596S-5.0', group: '1', groupLabel: 'DC-DC 降压稳压器' },
+      { value: 'OLD-001', label: 'OLD-001', group: '' },
+    ]);
+  });
+
+  it('分组那一列不存在 / 字典读不到 → 候选照出,只是没有键或没有名(不炸)', async () => {
+    const noColumn = harness({
+      manifest: LINKED_MANIFEST(),
+      ledger: partsLedger({ describe: async (a) => (a.object === 'profile' ? { columns: [{ name: 'internal_pn' }] } : { columns: [{ name: 'type_id' }, { name: 'type_name' }] }) }),
+    });
+    const t1 = await noColumn.ops.launchParams(W05);
+    expect(t1?.params[0]?.options?.every((o) => o.group === undefined)).toBe(true);
+    // 分组键在、字典表没物化 → 有键没名
+    const noDict = harness({ manifest: LINKED_MANIFEST(), ledger: partsLedger({ describe: async (a) => (a.object === 'chip_type' ? undefined : { columns: [{ name: 'internal_pn' }, { name: 'chip_type_id' }] }) }) });
+    const t2 = await noDict.ops.launchParams(W05);
+    expect(t2?.params[0]?.options?.[0]).toEqual({ value: 'AMS1117-3.3', label: 'AMS1117-3.3', group: '2' });
+  });
+
   it('禁用 412 / 责任人不在职 400 / 参数不合 400 —— 都不起单', async () => {
     const { ops, started } = harness({ enabled: false });
     expect((await ops.launch(W05, launchInput(), ME)).kind).toBe('disabled');

apps/api/src/app/__tests__/view-table-edit.test.ts

@@ -689,3 +689,20 @@ describe('decisionReadings:按 card-reply 数', () => {
     expect(decisionReadings([])).toEqual({ decision_last: '', decision_approve_total: 0, decision_reject_total: 0, decision_custom_total: 0 });
   });
 });
+
+describe('conditionGateOf:确认闸的条件档(2026-08-31,「类型不一致还能确认」逼出)', () => {
+  it('条件为假 → 不受理,拒回用发卡人那句话;为真 / 没声明 → 不拦', async () => {
+    const { conditionGateOf } = await import('../routes/desk.ts');
+    const readings = { parts_profile_distinct_chip_type_id: 2 };
+    const blocked = conditionGateOf('parts_profile_distinct_chip_type_id <= 1', '两颗料不是同一个芯片类型 —— 先改对再确认。', readings);
+    expect(blocked?.ready).toBe(false);
+    expect(blocked?.why).toContain('不是同一个芯片类型');
+    expect(conditionGateOf('parts_profile_distinct_chip_type_id <= 1', '话', { parts_profile_distinct_chip_type_id: 1 })).toBeUndefined();
+    expect(conditionGateOf(undefined, undefined, readings)).toBeUndefined();
+  });
+
+  it('表达式炸了不成墙(装包静态审管坏表达式;运行时评估不出的条件不该锁死一单)', async () => {
+    const { conditionGateOf } = await import('../routes/desk.ts');
+    expect(conditionGateOf('((((', '话', {})).toBeUndefined();
+  });
+});

apps/api/src/app/activity-ops/launch-params.ts

@@ -7,6 +7,10 @@
  *   · `x-control`:`text | textarea | select | combo` —— 不写就按类型推:enum → select、`array<string>` → list、string → text;
  *     **数组字段也可以标 combo / select**(表单只选一颗,提交单个字符串,后端包成一元数组;传数组也照收)
  *   · `x-options`:`{ ledger: '域.对象', value: '列', label: '列' }` —— combo / select 的候选从正式台账现读(客户 / 料号这类「台账里可能有」的)
+ *   · `x-options.group`:候选的**分组键**(2026-08-31 用户定)—— 只写列名(`'chip_type_id'`)= 有键没名;
+ *     整份写 `{ column, ledger, value, label }` 再从字典表换人读名(`parts.chip_type.type_id → type_name`)
+ *   · `x-link`:联动组名 —— 同名的几格按候选的分组键互相收窄(组内先填的那格是锚,其余按锚的键收窄)。
+ *     **服务端不据此立墙**:combo 本就收候选之外的值(新增料号),类型一致归活动自己的收步判据管
  *   · `format: 'file'` 的字段**本期不上表单**(文档没有文件控件;W05 的 datasheet 在数据工单里传)
  *   · `x-order`:表单里的次序(数字,小的在前)。**必须声明**才有稳定次序 —— 清单存在 jsonb 里,
  *     PG 按键长再按字节序重排对象键,`properties` 的书写顺序到不了这里(实测:原料号跑到了客户需求前面)
@@ -17,7 +21,13 @@
 import type { LaunchOption, LaunchParam, LaunchParamType } from '@contracts';
 import { LAUNCH_PARAM_TYPES } from '@contracts';
 
-export type OptionsSource = { readonly ledger: string; readonly value: string; readonly label: string };
+/**
+ * 候选的**分组键**(2026-08-31 用户定的联动):`column` 是候选行上取哪一列当键(如 `chip_type_id`),
+ * `dict` 是把这枚键换成人读名的字典表(如 `parts.chip_type.type_id → type_name`);
+ * 字典没声明 / 写残 → 只有键没有名(界面退回摆键本身,不炸)。
+ */
+export type GroupSource = { readonly column: string; readonly dict: { readonly ledger: string; readonly value: string; readonly label: string } | undefined };
+export type OptionsSource = { readonly ledger: string; readonly value: string; readonly label: string; readonly group: GroupSource | undefined };
 
 /** 一个入参字段的规格 —— JSON Schema 里我们认的那几个词 */
 export type FieldSpec = {
@@ -34,6 +44,8 @@ export type FieldSpec = {
   readonly example: unknown;
   readonly defaultValue: unknown;
   readonly optionsSource: OptionsSource | undefined;
+  /** 联动组名(`x-link`);同名的几格按候选的分组键互相收窄 —— 摆法在前端,服务端不据此立墙 */
+  readonly linkGroup: string | undefined;
   /** 表单次序(`x-order`);没声明的排在声明了的后面、彼此保持读到的顺序 */
   readonly order: number | undefined;
 };
@@ -46,6 +58,24 @@ function asString(value: unknown): string | undefined {
   return typeof value === 'string' ? value : undefined;
 }
 
+/** `x-options.group`:只写列名(字符串)= 有键没名;整份声明 = 键 + 换名字典。写残当没声明 —— 候选照出,只是不联动 */
+function groupSourceOf(value: unknown): GroupSource | undefined {
+  const asColumn = asString(value);
+  if (asColumn !== undefined) return asColumn === '' ? undefined : { column: asColumn, dict: undefined };
+  const raw = asRecord(value);
+  if (raw === undefined) return undefined;
+  const column = asString(raw['column']);
+  if (column === undefined || column === '') return undefined;
+  const ledger = asString(raw['ledger']);
+  const valueCol = asString(raw['value']);
+  const labelCol = asString(raw['label']);
+  const dict =
+    ledger === undefined || !ledger.includes('.') || valueCol === undefined || valueCol === ''
+      ? undefined
+      : { ledger, value: valueCol, label: labelCol === undefined || labelCol === '' ? valueCol : labelCol };
+  return { column, dict };
+}
+
 function optionsSourceOf(value: unknown): OptionsSource | undefined {
   const raw = asRecord(value);
   if (raw === undefined) return undefined;
@@ -53,7 +83,7 @@ function optionsSourceOf(value: unknown): OptionsSource | undefined {
   const valueCol = asString(raw['value']);
   const labelCol = asString(raw['label']);
   if (ledger === undefined || !ledger.includes('.') || valueCol === undefined || valueCol === '') return undefined;
-  return { ledger, value: valueCol, label: labelCol === undefined || labelCol === '' ? valueCol : labelCol };
+  return { ledger, value: valueCol, label: labelCol === undefined || labelCol === '' ? valueCol : labelCol, group: groupSourceOf(raw['group']) };
 }
 
 /** `input.data` 的 properties 逐个读成规格,保属性序(表单顺序就是清单顺序) */
@@ -81,6 +111,7 @@ export function fieldSpecsOf(inputSchema: Readonly<Record<string, unknown>>): Fi
       example: Array.isArray(examples) ? examples[0] : undefined,
       defaultValue: spec['default'],
       optionsSource: optionsSourceOf(spec['x-options']),
+      linkGroup: asString(spec['x-link']) === '' ? undefined : asString(spec['x-link']),
       order: typeof spec['x-order'] === 'number' && Number.isFinite(spec['x-order']) ? spec['x-order'] : undefined,
     };
   });
@@ -159,6 +190,8 @@ export function launchParamOf(spec: FieldSpec, resolved: readonly LaunchOption[]
     ...(placeholder === undefined ? {} : { placeholder }),
     ...(withOptions ? { options } : {}),
     ...(fallback === undefined ? {} : { default: fallback }),
+    /* 联动只在真有候选时才谈得上 —— 一个候选都没有的 combo 摆了组名,前端也没有可收窄的东西 */
+    ...(withOptions && spec.linkGroup !== undefined ? { linkGroup: spec.linkGroup } : {}),
   };
 }
 

apps/api/src/app/activity-ops/service.ts

@@ -38,7 +38,7 @@ import type { StartTaskInput } from '@modules/task';
 import { MIME_OF } from '../file-compose.ts';
 import type { FileFormat } from '../file-compose.ts';
 import { fieldSpecsOf, launchParamsOf, validateLaunchParams } from './launch-params.ts';
-import type { FieldSpec, LaunchIssue, OptionsSource } from './launch-params.ts';
+import type { FieldSpec, GroupSource, LaunchIssue, OptionsSource } from './launch-params.ts';
 import { instanceStateOf, verdictFactOf } from './instance-state.ts';
 import type { StateVerdict } from './instance-state.ts';
 import { followRes, stepsOf } from './instance-steps.ts';
@@ -229,6 +229,34 @@ export function createActivityOps(deps: ActivityOpsDeps): ActivityOps {
     return { ...rest, desc: profile?.description ?? '', view: hasView ? { url: `/api/gov/activities/${card.activityId}/view` } : null };
   }
 
+  /**
+   * 分组键的人读名字典(`x-options.group.dict`)—— 键 → 名。
+   * 表没物化 / 列不在 / 查不动 → 空表(候选仍带键、只是没有名;界面退回摆键本身,不炸)。
+   */
+  async function groupLabels(dict: NonNullable<GroupSource['dict']>): Promise<ReadonlyMap<string, string>> {
+    const [domain, object] = dict.ledger.split('.', 2);
+    if (domain === undefined || object === undefined || domain === '' || object === '') return new Map();
+    const address = { domain, object };
+    const described = await deps.ledger.describe(address).catch(() => undefined);
+    if (described === undefined || !described.columns.some((c) => c.name === dict.value) || !described.columns.some((c) => c.name === dict.label)) {
+      warn(`[activity-ops] 分组人读名读不到:${dict.ledger} 未物化或没有列 ${dict.value} / ${dict.label}`);
+      return new Map();
+    }
+    const page = await deps.ledger.query({ address, where: {}, orderBy: [], limit: OPTIONS_CAP, offset: 0 }).catch((error: unknown) => {
+      warn(`[activity-ops] 分组人读名查询失败:${dict.ledger} —— ${error instanceof Error ? error.message : String(error)}`);
+      return undefined;
+    });
+    const out = new Map<string, string>();
+    for (const row of page?.rows ?? []) {
+      const key = row[dict.value];
+      const name = row[dict.label];
+      if (key === undefined || key === null || String(key) === '') continue;
+      if (name === undefined || name === null || String(name) === '') continue;
+      out.set(String(key), String(name));
+    }
+    return out;
+  }
+
   /** combo / select 的候选从正式台账现读;表没物化、列不存在、查询失败 → 没有候选(不炸,说一声) */
   async function resolveOptions(source: OptionsSource): Promise<readonly LaunchOption[] | undefined> {
     const [domain, object] = source.ledger.split('.', 2);
@@ -251,13 +279,22 @@ export function createActivityOps(deps: ActivityOpsDeps): ActivityOps {
         return undefined;
       });
     if (page === undefined) return undefined;
+    /* 分组键(联动用):声明了、且候选表真有这一列才取 —— 列不在就当没声明(候选照出,只是不联动) */
+    const group = source.group !== undefined && columns.has(source.group.column) ? source.group : undefined;
+    if (source.group !== undefined && group === undefined) warn(`[activity-ops] 分组键读不到:${source.ledger} 没有列 ${source.group.column}`);
+    const names = group?.dict === undefined ? new Map<string, string>() : await groupLabels(group.dict);
     return page.rows
       .map((row) => {
         const value = row[source.value];
         const label = row[source.label];
         const v = value === undefined || value === null ? '' : String(value);
         const l = label === undefined || label === null || String(label) === '' ? v : String(label);
-        return { value: v, label: l };
+        if (group === undefined) return { value: v, label: l };
+        const raw = row[group.column];
+        /* 那一列没值 = 「未标类型」:空串是它自己的一档,不是「没有分组键这回事」 */
+        const key = raw === undefined || raw === null ? '' : String(raw);
+        const name = names.get(key);
+        return { value: v, label: l, group: key, ...(name === undefined ? {} : { groupLabel: name }) };
       })
       .filter((o) => o.value !== '');
   }

apps/api/src/app/routes/desk.ts

@@ -45,7 +45,8 @@ function rowsOf<T>(result: unknown): T[] {
 }
 import { staffOf } from '../http-env.ts';
 import type { AppEnv } from '../http-env.ts';
-import { coerceToColumn, missingReadings, rowLabel } from '../wiring/engines.ts';
+import { evaluateCondition } from '@sfeel';
+import { coerceToColumn, distinctReadings, missingReadings, rowLabel, rowReadings, tallyReadings } from '../wiring/engines.ts';
 import { orderChat } from '../chat-order.ts';
 
 
@@ -816,7 +817,41 @@ async function submitGate(
   for (const draft of await container.ledger.taskDrafts(taskId)) {
     (mine[`mine:${draft.domain}.${draft.object}`] ??= []).push({ ...draft.key, ...draft.patch });
   }
-  return emptyGate(mine, watched, declared) ?? gateOf(missingReadings(mine, watched), watched);
+  const base = emptyGate(mine, watched, declared) ?? gateOf(missingReadings(mine, watched), watched);
+  if (!base.ready) return base;
+  /*
+   * **条件档**(2026-08-31,W05「两颗料不是同一个芯片类型还能确认」逼出):缺格闸都过了,
+   * 发卡的人还声明了一条 S-FEEL 条件的,再按**全部声明表的基座读数**现算一遍 —— 为假就
+   * 不受理。读数从本单草稿现读(rows/missing/tally/distinct 同一套函数),没有 tick 滞后:
+   * 人刚在件上改完类型、点确认,算的就是改完之后的样子。
+   */
+  return (
+    conditionGateOf(order.gateWhen, order.gateWhenSay, {
+      ...rowReadings(mine, manifest.declarations.ledger),
+      ...missingReadings(mine, manifest.declarations.ledger),
+      ...tallyReadings(mine, manifest.declarations.ledger),
+      ...distinctReadings(mine, manifest.declarations.ledger),
+    }) ?? base
+  );
+}
+
+/**
+ * 确认闸的条件档 —— S-FEEL 为假就交不了,拒回用发卡人写的那句话(display 与服务端同一段)。
+ * 条件只读基座读数(机检纪律)。表达式炸了按「不拦」:坏表达式装包时静态审就该拦
+ * (checkWhen 已审),运行时评估不出的条件不该成墙(「没有依据的时候不拦人」)。
+ */
+export function conditionGateOf(
+  when: string | undefined,
+  say: string | undefined,
+  readings: Readonly<Record<string, string | number>>,
+): { ready: boolean; why: string; blanks: string[] } | undefined {
+  if (when === undefined || when.trim() === '') return undefined;
+  try {
+    if (evaluateCondition(when, readings)) return undefined;
+  } catch {
+    return undefined;
+  }
+  return { ready: false, why: say ?? '这张卡声明的确认条件还不成立 —— 回件上把它办对再来确认。', blanks: [] };
 }
 
 /**

apps/api/src/app/wiring/engines.ts

@@ -1203,7 +1203,7 @@ export function wireEngines(deps: EngineWiringDeps): EngineWiring {
      * 回 `dropped: false` = 草稿层里根本没有这一行 —— 多半是主键写法对不上
      * (`DAG…` 与 `DAG…-R0` 是两行);如实说比静默成功有用。
      */
-    async draftDrop(input: { taskId: TaskId; domain: string; object: string; key: Record<string, string | number> }) {
+    async draftDrop(input: { taskId: TaskId; domain: string; object: string; key: Record<string, string | number>; skipLanded?: boolean | undefined }) {
       const allowed = await taskData.writable(input.taskId);
       const target = allowed.find((a) => a.domain === input.domain && a.object === input.object);
       if (target === undefined) {
@@ -1226,6 +1226,12 @@ export function wireEngines(deps: EngineWiringDeps): EngineWiring {
           Object.keys(input.key).every((k) => String(d.key[k] ?? '') === String(input.key[k] ?? '')),
       );
       if (landedHit !== undefined) {
+        /*
+         * 配方 `prune` 传 `skipLanded`:已落地 = 已经是世界的一部分,不是陈旧草稿 ——
+         * 跳过是常态,不该整单炸掉(port.ts 上的大注释)。模型那一路不传,照旧硬拒:
+         * 那句拒回是它的行动指南。
+         */
+        if (input.skipLanded === true) return { dropped: false, landed: true };
         throw new Error(
           `${target.label}里这一行(${Object.entries(input.key).map(([k, v]) => `${k}=${String(v)}`).join('、')})` +
             '是本单在数据工单里建好、人确认后已入库的,撤不掉;要改由人在件上改,你接着办下一件事。',

apps/api/src/modules/activity-registry/internal/domain/static-audit.ts

@@ -612,6 +612,8 @@ export function autoRecipeFindings(manifest: ActivityManifest): StaticAuditFindi
       const where = `${at}.do[${index}]`;
       /* 动作级 `when`:语法 + 名字都审(它看得见的只有 scope 与 let,没有行内列) */
       if (action.when !== undefined) checkWhen(action.when, where, letNames);
+      /* 确认闸的条件档与动作级 when 同一作用域(基座读数),同一套审 */
+      if (action.kind === 'card' && action.gateWhen !== undefined) checkWhen(action.gateWhen, where, letNames);
       if (action.kind === 'project') {
         checkAddress(action.into, where);
         walkSource(action.from, where);
@@ -628,7 +630,7 @@ export function autoRecipeFindings(manifest: ActivityManifest): StaticAuditFindi
          * 说的是「这张表归人填,模型没有来源」—— 人加的行配方的数据源里当然没有,
          * 下一拍对齐就把它撤了。两条声明放在同一张表上,意思是相反的。
          */
-        if (action.prune === true && (step.humanWrites ?? []).includes(action.into)) {
+        if ((action.prune === true || action.prune === 'live') && (step.humanWrites ?? []).includes(action.into)) {
           out.push({
             code: 'schema-invalid',
             severity: 'warn',

apps/api/src/modules/interaction/__tests__/view-render.test.ts

@@ -542,3 +542,17 @@ describe('data-options:下拉的选项从台账现读', () => {
     expect(out).toContain('<option value="2" selected>LDO 线性稳压器</option>');
   });
 });
+
+describe('孪生件占位提示:data-ph 落成 input 的 placeholder(2026-08-31,W05 参数瓷贴)', () => {
+  it('带 data-ph 的可改格,孪生 input 有 placeholder;不带的没有', () => {
+    const html =
+      '<div data-rows="mine:parts.parameter" data-edit="parts.parameter"><p>' +
+      '<span class="jc-vcell" data-slot="param_value" data-col="param_value" data-ph="规格书上的值,查不到留空" data-blank></span>' +
+      '<span class="jc-vcell" data-slot="param_note" data-col="param_note" data-blank></span>' +
+      '</p></div>';
+    const out = renderView(html, { 'mine:parts.parameter': [{ param_value: '', param_note: '' }] });
+    expect(out).toContain('placeholder="规格书上的值,查不到留空"');
+    const notePart = out.slice(out.indexOf('data-col="param_note"'));
+    expect(notePart.slice(0, notePart.indexOf('/>'))).not.toContain('placeholder=');
+  });
+});

apps/api/src/modules/interaction/internal/domain/view-render.ts

@@ -263,7 +263,9 @@ function twinInputs(inner: string, rowIndex: number): string {
       .split(/\s+/)
       .filter((c) => c === 'mono' || c === 'num')
       .join(' ');
-    const input = `<input class="jc-cell${style === '' ? '' : ` ${style}`}" data-col="${col}" data-row="${rowIndex}" data-slot="${slot}" data-value/>`;
+    /* `data-ph`:模版给这一格的输入孪生件配一句占位提示(2026-08-31,W05 参数瓷贴要「短短一句说清这格填什么」) */
+    const ph = /\bdata-ph\s*=\s*"([^"]*)"/.exec(attrs)?.[1];
+    const input = `<input class="jc-cell${style === '' ? '' : ` ${style}`}" data-col="${col}" data-row="${rowIndex}" data-slot="${slot}"${ph === undefined || ph === '' ? '' : ` placeholder="${ph}"`} data-value/>`;
     // 只读那一份把 `data-col` 交出去 —— 它的活已经干完(告诉这里是哪一列),留着只是噪音
     return `${all.replace(/\s*\bdata-col\s*=\s*"[^"]*"/, '')}${input}`;
   });

apps/api/src/modules/ledger/__tests__/ledger-store.it.test.ts

@@ -32,6 +32,7 @@ const T6 = 't-it-6' as TaskId;
 const T7 = 't-it-7' as TaskId;
 const T8 = 't-it-8' as TaskId;
 const T9 = 't-it-9' as TaskId;
+const T10 = 't-it-10' as TaskId;
 
 /** 哪几单算试跑 —— 由用例现填,替代 app 里那条查 `task.origin` 的 SQL */
 const SIMULATED = new Set<string>();
@@ -76,7 +77,7 @@ afterAll(async () => {
       .query(`delete from ledger.__object_meta where domain in ($1, $2)`, [DOMAIN, MASTER_DOMAIN])
       .catch(() => undefined);
     await pool
-      .query(`delete from ledger.__draft where task_id = any($1)`, [[T1, T2, T3, T4, T5, T6, T7, T8, T9]])
+      .query(`delete from ledger.__draft where task_id = any($1)`, [[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]])
       .catch(() => undefined);
     await pool.end();
   }
@@ -463,3 +464,47 @@ describe('ledger · 数据工单确认即入库(范围放行)', () => {
     expect((await ledger.taskDrafts(T9))[0]).toMatchObject({ landed: false });
   }, 60_000);
 });
+
+/**
+ * **保存过的行不许跳位**(2026-08-31 用户:「点击保存后,列表里面的元素每次排列顺序
+ * 都不一致,需要保持顺序的一致性」)。
+ *
+ * 病根是草稿层从前按 `updated_at` 读:`put` 的 upsert 分支每次都写 `updated_at = now()`,
+ * 人保存了哪几行、哪几行就跳到列表末尾;同一批写下的行(配方一次 project 铺 7 行)
+ * `updated_at` 又完全相同,并列之间没有次级键 —— PostgreSQL 更新一行是「旧版本作废 +
+ * 新版本插到堆尾」,物理顺序本来就会变,于是每保存一次屏上的表就重排一次。
+ *
+ * 这一条**只有对真库才测得出来**:假 store 的 Map 天然按插入序,永远看不到这个毛病。
+ * 断言两件事:①同一批写下的多行,读出来就是写下的顺序;②改中间那一行(件上按保存)
+ * 之后**顺序一个字不变** —— 用真的 `draftWrite`(它走的就是那条 upsert)。
+ */
+describe('ledger · 草稿层读出来的顺序稳定(件上的列表不许每次保存都重排)', () => {
+  const REF = { domain: DOMAIN, object: OBJECT };
+  const keysOf = async (taskId: TaskId): Promise<string[]> =>
+    (await ledger.taskDrafts(taskId)).map((d) => String((d.key as Record<string, unknown>)['pn']));
+
+  itDb()('按诞生序读:同批写下的顺序原样保留,改了中间那一行也不跳位', async () => {
+    const pns = ['PN-A', 'PN-B', 'PN-C', 'PN-D', 'PN-E'];
+    for (const pn of pns) {
+      await ledger.draftWrite({ taskId: T10, address: REF, key: { pn }, patch: { pn, eau: 1 } });
+    }
+    expect(await keysOf(T10)).toEqual(pns);
+
+    /* 件上按保存 = 对已有的那一行再写一笔(走 upsert 的 update 分支) */
+    await ledger.draftWrite({ taskId: T10, address: REF, key: { pn: 'PN-B' }, patch: { eau: 999 } });
+    expect(await keysOf(T10)).toEqual(pns);
+
+    /* 再保存两次、换不同的行 —— 顺序仍是诞生序,不是「最近改过的在最后」 */
+    await ledger.draftWrite({ taskId: T10, address: REF, key: { pn: 'PN-D' }, patch: { eau: 7 } });
+    await ledger.draftWrite({ taskId: T10, address: REF, key: { pn: 'PN-A' }, patch: { eau: 8 } });
+    expect(await keysOf(T10)).toEqual(pns);
+
+    /* 值确实写进去了 —— 不是靠「没写成功」换来的稳定 */
+    const rows = await ledger.taskDrafts(T10);
+    expect(rows.find((d) => (d.key as Record<string, unknown>)['pn'] === 'PN-B')?.patch).toMatchObject({ eau: 999 });
+
+    /* 新写的行排在末尾(诞生序的另一半:后来的就该在后面) */
+    await ledger.draftWrite({ taskId: T10, address: REF, key: { pn: 'PN-F' }, patch: { pn: 'PN-F', eau: 2 } });
+    expect(await keysOf(T10)).toEqual([...pns, 'PN-F']);
+  }, 60_000);
+});

apps/api/src/modules/ledger/internal/adapter/ledger-store.ts

@@ -319,7 +319,16 @@ create table if not exists ${DRAFT_TABLE} (
 );
 -- 已落地记号(2026-08-27,数据工单确认即入库):非空 = 这一行已在一道更早的门上并进正式表,
 -- 放行时不再写它。加列走 if not exists —— 这张表由启动时的 DDL 自建,不走迁移。
-alter table ${DRAFT_TABLE} add column if not exists landed_at timestamptz;`;
+alter table ${DRAFT_TABLE} add column if not exists landed_at timestamptz;
+-- **诞生序**(2026-08-31 用户:「点击保存后,列表里面的元素每次排列顺序都不一致」):
+-- 读草稿层从前按 updated_at 排,而 upsert 每次都写 updated_at = now() —— 人保存了哪几行,
+-- 哪几行就跳到列表末尾;同一批写下的行(配方一次 project 铺 7 行)updated_at 又完全相同,
+-- 并列之间没有次级键,PostgreSQL 返回什么顺序都算数(更新一行 = 旧版本作废 + 新版本插到
+-- 堆尾,物理顺序本来就会变),于是每保存一次屏上就重排一次。
+-- bigserial:**insert 那一刻取号,upsert 的 update 分支不碰它** —— 记的是「这一行是第几个
+-- 被写下的」,而配方铺行的顺序正是人期望在件上看到的顺序。单键、严格全序、没有并列。
+-- 与 landed_at 同款走 DDL 加列(这张表不走迁移,见上一句)。
+alter table ${DRAFT_TABLE} add column if not exists seq bigserial;`;
 
 type DraftRow = {
   task_id: string;
@@ -346,16 +355,31 @@ function toEntry(row: DraftRow): DraftEntry & ObjectRef {
 
 export function createDraftStore(runner: Queryable): DraftStore {
   return {
+    /*
+     * **按诞生序读,不按更新时刻读**(2026-08-31 用户:「点击保存后,列表里面的元素
+     * 每次排列顺序都不一致,需要保持顺序的一致性」)。
+     *
+     * 从前是 `order by updated_at`,而 `put` 的 upsert 分支每次都写 `updated_at = now()`
+     * —— **人保存了哪几行,哪几行就跳到列表末尾**;同一批写下的行(配方一次 project
+     * 铺 7 行)`updated_at` 又完全相同,并列之间没有次级键,PostgreSQL 返回什么顺序都
+     * 算数(更新一行 = 旧版本作废 + 新版本插到堆尾,物理顺序本来就会变),于是每保存
+     * 一次,屏上的表就重排一次。
+     *
+     * `seq` 是 `bigserial`(迁移 0036):**insert 那一刻取号,upsert 的 update 分支不碰它**
+     * —— 记的正是「这一行是第几个被写下的」。而配方铺行的顺序就是人期望在件上看到的
+     * 顺序(原 PN 的参数在前、候选的在后,组内按字典序 —— 配方那么遍历的)。
+     * 单键、严格全序、没有并列,也就没有「并列之间谁先谁后」这种不确定。
+     */
     async list(taskId) {
       const res = await runner.query<DraftRow>(
-        `select * from ${DRAFT_TABLE} where task_id = $1 order by updated_at`,
+        `select * from ${DRAFT_TABLE} where task_id = $1 order by seq`,
         [taskId],
       );
       return res.rows.map(toEntry);
     },
     async listForObject(taskId, ref) {
       const res = await runner.query<DraftRow>(
-        `select * from ${DRAFT_TABLE} where task_id = $1 and domain = $2 and object = $3 order by updated_at`,
+        `select * from ${DRAFT_TABLE} where task_id = $1 and domain = $2 and object = $3 order by seq`,
         [taskId, ref.domain, ref.object],
       );
       return res.rows.map(toEntry);

apps/api/src/modules/loop-engine/CONTRACT.md

@@ -177,6 +177,16 @@
     跳过的行照旧算「这一笔要的行」,`prune` 不许撤它。
 - `writable` 多一个可选 `caseKey`(单标识列):摆给人看的行标识要**去掉单号那一段**
   (2026-08-25 那条口径,基座那一侧是 `rowLabel`)—— 人正在这一单里看,单号是脚下的地面。
+- `draftDrop` 多一个可选入参 `skipLanded` 与可选出参 `landed`(2026-08-31,同族第三个旗):
+  已随「数据工单确认即入库」落地的行,配方 `prune` 传 `skipLanded` 时回 `{dropped:false, landed:true}`
+  而不是抛 —— 已落地 = 已是世界的一部分,不是陈旧草稿,跳过是配方的常态;抛出去就是整单停摆
+  (2026-08-30 e2e 案例 2 的死锁,当时以「W05 ②③ 两笔不带 prune」绕开,代价是**没落地的**
+  陈旧行也不清 —— 2026-08-31 用户实测点名的「改回同一类型,下面还是两个类型」)。
+  模型那一路不传:那句「已入库撤不掉」的拒回是它的行动指南,一个字不变。
+- 配方 `card` 多两个可选键 `gateWhen` / `gateWhenSay`(2026-08-31):确认闸的**条件档** ——
+  除了「必填缺几格」,发卡的人还可声明一条 S-FEEL 条件(只读基座读数,装包静态审同
+  `when` 一套审),受理回传前在 app 层 `submitGate` 现算,为假不受理、拒回用发卡人那句话
+  (W05 第一例:两颗料不是同一个芯片类型不许确认)。运行时评估不出的条件不成墙。
 
 同批三条不变量:
 - **配方由 `liveStep` 驱动,不由 `current` 的兜底驱动**:兜底(在场的第一个有剧本的项)不过滤

apps/api/src/modules/loop-engine/__tests__/auto-runner.test.ts

@@ -103,8 +103,14 @@ function harness(seed: Record<string, unknown> = {}, override: { analyze?: Analy
         });
         return Promise.resolve({ changed });
       },
-      draftDrop: (i: { domain: string; object: string; key: Record<string, string> }) => {
+      draftDrop: (i: { domain: string; object: string; key: Record<string, string>; skipLanded?: boolean }) => {
         const id = `${i.domain}.${i.object}|${Object.values(i.key).join('|')}`;
+        /* 生产真有的落地守卫(engines.ts):已落地的行,配方带 skipLanded 就跳过,别的路硬拒 */
+        const row = drafts.get(id);
+        if (row?.landed === true) {
+          if (i.skipLanded === true) return Promise.resolve({ dropped: false, landed: true });
+          return Promise.reject(new Error('这一行是本单在数据工单里建好、人确认后已入库的,撤不掉'));
+        }
         return Promise.resolve({ dropped: drafts.delete(id) });
       },
     },
@@ -244,6 +250,28 @@ describe('配方执行器', () => {
     expect(line).not.toContain('W05-1');
   });
 
+  it('prune:已落地的陈旧行跳过不炸,没落地的照撤(2026-08-31 skipLanded)', async () => {
+    const { runner, drafts, notes, ctx } = harness({});
+    /* 铺 A、B、C 三行;B 随「数据工单确认即入库」落了地(landed),B、C 随后都不在投影源里了 */
+    await runner.run(
+      { do: [{ kind: 'project', into: 'sub_eval.part', from: { rows: [{ pn: 'A' }, { pn: 'B' }, { pn: 'C' }] }, fields: { eval_ref: 'W05-1', internal_pn: { col: 'pn' } } }] },
+      ctx,
+    );
+    for (const d of drafts.values()) if (d.key['internal_pn'] === 'B') d.landed = true;
+    const out = await runner.run(
+      { do: [{ kind: 'project', into: 'sub_eval.part', prune: true, from: { rows: [{ pn: 'A' }] }, fields: { eval_ref: 'W05-1', internal_pn: { col: 'pn' } } }] },
+      ctx,
+    );
+    /* 不炸(从前这里整个配方抛错停摆);C(没落地)撤掉,B(已落地)原地留下 */
+    expect(out.failedAt).toBeUndefined();
+    expect(out.dropped).toBe(1);
+    expect([...drafts.values()].map((d) => d.key['internal_pn']).sort()).toEqual(['A', 'B']);
+    const line = notes.find((n) => n.includes('撤掉 1 行'));
+    expect(line).toContain('撤掉 1 行(C)');
+    /* 跳过也要出声:B 已入库、这一笔不清它 —— 实情说给人听(debt 那条的原话要求) */
+    expect(line).toContain('1 行已随数据工单入库、这一笔不清它');
+  });
+
   it('say:进工作日志,归系统', async () => {
     const { runner, notes, ctx } = harness({ n: 2 });
     await runner.run({ do: [{ kind: 'say', text: { cat: ['已核对 ', { in: 'n' }, ' 颗料'] } }] }, ctx);
@@ -370,6 +398,8 @@ describe('card 与 submit', () => {
             standard: '必填格全部填上,红带消失',
             basis: [{ k: '候选料号', v: { in: 'pn' } }],
             gateLedgers: ['parts.profile', 'parts.parameter'],
+            gateWhen: 'parts_profile_distinct_chip_type_id <= 1',
+            gateWhenSay: '两颗料不是同一个芯片类型 —— 先改对再确认。',
           },
         ],
       },
@@ -387,6 +417,9 @@ describe('card 与 submit', () => {
         standard: '必填格全部填上,红带消失',
         basis: [{ k: '候选料号', v: 'XL2596S-5.0' }],
         gateLedgers: ['parts.profile', 'parts.parameter'],
+        /* 确认闸条件档随卡走(2026-08-31)—— 服务端 submitGate 靠它拦「类型不一致还确认」 */
+        gateWhen: 'parts_profile_distinct_chip_type_id <= 1',
+        gateWhenSay: '两颗料不是同一个芯片类型 —— 先改对再确认。',
         fields: [],
       },
     });
@@ -465,6 +498,38 @@ describe('配方留痕真的到得了工作日志(spec §5.9 验收 · R10)', ()
     expect(appended[0]?.detail?.['internal']).toBeUndefined();
   });
 
+  /**
+   * **人正在件上填的那几拍(quiet),say 不上对话区**(2026-08-31 用户:「每次保存的时候
+   * 右边也会出现 ai 推进中,然后会说一句话,能不能把这个也取消掉」)。
+   *
+   * 件上按保存会 `wake` 这一单(「保存即铺格」),配方跟着跑一趟 quiet —— 而 quiet 只跑
+   * project 与 say,于是人按几次保存,同一句交代就往对话区说几遍。对话区的纪律是
+   * **一轮一句,不是一拍一句**(2026-08-01),而 quiet 拍压根没有交出控制权(人正对着
+   * 那张卡填),算不上新一轮。
+   *
+   * 压下去不是丢掉:`internal` 是两个投影共用的一个旗(终审 I5/F2)。这一条钉住的是
+   * **前一半**(quiet → 标 internal,而工作日志按 `detail.auto` 照旧放行);
+   * **后一半**(标了 internal 就进不了对话区)钉在
+   * `apps/api/src/modules/interaction/__tests__/chat-projection.test.ts`
+   * 「引擎内部观察(internal 标)进日志不进对话」那一条 —— `projectChat` 没出模块边界,
+   * 跨模块深入 internal 会被 depcruise 拦,两半各钉在自己模块里。
+   */
+  it('**quiet 拍的 say:标 internal(对话区据此挡住),而工作日志照旧看得见**', async () => {
+    const { runner, appended, ctx } = harness({ n: 2 });
+    await runner.run(
+      { do: [{ kind: 'say', text: { cat: ['已核对 ', { in: 'n' }, ' 颗料'] } }] },
+      { ...ctx, quiet: true, carded: true },
+    );
+    expect(appended).toHaveLength(1);
+    expect(appended[0]?.detail?.['internal']).toBe(true);
+    /* 话本身没丢:`detail.auto` 那条例外让它留在工作日志里(值有插值时也查得到) */
+    expect(appended[0]?.title).toBe('已核对 2 颗料');
+    expect(typeof appended[0]?.detail?.['auto']).toBe('string');
+    const lines = structuredLog([asLogEntry(appended[0]!)]);
+    expect(lines).toHaveLength(1);
+    expect(lines[0]?.who).toBe('system');
+  });
+
   it('project 那一笔:进日志且归系统,**而且标着 internal(对话区那一侧据此挡住)**', async () => {
     const { runner, appended, ctx } = harness({});
     await runner.run(
@@ -735,6 +800,23 @@ describe('prune:人在填的时候不撤行(F3)', () => {
     expect(out.dropped).toBe(1);
     expect([...drafts.values()].map((d) => d.key['internal_pn'])).toEqual(['A']);
   });
+
+  /*
+   * `prune: 'live'`(2026-08-31):quiet 拍也撤 —— 只给**人不会在件上加行**的表用
+   * (行集全由配方铺,如 W05 参数骨架):F3 防的是「人刚加的行被撤」,人加不了行的表
+   * 没有这个风险;而「改了类型,旧类型的参数行还摆在屏上」是另一种撒谎(用户实测点名
+   * 「只会跟着变多,不会跟着变少」)—— 跟手比守候更诚实。
+   */
+  it("prune:'live' 在 quiet 拍也对齐 —— 人加不了行的表,改选后旧行跟手消失", async () => {
+    const { runner, drafts, ctx } = harness({});
+    await runner.run(SEED, ctx);
+    const out = await runner.run(
+      { do: [{ kind: 'project', into: 'sub_eval.part', prune: 'live', from: { rows: [{ pn: 'A' }] }, fields: { eval_ref: 'W05-1', internal_pn: { col: 'pn' } } }] },
+      { ...ctx, quiet: true },
+    );
+    expect(out.dropped).toBe(1);
+    expect([...drafts.values()].map((d) => d.key['internal_pn'])).toEqual(['A']);
+  });
 });
 
 /**

apps/api/src/modules/loop-engine/internal/usecase/auto-runner.ts

@@ -125,12 +125,24 @@ export function createAutoRunner(deps: AutoRunnerDeps): {
            * 而 `result` 不在 `task-log.ts` 的 `SKELETON` 里,这一笔永远进不了工作日志
            * (spec §5.9 承诺「配方每一笔照常进 task_memory,工作日志里归系统灰」落空)。
            * `observation` 在骨架里;不带 `detail.say` 时 `actorOf` 本就归系统。
+           *
+           * **人正在件上填的那几拍(quiet),这句话不上对话区**(2026-08-31 用户:
+           * 「每次保存的时候右边也会出现 ai 推进中,然后会说一句话,能不能把这个也取消掉」)。
+           * 对话区的纪律是**一轮一句,不是一拍一句**(2026-08-01):只有**交出控制权**
+           * 那一拍的交代摆到人面前。而 quiet 拍恰恰没有交出控制权 —— 控制权本来就在
+           * 人手上(他正对着这张件填),配方这一趟只是按最新草稿把行铺好;人按几次保存
+           * 就跑几趟,同一句话跟着说几遍,那是纯噪音。
+           * 压下去不是丢掉:`internal` 是两个投影共用的一个旗(终审 I5/F2)——
+           * `chat-projection` 据此挡住对话区,而 `task-log.machinery()` 对 `detail.auto`
+           * 开了例外,这一笔在**工作日志里照旧看得见**(话有插值时值的变化也查得到)。
            */
           await deps.memory.append({
             taskId: context.taskId,
             kind: 'observation',
             title: evalText(action.text, base),
-            detail: { auto: `${context.stepId}#${index + 1}` },
+            detail: context.quiet
+              ? { auto: `${context.stepId}#${index + 1}`, internal: true }
+              : { auto: `${context.stepId}#${index + 1}` },
           });
           return { wrote: 0, dropped: 0 };
         }
@@ -196,6 +208,8 @@ export function createAutoRunner(deps: AutoRunnerDeps): {
             kept.add(keyText(key));
           }
           let localDropped = 0;
+          /** 已随「数据工单确认」落地、prune 不动它的行数 —— 跳过要说给人听(debt 那条的原话要求) */
+          let localLandedKept = 0;
           /*
            * **人正在件上编辑的时候不 prune**(2026-08-29 终审 F3)。
            * `prune` 的语义是「这一笔投影出来的行就是这张表的全部,多出来的撤掉」——
@@ -204,19 +218,30 @@ export function createAutoRunner(deps: AutoRunnerDeps): {
            * (2026-08-02 为人工撤行立过「撤要说出来、要点名哪几行」的规矩,这里连说都没说)。
            * 有卡在等人(quiet)= 人正对着这张件填,这一拍只铺不撤;等他交回之后那一拍再对齐。
            */
-          if (action.prune === true && !context.quiet) {
+          /* true:非 quiet 拍才撤(F3,人正编辑不动他的行);'live':quiet 也撤 ——
+             只给人不会在件上加行的表用(契约注释与静态审都写着),跟手比守候更诚实 */
+          if (action.prune === 'live' || (action.prune === true && !context.quiet)) {
             for (const stale of before) {
               const key: Record<string, string> = {};
               for (const column of decl.keys) key[column] = String(stale[column] ?? '');
               if (kept.has(keyText(key))) continue;
-              const { dropped: gone } = await deps.data.draftDrop({ taskId: context.taskId, domain: decl.domain, object: decl.object, key });
+              /*
+               * `skipLanded`:已随「数据工单确认」落进正式表的行不撤、也不炸(2026-08-31)。
+               * 从前这里不传,已落地的陈旧行让整个配方抛错停摆(2026-08-30 e2e 案例 2),
+               * ②③ 那两笔被迫整个放弃 prune —— 连**没落地的**陈旧行(人改了类型选择,
+               * 旧类型的字典/字段行)也跟着积在屏上。现在已落地的原地留下(它是世界的
+               * 一部分),没落地的照撤 —— 两种行各得其所。
+               */
+              const { dropped: gone, landed } = await deps.data.draftDrop({ taskId: context.taskId, domain: decl.domain, object: decl.object, key, skipLanded: true });
               if (gone) {
                 localDropped += 1;
                 dropNames.push(rowName(key, decl.caseKey));
+              } else if (landed === true) {
+                localLandedKept += 1;
               }
             }
           }
-          if (localWrote > 0 || localDropped > 0 || localExisting > 0 || localUnkeyed > 0) {
+          if (localWrote > 0 || localDropped > 0 || localExisting > 0 || localUnkeyed > 0 || localLandedKept > 0) {
             /*
              * **kind: 'observation' + `internal: true`**(2026-08-29 终审 I5,控制端裁定 F2)。
              * `kind` 必须是 `observation`:`result` 不在 `task-log.ts` 的 `SKELETON` 里,进不了工作日志(R10)。
@@ -241,7 +266,9 @@ export function createAutoRunner(deps: AutoRunnerDeps): {
                 /* 撤了要点名(M2):不点名的话,下一拍的读者(人或模型)对不上是哪几行没了 */
                 (localDropped === 0 ? '' : `,撤掉 ${localDropped} 行(${nameList(dropNames)})`) +
                 /* 少写了几行要出声(M1):静默 continue 的那几行,表里少了谁也查不出为什么 */
-                (localUnkeyed === 0 ? '' : `,${localUnkeyed} 行因主键算不出来没写(主键列:${decl.keys.join('、')})`),
+                (localUnkeyed === 0 ? '' : `,${localUnkeyed} 行因主键算不出来没写(主键列:${decl.keys.join('、')})`) +
+                /* 已落地的陈旧行跳过也要出声 —— 「这几行已经入库、这一笔没法帮你清」的实情说给人听 */
+                (localLandedKept === 0 ? '' : `,${localLandedKept} 行已随数据工单入库、这一笔不清它`),
               detail: {
                 auto: `${context.stepId}#${index + 1}`,
                 ledger: action.into,
@@ -344,6 +371,9 @@ export function createAutoRunner(deps: AutoRunnerDeps): {
               ...(action.guide === undefined ? {} : { steps: [...action.guide] }),
               ...(action.standard === undefined ? {} : { standard: evalText(action.standard, base) }),
               ...(action.gateLedgers === undefined ? {} : { gateLedgers: [...action.gateLedgers] }),
+              ...(action.gateWhen === undefined ? {} : { gateWhen: action.gateWhen }),
+              
+              ...(action.gateWhenSay === undefined ? {} : { gateWhenSay: action.gateWhenSay }),
             },
           });
           return { wrote: 0, dropped: 0, cardId: id, stop: true };
@@ -384,7 +414,11 @@ export function createAutoRunner(deps: AutoRunnerDeps): {
           }
           const base: ExprCtx = { scope, lets, condition };
           if (action.when !== undefined && !condition(action.when, { ...scope, ...lets })) continue;
-          /* 有卡在等人交回:只算、只写 —— 不发新卡、不 submit、不 analyze */
+          /*
+           * 有卡在等人交回:只算、只写 —— 不发新卡、不 submit、不 analyze。
+           * `say` 照跑但**落成 internal**(见 runAction 里 say 那一段):话要留痕,
+           * 只是不摆到对话区上去 —— 人正在填,这一趟没有新一轮可言。
+           */
           if (ctx.quiet && action.kind !== 'project' && action.kind !== 'say') continue;
 
           const done = await runAction(action, index, base, ctx);

apps/api/src/modules/loop-engine/port.ts

@@ -92,7 +92,19 @@ export type TaskDataGateway = {
     domain: string;
     object: string;
     key: Record<string, string | number>;
-  }): Promise<{ dropped: boolean }>;
+    /**
+     * **已落地的行:跳过,不拒**(2026-08-31,配方专用 —— 与 `draftWrite` 的两个旗同族)。
+     * 「数据工单确认即入库」把行落进正式表后,草稿层那一笔只是「本单写过它」的记号;
+     * 撤记号正式表一个字不动,读面反而少一行 —— 所以对人/模型那一路它是硬拒(拒回是
+     * 行动指南)。而配方 `prune` 的语义是「陈旧的投影行清掉」:已落地 = 已经是世界的
+     * 一部分,不是陈旧草稿 —— 对配方来说跳过是常态,抛错就是整单停摆(2026-08-30
+     * e2e 案例 2 的死锁:人确认入库后改了类型选择,prune 想撤已落地的旧类型行,当场炸;
+     * 当时以「②③ 不带 prune」绕开,代价是**没落地的**陈旧行也跟着不清了 ——
+     * 2026-08-31 用户实测点名的「改回同一类型,下面还是两个类型」正是这半截代价)。
+     * 模型那一路不传这个旗:行为一个字不变。
+     */
+    skipLanded?: boolean | undefined;
+  }): Promise<{ dropped: boolean; landed?: boolean }>;
 };
 
 /**

apps/web/src/features/desk-task/__tests__/pending-cards.test.ts

@@ -4,7 +4,7 @@
 import { describe, expect, it } from 'vitest';
 import { dataEntryCardSchema, decisionCardSchema } from '@contracts';
 import type { TaskDetail } from '@contracts';
-import { pendingCardsOf } from '../internal/pending-cards.ts';
+import { awaitingHuman, pendingCardsOf } from '../internal/pending-cards.ts';
 
 const AT = '2026-08-28T00:55:30.054Z';
 
@@ -66,3 +66,40 @@ describe('pendingCardsOf', () => {
     expect(pendingCardsOf(chat(entry('c-1'), later)).entryLedger).toBe('客户档案');
   });
 });
+
+/**
+ * **有活等着人办就不摆推进场景**(2026-08-31 用户:「在中央工作区修改了内容点击保存后,
+ * 为什么会出现『AI 正在推进这单』」)。
+ *
+ * 件上按保存走 `afterSave`:**先重推件、再叫醒任务**(「保存即铺格」)。叫醒把 runtime
+ * 拨成 `running`,而工作区的 `running` 判据压过 `viewHtml` —— 人刚填完按保存,屏上那份
+ * 刚重推的件被推进场景顶掉几秒;而那一拍按「叫了人就等人」的闸根本不问模型,那一屏
+ * 写的「看材料、写台账、调工具」一件没发生。这一组钉的就是那道新条件。
+ */
+describe('awaitingHuman:这一单还有活等着人办吗', () => {
+  const none = { decision: false, entry: false } as const;
+
+  it('没工单没卡 —— AI 真在埋头算,推进场景照旧摆(2026-08-21 要的正是它)', () => {
+    expect(awaitingHuman({ openOrders: 0, cards: none })).toBe(false);
+  });
+
+  it('有工单没办结 —— 人正要在件上填,不许拿推进场景盖掉件', () => {
+    expect(awaitingHuman({ openOrders: 1, cards: none })).toBe(true);
+  });
+
+  it('决策卡还没选 —— 人要决定的对象常常就是件上那份稿,件得留着', () => {
+    expect(awaitingHuman({ openOrders: 0, cards: { decision: true, entry: false } })).toBe(true);
+  });
+
+  it('录入卡还没确认 —— 让位给录入占位页那一支(它排在 running 之后)', () => {
+    expect(awaitingHuman({ openOrders: 0, cards: { decision: false, entry: true, entryLedger: '客户档案' } })).toBe(true);
+  });
+
+  it('工单全办结、卡全答过 —— 回到「AI 真在算」,推进场景该摆', () => {
+    expect(awaitingHuman({ openOrders: 0, cards: none })).toBe(false);
+  });
+
+  it('三样都在 —— 仍是「等人」,不是「AI 在推进」', () => {
+    expect(awaitingHuman({ openOrders: 2, cards: { decision: true, entry: true, entryLedger: '客户档案' } })).toBe(true);
+  });
+});

apps/web/src/features/desk-task/internal/TaskChat.tsx

@@ -14,6 +14,7 @@ import { call } from '@web-shared/typed-fetch.ts';
 import { Ico } from '@web-shared/Ico.tsx';
 import { EmptyState } from '@web-shared/desk/module-kit.tsx';
 import { ChatStream, WorkingStrip } from './chat-bubbles.tsx';
+import { awaitingHuman, pendingCardsOf } from './pending-cards.ts';
 import { Btn } from '@web-shared/Btn.tsx';
 
 export function TaskChat({
@@ -43,8 +44,20 @@ export function TaskChat({
    * AI 正在办这单 = Loop 在自己转(runtime running)。
    * 等人(awaiting-human)、等外部(awaiting-event)、已收尾都不算 ——
    * 那时亮「工作中」就是撒谎:环没在转,是在等。
+   *
+   * **`&& !awaitingHuman(...)` 是 2026-08-31 补的**(用户:「每次保存的时候右边也会
+   * 出现 ai 推进中」):件上按保存会 `wake` 这一单(「保存即铺格」,不叫醒参数格永远
+   * 不出现)—— runtime 就此被拨成 `running`,而人其实正对着卡在填。上面这三句话说的
+   * 原则没变,变的是「等人」这件事从此不只看 runtime:**有未办结的工单 / 未回的卡,
+   * 就是在等人**,哪怕 runtime 写着 running。工作区那一侧同一个判断、同一个函数。
    */
-  const working = detail.card.terminal === undefined && detail.card.runtime === 'running';
+  const working =
+    detail.card.terminal === undefined &&
+    detail.card.runtime === 'running' &&
+    !awaitingHuman({
+      openOrders: detail.workOrders.filter((o) => o.done === undefined).length,
+      cards: pendingCardsOf(detail.chat),
+    });
 
   /** 回传后一律重取任务投影 —— 卡与工单的状态由服务端说,前端不自行推演 */
   const refresh = () => {

apps/web/src/features/desk-task/internal/ViewRegion.tsx

@@ -21,7 +21,7 @@ import ScrollArea from '@web-shared/ScrollArea.tsx';
 import { EmptyState } from '@web-shared/desk/module-kit.tsx';
 import { ViewBlocks, ViewContainer } from '@ui';
 import { pagerFace, pagerText } from './pager.ts';
-import { pendingCardsOf } from './pending-cards.ts';
+import { awaitingHuman, pendingCardsOf } from './pending-cards.ts';
 import type { ViewEdits, ViewSave } from '@ui';
 import { GuideCard, WorkOrderReport } from './work-order-report.tsx';
 import { FileViewer } from './FileViewer.tsx';
@@ -176,6 +176,8 @@ export function ViewRegion({ detail, onReplyOrder, values, onField, locate }: Vi
    */
   const pending = pendingCardsOf(detail.chat);
   const pendingChatCard = pending.decision || pending.entry;
+  /* 这一单还有活等着人办吗 —— 推进场景要不要摆看它(缘由见 `awaitingHuman` 的头注) */
+  const holding = awaitingHuman({ openOrders: openList.length, cards: pending });
 
   /*
    * 标记已读 / 未读 —— 乐观更新交给失效:标完服务端广播 task 触点,
@@ -763,7 +765,7 @@ export function ViewRegion({ detail, onReplyOrder, values, onField, locate }: Vi
               desc="成果正在并进正式表、按去向发往下游。落完这一屏会换成收尾结果 —— 不用刷新。"
               hint="通常几秒钟"
             />
-          ) : detail.card.runtime === 'running' ? (
+          ) : detail.card.runtime === 'running' && !holding ? (
             /*
              * **AI 正在算这一拍,不是「已经有一份件摆着」**(2026-08-21 用户:
              * 「AI 持续推进中时中间的页面不变成持续推进的页面了,而是卡在 html
@@ -774,6 +776,14 @@ export function ViewRegion({ detail, onReplyOrder, values, onField, locate }: Vi
              * 空待处理就被这份**陈旧**的件抢先占住,推进中动画再也显示不出来。
              * **正在跑的这一拍,永远比上一拍摆下的旧件优先**:running 判据挪到
              * viewHtml 前面,陈旧的件只在「AI 这会儿不在算」时才配拿来顶上。
+             *
+             * **`&& !holding` 是 2026-08-31 补的**(用户:「在中央工作区修改了内容点击
+             * 保存后,为什么会出现『AI 正在推进这单』」):上面那段的前提是「viewHtml 是
+             * 上一次推的,可能陈旧」。而件上按保存走的 `afterSave` 是**先重推件、再叫醒
+             * 任务**(「保存即铺格」)—— 那条路上件比 `running` 还新,顶掉它没有道理;
+             * 且那一拍按「叫了人就等人」的闸根本不问模型,这一屏写的「看材料、写台账、
+             * 调工具都由它来」一件没发生。**有活等着人办就不摆推进场景**,判断收在
+             * `awaitingHuman` 里(与服务端 `humanTool.pendingCards` 同一句话)。
              */
             <WorkingScene doneN={doneList.length} />
           ) : pending.entry ? (

apps/web/src/features/desk-task/internal/chat-bubbles.tsx

@@ -1051,7 +1051,8 @@ function ExecForm({ order, onReplyOrder, onLocate, orderValues, onField, face =
         </button>
         <p className="jc-fc-q">{order.ask}</p>
         <Guide steps={order.steps} standard={order.standard} />
-        {order.basis.length > 0 && <Kv items={order.basis} />}
+        {/* 参考信息不再上卡(2026-08-31 用户定:「派发的工单参考信息这个板块不要显示」)——
+            basis 数据照旧随卡走(工单详情 / 归档件仍有),只是对话区这张卡不摆 */}
         {order.fields.map((f) => (
           <label key={f.key} className="jc-fc-fld">
             <span>

apps/web/src/features/desk-task/internal/pending-cards.ts

@@ -23,6 +23,32 @@ export type PendingCards = {
   readonly entryLedger?: string;
 };
 
+/**
+ * **这一单还有活等着人办吗** —— 未办结的工单,或未回的决策卡 / 录入卡。
+ *
+ * 与服务端 `humanTool.pendingCards`(没办结工单 + 没作答且没被顶替的对话卡)说的是
+ * 同一句话,两侧各按自己手上的数据算。
+ *
+ * 用处(2026-08-31 用户:「在中央工作区修改了内容点击保存后,为什么会出现『AI 正在
+ * 推进这单』」):件上按保存会走 `afterSave` —— **先重推件、再叫醒任务**
+ * (「保存即铺格」:人选了芯片类型按保存,配方这才有机会把参数行铺出来;不叫醒
+ * 格子永远不出现,2026-08-30 走查在这儿卡死过)。叫醒把 runtime 拨成 `running`,
+ * 而工作区的 `running` 判据排在 `viewHtml` 前面(2026-08-21:正在跑的这一拍要压过
+ * 上一拍摆下的**陈旧**的件)—— 于是人刚填完按下保存,屏上那份**刚重推、含着他刚填
+ * 的值**的件被「AI 正在推进这单」顶掉几秒。
+ * 那条 2026-08-21 的规则前提是「viewHtml 是上一次推的,可能陈旧」,而这条路上件比
+ * `running` 还新,前提不成立;更要紧的是那一拍按「叫了人就等人」的闸
+ * (`turn-runner`,2026-08-27)**根本不问模型**,推进场景写着「看材料、写台账、调工具
+ * 都由它来」——那些事一件没发生,**界面在撒谎**。
+ *
+ * 所以:**有活等着人办时不摆推进场景**(件 / 录入占位页照旧摆,人正要在上面办事);
+ * 没有任何卡在等人、AI 真在埋头算下一拍时,推进场景照旧 —— 那正是 2026-08-21 要的。
+ * 与服务端那条闸是同一条道理的两侧:**有未答的卡,服务端就不问模型,前端就不说 AI 在推进。**
+ */
+export function awaitingHuman(input: { readonly openOrders: number; readonly cards: PendingCards }): boolean {
+  return input.openOrders > 0 || input.cards.decision || input.cards.entry;
+}
+
 export function pendingCardsOf(chat: TaskDetail['chat']): PendingCards {
   let decision = false;
   let entryLedger: string | undefined;

apps/web/src/features/gov-task/__tests__/launch-link.test.ts

@@ -0,0 +1,125 @@
+/**
+ * 启动参数的按分组联动(2026-08-31 用户定:原内部料号 / 候选内部料号按芯片类型互相收窄)。
+ *
+ * 三条口径由用户当场定死:
+ *   ①**组内第一个填上值的那格是锚**,锚自己永远摆全量;锚粘着不让位 —— 把它清空,收窄整组解除
+ *     (不把锚顺手交给另一格,否则「清空锚再改主意」当场被另一格锁住);整组都空了才重新认锚。
+ *   ②未标类型的老料**列在末尾单独一组**,不是不列。
+ *   ③锚改了类型之后,另一格里失配的值**清空**(人自己新增的值不动 —— 它压根不在候选里)。
+ */
+import { describe, expect, it } from 'vitest';
+import type { LaunchParam } from '@contracts';
+import { comboFace, nextAnchors, staleLinked } from '../internal/launch-link.ts';
+
+const OPTIONS = [
+  { value: 'LM2596S-5.0', label: 'LM2596S-5.0', group: '1', groupLabel: 'DC-DC 降压稳压器' },
+  { value: 'XL2596S-5.0', label: 'XL2596S-5.0', group: '1', groupLabel: 'DC-DC 降压稳压器' },
+  { value: 'AMS1117-3.3', label: 'AMS1117-3.3', group: '2', groupLabel: 'LDO 线性稳压器' },
+  { value: 'OLD-001', label: 'OLD-001', group: '' },
+];
+const combo = (key: string, label: string): LaunchParam => ({ key, label, type: 'combo', required: true, options: OPTIONS, linkGroup: 'chip-type' });
+const PARAMS: LaunchParam[] = [combo('originalInternalPn', '原内部料号'), combo('candidateInternalPn', '候选内部料号')];
+/** 不联动的一格:同一张表上还有别的 combo,不该被卷进来 */
+const LOOSE: LaunchParam = { key: 'customerCode', label: '客户', type: 'combo', options: [{ value: 'CU-0142', label: 'Itelma' }] };
+
+const face = (key: string, values: Record<string, string>, anchors: Record<string, string> = {}) =>
+  comboFace(PARAMS.find((p) => p.key === key)!, [...PARAMS, LOOSE], values, anchors);
+
+describe('nextAnchors —— 谁是锚', () => {
+  it('组内第一个填上值的那格入座;另一格随后填上也不改朝换代', () => {
+    const first = nextAnchors(PARAMS, { originalInternalPn: 'LM2596S-5.0', candidateInternalPn: '' }, {});
+    expect(first).toEqual({ 'chip-type': 'originalInternalPn' });
+    expect(nextAnchors(PARAMS, { originalInternalPn: 'LM2596S-5.0', candidateInternalPn: 'XL2596S-5.0' }, first)).toEqual(first);
+  });
+
+  it('先填候选那格,锚就是它(反过来一样)', () => {
+    expect(nextAnchors(PARAMS, { originalInternalPn: '', candidateInternalPn: 'XL2596S-5.0' }, {})).toEqual({ 'chip-type': 'candidateInternalPn' });
+  });
+
+  it('**锚粘着**:把锚清空,收窄整组解除 —— 不把锚顺手交给还填着值的另一格', () => {
+    const anchors = { 'chip-type': 'originalInternalPn' };
+    const after = nextAnchors(PARAMS, { originalInternalPn: '', candidateInternalPn: 'XL2596S-5.0' }, anchors);
+    expect(after).toEqual(anchors);
+    // 锚空着 = 没有可收窄的依据:另一格摆全量(四条,分两类 + 未标类型)
+    expect(face('candidateInternalPn', { originalInternalPn: '', candidateInternalPn: 'XL2596S-5.0' }, after).narrow).toBeUndefined();
+  });
+
+  it('整组都空了才重新认锚 —— 这次谁先填谁当', () => {
+    const anchors = { 'chip-type': 'originalInternalPn' };
+    const cleared = nextAnchors(PARAMS, { originalInternalPn: '', candidateInternalPn: '' }, anchors);
+    expect(cleared).toEqual({});
+    expect(nextAnchors(PARAMS, { originalInternalPn: '', candidateInternalPn: 'AMS1117-3.3' }, cleared)).toEqual({ 'chip-type': 'candidateInternalPn' });
+  });
+});
+
+describe('comboFace —— 这一格摆哪些候选', () => {
+  it('没有锚:全量,按类型分组,**未标类型殿后**', () => {
+    const f = face('originalInternalPn', {});
+    expect(f.narrow).toBeUndefined();
+    expect(f.groups.map((g) => [g.label, g.options.map((o) => o.value)])).toEqual([
+      ['DC-DC 降压稳压器', ['LM2596S-5.0', 'XL2596S-5.0']],
+      ['LDO 线性稳压器', ['AMS1117-3.3']],
+      ['未标类型', ['OLD-001']],
+    ]);
+  });
+
+  it('锚自己永远摆全量 —— 人想换类型,回去改锚就行', () => {
+    const anchors = { 'chip-type': 'originalInternalPn' };
+    const f = face('originalInternalPn', { originalInternalPn: 'LM2596S-5.0' }, anchors);
+    expect(f.narrow).toBeUndefined();
+    expect(f.groups.flatMap((g) => g.options.map((o) => o.value))).toEqual(['LM2596S-5.0', 'XL2596S-5.0', 'AMS1117-3.3', 'OLD-001']);
+  });
+
+  it('另一格按锚的类型收窄:同类型在前、未标类型殿后;点名按谁的什么类型收的', () => {
+    const f = face('candidateInternalPn', { originalInternalPn: 'LM2596S-5.0' }, { 'chip-type': 'originalInternalPn' });
+    expect(f.narrow).toEqual({ by: '原内部料号', label: 'DC-DC 降压稳压器' });
+    expect(f.groups.map((g) => [g.label, g.options.map((o) => o.value)])).toEqual([
+      ['DC-DC 降压稳压器', ['LM2596S-5.0', 'XL2596S-5.0']],
+      ['未标类型', ['OLD-001']],
+    ]);
+  });
+
+  it('**锚本身没有类型**(未标类型的老料)→ 另一格摆全部(用户原话)', () => {
+    const f = face('candidateInternalPn', { originalInternalPn: 'OLD-001' }, { 'chip-type': 'originalInternalPn' });
+    expect(f.narrow).toBeUndefined();
+    expect(f.groups.flatMap((g) => g.options)).toHaveLength(4);
+  });
+
+  it('**锚填的是新增料号**(库里没有这个值)→ 收窄无从谈起,另一格摆全部', () => {
+    const f = face('candidateInternalPn', { originalInternalPn: 'BRAND-NEW-PN' }, { 'chip-type': 'originalInternalPn' });
+    expect(f.narrow).toBeUndefined();
+    expect(f.groups.flatMap((g) => g.options)).toHaveLength(4);
+  });
+
+  it('类型只有键没有名(字典读不到)→ 分组标题退回摆键本身,不编一个名字', () => {
+    const bare: LaunchParam = { ...PARAMS[1]!, options: [{ value: 'A', label: 'A', group: '7' }] };
+    const f = comboFace(bare, [PARAMS[0]!, bare], {}, {});
+    expect(f.groups.map((g) => g.label)).toEqual(['7']);
+  });
+
+  it('不联动的 combo(没有 linkGroup / 候选不带分组键)→ 一组无标题,谁也不管它', () => {
+    const f = comboFace(LOOSE, [...PARAMS, LOOSE], { originalInternalPn: 'LM2596S-5.0' }, { 'chip-type': 'originalInternalPn' });
+    expect(f.narrow).toBeUndefined();
+    expect(f.groups).toEqual([{ label: undefined, options: LOOSE.options }]);
+  });
+});
+
+describe('staleLinked —— 锚换了类型,另一格里失配的值', () => {
+  it('在全量候选里、却不在收窄后的候选里 → 点名清空', () => {
+    expect(staleLinked(PARAMS, { originalInternalPn: 'AMS1117-3.3', candidateInternalPn: 'XL2596S-5.0' }, { 'chip-type': 'originalInternalPn' })).toEqual(['candidateInternalPn']);
+  });
+
+  it('同类型的、未标类型的、人自己新增的、空的 —— 一个都不动', () => {
+    const anchors = { 'chip-type': 'originalInternalPn' };
+    const keep = (candidate: string) => staleLinked(PARAMS, { originalInternalPn: 'LM2596S-5.0', candidateInternalPn: candidate }, anchors);
+    expect(keep('XL2596S-5.0')).toEqual([]);
+    expect(keep('OLD-001')).toEqual([]);
+    // 新增的值压根不在候选里 —— 它是人自己写的新料号,不是失配的旧选择
+    expect(keep('BRAND-NEW-PN')).toEqual([]);
+    expect(keep('')).toEqual([]);
+  });
+
+  it('锚自己不算失配(它摆的就是全量)', () => {
+    expect(staleLinked(PARAMS, { originalInternalPn: 'AMS1117-3.3', candidateInternalPn: '' }, { 'chip-type': 'originalInternalPn' })).toEqual([]);
+  });
+});

apps/web/src/features/gov-task/internal/launch-link.ts

@@ -0,0 +1,132 @@
+/**
+ * 启动参数的**按分组联动**(2026-08-31 用户定)—— 纯函数,不碰 React。
+ *
+ * 服务端下发的两样东西就是这里的全部依据:候选各自带 `group` / `groupLabel`(清单 `x-options.group`),
+ * 参数带 `linkGroup`(清单 `x-link`)。前端**不认识**「原内部料号」「芯片类型」这些名字 ——
+ * 换个活动声明另一组联动,这段代码一个字不用改。
+ *
+ * 三条口径(用户当场定):
+ *   ①**组内第一个填上值的那格是锚**,锚自己永远摆全量候选,其余格按锚的分组键收窄;
+ *     锚**粘着**:把它清空只是解除收窄,**不把锚交给还填着值的另一格** ——
+ *     否则「清空锚、改个类型重填」当场被另一格锁住,人就改不了主意了(这一条是这次设计的要害)。
+ *     整组都空了才重新认锚。
+ *   ②锚没有分组键(未标类型的老料)、或锚填的是库里没有的新值(新增料号)→ 不收窄。
+ *   ③收窄之后,「未标类型」的候选**列在末尾单独一组**,不是不列。
+ *
+ * 服务端不据此立墙(`launch-params.ts` 头注):两格填不同类型照样收得下,类型一致归活动自己的收步判据管。
+ */
+import type { LaunchOption, LaunchParam } from '@contracts';
+
+/** 组名 → 当下坐着锚位的那格字段名 */
+export type LinkAnchors = Readonly<Record<string, string>>;
+/** 一组候选(`label` 为空 = 这批候选没有分组键,摆一列不分组) */
+export type OptionGroup = { readonly label: string | undefined; readonly options: readonly LaunchOption[] };
+/** 这一格该摆什么:分好组的候选 + 被谁按什么类型收窄(没收窄就没有) */
+export type ComboFace = { readonly groups: readonly OptionGroup[]; readonly narrow: { readonly by: string; readonly label: string } | undefined };
+
+const UNGROUPED = '未标类型';
+
+const valueOf = (values: Readonly<Record<string, string | readonly string[]>>, key: string): string => {
+  const v = values[key];
+  return typeof v === 'string' ? v.trim() : '';
+};
+
+/** 同一联动组的几格(按表单次序);只认真有候选的那些 —— 没有候选就没有可收窄的东西 */
+function membersOf(params: readonly LaunchParam[], group: string): readonly LaunchParam[] {
+  return params.filter((p) => p.linkGroup === group && (p.options ?? []).length > 0);
+}
+
+/** 锚这一格填的值落在哪个分组键上;`undefined` = 收窄无从谈起(没填 / 填的是库里没有的新值) */
+function anchorGroup(anchor: LaunchParam, value: string): { readonly key: string; readonly label: string } | undefined {
+  if (value === '') return undefined;
+  const hit = (anchor.options ?? []).find((o) => o.value === value);
+  // 值不在候选里 = 人自己新增的料号,它没有类型可言
+  if (hit === undefined || hit.group === undefined || hit.group === '') return undefined;
+  return { key: hit.group, label: hit.groupLabel ?? hit.group };
+}
+
+/**
+ * 值变过之后这一组的锚是谁。锚粘着:占了位就不让,直到组内所有格都空 —— 见头注①。
+ * 只动传进来的那份,原样返回也是合法结果(调用方按引用比较可省一次渲染)。
+ */
+export function nextAnchors(params: readonly LaunchParam[], values: Readonly<Record<string, string | readonly string[]>>, anchors: LinkAnchors): LinkAnchors {
+  const groups = new Set(params.map((p) => p.linkGroup).filter((g): g is string => g !== undefined));
+  let out = anchors;
+  const set = (group: string, key: string | undefined) => {
+    if (out === anchors) out = { ...anchors };
+    const next = { ...out };
+    if (key === undefined) delete next[group];
+    else next[group] = key;
+    out = next;
+  };
+  for (const group of groups) {
+    const members = membersOf(params, group);
+    const filled = members.filter((p) => valueOf(values, p.key) !== '');
+    const seated = anchors[group];
+    if (filled.length === 0) {
+      // 整组都空了 —— 锚位空出来,下一个填上值的那格重新认
+      if (seated !== undefined) set(group, undefined);
+      continue;
+    }
+    // 锚位还坐着人(哪怕它此刻是空的)就不动;锚被别的活动版本改没了才重新认
+    if (seated !== undefined && members.some((p) => p.key === seated)) continue;
+    set(group, filled[0]?.key);
+  }
+  return out;
+}
+
+/** 一批候选按分组键分组:有键的按首次出现的次序,**没有键的殿后**(用户定) */
+function groupOptions(options: readonly LaunchOption[]): readonly OptionGroup[] {
+  if (!options.some((o) => o.group !== undefined)) return [{ label: undefined, options }];
+  const named = new Map<string, { label: string; options: LaunchOption[] }>();
+  const bare: LaunchOption[] = [];
+  for (const o of options) {
+    const key = o.group ?? '';
+    if (key === '') {
+      bare.push(o);
+      continue;
+    }
+    const hit = named.get(key);
+    if (hit === undefined) named.set(key, { label: o.groupLabel ?? key, options: [o] });
+    else hit.options.push(o);
+  }
+  const out: OptionGroup[] = [...named.values()].map((g) => ({ label: g.label, options: g.options }));
+  if (bare.length > 0) out.push({ label: UNGROUPED, options: bare });
+  return out;
+}
+
+/** 这一格摆哪些候选、被谁收窄 —— 锚自己与不联动的格子都摆全量 */
+export function comboFace(
+  param: LaunchParam,
+  params: readonly LaunchParam[],
+  values: Readonly<Record<string, string | readonly string[]>>,
+  anchors: LinkAnchors,
+): ComboFace {
+  const all = param.options ?? [];
+  const group = param.linkGroup;
+  const seated = group === undefined ? undefined : anchors[group];
+  if (group === undefined || seated === undefined || seated === param.key) return { groups: groupOptions(all), narrow: undefined };
+  const anchor = params.find((p) => p.key === seated);
+  const by = anchor === undefined ? undefined : anchorGroup(anchor, valueOf(values, seated));
+  if (anchor === undefined || by === undefined) return { groups: groupOptions(all), narrow: undefined };
+  // 收窄:同分组键的 + 未标类型的(殿后)—— 「新增」那条路由控件自己一直留着
+  return { groups: groupOptions(all.filter((o) => o.group === by.key || o.group === undefined || o.group === '')), narrow: { by: anchor.label, label: by.label } };
+}
+
+/**
+ * 锚换了类型之后,组内哪几格的值**失配**:那个值在全量候选里、却不在收窄后的候选里。
+ * 人自己新增的值(压根不在候选里)不动 —— 它不是一次失配的旧选择,是一颗新料号。
+ */
+export function staleLinked(params: readonly LaunchParam[], values: Readonly<Record<string, string | readonly string[]>>, anchors: LinkAnchors): readonly string[] {
+  const out: string[] = [];
+  for (const param of params) {
+    const value = valueOf(values, param.key);
+    if (value === '' || param.linkGroup === undefined) continue;
+    const face = comboFace(param, params, values, anchors);
+    if (face.narrow === undefined) continue;
+    const known = (param.options ?? []).some((o) => o.value === value);
+    const kept = face.groups.some((g) => g.options.some((o) => o.value === value));
+    if (known && !kept) out.push(param.key);
+  }
+  return out;
+}

apps/web/src/features/gov-task/internal/panel.tsx

@@ -52,6 +52,8 @@ import {
   useOpsLaunchParams,
 } from '@web-shared/gov/gov-api.ts';
 import type { OpsInstance, OpsInstanceQuery } from '@web-shared/gov/gov-api.ts';
+import { comboFace, nextAnchors, staleLinked } from './launch-link.ts';
+import type { ComboFace, LinkAnchors } from './launch-link.ts';
 
 export type HomeProps = { tab: string; nav: Nav };
 
@@ -305,8 +307,11 @@ const COMBO_CREATE = '__create__';
  * 选择+新增(2026-08-27 用户定):先摆选择框,「新增 …」是候选**第一项**(2026-08-28 用户定,从末项提上来);
  * 选了它就换成输入框自己填(库里没有的值也收 —— 不拦启动,缺口由服务端派数据工单),
  * 旁边留「返回选择」换回去。
+ *
+ * 2026-08-31 加联动:候选摆什么由 `face` 说了算(`internal/launch-link.ts` 按服务端下发的分组键算好),
+ * 这里只管渲染 —— 分了组就出 `optgroup`,「新增」那条路**收窄与否都留着**(用户原话)。
  */
-function ComboInput({ p, value, onChange }: { p: LaunchParam; value: string; onChange: (v: string) => void }) {
+function ComboInput({ p, value, face, onChange }: { p: LaunchParam; value: string; face: ComboFace; onChange: (v: string) => void }) {
   const [custom, setCustom] = useState(false);
   if (custom) {
     return (
@@ -340,11 +345,23 @@ function ComboInput({ p, value, onChange }: { p: LaunchParam; value: string; onC
     >
       <option value="">请选择…</option>
       <option value={COMBO_CREATE}>＋ 新增{p.label}…</option>
-      {(p.options ?? []).map((o) => (
+      {face.groups.map((g, i) =>
+        g.label === undefined ? (
+          g.options.map((o) => (
+            <option key={o.value} value={o.value}>
+              {o.label}
+            </option>
+          ))
+        ) : (
+          <optgroup key={`${g.label}-${i}`} label={g.label}>
+            {g.options.map((o) => (
               <option key={o.value} value={o.value}>
                 {o.label}
               </option>
             ))}
+          </optgroup>
+        ),
+      )}
     </select>
   );
 }
@@ -364,9 +381,18 @@ function LaunchDrawer({ activityId, name, onCancel, onLaunch }: { activityId: st
   const specQ = useOpsLaunchParams(activityId, true);
   const spec = specQ.data?.params ?? [];
   const [values, setValues] = useState<LaunchValues>({});
+  /* 联动(2026-08-31 用户定):组名 → 坐着锚位的那格;锚自己摆全量,其余格按它的分组键收窄。
+     `linkNote` 是「原来选的那个与新类型不同类,已清空」这句话 —— 人一动那一格就摘掉 */
+  const [anchors, setAnchors] = useState<LinkAnchors>({});
+  const [linkNote, setLinkNote] = useState<Record<string, string>>({});
   /* 参数表回来了才铺初始值(含服务端 default 预填)—— 抽屉先开、表后到 */
   useEffect(() => {
-    if (specQ.data !== undefined) setValues(initLaunchValues(specQ.data.params));
+    if (specQ.data === undefined) return;
+    const init = initLaunchValues(specQ.data.params);
+    setValues(init);
+    /* 服务端 default 预填的值也算「填上了」—— 它就是这一组的锚 */
+    setAnchors(nextAnchors(specQ.data.params, init, {}));
+    setLinkNote({});
   }, [specQ.data]);
   /* 幂等键:每开一次抽屉(每次挂载)一枚 */
   const [idem] = useState(() => crypto.randomUUID());
@@ -396,7 +422,25 @@ function LaunchDrawer({ activityId, name, onCancel, onLaunch }: { activityId: st
   }, [onCancel]);
 
   const setVal = (key: string, v: string | string[]) => {
-    setValues((cur) => ({ ...cur, [key]: v }));
+    /* 联动三步(2026-08-31):重认锚 → 按锚收窄 → 组内失配的值清空并说一句。
+       失配 = 那个值在全量候选里、却不在收窄后的候选里;人自己新增的值不动(它压根不在候选里) */
+    const merged: LaunchValues = { ...values, [key]: v };
+    const nextA = nextAnchors(spec, merged, anchors);
+    const notes: Record<string, string> = {};
+    for (const stale of staleLinked(spec, merged, nextA)) {
+      const was = merged[stale];
+      merged[stale] = '';
+      const kind = comboFace(spec.find((x) => x.key === stale) ?? { key: stale, label: stale, type: 'combo' }, spec, merged, nextA).narrow?.label;
+      notes[stale] = kind === undefined ? `原选的 ${String(was)} 与新的选择不同类,已清空` : `原选的 ${String(was)} 与「${kind}」不同类,已清空`;
+    }
+    setValues(merged);
+    if (nextA !== anchors) setAnchors(nextA);
+    setLinkNote((cur) => {
+      const next = { ...cur, ...notes };
+      /* 人一动这一格,它自己那句「已清空」就摘掉 —— 说的是上一次的事 */
+      delete next[key];
+      return next;
+    });
     /* 改过的格子把它的小红字摘掉 —— 错留在屏上而人已经改了,是另一种撒谎 */
     setFieldErr((cur) => {
       if (cur[key] === undefined) return cur;
@@ -509,7 +553,7 @@ function LaunchDrawer({ activityId, name, onCancel, onLaunch }: { activityId: st
                     ))}
                   </select>
                 )}
-                {p.type === 'combo' && <ComboInput p={p} value={(values[p.key] as string) ?? ''} onChange={(v) => setVal(p.key, v)} />}
+                {p.type === 'combo' && <ComboInput p={p} value={(values[p.key] as string) ?? ''} face={comboFace(p, spec, values, anchors)} onChange={(v) => setVal(p.key, v)} />}
                 {p.type === 'list' && (
                   <span className="g-lplist">
                     {((values[p.key] as string[]) ?? ['']).map((v, i, arr) => (
@@ -537,6 +581,17 @@ function LaunchDrawer({ activityId, name, onCancel, onLaunch }: { activityId: st
                   </span>
                 )}
                 {p.desc !== undefined && <small>{p.desc}</small>}
+                {/* 联动(2026-08-31):被收窄的那格要说清是按谁的什么收的,以及怎么换 —— 悄悄少几条候选比不收窄更糟 */}
+                {p.type === 'combo' &&
+                  (() => {
+                    const narrow = comboFace(p, spec, values, anchors).narrow;
+                    return narrow === undefined ? null : (
+                      <small>
+                        已按「{narrow.by}」收窄:只列同为「{narrow.label}」的候选(库里没标的在末尾一组),要别的就回去改「{narrow.by}」,或在这里新增{p.label}。
+                      </small>
+                    );
+                  })()}
+                {linkNote[p.key] !== undefined && <small className="warn">{linkNote[p.key]}</small>}
                 {fieldErr[p.key] !== undefined && <small className="warn">{fieldErr[p.key]}</small>}
               </label>
             ))}

docs/API文档-活动模块.md

@@ -385,7 +385,8 @@ window.addEventListener('message', (e) => {
       "required": true,
       "desc": "差异评估基准;库里没有该 PN 也可启动,启动后派数据工单补参数。",
       "placeholder": "LM2596S-5.0",
-      "options": [{ "value": "LM2596S-5.0", "label": "LM2596S-5.0" }]
+      "linkGroup": "chip-type",
+      "options": [{ "value": "LM2596S-5.0", "label": "LM2596S-5.0", "group": "1", "groupLabel": "DC-DC 降压稳压器" }]
     },
     {
       "key": "candidateInternalPns",
@@ -394,7 +395,12 @@ window.addEventListener('message', (e) => {
       "required": true,
       "desc": "被评估物料;库里有就直接选,没有就自己填料号,启动后经数据工单创建。",
       "placeholder": "XL2596S-5.0",
-      "options": [{ "value": "LM2596S-5.0", "label": "LM2596S-5.0" }, { "value": "LM2596S-ADJ", "label": "LM2596S-ADJ" }]
+      "linkGroup": "chip-type",
+      "options": [
+        { "value": "LM2596S-5.0", "label": "LM2596S-5.0", "group": "1", "groupLabel": "DC-DC 降压稳压器" },
+        { "value": "AMS1117-3.3", "label": "AMS1117-3.3", "group": "2", "groupLabel": "LDO 线性稳压器" },
+        { "value": "OLD-001", "label": "OLD-001", "group": "" }
+      ]
     }
   ]
 }
@@ -406,7 +412,11 @@ W05 的候选内部料号(2026-08-27 用户定)与原内部料号**同款下拉
 
 候选量大到不宜内联时(如全量物料台账选 PN),后续加 `optionsSource` 引用检索接口;**本期一律内联 `options`**(封顶 500 行)。
 
-> 活动清单侧怎么声明(前端不用管,给写活动包的人看):`properties.<key>` 上 `title`→label、`description`→desc、`examples[0]`→placeholder、`default`、`required[]`;`enum`+`enumNames`→select;`'x-control'` 定标量控件(`text|textarea|select|combo`);`'x-options': { ledger:'域.对象', value:'列', label:'列' }` 让候选从正式台账现读;`type:'array'` 且元素是字符串→list,**数组字段标 `x-control: combo|select` 就摆成单选**(提交单个字符串,后端包成一元数组);**`'x-order': <数字>` 定表单次序**(清单存在 jsonb 里,书写顺序到不了这里);`format:'file'` 的字段本期不上表单;select 没候选降成 text。
+**按分组联动(2026-08-31 用户定)**:候选可带 `group`(分组键,如这颗料的芯片类型编号;`""` = 那一列没值,即「未标类型」)与 `groupLabel`(它的人读名,字典读不到就没有这个键);参数可带 `linkGroup`(联动组名)。**同一 `linkGroup` 的几格按 `group` 互相收窄**:组内**第一个填上值的那格是锚**,锚自己永远摆全量候选,其余格只列与锚同 `group` 的候选 + `group` 为空的那些(殿后单独一组)+「新增」这条路;锚清空则整组解除收窄(锚**不让位**给还填着值的另一格 —— 否则「清空锚、改个类型重填」当场被另一格锁住),整组都空了才重新认锚。锚没有 `group`、或锚填的是候选之外的新值 → 不收窄。锚换了类型之后,另一格里**在全量候选里、却不在收窄后候选里**的值由前端清空并说明(人自己新增的值不动 —— 它压根不在候选里)。
+
+> **这是表单的引导,不是墙**:服务端不据 `linkGroup` 校验 —— 两格填不同 `group` 的值照样收得下(combo 本就允许候选之外的值)。类型一致性由活动自己的收步判据管(W05 是 S1 的 `sub_eval_part_distinct_chip_type_id = 1`)。
+
+> 活动清单侧怎么声明(前端不用管,给写活动包的人看):`properties.<key>` 上 `title`→label、`description`→desc、`examples[0]`→placeholder、`default`、`required[]`;`enum`+`enumNames`→select;`'x-control'` 定标量控件(`text|textarea|select|combo`);`'x-options': { ledger:'域.对象', value:'列', label:'列' }` 让候选从正式台账现读;`'x-options'.group` 让候选带上分组键 —— 只写列名(`'chip_type_id'`)= 有键没名,整份写 `{ column, ledger, value, label }` 再从字典表换人读名;`'x-link': '<组名>'` 把几格结成联动组(同组按分组键互相收窄,见上);`type:'array'` 且元素是字符串→list,**数组字段标 `x-control: combo|select` 就摆成单选**(提交单个字符串,后端包成一元数组);**`'x-order': <数字>` 定表单次序**(清单存在 jsonb 里,书写顺序到不了这里);`format:'file'` 的字段本期不上表单;select 没候选降成 text。
 
 ## 5. 启动活动(创建实例)—— `POST /api/gov/activities/:activityId/instances`(`launchOpsInstanceRoute`)
 

docs/debt.md

@@ -1397,8 +1397,9 @@ ACT-WORK-05 恰好撞上这个「恰好」:`engines.ts` 的 `taskData.view()`
 - **行级来源标记只有 P-08 有**:P-08 借 `sub_eval.pn_check.exists_status`(found = 在库直读 / created = 本单建档)说了
   每颗料是不是这一单建的;P-10 / P-06 只按「本单挂的 / 同料号历史」分两个 `<tbody>`,P-10 分不出哪份资料是本单
   数据工单建的。要分,得在放行留痕里记主键名单(`ledger-write` 的 detail 现在只有表与行数)。
-- **`vtok` / `badgeCss` 三处各一份**(`report.ts` / `views/badge.ts` / `activity.test.ts`)——都注明「必须与 `classToken`
-  一字不差」;该抽进 `@sdk` 一处,包内测试改 import。report.ts 当时另一会话在改,没动它。
+- ~~**`vtok` / `badgeCss` 三处各一份**(`report.ts` / `views/badge.ts` / `activity.test.ts`)~~(2026-08-31 视图层
+  重设计时收掉一份:report.ts 改 import `views/badge.ts`,包内只剩 badge.ts 与测试镜像两份 —— 测试那份是
+  「与 classToken 一字不差」的回归网,按测试镜像惯例(view-render-addrow-thead 同款)留着;抽进 `@sdk` 仍可做,不急)。
 - **`viewTemplates[].data` 没有装包期静态审**:`from` 指到没声明的表 / 后面的集合、`by.column` 不是那张表的列,
   现在只有 W05 包内测试钉着 + 运行时「那一块空着 + stderr 点名」。该并进 `static-audit`(与 `refersTo` 目标核对同款)。
 - **`docs/数据域字段说明-W05.md` §二 / §十二.4 的参数集口径过时**:仍写 `normalized_parameter_set` 是 text 列「不建子表」,
@@ -1668,7 +1669,14 @@ B 表却**不在**同一份 `only` 名单里——B 表对应的那一行仍留
 有),先看确认那张卡的 `gateLedgers`/绑定 `blocks` 是不是只列了「主表」、漏了它
 `refersTo` 指向的「字典表」。
 
-## `prune` 与「数据工单确认即入库」的架构性冲突(2026-08-30,ACT-WORK-05 案例 2 真跑撞见)
+## ~~`prune` 与「数据工单确认即入库」的架构性冲突~~(2026-08-30 撞见;2026-08-31 已治,销账)
+
+**治法即下文「要治」的第二条**:`draftDrop` 加配方专用旗 `skipLanded`(loop-engine/port.ts),
+`prune` 遇已落地行**跳过并出声**(观察痕「N 行已随数据工单入库、这一笔不清它」),不再抛
+`AutoRecipeError`;W05 ②③ 两笔自投影随之恢复 `prune:true` —— 没落地的陈旧选型照撤
+(2026-08-31 用户实测点名的「改回同一类型,下面还是两个类型」就此清掉),已落地的原地留下
+(它已是世界的一部分,字典行本就该积累)。模型那一路的硬拒一个字不变(拒回是它的行动指南)。
+测:auto-runner「prune:已落地的陈旧行跳过不炸」(变异验证过)。原始记录留档如下。
 
 **现象**:数据工单**确认落地之后**再改动会影响行集合的字段(如 W05 的芯片类型),
 `project` 动作的 `prune: true` 要把「新计算出的集合里没有」的陈旧行撤掉——而那些行如果

docs/活动开发规范.md

@@ -363,6 +363,11 @@ W05 的两张数据工单(人填的值已入库、必填不缺、逐颗对账)
    的规矩,这条路连说都没说)。基座给了两道护栏:有卡在等人(人正对着件填)那几拍**不 prune**;
    同一张表既被 `prune` 又列在这一步 `humanWrites` 里,装包时报 warn。护栏不是许可 ——
    要人加行的表就别 `prune` 它。
+   **`prune: 'live'`(2026-08-31)是这条纪律的反面特例**:行集**全由配方铺、人在件上加不了行**
+   的表(如 W05 的参数骨架 —— 行按「料 × 类型字段」派生,件上没有加行钮),quiet 拍也照撤 ——
+   F3 防的风险在这种表上不存在,而「改了类型,旧类型的参数行还摆在屏上」是另一种撒谎
+   (实测:用户改选类型,行「只会跟着变多,不会跟着变少」)。有加行钮的表**永远不许用 `'live'`**。
+   两档都跳过已落地的行并出声(`draftDrop` 的 `skipLanded`)。
 6. **`card` 之后的那几笔,要等人交回之后的那一拍才跑。** 卡真发出去那一拍到此为止;
    人交回之后那一拍,`card` 这一笔被跳过、后面的照跑。所以「铺格 → 发卡 → 收口整理」读起来像一拍连做,
    其实是两拍 —— 收口那一笔看得见人填的值,这正是它该在的位置。装包时会为此报一条 warn 提醒。

packages/contracts/src/__tests__/auto-recipe.test.ts

@@ -28,6 +28,20 @@ describe('auto 配方契约', () => {
     expect(parsed.success).toBe(false);
   });
 
+  it("prune 收 'live' 档 —— quiet 拍也撤,只给人不会在件上加行的表用(其余字符串拒)", () => {
+    const live = autoRecipeSchema.safeParse({ do: [{ kind: 'project', into: 'a.b', prune: 'live', from: { once: true }, fields: { k: 'v' } }] });
+    expect(live.success).toBe(true);
+    const junk = autoRecipeSchema.safeParse({ do: [{ kind: 'project', into: 'a.b', prune: 'always', from: { once: true }, fields: { k: 'v' } }] });
+    expect(junk.success).toBe(false);
+  });
+
+  it('card 收确认闸条件档 gateWhen/gateWhenSay(2026-08-31,类型不一致不许确认)', () => {
+    const ok = autoRecipeSchema.safeParse({
+      do: [{ kind: 'card', as: 'execution', title: 't', gateWhen: 'a_b_distinct_c <= 1', gateWhenSay: '先改对再确认' }],
+    });
+    expect(ok.success).toBe(true);
+  });
+
   it('prune 只许挂在 project 上', () => {
     const parsed = autoRecipeSchema.safeParse({ do: [{ kind: 'say', text: 'x', prune: true }] });
     expect(parsed.success).toBe(false);

packages/contracts/src/activity-ops.ts

@@ -174,7 +174,12 @@ export const LAUNCH_PARAM_TYPES = ['text', 'textarea', 'select', 'combo', 'list'
 export const launchParamTypeSchema = z.enum(LAUNCH_PARAM_TYPES);
 export type LaunchParamType = z.infer<typeof launchParamTypeSchema>;
 
-export const launchOptionSchema = z.object({ value: z.string(), label: z.string() });
+/**
+ * 一条候选。`group` 是**联动分组键**(2026-08-31 用户定):清单 `x-options.group` 指了哪一列,
+ * 这颗候选就带上它在那一列的值(如料号的 `chip_type_id`);空串 = 那一列没值(「未标类型」)。
+ * `groupLabel` 是这枚键的人读名(从字典表现读,如「DC-DC 降压稳压器」),读不到就没有 —— 界面退回摆键本身。
+ */
+export const launchOptionSchema = z.object({ value: z.string(), label: z.string(), group: z.string().optional(), groupLabel: z.string().optional() });
 export type LaunchOption = z.infer<typeof launchOptionSchema>;
 
 export const launchParamSchema = z.object({
@@ -188,6 +193,13 @@ export const launchParamSchema = z.object({
   /** select / combo 的候选;combo 提交候选之外的值也合法 */
   options: z.array(launchOptionSchema).optional(),
   default: z.union([z.string(), z.array(z.string())]).optional(),
+  /**
+   * 联动组名(清单 `x-link`)—— 同一组的几格按候选的 `group` 互相收窄:
+   * 组内**第一个填上值的那格是锚**,锚自己永远摆全量候选,其余格只摆与锚同 `group` 的候选
+   * (外加没有 `group` 的那些,单独一组殿后)+「新增」这条路;锚清空或改成新增即解除。
+   * 服务端**不据此立墙** —— combo 本就收候选之外的值,类型一致性归活动自己的收步判据管。
+   */
+  linkGroup: z.string().optional(),
 });
 export type LaunchParam = z.infer<typeof launchParamSchema>;
 

packages/contracts/src/auto-recipe.ts

@@ -97,8 +97,16 @@ export type AutoAction =
       readonly when?: string | undefined;
       /** 台账地址「域.对象」—— 必须在 `declarations.ledger` 里(静态审) */
       readonly into: string;
-      /** 这一笔投影出来的行**就是这张表在本单草稿里的全部**,多出来的撤掉。只动草稿层 */
-      readonly prune?: boolean | undefined;
+      /**
+       * 这一笔投影出来的行**就是这张表在本单草稿里的全部**,多出来的撤掉。只动草稿层。
+       * `true`:只在非 quiet 拍撤 —— 人正对着件编辑的那几拍不动他的行(2026-08-29 终审 F3:
+       * 人刚在件上加的行,配方的数据源里当然没有,quiet 撤行就是静默数据丢失)。
+       * `'live'`(2026-08-31):quiet 拍也撤 —— **只给人不会在件上加行的表用**(行集全由配方铺,
+       * 如 W05 的参数骨架):F3 防的是「人刚加的行被撤」,人加不了行的表没有这个风险,
+       * 而「改了类型,旧类型的参数行还摆在屏上」是另一种撒谎 —— 跟手比守候更诚实。
+       * 已落地的行两档都跳过并出声(draftDrop 的 skipLanded)。
+       */
+      readonly prune?: boolean | 'live' | undefined;
       readonly from: AutoSource;
       readonly fields: Readonly<Record<string, AutoExpr>>;
     }
@@ -131,6 +139,9 @@ export type AutoAction =
       readonly basis?: readonly { readonly k: string; readonly v: AutoExpr }[] | undefined;
       /** 这张卡的提交闸盯哪几张表 */
       readonly gateLedgers?: readonly string[] | undefined;
+      /** 确认闸的条件档(S-FEEL,只读基座读数;为假不受理确认)+ 拒回那句话 —— 见 card.ts 同名字段 */
+      readonly gateWhen?: string | undefined;
+      readonly gateWhenSay?: string | undefined;
       /** 决策卡的选项;`variant:'review'` 时允许只有一个 */
       readonly options?:
         | readonly { readonly value: string; readonly label: string; readonly detail?: string | undefined }[]
@@ -145,7 +156,7 @@ export const autoActionSchema: z.ZodType<AutoAction> = z.discriminatedUnion('kin
       kind: z.literal('project'),
       when: z.string().min(1).optional(),
       into: z.string().regex(/^[a-z_]+\.[a-z_]+$/, '台账地址写成「域.对象」'),
-      prune: z.boolean().optional(),
+      prune: z.union([z.boolean(), z.literal('live')]).optional(),
       from: autoSourceSchema,
       fields: z.record(z.string(), autoExprSchema),
     })
@@ -173,6 +184,8 @@ export const autoActionSchema: z.ZodType<AutoAction> = z.discriminatedUnion('kin
       standard: autoExprSchema.optional(),
       basis: z.array(z.object({ k: z.string().min(1), v: autoExprSchema }).strict()).optional(),
       gateLedgers: z.array(z.string().min(1)).optional(),
+      gateWhen: z.string().min(1).optional(),
+      gateWhenSay: z.string().min(1).optional(),
       options: z
         .array(z.object({ value: z.string().min(1), label: z.string().min(1), detail: z.string().optional() }).strict())
         .optional(),

packages/contracts/src/card.ts

@@ -378,6 +378,14 @@ export const executionWorkOrderSchema = z.object({
    * 优先级:卡上绑了表(`blocks`)> 这一项 > 必交付物声明。
    */
   gateLedgers: z.array(z.string()).optional(),
+  /**
+   * **确认闸的条件档**(2026-08-31,W05「类型不一致还能确认」逼出):除了「必填缺几格」,
+   * 发卡的人还可以声明一条 S-FEEL 条件(只读基座读数),为假就不受理确认 ——
+   * 服务端在受理回传前现算(与缺格闸同一段 submitGate),display 与拒回同一句话
+   * (`gateWhenSay`)。机检只读基座数的纪律在这儿同样成立:条件里只许出现读数名。
+   */
+  gateWhen: z.string().optional(),
+  gateWhenSay: z.string().optional(),
   gate: z
     .object({
       /** 能交了吗 */

packages/ui-kit/__tests__/view-container-multihost.test.ts

@@ -0,0 +1,129 @@
+/**
+ * **多宿主收值 + 嵌套异地址排除**(2026-08-31,W05 芯片卡翻面逼出的平台扩面)。
+ *
+ * 版面要求「参数值印在每张芯片卡的**背面**、就地可改」:参数表的行天然分居两张卡,
+ * 一个宿主装不下 —— `hostsOf` 把同一地址的全部宿主都数进来,每个宿主各自归行。
+ *
+ * 更要紧的是**嵌套异地址排除**:卡背的参数宿主(`data-edit="parts.parameter"`)住在
+ * 芯片卡宿主(`data-edit="parts.profile"`)的行里 —— 外层收值若把里层宿主的格子也
+ * 收走,参数值就会被当成主数据的列并进主数据的行(`view-container-collect-nested.test.ts`
+ * 钉过的静默丢数据,换一副面孔回来)。规则:**格子只归它最近的 `data-edit` 祖先**。
+ * 嵌套的 `data-rows` 不带 `data-edit` 时行为原样(照旧并行 —— 那两条钉测不动)。
+ */
+// @vitest-environment jsdom
+import { describe, expect, it } from 'vitest';
+import { collect, mirrorTwins, scopedTargets, setOpenIn } from '../src/ViewContainer.tsx';
+
+/** 两张芯片卡:正面是主数据格(profile),背面各住一个参数宿主(parameter) */
+const FLIP_CARDS =
+  '<article data-edit="parts.profile">' +
+  '<section class="dossier">' +
+  '<button class="pen-a" data-edit-open="parts.profile"></button>' +
+  '<div class="front"><input data-col="internal_pn" value="LM2596S-5.0"/><input data-col="brand_name" value="TI"/></div>' +
+  '<div class="back"><section class="pback" data-edit="parts.parameter">' +
+  '<div class="ptile"><input data-col="internal_pn" value="LM2596S-5.0"/><input data-col="param_name" value="输出电压"/><input data-col="param_value" value="5.0"/></div>' +
+  '<div class="ptile"><input data-col="internal_pn" value="LM2596S-5.0"/><input data-col="param_name" value="输出电流"/><input data-col="param_value" value="3"/></div>' +
+  '</section></div>' +
+  '</section>' +
+  '<section class="dossier">' +
+  '<div class="front"><input data-col="internal_pn" value="XL2596S-5.0"/><input data-col="brand_name" value="XLSEMI"/></div>' +
+  '<div class="back"><section class="pback" data-edit="parts.parameter">' +
+  '<div class="ptile"><input data-col="internal_pn" value="XL2596S-5.0"/><input data-col="param_name" value="输出电压"/><input data-col="param_value" value="5.0"/></div>' +
+  '<div class="ptile"><input data-col="internal_pn" value="XL2596S-5.0"/><input data-col="param_name" value="输出电流"/><input data-col="param_value" value="2.5"/></div>' +
+  '</section></div>' +
+  '</section>' +
+  '</article>' +
+  '<div class="jc-editgate" data-edit-for="parts.parameter"></div>';
+
+function docOf(html: string): Document {
+  const doc = document.implementation.createHTMLDocument('');
+  doc.body.innerHTML = html;
+  return doc;
+}
+
+describe('多宿主 collect():同一地址的宿主都数进来,格子只归最近的 data-edit 祖先', () => {
+  it('parts.parameter 分居两张卡背的两个宿主 —— 4 个瓷贴收到 4 行,主键各自带对', () => {
+    const got = collect(docOf(FLIP_CARDS), 'parts.parameter');
+    expect(got).toHaveLength(4);
+    const xl = got.filter((r) => r['internal_pn'] === 'XL2596S-5.0');
+    expect(xl).toHaveLength(2);
+    expect(new Map(xl.map((r) => [r['param_name'], r['param_value']])).get('输出电流')).toBe('2.5');
+  });
+
+  it('parts.profile 收值**不含**卡背参数宿主的格子 —— 两行主数据,一列参数都不许混进来', () => {
+    const got = collect(docOf(FLIP_CARDS), 'parts.profile');
+    expect(got).toHaveLength(2);
+    for (const row of got) {
+      expect(row['brand_name']).toBeDefined();
+      /* 静默丢数据的那副面孔:param_value 若出现在主数据行里,就是里层宿主被外层吞了 */
+      expect(row['param_value']).toBeUndefined();
+      expect(row['param_name']).toBeUndefined();
+    }
+  });
+
+  it('setOpenIn:一把闸开合同一地址的**全部**宿主(非表格容器,.on 落在宿主自身)', () => {
+    const doc = docOf(FLIP_CARDS);
+    setOpenIn(doc, 'parts.parameter', true);
+    const hosts = Array.from(doc.querySelectorAll('.pback'));
+    expect(hosts).toHaveLength(2);
+    expect(hosts.every((h) => h.classList.contains('on'))).toBe(true);
+    expect(doc.querySelector('[data-edit-for="parts.parameter"]')?.classList.contains('on')).toBe(true);
+    /* 外层 profile 宿主不许被顺手点亮 —— 两把闸各管各的 */
+    expect(doc.querySelector('[data-edit="parts.profile"]')?.classList.contains('on')).toBe(false);
+    setOpenIn(doc, 'parts.parameter', false);
+    expect(hosts.every((h) => !h.classList.contains('on'))).toBe(true);
+  });
+});
+
+describe('mirrorTwins:下拉镜像的是选项文案,不是 value(2026-08-31「保存一瞬间变数字」)', () => {
+  const SEL =
+    '<div data-edit="parts.profile"><div class="row">' +
+    '<span class="jc-vcell tsel">旧名</span>' +
+    '<select class="jc-cell" data-col="chip_type_id">' +
+    '<option value=""></option><option value="1">DC-DC 降压稳压器</option><option value="2">LDO 线性稳压器</option>' +
+    '</select>' +
+    '</div></div>';
+
+  it('镜进孪生件的是「DC-DC 降压稳压器」,不是「1」;selected 属性拨到人选的那一项(守卫 CSS 认它)', () => {
+    const doc = document.implementation.createHTMLDocument('');
+    doc.body.innerHTML = SEL;
+    const sel = doc.querySelector('select') as HTMLSelectElement;
+    sel.value = '1';
+    mirrorTwins(doc, 'parts.profile');
+    expect(doc.querySelector('.tsel')?.textContent).toBe('DC-DC 降压稳压器');
+    expect(doc.querySelector('option[value="1"]')?.hasAttribute('selected')).toBe(true);
+    expect(doc.querySelector('option[value="2"]')?.hasAttribute('selected')).toBe(false);
+  });
+
+  it('没选(空占位)= 没答:孪生件一个字不动', () => {
+    const doc = document.implementation.createHTMLDocument('');
+    doc.body.innerHTML = SEL;
+    mirrorTwins(doc, 'parts.profile');
+    expect(doc.querySelector('.tsel')?.textContent).toBe('旧名');
+  });
+});
+
+describe('scopedTargets:开合作用域跟着触发钮走(2026-08-31「不要做联动,各自编辑各自的部分」)', () => {
+  it('钮在本地址宿主的行里 → 只这一行(A 卡的笔只开 A 卡);钮对别的地址 → 只这张卡里那个宿主', () => {
+    const doc = docOf(FLIP_CARDS);
+    const pen = doc.querySelector('.pen-a') as HTMLElement;
+    // ① profile:钮在 profile 宿主里 → 落到它所在的那一行(第一张卡的 section)
+    const t1 = scopedTargets(doc, 'parts.profile', pen);
+    expect(t1).toHaveLength(1);
+    expect(t1[0]?.className).toBe('dossier');
+    expect(t1[0]?.contains(pen)).toBe(true);
+    // ② parameter:钮不在任何 parameter 宿主里,但在 profile 的行里 → 行内那一个 pback,不是两个
+    const t2 = scopedTargets(doc, 'parts.parameter', pen);
+    expect(t2).toHaveLength(1);
+    expect(t2[0]?.classList.contains('pback')).toBe(true);
+    expect(t1[0]?.contains(t2[0] ?? null)).toBe(true);
+  });
+
+  it('外部闸(不在任何宿主/行里)→ 全部宿主,老行为', () => {
+    const doc = docOf(FLIP_CARDS);
+    const gate = doc.querySelector('[data-edit-for="parts.parameter"]') as HTMLElement;
+    const t = scopedTargets(doc, 'parts.parameter', gate);
+    expect(t).toHaveLength(2);
+    expect(t.every((h) => h.classList.contains('pback'))).toBe(true);
+  });
+});

packages/ui-kit/src/ViewContainer.tsx

@@ -161,9 +161,33 @@ function replaceInPlace(doc: Document, html: string): void {
   }
 }
 
-/** 一张可改的表的容器(tbody)—— 按 `data-edit` 地址找 */
+/** 一张可改的表的容器(tbody)—— 按 `data-edit` 地址找(多宿主时取文档序第一个,老调用方语义不变) */
 export function bodyOf(doc: Document, address: string): HTMLElement | null {
-  return doc.querySelector<HTMLElement>(`[data-edit="${CSS.escape(address)}"]`);
+  return hostsOf(doc, address)[0] ?? null;
+}
+
+/**
+ * **同一个地址的全部宿主**(2026-08-31,W05 芯片卡翻面逼出的多宿主收值)。
+ *
+ * 从前一个地址恰一个宿主(`bodyOf` 单 querySelector)——「参数值印在每张芯片卡的背面、
+ * 就地可改」这种版面下,同一张表(`parts.parameter`)的行天然分居两张卡,一个宿主装不下。
+ * 现在收值 / 开合 / 镜像都按**宿主清单**走:每个宿主各自归行(行仍是宿主的直接子元素),
+ * 清单合起来就是这张表。加行(`addRow`)仍只认第一个宿主 —— 会加行的表(类型字典 /
+ * 字段清单)从来都是单宿主,多宿主的表行由配方铺、人不加行。
+ */
+export function hostsOf(doc: Document, address: string): HTMLElement[] {
+  return Array.from(doc.querySelectorAll<HTMLElement>(`[data-edit="${CSS.escape(address)}"]`));
+}
+
+/**
+ * 这个格子归这个宿主管吗 —— **认最近的 `data-edit` 祖先**。
+ * 宿主可以嵌套(芯片卡是 `parts.profile` 的行,卡背里又住着 `parts.parameter` 的宿主):
+ * 外层收值时不认里层宿主的格子,不然参数值会被当成主数据的列并进主数据的行
+ * (`view-container-collect-nested.test.ts` 钉过的那种静默丢数据,换一副面孔回来)。
+ * 嵌套的 `data-rows` **不带** `data-edit` 时行为原样(照旧并行 —— 那两条钉测不动)。
+ */
+function ownsCell(host: HTMLElement, cell: Element): boolean {
+  return cell.closest('[data-edit]') === host;
 }
 
 /**
@@ -186,11 +210,11 @@ type EditCell = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
 
 /** 一张表的输入格子;`gone` 的行(人删掉的)不算在内。下拉与多行文本(textarea)与文本输入同源同待 */
 function cellsOf(doc: Document, address: string): EditCell[] {
-  const host = bodyOf(doc, address);
-  if (host === null) return [];
-  return Array.from(
-    host.querySelectorAll<EditCell>('input[data-col], select[data-col], textarea[data-col]'),
-  ).filter((i) => i.closest('.jc-row-gone') === null);
+  return hostsOf(doc, address).flatMap((host) =>
+    Array.from(host.querySelectorAll<EditCell>('input[data-col], select[data-col], textarea[data-col]')).filter(
+      (i) => ownsCell(host, i) && i.closest('.jc-row-gone') === null,
+    ),
+  );
 }
 
 /**
@@ -212,10 +236,12 @@ export function unanswered(cell: EditCell): boolean {
  * 认行元素则怎么增删都对得上:同一个 `<tr>` 里的格子就是同一行。
  */
 export function collect(doc: Document, address: string): Array<Record<string, string>> {
-  const host = bodyOf(doc, address);
-  if (host === null) return [];
   const byRow = new Map<Element, Record<string, string>>();
-  for (const cell of cellsOf(doc, address)) {
+  for (const host of hostsOf(doc, address)) {
+  for (const cell of Array.from(
+    host.querySelectorAll<EditCell>('input[data-col], select[data-col], textarea[data-col]'),
+  )) {
+    if (!ownsCell(host, cell) || cell.closest('.jc-row-gone') !== null) continue;
     const col = cell.dataset['col'];
     const row = rowOf(host, cell);
     if (col === undefined || row == null) continue;
@@ -230,6 +256,7 @@ export function collect(doc: Document, address: string): Array<Record<string, st
     one[col] = cell.value;
     byRow.set(row, one);
   }
+  }
   return [...byRow.values()];
 }
 
@@ -253,28 +280,43 @@ export function collect(doc: Document, address: string): Array<Record<string, st
  * 而 `twinInputs` 是把 input **紧接着**只读那份写出来的,前一个兄弟就是它的孪生件。
  * 这条是在真单的 DOM 上查出来的:合成 fixture 里我两份都写了 data-slot,于是照样绿。
  */
-function mirrorTwins(doc: Document, address: string): void {
+export function mirrorTwins(doc: Document, address: string): void {
   for (const cell of cellsOf(doc, address)) {
     // 与 collect 同一条规矩:没答的不算话(「没点/没选」= 不改)
     if (unanswered(cell)) continue;
     const twin = cell.previousElementSibling;
     if (twin === null || twin.tagName === 'INPUT' || twin.tagName === 'SELECT' || twin.tagName === 'TEXTAREA') continue;
+    /*
+     * **下拉镜像的是选项文案,不是 value**(2026-08-31 用户:「保存的一瞬间芯片类型
+     * 下拉框的值会变成数字」)—— 下拉的 value 是机器码(type_id、tally 值),
+     * 摆给人看的向来是人读名;顺手把 selected 属性拨到人选的那一项:守卫类 CSS
+     * (:has(option[selected]))与「取消后再编辑」的回显都认它,不拨的话保存后到
+     * 重推回来那一段,屏上仍按旧选择说话。
+     */
+    if (cell.tagName === 'SELECT') {
+      const sel = cell as HTMLSelectElement;
+      for (const o of Array.from(sel.options)) o.toggleAttribute('selected', o.value === sel.value && sel.value !== '');
+      twin.textContent = sel.selectedOptions[0]?.textContent ?? sel.value;
+      continue;
+    }
     twin.textContent = cell.value;
   }
 }
 
 /** 人删掉的那几行 —— 只交主键那几格够认行的值(整行都交也无妨,服务端只看主键) */
 function collectGone(doc: Document, address: string): Array<Record<string, string>> {
-  const host = bodyOf(doc, address);
-  if (host === null) return [];
-  return Array.from(host.querySelectorAll<HTMLElement>('.jc-row-gone')).map((row) => {
+  return hostsOf(doc, address).flatMap((host) =>
+    Array.from(host.querySelectorAll<HTMLElement>('.jc-row-gone'))
+      .filter((row) => row.closest('[data-edit]') === host)
+      .map((row) => {
     const one: Record<string, string> = {};
     for (const cell of Array.from(row.querySelectorAll<HTMLInputElement>('input[data-col]'))) {
       const col = cell.dataset['col'];
       if (col !== undefined) one[col] = cell.value;
     }
     return one;
-  });
+  }),
+  );
 }
 
 /**
@@ -322,6 +364,46 @@ export function addRow(doc: Document, address: string): boolean {
   return true;
 }
 
+/**
+ * 那块内容与它的闸一起开合。`.on` 落在哪:行容器是表格的落在 `<table>`(老件,样式按
+ * `table.on` 写);不是表格的落在 `data-edit` 元素自身(2026-08-02 A2 对决卡立的规矩)。
+ * 这一版是**全宿主**开合(外部闸行用它);按了卡上钮的走 `scopedTargets`(见下)。
+ */
+export function setOpenIn(doc: Document, address: string, on: boolean): void {
+  doc.querySelector<HTMLElement>(`[data-edit-for="${CSS.escape(address)}"]`)?.classList.toggle('on', on);
+  for (const host of hostsOf(doc, address)) (host.closest('table') ?? host).classList.toggle('on', on);
+}
+
+/**
+ * **开合的作用域跟着触发钮走**(2026-08-31 用户:「芯片档案编辑就不能各自编辑各自的部分吗,
+ * 不要做联动」)。三档,从近到远:
+ *   ① 钮长在这张表**自己的宿主**里 —— 落到钮所在的**那一行**(宿主的直接子元素;
+ *      W05 芯片卡的笔落在这张卡的行上,只这张卡进编辑);行认不出就整个宿主;
+ *   ② 钮长在**别的**宿主的某一行里 —— 落到**这一行内部**属于本地址的宿主们
+ *      (W05 卡背的参数宿主住在主数据宿主的行里:点这张卡的笔,只这张卡的卡背开);
+ *   ③ 都不是(外部闸行,如差异审核件的编辑闸)—— 全部宿主一起,老行为。
+ * 收值与保存**不随作用域收窄**(collect 仍按地址全量;「只写真改了的行」在服务端把关,
+ * 没动的行是 no-op)—— 作用域只管「屏上哪一块进编辑态」这一件事。
+ */
+export function scopedTargets(doc: Document, address: string, trigger: Element): HTMLElement[] {
+  const hosts = hostsOf(doc, address);
+  for (const host of hosts) {
+    if (host.contains(trigger)) {
+      const row = rowOf(host, trigger);
+      return [(row as HTMLElement | null) ?? host];
+    }
+  }
+  /* 钮在别的宿主的行里:找出包住钮的那一行(任意 data-edit 宿主的直接子元素),取行内的本地址宿主 */
+  for (let n: Element | null = trigger; n !== null; n = n.parentElement) {
+    const parent = n.parentElement;
+    if (parent !== null && parent.hasAttribute('data-edit')) {
+      const inner = hosts.filter((h) => n !== null && n.contains(h));
+      if (inner.length > 0) return inner;
+    }
+  }
+  return hosts.map((h) => (h.closest('table') ?? h) as HTMLElement);
+}
+
 /**
  * `data-file="域.对象/主键值"` → 取文件要的那两样。
  *
@@ -394,8 +476,15 @@ export function ViewContainer({ html, title = '活动视图', editable = false,
      * 填回表的尾巴(实测 A2 工作单:量得 2402、实际 2524)。
      */
     bindRef.current();
-    // 取 body 与 documentElement 的较大者:两者谁撑开高度随文档结构而异
-    const next = Math.max(doc.documentElement.scrollHeight, doc.body?.scrollHeight ?? 0);
+    /*
+     * **量 body,不量 documentElement**(2026-08-31 用户:「页面底部都没东西了,
+     * 怎么还可以向下滑动一截」):documentElement.scrollHeight 以 iframe 自身高度为下限 ——
+     * 内容一旦把 iframe 撑高过一次(比如参数编辑态输入框把卡背拉长),收起后它也缩不回去,
+     * 量高从此**只涨不缩**,底部留一截空白滚动。body(margin 0、height auto)的 scrollHeight
+     * 才是内容自己的高;body 读不出(异常文档)再退回 documentElement。
+     */
+    const body = doc.body?.scrollHeight ?? 0;
+    const next = body > 0 ? body : doc.documentElement.scrollHeight;
     if (next > 0) setHeight(next);
   }, []);
 
@@ -409,7 +498,7 @@ export function ViewContainer({ html, title = '活动视图', editable = false,
   const fileSink = useRef(onOpenFile);
   fileSink.current = onOpenFile;
   /** 进编辑态那一刻的样子 —— 「取消」要还原成它(值 + 那时有几行) */
-  const snapshot = useRef(new Map<string, { values: string[]; rows: number }>());
+  const snapshot = useRef(new Map<string, { values: string[]; rows: number[] }>());
 
   /*
    * 挂事件 + 开关闸 —— 都在**父文档这一侧**做,iframe 里没有脚本。
@@ -464,8 +553,7 @@ export function ViewContainer({ html, title = '活动视图', editable = false,
      */
     const setOpen = (address: string, on: boolean): void => {
       doc.querySelector<HTMLElement>(`[data-edit-for="${CSS.escape(address)}"]`)?.classList.toggle('on', on);
-      const host = doc.querySelector<HTMLElement>(`[data-edit="${CSS.escape(address)}"]`);
-      (host?.closest('table') ?? host)?.classList.toggle('on', on);
+      for (const target of scopedTargets(doc, address, hit)) (target.closest('table') ?? target).classList.toggle('on', on);
     };
 
     const open = hit.dataset['editOpen'];
@@ -479,7 +567,8 @@ export function ViewContainer({ html, title = '活动视图', editable = false,
       // (radio 的 value 是恒定的选项值,快照与还原认的是 checked)
       snapshot.current.set(open, {
         values: cellsOf(doc, open).map((c) => (c.type === 'radio' ? ((c as HTMLInputElement).checked ? '1' : '') : c.value)),
-        rows: Array.from(bodyOf(doc, open)?.children ?? []).length,
+        /* 行数逐宿主记 —— 多宿主时「取消」要把每个宿主各自加出来的行裁回去 */
+        rows: hostsOf(doc, open).map((h) => h.children.length),
       });
       setOpen(open, true);
       return;
@@ -488,11 +577,11 @@ export function ViewContainer({ html, title = '活动视图', editable = false,
       const was = snapshot.current.get(cancel);
       if (was !== undefined) {
         // 加出来的那几行整个撤掉,删掉的标记摘掉,再把值放回去 —— 三样一起才叫还原
-        const host = bodyOf(doc, cancel);
-        if (host !== null) {
-          while (host.children.length > was.rows) host.lastElementChild?.remove();
+        hostsOf(doc, cancel).forEach((host, i) => {
+          const keep = was.rows[i];
+          if (keep !== undefined) while (host.children.length > keep) host.lastElementChild?.remove();
           for (const row of Array.from(host.querySelectorAll('.jc-row-gone'))) row.classList.remove('jc-row-gone');
-        }
+        });
         cellsOf(doc, cancel).forEach((c, i) => {
           const saved = was.values[i];
           if (saved === undefined) return;

tools/e2e-a2.mjs

@@ -604,22 +604,9 @@ const SUITES = {
         edits: [],
         extraTables: [
           /*
-           * `parts.chip_type` **没有任何 `data-edit` 绑定**(manifest.ts / case-model.ts
-           * 头注明写:新建类型时人在 `parts.type_param` 那张表加行,`parts.chip_type` 那
-           * 张字典表本身没有编辑面 —— `ViewContainer.addRow` 靠克隆末行实现「加一行」,
-           * 而它在任何一单里都是从零行起,没有可克隆的样子)。写的授权面是**台账声明**
-           * 不是「当下卡上有没有绑定」(`writesOf` 只认 `declarations.ledger`),所以这条
-           * 写入走得通 —— 只是脚本代脚本走 API,不是真人代替点了一个并不存在的按钮。
-           * 只有样例 0(候选缺库·新建类型)会喂 `edits`,其余案例这里留空、这张表不写。
+           * 2026-08-31「只选不建」:parts.chip_type / parts.type_param 两条随功能退役 ——
+           * S1 的写授权面(writes)已收窄,再喂这两张表会被 400 拒。字典只在治理侧维护。
            */
-          { address: 'parts.chip_type', rowKey: 'type_id', blankCol: 'type_name', edits: [] },
-          {
-            // 复合主键 (type_id, param_name) —— 同一类型两个字段不能靠单列区分。
-            address: 'parts.type_param',
-            rowKey: ['type_id', 'param_name'],
-            blankCol: 'param_desc',
-            edits: [],
-          },
           {
             // 复合主键 (internal_pn, param_name) —— 两颗料同名参数(如都有「工作温度」)
             // 不这样区分,rows.find 会永远命中第一条同名行、把不同料的值互相顶掉。
@@ -634,8 +621,8 @@ const SUITES = {
     cases: [
       {
         sample: 0,
-        name: '候选缺库 · XL2596S-5.0 新建芯片类型(自增 type_id,字段清单沿用原型口径)入库,'
-          + '原 PN 一并转挂新类型才够得上 distinct=1 · 审核先点名意见驳回再通过',
+        name: '候选缺库 · XL2596S-5.0 建档并选已有类型(type_1,2026-08-31 起本活动只选不建)'
+          + '· 审核先点名意见驳回再通过',
         decideSeq: ['custom:使能阈值那条 UNKNOWN 的去向请写明验证任务号与测试条件', 'approve'],
         expectDecision: true,
         expectPort: 'assessment-released',
@@ -660,39 +647,13 @@ const SUITES = {
          * `type_id`,只是绕开这一条平台坑去验证后续链路,不代表浏览器里的真人也这样能走通。**
          */
         customFill: async (taskId) => {
-          const typeId = '90';
-          // ① 新建芯片类型:显式给 type_id(见上方大注释,不走 autoKeys 续号)
+          /* 2026-08-31「只选不建」:两颗料都挂到既有的 type_1(DC-DC)—— 新建类型那条路
+             (显式 type_id=90 绕全表一致坑的那整套)随功能移除,史见 git 2.9.0 及更早。 */
+          const typeId = '1';
           await api(`/api/desk/tasks/${taskId}/table`, {
             method: 'POST',
             body: JSON.stringify({
               tables: {
-                'parts.chip_type': [
-                  {
-                    type_id: typeId,
-                    type_name: 'DC-DC 降压稳压器(评估自定义)',
-                    description: '本次评估自定义的降压转换器类型,核心参数字段清单沿用原类型口径,供原 PN 与候选料共用比对。',
-                  },
-                ],
-              },
-            }),
-          });
-          console.log(`   新建类型已保存,显式指定 type_id=${typeId}(绕开全表一致平台坑,已报未改)`);
-          // ③ 核心参数字段清单(逐字照抄 type_id=1 的字典行,见 seed-mvp-data.ts)+
-          //    两颗料都转挂新类型(distinct 要求同一个值)+ 候选料的参数值。
-          //    LM2596S-5.0 的既有参数值按同名 lookup 自动带过来,不必在这里重填。
-          await api(`/api/desk/tasks/${taskId}/table`, {
-            method: 'POST',
-            body: JSON.stringify({
-              tables: {
-                'parts.type_param': [
-                  { type_id: typeId, param_name: '输入电压范围', param_desc: '芯片允许的输入直流电压区间。候选料的上限低于应用输入上限就是硬伤,烧的是芯片。', constraint_type: 'hard', param_unit: 'V' },
-                  { type_id: typeId, param_name: '输出电压', param_desc: '固定版给定值;可调版给可调区间,需外围反馈电阻网络设定。固定换可调要动外围。', constraint_type: 'hard', param_unit: 'V' },
-                  { type_id: typeId, param_name: '输出电流', param_desc: '满载持续输出能力。低于原料即降额,负载重时会掉压或过热保护。', constraint_type: 'hard', param_unit: 'A' },
-                  { type_id: typeId, param_name: '开关频率', param_desc: '决定外围电感与输出电容的取值。频率变了外围多半要跟着换,不是换颗料就完。', constraint_type: 'soft', param_unit: 'kHz' },
-                  { type_id: typeId, param_name: '静态电流', param_desc: '空载待机时自身消耗。电池供电场景敏感,市电场景通常不敏感。', constraint_type: 'soft', param_unit: 'mA' },
-                  { type_id: typeId, param_name: '工作温度', param_desc: '保证参数指标的环境温度区间。工业温域窄于应用要求就是硬伤。', constraint_type: 'hard', param_unit: '℃' },
-                  { type_id: typeId, param_name: '使能阈值', param_desc: 'ON/OFF 引脚的开关门限。上游用 MCU 电平直驱时,阈值对不上会关不掉或开不起来。', constraint_type: 'hard', param_unit: 'V' },
-                ],
                 'parts.profile': [
                   { internal_pn: 'LM2596S-5.0', chip_type_id: typeId },
                   {
@@ -768,10 +729,8 @@ const SUITES = {
             await db.query("delete from ledger.validation__record where validation_internal_pn = 'XL2596S-5.0'");
             await db.query("delete from ledger.parts__parameter where internal_pn = 'XL2596S-5.0'");
             await db.query("delete from ledger.parts__profile where internal_pn = 'XL2596S-5.0'");
-            await db.query("delete from ledger.parts__type_param where type_id = '90'");
-            await db.query("delete from ledger.parts__chip_type where type_id = '90'");
           });
-          console.log('   跨案例隔离:LM2596S-5.0 已转回 type_1;这一例全新建的 XL2596S-5.0(候选料本身、评估结果、type_id=90 字典行)已整体清空');
+          console.log('   跨案例隔离:XL2596S-5.0(这一例建档的候选料与它的评估结果)已整体清空;LM2596S-5.0 类型兜底归位 type_1');
         },
       },
       {
@@ -788,9 +747,9 @@ const SUITES = {
         name: '两颗都在库但分属不同芯片类型 · 硬拦(填别的格子绕不过去,只有改类型才行)· 审核通过',
         // gate_reason 要点名「不是同一个芯片类型」——数据卡一出现就查这句话,latch 住
         expectGateReason: /芯片类型/,
-        // 唯一的修复是把其中一颗转挂到另一颗的类型上;缺的那一个新必填参数一并补上,
-        // 不改类型光填别的格子过不去(S1 的 doneWhen/distinct 与提交闸的必填检查不是同一件事——
-        // 提交闸不查 distinct,这条路真正的硬拦在 S2 的入场哨兵,详见任务报告)。
+        // 唯一的修复是把其中一颗转挂到另一颗的类型上;缺的那一个新必填参数一并补上。
+        // 2026-08-31 起确认闸多了条件档(gateWhen 钉 parts_profile_distinct_chip_type_id):
+        // 类型不一致时确认直接 400 —— 上面的空手交卷探针吃到的就是它;修好类型再确认才收。
         stageEdits: {
           'parts.profile': [{ internal_pn: 'LM2596S-5.0', chip_type_id: '2' }],
           // 转去 LDO 类型后,LM2596S-5.0 多出一条它从没记过的必填参数「压差」