clearai-dsh 0.3.0 → 0.4.0

package/lib/client.js

@@ -81,12 +81,12 @@ var Wt=Object.create;var Le=Object.defineProperty;var Pt=Object.getOwnPropertyDe
 /**
  * clearai-dsh —— 浏览器半(ClearAI 的面板)。
  *
- * 它注册四个座位,外加输入框那两个:
- *   中栏 `conversation.view`    产物(声明 vs 盘上实际)、事实(已确认事实 + 在流转的命题)
- *   右栏 `sidebarRightTabs`     世界树(步骤/分叉/车道的拓扑与闸门)、技能 · 记忆(合并目录 + 本会话用量)
- *   输入框 `conversation.input`  计划芯片(步数 + 「需要你 N」)、续跑状态行
- * 除此之外还有一个**只给人**的写入口:世界树详情里的人门动作(采纳 / 放弃),它走宿主半的
- * `POST /api/clearai/gate`,落成一条署名为人的消息——模型能调的工具面里没有这些动词。
+ * 它注册三个座位:
+ *   中栏 `conversation.view`    本体(页眉 + 本体图 / 实体图 + 按可信度分组的结论)
+ *   右栏 `sidebarRightTabs`     世界树(计划的步骤,一行一步)
+ *   输入框 `conversation.input`  计划芯片(步数 + 「待处理 N」)
+ * 交付与文件改动走 DSH 原生的卡片,技能走原生技能目录,这里都不另做一份。
+ * 面板**只读**:没有写入口。要人拍板的事由开门的那次工具调用当场问人,要改词汇就在对话里说。
  *
  * 面板自己不取数、不重算:宿主半注册的**会话投影单元** `clearai`(见 `lib/index.js`)把算好的
  * 视图推下来,`useProjection('clearai')` 读它。投影为空(`undefined`)时渲染平静的空态,
@@ -185,8 +185,8 @@ window.__ModuleLoader__.load({
 
 		/** 语言命名空间。表按**源文**索引:键就是中文原文,所以漏翻译一条只会退回中文,不会把 key 显示给人。 */
 		const LOCALE_NS = 'clearai'
-		const LOCALE_ZH = {"个节点": "个节点", "条边": "条边", "适配": "适配", "打开图谱工作区": "打开图谱工作区", "关闭工作区": "关闭工作区", "图组件不可用": "图组件不可用", "点节点看知识详情": "点节点看知识详情", "按此筛选": "按此筛选", "关闭": "关闭", "正在取这条知识的读数…": "正在取这条知识的读数…", "取不到读数": "取不到读数", "宿主没有这个对象的读数(可能刚被废止,或它不在当前词汇里)。": "宿主没有这个对象的读数(可能刚被废止,或它不在当前词汇里)。", "父概念": "父概念", "形态": "形态", "取值": "取值", "引用": "引用", "子概念": "子概念", "相关谓词": "相关谓词", "实例": "实例", "关系边": "关系边", "主词": "主词", "相关事实": "相关事实", "(还有更多,未列出)": "(还有更多,未列出)", "历史": "历史", "这条事实没有命题关联(旧账本):不拿文本相等去猜身份。": "这条事实没有命题关联(旧账本):不拿文本相等去猜身份。", "推翻条件": "推翻条件", "支持到": "支持到", "断言": "断言", "没有证据引用(旧事实或自判)。": "没有证据引用(旧事实或自判)。", "出处": "出处", "产生步骤": "产生步骤", "复核": "复核", "这条事实参与了一对冲突读数(只暴露,不裁决)": "这条事实参与了一对冲突读数(只暴露,不裁决)", "滚轮缩放 · 拖动平移 · 拖节点挪位": "滚轮缩放 · 拖动平移 · 拖节点挪位", "类型": "类型", "还有 ": "还有 ", " 条未列出 · 用 / 触发菜单选": " 条未列出 · 用 / 触发菜单选", "被推翻 · 待裁决": "被推翻 · 待裁决", "等待输入": "等待输入", "等待人工处理": "等待人工处理", "等待中": "等待中", "等待人工": "等待人工", "异常终止": "异常终止", "发送失败:": "发送失败:", "已获首条证据": "已获首条证据", "按判据推荐": "按判据推荐", "系统内部消息(非运行状态)": "系统内部消息(非运行状态)", "填写缘由后提交": "填写缘由后提交", "请填写缘由": "请填写缘由", "点击在右栏预览": "点击在右栏预览", "点击查看详情": "点击查看详情", "查看步骤详情": "查看步骤详情", "查看词条": "查看词条", "放弃需填写缘由后提交": "放弃需填写缘由后提交", "撤回需填写缘由后提交": "撤回需填写缘由后提交", "暂无数据。发送第一条消息后,此处显示已确立条目与在验命题。": "暂无数据。发送第一条消息后,此处显示已确立条目与在验命题。", "暂无数据。发送第一条消息后,此处显示技能目录与记忆。": "暂无数据。发送第一条消息后,此处显示技能目录与记忆。", "暂无命题。每条需一句主张与一句推翻条件;通过验证后升格为事实。": "暂无命题。每条需一句主张与一句推翻条件;通过验证后升格为事实。", "暂无目标。目标携带验收判据;判据在结果出现之前登记。": "暂无目标。目标携带验收判据;判据在结果出现之前登记。", "暂无目标。验证达门槛且无推翻的命题在验收时升格为事实。": "暂无目标。验证达门槛且无推翻的命题在验收时升格为事实。", "暂无计划。建立计划后,已交付步骤按阶段列于此处。": "暂无计划。建立计划后,已交付步骤按阶段列于此处。", "暂无计划。建立后此处显示计划拓扑:脊柱步、车道与收敛点。": "暂无计划。建立后此处显示计划拓扑:脊柱步、车道与收敛点。", "暂无记忆。": "暂无记忆。", "暂无证据。先登记判据,后执行验证。": "暂无证据。先登记判据,后执行验证。", "此层暂无节点。": "此层暂无节点。", "暂无技能或记忆。使用 `SaveSkill` / `WriteMemory`,或将技能放入 `clear/skills/`。": "暂无技能或记忆。使用 `SaveSkill` / `WriteMemory`,或将技能放入 `clear/skills/`。", "达门槛且无推翻的命题在目标验收时升格为事实(写入 clear/knowledge/facts/)。": "达门槛且无推翻的命题在目标验收时升格为事实(写入 clear/knowledge/facts/)。", "修改判据需重新建立世界线": "修改判据需重新建立世界线", "计划的拓扑与闸门:脊柱步、车道、收敛点、人工决策点": "计划的拓扑与闸门:脊柱步、车道、收敛点、人工决策点", "由内核执行 ConvergeFork 完成合并": "由内核执行 ConvergeFork 完成合并", "通过提问卡做出裁决(含判据与各分支读数)": "通过提问卡做出裁决(含判据与各分支读数)", "通过提问卡决定": "通过提问卡决定", "在世界树中查看此步骤": "在世界树中查看此步骤", "右栏预览": "右栏预览", "查看此步骤的证据": "查看此步骤的证据", "查看评估者": "查看评估者", "工作区现状(首轮对话后进入投影)": "工作区现状(首轮对话后进入投影)", "本体声明尚未进入投影;当前显示规范闭环的镜像,下一拍自动对齐。": "本体声明尚未进入投影;当前显示规范闭环的镜像,下一拍自动对齐。", "目录尚未到达(内核下一次 pre-step 下发)": "目录尚未到达(内核下一次 pre-step 下发)", "这些等级尚无证据:跳级不违规,但需说明原因": "这些等级尚无证据:跳级不违规,但需说明原因", "此谓词已不在词汇中(可能已废止);存量断言仍可读。": "此谓词已不在词汇中(可能已废止);存量断言仍可读。", "策略暂停(原因未记录,已告警)": "策略暂停(原因未记录,已告警)", "未升格:断言仍在命题上": "未升格:断言仍在命题上", "放弃缘由(必填)": "放弃缘由(必填)", "撤回缘由(必填)": "撤回缘由(必填)", "登记概念": "登记概念", "登记谓词": "登记谓词", "名称": "名称", "单位": "单位", "提交": "提交", "取消": "取消", "废止": "废止", "为什么?": "为什么?", "提交中…": "提交中…", "点节点按概念过滤 · 滚轮缩放 · 拖拽平移": "点节点按概念过滤 · 滚轮缩放 · 拖拽平移", "复位": "复位", "全景": "全景", "还原": "还原", "展开图带": "展开图带", "图里只画了前": "图里只画了前", " 个节点;全景可看全部": " 个节点;全景可看全部", "一条边": "一条边", "词汇": "词汇", "概念": "概念", "谓词": "谓词", "已废止": "已废止", "健康": "健康", "单值": "单值", "打开词汇货架(原生预览)": "打开词汇货架(原生预览)", "冲突": "冲突", " 对": " 对", "只暴露,不裁决;撤回或维持由人决定": "只暴露,不裁决;撤回或维持由人决定", "按": "按", "过滤": "", "清除": "清除", "按此谓词过滤": "按此谓词过滤", "在图里看": "在图里看", " · 未升格": " · 未升格", "释义": "释义", "主词域": "主词域", "值域": "值域", "本体": "本体", "本体货架 · ": "本体货架 · ", "这里会长出你的本体:已确立的条目与在验的命题。": "这里会长出你的本体:已确立的条目与在验的命题。", "本体图": "本体图", "实体图": "实体图", " · 交付 ": " · 交付 ", " · 人 ": " · 人 ", " · 在工作区外,面板不读正文": " · 在工作区外,面板不读正文", " · 尺子 ": " · 尺子 ", " · 执行没跑成": " · 执行没跑成", " · 支持到 ": " · 支持到 ", " · 最近 ": " · 最近 ", " · 证据 ": " · 证据 ", " · 车道 ": " · 车道 ", " · 随步骤作废而终止": " · 随步骤作废而终止", " 份)。": " 份)。", " 份产物,但没有任何计划声明过它们。点一条可以直接看(它们不计入交付)。": " 份产物,但没有任何计划声明过它们。点一条可以直接看(它们不计入交付)。", " 份没列出来(这一栏只列最近改动的 ": " 份没列出来(这一栏只列最近改动的 ", " 发起": " 发起", " 处声明": " 处声明", " 字节": " 字节", " 字节 · ": " 字节 · ", " 字节 · 未被任何计划声明": " 字节 · 未被任何计划声明", " 字节 · 资源 ": " 字节 · 资源 ", " 推翻:": " 推翻:", " 旁观 ": " 旁观 ", " 条": " 条", " 条)": " 条)", " 次侦察": " 次侦察", " 次评估者": " 次评估者", " 步": " 步", " 步)": " 步)", " 等 ": " 等 ", " 评估卡": " 评估卡", " 轮": " 轮", " 里打开": " 里打开", "(假设达到这一级且无推翻才升格为事实)": "(假设达到这一级且无推翻才升格为事实)", "(每次修订留痕,旧值不删)": "(每次修订留痕,旧值不删)", "(点一下开右栏「世界树」)": "(点一下开右栏「世界树」)", "(点一下开右栏「世界树」看拓扑)": "(点一下开右栏「世界树」看拓扑)", "(留档不删)": "(留档不删)", "(缺)": "(缺)", "(要独立评估)才达门槛": "(要独立评估)才达门槛", "),所以这个分叉没有归宿了:**随步骤作废而终止**——它既不是被人裁掉(没人做过这个决定),也不是被算术排掉(没有尺子排过它)。要收掉工作副本(保留 ref),对它调 AbandonFork(会弹人工确认)。": "),所以这个分叉没有归宿了:**随步骤作废而终止**——它既不是被人裁掉(没人做过这个决定),也不是被算术排掉(没有尺子排过它)。要收掉工作副本(保留 ref),对它调 AbandonFork(会弹人工确认)。", "),等目标验收时升格为事实": "),等目标验收时升格为事实", ")——它不是落选:落选意味着它跑完了、被尺子排到了后面;这一条是没跑成,所以也没有读数可以参与算术。": ")——它不是落选:落选意味着它跑完了、被尺子排到了后面;这一条是没跑成,所以也没有读数可以参与算术。", "**执行没跑成**(": "**执行没跑成**(", "**执行者未归**:这条世界线的执行者派出去之后没有回灌,而分叉已经收口——它再回来也没有归宿了,所以这里既不判它跑成也没跑成,也不再等它。它的产物(如果写过)还在它自己的工作副本里;要判断那条线到底做出了什么,直接看工作副本比看这条状态可靠。": "**执行者未归**:这条世界线的执行者派出去之后没有回灌,而分叉已经收口——它再回来也没有归宿了,所以这里既不判它跑成也没跑成,也不再等它。它的产物(如果写过)还在它自己的工作副本里;要判断那条线到底做出了什么,直接看工作副本比看这条状态可靠。", ":还差 ": ":还差 ", ";放弃缘由:": ";放弃缘由:", "clearai 面板:右栏页签类型注册失败 ": "clearai 面板:右栏页签类型注册失败 ", "clearai-loop: 席位跟着会话预设进出": "clearai-loop: 席位跟着会话预设进出", "世界树": "世界树", "世界线:": "世界线:", "事实": "事实", "产物": "产物", "人审查后决定撤回": "人审查后决定撤回", "人已撤回(记录保留)": "人已撤回(记录保留)", "撤回事实": "撤回事实", "维持原事实": "维持原事实", "未走过 ": "未走过 ", "认可,继续": "认可,继续", "确认撤回": "确认撤回", "确认撤回(记录保留,不再作为「已知」引用)": "确认撤回(记录保留,不再作为「已知」引用)", "人的裁决:": "人的裁决:", "仅人可引用": "仅人可引用", "会话日志里的原生审批对(不可伪造)": "会话日志里的原生审批对(不可伪造)", "依据": "依据", "侦 ": "侦 ", "侦察 · ": "侦察 · ", "候选": "候选", "做什么": "做什么", "做法": "做法", "其他(": "其他(", "出现推翻证据": "出现推翻证据", "出现推翻证据(终态,记录保留)": "出现推翻证据(终态,记录保留)", "分支": "分支", "切回历史的世界树(计划都还在,文档也归档在 clear/goals/plans/)": "切回历史的世界树(计划都还在,文档也归档在 clear/goals/plans/)", "判据": "判据", "判据:": "判据:", "判据待写": "判据待写", "升格门槛": "升格门槛", "原生预览打不开这条路(它在工作区外?)": "原生预览打不开这条路(它在工作区外?)", "原生预览打开它": "原生预览打开它", "原生预览打开它(计划声明的产物)": "原生预览打开它(计划声明的产物)", "合并目录、本会话用法、可引用可采纳": "合并目录、本会话用法、可引用可采纳", "命题": "命题", "命题 · ": "命题 · ", "在": "在", "在 ": "在 ", "声明的是目录;准入要求具体文件——目录不算物证": "声明的是目录;准入要求具体文件——目录不算物证", "多问我": "多问我", "完成度 ": "完成度 ", "完成度 —": "完成度 —", "审批记录": "审批记录", "工作区模板 · clear/skills": "工作区模板 · clear/skills", "已交付": "已交付", "已作废": "已作废", "已回灌": "已回灌", "已推翻": "已推翻", "已提出": "已提出", "已撤回": "已撤回", "已收尾 · 存档可看": "已收尾 · 存档可看", "已改版": "已改版", "已放弃": "已放弃", "已放弃探索:": "已放弃探索:", "已放弃的分叉": "已放弃的分叉", "已替代": "已替代", "已确认": "已确认", "已确认事实 · ": "已确认事实 · ", "已被下一版命题替代(版本留着,不参与当前推理)": "已被下一版命题替代(版本留着,不参与当前推理)", "已裁决": "已裁决", "已评估": "已评估", "已达成": "已达成", "已达门槛(": "已达门槛(", "已达门槛,已升格为事实": "已达门槛,已升格为事实", "已采纳": "已采纳", "待开计划": "待开计划", "待推进": "待推进", "待裁决": "待裁决", "我的 · ~/.dsh": "我的 · ~/.dsh", "打开 ": "打开 ", "打开「事实」那一格并展开这条命题": "打开「事实」那一格并展开这条命题", "打开世界树并选中产出这条事实的验证步": "打开世界树并选中产出这条事实的验证步", "打开世界树并选中产生这条证据的验证步": "打开世界树并选中产生这条证据的验证步", "打开失败:HTTP ": "打开失败:HTTP ", "打开计划文档(原生预览)": "打开计划文档(原生预览)", "技能 · 记忆": "技能 · 记忆", "探索中": "探索中", "推翻": "推翻", "推进中": "推进中", "提交中…": "提交中…", "提交失败:": "提交失败:", "支持": "支持", "支持到 ": "支持到 ", "收敛": "收敛", "收束:": "收束:", "收起": "收起", "收起详情": "收起详情", "放弃了这次探索": "放弃了这次探索", "放弃探索": "放弃探索", "放弃缘由(必填)": "Reason for abandoning (required)", "放弃这条分叉": "放弃这条分叉", "放弃这次探索(留档不删,ref 保留)": "放弃这次探索(留档不删,ref 保留)", "放行": "放行", "旁观写这条裁决的评估者子会话(论证过程)": "旁观写这条裁决的评估者子会话(论证过程)", "旁观评估者": "旁观评估者", "旁观这条世界线的评估者会话(只读)": "旁观这条世界线的评估者会话(只读)", "无法判定": "无法判定", "是目录(不算物证)": "是目录(不算物证)", "最后改动 ": "最后改动 ", "未分类": "未分类", "未声明": "未声明", "未收口(随步骤作废而终止)": "未收口(随步骤作废而终止)", "未知": "未知", "未走:": "未走:", "未采纳": "未采纳", "本会话 模型 ": "本会话 模型 ", "本项目 · .dsh / .agents": "本项目 · .dsh / .agents", "本项目写的 · clear/skills": "本项目写的 · clear/skills", "核心产物(": "核心产物(", "步 ": "步 ", "派出 ": "派出 ", "派生 · ": "派生 · ", "版本": "版本", "状态": "状态", "独立评估者": "独立评估者", "用原生预览打开章程(它每回合整份注入模型上下文)": "用原生预览打开章程(它每回合整份注入模型上下文)", "盘上已有(": "盘上已有(", "盘上没有": "盘上没有", "盘上没有这个文件": "盘上没有这个文件", "目录": "目录", "目录里已经没有(": "目录里已经没有(", "目标": "目标", "目标挂起": "目标挂起", "确认放弃": "确认放弃", "确认放弃(留档不删,ref 保留)": "确认放弃(留档不删,ref 保留)", "等独立裁决": "等独立裁决", "策略暂停": "策略暂停", "续跑:多问我——每个阶段收尾就停下,等你给下一阶段(文档里叫「人在场」)。点一下切成「自己拿主意」。": "续跑:多问我——每个阶段收尾就停下,等你给下一阶段(文档里叫「人在场」)。点一下切成「自己拿主意」。", "续跑:自己拿主意——立约即授权,按轮数自己往下跑,只在不可约的判断上开门(文档里叫「无人值守」)。点一下切成「多问我」。": "续跑:自己拿主意——立约即授权,按轮数自己往下跑,只在不可约的判断上开门(文档里叫「无人值守」)。点一下切成「多问我」。", "续跑停着:": "续跑停着:", "续跑已撤回": "续跑已撤回", "缘由必填": "缘由必填", "缺": "缺", "自判": "自判", "自定义": "自定义", "自己拿主意": "自己拿主意", "被 ": "被 ", "被下一版命题改写": "被下一版命题改写", "裁决": "裁决", "裁决:采纳 ": "裁决:采纳 ", "要你": "要你", "观测": "观测", "计划": "计划", "计划 ": "计划 ", "计划受阻,等人处置": "计划受阻,等人处置", "计划在建,**等你确认**": "计划在建,**等你确认**", "计划已交付 ": "计划已交付 ", "计划已收尾(": "计划已收尾(", "计划待确认": "计划待确认", "计划文档": "计划文档", "记忆(": "记忆(", "记忆索引": "记忆索引", "证据": "证据", "证据 ": "证据 ", "评 ": "评 ", "评估": "评估", "评估卡": "评估卡", "评估者": "评估者", "评估者 ": "评估者 ", "评估者会话 ": "评估者会话 ", "评估者在裁决": "评估者在裁决", "读不到交付物:": "读不到交付物:", "读取中…": "读取中…", "读数": "读数", "读数(尺子 ": "读数(尺子 ", "起过 ": "起过 ", "跑着": "跑着", "车道 · ": "车道 · ", "边界:": "边界:", "运行时注册": "运行时注册", "还有 ": "还有 ", "还没交付": "还没交付", "这一步已作废(缘由:": "这一步已作废(缘由:", "这一步没有声明产物。": "这一步没有声明产物。", "这个会话还没开始:面板的数据来自会话日志,发第一句话之后,这里会显示已确认的事实与正在流转的命题。": "这个会话还没开始:面板的数据来自会话日志,发第一句话之后,这里会显示已确认的事实与正在流转的命题。", "这个会话还没有 ClearAI 的状态。": "这个会话还没有 ClearAI 的状态。", "这个工作区盘上已经有 ": "这个工作区盘上已经有 ", "进度": "进度", "采纳": "采纳", "采纳 ": "采纳 ", "采纳:改写 frontmatter,模型从此加载得到它": "采纳:改写 frontmatter,模型从此加载得到它", "采纳了某条世界线": "采纳了某条世界线", "采纳此世界线": "采纳此世界线", "问题:": "问题:", "阶段": "阶段", "阶段 ": "阶段 ", "阶段交界": "阶段交界", "需要你 ": "需要你 ", "面板动作失败:": "面板动作失败:", "项目章程": "项目章程", "预设自带": "预设自带", "验证": "验证", "验证中": "验证中", "这次采纳没有合并:": "这次采纳没有合并:", "(决定已登记,产物由一次普通交付落位)": "(决定已登记,产物由一次普通交付落位)", "分支或工作副本已不在": "分支或工作副本已不在", "怎么补这一级?": "怎么补这一级?", "收起这一级要交的东西": "收起这一级要交的东西", "读不到等级说明": "读不到等级说明", "这一级看什么:": "这一级看什么:", "这一级要交什么:": "这一级要交什么:", "这一级要检查的对象:": "这一级要检查的对象:", "这条命题还没写明断言主体:先用 RegisterInstance 把实例连出处登记下来。": "这条命题还没写明断言主体:先用 RegisterInstance 把实例连出处登记下来。", "reason 怎么写:": "reason 怎么写:", "reason 里必须点到上面这些对象名,不能写「时间不够」。": "reason 里必须点到上面这些对象名,不能写「时间不够」。", "跳级本身不违规:要交的是「这一级为什么不适用」的理由,不是这一级的读数。": "跳级本身不违规:要交的是「这一级为什么不适用」的理由,不是这一级的读数。", "缺口": "缺口", "语言还没立:概念与谓词都还是空的": "语言还没立:概念与谓词都还是空的", "命题只有散文主张:没有能被机器比对的断言": "命题只有散文主张:没有能被机器比对的断言", "升格的事实没带断言:它进不了实体图": "升格的事实没带断言:它进不了实体图", "命题没被任何证据碰过": "命题没被任何证据碰过", "断言主体还没落到实体图": "断言主体还没落到实体图", "跳级没写理由": "跳级没写理由", "概念没有任何结论引用": "概念没有任何结论引用", "未登记的缺口类型": "未登记的缺口类型", "下一步:": "下一步:", "看实体图": "看实体图", "切到实体图那一层,看有哪些实例节点": "切到实体图那一层,看有哪些实例节点", "这一层还没有实例节点。": "这一层还没有实例节点。", "实例靠 RegisterInstance 登记(带出处);断言挂在命题上不算「已知」。": "实例靠 RegisterInstance 登记(带出处);断言挂在命题上不算「已知」。", " 个断言主体还没落到这一层:": " 个断言主体还没落到这一层:", "先 RegisterInstance 把实例连出处登记下来;确实不值得留下形态就如实说清": "先 RegisterInstance 把实例连出处登记下来;确实不值得留下形态就如实说清", "用 ExplainLevelSkip 写明「为什么这一级在本项目里不适用」": "用 ExplainLevelSkip 写明「为什么这一级在本项目里不适用」", "要么在断言里用起来,要么在货架上如实标出「未被引用」": "要么在断言里用起来,要么在货架上如实标出「未被引用」", "交给模型的写法:": "交给模型的写法:", "推理自检:结论只是自己推了一遍,没有引入任何外部输入": "推理自检:结论只是自己推了一遍,没有引入任何外部输入", "已有知识:引用自己或别人手上已有的材料": "已有知识:引用自己或别人手上已有的材料", "可复算:照一份能重跑的步骤自己算一遍": "可复算:照一份能重跑的步骤自己算一遍", "独立裁决:由另一个评估者读产物后给结论": "独立裁决:由另一个评估者读产物后给结论", "人放行:交付前有人看过并批准": "人放行:交付前有人看过并批准", "还没建计划:先想清楚要怎么回答": "还没建计划:先想清楚要怎么回答", "执行中:有活动计划且还有未落定的步": "执行中:有活动计划且还有未落定的步", "阶段边界:当前计划的步都落定了,该结案或起新计划": "阶段边界:当前计划的步都落定了,该结案或起新计划", "在等裁决:有交付/结案在飞,或上一次裁决还没回来": "在等裁决:有交付/结案在飞,或上一次裁决还没回来", "卡住了:连续几次没通过观测准入,停下等人": "卡住了:连续几次没通过观测准入,停下等人", "目标已达成(终局)": "目标已达成(终局)", "目标已如实放弃(终局)": "目标已如实放弃(终局)", "已登记:某实例在某出处下被登记下来(一等写入口)": "已登记:某实例在某出处下被登记下来(一等写入口)", "已升格:来自过了独立裁决的事实断言": "已升格:来自过了独立裁决的事实断言", "实体断言:登记那一刻就成立的边,有出处但未经独立裁决": "实体断言:登记那一刻就成立的边,有出处但未经独立裁决", "支持到哪一级:所有支持证据里最高的那一级": "支持到哪一级:所有支持证据里最高的那一级", "从没走过的等级:已用到最高级之下、一条证据都没有的级": "从没走过的等级:已用到最高级之下、一条证据都没有的级", "被推翻次数:收到过几条推翻证据": "被推翻次数:收到过几条推翻证据", "无法判定次数:判过但判不出来": "无法判定次数:判过但判不出来", "还没有概念与谓词:换一轮只能靠重读散文取用结论": "还没有概念与谓词:换一轮只能靠重读散文取用结论", "命题只有散文主张:两条结论是不是在说同一件事只能靠重读判断": "命题只有散文主张:两条结论是不是在说同一件事只能靠重读判断", "已升格事实没带断言:进不了实体图,也不能按概念取用": "已升格事实没带断言:进不了实体图,也不能按概念取用", "有命题一条证据都没碰过:没看过不等于没问题": "有命题一条证据都没碰过:没看过不等于没问题", "断言的主体还没有落到实体图上:句子只挂在命题上,不构成「已知」": "断言的主体还没有落到实体图上:句子只挂在命题上,不构成「已知」", "有等级被跳过而没写理由:跳级不违规,但要说清为什么不适用": "有等级被跳过而没写理由:跳级不违规,但要说清为什么不适用", "有概念没有任何结论引用:它们还只是约定,不是已知": "有概念没有任何结论引用:它们还只是约定,不是已知", "判据没改过:它还是立约时那一份(要原文读账本里的 done_criteria)": "判据没改过:它还是立约时那一份(要原文读账本里的 done_criteria)", "判据改动要有一份独立裁决:改「怎样算完成」不能被顺手做掉": "判据改动要有一份独立裁决:改「怎样算完成」不能被顺手做掉", "宿主会话服务读不到:这一刻拿不到会话,写盘可能写到错地方": "宿主会话服务读不到:这一刻拿不到会话,写盘可能写到错地方", "投影服务读不到:这一刻的读数是空的,不是「没有」": "投影服务读不到:这一刻的读数是空的,不是「没有」", " · 改过 ": " · 改过 ", " 次": " 次", " · 最近一次修订的独立裁决:": " · 最近一次修订的独立裁决:", "全文在 ": "全文在 ", "打开目标文档(原生预览)": "打开目标文档(原生预览)", "背景(不参与判定):": "背景(不参与判定):"}
-		const LOCALE_EN = {"个节点": " nodes", "条边": " edges", "适配": "Fit", "打开图谱工作区": "Open the graph workspace", "关闭工作区": "Close the workspace", "图组件不可用": "The graph component is unavailable", "点节点看知识详情": "Click a node to see what it means", "按此筛选": "Filter by this", "关闭": "Close", "正在取这条知识的读数…": "Fetching this entry’s readings…", "取不到读数": "Could not fetch the readings", "宿主没有这个对象的读数(可能刚被废止,或它不在当前词汇里)。": "The host has no readings for this object (it may have just been deprecated, or it is not in the current vocabulary).", "父概念": "Parent concept", "形态": "Value form", "取值": "Value", "引用": "Used by", "子概念": "Child concepts", "相关谓词": "Related predicates", "实例": "Instances", "关系边": "Relation edges", "主词": "Subjects", "相关事实": "Related facts", "(还有更多,未列出)": " (more not listed)", "历史": "History", "这条事实没有命题关联(旧账本):不拿文本相等去猜身份。": "This fact has no proposition link (old ledger); text equality is not used to guess identity.", "推翻条件": "Refutation condition", "支持到": "Supported to", "断言": "Assertion", "没有证据引用(旧事实或自判)。": "No evidence cites it (an old fact, or self-judged).", "出处": "Provenance", "产生步骤": "Producing step", "复核": "Review", "这条事实参与了一对冲突读数(只暴露,不裁决)": "This fact takes part in a conflict reading (surfaced, never adjudicated)", "滚轮缩放 · 拖动平移 · 拖节点挪位": "wheel to zoom · drag to pan · drag a node to move it", "类型": "Type", "还有 ": "and ", " 条未列出 · 用 / 触发菜单选": " more not listed · pick them from the / menu", "被推翻 · 待裁决": "refuted · awaiting decision", "等待输入": "awaiting input", "等待人工处理": "awaiting human action", "等待中": "waiting", "等待人工": "awaiting human", "异常终止": "terminated abnormally", "发送失败:": "send failed: ", "已获首条证据": "first evidence received", "按判据推荐": "recommended by criterion", "系统内部消息(非运行状态)": "system-internal message (not a run state)", "填写缘由后提交": "fill in the reason, then submit", "请填写缘由": "reason required", "点击在右栏预览": "click to preview in the right sidebar", "点击查看详情": "click for details", "查看步骤详情": "view step details", "查看词条": "view term", "放弃需填写缘由后提交": "fill in the reason before abandoning", "撤回需填写缘由后提交": "fill in the reason before retracting", "暂无数据。发送第一条消息后,此处显示已确立条目与在验命题。": "No data yet. After your first message this shows established entries and propositions in verification.", "暂无数据。发送第一条消息后,此处显示技能目录与记忆。": "No data yet. After your first message this shows the skill catalogue and memory.", "暂无命题。每条需一句主张与一句推翻条件;通过验证后升格为事实。": "No propositions yet. Each needs a one-line claim and a refutation condition; verified ones are promoted to facts.", "暂无目标。目标携带验收判据;判据在结果出现之前登记。": "No goal yet. A goal carries its acceptance criterion; the criterion is registered before any result.", "暂无目标。验证达门槛且无推翻的命题在验收时升格为事实。": "No goal yet. Verified propositions reaching the threshold without refutation are promoted at acceptance.", "暂无计划。建立计划后,已交付步骤按阶段列于此处。": "No plan yet. Delivered steps are listed here by stage once a plan exists.", "暂无计划。建立后此处显示计划拓扑:脊柱步、车道与收敛点。": "No plan yet. Once committed, this shows the plan topology: spine steps, lanes, and convergence.", "暂无记忆。": "No memory yet.", "暂无证据。先登记判据,后执行验证。": "No evidence yet. Register the criterion first, then verify.", "此层暂无节点。": "No nodes on this layer yet.", "暂无技能或记忆。使用 `SaveSkill` / `WriteMemory`,或将技能放入 `clear/skills/`。": "No skills or memory yet. Use `SaveSkill` / `WriteMemory`, or put a skill under `clear/skills/`.", "达门槛且无推翻的命题在目标验收时升格为事实(写入 clear/knowledge/facts/)。": "Propositions reaching the threshold with no refutation are promoted to fact at goal acceptance (written under clear/knowledge/facts/).", "修改判据需重新建立世界线": "changing the criterion requires a new worldline", "计划的拓扑与闸门:脊柱步、车道、收敛点、人工决策点": "Plan topology and gates: spine steps, lanes, convergence, human decision points", "由内核执行 ConvergeFork 完成合并": "the kernel runs ConvergeFork to complete the merge", "通过提问卡做出裁决(含判据与各分支读数)": "decide via the question card (with the criterion and each branch's reading)", "通过提问卡决定": "decide via question card", "在世界树中查看此步骤": "see this step in Worldlines", "右栏预览": "preview in right sidebar", "查看此步骤的证据": "see the evidence for this step", "查看评估者": "view evaluator", "工作区现状(首轮对话后进入投影)": "workspace state (enters the projection after the first turn)", "本体声明尚未进入投影;当前显示规范闭环的镜像,下一拍自动对齐。": "The ontology declaration has not reached the projection; a canonical-loop mirror is shown and will align at the next step.", "目录尚未到达(内核下一次 pre-step 下发)": "the catalogue has not arrived yet (the kernel sends it on the next pre-step)", "这些等级尚无证据:跳级不违规,但需说明原因": "no evidence at these levels: skipping is not a violation, but state why", "此谓词已不在词汇中(可能已废止);存量断言仍可读。": "this predicate is no longer in the vocabulary (possibly deprecated); existing assertions remain readable.", "策略暂停(原因未记录,已告警)": "paused by policy (reason not recorded; warned)", "未升格:断言仍在命题上": "not yet promoted: the assertion is still on a proposition", "放弃缘由(必填)": "Reason for abandoning (required)", "撤回缘由(必填)": "Reason for retracting (required)", "登记概念": "Register a concept", "登记谓词": "Register a predicate", "名称": "Label", "单位": "Unit", "提交": "Submit", "取消": "Cancel", "废止": "Deprecate", "为什么?": "Why?", "提交中…": "Submitting…", "点节点按概念过滤 · 滚轮缩放 · 拖拽平移": "Click a node to filter by concept · wheel to zoom · drag to pan", "复位": "Reset view", "全景": "Panorama", "还原": "Restore", "展开图带": "Show the graph band", "图里只画了前": "Showing the first", " 个节点;全景可看全部": " nodes; the panorama shows all", "一条边": "An edge", "词汇": "Vocabulary", "概念": "concepts", "谓词": "predicates", "已废止": "deprecated", "健康": "Health", "单值": "single-valued", "打开词汇货架(原生预览)": "Open the vocabulary shelf (native preview)", "冲突": "Conflict", " 对": " pair(s)", "只暴露,不裁决;撤回或维持由人决定": "surfaced, never adjudicated; retracting or keeping is a human decision", "按": "Filtered by", "过滤": "", "清除": "Clear", "按此谓词过滤": "Filter by this predicate", "在图里看": "See it in the graph", " · 未升格": " · not yet promoted", "释义": "Gloss", "主词域": "Subject domain", "值域": "Range", "本体": "Ontology", "本体货架 · ": "Ontology shelf · ", "这里会长出你的本体:已确立的条目与在验的命题。": "This is where your ontology grows: established entries and propositions still in verification.", "本体图": "Ontology graph", "实体图": "Entity graph", " · 交付 ": " · delivered ", " · 人 ": " · human ", " · 在工作区外,面板不读正文": " · outside the workspace; the panel will not read it", " · 尺子 ": " · metric ", " · 执行没跑成": " · execution did not complete", " · 支持到 ": " · supported to ", " · 最近 ": " · latest ", " · 证据 ": " · evidence ", " · 车道 ": " · lanes ", " · 随步骤作废而终止": " · ended when its step was voided", " 份)。": " files).", " 份产物,但没有任何计划声明过它们。点一条可以直接看(它们不计入交付)。": " artifacts on disk, but no plan declared them. Click one to open it (they do not count toward delivery).", " 份没列出来(这一栏只列最近改动的 ": " more not listed (this column lists only the ", " 发起": " started", " 处声明": " declared", " 字节": " bytes", " 字节 · ": " bytes · ", " 字节 · 未被任何计划声明": " bytes · declared by no plan", " 字节 · 资源 ": " bytes · resources ", " 推翻:": "refuted by:", " 旁观 ": " observe ", " 条": " entries", " 条)": " entries)", " 次侦察": " scouts", " 次评估者": " evaluators", " 步": " steps", " 步)": " steps)", " 等 ": " and ", " 评估卡": " evaluation card", " 轮": " rounds", " 里打开": "", "(假设达到这一级且无推翻才升格为事实)": " (a hypothesis is promoted to fact only at this level and with no refutation)", "(每次修订留痕,旧值不删)": " (every revision is kept; old values are not deleted)", "(点一下开右栏「世界树」)": " (click to open Worldlines)", "(点一下开右栏「世界树」看拓扑)": " (click to see the topology in Worldlines)", "(留档不删)": " (kept on record, not deleted)", "(缺)": " (missing)", "(要独立评估)才达门槛": " (independent evaluation required) to reach the threshold", "),所以这个分叉没有归宿了:**随步骤作废而终止**——它既不是被人裁掉(没人做过这个决定),也不是被算术排掉(没有尺子排过它)。要收掉工作副本(保留 ref),对它调 AbandonFork(会弹人工确认)。": "), so this fork has no destination left: **it ended when its step was voided** — it was neither decided by a person (nobody made that call) nor ranked out by arithmetic (no metric ever ranked it). To drop the working copy (keeping the ref), call AbandonFork on it (it asks for human confirmation).", "),等目标验收时升格为事实": "), and is promoted to fact when the goal is accepted", ")——它不是落选:落选意味着它跑完了、被尺子排到了后面;这一条是没跑成,所以也没有读数可以参与算术。": ") — this is not a loss: losing means it ran and was ranked behind; this one did not run, so it has no reading to enter into the arithmetic.", "**执行没跑成**(": "**Execution did not complete** (", "**执行者未归**:这条世界线的执行者派出去之后没有回灌,而分叉已经收口——它再回来也没有归宿了,所以这里既不判它跑成也没跑成,也不再等它。它的产物(如果写过)还在它自己的工作副本里;要判断那条线到底做出了什么,直接看工作副本比看这条状态可靠。": "**Executor never returned**: this worldline's executor was dispatched but never reported back, and the fork has already converged — if it returned now there would be nowhere to land, so it is neither judged done nor judged failed, and it is no longer awaited. Whatever it wrote still sits in its own working copy; to judge what that line actually produced, read the working copy rather than this status.", ":还差 ": ": short by ", ";放弃缘由:": "; reason for abandoning: ", "clearai 面板:右栏页签类型注册失败 ": "clearai panel: failed to register the right-sidebar tab type ", "clearai-loop: 席位跟着会话预设进出": "clearai-loop: seats come and go with the session's preset", "世界树": "Worldlines", "世界线:": "Worldline: ", "事实": "Facts", "产物": "Deliverables", "人审查后决定撤回": "withdrawn after human review", "人已撤回(记录保留)": "withdrawn by a person (record kept)", "撤回事实": "Retract the fact", "维持原事实": "Keep the fact", "未走过 ": "untouched: ", "认可,继续": "Approve, continue", "确认撤回": "Confirm retraction", "确认撤回(记录保留,不再作为「已知」引用)": "Confirm retraction (the record is kept; it can no longer be cited as known)", "人的裁决:": "Human decision: ", "仅人可引用": "user-invocable only", "会话日志里的原生审批对(不可伪造)": "the native approval pair in the session log (cannot be forged)", "依据": "Basis", "侦 ": "S", "侦察 · ": "Scout · ", "候选": "candidate", "做什么": "What it does", "做法": "Approach", "其他(": "Other (", "出现推翻证据": "refuting evidence appeared", "出现推翻证据(终态,记录保留)": "refuting evidence appeared (terminal; record kept)", "分支": "Branch", "切回历史的世界树(计划都还在,文档也归档在 clear/goals/plans/)": "Switch back to an earlier worldline set (the plans are all still here, and their documents are archived under clear/goals/plans/)", "判据": "Criterion", "判据:": "Criterion: ", "判据待写": "criterion not written", "升格门槛": "Promotion threshold", "原生预览打不开这条路(它在工作区外?)": "The native preview cannot open this path (is it outside the workspace?)", "原生预览打开它": "Open it in the native preview", "原生预览打开它(计划声明的产物)": "Open it in the native preview (an artifact declared by the plan)", "合并目录、本会话用法、可引用可采纳": "Merged catalogue, usage in this session, invocable and adoptable", "命题": "Propositions", "命题 · ": "Propositions · ", "在": "in", "在 ": "in ", "声明的是目录;准入要求具体文件——目录不算物证": "This declares a directory; admission requires a concrete file — a directory is not physical evidence", "多问我": "Ask me more", "完成度 ": "Progress ", "完成度 —": "Progress —", "审批记录": "approval record", "工作区模板 · clear/skills": "Workspace template · clear/skills", "已交付": "delivered", "已作废": "voided", "已回灌": "reported back", "已推翻": "refuted", "已提出": "proposed", "已撤回": "withdrawn", "已收尾 · 存档可看": "closed · archived and readable", "已改版": "superseded", "已放弃": "abandoned", "已放弃探索:": "Exploration abandoned: ", "已放弃的分叉": "abandoned fork", "已替代": "superseded", "已确认": "confirmed", "已确认事实 · ": "Confirmed facts · ", "已被下一版命题替代(版本留着,不参与当前推理)": "superseded by a later version of the proposition (the version is kept but takes no part in current reasoning)", "已裁决": "decided", "已评估": "evaluated", "已达成": "achieved", "已达门槛(": "threshold reached (", "已达门槛,已升格为事实": "threshold reached; promoted to fact", "已采纳": "adopted", "待开计划": "no plan yet", "待推进": "to advance", "待裁决": "awaiting decision", "我的 · ~/.dsh": "Mine · ~/.dsh", "打开 ": "Open ", "打开「事实」那一格并展开这条命题": "Open the Facts pane and expand this proposition", "打开世界树并选中产出这条事实的验证步": "Open Worldlines and select the verification step that produced this fact", "打开世界树并选中产生这条证据的验证步": "Open Worldlines and select the verification step that produced this evidence", "打开失败:HTTP ": "Open failed: HTTP ", "打开计划文档(原生预览)": "Open the plan document (native preview)", "技能 · 记忆": "Skills · Memory", "探索中": "exploring", "推翻": "refute", "推进中": "in progress", "提交中…": "Submitting…", "提交失败:": "Submit failed: ", "支持": "support", "支持到 ": "supported to ", "收敛": "converge", "收束:": "Closed with: ", "收起": "Collapse", "收起详情": "Collapse details", "放弃了这次探索": "abandoned this exploration", "放弃探索": "Abandon exploration", "放弃缘由(必填)": "Reason for abandoning (required)", "放弃这条分叉": "Abandon this fork", "放弃这次探索(留档不删,ref 保留)": "Abandon this exploration (kept on record, ref preserved)", "放行": "release", "旁观写这条裁决的评估者子会话(论证过程)": "Observe the evaluator sub-session that wrote this verdict (the reasoning process)", "旁观评估者": "Observe evaluator", "旁观这条世界线的评估者会话(只读)": "Observe this worldline's evaluator session (read-only)", "无法判定": "inconclusive", "是目录(不算物证)": "is a directory (not physical evidence)", "最后改动 ": "Last changed ", "未分类": "Uncategorised", "未声明": "not declared", "未收口(随步骤作废而终止)": "not closed (ended when its step was voided)", "未知": "unknown", "未走:": "Not taken: ", "未采纳": "not adopted", "本会话 模型 ": "This session — model ", "本项目 · .dsh / .agents": "This project · .dsh / .agents", "本项目写的 · clear/skills": "Written by this project · clear/skills", "核心产物(": "Core deliverables (", "步 ": "step ", "派出 ": "dispatched ", "派生 · ": "derived · ", "版本": "Version", "状态": "Status", "独立评估者": "independent evaluator", "用原生预览打开章程(它每回合整份注入模型上下文)": "Open the charter in the native preview (it is injected whole into the model's context every turn)", "盘上已有(": "Already on disk (", "盘上没有": "not on disk", "盘上没有这个文件": "this file is not on disk", "目录": "directory", "目录里已经没有(": "no longer in the catalogue (", "目标": "Goal", "目标挂起": "goal suspended", "确认放弃": "Confirm abandon", "确认放弃(留档不删,ref 保留)": "Confirm abandon (kept on record, ref preserved)", "等独立裁决": "waiting for an independent verdict", "策略暂停": "paused by policy", "续跑:多问我——每个阶段收尾就停下,等你给下一阶段(文档里叫「人在场」)。点一下切成「自己拿主意」。": "Continuation: ask me more — it stops at the end of each stage and waits for you to give the next one (called \"attended\" in the docs). Click to switch to \"decide for yourself\".", "续跑:自己拿主意——立约即授权,按轮数自己往下跑,只在不可约的判断上开门(文档里叫「无人值守」)。点一下切成「多问我」。": "Continuation: decide for yourself — committing a plan is the authorisation, and it keeps going for a set number of rounds, opening a gate only for decisions it cannot reduce (called \"unattended\" in the docs). Click to switch to \"ask me more\".", "续跑停着:": "Continuation is stopped: ", "续跑已撤回": "Continuation was withdrawn", "缘由必填": "A reason is required", "缺": "missing", "自判": "self-judged", "自定义": "custom", "自己拿主意": "Decide for yourself", "被 ": "by ", "被下一版命题改写": "rewritten by a later version of the proposition", "裁决": "Verdict", "裁决:采纳 ": "Verdict: adopt ", "要你": "needs you", "观测": "Observation", "计划": "Plan", "计划 ": "Plan ", "计划受阻,等人处置": "plan blocked, waiting for a person", "计划在建,**等你确认**": "plan is being built, **waiting for your confirmation**", "计划已交付 ": "Plan delivered ", "计划已收尾(": "Plan closed (", "计划待确认": "plan awaiting confirmation", "计划文档": "Plan document", "记忆(": "Memory (", "记忆索引": "Memory index", "证据": "Evidence", "证据 ": "Evidence ", "评 ": "E", "评估": "Evaluation", "评估卡": "evaluation card", "评估者": "Evaluator", "评估者 ": "Evaluator ", "评估者会话 ": "Evaluator session ", "评估者在裁决": "an evaluator is deciding", "读不到交付物:": "Cannot read deliverables: ", "读取中…": "Reading…", "读数": "Reading", "读数(尺子 ": "Reading (metric ", "起过 ": "ran ", "跑着": "running", "车道 · ": "Lane · ", "边界:": "Scope: ", "运行时注册": "registered at runtime", "还有 ": "and ", "还没交付": "not delivered yet", "这一步已作废(缘由:": "This step was voided (reason: ", "这一步没有声明产物。": "This step declares no artifacts.", "这个会话还没开始:面板的数据来自会话日志,发第一句话之后,这里会显示已确认的事实与正在流转的命题。": "This session has not started: the panels read the session log, so after your first message this will show confirmed facts and the propositions in flight.", "这个会话还没有 ClearAI 的状态。": "This session has no ClearAI state yet.", "这个工作区盘上已经有 ": "This workspace already has ", "进度": "Progress", "采纳": "Adopt", "采纳 ": "Adopt ", "采纳:改写 frontmatter,模型从此加载得到它": "Adopt: rewrites the frontmatter so the model can load it from then on", "采纳了某条世界线": "adopted one worldline", "采纳此世界线": "Adopt this worldline", "问题:": "Question: ", "阶段": "Stage", "阶段 ": "Stage ", "阶段交界": "at a stage boundary", "需要你 ": "needs you ", "面板动作失败:": "Panel action failed: ", "项目章程": "Project charter", "预设自带": "shipped with the preset", "验证": "Verification", "验证中": "verifying", "这次采纳没有合并:": "This adoption was not merged: ", "(决定已登记,产物由一次普通交付落位)": " (the decision is on record; a normal delivery places the artifacts)", "分支或工作副本已不在": "its branch or working copy is gone", "怎么补这一级?": "How do I fill in this level?", "收起这一级要交的东西": "Hide what this level requires", "读不到等级说明": "Level descriptions are unavailable", "这一级看什么:": "What this level looks at: ", "这一级要交什么:": "What this level must hand in: ", "这一级要检查的对象:": "Objects this level must check: ", "这条命题还没写明断言主体:先用 RegisterInstance 把实例连出处登记下来。": "This proposition names no assertion subject yet: use RegisterInstance to register the instance together with its provenance.", "reason 怎么写:": "How to write the reason: ", "reason 里必须点到上面这些对象名,不能写「时间不够」。": "The reason must name those objects above; \"not enough time\" does not count.", "跳级本身不违规:要交的是「这一级为什么不适用」的理由,不是这一级的读数。": "Skipping a level is not itself a violation: what is owed is why this level does not apply here, not a reading for it.", "缺口": "Gaps", "语言还没立:概念与谓词都还是空的": "No language yet: both concepts and predicates are empty", "命题只有散文主张:没有能被机器比对的断言": "Prose-only proposition: it has no assertion a machine can compare", "升格的事实没带断言:它进不了实体图": "A promoted fact carries no assertion, so it cannot enter the entity graph", "命题没被任何证据碰过": "No evidence has touched this proposition", "断言主体还没落到实体图": "Assertion subjects have not landed on the entity graph", "跳级没写理由": "A level was skipped without a reason", "概念没有任何结论引用": "No conclusion cites this concept", "未登记的缺口类型": "Unregistered gap type", "下一步:": "Next: ", "看实体图": "Show the entity graph", "切到实体图那一层,看有哪些实例节点": "Switch to the entity layer to see which instance nodes exist", "这一层还没有实例节点。": "No instance nodes have landed on this layer yet.", "实例靠 RegisterInstance 登记(带出处);断言挂在命题上不算「已知」。": "Instances arrive through RegisterInstance, with provenance; an assertion left on a proposition does not count as known.", " 个断言主体还没落到这一层:": " assertion subjects have not landed on this layer: ", "先 RegisterInstance 把实例连出处登记下来;确实不值得留下形态就如实说清": "First register the instance with RegisterInstance, provenance included; if it truly does not deserve a lasting shape, say so plainly", "用 ExplainLevelSkip 写明「为什么这一级在本项目里不适用」": "Use ExplainLevelSkip to state why this level does not apply in this project", "要么在断言里用起来,要么在货架上如实标出「未被引用」": "Either put it to use in an assertion, or mark it plainly on the shelf as uncited", "交给模型的写法:": "How to hand it to the model: ", "推理自检:结论只是自己推了一遍,没有引入任何外部输入": "Reasoning self-check: the conclusion is only your own derivation, with no external input brought in", "已有知识:引用自己或别人手上已有的材料": "Existing knowledge: citing material you or someone else already has at hand", "可复算:照一份能重跑的步骤自己算一遍": "Reproducible: work it through yourself from a set of steps that can be re-run", "独立裁决:由另一个评估者读产物后给结论": "Independent verdict: another evaluator reads the artifact and gives the conclusion", "人放行:交付前有人看过并批准": "Human release: a person has looked at it and approved before delivery", "还没建计划:先想清楚要怎么回答": "No plan yet: work out how the question will be answered first", "执行中:有活动计划且还有未落定的步": "Executing: there is an active plan with steps still open", "阶段边界:当前计划的步都落定了,该结案或起新计划": "Stage boundary: every step of the current plan has landed; close the goal or plan the next stage", "在等裁决:有交付/结案在飞,或上一次裁决还没回来": "Awaiting verdict: a delivery or closure is in flight, or the last verdict has not returned", "卡住了:连续几次没通过观测准入,停下等人": "Stalled: admission failed several times in a row; stopped and waiting for a person", "目标已达成(终局)": "Goal achieved (terminal)", "目标已如实放弃(终局)": "Goal abandoned honestly (terminal)", "已登记:某实例在某出处下被登记下来(一等写入口)": "Registered: an instance was recorded against a provenance (a first-class write path)", "已升格:来自过了独立裁决的事实断言": "Promoted: an assertion from a fact that passed an independent verdict", "实体断言:登记那一刻就成立的边,有出处但未经独立裁决": "Asserted edge: holds from the moment it was recorded, with provenance but no independent verdict", "支持到哪一级:所有支持证据里最高的那一级": "Supported to: the highest level among supporting evidence", "从没走过的等级:已用到最高级之下、一条证据都没有的级": "Untouched levels: levels below the highest one used that have no evidence at all", "被推翻次数:收到过几条推翻证据": "Refutations: how many refuting pieces of evidence arrived", "无法判定次数:判过但判不出来": "Inconclusive: judged, but the material would not settle it", "还没有概念与谓词:换一轮只能靠重读散文取用结论": "No concepts or predicates yet: reusing conclusions means re-reading prose", "命题只有散文主张:两条结论是不是在说同一件事只能靠重读判断": "Prose-only claim: whether two conclusions say the same thing can only be decided by re-reading", "已升格事实没带断言:进不了实体图,也不能按概念取用": "A promoted fact carries no assertion: it cannot enter the entity graph or be fetched by concept", "有命题一条证据都没碰过:没看过不等于没问题": "Some claim has never been touched by evidence: unlooked is not the same as fine", "断言的主体还没有落到实体图上:句子只挂在命题上,不构成「已知」": "Assertion subjects have not landed on the entity graph: the sentence hangs on a proposition and is not yet known", "有等级被跳过而没写理由:跳级不违规,但要说清为什么不适用": "A level was skipped with no reason recorded: skipping is allowed, but say why it does not apply", "有概念没有任何结论引用:它们还只是约定,不是已知": "A concept is cited by no conclusion: it is still only a convention, not knowledge", "判据没改过:它还是立约时那一份(要原文读账本里的 done_criteria)": "The criterion has not changed: it is still the one registered at commit time (read done_criteria from the ledger)", "判据改动要有一份独立裁决:改「怎样算完成」不能被顺手做掉": "Changing the criterion needs an independent verdict: redefining done must not happen as a side effect", "宿主会话服务读不到:这一刻拿不到会话,写盘可能写到错地方": "The host session service is unreadable: no session right now, so writing could land in the wrong place", "投影服务读不到:这一刻的读数是空的,不是「没有」": "The projection service is unreadable: readings are empty right now, which is not the same as nothing", " · 改过 ": " · changed ", " 次": " times", " · 最近一次修订的独立裁决:": " · latest revision decided by an independent verdict: ", "全文在 ": "Full text at ", "打开目标文档(原生预览)": "Open the goal document (native preview)", "背景(不参与判定):": "Background (not part of the verdict): "}
+		const LOCALE_ZH = {":":":"," · 改过 ":" · 改过 "," · 最近一次修订的独立裁决:":" · 最近一次修订的独立裁决:"," 次":" 次"," 次评估者":" 次评估者"," 步":" 步"," 步)":" 步)"," 看核验记录":" 看核验记录"," 看核验过程":" 看核验过程"," 轮":" 轮","(点一下开右栏「世界树」)":"(点一下开右栏「世界树」)","(点一下开右栏「世界树」看拓扑)":"(点一下开右栏「世界树」看拓扑)","(缺)":"(缺)","clearai 面板:右栏页签类型注册失败 ":"clearai 面板:右栏页签类型注册失败 ","clearai-loop: 席位跟着会话预设进出":"clearai-loop: 席位跟着会话预设进出","」相关的":"」相关的","一句话":"一句话","一步检验":"一步检验","上位":"上位","下一步:找一步去检验它":"下一步:找一步去检验它","下一步:换个办法再检验":"下一步:换个办法再检验","下一步:独立核验通过 → 已验证":"下一步:独立核验通过 → 已验证","下一步:结案时写进长期知识":"下一步:结案时写进长期知识","下位":"下位","不确定":"不确定","世界树":"世界树","主语":"主语","事实":"事实","产物":"产物","人撤回":"人撤回","人放行":"人放行","代码":"代码","依据":"依据","值的形态":"值的形态","做什么":"做什么","入本体":"入本体","全屏":"全屏","全文在 ":"全文在 ","公式":"公式","关系":"关系","关闭":"关闭","写进长期知识":"写进长期知识","出自":"出自","切回历史的世界树(计划都还在,文档也归档在 clear/goals/plans/)":"切回历史的世界树(计划都还在,文档也归档在 clear/goals/plans/)","判据":"判据","判据:":"判据:","判断":"判断","原生预览打开它":"原生预览打开它","原生预览打开它(计划声明的产物)":"原生预览打开它(计划声明的产物)","取不到":"取不到","取值":"取值","只看与「":"只看与「","只看相关":"只看相关","可信度怎么变的":"可信度怎么变的","可复算":"可复算","命题":"命题","图组件不可用":"图组件不可用","在图上找它":"在图上找它","在检验这一站被推翻,不再往下走。":"在检验这一站被推翻,不再往下走。","实体图":"实体图","实体图还空着。":"实体图还空着。","实例":"实例","审批记录":"审批记录","已交付":"已交付","已作废":"已作废","已推翻":"已推翻","已提出":"已提出","已收尾 · 存档可看":"已收尾 · 存档可看","已替换":"已替换","已被替换,不再往下走。":"已被替换,不再往下走。","已验证":"已验证","引用":"引用","引用已有材料":"引用已有材料","待推进":"待推进","待核验":"待核验","打开「本体」那一格并展开这条结论":"打开「本体」那一格并展开这条结论","打开目标文档(原生预览)":"打开目标文档(原生预览)","打开计划文档(原生预览)":"打开计划文档(原生预览)","推翻":"推翻","提出":"提出","支持":"支持","收起":"收起","收起详情":"收起详情","放行":"放行","数值":"数值","暂无计划。建立后此处显示计划的步骤与闸门。":"暂无计划。建立后此处显示计划的步骤与闸门。","有 ":"有 ","有矛盾":"有矛盾","未声明":"未声明","本体":"本体","本体图":"本体图","查看此步骤的证据":"查看此步骤的证据","查看步骤详情":"查看步骤详情","查看评估者":"查看评估者","检验":"检验","检验结果:":"检验结果:","概念":"概念","正在取…":"正在取…","正在裁决":"正在裁决","步 ":"步 ","清除":"清除","点击查看详情":"点击查看详情","点开看进度和来历":"点开看进度和来历","状态":"状态","独立核验":"独立核验","独立核验:":"独立核验:","用到它的结论":"用到它的结论","盘上没有这个文件":"盘上没有这个文件","目标":"目标","相关":"相关","看核验":"看核验","看记录":"看记录","矛盾":"矛盾","第 n 步":"第 n 步","算错":"算错","类型":"类型","结论":"结论","结论照常可读。":"结论照常可读。","背景(不参与判定):":"背景(不参与判定):","自己推了一遍":"自己推了一遍","自己检验":"自己检验","范围":"范围","范围:":"范围:","补充":"补充","观测":"观测","计划":"计划","计划 ":"计划 ","计划受阻,等人处置":"计划受阻,等人处置","计划已交付 ":"计划已交付 ","计划已收尾(":"计划已收尾(","计划文档":"计划文档","计划的步骤与闸门":"计划的步骤与闸门","证据":"证据","评 ":"评 ","评估":"评估","评估卡":"评估卡","起过 ":"起过 ","还没有内容。发第一条消息后,这里显示本体图和结论。":"还没有内容。发第一条消息后,这里显示本体图和结论。","还没有立目标":"还没有立目标","还没有结论。模型立下判断之后,这里一行一条。":"还没有结论。模型立下判断之后,这里一行一条。","这一项已经不在当前的词里了(可能刚被废止)。":"这一项已经不在当前的词里了(可能刚被废止)。","这个词已废止,旧结论里的用法照样可读。":"这个词已废止,旧结论里的用法照样可读。","进度":"进度","退出全屏":"退出全屏","适配":"适配","释义":"释义","待处理":"待处理","待处理 ":"待处理 ","验证":"验证","验证中":"验证中","展开下一层":"展开下一层","收起下一层":"收起下一层","本体文件有 ":"本体文件有 "," 处问题(这些不进图)":" 处问题(这些不进图)"," 个断言的主语还没写成实体文件。":" 个断言的主语还没写成实体文件。","clear/ontology/entities/ 下的实体文件、写进长期知识的断言会出现在这里。":"clear/ontology/entities/ 下的实体文件、写进长期知识的断言会出现在这里。","本体图还空着。模型在 clear/ontology/concepts/ 和 relations/ 下写概念与关系文件之后,它们会长在这里。":"本体图还空着。模型在 clear/ontology/concepts/ 和 relations/ 下写概念与关系文件之后,它们会长在这里。"}
+		const LOCALE_EN = {":":": "," · 改过 ":" · changed "," · 最近一次修订的独立裁决:":" · latest revision decided by an independent verdict: "," 次":" times"," 次评估者":" evaluators"," 步":" steps"," 步)":" steps)"," 看核验记录":" Review record"," 看核验过程":" Watch the review"," 轮":" rounds","(点一下开右栏「世界树」)":" (click to open the World Tree)","(点一下开右栏「世界树」看拓扑)":" (click to see the steps in the World Tree)","(缺)":" (missing)","clearai 面板:右栏页签类型注册失败 ":"clearai panel: failed to register the right-sidebar tab type ","clearai-loop: 席位跟着会话预设进出":"clearai-loop: seats come and go with the session's preset","」相关的":"\"","一句话":"Statement","一步检验":"A test","上位":"Broader","下一步:找一步去检验它":"Next: test it in a step","下一步:换个办法再检验":"Next: test it another way","下一步:独立核验通过 → 已验证":"Next: independent check passes → Verified","下一步:结案时写进长期知识":"Next: written to long-term knowledge at close","下位":"Narrower","不确定":"Uncertain","世界树":"World Tree","主语":"Subject","事实":"Facts","产物":"Deliverables","人撤回":"Withdrawn by a person","人放行":"Released by a person","代码":"Code","依据":"Basis","值的形态":"Value form","做什么":"What it does","入本体":"In ontology","全屏":"Full screen","全文在 ":"Full text at ","公式":"Formula","关系":"Relation","关闭":"Close","写进长期知识":"Written to long-term knowledge","出自":"From","切回历史的世界树(计划都还在,文档也归档在 clear/goals/plans/)":"Switch back to an earlier World Tree (the plans are all still here, and their documents are archived under clear/goals/plans/)","判据":"Criterion","判据:":"Criterion: ","判断":"Judgment","原生预览打开它":"Open it in the native preview","原生预览打开它(计划声明的产物)":"Open it in the native preview (an artifact declared by the plan)","取不到":"Unavailable","取值":"Value","只看与「":"Only related to \"","只看相关":"Only related","可信度怎么变的":"How trust changed","可复算":"Reproducible","命题":"Propositions","图组件不可用":"The graph component is unavailable","在图上找它":"Find it on the graph","在检验这一站被推翻,不再往下走。":"Refuted at the test stage; it goes no further.","实体图":"Entity graph","实体图还空着。":"The entity graph is empty. ","实例":"Instances","审批记录":"approval record","已交付":"delivered","已作废":"voided","已推翻":"Refuted","已提出":"proposed","已收尾 · 存档可看":"closed · archived and readable","已替换":"Replaced","已被替换,不再往下走。":"Replaced; it goes no further.","已验证":"Verified","引用":"Reference","引用已有材料":"Cites existing material","待推进":"to advance","待核验":"Awaiting check","打开「本体」那一格并展开这条结论":"Open the Ontology pane and expand this conclusion","打开目标文档(原生预览)":"Open the goal document (native preview)","打开计划文档(原生预览)":"Open the plan document (native preview)","推翻":"Refute","提出":"Proposed","支持":"Support","收起":"Collapse","收起详情":"Collapse details","放行":"release","数值":"Quantity","暂无计划。建立后此处显示计划的步骤与闸门。":"No plan yet. Once created, its steps show here.","有 ":"","有矛盾":"Conflicting","未声明":"not declared","本体":"Ontology","本体图":"Ontology graph","查看此步骤的证据":"see the evidence for this step","查看步骤详情":"view step details","查看评估者":"view evaluator","检验":"Test","检验结果:":"Result: ","概念":"concepts","正在取…":"Loading…","正在裁决":"Deciding","步 ":"step ","清除":"Clear","点击查看详情":"click for details","点开看进度和来历":"Open to see progress and history","状态":"Status","独立核验":"Independent check","独立核验:":"Independent check: ","用到它的结论":"Conclusions using it","盘上没有这个文件":"this file is not on disk","目标":"Goal","相关":"Related","看核验":"See check","看记录":"See record","矛盾":"Conflicts","第 n 步":"Step n","算错":"Wrong if","类型":"Type","结论":"CONCLUSIONS","结论照常可读。":"conclusions are still readable.","背景(不参与判定):":"Background (not part of the verdict): ","自己推了一遍":"Reasoned through alone","自己检验":"Self-tested","范围":"Scope","范围:":"Scope: ","补充":"More","观测":"Observation","计划":"Plan","计划 ":"Plan ","计划受阻,等人处置":"plan blocked, waiting for a person","计划已交付 ":"Plan delivered ","计划已收尾(":"Plan closed (","计划文档":"Plan document","计划的步骤与闸门":"Plan steps","证据":"Evidence","评 ":"E","评估":"Evaluation","评估卡":"evaluation card","起过 ":"ran ","还没有内容。发第一条消息后,这里显示本体图和结论。":"Nothing yet. After the first message, the graph and conclusions show here.","还没有立目标":"No goal yet","还没有结论。模型立下判断之后,这里一行一条。":"No conclusions yet. Each judgment gets one line here.","这一项已经不在当前的词里了(可能刚被废止)。":"This item is no longer in the vocabulary (it may have just been deprecated).","这个词已废止,旧结论里的用法照样可读。":"This term is deprecated; older conclusions still read fine.","进度":"Progress","退出全屏":"Exit full screen","适配":"Fit","释义":"Gloss","待处理":"To handle","待处理 ":"to handle ","验证":"Verification","验证中":"Testing","展开下一层":"Expand the next level","收起下一层":"Collapse the next level","本体文件有 ":"Ontology files have "," 处问题(这些不进图)":" problems (these stay off the graph)"," 个断言的主语还没写成实体文件。":" assertion subjects have no entity file yet. ","clear/ontology/entities/ 下的实体文件、写进长期知识的断言会出现在这里。":"Entity files under clear/ontology/entities/ and assertions in long-term knowledge appear here.","本体图还空着。模型在 clear/ontology/concepts/ 和 relations/ 下写概念与关系文件之后,它们会长在这里。":"The ontology graph is empty. Concepts and relations appear once the model writes files under clear/ontology/concepts/ and relations/."}
 
 		/**
 		 * 翻译函数:**由原生 locale 座位绑定**(`ctx.locale.bind`),不是我们自建的一套 i18n。
@@ -231,56 +231,11 @@ window.__ModuleLoader__.load({
 		 */
 		const inject = ['slots', 'sessions', 'sidebarRightTabs', 'sidebarRight']
 
-		const PHASE = lazyTable(() => ({
-			drafting: t('判据待写'),
-			planning: t('待开计划'),
-			executing: t('推进中'),
-			waiting: t('等待中'),
-			stage_boundary: t('阶段交界'),
-			auditing: t('评估者在裁决'),
-			stalled: t('等待人工'),
-			suspended: t('目标挂起'),
-			achieved: t('已达成'),
-			abandoned: t('已放弃'),
-			superseded: t('已改版'),
-		}))
-		const HYPOTHESIS = lazyTable(() => ({
-			proposed: t('已提出'),
-			alive: t('验证中'),
-			confirmed: t('已确认'),
-			/** 规范词是「已替代」(与验证本体同词);「已改版」是旧写法。 */
-			refuted: t('已推翻'),
-			superseded: t('已替代'),
-			retracted: t('已撤回'),
-		}))
 		const STEP = lazyTable(() => ({ open: t('待推进'), advanced: t('已交付'), void: t('已作废') }))
-		const VERDICT = lazyTable(() => ({ support: t('支持'), refute: t('推翻'), inconclusive: t('无法判定') }))
-		const EVALUATOR = lazyTable(() => ({ self: t('自判'), independent: t('独立评估者') }))
-		const BRANCH_STATUS = lazyTable(() => ({ exploring: t('探索中'), evaluated: t('已评估'), adopted: t('已采纳'), pruned: t('未采纳') }))
-		/** 人在面板上做过的裁决(树详情里要如实回放:谁、以什么理由)。 */
-		const FORK_ACTION = lazyTable(() => ({ adopt_branch: t('采纳了某条世界线'), abandon_fork: t('放弃了这次探索') }))
-		/** 侦察的三种结局(与 fold 的派生同源):跑着 / 正常回灌 / 没正常结束。 */
-		const SCOUT = lazyTable(() => ({ running: t('跑着'), settled: t('已回灌'), failed: t('异常终止') }))
-
-		/**
-		 * **缺口 code → 人话标签**。code 是机器词(`no_language` 这类),**不上屏**——
-		 * 人看到的是这一句。允许的 code 在这里是**显式清单**:表本身是惰性代理,
-		 * 用 `in` 判会把 `toString` 这类原型上的键也认成缺口类型。
-		 * 表里的每一句都在 LOCALE_ZH / LOCALE_EN 里成对登记(与其余面向人的串同一规矩)。
-		 */
-		const GAP_CODES = ['no_language', 'prose_only_claims', 'unstructured_facts', 'untouched_claims', 'entities_unlanded', 'levels_skipped', 'orphan_terms']
-		const GAP_LABEL = lazyTable(() => ({
-			no_language: t('语言还没立:概念与谓词都还是空的'),
-			prose_only_claims: t('命题只有散文主张:没有能被机器比对的断言'),
-			unstructured_facts: t('升格的事实没带断言:它进不了实体图'),
-			untouched_claims: t('命题没被任何证据碰过'),
-			entities_unlanded: t('断言主体还没落到实体图'),
-			levels_skipped: t('跳级没写理由'),
-			orphan_terms: t('概念没有任何结论引用'),
-		}))
-
-		const STRONG = { refuted: true, stalled: true, refute: true }
-
+		const VERDICT = lazyTable(() => ({ support: t('支持'), refute: t('推翻'), inconclusive: t('不确定') }))
+		
+		/** 「第 n 步」:整句做一个词条,英文才排得成 Step n。 */
+		const nth = (n) => t('第 n 步').replace('n', String(n))
 		const dash = (value) => (value === null || value === undefined || value === '' ? '—' : String(value))
 		const gloss = (table, value) => (value === null || value === undefined ? '—' : `${table[value] ?? value}`)
 		const when = (at) => {
@@ -329,14 +284,124 @@ window.__ModuleLoader__.load({
 .clearai-treerow{display:flex;align-items:center;gap:6px;padding:0 6px;cursor:pointer;border-radius:4px;transition:background .12s}
 .clearai-treerow:hover{background:var(--dsw-alias-interactive-bg-hover)}
 .clearai-treerow[data-sel="1"]{background:var(--dsw-alias-interactive-bg-active, var(--dsw-alias-interactive-bg-hover))}
+/* ── 本体格(第六阶段):期刊式排版 + 进度轨。颜色只用主题令牌,深浅色跟着宿主走。 ── */
+.clearai-atlas{height:100%;overflow-y:auto;box-sizing:border-box;padding:22px 26px 180px;font-size:13px;line-height:1.6;color:var(--dsw-alias-label-primary)}
+.clearai-serif,.clearai-question,.clearai-row-title,.clearai-card-title,.clearai-star>span{font-family:ui-serif,"Songti SC","Noto Serif SC","Source Han Serif SC",Georgia,serif}
+.clearai-head{display:flex;flex-direction:column;gap:6px;padding-bottom:16px;margin-bottom:16px;border-bottom:.5px solid var(--dsw-alias-border-l2)}
+.clearai-question{font-size:19px;font-weight:600;line-height:1.45;letter-spacing:.01em}
+.clearai-counts{font-size:12px;color:var(--dsw-alias-label-secondary)}
+.clearai-need{display:flex;gap:8px;align-items:baseline;font-size:12.5px;padding:4px 10px;border-left:2px solid var(--dsw-alias-state-warn-primary);background:var(--dsw-alias-bg-layer-1);border-radius:0 6px 6px 0}
+.clearai-need b{font-weight:600;color:var(--dsw-alias-state-warn-primary);white-space:nowrap}
+.clearai-track{display:flex;align-items:center;gap:8px;margin-top:6px;font-size:11.5px;color:var(--dsw-alias-label-tertiary)}
+.clearai-track-stop{display:inline-flex;align-items:center;gap:5px;white-space:nowrap}
+.clearai-track-stop i{width:7px;height:7px;border-radius:50%;border:1px solid var(--dsw-alias-border-l3);box-sizing:border-box}
+.clearai-track-stop[data-on="1"]{color:var(--dsw-alias-label-primary)}
+.clearai-track-stop[data-on="1"] i{background:var(--dsw-alias-label-primary);border-color:var(--dsw-alias-label-primary)}
+.clearai-track-line{flex:1 1 18px;max-width:56px;height:1px;background:var(--dsw-alias-border-l2)}
+.clearai-track-line[data-on="1"]{background:var(--dsw-alias-label-secondary)}
+/* 图 */
+.clearai-graph{margin-bottom:18px}
+.clearai-graph[data-full="1"]{position:fixed;inset:0;z-index:40;background:var(--dsw-alias-bg-base);padding:16px 20px;display:flex;flex-direction:column;margin:0}
+.clearai-graph-bar{display:flex;align-items:center;gap:14px;margin-bottom:8px;font-size:12px}
+.clearai-seg{display:inline-flex;border:.5px solid var(--dsw-alias-border-l3);border-radius:999px;padding:2px}
+.clearai-seg>span{padding:2px 12px;border-radius:999px;cursor:pointer;color:var(--dsw-alias-label-secondary);white-space:nowrap}
+.clearai-seg>span[data-on="1"]{background:var(--dsw-alias-label-primary);color:var(--dsw-alias-label-primary-inverted)}
+.clearai-legend{display:inline-flex;gap:12px;color:var(--dsw-alias-label-tertiary);font-size:11.5px}
+.clearai-legend>span{display:inline-flex;align-items:center;gap:5px}
+.clearai-legend>span::before{content:"";width:16px;border-top:1.3px solid var(--dsw-alias-label-secondary)}
+.clearai-legend>span[data-l="dash"]::before{border-top-style:dashed;border-top-color:var(--dsw-alias-label-tertiary)}
+.clearai-legend>span[data-l="warn"]::before{border-top-color:var(--dsw-alias-state-warn-primary)}
+.clearai-graph-body{display:flex;flex-direction:column;gap:10px;min-height:0}
+.clearai-graph[data-full="1"] .clearai-graph-body{flex:1 1 auto}
+.clearai-graph-body[data-side="1"]{flex-direction:row}
+.clearai-graph-canvas{height:340px;border:.5px solid var(--dsw-alias-border-l2);border-radius:10px;overflow:hidden;background:var(--dsw-alias-bg-base)}
+.clearai-graph[data-full="1"] .clearai-graph-canvas{height:auto;flex:1 1 auto;min-width:0}
+.clearai-graph-side{flex:0 0 auto}
+.clearai-graph-body[data-side="1"] .clearai-graph-side{width:380px;overflow-y:auto}
+.clearai-graph-problems{margin-top:6px;font-size:11.5px;color:var(--dsw-alias-label-secondary)}.clearai-graph-problems summary{cursor:pointer;color:var(--dsw-alias-state-warn-primary)}.clearai-graph-problems>div{padding:2px 0 2px 12px;line-height:1.5}.clearai-graph-problems>div[data-sev=info]{opacity:.7}.clearai-graph-problems code{font-size:11px}
+.clearai-fold{margin-left:2px;padding:0 4px;border-radius:6px;font-weight:500;font-size:10.5px;color:var(--dsw-alias-label-secondary);background:var(--dsw-alias-bg-l2,rgba(127,127,127,.12));cursor:pointer}
+.clearai-graph-empty{height:150px;display:flex;align-items:center;justify-content:center;text-align:center;padding:0 24px;border:.5px dashed var(--dsw-alias-border-l3);border-radius:10px;color:var(--dsw-alias-label-secondary);font-size:12.5px}
+.react-flow__node.clearai-star-node .react-flow__handle{opacity:0;pointer-events:none;left:4.5px;top:50%;transform:translate(-50%,-50%);min-width:0;min-height:0;width:1px;height:1px;border:0}
+.react-flow__node.clearai-star-node.selected,.react-flow__node.clearai-star-node:focus{box-shadow:none;outline:none}
+.clearai-star{display:inline-flex;align-items:center;gap:6px;white-space:nowrap;font-size:12.5px;color:var(--dsw-alias-label-primary);cursor:pointer}
+.clearai-star>i{flex:0 0 auto;width:9px;height:9px;border-radius:50%;box-sizing:border-box;border:1.4px solid var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-base)}
+.clearai-star[data-kind="instance"]>i{background:var(--dsw-alias-label-primary)}
+.clearai-star[data-kind="literal"]>i{width:6px;height:6px;border:0;background:var(--dsw-alias-label-secondary)}
+.clearai-star[data-kind="literal"]{color:var(--dsw-alias-label-secondary);font-size:11.5px}
+.clearai-star[data-kind="value_type"]>i{border-radius:2px;width:8px;height:8px;border-color:var(--dsw-alias-label-tertiary)}
+.clearai-star[data-kind="value_type"]{color:var(--dsw-alias-label-secondary);font-size:11.5px}
+.clearai-star[data-state="pending"]>i{border-style:dashed;background:var(--dsw-alias-bg-base);border-color:var(--dsw-alias-label-secondary)}
+.clearai-star[data-state="off"]{opacity:.45}
+.clearai-star[data-state="off"]>i{border-style:dashed}
+.clearai-star[data-state="conflict"]>i{border-color:var(--dsw-alias-state-warn-primary);background:var(--dsw-alias-state-warn-primary)}
+.clearai-star[data-sel="1"]>i{box-shadow:0 0 0 4px var(--dsw-alias-interactive-bg-hover)}
+.clearai-star[data-sel="1"]>span{font-weight:600}
+/* 小卡 */
+.clearai-card{display:flex;flex-direction:column;gap:8px;padding:12px 14px;border:.5px solid var(--dsw-alias-border-l2);border-radius:10px;background:var(--dsw-alias-bg-layer-1)}
+.clearai-card-head{display:flex;align-items:baseline;gap:8px;font-size:12px}
+.clearai-card-kind{font-size:11px;color:var(--dsw-alias-label-tertiary);letter-spacing:.06em}
+.clearai-card-title{font-size:15px;font-weight:600}
+.clearai-card-facts{display:flex;flex-direction:column;gap:4px}
+.clearai-card-fact{display:flex;align-items:baseline;gap:8px;flex-wrap:wrap;font-size:12.5px}
+/* 结论 */
+.clearai-section-head{font-size:11px;letter-spacing:.14em;color:var(--dsw-alias-label-tertiary);margin:4px 0 4px}
+.clearai-filter{display:flex;gap:10px;align-items:baseline;font-size:12px;color:var(--dsw-alias-label-secondary);margin:-8px 0 12px}
+.clearai-list{display:flex;flex-direction:column;gap:10px}
+.clearai-group-head{display:flex;gap:6px;align-items:baseline;font-size:11.5px;color:var(--dsw-alias-label-secondary);margin:6px 0 2px}
+.clearai-group-head>span{color:var(--dsw-alias-label-tertiary)}
+.clearai-row{border-top:.5px solid var(--dsw-alias-border-l1)}
+.clearai-row[data-open="1"]{background:var(--dsw-alias-bg-layer-1);border-radius:8px;border-top-color:transparent}
+.clearai-row-head{display:flex;align-items:baseline;gap:10px;padding:7px 8px;cursor:pointer;border-radius:8px}
+.clearai-row-head:hover{background:var(--dsw-alias-interactive-bg-hover)}
+.clearai-row-title{font-size:14px;font-weight:500;white-space:nowrap}
+.clearai-row-sub{flex:1 1 auto;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:12px;color:var(--dsw-alias-label-secondary)}
+.clearai-row-step{margin-left:auto;font-size:11.5px;color:var(--dsw-alias-label-tertiary);white-space:nowrap}
+.clearai-row[data-trust="replaced"] .clearai-row-title{text-decoration:line-through;color:var(--dsw-alias-label-tertiary)}
+.clearai-trust{flex:0 0 auto;display:inline-block;font-size:11px;line-height:16px;padding:0 7px;border-radius:999px;border:.5px solid var(--dsw-alias-label-primary);color:var(--dsw-alias-label-primary);white-space:nowrap}
+.clearai-trust[data-trust="credible"]{background:var(--dsw-alias-label-primary);color:var(--dsw-alias-label-primary-inverted)}
+.clearai-trust[data-trust="testing"]{border-color:var(--dsw-alias-border-l3);color:var(--dsw-alias-label-secondary)}
+.clearai-trust[data-trust="unclear"]{border-style:dashed;border-color:var(--dsw-alias-label-tertiary);color:var(--dsw-alias-label-secondary)}
+.clearai-trust[data-trust="refuted"]{border-color:var(--dsw-alias-state-error-primary);color:var(--dsw-alias-state-error-primary)}
+.clearai-trust[data-trust="replaced"]{border-color:var(--dsw-alias-border-l2);color:var(--dsw-alias-label-tertiary)}
+.clearai-trust[data-trust="conflict"]{border-color:var(--dsw-alias-state-warn-primary);color:var(--dsw-alias-state-warn-primary)}
+/* 点开一条:三段 */
+.clearai-detail{display:flex;flex-direction:column;gap:16px;padding:6px 12px 14px 12px}
+.clearai-part-head{display:flex;align-items:center;gap:8px;font-size:11.5px;color:var(--dsw-alias-label-tertiary);margin-bottom:8px}
+.clearai-part-head b{width:16px;height:16px;border-radius:50%;display:inline-flex;align-items:center;justify-content:center;font-size:10px;font-weight:600;background:var(--dsw-alias-bg-layer-2);color:var(--dsw-alias-label-secondary)}
+.clearai-stations-bar{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:4px}
+.clearai-stations-bar span{height:5px;border-radius:3px;background:var(--dsw-alias-border-l1)}
+.clearai-stations-bar span[data-state="done"]{background:var(--dsw-alias-label-primary)}
+.clearai-stations-bar span[data-state="next"]{background:repeating-linear-gradient(90deg,var(--dsw-alias-label-secondary) 0 4px,var(--dsw-alias-border-l1) 4px 8px)}
+.clearai-stations-bar span[data-state="broken"]{background:var(--dsw-alias-state-error-primary)}
+.clearai-stations-names{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:4px;margin-top:6px;font-size:11.5px;color:var(--dsw-alias-label-tertiary)}
+.clearai-stations-names span[data-now="1"]{color:var(--dsw-alias-label-primary);font-weight:600}
+.clearai-stations-note{margin-top:6px;font-size:12px;color:var(--dsw-alias-state-error-primary)}
+.clearai-tl{position:relative;display:flex;flex-direction:column}
+.clearai-tl::before{content:"";position:absolute;left:4px;top:9px;bottom:9px;width:1px;background:var(--dsw-alias-border-l2)}
+.clearai-tl-row{position:relative;display:grid;grid-template-columns:9px 76px 1fr;gap:10px;align-items:baseline;padding:2px 0;font-size:12.5px}
+.clearai-tl-dot{width:9px;height:9px;border-radius:50%;box-sizing:border-box;align-self:center;background:var(--dsw-alias-label-primary)}
+.clearai-tl-row[data-kind="proposed"] .clearai-tl-dot{background:var(--dsw-alias-bg-base);border:1.4px solid var(--dsw-alias-label-tertiary)}
+.clearai-tl-row[data-verdict="refute"] .clearai-tl-dot{background:var(--dsw-alias-state-error-primary)}
+.clearai-tl-row[data-verdict="inconclusive"] .clearai-tl-dot{background:var(--dsw-alias-bg-base);border:1.4px dashed var(--dsw-alias-label-secondary)}
+.clearai-tl-row[data-kind="promoted"] .clearai-tl-dot{background:var(--dsw-alias-brand-primary)}
+.clearai-tl-row[data-kind="next"]{color:var(--dsw-alias-label-tertiary)}
+.clearai-tl-row[data-kind="next"] .clearai-tl-dot{background:var(--dsw-alias-bg-base);border:1px dashed var(--dsw-alias-label-tertiary)}
+.clearai-tl-time{font-size:11.5px;color:var(--dsw-alias-label-tertiary);font-variant-numeric:tabular-nums}
+.clearai-tl-move{font-weight:600}
+.clearai-kv{display:grid;grid-template-columns:44px 1fr;gap:5px 14px;font-size:12.5px;line-height:1.6}
+.clearai-kv>span:nth-child(odd){color:var(--dsw-alias-label-tertiary)}
+.clearai-chips{display:inline-flex;gap:6px;flex-wrap:wrap}
+.clearai-quiet{color:var(--dsw-alias-label-secondary);font-size:12.5px;padding:6px 0}
 `
 		/** 把上面那段 CSS 挂进页面(带 data-plugin 标记,宿主按包名记账,卸载时收掉)。 */
 		function installStyles() {
 			if (typeof document === 'undefined') return () => {}
-			const existing = document.querySelector('style[data-plugin="clearai-dsh"]')
+			/** 只认自己那一张:图组件的样式表也挂着 data-plugin="clearai-dsh"(data-clearai="xyflow"),按包名查会误以为已经挂过。 */
+			const existing = document.querySelector('style[data-plugin="clearai-dsh"][data-clearai="panel"]')
 			if (existing !== null) return () => {}
 			const tag = document.createElement('style')
 			tag.dataset.plugin = 'clearai-dsh'
+			tag.dataset.clearai = 'panel'
 			tag.textContent = CSS
 			document.head.append(tag)
 			return () => {
@@ -426,47 +491,16 @@ window.__ModuleLoader__.load({
 			evBasis: { color: 'var(--dsw-alias-label-secondary)', opacity: 0.85, flex: '1 1 auto', minWidth: 0 },
 			fileLink: { color: 'var(--dsw-alias-brand-primary)', cursor: 'pointer', whiteSpace: 'nowrap' },
 			pathFoot: { fontSize: 11, color: 'var(--dsw-alias-label-secondary)', opacity: 0.7, marginTop: 2 },
-			/** 未走过等级那一行:安静,但**可点**——所以给下划线,颜色用链接令牌(它是一条通道)。 */
-			levelChannel: { fontSize: 11.5, flex: '0 0 auto', cursor: 'pointer', textDecoration: 'underline', textUnderlineOffset: 2, color: 'var(--dsw-alias-brand-primary)' },
-			/** 等级说明展开区:与 propBody 同一族的左侧竖线,但不占证明那一栏的位。 */
-			levelGuide: { display: 'flex', flexDirection: 'column', gap: 6, marginTop: 6, paddingLeft: 10, borderLeft: '2px solid var(--dsw-alias-border-l2)' },
-			levelRow: { display: 'flex', flexDirection: 'column', gap: 1, fontSize: 11.5 },
-			levelHead: { fontWeight: 600, color: 'var(--dsw-alias-label-primary)' },
 			/** 世界树页眉的判据小节:逐条带序号;左侧竖线说明它是「目标的一部分」而不是新面板。 */
 			criteria: { display: 'flex', flexDirection: 'column', gap: 1, paddingLeft: 8, marginTop: 2, borderLeft: '2px solid var(--dsw-alias-border-l2)' },
 			criteriaRow: { display: 'flex', gap: 6, alignItems: 'baseline', fontSize: 11.5 },
 		}
-
-		/** 密集列表里用的那一档按钮(11px 圆角)。 */
-		function Chip(props) {
-			return h('button', { type: 'button', className: 'clearai-chip', disabled: props.disabled === true, title: props.title, onClick: props.onClick }, props.children)
-		}
 		/** 可点的文本(替代裸下划线 span)。 */
 		function Link(props) {
 			return h('span', { className: 'clearai-link', title: props.title, onClick: props.onClick }, props.children)
 		}
 
-		/**
-		 * 读一个面板自己的 HTTP 响应。
-		 *
-		 * 为什么不能直接 `response.json()`:那条路上失败时返回的是**纯文本**
-		 * (`connection` 层查不到 exact fetch route 就回 `404 "not found"`),
-		 * 直接 parse 会抛出 `Unexpected token 'o', "not found" is not valid JSON`
-		 * ——人看到的是解析器的抱怨,不是发生了什么。
-		 * 这里统一成 `{ ok, status, payload, error }`,`error` 里带上状态码与原文。
-		 */
-		const readResponse = async (response) => {
-			const text = await response.text()
-			let payload = null
-			try {
-				payload = text === '' ? null : JSON.parse(text)
-			} catch {
-				payload = null
-			}
-			if (payload !== null && payload.ok === true) return { ok: true, status: response.status, payload, error: null }
-			const reason = payload !== null && typeof payload.error === 'string' ? payload.error : `${response.status} ${text.slice(0, 80)}`.trim()
-			return { ok: false, status: response.status, payload, error: reason }
-		}
+
 
 		function Tag(props) {
 			return h('span', { style: props.strong === true ? S.tagStrong : S.tag }, props.children)
@@ -514,7 +548,7 @@ window.__ModuleLoader__.load({
 		/**
 		 * **目标那一块**(世界树页眉):主张一行 + **判据小节**(逐条带序号)。
 		 *
-		 * 判据是**多条**的清点清单(`SetGoal` 收 `criteria: string[]`)⇒ 挤成一句「判据:均值差…」
+		 * 判据是**多条**的清点清单(`Frame` 收 `criteria: string[]`)⇒ 挤成一句「判据:均值差…」
 		 * 会把「第 3 条没做到」抹平。所以逐条列出来,修订史与全文指针各占一行。
 		 * 读的是 `knowledgeView` 那一份(与运行态卡**同一份**);拿不到(旧宿主 / 测试桩)时
 		 * 退回原来那句摘要——面板不许因为缺一份投影而空白,也不许自己再拼一套判据。
@@ -575,21 +609,6 @@ window.__ModuleLoader__.load({
 			release: t('放行'),
 		}))
 
-		/**
-		 * 命题的分组 = **本体声明的五个状态**,顺序即认识论的顺序。
-		 *
-		 * 用词有权威出处:[`docs/verification-loop.md`](../docs/verification-loop.md) 的状态表
-		 * (那份文档明说「其他文档、提示词与代码注释提到这些概念时,以这里的叫法为准」)。
-		 * 界面因此不另造一套产品词——「已确认」的命题不在这一列:它已经**升格为事实**,在事实货架上。
-		 */
-		const PROPOSITION_GROUPS = lazyTable(() => ([
-			{ status: 'proposed', label: t('已提出') },
-			{ status: 'alive', label: t('验证中') },
-			{ status: 'refuted', label: t('已推翻') },
-			{ status: 'superseded', label: t('已替代') },
-			{ status: 'retracted', label: t('已撤回') },
-		]))
-
 		/**
 		 * 一行够用的摘要。**真数据逼出来的**:评估者的依据常常是几百字的一整段
 		 * (逐条对照判据 + 隔离标注),原样内联会把那一行撑到没法看。
@@ -605,9 +624,16 @@ window.__ModuleLoader__.load({
 		const levelRank = (value) => LEVEL_RANK[value] ?? -1
 
 		/**
-		 * 一条命题的证据。链是**证据 → 步骤 → 命题**(`evidence.stepId` → `step.tests.hypothesis`),
-		 * 与原始设计 `evidenceForHypothesis` 同一条链:证据挂在步骤上,不直接挂在命题上。
+		 * 一条命题的证据。新账上每条证据写明它针对哪条命题(`evidence.hypothesis`);
+		 * 旧账没有这一格,走**证据 → 步骤 → 命题**(`evidence.stepId` → `step.tests.hypotheses`)那条链。
 		 */
+		/** 一个步骤检验的命题 id(新形状 `tests.hypotheses`;旧形状单条 `tests.hypothesis` 照旧认)。 */
+		function testedOf(meta) {
+			const tests = meta?.tests
+			if (Array.isArray(tests?.hypotheses)) return tests.hypotheses
+			return typeof tests?.hypothesis === 'string' && tests.hypothesis !== '' ? [tests.hypothesis] : []
+		}
+
 		function evidenceOf(data, hypothesisId) {
 			/**
 			 * 走**跨计划**的步骤索引:命题的验证步常常留在**已收尾的旧计划**里
@@ -617,10 +643,13 @@ window.__ModuleLoader__.load({
 			const index = data?.stepIndex ?? {}
 			const steps = new Set(
 				Object.entries(index)
-					.filter(([, meta]) => meta?.tests?.hypothesis === hypothesisId)
+					.filter(([, meta]) => testedOf(meta).includes(hypothesisId))
 					.map(([stepId]) => stepId),
 			)
-			return (data?.evidence ?? []).filter((item) => steps.has(item.stepId)).slice().sort((a, b) => (a.at ?? 0) - (b.at ?? 0))
+			return (data?.evidence ?? [])
+				.filter((item) => (item.hypothesis === null || item.hypothesis === undefined ? steps.has(item.stepId) : item.hypothesis === hypothesisId))
+				.slice()
+				.sort((a, b) => (a.at ?? 0) - (b.at ?? 0))
 		}
 
 		/**
@@ -689,68 +718,6 @@ window.__ModuleLoader__.load({
 			return out
 		}
 
-		/** 一条证据一句话:`e-1 · L2 · 支持 · 自判 · 依据… · 出处`。 */
-		function evidenceLine(data, item) {
-			return h(
-				'div',
-				{ key: item.id, style: S.evRow },
-				h('span', { style: S.evHead }, `${item.id} · ${dash(item.level)} · ${gloss(VERDICT, item.verdict)} · ${gloss(EVALUATOR, item.evaluator)}`),
-				h('span', { style: S.evBasis, title: String(item.basis ?? '') }, brief(item.basis, 160)),
-				...originsOf(data, item).map((origin, index) => {
-					/**
-					 * 四类入口各自的去处:
-					 *   产物 / 评估卡 → 右侧**原生预览**打开那个文件;
-					 *   看评估者      → 旁观**评估者子会话**(论证过程在里面,harness 原生能力);
-					 *   审批记录      → 没有文件(原生审批对在会话日志里),如实说明它凭什么不可伪造。
-					 */
-					const open =
-						origin.kind === 'evaluator-session'
-							? origin.session === null || data.openSpectator === undefined
-								? undefined
-								: () => data.openSpectator(origin.session)
-							: origin.path === null || data.openPreview === undefined
-								? undefined
-								: () => data.openPreview(origin.path)
-					const title =
-						origin.kind === 'evaluator-session'
-							? t('旁观写这条裁决的评估者子会话(论证过程)')
-							: origin.kind === 'approval-record'
-								? `${t('会话日志里的原生审批对(不可伪造)')}${origin.call === null ? '' : ` · ${origin.call}`}`
-								: (origin.path ?? '')
-					return h(
-						'span',
-						{
-							key: `${item.id}-${origin.label}-${index}`,
-							style: open === undefined ? S.faint : S.fileLink,
-							onClick:
-								open === undefined
-									? undefined
-									: (event) => {
-											event?.stopPropagation?.()
-											open()
-										},
-							title,
-						},
-						origin.label,
-					)
-				}),
-			)
-		}
-
-		/** 当前处境一句话:这是这一格存在的理由——用户要知道「现在能不能当真」。 */
-		function whereOf(data, row) {
-			const evidence = evidenceOf(data, row.id)
-			const threshold = data?.goal?.promoteAtLevel ?? 'L3'
-			const refute = evidence.find((item) => item.verdict === 'refute')
-			if (row.status === 'refuted') return refute === undefined ? t('出现推翻证据(终态,记录保留)') : `${t('被 ')}${refute.id}${t(' 推翻:')}${brief(refute.basis, 56)}`
-			if (row.status === 'superseded') return t('已被下一版命题替代(版本留着,不参与当前推理)')
-			if (row.status === 'confirmed') return t('已达门槛,已升格为事实')
-			if (row.status === 'retracted') return t('人已撤回(记录保留)')
-			if (row.supportedLevel === null || row.supportedLevel === undefined) return t('暂无证据。先登记判据,后执行验证。')
-			if (levelRank(row.supportedLevel) >= levelRank(threshold)) return `${t('已达门槛(')}${row.supportedLevel}${t('),等目标验收时升格为事实')}`
-			return `${t('支持到 ')}${row.supportedLevel}${t(':还差 ')}${threshold}${t('(要独立评估)才达门槛')}`
-		}
-
 		/**
 		 * 一条**事实**的证据落在哪一步(纯函数:可单测)。
 		 *
@@ -766,717 +733,358 @@ window.__ModuleLoader__.load({
 			return null
 		}
 
-		/** 一条事实的证据落在哪份计划里:多份计划各有自己的世界树,跳过去时要切到那一份。 */
-		function rowPlanOf(data, fact) {
-			for (const id of fact?.evidenceIds ?? []) {
-				const item = (data?.evidence ?? []).find((entry) => entry.id === id)
-				if (typeof item?.planId === 'string' && item.planId !== '') return item.planId
-			}
-			return null
-		}
+		/**
+		 * ═══ 本体格(第六阶段:图为主) ═══
+		 *
+		 * 一屏三层,自上而下越来越细:
+		 *   ① 页眉:在回答什么 · 一行计数 · 待处理(只陈述)· 迷你进度轨(判断 → 检验 → 已验证 → 入本体);
+		 *   ② 图:本体图 / 实体图二选一,星图式(点 + 衬线标签;实线已验证、虚线待核验);
+		 *   ③ 结论:一行一条,按可信度分组;点开依次是 进度 → 可信度怎么变的 → 补充。
+		 *
+		 * 用词与运行态卡**同一套**(`knowledge-view.js` 的 TRUST / VERDICT_WORD / LEVEL_WORD):
+		 * 单次检验的结果是 支持 / 推翻 / 不确定;一条结论的状态是 已验证 / 待核验 / 验证中 / 不确定 / 已推翻 / 已替换。
+		 * 内部编号(h-… / e-… / s-…)不上屏:人认的是短名和「第几步」。
+		 */
+		const TRUST_ORDER = ['credible', 'pending', 'testing', 'unclear', 'refuted', 'replaced']
+		const TRUST_WORD = lazyTable(() => ({ credible: t('已验证'), pending: t('待核验'), testing: t('验证中'), unclear: t('不确定'), refuted: t('已推翻'), replaced: t('已替换') }))
+		const LEVEL_WORD = lazyTable(() => ({ L0: t('自己推了一遍'), L1: t('引用已有材料'), L2: t('可复算'), L3: t('独立核验'), L4: t('人放行') }))
+		/** 进度轨的四站。顺序即一条结论要走的路。 */
+		const STATIONS = () => [t('判断'), t('检验'), t('已验证'), t('入本体')]
+		/** 还没走完时,下一步是什么(时间线末尾那条虚点)。 */
+		const NEXT_STEP = lazyTable(() => ({
+			testing: t('下一步:找一步去检验它'),
+			pending: t('下一步:独立核验通过 → 已验证'),
+			unclear: t('下一步:换个办法再检验'),
+			credible: t('下一步:结案时写进长期知识'),
+		}))
+		/** 值的形态(本体图上的小方块):内部词换成人话。 */
+		const FORM_WORD = lazyTable(() => ({ statement: t('一句话'), quantity: t('数值'), formula: t('公式'), code: t('代码'), reference: t('引用') }))
+		const KIND_WORD = lazyTable(() => ({ concept: t('概念'), value_type: t('值的形态'), instance: t('实例'), literal: t('取值'), edge: t('关系') }))
 
-		/** 右侧那一列:最有力的一条证据给出的**等级 · 判者**——这就是「多可信」。 */
-		function judgeOf(data, row) {
-			const evidence = evidenceOf(data, row.id)
-			const best = evidence.slice().sort((a, b) => levelRank(b.level) - levelRank(a.level))[0]
-			return best === undefined ? '—' : `${dash(best.level)} · ${gloss(EVALUATOR, best.evaluator)}`
-		}
+		/** 一步检验是怎么做的:独立核验直接说;自己做的,说到了哪一级(可复算 / 引用材料 / 推了一遍)。 */
+		const howOf = (row) => (row.evaluator === 'independent' ? t('独立核验') : (LEVEL_WORD[row.level] ?? t('自己检验')))
 
-		/** 实际**走过**的转移(不画未走的岔路:那是过程知识,不是「我现在能信什么」)。 */
-		function transitionsOf(data, row) {
-			const evidence = evidenceOf(data, row.id)
-			const out = []
-			/**
-			 * `to` 一律用**声明里的原始状态键**(`alive` / `refuted` …),不做翻译——
-			 * 翻译只在渲染时做。混用两套键是踩过的坑:流转图按原始键查「这一跳走没走过」,
-			 * 而这里返回的是中文字面 ⇒ 命不中 ⇒ 走过的边全被画成"没走"。
-			 */
-			if (evidence.length > 0) {
-				const first = evidence[0]
-				out.push({ to: 'alive', on: t('已获首条证据'), by: `${first.id} · ${dash(first.level)} ${gloss(VERDICT, first.verdict)}`, independent: first.evaluator === 'independent' })
+		/**
+		 * **结论行的模型**(纯函数,导出给测试)。
+		 *
+		 * 一条判断一行;旧账本里没有判断关联的事实也各占一行(它们已经写进长期知识,只是不知道出自哪条判断)。
+		 * 站位:写进长期知识 = 4,已验证 = 3,检验过 = 2,只是提出 = 1;被推翻的停在「检验」那一站。
+		 */
+		function conclusionsOf(data) {
+			const facts = Array.isArray(data?.facts) ? data.facts : []
+			const ordinalOf = new Map()
+			for (const plan of [...(Array.isArray(data?.plans) ? data.plans : []), ...(data?.plan ? [data.plan] : [])]) {
+				for (const step of plan?.steps ?? []) if (typeof step?.id === 'string') ordinalOf.set(step.id, step.ordinal ?? null)
+			}
+			const testingStep = (id) => {
+				for (const [stepId, meta] of Object.entries(data?.stepIndex ?? {})) if (testedOf(meta).includes(id)) return ordinalOf.get(stepId) ?? null
+				return null
 			}
-			if (row.status === 'refuted') {
-				const refute = evidence.find((item) => item.verdict === 'refute')
-				out.push({
-					to: 'refuted',
-					on: t('出现推翻证据'),
-					by: refute === undefined ? '—' : `${refute.id} · ${gloss(EVALUATOR, refute.evaluator)}`,
-					independent: refute !== undefined && refute.evaluator === 'independent',
+			const linked = new Set()
+			const rows = (Array.isArray(data?.goal?.hypotheses) ? data.goal.hypotheses : []).map((hypothesis) => {
+				const history = Array.isArray(hypothesis.history) ? hypothesis.history : []
+				const fact = facts.find((item) => item.hypothesis === hypothesis.id) ?? null
+				if (fact !== null) linked.add(fact.id)
+				const lastEvidence = [...history].reverse().find((row) => row.kind === 'evidence') ?? null
+				const promoted = fact !== null && fact.review?.decision !== 'retracted'
+				const trust = TRUST_ORDER.includes(hypothesis.trust) ? hypothesis.trust : 'testing'
+				const station = trust === 'refuted' ? 2 : promoted ? 4 : trust === 'credible' ? 3 : lastEvidence !== null ? 2 : 1
+				return {
+					key: hypothesis.id,
+					hypothesis: hypothesis.id,
+					name: String(hypothesis.name ?? ''),
+					claim: String(hypothesis.claim ?? ''),
+					trust,
+					station,
+					history,
+					refuteWhen: hypothesis.refuteWhen ?? null,
+					scope: fact?.scope ?? hypothesis.fact?.scope ?? null,
+					basis: lastEvidence?.basis ?? null,
+					evidenceId: lastEvidence?.id ?? null,
+					step: lastEvidence?.ordinal ?? testingStep(hypothesis.id),
+					assertions: fact?.assertions ?? hypothesis.assertions ?? null,
+					fact: fact?.id ?? null,
+				}
+			})
+			for (const fact of facts) {
+				if (linked.has(fact.id)) continue
+				const trust = fact.review?.decision === 'retracted' ? 'replaced' : fact.refuted === true ? 'refuted' : 'credible'
+				rows.push({
+					key: fact.id,
+					hypothesis: null,
+					name: '',
+					claim: String(fact.text ?? ''),
+					trust,
+					station: trust === 'credible' ? 4 : 2,
+					history: [{ kind: 'promoted', at: fact.at ?? null, level: fact.level ?? null, to: 'credible' }],
+					refuteWhen: null,
+					scope: fact.scope ?? null,
+					basis: null,
+					evidenceId: (fact.evidenceIds ?? [])[0] ?? null,
+					step: null,
+					assertions: fact.assertions ?? null,
+					fact: fact.id,
 				})
 			}
-			if (row.status === 'superseded') out.push({ to: 'superseded', on: t('被下一版命题改写'), by: row.version > 1 ? `v${row.version}` : '—', independent: false })
-			if (row.status === 'retracted') out.push({ to: 'retracted', on: t('人审查后决定撤回'), by: '—', independent: false })
-			return out
+			return rows
 		}
 
-		/**
-		 * 流转图的**固定布局**(产品面,不是通用图布局器)。
-		 *
-		 * 主干一行(左→右):已提出 → 验证中 → 已确认;终态分支挂在下面一行。
-		 * 这样无论声明有没有下发、有几条边,**横向主干都在** —— 不会退化成竖排。
-		 * 声明下发后,边的 `on` / `actor` 从声明取(未走的边据此写清"这件事叫什么、谁发起");
-		 * 声明还没下来的旧会话,用规范闭环的安全镜像,并在标题里如实标注。
-		 */
-		const FLOW_LAYOUT = {
-			nodeW: 112,
-			nodeH: 30,
-			width: 600,
-			height: 152,
-			trunkY: 20,
-			branchY: 100,
-			place: {
-				proposed: { x: 16, y: 20 },
-				alive: { x: 166, y: 20 },
-				confirmed: { x: 316, y: 20 },
-				refuted: { x: 166, y: 100 },
-				superseded: { x: 316, y: 100 },
-				retracted: { x: 466, y: 100 },
-			},
-			/** 声明缺失时的规范镜像:只用来画图,标题会说明它不是实时声明。 */
-			fallbackEdges: [
-				['proposed', 'alive', 'system', 'evidence_appended'],
-				['alive', 'confirmed', 'system', 'promotion_threshold'],
-				['alive', 'refuted', 'system', 'refuting_evidence'],
-				['proposed', 'superseded', 'model', 'hypothesis_revised'],
-				['confirmed', 'retracted', 'human', 'retraction_request'],
-			],
+		/** 短名与主张重复时只说一遍(没起短名的旧判断,短名就是主张的开头)。 */
+		const titleOf = (row) => {
+			const name = row.name.trim()
+			if (name === '' || name.endsWith('…') || row.claim.startsWith(name)) return { title: brief(row.claim, 40), sub: null }
+			return { title: name, sub: brief(row.claim, 60) }
 		}
 
-		/**
-		 * **流转图**:横向主干 + 分支的 SVG 状态机。
-		 *
-		 * 三条着色规矩(与世界树同一套视觉语言):
-		 *   · **走过的边**:实线 + 颜色(独立裁决用品牌强调色、自判用前景色),旁边写清触发与凭据;
-		 *   · **当前态**:品牌色描边 + 呼吸光环,并在节点上写「当前」;
-		 *   · **没走的边**:虚线 + 低饱和,写明「这件事 · 谁发起」。
-		 */
-		function StateFlow(props) {
-			const { data, row } = props
-			const spec = (data?.ontology?.objects ?? []).find((object) => object.name === 'hypothesis') ?? null
-			const declared = Array.isArray(spec?.edges) && spec.edges.length > 0 ? spec.edges : null
-			const edges = declared ?? FLOW_LAYOUT.fallbackEdges
-			const path = transitionsOf(data, row)
-			const taken = new Map(path.map((step) => [step.to, step]))
-			const current = row.status
-			const L = FLOW_LAYOUT
-			const items = []
-			for (const [from, to, actor, on] of edges) {
-				const a = L.place[from]
-				const b = L.place[to]
-				if (a === undefined || b === undefined || from === to) continue
-				const step = taken.get(to)
-				const done = step !== undefined
-				const color = done ? (step.independent === true ? 'var(--dsw-alias-brand-primary)' : 'var(--dsw-alias-label-primary)') : 'var(--dsw-alias-border-l2)'
-				const horizontal = a.y === b.y && b.x > a.x
-				const x1 = horizontal ? a.x + L.nodeW : a.x + L.nodeW / 2
-				const y1 = horizontal ? a.y + L.nodeH / 2 : a.y + L.nodeH
-				const x2 = horizontal ? b.x : b.x + L.nodeW / 2
-				const y2 = horizontal ? b.y + L.nodeH / 2 : b.y
-				const midY = (y1 + y2) / 2
-				items.push(
-					h(
-						'path',
-						{
-							key: `edge-${from}-${to}`,
-							d: horizontal ? `M ${x1} ${y1} H ${x2}` : `M ${x1} ${y1} V ${midY} H ${x2} V ${y2}`,
-							fill: 'none',
-							stroke: color,
-							strokeWidth: done ? 2 : 1,
-							strokeDasharray: done ? undefined : '4 3',
-						},
-						h(
-							'title',
-							null,
-							done ? `${step.on} · ${step.by}` : `${t('未走:')}${on ?? to} · ${actor ?? '?'}${t(' 发起')}`,
-						),
-					),
-				)
-				const label = done ? `${step.by.split(' · ')[0]} · ${step.by.split(' · ')[1] ?? ''}`.trim() : ''
-				if (label !== '') {
-					items.push(
-						h(
-							'text',
-							{
-								key: `label-${from}-${to}`,
-								x: horizontal ? (x1 + x2) / 2 : x2 + 5,
-								y: horizontal ? y1 - 7 : midY - 4,
-								textAnchor: horizontal ? 'middle' : 'start',
-								fontSize: 9.5,
-								fill: color,
-							},
-							label,
-						),
-					)
-				}
-			}
-			for (const [state, position] of Object.entries(L.place)) {
-				const reached = state === 'proposed' || taken.has(state)
-				const isNow = state === current
-				items.push(
-					h('rect', {
-						key: `node-${state}`,
-						x: position.x,
-						y: position.y,
-						width: L.nodeW,
-						height: L.nodeH,
-						rx: L.nodeH / 2,
-						fill: isNow ? 'var(--dsw-alias-bg-layer-2)' : 'transparent',
-						stroke: isNow ? 'var(--dsw-alias-brand-primary)' : reached ? 'var(--dsw-alias-label-primary)' : 'var(--dsw-alias-border-l2)',
-						strokeWidth: isNow ? 2 : 1,
-						strokeDasharray: reached || isNow ? undefined : '4 3',
-						className: isNow ? 'clearai-breathe-stroke' : undefined,
-					}),
-				)
-				items.push(
-					h(
-						'text',
-						{
-							key: `text-${state}`,
-							x: position.x + L.nodeW / 2,
-							y: position.y + L.nodeH / 2 + 4,
-							textAnchor: 'middle',
-							fontSize: 11,
-							fill: isNow ? 'var(--dsw-alias-brand-primary)' : reached ? 'var(--dsw-alias-label-primary)' : 'var(--dsw-alias-label-secondary)',
-						},
-						`${gloss(HYPOTHESIS, state)}${isNow ? ' · 当前' : ''}`,
-					),
-				)
-			}
-			/**
-			 * 图下那几行**来路**:图上只标走过那一跳的证据 id(窄间距里读得清),
-			 * 完整的「这件事叫什么 + 谁做的」写在这里 —— 图管结构,文字管凭据,各占各的地方。
-			 */
-			const walked = path.filter((step) => step.to !== 'retracted' || current === 'retracted')
+		/** 状态小签:实心 = 已验证,描边 = 待核验,淡描边 = 验证中,虚边 = 不确定,红 = 已推翻,删除线 = 已替换。 */
+		function TrustTag(props) {
+			return h('span', { className: 'clearai-trust', 'data-trust': props.trust }, TRUST_WORD[props.trust] ?? props.trust)
+		}
+
+		/** 四站进度条:走过的实心,在路上的那一段斜纹,当前站名加粗。 */
+		function StationBar(props) {
+			const reached = props.station
+			const stopped = props.trust === 'refuted' || props.trust === 'replaced'
+			const names = STATIONS()
 			return h(
 				'div',
-				{ style: { margin: '4px 0 8px', maxWidth: '100%' } },
+				{ className: 'clearai-stations', 'data-stopped': stopped ? '1' : '0' },
 				h(
 					'div',
-					{ style: { overflowX: 'auto' } },
-					h(
-						'svg',
-						{ width: L.width, height: L.height, viewBox: `0 0 ${L.width} ${L.height}`, style: { display: 'block', minWidth: L.width } },
-						...items,
-					),
+					{ className: 'clearai-stations-bar' },
+					...names.map((_, index) => h('span', { key: `seg-${index}`, 'data-state': index < reached ? (stopped && index === reached - 1 ? 'broken' : 'done') : index === reached && !stopped ? 'next' : 'todo' })),
 				),
-				walked.length === 0
-					? null
-					: h(
-							'div',
-							{ style: { display: 'flex', flexDirection: 'column', gap: 1, marginTop: 2 } },
-							...walked.map((step) =>
-								h(
-									'div',
-									{ key: `walked-${step.to}`, style: { fontSize: 11, color: 'var(--dsw-alias-label-secondary)' } },
-									`${step.on} → ${gloss(HYPOTHESIS, step.to)} · ${step.by}`,
-								),
-							),
-						),
-				declared === null
-					? h('div', { style: { ...S.faint, fontSize: 11, marginTop: 2 } }, t('本体声明尚未进入投影;当前显示规范闭环的镜像,下一拍自动对齐。'))
-					: null,
+				h('div', { className: 'clearai-stations-names' }, ...names.map((name, index) => h('span', { key: `name-${index}`, 'data-now': index === reached - 1 ? '1' : '0' }, name))),
+				stopped ? h('div', { className: 'clearai-stations-note' }, props.trust === 'refuted' ? t('在检验这一站被推翻,不再往下走。') : t('已被替换,不再往下走。')) : null,
 			)
 		}
 
-		/**
-		 * 一条断言里的人与物:**等级说明要点名「这一级要检查的对象」**,名字就从这里来。
-		 * 只做展示用拼装,不重算账本(断言在账本里已经是定型的形状)。
-		 */
-		const assertionSubjectName = (assertion) => {
-			const subject = assertion?.subject ?? {}
-			const id = String(subject.id ?? '')
-			if (id === '') return ''
-			const type = String(subject.type ?? '')
-			return type === '' ? id : `${type}|${id}`
-		}
-		const assertionObjectName = (object) => {
-			if (object === null || object === undefined) return ''
-			const value = String(object.value ?? '')
-			if (object.kind !== 'quantity') return value
-			const unit = String(object.unit ?? '')
-			return unit === '' ? value : `${value} ${unit}`
-		}
-		const assertionName = (assertion) => {
-			const chip = String(assertion?.chip ?? '')
-			if (chip !== '') return chip
-			const subject = assertionSubjectName(assertion)
-			const predicate = String(assertion?.predicate ?? '')
-			const object = assertionObjectName(assertion?.object)
-			return `${subject} · ${predicate} = ${object}`
-		}
-
-		/**
-		 * 等级说明**只有一个来源**:折法侧经宿主投影下发的 `knowledgeView`;
-		 * 它的底稿是 `preset/plugins/prompts.js` 里那五级说明。
-		 * 客户端**绝不手抄第二份**——两处各写一套,漂移是迟早的事。
-		 * 取不到就返回 null,由调用点如实说「读不到等级说明」。
-		 */
-		const levelTableOf = (data) => {
-			const view = data?.knowledgeView ?? null
-			const table = view?.levels ?? view?.glossary ?? null
-			return table !== null && typeof table === 'object' ? table : null
-		}
-
-		/**
-		 * **等级通道**:未走过的等级不再是一句陈述,而是一行**可点**的东西。
-		 *
-		 * 点开看到的是 `ExplainLevelSkip` 要交的三件:
-		 *   ① 这一级要检查的对象(这条命题自己的断言主体——reason 里必须点到它们);
-		 *   ② reason 该怎么写(以及模板);
-		 *   ③ 这一级在这一档里可能不适用的理由从哪来说(等级说明的 `plain` / `where`)。
-		 *
-		 * 「跳过」本身不违规,所以这里**不劝、不拦**:只把要交的东西摆出来。
-		 */
-		const LevelGuide = ({ row, data }) => {
-			const untouched = Array.isArray(row?.untouchedLevels) ? row.untouchedLevels : []
-			const table = levelTableOf(data)
-			const objects = (Array.isArray(row?.assertions) ? row.assertions : []).map(assertionName).filter((text) => text !== '')
-			const hypothesis = String(row?.id ?? '')
+		/** 可信度怎么变的:一笔一行,变了的那一笔写出「之前 → 之后」。 */
+		function TrustTimeline(props) {
+			const rows = props.history
+			const lines = rows.map((row, index) => {
+				let text = ''
+				if (row.kind === 'proposed') text = t('提出')
+				else if (row.kind === 'evidence') text = `${row.ordinal === null || row.ordinal === undefined ? t('一步检验') : `${nth(row.ordinal)}`}${t(':')}${VERDICT[row.verdict] ?? row.verdict} · ${howOf(row)}`
+				else if (row.kind === 'promoted') text = t('写进长期知识')
+				else if (row.kind === 'retracted') text = `${t('人撤回')}${row.reason ? `:${brief(row.reason, 40)}` : ''}`
+				const moved = row.from !== undefined && row.from !== row.to
+				return h(
+					'div',
+					{ key: `tl-${index}`, className: 'clearai-tl-row', 'data-kind': row.kind, 'data-verdict': row.verdict ?? '' },
+					h('span', { className: 'clearai-tl-dot' }),
+					h('span', { className: 'clearai-tl-time' }, when(row.at)),
+					h('span', null, text, moved ? h('b', { className: 'clearai-tl-move' }, ` · ${TRUST_WORD[row.from] ?? row.from} → ${TRUST_WORD[row.to] ?? row.to}`) : null),
+				)
+			})
+			const next = props.station >= 4 || props.trust === 'refuted' || props.trust === 'replaced' ? null : (NEXT_STEP[props.trust] ?? null)
+			if (next !== null) lines.push(h('div', { key: 'tl-next', className: 'clearai-tl-row', 'data-kind': 'next' }, h('span', { className: 'clearai-tl-dot' }), h('span', { className: 'clearai-tl-time' }, ''), h('span', null, next)))
+			return h('div', { className: 'clearai-tl' }, ...lines)
+		}
+
+		/** 点开一条:进度 → 可信度怎么变的 → 补充,依次往下。 */
+		function ConclusionDetail(props) {
+			const { row, data } = props
+			const evidence = row.evidenceId === null ? null : ((data?.evidence ?? []).find((item) => item.id === row.evidenceId) ?? null)
+			const origins = evidence === null ? [] : originsOf(data, evidence)
+			const subjects = [...new Set((Array.isArray(row.assertions) ? row.assertions : []).map((assertion) => String(assertion?.subject?.id ?? '')).filter((id) => id !== ''))]
+			const part = (index, title, body) => h('div', { className: 'clearai-part' }, h('div', { className: 'clearai-part-head' }, h('b', null, String(index)), title), body)
+			const kv = (label, value) => (value === null || value === undefined || value === '' ? [] : [h('span', { key: `k-${label}` }, label), h('span', { key: `v-${label}` }, value)])
 			return h(
 				'div',
-				{ style: S.levelGuide },
-				...untouched.map((level) => {
-					const info = table === null ? null : table[level] ?? null
-					const plain = info === null ? null : String(info.plain ?? '')
-					const where = info === null ? null : String(info.where ?? '')
-					const nextAction = info === null ? null : String(info.nextAction ?? '')
-					return h(
+				{ className: 'clearai-detail' },
+				part(1, t('进度'), h(StationBar, { station: row.station, trust: row.trust })),
+				part(2, t('可信度怎么变的'), h(TrustTimeline, { history: row.history, station: row.station, trust: row.trust })),
+				part(
+					3,
+					t('补充'),
+					h(
 						'div',
-						{ key: level, style: S.levelRow },
-						h('div', { style: S.levelHead }, `${level} · ${plain === null || plain === '' ? t('读不到等级说明') : t(plain)}`),
-						where === null || where === '' ? null : h('div', { style: S.faint }, `${t('这一级看什么:')}${t(where)}`),
-						nextAction === null || nextAction === '' ? null : h('div', { style: S.faint }, `${t('这一级要交什么:')}${t(nextAction)}`),
-						h(
-							'div',
-							{ style: S.faint },
-							`${t('这一级要检查的对象:')}${objects.length === 0 ? t('这条命题还没写明断言主体:先用 RegisterInstance 把实例连出处登记下来。') : objects.join(';')}`,
+						{ className: 'clearai-kv' },
+						...kv(
+							t('依据'),
+							row.basis === null
+								? null
+								: h(
+										'span',
+										null,
+										h('span', { title: String(row.basis) }, brief(row.basis, 120)),
+										...origins
+											.filter((origin) => origin.path !== null || origin.session !== null)
+											.slice(0, 2)
+											.map((origin, index) =>
+												h(
+													'span',
+													{
+														key: `o-${index}`,
+														className: 'clearai-link',
+														style: { marginLeft: 8 },
+														onClick: () => (origin.session !== null && origin.kind === 'evaluator-session' ? data.openSpectator?.(origin.session) : data.openPreview?.(origin.path)),
+														title: origin.path ?? '',
+													},
+													origin.kind === 'audit-card' || origin.kind === 'evaluator-session' ? t('看核验') : t('看记录'),
+												),
+											),
+									),
 						),
-						h('div', { style: S.faint }, `${t('reason 怎么写:')}${t('reason 里必须点到上面这些对象名,不能写「时间不够」。')}`),
-						h('div', { style: S.faint }, t('跳级本身不违规:要交的是「这一级为什么不适用」的理由,不是这一级的读数。')),
-						/**
-						 * 模板本身是**代码**,不翻译;它前面那句话是人话,走 t()。
-						 * (verb 名与字段名是模型的接口,换语言也不该换。)
-						 */
-						h('div', { style: S.faint }, t('交给模型的写法:'), h('span', { style: S.mono }, ` ExplainLevelSkip { hypothesis: '${hypothesis}', levels: ['${level}'], reason: '…' }`)),
-					)
-				}),
+						...kv(t('范围'), row.scope === row.refuteWhen ? null : row.scope),
+						...kv(t('算错'), row.refuteWhen),
+						...kv(
+							t('相关'),
+							subjects.length === 0
+								? null
+								: h('span', { className: 'clearai-chips' }, ...subjects.map((id) => h('span', { key: id, className: 'clearai-chip', onClick: () => props.onFocus?.(id), title: t('在图上找它') }, labelOfEntity(data, id)))),
+						),
+						...kv(t('出自'), row.step === null ? null : `${nth(row.step)}`),
+					),
+				),
 			)
 		}
 
-		/**
-		 * **命题行**:一行一条命题,默认只有主张 + 当前处境 + 等级判者。
-		 * 点开才出现「凭什么」——流转图 + 每条证据的出处。
-		 */
-		function PropositionRow(props) {
-			const { data, row, open, onToggle } = props
-			const evidence = evidenceOf(data, row.id)
-			const path = transitionsOf(data, row)
-			const untouched = Array.isArray(row.untouchedLevels) ? row.untouchedLevels : []
-			/**
-			 * 等级通道的展开是**界面状态**(点了哪一条,不进账本)。
-			 * `levelsOpen` 是给测试缝的显式覆盖:真 React 里点不动的地方,测试要能直接渲染展开态。
-			 */
-			const [levelsShown, setLevelsShown] = React.useState(false)
-			const levelsOpen = props.levelsOpen ?? levelsShown
+		/** 实例在图上的名字(登记时给的 label);图上没有它就退回 id。 */
+		const labelOfEntity = (data, id) => String((data?.lexicon?.graph?.nodes ?? []).find((node) => node.layer === 'entity' && String(node.ref ?? '') === id)?.label ?? id)
+
+		/** 一条结论一行:状态签 + 短名(+ 主张)+ 出自第几步。 */
+		function ConclusionRow(props) {
+			const { row, open } = props
+			const { title, sub } = titleOf(row)
 			return h(
 				'div',
-				{ style: open === true ? S.propOpen : S.propRow },
+				{ className: 'clearai-row', 'data-open': open ? '1' : '0', 'data-trust': row.trust },
 				h(
 					'div',
-					{ style: S.propHead, onClick: onToggle },
-					h('span', { style: { ...S.propClaim, ...(row.status === 'refuted' || row.status === 'superseded' ? S.stale : {}) } }, dash(row.claim)),
-					h('span', { style: S.propWhere }, whereOf(data, row)),
-					h('span', { style: S.propJudge }, `${gloss(HYPOTHESIS, row.status)} · ${judgeOf(data, row)}`),
-					/**
-					 * **从没被走过的等级**:等级越往上,系统补的独立性越多(独立裁决、人放行),
-					 * 所以「直接跳到高等级」这件事本身不违规(首次测量没有廉价路),但必须看得见——
-					 * 与「这条假设从没被证据碰过」标成「未触及」同一条规矩。
-					 *
-					 * 它同时是**通道**,不是陈述:点开就是 `ExplainLevelSkip` 要交的东西
-					 * (要检查哪些对象、reason 怎么写、这一级为什么可能不适用)。
-					 * 只说「尚无证据」而不给出口,读者只会知道欠账、不知道还法。
-					 */
-					untouched.length === 0
-						? null
-						: h(
-								'span',
-								{
-									style: S.levelChannel,
-									title: t('这些等级尚无证据:跳级不违规,但需说明原因'),
-									onClick: (event) => {
-										event?.stopPropagation?.()
-										setLevelsShown(levelsOpen !== true)
-									},
-								},
-								`${t('未走过 ')}${untouched.join('/')} · ${levelsOpen === true ? t('收起这一级要交的东西') : t('怎么补这一级?')}`,
-							),
+					{ className: 'clearai-row-head', onClick: () => props.onToggle(row.key), title: open ? t('收起') : t('点开看进度和来历') },
+					h(TrustTag, { trust: row.trust }),
+					h('span', { className: 'clearai-row-title' }, title),
+					sub === null ? null : h('span', { className: 'clearai-row-sub' }, sub),
+					h('span', { className: 'clearai-row-step' }, row.step === null ? '' : `${nth(row.step)}`),
 				),
-				h(AssertionChips, { assertions: row.assertions, ui: data.assertionUI, promoted: false }),
-				levelsOpen === true ? h(LevelGuide, { row, data }) : null,
-				open === true
-					? h(
-							'div',
-							{ style: S.propBody },
-							h(StateFlow, { data, row }),
-							evidence.length === 0 ? null : h('div', { style: S.evList }, ...evidence.map((item) => evidenceLine(data, item))),
-							/**
-							 * 图上那一跳的完整凭据(触发 + 判者 + 两个可点入口)。
-							 * 这里**不再**摆本体文件路径:那是文档坐标,不是面板上的动作 ——
-							 * 「这句话不用了」——人拍板删的。
-							 */
-							evidence.length === 0
-								? null
-								: h(
-										'div',
-										{ style: S.pathFoot },
-										h(
-											Link,
-											{
-												onClick: () => {
-													const last = evidence[evidence.length - 1]
-													treeFocus.set({ plan: last.planId ?? null, step: last.stepId, branch: last.branch ?? null })
-													if (data.openRail !== undefined) data.openRail('clearai-worldtree')
-												},
-												title: t('打开世界树并选中产生这条证据的验证步'),
-											},
-											t('在世界树中查看此步骤'),
-										),
-									),
-						)
-					: null,
-			)
-		}
-
-		/** **命题货架**:按本体状态分组;空组不出现。已确认的不在这里(它已升格为事实)。 */
-		function PropositionShelf(props) {
-			/**
-			 * 打开器**自己接**(不靠外层注入):谁渲染这个货架,点证据/点事实都能开原件。
-			 * 踩过的坑:只有最外层 `Facts` 注入 `openPreview` 时,单独渲染货架(测试缝、
-			 * 以后的复用)会让整排出处看着能点、点了没反应。
-			 */
-			/**
-			 * `props.X ?? 已有值`:外层 `Facts` 只传 `{data}`,而打开器在 `data` 里 ——
-			 * 直接写 `openRail: props.openRail` 会用 `undefined` 把它盖掉 ⇒ 链接永不渲染 ✗(踩过的坑)。
-			 */
-			const base = props.data ?? (typeof props.useProjection === 'function' ? props.useProjection('clearai') : undefined) ?? {}
-			const data = { ...base, openPreview: props.openPreview ?? base.openPreview, openRail: props.openRail ?? base.openRail, openSpectator: props.openSpectator ?? base.openSpectator }
-			const rows = (data.goal?.hypotheses ?? []).filter((row) => row.status !== 'confirmed')
-			const groups = PROPOSITION_GROUPS.map((group) => ({ ...group, rows: rows.filter((row) => row.status === group.status) })).filter((group) => group.rows.length > 0)
-			return h(
-				Section,
-				{ title: `${t('命题 · ')}${rows.length}` },
-				rows.length === 0
-					? h('div', { style: S.faint }, t('暂无命题。每条需一句主张与一句推翻条件;通过验证后升格为事实。'))
-					: h(
-							'div',
-							null,
-							...groups.map((group) =>
-								h(
-									'div',
-									{ key: group.status },
-									h('div', { style: S.group }, group.label, h('span', { style: S.groupN }, String(group.rows.length))),
-									...group.rows.map((row) => h(PropositionRow, { key: row.id, data, row, open: props.open === row.id, onToggle: () => props.onToggle(row.id) })),
-								),
-							),
-						),
+				open ? h(ConclusionDetail, { row, data: props.data, onFocus: props.onFocus }) : null,
 			)
 		}
 
-		/**
-		 * 一条缺口的**去处**(没有就返回 null,由行里如实只写「下一步」)。
-		 *
-		 * 「可点则跳」不是每条都能跳:缺口是**账本自己算出来的欠账**,有的欠在模型那一侧
-		 * (要用哪个动词补),有的欠在本面板别处。能跳到具体去处的才挂链接;
-		 * 跳不到的**不假装可点**——那会教人学会「点了没反应」。
-		 */
-		const gapTarget = (code, data, onShowEntity) => {
-			if (code === 'entities_unlanded' && typeof onShowEntity === 'function') return { label: t('看实体图'), title: t('切到实体图那一层,看有哪些实例节点'), run: onShowEntity }
-			if ((code === 'no_language' || code === 'orphan_terms') && typeof data?.openPreview === 'function') return { label: t('打开词汇货架(原生预览)'), title: t('原生预览打开它'), run: () => data.openPreview('clear/ontology/domain.md') }
-			return null
-		}
-
-		/**
-		 * **缺口行**:「结构完整」这类结论之外,这一栏把**欠账**摆出来。
-		 *
-		 * 每条 = code 的人话 + 计数 + 现状(折法侧写好的 `detail`)+ 下一步(`nextAction`),
-		 * 能跳的去处挂成链接。缺口的算法在折法侧(账本是唯一生产者),这里**不重算**——
-		 * 客户端自己再算一套,两边迟早各说各话。
-		 */
-		const GapShelf = ({ data, onShowEntity }) => {
-			const gaps = Array.isArray(data?.knowledge?.gaps) ? data.knowledge.gaps : []
-			if (gaps.length === 0) return null
+		/** 结论列表:按可信度分组,空组不出现。 */
+		function ConclusionList(props) {
+			const rows = props.rows
+			if (rows.length === 0) return h('div', { className: 'clearai-quiet' }, t('还没有结论。模型立下判断之后,这里一行一条。'))
 			return h(
-				Section,
-				{ title: `${t('缺口')} ${gaps.length}` },
-				...gaps.map((gap, index) => {
-					const code = String(gap?.code ?? '')
-					const label = GAP_CODES.includes(code) ? GAP_LABEL[code] : null
-					const count = typeof gap?.count === 'number' ? gap.count : null
-					const target = gapTarget(code, data, onShowEntity)
-					const detail = String(gap?.detail ?? '')
-					const nextAction = String(gap?.nextAction ?? '')
+				'div',
+				{ className: 'clearai-list' },
+				...TRUST_ORDER.map((trust) => {
+					const group = rows.filter((row) => row.trust === trust)
+					if (group.length === 0) return null
 					return h(
 						'div',
-						{ key: `${code}-${index}`, style: S.row },
-						h(
-							'div',
-							{ style: S.inline },
-							label === null
-								? h('span', { style: S.tagStrong, title: code }, t('未登记的缺口类型'))
-								: h('span', { style: S.tagStrong }, label),
-							count === null ? null : h('span', { style: S.faint }, String(count)),
-							target === null ? null : h(Link, { title: target.title, onClick: target.run }, target.label),
-						),
-						detail === '' ? null : h('div', { style: S.faint }, t(detail)),
-						nextAction === '' ? null : h('div', { style: S.dim }, `${t('下一步:')}${t(nextAction)}`),
+						{ key: trust, className: 'clearai-group' },
+						h('div', { className: 'clearai-group-head' }, TRUST_WORD[trust], h('span', null, String(group.length))),
+						...group.map((row) => h(ConclusionRow, { key: row.key, row, open: props.open === row.key, onToggle: props.onToggle, data: props.data, onFocus: props.onFocus })),
 					)
 				}),
 			)
 		}
 
-		/** **事实货架**:已确认、可作已知的那一层。每条都带边界——没有边界的事实没人敢用。 */
-		function FactShelf(props) {
-			const base = props.data ?? (typeof props.useProjection === 'function' ? props.useProjection('clearai') : undefined) ?? {}
-			const data = { ...base, openPreview: props.openPreview ?? base.openPreview, openRail: props.openRail ?? base.openRail, openSpectator: props.openSpectator ?? base.openSpectator }
-			const facts = data.facts ?? []
+		/** 页眉:在回答什么 · 一行计数 · 待处理 · 迷你进度轨。 */
+		function AtlasHeader(props) {
+			const { data, rows } = props
+			const live = rows.filter((row) => row.trust !== 'replaced')
+			const counts = TRUST_ORDER.filter((trust) => trust !== 'replaced')
+				.map((trust) => [trust, rows.filter((row) => row.trust === trust).length])
+				.filter(([, count]) => count > 0)
+			const stations = STATIONS().map((name, index) => [name, live.filter((row) => row.station >= index + 1).length])
+			const needYou = Array.isArray(data?.needYou) ? data.needYou : []
 			return h(
-				Section,
-				{ title: `${t('本体货架 · ')}${facts.length}`, mark: true },
-				facts.length === 0
-					? h(
-							'div',
-							{ style: S.faint },
-							data.goal === null || data.goal === undefined
-								? t('暂无目标。验证达门槛且无推翻的命题在验收时升格为事实。')
-								: t('达门槛且无推翻的命题在目标验收时升格为事实(写入 clear/knowledge/facts/)。'),
-						)
+				'div',
+				{ className: 'clearai-head' },
+				h('div', { className: 'clearai-question', title: String(data?.goal?.claim ?? '') }, data?.goal ? String(data.knowledgeView?.goal?.headline ?? data.goal.claim ?? '') : t('还没有立目标')),
+				counts.length === 0 ? null : h('div', { className: 'clearai-counts' }, counts.map(([trust, count]) => `${TRUST_WORD[trust]} ${count}`).join(' · ')),
+				...needYou.map((item, index) => h('div', { key: `need-${index}`, className: 'clearai-need' }, h('b', null, t('待处理')), String(item?.text ?? ''))),
+				live.length === 0
+					? null
 					: h(
 							'div',
-							null,
-							...facts.map((row) =>
-								h(
-									'div',
-									{
-										key: row.id,
-										style: S.factRow,
-										/** 这一格**就是**事实库:点这条事实开它的原件(右侧原生预览),不再另挂一个「打开事实库」。 */
-										onClick: row.path === null || row.path === undefined || data.openPreview === undefined ? undefined : () => data.openPreview(row.path),
-										title: row.path === null || row.path === undefined ? '' : `${t('打开 ')}${row.path}`,
-									},
-									h(
-										'div',
-										{ style: S.factClaim },
-										/**
-										 * 复核状态直接说在标题旁边:一条**已撤回**的事实仍留在这里(P5:记录不删),
-										 * 但它已经不能当「已知」引用了——不写出来,读者会照旧引用它。
-										 */
-										dash(row.text),
-										row.review?.decision === 'retracted'
-											? h('span', { style: { ...S.tag, marginLeft: 6 } }, t('人已撤回(记录保留)'))
-											: row.refuted === true
-												? h('span', { style: { ...S.tag, marginLeft: 6 } }, t('被推翻 · 待裁决'))
-												: null,
-									),
-									h(
-										'div',
-										{ style: S.factMeta, title: row.scope === null || row.scope === undefined ? '' : String(row.scope) },
-										/**
-										 * 边界和证据的「依据」是同一类字段 ⇒ **同一条规矩**:列表放摘要、全文进 tooltip。
-										 * 真数据里边界常是 200~300 字,三条事实就把这一格撑到一千多字 ✗(货架只放摘要)。
-										 */
-										`${t('边界:')}${row.scope === null || row.scope === undefined || String(row.scope).trim() === '' ? '(未写——引用前请谨慎)' : brief(row.scope, 80)}${t(' · 支持到 ')}${dash(row.level)}${t(' · 证据 ')}${(row.evidenceIds ?? []).length}${t(' 条')}`,
-										/**
-										 * 原件的标签用**文件名**(「打开原件」四平八稳,但一排下来同样认不出是谁)。
-										 */
-										/**
-										 * 整行已经可点开原件 ⇒ 不再挂一个同样动作的「事实存档」✗(同一动作不开两条路)。
-										 * 原件路径在整行的 tooltip 里(`打开 <path>`)。
-										 */
-										/**
-										 * 跳去它那一步。**不把 `openRail` 当成渲染前提** ——
-										 * 把渲染前提挂在它上面,整条链接会一起消失。
-										 * 拿不到 `openRail` 也照常渲染:点了至少把聚焦设上、并试一次原生切视图。
-										 */
-										stepOfFact(data, row) === null
-											? null
-											: h(
-													Link,
-													{
-														onClick: (event) => {
-															event?.stopPropagation?.()
-															treeFocus.set({ plan: rowPlanOf(data, row), step: stepOfFact(data, row), branch: null })
-															if (data.openRail !== undefined) data.openRail('clearai-worldtree')
-														},
-														title: t('打开世界树并选中产出这条事实的验证步'),
-													},
-													t('在世界树中查看此步骤'),
-												),
-									/**
-									 * **冲突内联标记**:冲突行只给指针,受害的条目自己也要亮出来——
-									 * 读者扫到这一行时不必回头去对那一行指针。
-									 */
-									data.conflictOf !== undefined && data.conflictOf.has(row.id)
-										? h('div', { style: S.row }, h('span', { style: { ...S.tag, borderColor: 'rgba(220,38,38,0.7)', color: '#dc2626' } }, `${t('冲突')} · ${String(data.conflictOf.get(row.id).predicate)}`), h('span', { style: S.faint }, ` ${data.conflictOf.get(row.id).sides.map((side) => `${side.fact}(${side.value})`).join(' ')}`))
-										: null,
-									h(AssertionChips, { assertions: row.assertions, ui: data.assertionUI, promoted: true }),
-									),
-								),
-							),
+							{ className: 'clearai-track' },
+							...stations.flatMap(([name, count], index) => [
+								index === 0 ? null : h('span', { key: `line-${index}`, className: 'clearai-track-line', 'data-on': count > 0 ? '1' : '0' }),
+								h('span', { key: `st-${index}`, className: 'clearai-track-stop', 'data-on': count > 0 ? '1' : '0' }, h('i', null), `${name} ${count}`),
+							]),
 						),
 			)
 		}
 
 		/**
-		 * **「事实」页签**:一个**知识货架**,不是机制说明页。
+		 * **本体格**(中栏视图)。
 		 *
-		 * 上架 = 已确认事实(可用作下一轮已知,按支持等级分级、每条带边界);
-		 * 下架 = 命题(人与模型提出的候选知识,按本体状态分组流转)。
-		 * 默认只回答一个问题:「我现在能信什么」;点开一条命题才回答「凭什么」。
+		 * 取数与从前一样:宿主半的会话投影单元 `clearai` 由插座作为 `useProjection` 交下来。
+		 * 界面状态(图层、全屏、选中、展开哪条、只看哪个词)全是界面的事,一个字节都不进账本。
 		 */
-		function Facts(props) {
-			// 取数与 Panel/Deliverables 同一姿势:宿主半的会话投影单元 `clearai` 由插座作为标准 prop 交下来。
+		function Atlas(props) {
 			const projected = typeof props.useProjection === 'function' ? props.useProjection('clearai') : undefined
 			const [manual, setManual] = React.useState(null)
-			/** 本体格的界面状态:图层次/全景/图带开关/过滤/芯片展开/词汇区开关。全是界面状态,不进账本。 */
 			const [layer, setLayer] = React.useState('ontology')
-			/** 图谱工作区是否打开(真正的全屏 overlay,不是把图带拉高)。界面状态,不进账本。 */
 			const [workspace, setWorkspace] = React.useState(false)
-			const [bandOpen, setBandOpen] = React.useState(true)
 			const [filter, setFilter] = React.useState(null)
-			const [chipKey, setChipKey] = React.useState(null)
-			const [vocabOpen, setVocabOpen] = React.useState(null)
+			const [focusNode, setFocusNode] = React.useState(null)
 			const incoming = useFocus(factsFocus)
+			/** 样式表由 `apply` 挂;面板被单独挂载(截图、预览)时也自己挂一次——同一个标记,不会挂两份。 */
+			React.useEffect(() => {
+				installStyles()
+			}, [])
 			if (projected === undefined || projected === null) {
-				return h('div', { style: S.wrap }, h('div', { style: S.bar }, h('span', { style: S.title }, t('本体'))), h(Empty, null, t('暂无数据。发送第一条消息后,此处显示已确立条目与在验命题。')))
+				return h('div', { className: 'clearai-atlas' }, h(Empty, null, t('还没有内容。发第一条消息后,这里显示本体图和结论。')))
 			}
 			const data = { ...projected, openPreview: props.openPreview, openRail: props.openRail, openSpectator: props.openSpectator }
-			const facts = data.facts ?? []
-			const propositions = (data.goal?.hypotheses ?? []).filter((row) => row.status !== 'confirmed')
-			/** 外面点进来的聚焦优先;手动点行仍然有效(聚焦为 null 时用它)。 */
+			const rows = conclusionsOf(data)
+			const lexicon = data.lexicon ?? null
+			/** 世界树那边点进来的聚焦优先;手动点行仍然有效。 */
 			const focused = incoming === null || incoming === undefined ? null : propositionForStep(data, incoming.step)
 			const open = focused ?? manual
-			/**
-			 * **本体层**:没有词条时下面这一切都不存在(零成本契约)——
-			 * 图带、冲突行、过滤、芯片、维护区,每一个都以「有东西可说」为前提。
-			 */
-			const lexicon = data.lexicon ?? null
-			const hasVocabulary = lexicon !== null && ((lexicon.terms ?? []).length > 0 || (lexicon.predicates ?? []).length > 0)
-			const conflicts = hasVocabulary === true ? (lexicon.conflicts ?? []) : []
-			/** factId → 它卷入的那对冲突(内联标记用;同一事实卷多对时取第一对)。 */
-			const conflictOf = new Map()
-			for (const conflict of conflicts) for (const side of conflict.sides) if (typeof side.fact === 'string' && !conflictOf.has(side.fact)) conflictOf.set(side.fact, conflict)
-			/** 过滤词条:图带点概念节点或芯片动作都会给词条 id;文本兜底匹配。 */
 			const filterTerm = filter === null ? null : ((lexicon?.terms ?? []).find((item) => item.id === filter) ?? (lexicon?.predicates ?? []).find((item) => item.id === filter) ?? { id: filter, label: filter, aliases: [] })
-			const matchedFacts = filterTerm === null ? facts : facts.filter((row) => termMatches(filterTerm, row))
-			const matchedPropositions = filterTerm === null ? propositions : propositions.filter((row) => termMatches(filterTerm, row))
-			const filteredData = filterTerm === null ? data : { ...data, facts: matchedFacts, goal: { ...data.goal, hypotheses: matchedPropositions } }
-			/** 断言芯片的公共道具:词条卡从词汇里查,动作回连过滤与图带。 */
-			const assertionUI = hasVocabulary === true ? { lexicon, openKey: chipKey, onToggle: (key) => setChipKey(chipKey === key ? null : key), onFilter: (id) => { setFilter(id); setChipKey(null) }, onGraph: () => { setBandOpen(true); setChipKey(null) } } : null
-			filteredData.assertionUI = assertionUI
-			filteredData.conflictOf = conflictOf
-			/** 语言先于句子:0 条目 0 命题而有词条时,维护区自动展开。 */
-			const vocabAutoOpen = vocabOpen === null ? (facts.length === 0 && propositions.length > 0 === false && hasVocabulary === true) : vocabOpen
-			const vocabActuallyOpen = vocabOpen === null ? (facts.length === 0 && propositions.length === 0 && hasVocabulary === true) : vocabOpen
-			/**
-			 * **缺口**:折法侧算好的欠账(客户端的唯一来源是投影)。空数组 = 不欠,这一栏整块不出现。
-			 * 实体图空态要用的那条读数也从这里取:`entities_unlanded` 的 count
-			 * 就是「多少个断言主体还没有落到实体图」。
-			 */
+			const shown = filterTerm === null ? rows : rows.filter((row) => termMatches(filterTerm, row))
 			const gaps = Array.isArray(data.knowledge?.gaps) ? data.knowledge.gaps : []
 			const unlandedRow = gaps.find((gap) => gap?.code === 'entities_unlanded')
-			const unlanded = typeof unlandedRow?.count === 'number' ? unlandedRow.count : null
-			/** 缺口行的去处之一:把图带切到实体层(空态的出口就在这一层)。 */
-			const showEntity = () => {
-				setLayer('entity')
-				setBandOpen(true)
-			}
-			const bar = h(
-				'div',
-				{ style: S.bar },
-				h('span', { style: S.title }, t('本体')),
-			)
-			if (hasVocabulary === false) {
-				/** 零成本:没有词条时,这一格与从前逐像素相同(两个货架 + 页眉)——但缺口照报。 */
-				return h('div', { style: S.wrap }, bar, h(GapShelf, { data, onShowEntity: showEntity }), h(FactShelf, { data }), h(PropositionShelf, {
-					data,
-					open,
-					onToggle: (id) => {
-						factsFocus.set(null)
-						setManual(open === id ? null : id)
-					},
-				}))
-			}
 			return h(
 				'div',
-				{ style: S.wrap },
-				bar,
-				/** 缺口行:欠账摆在最前面(它决定这个目标现在能不能收口),每条都带下一步。 */
-				h(GapShelf, { data, onShowEntity: showEntity }),
-				/** 冲突行:仅当有冲突。一行指针 + 内联标记,不做大区块(例外才打扰)。 */
-				conflicts.length > 0
-					? h(
-							'div',
-							{ style: S.section },
-							h('div', { style: S.head }, `${t('冲突')} ${conflicts.length}${t(' 对')}`),
-							...conflicts.map((conflict, index) =>
-								h('div', { key: `cf-${index}`, style: S.row }, `${String(conflict.predicate)} · ${String(conflict.subject)}:`, ...conflict.sides.map((side, sideIndex) => h('span', { key: `cf-${index}-${sideIndex}`, style: S.faint }, ` ${String(side.fact ?? '?')}(${String(side.value)})`)), ` —— ${t('只暴露,不裁决;撤回或维持由人决定')}`),
-							),
-						)
-					: null,
-				bandOpen === false
-					? h('div', { style: S.section }, h('span', { style: S.chipAction, onClick: () => setBandOpen(true) }, t('展开图带')))
-					: h(GraphBand, { lexicon, layer, unlanded, onLayer: setLayer, onFilter: (id) => setFilter(filter === id ? null : id), sessionId: data.sessionId, fullscreen: workspace, onToggleFullscreen: () => setWorkspace(workspace !== true) }),
-				/** 过滤状态行:仅当过滤激活;N/M 说真话,✕ 一键清除。 */
+				{ className: 'clearai-atlas' },
+				h(AtlasHeader, { data, rows }),
+				h(GraphBand, {
+					lexicon,
+					layer,
+					unlanded: typeof unlandedRow?.count === 'number' ? unlandedRow.count : null,
+					onLayer: setLayer,
+					onFilter: (id) => setFilter(filter === id ? null : id),
+					focus: focusNode,
+					sessionId: data.sessionId,
+					fullscreen: workspace,
+					onToggleFullscreen: () => setWorkspace(workspace !== true),
+				}),
 				filterTerm === null
 					? null
 					: h(
 							'div',
-							{ style: S.inline },
-							h('span', { style: S.tag }, `${t('按')}「${String(filterTerm.label ?? filterTerm.id)}」${t('过滤')}:${matchedFacts.length + matchedPropositions.length}/${facts.length + propositions.length}${t(' 条')}`),
-							h('span', { style: S.chipAction, onClick: () => setFilter(null) }, t('清除')),
+							{ className: 'clearai-filter' },
+							`${t('只看与「')}${String(filterTerm.label ?? filterTerm.id)}${t('」相关的')}${t(':')}${shown.length}/${rows.length}`,
+							h('span', { className: 'clearai-link', onClick: () => setFilter(null) }, t('清除')),
 						),
-				h(FactShelf, { data: filteredData }),
-				h(PropositionShelf, {
-					data: filteredData,
+				h('div', { className: 'clearai-section-head' }, t('结论')),
+				h(ConclusionList, {
+					rows: shown,
 					open,
-					onToggle: (id) => {
-						// 手动点行:先清掉外面的聚焦(否则它一直压着手动选择,点了没反应 ✗)
+					data,
+					onToggle: (key) => {
 						factsFocus.set(null)
-						setManual(open === id ? null : id)
+						setManual(open === key ? null : key)
+					},
+					onFocus: (id) => {
+						const node = (lexicon?.graph?.nodes ?? []).find((item) => item.layer === 'entity' && String(item.ref ?? '') === id)
+						if (node !== undefined) {
+							setLayer('entity')
+							setFocusNode(node.id)
+						}
 					},
 				}),
-				h(VocabBlock, { lexicon, open: vocabActuallyOpen, onToggle: () => setVocabOpen(vocabActuallyOpen !== true), openPreview: props.openPreview, sessionId: data.sessionId }),
 			)
 		}
 
-		/**
-		 * 「点开看」的目标:每个会话一份的小状态。
-		 *
-		 * 它只是**界面状态**(点了哪一条),不是事实——事实仍然只有投影与读面两个来源。
-		 * 预览页签**第一次用到时才注册**:宁可少一张页签,也不放一张空的在那里。
-		 */
-		/**
-		 * 打开 DSH **原生**的文档预览。
-		 *
-		 * 第一性原理:预览是「把一条路径渲染成人能看的东西」——而宿主已经有这件东西了,而且比我们全:
-		 * `dsh-client-ui-sidebar-documentpreview` 注册了 **6 个实现**(text / markdown / html / image /
-		 * pdf / code),自己按地址认领标签、自己按后缀挑实现、自己分页读盘。我们原来那套
-		 * `<pre>` + 自己写读面,等于**把同一件事做第二遍,而且只做出了其中一种**(把 md 显示成源码、
-		 * 根本打不开图)。
-		 *
-		 * 奥卡姆:不新造渲染器,也不新造读面——只按原生约定的地址把文件**递给**它:
-		 *   `dsh-resource://file/session/<sessionId>/<逐段编码的路径>`
-		 * (地址语法与编码规则照抄 `workspace-path/file-address`:`/#?` 之前、按 `/` 分段、逐段解码。)
-		 * 路径是绝对路径时,分段里会自然出现一个空段,拼回来仍是绝对路径——原生就是这么分的。
-		 *
-		 * **第二参是会话 id,不是路径**(传错会直接读空):读面按它查工作区根
-		 * (`workspaceFileScope`),拿错了就原样报
-		 * `lookup provider "workspaceFileScope" did not resolve the requested identity`。
-		 * 谁调用谁负责给对 —— 见 `apply` 里的 `openPreviewFor`,按**座位自己的** props 定型。
-		 */
-		/** 时间戳 → 「YYYY-MM-DD HH:mm」。与宿主半卡片里的写法一致:同一份事实在两处长得不一样,人就会怀疑其中一处。 */
-		const stampOf = (value) => (typeof value === 'number' && Number.isFinite(value) ? new Date(value).toISOString().slice(0, 16).replace('T', ' ') : t('未知'))
-
 		/** 逐段编码:照抄原生的 `encodeSegment`——`:` 保持字面(Windows 盘符),其余交给 encodeURIComponent。 */
 		const encodeAddressSegment = (segment) => encodeURIComponent(segment).replace(/%3A/gi, ':')
 		const fileAddress = (sessionId, path) => {
@@ -1506,236 +1114,18 @@ window.__ModuleLoader__.load({
 		}
 
 		/**
-		 * 产物视图(中栏第一眼该看「我拿到了什么」)。
+		 * 世界树(右栏):计划的步骤与闸门,一条脊柱从上往下。
+		 *
+		 * 几何照抄 ClearAI `PlanTree.tsx`(`ROW_H=30 / NODE_R=6`):行高固定 → 拓扑常驻不变。
+		 * 四条正交通道各答一个问题、可任意叠加:
 		 *
-		 * 数据走宿主读面(`/api/clearai/deliverables`):交付物的**存在性是文件系统事实**,
-		 * 浏览器读不了盘,所以由宿主在请求时即时 stat(顺带给出字节与修改时间)。
-		 * 投影一变(推进了一步、多了一条证据)就重新取一次——面板不许比状态慢一拍。
+		 *   ① **填充**  已落定终局了吗      实心 = 是(于是「实心到哪儿就是做到哪儿」,进度成了一眼可读的形)
+		 *   ② **颜色**  什么结局            绿=过 灰=待办/作废 蓝=在跑 琥珀=等你
+		 *   ③ **光环**  此刻在动吗          虚线环 = 独立评估者正在审这一步
+		 *   ④ **分段**  被闸门裁断过几次    N>1 才分段,封顶 3 段,驳回的那几段画红
 		 *
-		 * 这条读面回**两半**,这一栏也画两半:
-		 *   · `stages`  = **声明**(计划里写了要交什么、谁验的、盘上在不在);
-		 *   · `outputs` = **实际**(products/ 底下真有、但没有任何计划声明过的)。
-		 * 为什么两半都要:在一个已经有产物的老项目里开新会话,原来这一栏
-		 * 只有「阶段 0 · 交付 0/0」—— 可人此刻问的是「我拿到了什么」,盘上那份 46 KB 的 HTML
-		 * 明明就在。声明与实际是两件事,少画一半就等于对着半张表回答。
-		 */
-		function Deliverables(props) {
-			const data = typeof props.useProjection === 'function' ? props.useProjection('clearai') : undefined
-			const sessionId = data === null || data === undefined ? null : data.sessionId
-			const [stages, setStages] = React.useState(null)
-			const [onDisk, setOnDisk] = React.useState([])
-			const [error, setError] = React.useState(null)
-			const stamp = data === null || data === undefined ? '' : `${data.plan?.id ?? ''}:${data.plan?.advancedCount ?? 0}:${data.plan?.totalCount ?? 0}:${(data.evidence || []).length}:${(data.facts || []).length}`
-			React.useEffect(() => {
-				if (typeof sessionId !== 'string' || sessionId === '') return
-				let alive = true
-				fetch(`/api/clearai/deliverables?sessionId=${encodeURIComponent(sessionId)}`)
-					.then(readResponse)
-					.then((result) => {
-						if (!alive) return
-						if (result.ok === true) {
-							setStages(result.payload.stages ?? [])
-							setOnDisk(result.payload.outputs ?? [])
-						} else setError(result.error)
-					})
-					.catch((thrown) => {
-						if (alive) setError(String(thrown?.message ?? thrown))
-					})
-				return () => {
-					alive = false
-				}
-			}, [sessionId, stamp])
-
-			const openStage = data === null || data === undefined ? null : data.plan
-			// 点一条产物 → **原生预览**(md 渲染成 md、png 直接出图、html 直接看、pdf 用原生 pdf.js)
-			const open = (path) => props.openPreview?.(path)
-			if (sessionId === null) {
-				return h('div', { style: S.wrap }, h('div', { style: S.bar }, h('span', { style: S.title }, t('产物'))), h(Empty, null, t('这个会话还没有 ClearAI 的状态。')))
-			}
-			const advanced = (stages ?? []).flatMap((stage) => stage.steps.filter((step) => step.status === 'advanced' && step.artifacts.length > 0))
-			const delivered = advanced.reduce((sum, step) => sum + step.artifacts.filter((artifact) => artifact.exists).length, 0)
-			const declared = (stages ?? []).flatMap((stage) => stage.steps).reduce((sum, step) => sum + step.artifacts.length, 0)
-			/**
-			 * 「核心产物」:**盘上真的在**的输出成果(products/),跨阶段汇总在最上面。
-			 * 中间过程(lab/)不进这一栏——这正是 ClearAI 分类的用途:别让 100 个中间文件
-			 * 淹没 3 份交付物。
-			 */
-			/**
-			 * 「核心产物」= **一份文件一行**。
-			 *
-			 * 原先摊平的是「步骤 × 声明产物」这对组合 ⇒ 一个文件被几个步骤声明就出现几次 ✗
-			 * (真数据:`qinrun-dipforming-3d.html` 被 build/verify-3d/rebuild/integrate 四步都声明了,
-			 * 于是同一份 1153646 字节的文件列了四行,计数也跟着膨胀 ✗)。
-			 * 「后面几步也声明了它」是**有用的信息**(那几步在验它、整合它),所以去重时把它收进 `steps`,
-			 * 而不是丢掉。
-			 */
-			const byPath = new Map()
-			for (const stage of stages ?? []) {
-				for (const step of stage.steps) {
-					for (const artifact of step.artifacts) {
-						if (artifact.exists !== true) continue
-						if (artifact.area?.key !== 'output' && artifact.area?.key !== 'other') continue
-						const seen = byPath.get(artifact.path)
-						if (seen === undefined) byPath.set(artifact.path, { ...artifact, stage: stage.plan, steps: [step.id] })
-						else if (!seen.steps.includes(step.id)) seen.steps.push(step.id)
-					}
-				}
-			}
-			const coreOutputs = [...byPath.values()]
-			/** 盘上已有的:不铺满一屏(它只是「第一眼」),但如实说还有多少没列。 */
-			const ON_DISK_SHOWN = 25
-			const shownOnDisk = onDisk.slice(0, ON_DISK_SHOWN)
-			const hiddenOnDisk = onDisk.length - shownOnDisk.length
-			const clickable = coreOutputs.length + onDisk.length
-			return h(
-				'div',
-				{ style: S.wrap },
-				h(
-					'div',
-					{ style: S.bar },
-					h('span', { style: S.title }, t('产物')),
-					/**
-					 * 两个计数的**单位不同**,所以分开说:「处」= 步骤声明(一份文件被四步声明算四处),
-					 * 「份」= 去重后的文件。混着写会让人以为盘上有四份。
-					 */
-					h('span', { style: S.faint }, `${t('阶段 ')}${(stages ?? []).length}${t(' · 交付 ')}${delivered}/${declared}${t(' 处声明')}${onDisk.length === 0 ? '' : ` · 盘上 ${onDisk.length} 份`}`),
-					clickable === 0 ? null : h('span', { style: { ...S.faint, marginLeft: 'auto' } }, t('点击在右栏预览')),
-				),
-				error !== null ? h('div', { style: S.faint }, `${t('读不到交付物:')}${error}`) : null,
-				coreOutputs.length === 0
-					? null
-					: h(
-							'div',
-							{ style: S.section },
-							h('div', { style: S.head }, `${t('核心产物(')}${coreOutputs.length})`),
-							coreOutputs.map((artifact) =>
-								h(
-									'div',
-									{ key: artifact.path, style: S.inline },
-									h('span', { style: S.tagStrong }, artifact.area?.label ?? t('未分类')),
-									h(Link, { onClick: () => open(artifact.path) }, h('span', { style: S.mono }, artifact.path)),
-									h(
-										'span',
-										{ style: S.faint, title: artifact.steps.join(' · ') },
-										`${artifact.bytes}${t(' 字节 · ')}${artifact.steps.length === 1 ? `步 ${artifact.steps[0]}` : `步 ${artifact.steps[0]} 等 ${artifact.steps.length} 步`}`,
-									),
-								),
-							),
-						),
-				/**
-				 * 「盘上已有」= 实际那一半。它**不进**交付计数(计数只认计划声明),
-				 * 所以每条都带上这句交代,免得人以为计划多交了几份。
-				 */
-				onDisk.length === 0
-					? null
-					: h(
-							'div',
-							{ style: S.section },
-							h('div', { style: S.head }, `${t('盘上已有(')}${onDisk.length})`),
-							...shownOnDisk.map((item) =>
-								h(
-									'div',
-									{ key: item.path, style: S.inline },
-									h('span', { style: S.tag }, item.area?.label ?? t('未分类')),
-									h(Link, { onClick: () => open(item.path) }, h('span', { style: S.mono }, item.path)),
-									h('span', { style: S.faint }, `${item.bytes}${t(' 字节 · 未被任何计划声明')}`),
-								),
-							),
-							hiddenOnDisk <= 0 ? null : h('div', { style: S.faint }, `${t('还有 ')}${hiddenOnDisk}${t(' 份没列出来(这一栏只列最近改动的 ')}${ON_DISK_SHOWN}${t(' 份)。')}`),
-						),
-				stages === null
-					? h('div', { style: S.faint }, t('读取中…'))
-					: stages.length === 0
-						? h(
-								Empty,
-								null,
-								onDisk.length === 0
-									? t('暂无计划。建立计划后,已交付步骤按阶段列于此处。')
-									: `${t('这个工作区盘上已经有 ')}${onDisk.length}${t(' 份产物,但没有任何计划声明过它们。点一条可以直接看(它们不计入交付)。')}`,
-							)
-						: stages.map((stage) =>
-								h(
-									'div',
-									{ key: stage.plan, style: S.section },
-									h(
-										'div',
-										{ style: S.head },
-										// 「待确认」改成「授权记号未落账」:前者暗示有一道要人按的门,而门已经砍了——
-										// 记号会在第一次交付时按事实补写(行为即授权)。
-										`${openStage !== null && openStage.id === stage.plan ? '当前阶段 · ' : ''}${stage.plan} · ${dash(stage.status)}${stage.confirmedAt === null ? ' · 授权记号未落账(交付即落账)' : ''}`,
-									),
-									stage.brief === '' ? null : h('div', { style: S.faint }, stage.brief),
-									stage.summary === null || stage.summary === undefined ? null : h('div', { style: S.faint }, `${t('收束:')}${stage.summary}`),
-									stage.steps.map((step) =>
-										h(
-											'div',
-											{ key: step.id, style: S.row },
-											h(
-												'div',
-												{ style: S.inline },
-												h('span', { style: step.status === 'advanced' ? S.tagStrong : S.tag }, gloss(STEP, step.status)),
-												h('span', { style: S.mono }, `${step.ordinal}. ${step.id}`),
-												step.level === null ? null : h('span', { style: S.faint }, step.level),
-												h('span', null, step.do),
-											),
-											h('div', { style: S.faint }, `${t('判据:')}${step.doneCriteria}${step.voidReason === null || step.voidReason === undefined ? '' : `(作废:${step.voidReason})`}`),
-											step.artifacts.length === 0
-												? h('div', { style: S.faint }, t('这一步没有声明产物。'))
-												: h(
-														'div',
-														null,
-														step.artifacts.map((artifact) =>
-															h(
-																'div',
-																{ key: artifact.path, style: S.inline },
-																h('span', { style: artifact.exists ? S.tagStrong : S.tag }, artifact.exists ? t('在') : artifact.directory === true ? t('目录') : t('缺')),
-																h('span', { style: S.faint }, artifact.area?.label ?? t('未分类')),
-																/**
-																 * 判据为「缺」的那条**不是链接**:点进去只会撞一个不存在的路径
-																 * (原生预览会照实报错)。机制上不可点,胜过在文案里劝人别点。
-																 * 它带来的信息仍然齐全:路径、分类、「盘上没有」。
-																 */
-																artifact.exists
-																	? h('span', { className: 'clearai-link', onClick: () => open(artifact.path), title: t('右栏预览') }, artifact.path)
-																	: h(
-																			'span',
-																			{ style: S.mono, title: artifact.directory === true ? t('声明的是目录;准入要求具体文件——目录不算物证') : t('盘上没有这个文件') },
-																			artifact.path,
-																		),
-																artifact.exists
-																	? h('span', { style: S.faint }, `${artifact.bytes}${t(' 字节')}`)
-																	: h('span', { style: S.faint }, artifact.directory === true ? t('是目录(不算物证)') : t('盘上没有')),
-															),
-														),
-													),
-										),
-									),
-								),
-							),
-			)
-		}
-
-		/**
-		 * 世界树(右栏):计划即世界树——脊柱上一串步,到 fork 就地裂成并行车道,
-		 * 收敛画成菱形,再回到同一条脊柱(git-graph 式)。
-		 *
-		 * 几何与**四条正交通道**照抄 ClearAI `PlanTree.tsx`(`ROW_H=30 / LANE_W=15 / NODE_R=6`):
-		 * 行高固定 → 拓扑常驻不变;车道不移位 → 叉开与收敛看得清。四条通道各答一个问题、可任意叠加:
-		 *
-		 *   ① **填充**  已落定终局了吗      实心 = 是(于是「实心到哪儿就是做到哪儿」,进度成了一眼可读的形)
-		 *   ② **颜色**  什么结局            绿=过/采纳 灰=待办/落选 蓝=在跑 琥珀=等你
-		 *   ③ **光环**  此刻在动吗          呼吸 = 是(步骤与世界线共用同一惯用法)
-		 *   ④ **分段**  被闸门裁断过几次    N>1 才分段,封顶 3 段,驳回的那几段画红
-		 *
-		 * 这一处曾丢过一批行为(分岔/推进/闪烁/选择/裁减/变灰)。必须都在的:
-		 * 空心圈与实心核、呼吸光环与虚线审计环、轮次分段弧、落选/作废的**变灰划掉**、
-		 * 虚线轨道(落选那条)、点行选中 → 树下详情(含给人的两个动作:采纳这条世界线 / 放弃探索)。
-		 *
-		 * 第一性原理:一棵树好不好读,取决于**每一条通道只答一个问题**。把「在动」「落定」
-		 * 「结局」「几轮」挤进同一个实心点,读者就得靠记住上一次的颜色差——那不是可视化,是暗号。
-		 *
-		 * 奥卡姆:不画的东西也写清楚为什么——越位内环(我们的投影里没有「越位」这条事实)、
-		 * run 级状态色(同上)、任务选择器与结算单(进展页签已有),都不引入。
+		 * 第一性原理:一棵树好不好读,取决于**每一条通道只答一个问题**。
+		 * 并行探索不在这里画车道:竞争路线是竞争的假设,各由一个步骤检验,所以它们就是脊柱上的几步。
 		 */
 		const TREE = {
 			rowHeight: 30,
@@ -1751,17 +1141,10 @@ window.__ModuleLoader__.load({
 			done: 'rgb(var(--dsw-color-success, 16 185 129))',
 			running: '#7dd3fc',
 			pending: '#cbd5e1',
-			adopted: 'rgb(var(--dsw-color-success, 16 185 129))',
-			recommend: 'rgb(var(--dsw-color-warning, 245 158 11))',
-			evaluated: '#64748b',
-			exploring: '#94a3b8',
 			pruned: '#cbd5e1',
-			/** 执行没跑成:低饱和红(照抄原设计的 branchFailed)。它不是落选,所以不能与灰混用。 */
-			failed: '#c98f8f',
-			/** 落选/作废那条轨道画虚线(3 3),与实线轨道分开。 */
 			rail: 'hsla(220, 9%, 46%, 0.35)',
 		}
-		/** 一步/一条车道**被闸门裁断过几次**(`block/counted` 折出来的驳回次数 + 通过的那一次)。 */
+		/** 一步**被闸门裁断过几次**(`block/counted` 折出来的驳回次数 + 通过的那一次)。 */
 		function treeLoops(blocks, planId, stepId, advanced) {
 			const counted = Number(blocks?.[planId]?.[stepId] ?? 0)
 			const fails = Number.isFinite(counted) && counted > 0 ? counted : 0
@@ -1769,33 +1152,15 @@ window.__ModuleLoader__.load({
 		}
 
 		/**
-		 * 把「计划 + 世界线」摊成带车道的行:脊柱 + fork 车道 + 收敛。纯函数,便于断言拓扑。
-		 *
-		 * 放弃过的分叉**画一行**(不铺车道):它是留档的事实,不是一条还在走的路;
-		 * 原设计里那棵树也把它留着——「什么都不删」在图上就是「还在,但灰了」。
-		 */
-		/**
-		 * **对外聚焦通道**:别的面点一个步骤/世界线,世界树要能**选中那一行**。
-		 *
-		 * 为什么需要它:树原先只有**内部**选中状态(点行看详情),外面够不着 ⇒
-		 * 「在世界树里看这一步」只能把树打开,不定位 ✗ —— 这是"点击跳转闭环"里缺的那一环。
+		 * **对外聚焦通道**:别的面点一个步骤,世界树要能**选中那一行**。
 		 *
-		 * 只做两件最小的事:
-		 *   · 一个**纯函数** `rowIndexOf(rows, target)`:行身份 = `step.id`(+ 有分支时 `branch.id`),
-		 *     返回行下标或 null(可单测 ✓);
+		 *   · 一个**纯函数** `rowIndexOf(rows, target)`:行身份 = `step.id`,返回行下标或 null(可单测 ✓);
 		 *   · 一个**订阅式小 store**:聚焦是**界面状态**,不是事实 —— 不写任何变更、不进账本 ✓。
 		 */
 		function rowIndexOf(rows, target) {
 			if (target === null || target === undefined || typeof target.step !== 'string' || target.step === '') return null
-			const sameStep = rows.map((row, index) => ({ row, index })).filter((item) => item.row?.step?.id === target.step)
-			if (sameStep.length === 0) return null
-			if (typeof target.branch === 'string' && target.branch !== '') {
-				const branch = sameStep.find((item) => item.row?.branch?.id === target.branch)
-				return branch === undefined ? null : branch.index
-			}
-			// 没指定分支:优先"代表这一步"的那一行(step / fork / abandoned),否则退到第一行
-			const head = sameStep.find((item) => item.row?.kind === 'step' || item.row?.kind === 'fork' || item.row?.kind === 'abandoned')
-			return (head ?? sameStep[0]).index
+			const index = rows.findIndex((row) => row?.step?.id === target.step)
+			return index === -1 ? null : index
 		}
 
 		/**
@@ -1835,86 +1200,28 @@ window.__ModuleLoader__.load({
 		/**
 		 * 哪条命题的证据来自这一步(纯函数:可单测)。
 		 *
-		 * 唯一的关系就是**步骤上登记的 `tests.hypothesis`** —— 不猜:这一步没登记命题
+		 * 唯一的关系就是**步骤上登记的 `tests.hypotheses`**(检验几条就取第一条展开)—— 不猜:这一步没登记命题
 		 * (自判的 L0 步骤常常没有)就返回 `null`,界面因此**不乱展开**任何一条命题 ✓。
 		 * (第一版这里写过一个"退一步看证据挂谁"的回退,而它又去查同一个索引 ⇒ 循环 ✗,已删。)
 		 */
 		function propositionForStep(data, stepId) {
 			if (typeof stepId !== 'string' || stepId === '') return null
-			const hypothesis = (data?.stepIndex ?? {})[stepId]?.tests?.hypothesis
+			const hypothesis = testedOf((data?.stepIndex ?? {})[stepId])[0]
 			return typeof hypothesis === 'string' && hypothesis !== '' ? hypothesis : null
 		}
 
-		function treeRows(plan, forks) {
-			const rows = []
-			for (const step of plan?.steps ?? []) {
-				const fork = (forks ?? []).find((item) => item.stepId === step.id)
-				if (fork === undefined) {
-					rows.push({ kind: 'step', lane: 0, step })
-					continue
-				}
-				// 放弃过的分叉画成**一行灰掉的留档**(不是消失:什么都不删在图上就是「还在,但灰了」)。
-				// 判据是 fold 派生的 `phase === 'abandoned'`(它同时带 abandonReason)。
-				if (fork.phase === 'abandoned') {
-					rows.push({ kind: 'abandoned', lane: 0, step, fork })
-					continue
-				}
-				rows.push({ kind: 'fork', lane: 0, step, fork })
-				// 车道从 **1** 起(照抄原型):第 0 道是脊柱——第一条车道要是压在脊柱上,
-				// 扇出去的四条线会缩成一条往下掉的蛇。
-				fork.branches.forEach((branch, index) => {
-					rows.push({ kind: 'branch', lane: 1 + index, step, fork, branch })
-				})
-				rows.push({ kind: 'converge', lane: 0, step, fork })
-			}
-			return rows
+		/** 计划摊成行:一步一行,全在脊柱上。纯函数,便于断言拓扑。 */
+		function treeRows(plan) {
+			return (plan?.steps ?? []).map((step) => ({ kind: 'step', lane: 0, step }))
 		}
 
-		/**
-		 * 行与行之间的**连接**(轨道):不是「相邻两行连一条」,而是显式的扇出/扇入。
-		 *
-		 * 按相邻行连线会把「脊柱裂成四条并行车道」——
-		 * 被画成了一条往右下掉的**蛇**——分叉点只连到第一条车道,第二条连第三条……
-		 * 那不是分叉,是排队。原设计用的是显式连接表(fork → 每条车道、每条车道 → 收敛菱形),
-		 * 所以四条车道是从同一个点扇出去的。这里照它重写。
-		 */
+		/** 行与行之间的连接:相邻两步连一段脊柱。 */
 		function treeConns(rows) {
-			const conns = []
-			let prevMain = null
-			let forkRow = null
-			let branchRows = []
-			rows.forEach((row, index) => {
-				if (row.kind === 'step' || row.kind === 'abandoned' || row.kind === 'fork') {
-					// 脊柱(含放弃的留档行)接上一段主线
-					if (prevMain !== null) conns.push({ from: prevMain, fromLane: 0, to: index, toLane: 0 })
-					prevMain = index
-					if (row.kind === 'fork') {
-						forkRow = index
-						branchRows = []
-					}
-					return
-				}
-				if (row.kind === 'branch') {
-					// 扇出:从**分叉点**连到这一条车道(不是从上一条车道连过来)
-					if (forkRow !== null) conns.push({ from: forkRow, fromLane: 0, to: index, toLane: row.lane })
-					branchRows.push({ idx: index, lane: row.lane })
-					return
-				}
-				// 收敛:每条车道各收一条线进来,然后主线继续
-				for (const branch of branchRows) conns.push({ from: branch.idx, fromLane: branch.lane, to: index, toLane: 0 })
-				branchRows = []
-				forkRow = null
-				prevMain = index
-			})
-			return conns
+			return rows.slice(1).map((_, index) => ({ from: index, fromLane: 0, to: index + 1, toLane: 0 }))
 		}
 
-		/**
-		 * 轨道该在节点**边缘**收住,不进节点内部(照抄原型):圆形让 NODE_R + 描边,
-		 * 收敛菱形按对角让 NODE_R·√2(它是旋转 45° 的方,竖直方向的顶点比半径远)。
-		 * 两端切线都是竖直的,所以直接在 y 上让开即可,不必求切向。
-		 */
-		const railClear = (row) => (row?.kind === 'converge' ? TREE.radius * Math.SQRT2 + 1 : TREE.radius + 1.5)
+		/** 轨道在节点**边缘**收住,不进节点内部(照抄原型)。 */
+		const railClear = () => TREE.radius + 1.5
 
 		/**
 		 * 一条连接画成什么路径:同车道 = 直线;跨车道 = 三次贝塞尔(控制点与端点同 x,
@@ -1943,70 +1250,18 @@ window.__ModuleLoader__.load({
 			const audits = context?.audits ?? []
 			const planId = context?.planId ?? null
 			const stepId = row.step?.id ?? null
-			const advanced = row.kind === 'branch' ? row.branch.status === 'adopted' : row.step?.status === 'advanced'
+			const advanced = row.step?.status === 'advanced'
 			const loops = treeLoops(blocks, planId, stepId, advanced)
-			// ① 填充:落定终局了吗(与原设计同一条既有谓词:adopted|pruned 已是终局,advanced|void 同理)
-			const settled =
-				row.kind === 'branch'
-					? row.branch.status === 'adopted' || row.branch.status === 'pruned'
-					: row.kind === 'converge'
-						? row.fork.phase === 'settled'
-						: row.step.status === 'advanced' || row.step.status === 'void'
-			// ③ 光环:此刻在动吗——两种事实,各自一条规则,都不猜
-			//    · 虚线环 = 有 Evaluator 正在审这一步(audits 里 verdict 还没回来)
-			//    · 实心呼吸 = 这条世界线还在探索(原设计的 run 级状态我们这侧没有,所以只画我们真有的)
-			const auditing = row.kind !== 'branch' && audits.some((audit) => audit.stepId === stepId && (audit.verdict === null || audit.verdict === undefined))
-			/**
-			 * 光环 = 「此刻在动吗」。两个**必须**排除的假话:
-			 *   · 步骤已经作废/交付了,它上面那条车道不可能还在跑(分叉没跟着收口时会留下这种孤儿);
-			 *   · 分叉自己已经放弃了(它下面没有「在动」的东西)。
-			 * 状态机那一侧该不该让分叉跟着步骤一起收口,是另一件事(记在 recon 里待定);
-			 * 但**界面不许说假话**这一条不依赖那个决定。
-			 */
-			const ownerAlive = row.step?.status !== 'void' && row.step?.status !== 'advanced'
-			// 失败的世界线不再「在动」:它死了,不是还在跑。
-			const dead = row.kind === 'branch' && row.branch.failed === true
-			/**
-			 * 「执行者未归」也不在动:分叉已经收口(收敛或放弃),派出去的执行者**再回来也没有归宿**。
-			 * 它既不是失败(没人知道它跑成没跑成),也不是在跑(「结论会自动回灌」那句承诺实现不了)——
-			 * 所以它是第三个静止态:不判成败、不呼吸(不说破就会被读成还在跑)。
-			 */
-			const unreturned = row.kind === 'branch' && row.branch.unreturned === true
-			const live = row.kind === 'branch' && row.branch.status === 'exploring' && ownerAlive && !dead && !unreturned
+			// ① 填充:落定终局了吗(advanced | void)
+			const settled = row.step.status === 'advanced' || row.step.status === 'void'
+			// ③ 光环:有 Evaluator 正在审这一步(audits 里 verdict 还没回来)
+			const auditing = audits.some((audit) => audit.stepId === stepId && (audit.verdict === null || audit.verdict === undefined))
 			// ② 颜色:什么结局
-			const color =
-				row.kind === 'branch'
-					? row.branch.failed === true
-						? TREE_COLOR.failed
-						: row.branch.status === 'adopted'
-							? TREE_COLOR.adopted
-							: row.branch.status === 'pruned'
-								? TREE_COLOR.pruned
-							: row.branch.status === 'evaluated'
-								? TREE_COLOR.evaluated
-								: row.fork.recommended === row.branch.id && row.fork.phase !== 'settled'
-									? TREE_COLOR.recommend
-									: TREE_COLOR.exploring
-					: row.kind === 'converge'
-						? row.fork.phase === 'settled'
-							? TREE_COLOR.adopted
-							: row.fork.phase === 'deciding'
-								? TREE_COLOR.recommend
-								: TREE_COLOR.exploring
-						: row.kind === 'abandoned'
-							? TREE_COLOR.pruned
-							: row.step.status === 'advanced'
-								? TREE_COLOR.done
-								: row.step.status === 'void'
-									? TREE_COLOR.pruned
-									: TREE_COLOR.pending
-			// 变灰划掉:作废的步、落选的车道、放弃的分叉(单增:留档不删)
-			const greyed =
-				(row.kind === 'step' && row.step.status === 'void') ||
-				row.kind === 'abandoned' ||
-				(row.kind === 'branch' && (row.branch.status === 'pruned' || row.branch.failed === true || row.branch.orphaned === true))
-			const done = row.kind === 'step' && row.step.status === 'advanced'
-			return { settled, color, live, auditing, greyed, done, loops, ...loops }
+			const color = row.step.status === 'advanced' ? TREE_COLOR.done : row.step.status === 'void' ? TREE_COLOR.pruned : TREE_COLOR.pending
+			// 变灰划掉:作废的步(单增:留档不删)
+			const greyed = row.step.status === 'void'
+			const done = row.step.status === 'advanced'
+			return { settled, color, live: false, auditing, greyed, done, loops, ...loops }
 		}
 
 		/**
@@ -2020,7 +1275,7 @@ window.__ModuleLoader__.load({
 			const gap = total <= 1 ? 0 : Math.min(TREE.arcGap, slot * 0.5)
 			return { strokeDasharray: `${slot - gap} ${circumference - slot + gap}`, strokeDashoffset: -(index * slot) }
 		}
-		/** 要画的弧:只取闸门轮次,封顶 3 段(超出的轮数由行右的 `∞N` 徽标承载)。 */
+		/** 要画的弧:只取闸门轮次,封顶 3 段(超出的轮数由行右的 「N 轮」承载)。 */
 		function treeArcs(marks) {
 			// 无事发生(一次就过)= 不画弧:节点保持一个干净的圆点。
 			if (marks.fails === 0 && marks.rounds <= 1) return []
@@ -2054,27 +1309,26 @@ window.__ModuleLoader__.load({
 			const chosen = wanted === null ? null : plans.find((item) => item.id === wanted) ?? null
 			const plan = chosen ?? (data === null || data === undefined ? null : data.plan)
 			if (plan === null || plan === undefined) {
-				return h('div', { style: S.wrap }, h('div', { style: S.bar }, h('span', { style: S.title }, t('世界树'))), h(Empty, null, t('暂无计划。建立后此处显示计划拓扑:脊柱步、车道与收敛点。')))
+				return h('div', { style: S.wrap }, h('div', { style: S.bar }, h('span', { style: S.title }, t('世界树'))), h(Empty, null, t('暂无计划。建立后此处显示计划的步骤与闸门。')))
 			}
-			const rows = treeRows(plan, data.forks)
+			const rows = treeRows(plan)
 			/** 页眉那一句:计划的首个非空行,过长再截(整篇在 tooltip 与「计划文档」里)。 */
 			const briefLine = String(plan.brief ?? '').split('\n').map((line) => line.trim()).find((line) => line !== '' && !line.startsWith('#')) ?? ''
 			const briefText = String(plan.brief ?? '').trim()
-			const titleText = briefLine === '' ? plan.id : `${brief(briefLine, 44)} · ${plan.id}`
+			/** 计划编号(p-…)不上屏:人认的是那一句思路。 */
+			const titleText = briefLine === '' ? '' : brief(briefLine, 44)
 			/** 外面点进来的聚焦优先;手动点行仍然有效(聚焦为 null 时用它)。 */
 			const focused = rowIndexOf(rows, focus)
 			const selected = focused === null ? manual : focused
 			const context = { blocks: data.blocks ?? null, audits: data.audits ?? [], planId: plan.id }
-			const laneCount = rows.reduce((max, row) => Math.max(max, row.lane), 0) + 1
-			const gutter = TREE.padX * 2 + laneCount * TREE.laneWidth
+			const gutter = TREE.padX * 2 + TREE.laneWidth
 			const x = (lane) => TREE.padX + lane * TREE.laneWidth
 			const y = (index) => index * TREE.rowHeight + TREE.rowHeight / 2 + 4
 			const marksOf = rows.map((row) => treeMarks(row, context))
-			// 轨道:显式连接表(扇出/扇入)。落选那条画虚线(3 3)用灰——「这条路走过了,但没走通」。
+			// 轨道:相邻两步连一段脊柱;通向作废步的那段画灰。
 			const svg = treeConns(rows).map((conn, index) => {
-				const to = rows[conn.to]
 				const dashed = marksOf[conn.to].greyed
-				return h('path', { key: `rail-${index}`, d: railPath(conn, rows), fill: 'none', stroke: dashed ? TREE_COLOR.pruned : TREE_COLOR.rail, strokeWidth: 1, strokeDasharray: dashed && to.kind === 'branch' ? '3 3' : undefined })
+				return h('path', { key: `rail-${index}`, d: railPath(conn, rows), fill: 'none', stroke: dashed ? TREE_COLOR.pruned : TREE_COLOR.rail, strokeWidth: 1 })
 			})
 			rows.forEach((row, index) => {
 				const marks = marksOf[index]
@@ -2085,25 +1339,8 @@ window.__ModuleLoader__.load({
 				// ③ 光环(先画,在节点下面)
 				if (marks.auditing) {
 					nodes.push(h('circle', { key: 'halo', cx, cy, r: TREE.halo, fill: 'none', stroke: TREE_COLOR.running, strokeWidth: 1.4, strokeDasharray: '2 2.5', className: 'clearai-breathe-stroke' }))
-				} else if (marks.live) {
-					nodes.push(h('circle', { key: 'halo', cx, cy, r: TREE.halo, fill: marks.color, className: 'clearai-breathe' }))
 				}
-				if (row.kind === 'converge') {
-					nodes.push(
-						h('rect', {
-							key: 'node',
-							x: cx - TREE.radius,
-							y: cy - TREE.radius,
-							width: TREE.radius * 2,
-							height: TREE.radius * 2,
-							rx: 1,
-							transform: `rotate(45 ${cx} ${cy})`,
-							fill: marks.settled ? marks.color : 'transparent',
-							stroke: marks.color,
-							strokeWidth: 1.4,
-						}),
-					)
-				} else {
+				{
 					// ① 填充:落定的画实心核(有分段时核再小一圈,不与弧粘连)
 					if (marks.settled) {
 						nodes.push(h('circle', { key: 'core', cx, cy, r: arcs.length > 0 ? TREE.radius - TREE.arcWidth - 1 : TREE.radius, fill: marks.color }))
@@ -2133,42 +1370,12 @@ window.__ModuleLoader__.load({
 				svg.push(h('g', { key: `node-${index}` }, nodes))
 			})
 			const counts = (row) => {
-				if (row.kind === 'branch' || row.kind === 'converge') return null
 				const marks = treeMarks(row, context)
-				const stepId = row.step.id
-				const scouts = (data.scouts ?? []).filter((item) => item.stepId === stepId).length
-				const judges = (data.audits ?? []).filter((item) => item.stepId === stepId).length
-				return { marks, scouts, judges }
+				const judges = (data.audits ?? []).filter((item) => item.stepId === row.step.id).length
+				return { marks, judges }
 			}
-			/**
-			 * 行文只放**名字**,状态交给颜色/形状/标签说。但「失败」与「随步骤作废而终止」是两种
-			 * 容易被误读成「还在跑」的状态,所以它们各带一个后缀(语义:
-			 * 失败不是落选,孤儿不是被裁)。
-			 */
-			const rowSuffix = (row) =>
-				row.kind === 'branch' && row.branch.failed === true
-					? t(' · 执行没跑成')
-					: row.kind === 'branch' && row.branch.orphaned === true
-						? t(' · 随步骤作废而终止')
-						: ''
-			const rowLabel = (row) =>
-				row.kind === 'branch'
-					? `${row.branch.label || row.branch.id}${rowSuffix(row)}`
-					: row.kind === 'converge'
-						? row.fork.phase === 'settled'
-							? t('已采纳')
-							: row.fork.phase === 'orphaned'
-								? t('未收口(随步骤作废而终止)')
-								: row.fork.phase === 'deciding'
-									? t('待裁决')
-									: t('收敛')
-						: row.kind === 'abandoned'
-							? `${t('已放弃探索:')}${brief(row.fork.question, 24)}`
-							: /**
-							 * 行里只放**认得出这一步的那几个字**:`do` 常常是整句话(真数据里 ~100 字 ✗),
-							 * 全文在点开的详情里。
-							 */
-								`${row.step.ordinal}. ${brief(row.step.do, 26)}`
+			/** 行里只放**认得出这一步的那几个字**:`do` 常常是整句话,全文在点开的详情里。 */
+			const rowLabel = (row) => `${row.step.ordinal}. ${brief(row.step.do, 26)}`
 			return h(
 				'div',
 				{ style: S.wrap },
@@ -2210,7 +1417,7 @@ window.__ModuleLoader__.load({
 					h(
 						'span',
 						{ style: S.faint },
-						`${t('步 ')}${rows.filter((row) => row.kind === 'step' || row.kind === 'fork').length}${t(' · 车道 ')}${laneCount}`,
+						`${t('步 ')}${rows.length}`,
 					),
 					props.openPreview === undefined
 						? null
@@ -2218,12 +1425,12 @@ window.__ModuleLoader__.load({
 					h('span', { style: { ...S.faint, marginLeft: 'auto' } }, t('点击查看详情')),
 				),
 				/**
-				 * 这一格是**计划的一切**:目标是脊柱的起点、拓扑是它的形状、
-				 * 要你拍板的那一下(人门)就发生在某条车道上——所以三样都在这张图上,
+				 * 这一格是**计划的一切**:目标是脊柱的起点、步骤是它的形状、
+				 * 要你拍板的那一下(人门)就发生在某一步上——所以三样都在这张图上,
 				 * 而不是散在三个页签里(「进展」那一格因此撤了)。
 				 */
 				h(GoalLine, { goal: data.goal, view: data.knowledgeView, openPreview: props.openPreview }),
-				h(Inbox, { data }),
+				h(NeedYou, { data }),
 				h(
 					'div',
 					{ style: { display: 'flex', gap: 8, alignItems: 'flex-start' } },
@@ -2258,28 +1465,24 @@ window.__ModuleLoader__.load({
 											overflow: 'hidden',
 											textOverflow: 'ellipsis',
 											whiteSpace: 'nowrap',
-											fontWeight: row.kind === 'converge' || row.kind === 'fork' ? 600 : 400,
+											fontWeight: 400,
 											...(marks.greyed
 												? { color: 'var(--dsw-alias-label-secondary)', opacity: 0.55, textDecoration: 'line-through' }
 												: marks.done
-													? { opacity: 0.6, textDecoration: 'line-through' }
+													? { color: 'var(--dsw-alias-label-secondary)' }
 													: {}),
 										},
 									},
 									rowLabel(row),
 								),
-								row.kind === 'branch' && row.fork.recommended === row.branch.id && row.fork.phase !== 'settled' ? h('span', { style: { color: TREE_COLOR.recommend, flex: '0 0 auto' }, title: t('按判据推荐') }, '★') : null,
-								row.kind === 'branch' && row.branch.reading !== null && row.branch.reading !== undefined
-									? h('span', { style: { ...S.mono, color: marks.color, flex: '0 0 auto' }, title: `${t('读数(尺子 ')}${row.fork.decideBy?.metric ?? '—'})` }, String(row.branch.reading))
-									: null,
 								stat === null ? null : h(
 									'span',
 									{ style: { flex: '0 0 auto', display: 'flex', gap: 6, ...S.faint, marginLeft: 'auto' } },
-									stat.marks.loops.rounds > 0
-										? h('span', { title: `${stat.marks.loops.rounds}${t(' 轮')}${stat.marks.loops.fails > 0 ? ` · 其中 ${stat.marks.loops.fails} 次被驳回` : ''}` }, `∞${stat.marks.loops.rounds}`)
+									/** 说人话:只有返工过才说「做了 N 轮」;起过独立核验就写「独立核验」。 */
+									stat.marks.loops.rounds > 1
+										? h('span', { title: `${stat.marks.loops.rounds}${t(' 轮')}${stat.marks.loops.fails > 0 ? ` · 其中 ${stat.marks.loops.fails} 次被驳回` : ''}` }, `${stat.marks.loops.rounds}${t(' 轮')}`)
 										: null,
-									stat.scouts > 0 ? h('span', { title: `${t('派出 ')}${stat.scouts}${t(' 次侦察')}` }, `${t('侦 ')}${stat.scouts}`) : null,
-									stat.judges > 0 ? h('span', { title: `${t('起过 ')}${stat.judges}${t(' 次评估者')}` }, `${t('评 ')}${stat.judges}`) : null,
+									stat.judges > 0 ? h('span', { title: `${t('起过 ')}${stat.judges}${t(' 次评估者')}` }, t('独立核验')) : null,
 								),
 							)
 						}),
@@ -2289,92 +1492,22 @@ window.__ModuleLoader__.load({
 			)
 		}
 
-		/**
-		 * 树下的详情:选中行的**事实**都在这里(树上只有形状,文字细节在这里)。
-		 *
-		 * 分叉待裁决时,这里也是**给人的那两个动作**的落点(与原设计一致:
-		 * 「采纳、改判、放弃探索的动作都在 PlanTree 里」)。放弃必须带缘由——
-		 * 留痕可考,不是摆设(原设计用对话框强制必填,这里用同一个纪律:没缘由按钮不生效)。
-		 */
+		/** 树下的详情:选中那一步的**事实**都在这里(树上只有形状,文字细节在这里)。 */
 		function TreeDetail(props) {
 			const row = props.row
 			const data = props.data ?? {}
-			const [note, setNote] = React.useState('')
-			const [busy, setBusy] = React.useState(null)
-			const [error, setError] = React.useState(null)
-			const send = (action, extra) => {
-				setBusy(action)
-				setError(null)
-				fetch('/api/clearai/gate', {
-					method: 'POST',
-					headers: { 'content-type': 'application/json' },
-					body: JSON.stringify({ sessionId: data.sessionId, action, plan: data.plan?.id ?? null, step: row.step?.id ?? null, note: note.trim() === '' ? null : note.trim(), ...extra }),
-				})
-					.then(readResponse)
-					.then((result) => {
-						if (result.ok !== true) setError(result.error)
-					})
-					.catch((thrown) => setError(String(thrown?.message ?? thrown)))
-					.finally(() => setBusy(null))
-			}
 			const step = row.step
-			const fork = row.fork ?? null
 			const evidence = (data.evidence ?? []).filter((item) => item.stepId === step?.id)
 			const audits = (data.audits ?? []).filter((item) => item.stepId === step?.id)
-			const scouts = (data.scouts ?? []).filter((item) => item.stepId === step?.id)
-			const branch = row.kind === 'branch' ? row.branch : null
-			const deciding = fork !== null && fork.phase === 'deciding' && fork.abandonReason === null
 			return h(
 				'div',
 				{ style: { marginTop: 10, borderTop: '.5px solid var(--dsw-alias-border-l1)', paddingTop: 8 } },
 				h(
 					'div',
 					{ style: S.inline },
-					h('span', { style: S.head }, row.kind === 'branch' ? `${t('车道 · ')}${branch.label || branch.id}` : row.kind === 'converge' ? t('收敛') : row.kind === 'abandoned' ? t('已放弃的分叉') : `${t('步 ')}${step.ordinal} · ${step.id}`),
+					h('span', { style: S.head, title: step.id }, `${nth(step.ordinal)}`),
 					h(Link, { onClick: () => props.onClose?.(), title: t('收起详情') }, h('span', { style: S.faint }, t('收起'))),
 				),
-				row.kind === 'abandoned'
-					? h('div', { style: S.faint }, `${t('问题:')}${fork.question}${t(';放弃缘由:')}${fork.abandonReason ?? '未记'}${t('(留档不删)')}`)
-					: null,
-				fork?.orphaned === true
-					? h(
-							'div',
-							{ style: S.faint },
-							`${t('这一步已作废(缘由:')}${fork.ownerVoidReason ?? '未记'}${t('),所以这个分叉没有归宿了:**随步骤作废而终止**——它既不是被人裁掉(没人做过这个决定),也不是被算术排掉(没有尺子排过它)。要收掉工作副本(保留 ref),对它调 AbandonFork(会弹人工确认)。')}`,
-						)
-					: null,
-				branch?.failed === true
-					? h(
-							'div',
-							{ style: S.faint },
-							`${t('**执行没跑成**(')}${branch.execution?.note ?? 'failed'}${t(')——它不是落选:落选意味着它跑完了、被尺子排到了后面;这一条是没跑成,所以也没有读数可以参与算术。')}${branch.execution?.conclusion === null || branch.execution?.conclusion === undefined || branch.execution.conclusion === '' ? '' : `执行者最后说的话:${String(branch.execution.conclusion).slice(0, 160)}`}`,
-						)
-					: null,
-				branch?.unreturned === true
-					? h(
-							'div',
-							{ style: S.faint },
-							t('**执行者未归**:这条世界线的执行者派出去之后没有回灌,而分叉已经收口——它再回来也没有归宿了,所以这里既不判它跑成也没跑成,也不再等它。它的产物(如果写过)还在它自己的工作副本里;要判断那条线到底做出了什么,直接看工作副本比看这条状态可靠。'),
-						)
-					: null,
-				branch !== null
-					? h(
-							'div',
-							{ style: S.kv },
-							h('span', { style: S.faint }, t('做法')), h('span', null, branch.approach ?? '—'),
-							h('span', { style: S.faint }, t('判据')), h('span', null, branch.doneCriteria ?? '—'),
-							h('span', { style: S.faint }, t('读数')), h('span', { style: S.mono }, branch.reading === null || branch.reading === undefined ? '—' : `${branch.reading}${branch.validity === 'usable' ? '' : '(不可用)'}`),
-							h('span', { style: S.faint }, t('状态')), h('span', null, `${gloss(BRANCH_STATUS, branch.status)}${branch.verdict === null || branch.verdict === undefined ? '' : ` · 结论 ${branch.verdict}`}`),
-							branch.basis === null || branch.basis === undefined ? null : h('span', { style: S.faint }, t('依据')),
-							branch.basis === null || branch.basis === undefined ? null : h('span', null, branch.basis),
-							branch.gitBranch === null || branch.gitBranch === undefined ? null : h('span', { style: S.faint }, t('分支')),
-							branch.gitBranch === null || branch.gitBranch === undefined ? null : h('span', { style: S.mono }, `${branch.gitBranch}${branch.worktreeRemoved === true ? '(工作副本已清理,ref 保留)' : ''}`),
-							branch.evaluatorSession === null || branch.evaluatorSession === undefined ? null : h('span', { style: S.faint }, t('评估者')),
-							branch.evaluatorSession === null || branch.evaluatorSession === undefined
-								? null
-								: h(Link, { onClick: () => props.openSpectator?.(branch.evaluatorSession), title: t('旁观这条世界线的评估者会话(只读)') }, h('span', { style: S.mono }, branch.evaluatorSession)),
-						)
-					: null,
 				step === null || step === undefined
 					? null
 					: h(
@@ -2400,690 +1533,72 @@ window.__ModuleLoader__.load({
 											 * 「没查过」不许说成「缺」(真数据里树详情因此把每个产物都写成 `undefined(缺)` ✗)。
 											 */
 											const path = typeof artifact === 'string' ? artifact : artifact?.path
-											const exists = typeof artifact === 'string' ? null : (artifact?.exists ?? null)
-											if (typeof path !== 'string' || path === '') return null
-											return h(
-												'span',
-												{ key: `${path}-${index}`, style: { marginRight: 8 } },
-												exists === false
-													? h('span', { style: { ...S.mono, opacity: 0.6 }, title: t('盘上没有这个文件') }, `${path}${t('(缺)')}`)
-													: h(Link, { onClick: () => props.openPreview?.(path), title: exists === true ? t('原生预览打开它') : t('原生预览打开它(计划声明的产物)') }, h('span', { style: S.mono }, path)),
-											)
-										}),
-							),
-							/**
-							 * **反向跳**:从树里的这一步跳到「事实」那一格,并展开对应的命题。
-							 * 切中栏视图走**原生正门** selectPanel(经可选读法拿到的 layout 服务;守卫:
-							 * 没注册的 key 它会抛,而抛了不该把整棵树带下水)。
-							 */
-							props.openFacts === undefined
-								? null
-								: h('span', { style: S.faint }, t('证据')),
-							props.openFacts === undefined
-								? null
-								: h(
-										'span',
-										null,
-										h(
-											Link,
-											{
-												onClick: () => props.openFacts(step.id),
-												title: t('打开「事实」那一格并展开这条命题'),
-											},
-											t('查看此步骤的证据'),
-										),
-									),
-						),
-				evidence.length === 0 && audits.length === 0 && scouts.length === 0
-					? null
-					: h(
-							'div',
-							{ style: { marginTop: 6 } },
-							evidence.map((item) => h('div', { key: item.id, style: S.faint }, `${t('证据 ')}${item.id} · ${item.verdict ?? '—'}${item.level === null || item.level === undefined ? '' : ` · ${item.level}`} · ${item.evaluator ?? '—'}`)),
-							audits.map((item) =>
-								h(
-									'div',
-									{ key: item.id, style: S.faint },
-									`${t('评估者 ')}${item.verdict === null || item.verdict === undefined ? '正在裁决' : item.verdict} · ${item.evaluator ?? '—'}`,
-									item.evaluatorSession === null || item.evaluatorSession === undefined ? null : h(Link, { onClick: () => props.openSpectator?.(item.evaluatorSession) }, h('span', { style: S.mono }, `${t(' 旁观 ')}${item.evaluatorSession}`)),
-									item.cardPath === null || item.cardPath === undefined ? null : h(Link, { onClick: () => props.openPreview?.(item.cardPath) }, h('span', { style: S.mono }, t(' 评估卡'))),
-								),
-							),
-							scouts.map((item) => h('div', { key: item.id, style: S.faint }, `${t('侦察 · ')}${gloss(SCOUT, item.status)}${item.conclusion === null || item.conclusion === undefined ? '' : `:${String(item.conclusion).slice(0, 80)}`}`)),
-						),
-				fork === null
-					? null
-					: h(
-							'div',
-							{ style: { marginTop: 6 } },
-							h('div', { style: S.faint }, `${t('世界线:')}${fork.question}${t(' · 尺子 ')}${fork.decideBy?.metric ?? '—'}(${fork.decideBy?.direction === 'min' ? '越小越好' : '越大越好'}) · ${fork.phase === 'settled' ? '已收敛' : fork.phase === 'deciding' ? '待裁决' : '探索中'}`),
-							fork.verdict === null || fork.verdict === undefined
-								? null
-								: h('div', { style: S.faint }, `${t('裁决:采纳 ')}${fork.verdict.winner}${fork.verdict.tie === true ? '(并列)' : ''}${fork.verdict.margin === null || fork.verdict.margin === undefined ? '' : ` · 余量 ${fork.verdict.margin}`}${fork.provisional === true ? ' · 临时采纳,待复核' : ''}`),
-							// 采纳了但没合并:如实说(账上写过分支、后来对象没了,合并就做不到)。
-							fork.mergeSkipped === null || fork.mergeSkipped === undefined
-								? null
-								: h('div', { style: S.faint }, `${t('这次采纳没有合并:')}${fork.mergeSkipped.reason ?? t('分支或工作副本已不在')}${t('(决定已登记,产物由一次普通交付落位)')}`),
-							fork.humanDecision === null || fork.humanDecision === undefined ? null : h('div', { style: S.faint }, `${t('人的裁决:')}${gloss(FORK_ACTION, fork.humanDecision.action)}${fork.humanDecision.note === null || fork.humanDecision.note === undefined ? '' : ` · ${fork.humanDecision.note}`}`),
-						),
-				deciding
-					? h(
-							'div',
-							{ style: { marginTop: 6, display: 'flex', gap: 6, flexWrap: 'wrap', alignItems: 'center' } },
-							h(Chip, { disabled: busy !== null, onClick: () => send('adopt_branch', { fork: fork.id, branch: branch === null ? fork.recommended ?? null : branch.id }), title: t('由内核执行 ConvergeFork 完成合并') }, busy === 'adopt_branch' ? t('提交中…') : t('采纳此世界线')),
-							h('input', {
-								value: note,
-								placeholder: t('放弃缘由(必填)'),
-								onChange: (event) => setNote(event.target.value),
-								style: { fontSize: 11.5, padding: '2px 6px', borderRadius: 6, border: '.5px solid var(--dsw-alias-border-l3)', background: 'transparent', color: 'inherit', minWidth: 120 },
-							}),
-							h(
-								Chip,
-								{
-									disabled: busy !== null || note.trim() === '',
-									onClick: () => send('abandon_fork', { fork: fork.id }),
-									title: note.trim() === '' ? t('放弃要留痕:先写缘由') : t('放弃这次探索(留档不删,ref 保留)'),
-								},
-								busy === 'abandon_fork' ? t('提交中…') : t('放弃探索'),
-							),
-							error === null ? null : h('span', { style: S.faint }, `${t('提交失败:')}${error}`),
-						)
-					: null,
-			)
-		}
-		/**
-		 * 技能目录的**来源分组**(人此刻在问「我现在能用哪些技能」)。
-		 *
-		 * 分组表是**照抄宿主的来源名**,不是我们自己编的层次;表外的来源如实显示成
-		 * `其他(<来源>)`——宁可见到一个陌生的名字,也不把一条技能藏起来。
-		 */
-		const SOURCE_GROUPS = lazyTable(() => ([
-			{ test: (source) => source === 'bundled', label: t('预设自带'), order: 10 },
-			{ test: (source) => source === 'clearai-template', label: t('工作区模板 · clear/skills'), order: 20 },
-			{ test: (source) => source === 'clearai-workspace', label: t('本项目写的 · clear/skills'), order: 30 },
-			{ test: (source) => source === 'project-dsh' || source === 'project-agents', label: t('本项目 · .dsh / .agents'), order: 40 },
-			{ test: (source) => source === 'user-dsh' || source === 'user-agents', label: t('我的 · ~/.dsh'), order: 50 },
-			{ test: (source) => source === 'clearai-memory', label: t('记忆索引'), order: 60 },
-			{ test: (source) => source === 'runtime', label: t('运行时注册'), order: 70 },
-			{ test: (source) => source === 'custom', label: t('自定义'), order: 80 },
-		]))
-		const groupOf = (source) => SOURCE_GROUPS.find((group) => group.test(source)) ?? { label: `${t('其他(')}${source})`, order: 90 }
-		/** 一步的当前结果(指针的落点):用量行要说清「那一步现在怎么样了」。 */
-		const STEP_OUTCOME = lazyTable(() => ({ advanced: t('已交付'), open: t('还没交付'), void: t('已作废') }))
-
-		/**
-		 * 技能 · 记忆页签(右栏)。
-		 *
-		 * 技能清单 = **宿主原生的合并目录**(`projectionValues.clearai.skills.catalog`)——
-		 * 内核每个 pre-step 调一次 `ctx.skills.snapshot`,于是面板与模型看的是**同一张表**
-		 * (预设自带 / 我的 / 本项目的 / clear/skills 里的候选,合并后按 rank 取赢家)。
-		 *
-		 * 用法 = **本会话的加载记录**(`skills.usage`),从日志折出来的:模型加载是
-		 * `tool/call name='skill'`,人引用是一条含 `/名字` 的用户消息。给的是**指针**
-		 * (谁在第几步加载的、那一步现在什么结果),不是跨会话的比率——判据混杂的比率会冒充事实
-		 * 归并而不是各写一份。
-		 *
-		 * 写动作只留**一个**,而且它走既有的原生机制:
-		 *   · 「采纳」→ 人门动词 `promote_skill` → 内核改写 frontmatter(`status: active`)。
-		 * 引用走**原生**的 `/` 技能触发器(输入框里打 `/`,出候选菜单,选一条即注入正文)——
-		 * 我们原来在旁边又放了一个「引用」按钮,做的是同一件事,已砍掉(奥卡姆:重复不是能力)。
-		 */
-		function BrainTab(props) {
-			const sessionId = props.sessionId
-			const sessions = props.useSessions
-			const data =
-				typeof sessions === 'function' && typeof sessionId === 'string'
-					? sessions((snapshot) => snapshot?.byId?.[sessionId]?.projectionValues?.clearai)
-					: undefined
-			const brain = data === null || data === undefined ? null : data.brain
-			const skills = data === null || data === undefined || data.skills === null || data.skills === undefined ? null : data.skills
-			const catalog = skills === null ? null : skills.catalog
-			const usage = new Map((skills !== null && Array.isArray(skills.usage) ? skills.usage : []).map((item) => [item.name, item]))
-			const [error, setError] = React.useState(null)
-			const [busy, setBusy] = React.useState(false)
-			/**
-			 * 投影里还没有目录时,去问**工作区现状**(宿主读面 `GET /api/clearai/brain`)。
-			 *
-			 * 为什么要有这一条:面板的数据来自会话日志,而内核只在 pre-step 里落事实——
-			 * 新建的会话在第一轮对话之前**没有任何日志**,于是页签是空的,可工作区里其实
-			 * 已经躺着模板技能。这条读面直接问宿主的 skills 服务,
-			 * 拿到的就是模型看到的那张合并目录;渲染仍走同一套分组,并如实标注「还没进投影」。
-			 */
-			const [live, setLive] = React.useState(null)
-			const needsLive = catalog === null
-			React.useEffect(() => {
-				if (!needsLive || typeof sessionId !== 'string') return undefined
-				let alive = true
-				fetch(`/api/clearai/brain?sessionId=${encodeURIComponent(sessionId)}`)
-					.then(readResponse)
-					.then((result) => {
-						if (alive && result.ok === true && Array.isArray(result.payload?.entries)) setLive({ entries: result.payload.entries })
-					})
-					.catch(() => {})
-				return () => {
-					alive = false
-				}
-			}, [sessionId, needsLive])
-			const fromLive = catalog === null && live !== null
-			const entries = catalog !== null && Array.isArray(catalog.entries) ? catalog.entries : fromLive ? live.entries : null
-			/** 宿主装没装「用编辑器打开」那条原生路由:装了就多给一个入口,没装就不显示。 */
-			const [apps, setApps] = React.useState(null)
-
-			React.useEffect(() => {
-				let alive = true
-				fetch('/open-in-app/apps')
-					.then((response) => (response.ok ? response.json() : null))
-					.then((payload) => {
-						if (alive) setApps(Array.isArray(payload?.apps) ? payload.apps.filter((id) => typeof id === 'string') : [])
-					})
-					.catch(() => {
-						if (alive) setApps([])
-					})
-				return () => {
-					alive = false
-				}
-			}, [])
-
-			const promote = (name, viaAsk = false) => {
-				setBusy(true)
-				fetch('/api/clearai/gate', {
-					method: 'POST',
-					headers: { 'content-type': 'application/json' },
-					body: JSON.stringify(viaAsk ? { sessionId, action: 'ask', gate: 'promote_skill', skill: name } : { sessionId, action: 'promote_skill', skill: name }),
-				})
-					.then(readResponse)
-					.then((result) => {
-						if (result.ok !== true) setError(result.error)
-					})
-					.catch((thrown) => setError(String(thrown?.message ?? thrown)))
-					.finally(() => setBusy(false))
-			}
-
-			/**
-			 * 「引用」按钮已删掉(人门动词 `invoke_skill` 一并摘除)。
-			 *
-			 * 原生的 `/` 技能触发器做的正是同一件事,而且更好:`dsh-client-ui-skill` 注册
-			 * `trigger: '/'`,`dsh-client-ui-input-trigger` 出候选菜单,选一条就把技能正文
-			 * 作为指令注入这一回合——我们的按钮不过是在旁边又写了一遍同一个手势。
-			 * 少一个入口 = 少一处会与原生菜单走偏的语义(面板仍保留「采纳」:那是模型做不到的写动作)。
-			 */
-			/** 工作区外的技能(比如 `~/.dsh/skills`):面板读不了,交给宿主的「用编辑器打开」原生路由。 */
-			const openInApp = (dir) => {
-				const app = Array.isArray(apps) ? apps[0] : undefined
-				if (typeof app !== 'string') return
-				fetch('/open-in-app/open', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ app, path: dir }) })
-					.then((response) => {
-						if (!response.ok) setError(`${t('打开失败:HTTP ')}${response.status}`)
-					})
-					.catch((thrown) => setError(String(thrown?.message ?? thrown)))
-			}
-			/**
-			 * 点技能名 → **原生**文档预览(markdown 会渲染成 markdown,不是源码)。
-			 *
-			 * 用内核随投影发下来的 `file`(技能目录下的 SKILL.md):虚拟条目(记忆索引)没有正文文件,
-			 * `file` 是 null,面板就不画链接(点进去撞 404 是踩过的坑)。
-			 */
-			const pointAt = (skill) => {
-				if (typeof skill.file !== 'string') return
-				if (props.openPreview?.(skill.file) !== true) setError(t('原生预览打不开这条路(它在工作区外?)'))
-			}
-
-			if (brain === null || brain === undefined) {
-				// 两种情况要分开说:会话还没开始(没有第一轮对话 = 还没有任何事实)vs 真的没有技能或记忆。
-				const note =
-					data === undefined
-						? t('暂无数据。发送第一条消息后,此处显示技能目录与记忆。')
-						: t('暂无技能或记忆。使用 `SaveSkill` / `WriteMemory`,或将技能放入 `clear/skills/`。')
-				return h('div', { style: S.wrap }, h('div', { style: S.bar }, h('span', { style: S.title }, t('技能 · 记忆'))), h(Empty, null, note))
-			}
-			const overview = Array.isArray(brain.skills) ? brain.skills : []
-			const memory = brain.memory ?? { count: 0, files: [] }
-			/** 章程读数(内核扫的)+ 打开它的那条原生预览通道。 */
-			const constitution = data === null || data === undefined ? null : (data.constitution ?? null)
-			const openAt = (path) => props.openPreview?.(path)
-			const overviewOf = new Map(overview.map((skill) => [skill.name, skill]))
-			// 目录还没到(内核下一次 pre-step 才发):如实说,不拿 brain.skills 冒充合并目录。
-			const listed = entries === null ? overview.map((skill) => ({ name: skill.name, description: skill.description, source: skill.status === 'candidate' ? 'clearai-workspace' : 'clearai-template', model: skill.status !== 'candidate', user: true, dir: null, inside: null, stale: true })) : entries
-			const groups = []
-			for (const skill of listed) {
-				const group = groupOf(String(skill.source ?? 'unknown'))
-				const bucket = groups.find((item) => item.label === group.label) ?? { label: group.label, order: group.order, items: [] }
-				if (!groups.includes(bucket)) groups.push(bucket)
-				bucket.items.push(skill)
-			}
-			groups.sort((left, right) => left.order - right.order || left.label.localeCompare(right.label))
-			const quotedNames = new Set(listed.map((skill) => skill.name))
-			const orphanUsage = (skills !== null && Array.isArray(skills.usage) ? skills.usage : []).filter((item) => !quotedNames.has(item.name))
-			const usageLine = (item) => {
-				if (item === undefined) return null
-				const last = item.last
-				const pointer = last === null ? '—' : `${last.by === 'model' ? '模型' : '人'}${last.ordinal === null ? '' : ` · 第 ${last.ordinal} 步`}${last.outcome === null || last.outcome === undefined ? '' : ` · ${STEP_OUTCOME[last.outcome] ?? last.outcome}`}`
-				return `${t('本会话 模型 ')}${item.model}${t(' · 人 ')}${item.human}${t(' · 最近 ')}${pointer}`
-			}
-			const row = (skill) => {
-				const own = overviewOf.get(skill.name)
-				const candidate = own?.status === 'candidate'
-				const item = usage.get(skill.name)
-				const canOpen = typeof skill.file === 'string'
-				return h(
-					'div',
-					{ key: skill.name, style: S.row },
-					h(
-						'div',
-						{ style: S.inline },
-						candidate ? h('span', { style: S.tagStrong }, t('候选')) : null,
-						skill.model === false && !candidate ? h('span', { style: S.tag }, t('仅人可引用')) : null,
-						h(
-							'span',
-							{
-								style: S.mono,
-								className: canOpen ? 'clearai-link' : undefined,
-								onClick: canOpen ? () => pointAt(skill) : undefined,
-								title: [
-									String(skill.description ?? '').replace(/\s+/g, ' ').trim(),
-									own === undefined ? '' : `${own.bytes}${t(' 字节 · 资源 ')}${own.resources} · ${dash(own.tier ?? own.version)}`,
-								].filter((line) => line !== '').join('\n'),
-							},
-							skill.name,
-						),
-						/**
-						 * 机器读数(字节 / 资源数 / 层级)**不渲染**:它们不帮人认出一条技能,
-						 * 20 条排下来就是噪声(真数据这一格 4741 字里很大一份是它们 ✗),
-						 * 而且藏成 `display:none` 也还是 DOM 里的噪声 ⇒ 干脆不画,挂到技能名的 tooltip。
-						 */
-						candidate ? h(Chip, { disabled: busy, onClick: () => promote(skill.name), title: t('采纳:改写 frontmatter,模型从此加载得到它') }, t('采纳')) : null,
-						// 混合路径:同一件事也可以摆到原生提问卡上答(卡里带它的描述与后果)。
-						candidate ? h('span', { className: busy ? undefined : 'clearai-link', style: S.faint, onClick: busy ? undefined : () => promote(skill.name, true), title: t('通过提问卡决定') }, t('通过提问卡决定')) : null,
-					),
-					/**
-					 * 描述只留**认得出这条技能的那一句**(真数据里每条是一整段「适用/不适用」✗,
-					 * 18 条一起看就是信息爆炸)。全文在技能名的 tooltip 里,要选技能用原生的 `/` 触发菜单。
-					 */
-					skill.description === null || skill.description === undefined || skill.description === ''
-						? null
-						: h('div', { style: S.faint }, brief(skill.description, 60)),
-					usageLine(item) === null ? null : h('div', { style: S.dim }, usageLine(item)),
-					// 工作区外的技能:面板读不到正文(路径守卫),所以如实给绝对路径 + 宿主的编辑器入口。
-					skill.inside === false && typeof skill.dir === 'string' ? h('div', { style: S.faint }, `${skill.dir}${t(' · 在工作区外,面板不读正文')}`) : null,
-					skill.inside === false && typeof skill.dir === 'string' && Array.isArray(apps) && typeof apps[0] === 'string'
-						? h(Chip, { onClick: () => openInApp(skill.dir) }, `${t('在 ')}${apps[0]}${t(' 里打开')}`)
-						: null,
-				)
-			}
-			return h(
-				'div',
-				{ style: S.wrap },
-				h(
-					'div',
-					{ style: S.bar },
-					h('span', { style: S.title }, t('技能 · 记忆')),
-					/**
-					 * 计数在下面各段标题里(同屏重复计数 = 噪声);
-					 * 「与模型看到的是同一张表」是实现保证、不是用户信息,与事实那一格同一条规矩 → 去掉。
-					 * 只留**状态**:目录到没到、这份是不是"本会话还没有第一轮对话"的工作区现状。
-					 */
-					entries === null || fromLive ? h('span', { style: S.faint }, entries === null ? t('目录尚未到达(内核下一次 pre-step 下发)') : t('工作区现状(首轮对话后进入投影)')) : null,
-				),
-				error !== null ? h('div', { style: S.faint }, `${t('面板动作失败:')}${error}`) : null,
-				/**
-				 * 章程那一行(这个页签的第一层):**只有文件系统事实** + 一个点开就走的原生预览。
-				 *
-				 * 为什么不再有「占位 X/Y 条」:那是对文本做格式解析
-				 * ——模型把章程第 5 节写成 `- **变更记录**（一行即…）`,条目数就会数错,
-				 * **改一个标点「事实」就变**;而且它奖励的是「把数字清掉」而不是「把章程写实」。
-				 * 章程每回合本来就被原生指令文件整份注入模型上下文,面板这边只需要说清
-				 * 「它在哪、什么时候动过」——`mtime` 不依赖任何格式约定。
-				 */
-				constitution === null || constitution === undefined
-					? null
-					: h(
-							'div',
-							{ style: S.section },
-							h('div', { style: S.head }, t('项目章程')),
-							h(
-								'div',
-								{ style: S.inline },
-								/**
-								 * 文件名只在**链接**上说一次(原来段标题里还写一遍 ⇒ 同一行同一路径出现两遍 ✗)。
-								 * 点它是**动作**(原生预览),字节数与改动时间是文件系统事实 —— 这些留着有意义。
-								 */
-								h(
-									Link,
-									{ onClick: () => openAt(constitution.legacy === true ? 'clear/project.md' : 'PROJECT.md'), title: t('用原生预览打开章程(它每回合整份注入模型上下文)') },
-									h('span', { style: S.mono }, constitution.legacy === true ? 'clear/project.md' : 'PROJECT.md'),
-								),
-								h('span', { style: S.faint }, `${t('最后改动 ')}${stampOf(constitution.modifiedAt)} · ${constitution.bytes}${t(' 字节')}`),
-							),
-						),
-				...groups.map((group) => {
-					/**
-					 * **每段封顶**:合并目录在真机器上可以有一百多条(全局技能 + 模板 + 记忆),
-					 * 全列出来就是信息爆炸——这一格的用途是"认出这条技能",不是"读完整个目录"。
-					 *
-					 * 保留顺序**按用途排**,不是按字母:
-					 *   ① 候选(等人拍板,不列出来那件事就没有出口);
-					 *   ② 本会话真的用过(正在被引用的那些);
-					 *   ③ 其余按原序补到上限。
-					 * 被截掉的那部分不消失:`/` 原生触发菜单仍然是完整目录,这里只留一句话说清还有多少。
-					 */
-					const shownItems = (() => {
-						const cap = 8
-						if (group.items.length <= cap) return group.items
-						const candidates = group.items.filter((skill) => overviewOf.get(skill.name)?.status === 'candidate')
-						const used = group.items.filter((skill) => skill.status === 'candidate' ? false : usage.has(skill.name))
-						const picked = []
-						for (const skill of [...candidates, ...used, ...group.items]) {
-							if (picked.length >= cap) break
-							if (!picked.includes(skill)) picked.push(skill)
-						}
-						return picked
-					})()
-					const hidden = group.items.length - shownItems.length
-					return h(
-						'div',
-						{ key: group.label, style: S.section },
-						h('div', { style: S.head }, `${group.label}(${group.items.length})`),
-						shownItems.map((skill) => row(skill)),
-						hidden <= 0 ? null : h('div', { style: S.faint }, `${t('还有 ')}${hidden}${t(' 条未列出 · 用 / 触发菜单选')}`),
-					)
-				}),
-				orphanUsage.length === 0
-					? null
-					: h(
-							'div',
-							{ style: S.section },
-							h('div', { style: S.head }, `${t('目录里已经没有(')}${orphanUsage.length})`),
-							orphanUsage.map((item) => h('div', { key: item.name, style: S.row }, h('span', { style: S.mono }, item.name), h('span', { style: S.faint }, usageLine(item) ?? ''))),
-						),
-				h(
-					'div',
-					{ style: S.section },
-					h('div', { style: S.head }, `${t('记忆(')}${memory.count}${t(' 条)')}`),
-					(Array.isArray(memory.files) ? memory.files : []).map((file) =>
-						h(
-							'div',
-							{ key: file.file, style: S.row },
-							h(Link, { onClick: () => props.openPreview?.(file.path) }, h('span', { style: S.mono }, file.file)),
-							/**
-							 * 一个记忆文件里的条目可能十几条 ⇒ 行里只给**前两条 + 共几条**,
-							 * 全文进 tooltip(默认少而准,细节靠悬停/点开)。
-							 */
-							h(
-								'span',
-								{ style: S.faint, title: (file.entries ?? []).map((entry) => `${entry.kind === 'lesson' ? '经验' : '事实'}:${entry.title}`).join('\n') },
-								(() => {
-									const all = (file.entries ?? []).map((entry) => `${entry.kind === 'lesson' ? '经验' : '事实'}:${entry.title}`)
-									if (all.length === 0) return ''
-									return all.length <= 2 ? all.join(' / ') : `${all.slice(0, 2).join(' / ')}${t(' 等 ')}${all.length}${t(' 条')}`
-								})(),
-							),
-						),
-					),
-					memory.count === 0 ? h('div', { style: S.faint }, t('暂无记忆。')) : null,
-				),
-			)
-		}
-
-		/**
-		 * 人门区。**人门优先于运行态**——等人的事永远最先说。
-		 * 写通道只给人:模型能调的工具面里没有这些动词。按下去之后由宿主平面把它变成一条
-		 * 带结构化标记的用户消息,折进投影(`by:'user'`),面板随投影自己更新。
-		 */
-		function Inbox(props) {
-			const data = props.data
-			const sessionId = data === null || data === undefined ? null : data.sessionId
-			const items = data === null || data === undefined || !Array.isArray(data.inbox) ? [] : data.inbox
-			const [busy, setBusy] = React.useState(null)
-			const [error, setError] = React.useState(null)
-			// 放弃的分叉:要写缘由才提交(两步),缘由按分叉 id 存着——
-			// 同一个屏上可能有两条分叉,不能共用一个输入框。
-			const [abandonFork, setAbandon] = React.useState(null)
-			const [abandonNote, setAbandonNote] = React.useState('')
-			/**
-			 * 撤回一条事实也要写缘由,按事实 id 分开存(同一屏上可能有多条被推翻的事实)。
-			 * 分工与「放弃这条分叉」一样:**机制只记录**,「值得索要理由」这条规矩在界面上——
-			 * 撤回改变的是下一轮模型会引用什么,而「维持原事实」不改任何面,所以它是一键。
-			 */
-			const [retractFact, setRetract] = React.useState(null)
-			const [retractNote, setRetractNote] = React.useState('')
-			if (items.length === 0) return null
-			const send = (item, extra) => {
-				setBusy(`${item.kind}:${item.plan || ''}:${item.step || ''}`)
-				setError(null)
-				// `gate` 只有「用提问卡决定」那一步用得上:它是**界面手势**,不是事实动词。
-				/**
-				 * `value` 是**标的**(比如被推翻的那条事实的 id):宿主据此先核它还在不在,
-				 * 核不到就回 409,而不是收下一条什么都不改的动作。
-				 */
-				const body = { sessionId, action: item.human_action, plan: item.plan ?? null, fork: extra?.fork ?? item.fork ?? null, branch: extra?.branch ?? null, gate: extra?.gate ?? null, skill: extra?.skill ?? null, value: item.value ?? null, note: extra?.note ?? null }
-				fetch('/api/clearai/gate', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) })
-					.then(readResponse)
-					.then((result) => {
-						if (result.ok !== true) setError(result.error)
-					})
-					.catch((thrown) => setError(String(thrown?.message ?? thrown)))
-					.finally(() => setBusy(null))
-			}
-			/**
-			 * 收件箱里现在只有**真门**(计划确认已砍:它是记号不是闸门,见 fold 的 HUMAN_GATE_ACTIONS)。
-			 *
-			 * 门要什么由**数据**说(`item.needs`),不在这里按 kind 猜 ✗:
-			 *   · `click` ⇒ 给按钮;
-			 *   · `word`  ⇒ 给**一句提示**(「说一句话就行 —— <要说什么>」),
-			 *     因为那种门本来就不是点击能表达的(复核 / 解除阻塞),而它照样会按住续跑。
-			 *
-			 * 但**世界线裁决那一种不走这里**:它要点出每条分支的读数,只有下面那一块拿得到
-			 * 分支数据。两条路都渲染同一条条目,就等于同一道门上摆两个按钮——其中一个还没有
-			 * 分支可裁,点下去只会落一条**什么都不改**的人门记录,而界面还会回一句成功。
-			 */
-			const FORK_RENDERED = 'fork_adopt'
-			/** 世界线那一块真正会渲染的分叉(判据与条目本身一字不差:同一个分叉、同一步)。 */
-			const forkRows = (data.forks || []).filter((fork) => fork.phase === 'deciding' && (fork.humanDecision ?? null) === null)
-			const covered = new Set(forkRows.map((fork) => fork.stepId))
-			const restItems = items.filter((item) => !(item.kind === FORK_RENDERED && covered.has(item.step)))
-			/**
-			 * 这一层给什么,由**它真的能落实什么**决定:
-			 *   · 候选技能 → 「采纳」(白名单动词,一步到位);
-			 *   · 落不到世界线块的裁决条目 → 「用提问卡决定」——它不是点击能裁的,
-			 *     而提问卡那条路会把判据与各分支读数铺进对话框,答案照样落账;
-			 *   · 要一句话的门 → 不摆按钮,给一句话提示。
-			 */
-			/** 门要什么由**数据**说(`needs`);每个 kind 给什么按钮也在这一处说完,别处不再猜。 */
-			const label = (item) =>
-				item.needs !== 'click'
-					? null
-					: item.kind === FORK_RENDERED
-						? t('通过提问卡决定')
-						: item.kind === 'fact_refutation'
-							? t('撤回事实')
-							: item.kind === 'provisional_review'
-								? t('认可,继续')
-								: item.kind === 'skill_candidate'
-									? t('采纳')
-									: null
-			return h(
-				'div',
-				{ style: S.gate },
-				h('div', { style: S.head }, `${t('需要你 ')}${items.length}`),
-				...forkRows.length > 0
-					? forkRows
-							.map((fork) =>
-								h(
-									'div',
-									{ key: `adopt-${fork.id}`, style: S.gateRow },
-									h('span', { style: S.mono }, `${fork.stepId} · ${fork.question}`),
-									/**
-									 * 混合路径:同一道门,也可以摆到**原生提问卡**上去答。
-									 * 为什么两条路都留:面板这条是熟手的快路(一步到位);提问卡那条把
-									 * 判据、各分支的读数与推荐**铺在对话框里**,而且它会挡住输入框——
-									 * 人正在看对话时,那是最不会被忽略的位置。两条路的落账完全相同。
-									 */
-									h(
-										'button',
-										{
-											type: 'button',
-											className: 'clearai-btn',
-											disabled: busy !== null,
-											title: t('通过提问卡做出裁决(含判据与各分支读数)'),
-											onClick: () => send({ kind: 'fork_adopt', human_action: 'ask', plan: fork.plan ?? null, step: fork.stepId }, { gate: 'fork_adopt', fork: fork.id }),
-										},
-										t('通过提问卡决定'),
-									),
-									...fork.branches.map((branch) =>
+											const exists = typeof artifact === 'string' ? null : (artifact?.exists ?? null)
+											if (typeof path !== 'string' || path === '') return null
+											return h(
+												'span',
+												{ key: `${path}-${index}`, style: { marginRight: 8 } },
+												exists === false
+													? h('span', { style: { ...S.mono, opacity: 0.6 }, title: t('盘上没有这个文件') }, `${path}${t('(缺)')}`)
+													: h(Link, { onClick: () => props.openPreview?.(path), title: exists === true ? t('原生预览打开它') : t('原生预览打开它(计划声明的产物)') }, h('span', { style: S.mono }, path)),
+											)
+										}),
+							),
+							/**
+							 * **反向跳**:从树里的这一步跳到「事实」那一格,并展开对应的命题。
+							 * 切中栏视图走**原生正门** selectPanel(经可选读法拿到的 layout 服务;守卫:
+							 * 没注册的 key 它会抛,而抛了不该把整棵树带下水)。
+							 */
+							props.openFacts === undefined
+								? null
+								: h('span', { style: S.faint }, t('证据')),
+							props.openFacts === undefined
+								? null
+								: h(
+										'span',
+										null,
 										h(
-											'button',
+											Link,
 											{
-												key: branch.id,
-												type: 'button',
-												tone: 'warn',
-												disabled: busy !== null,
-												onClick: () => send({ kind: 'fork_adopt', human_action: 'adopt_branch', plan: fork.plan ?? null, step: fork.stepId }, { fork: fork.id, branch: branch.id }),
+												onClick: () => props.openFacts(step.id),
+												title: t('打开「本体」那一格并展开这条结论'),
 											},
-											`${t('采纳 ')}${branch.label}${branch.reading === null || branch.reading === undefined ? '' : `(${branch.reading})`}`,
+											t('查看此步骤的证据'),
 										),
 									),
-									/**
-									 * 放弃要留痕:两下才生效(先点开缘由框,写了才能提交)。
-									 * 单次点击就放弃会把「为什么」永远丢掉——而放弃正是最需要缘由的那一类决定。
-									 * 与树下详情同一条纪律(那边是按钮 disabled,这里是两步)。
-									 */
-									h(
-										'button',
-										{
-											type: 'button',
-											className: 'clearai-btn',
-											disabled: busy !== null,
-											onClick: () => setAbandon(fork.id),
-											title: t('放弃需填写缘由后提交'),
-										},
-										t('放弃这条分叉'),
-									),
-									abandonFork === fork.id
-										? h(
-												'span',
-												{ style: { display: 'inline-flex', gap: 6, alignItems: 'center' } },
-												h('input', {
-													value: abandonNote,
-													placeholder: t('放弃缘由(必填)'),
-													onChange: (event) => setAbandonNote(event.target.value),
-													style: { fontSize: 11.5, padding: '2px 6px', borderRadius: 6, border: '.5px solid var(--dsw-alias-border-l3)', background: 'transparent', color: 'inherit', minWidth: 140 },
-												}),
-												h(
-													'button',
-													{
-														type: 'button',
-														className: 'clearai-btn',
-														disabled: busy !== null || abandonNote.trim() === '',
-														onClick: () => send({ kind: 'fork_adopt', human_action: 'abandon_fork', plan: fork.plan ?? null, step: fork.stepId }, { fork: fork.id, note: abandonNote.trim() }),
-														title: abandonNote.trim() === '' ? t('缘由必填') : t('确认放弃(留档不删,ref 保留)'),
-													},
-													t('确认放弃'),
-												),
-											)
-										: null,
+						),
+				evidence.length === 0 && audits.length === 0
+					? null
+					: h(
+							'div',
+							{ style: { marginTop: 6 } },
+							evidence.map((item) => h('div', { key: item.id, style: S.faint }, `${t('检验结果:')}${VERDICT[item.verdict] ?? '—'} · ${howOf(item)}${item.basis ? ` · ${brief(item.basis, 60)}` : ''}`)),
+							audits.map((item) =>
+								h(
+									'div',
+									{ key: item.id, style: S.faint },
+									`${t('独立核验:')}${item.verdict === null || item.verdict === undefined ? t('正在裁决') : (VERDICT[item.verdict] ?? item.verdict)}`,
+									item.evaluatorSession === null || item.evaluatorSession === undefined ? null : h(Link, { onClick: () => props.openSpectator?.(item.evaluatorSession) }, h('span', null, t(' 看核验过程'))),
+									item.cardPath === null || item.cardPath === undefined ? null : h(Link, { onClick: () => props.openPreview?.(item.cardPath) }, h('span', null, t(' 看核验记录'))),
 								),
-							)
-					: [],
-				...restItems.map((item, index) => {
-					/** 裁决条目走**界面手势**:`ask` 只是把卡摆上去,答案回到宿主那条老路落账。 */
-					const asCard = item.kind === FORK_RENDERED
-					const act = asCard ? { ...item, human_action: 'ask' } : item
-					const extra = asCard ? { gate: FORK_RENDERED, fork: item.fork ?? null } : null
-					return h(
-						'div',
-						{ key: `${item.kind}-${index}`, style: S.gateRow, title: item.kind },
-						/** 机器词(`provisional_review` 这类)**不上屏** ✗ —— 进 tooltip,给人看的是标题那句话。 */
-						label(item) === null ? null : h('span', { style: S.tagStrong }, `${t('要你')}${label(item)}`),
-						h('span', null, item.title),
-						h('span', { style: S.faint }, item.summary),
-						label(item) !== null
-							? h(
-									'button',
-									{
-										type: 'button',
-										className: 'clearai-btn',
-										disabled: busy !== null,
-										/** 撤回先开缘由框(两步):「为什么撤回」是最值得留下的那句话。 */
-										onClick: () => (item.kind === 'fact_refutation' ? setRetract(item.value) : send(act, extra)),
-										title: item.kind === 'fact_refutation' ? t('撤回需填写缘由后提交') : undefined,
-									},
-									label(item),
-								)
-							: item.needs === 'word'
-								? h('span', { style: { ...S.faint, opacity: 0.9 } }, `${t('')}${item.ask ?? '说一句你的决定'}`)
-								: null,
-						/**
-						 * 事实复核那道门有**两个**结局,而且两个都必须能一键落地:
-						 * 只给「撤回」的话,「判定证据不可靠、维持原事实」就只能靠不说话——
-						 * 而门开着会按住续跑,于是系统一直等一个永远不会来的动作。
-						 */
-						item.kind === 'fact_refutation'
-							? h(
-									'button',
-									{ type: 'button', className: 'clearai-btn', disabled: busy !== null, onClick: () => send({ ...item, human_action: 'keep_fact' }, null) },
-									t('维持原事实'),
-								)
-							: null,
-						item.kind === 'fact_refutation' && retractFact === item.value
-							? h(
-									'span',
-									{ style: { display: 'inline-flex', gap: 6, alignItems: 'center' } },
-									h('input', {
-										value: retractNote,
-										placeholder: t('撤回缘由(必填)'),
-										onChange: (event) => setRetractNote(event.target.value),
-										style: { fontSize: 11.5, padding: '2px 6px', borderRadius: 6, border: '.5px solid var(--dsw-alias-border-l3)', background: 'transparent', color: 'inherit', minWidth: 140 },
-									}),
-									h(
-										'button',
-										{
-											type: 'button',
-											className: 'clearai-btn',
-											disabled: busy !== null || retractNote.trim() === '',
-											onClick: () => send(act, { note: retractNote.trim() }),
-											title: retractNote.trim() === '' ? t('缘由必填') : t('确认撤回(记录保留,不再作为「已知」引用)'),
-										},
-										t('确认撤回'),
-									),
-								)
-							: null,
-					)
-				}),
-				error === null ? null : h('div', { style: S.faint }, `${t('发送失败:')}${error}`),
+							),
+						),
 			)
 		}
 
+		/** 待处理:只陈述的几行(计划停下、结论矛盾),没有按钮——要怎么办,在对话里说。 */
+		function NeedYou(props) {
+			const items = Array.isArray(props.data?.needYou) ? props.data.needYou : []
+			if (items.length === 0) return null
+			return h('div', { style: { display: 'flex', flexDirection: 'column', gap: 4, margin: '0 0 8px' } }, ...items.map((item, index) => h('div', { key: `need-${index}`, className: 'clearai-need' }, h('b', null, t('待处理')), String(item?.text ?? ''))))
+		}
+
 		/**
 		 * 旁观入口(阶段 4 的 4.5):点一下跳到那个子会话,**只看不动手**。
 		 * 判断不许匿名——评估者/仲裁是谁、在哪,面板上给得出入口。
 		 * 拿不到会话服务就退化成一行文本 id:宁可少一个按钮,也不假装能跳。
 		 */
 
-		/**
-		 * 续跑档的两个小工具(纯函数,便于直接断言文案)。
-		 *
-		 * **说行为,不说机制**:人要回答的是「我走开的时候它还接着干吗」,不是「这是哪个档」。
-		 * 哲学词(人在场 / 无人值守)留在文档、运行态卡与提示词里——那些读者是模型和写文档的人;
-		 * 给人点的那一格说人话,并在 tooltip 里注明两个词是一回事。
-		 *
-		 * 为什么是「多问我 / 自己拿主意」而不是「先问我 / 别问我」:两档都**会**为不可约的判断开门
-		 * (湿实验、护栏级授权、L4 放行),所以只能写程度,不能写绝对——绝对的说法是假承诺。
-		 */
-		const TIER_TEXT = lazyTable(() => ({ attended: t('多问我'), unattended: t('自己拿主意') }))
-		const TIER_HINT = lazyTable(() => ({
-			attended: t('续跑:多问我——每个阶段收尾就停下,等你给下一阶段(文档里叫「人在场」)。点一下切成「自己拿主意」。'),
-			unattended: t('续跑:自己拿主意——立约即授权,按轮数自己往下跑,只在不可约的判断上开门(文档里叫「无人值守」)。点一下切成「多问我」。'),
-		}))
-		const tierLabel = (value, pending) => `${TIER_TEXT[value] ?? value}${pending ? '(已切,下一步生效)' : ''}`
-
-		/**
-		 * 「多问我 / 自己跑」那个开关**删掉了**。
-		 *
-		 * 第一性原理 + 奥坎姆:「我要不要在场」是**运行时状态**——有没有门开着、有没有裁决在飞、
-		 * 有没有开着的步;这些系统自己知道 ✗,不该要用户预先声明。
-		 * 而且那一档还顺手把「计划经人确认」变成系统自己签的 ✗(与 L4「人放行」同一类病)。
-		 * 续跑本身走**原生 goal**(宿主的回合驱动);我们只决定"什么时候该布防、给多大保险丝"。
-		 */
 		/**
 		 * 计划的小图形:一棵**迷你世界树**——一根脊柱、一条岔、两个节点。
 		 * 用 `currentColor`:颜色留给状态(等人确认 = 琥珀,受阻 = 琥珀,收尾 = 灰),形状留给语义。
@@ -3125,29 +1640,26 @@ window.__ModuleLoader__.load({
 			 * 一格只放**一个符号**:进度。要人注意的事不换符号,只换颜色。
 			 *
 			 * 这条工具行上的格子只承担**可点、且只有我们知道**的两句:
-			 *   需要你 N(人门计数,点了开世界树)· 续跑停着(为什么停,人是可以处置的)。
+			 *   待处理 N(人门计数,点了开世界树)· 续跑停着(为什么停,人是可以处置的)。
 			 * 「已达成 · 100%」那一类与原生目标提示说的是同一件事,不在这里重复。
 			 */
-			const inboxCount = Array.isArray(data?.inbox) ? data.inbox.length : 0
-			const cont = data?.continuation ?? null
-			const holdNote = cont === null || cont === undefined || cont.state !== 'paused' ? null : `${t('续跑停着:')}${HOLD_WHY[cont.why] ?? cont.why ?? '策略暂停'}`
-			const pending = plan.confirmationPending === true
+			const inboxCount = Array.isArray(data?.needYou) ? data.needYou.length : 0
 			const blocked = plan.blocked !== null && plan.blocked !== undefined
-			const attention = pending || blocked
+			const attention = blocked
 			/**
 			 * 符号**恒定是进度**(形状稳定才学得会):要人注意不在符号上换字,
 			 * 而是换颜色(与世界树同一条规矩:形状说状态,别让人去猜一个 '?')。
-			 * 「需要你 N」就在这一格(`waiting`):门开着是**事实面**上最要紧的一句,
+			 * 「待处理 N」就在这一格(`waiting`):门开着是**事实面**上最要紧的一句,
 			 * 而它可点——点一下开世界树,那里才看得到要裁什么。
 			 */
 			const symbol = `${done}/${total}`
 			const brief = typeof plan.brief === 'string' && plan.brief.trim() !== '' ? plan.brief.trim() : null
-			const meaning = pending ? t('计划在建,**等你确认**') : blocked ? t('计划受阻,等人处置') : plan.status === 'closed' ? `${t('计划已收尾(')}${done}/${total}${t(' 步)')}` : `${t('计划已交付 ')}${done}/${total}${t(' 步')}`
+			const meaning = blocked ? t('计划受阻,等人处置') : plan.status === 'closed' ? `${t('计划已收尾(')}${done}/${total}${t(' 步)')}` : `${t('计划已交付 ')}${done}/${total}${t(' 步')}`
 			/**
-			 * 等人时**只说一句**:先「需要你 N」(人门计数),没有门才说续跑停着的原因。
+			 * 等人时**只说一句**:先「待处理 N」(人门计数),没有门才说续跑停着的原因。
 			 * 两者是同一根轴(为什么在等人)⇒ 一格只放一个,不并列。
 			 */
-			const waiting = inboxCount > 0 ? `${t('需要你 ')}${inboxCount}` : null
+			const waiting = inboxCount > 0 ? `${t('待处理 ')}${inboxCount}` : null
 			const attentionNow = attention || waiting !== null
 			return h(
 				'button',
@@ -3167,19 +1679,6 @@ window.__ModuleLoader__.load({
 			)
 		}
 
-		/**
-		 * 策略暂停的**理由**对照表(值来自内核 `holdReason`,不是这里自创的):
-		 * 面板要说的正是「平台说不出的那一句」——为什么停。新增理由时这张表跟着补,
-		 * 补漏了也不骗人:认不出来的值原样显示,而不是显示一个体面的空话。
-		 */
-		/** 窗口停下的理由 = **真的有人的事**(「一阶段收尾」那条已删:它是档位的表达,不是人的事)。 */
-		const HOLD_WHY = lazyTable(() => ({
-			audit: t('等独立裁决'),
-			plan_confirm: t('计划待确认'),
-			gate: t('等待人工处理'),
-			unknown: t('策略暂停(原因未记录,已告警)'),
-		}))
-
 		/**
 		 * 一步的**人话**名字:`do` 是模型写的那句「做什么」,截短了放进一行。
 		 * 内部步 id(`s-3`)只进 tooltip 与世界树——它在日志里是账,在界面上不是给人看的。
@@ -3189,47 +1688,12 @@ window.__ModuleLoader__.load({
 			return value.length <= 12 ? value : `${value.slice(0, 12)}…`
 		}
 
-		/**
-		 * **续跑注**:只在**有话要说**时出现的一格。
-		 *
-		 * 输入框下那条整行删掉之后,它说的三句话里有两句**别处无处可说** ✗:
-		 *   · 「续跑已撤回」——人按下清除的那一瞬,dock 已经消失,而内核还没到下一拍;
-		 *   · 「续跑停着:<理由>」——平台只会说"目标已暂停",说不出**为什么**;
-		 * 所以把它们移到工具行(与计划 chip 同一行,**不占新行**):正常跑着时一个字都不说 ✓。
-		 */
-		function ContinuationNote(props) {
-			const data = typeof props.useProjection === 'function' ? props.useProjection('clearai') : undefined
-			const hostGoal = typeof props.useProjection === 'function' ? props.useProjection('goal') : undefined
-			const cont = data === null || data === undefined ? null : (data.continuation ?? null)
-			if (cont === null) return null
-			const vanished = hostGoal === null || hostGoal === undefined
-			/** 门要**一句话**时(dock 只会说"目标已暂停"),这句话说得更准:等你说一声 ✓ */
-			const wordGate = Array.isArray(data?.inbox) && data.inbox.some((item) => item.needs === 'word')
-			const holdText = wordGate ? t('等待输入') : (HOLD_WHY[cont.why] ?? cont.why ?? t('策略暂停'))
-			const text =
-				cont.state === 'withdrawn' || ((cont.state === 'armed' || cont.state === 'paused') && vanished)
-					? t('续跑已撤回')
-					: cont.state === 'paused'
-						? `${t('续跑停着:')}${holdText}`
-						: null
-			if (text === null) return null
-			return h(
-				'span',
-				{
-					className: 'clearai-toolctl',
-					style: { opacity: 0.8, fontSize: 11.5, cursor: 'default' },
-					title: t('系统内部消息(非运行状态)'),
-				},
-				text,
-			)
-		}
-
 		/**
 		 * 输入框下那条派生状态条**删掉了**。
 		 *
 		 * 它说的事(阶段 / 完成度 / 当前步)与**原生目标提示**、与工具行那颗计划 chip 的 `N/M`
 		 * 说的是同一件 ✗ —— 而它**独占一行,把输入框整个顶上去** ✗。
-		 * 唯一可点、且只有我们知道的那一件(「需要你 N」)已经并进计划 chip:
+		 * 唯一可点、且只有我们知道的那一件(「待处理 N」)已经并进计划 chip:
 		 * 同一行、一点直达世界树。剩下的「为什么停」也在那颗 chip 上只说一句。
 		 */
 		/**
@@ -3265,65 +1729,6 @@ window.__ModuleLoader__.load({
 			return hitsAssertion || hitsText
 		}
 
-		/**
-		 * **断言芯片行**:一条已确立条目(或命题)的断言,点开就地展开词条卡。
-		 *
-		 * 为什么是「就地展开」而不是跳走:芯片的用途就是**读这条结论时**顺手看清
-		 * 「这个谓词什么意思、是不是单值、依据是什么」——跳一步,读者的上下文就断了。
-		 * 词条卡的两个人物(筛选此概念 / 在图里看)由外层经 `ui` 递进来。
-		 */
-		const AssertionChips = ({ assertions, ui, promoted }) => {
-			const rows = Array.isArray(assertions) ? assertions : []
-			if (ui === null || ui === undefined || rows.length === 0) return null
-			return h(
-				'div',
-				{ style: S.chipRow },
-				...rows.map((assertion, index) => {
-					const key = `${promoted === false ? 'p' : 'f'}-${index}`
-					const open = ui.openKey === key
-					const predicate = (ui.lexicon?.predicates ?? []).find((item) => item.id === assertion?.predicate) ?? null
-					const label = String(assertion?.chip ?? `${String(assertion?.subject?.id ?? '')} · ${String(assertion?.predicate ?? '')}`)
-					const card =
-						open === false
-							? null
-							: h(
-									'div',
-									{ style: S.chipCard },
-									predicate === null
-										? h('div', { style: S.faint }, t('此谓词已不在词汇中(可能已废止);存量断言仍可读。'))
-										: h('div', null,
-												h('div', { style: S.chipCardTitle }, `${predicate.label ?? predicate.id} · ${predicate.id}`),
-												h('div', { style: S.kv }, h('span', { style: S.faint }, `${t('释义')}:`), ` ${String(predicate.gloss ?? '—')}`),
-												h('div', { style: S.kv }, h('span', { style: S.faint }, `${t('主词域')}:`), ` ${String(predicate.domain ?? '—')}`),
-												h('div', { style: S.kv }, h('span', { style: S.faint }, `${t('值域')}:`), ` ${predicate.range?.term ?? (predicate.range?.form ?? '—') + (predicate.range?.unit ?? '')}`),
-												h('div', { style: S.kv }, h('span', { style: S.faint }, `${t('单值')}:`), ` ${predicate.functional === true ? '✓' : '—'}`),
-												h('div', { style: S.kv }, h('span', { style: S.faint }, `${t('依据')}:`), ` ${String(predicate.basis ?? '—')}`),
-											),
-									h(
-										'div',
-										{ style: S.chipActions },
-										h('span', { style: S.chipAction, onClick: () => ui.onFilter(assertion?.predicate ?? null) }, t('按此谓词过滤')),
-										h('span', { style: S.chipAction, onClick: () => ui.onGraph() }, t('在图里看')),
-									),
-								)
-					return h(
-						'div',
-						{ key, style: S.chipWrap },
-						h(
-							'span',
-							{
-								style: open === true ? { ...S.chip, borderColor: 'rgba(74,163,255,0.9)' } : S.chip,
-								onClick: () => ui.onToggle(key),
-								title: promoted === false ? t('未升格:断言仍在命题上') : t('查看词条'),
-							},
-							`${label}${promoted === false ? t(' · 未升格') : ''}`,
-						),
-						card,
-					)
-				}),
-			)
-		}
-
 		/**
 		 * **力导向布局**(graphology + ForceAtlas2),与参考实现 `refs/semantica/explorer` 同一套。
 		 *
@@ -3400,28 +1805,18 @@ window.__ModuleLoader__.load({
 		}
 
 		/**
-		 * **知识 Inspector**:点击图上的节点或边之后,回答「这是什么、凭什么信、谁改过它」。
+		 * **节点小卡**:点图上的一个点或一条边,回答「这是什么、哪些结论用到它」。
 		 *
-		 * 为什么要有它:图能画出来不等于图是知识入口。从前点一个节点只得到「按此过滤」——
-		 * 读的人仍然不知道这个词是什么意思。现在那条链补齐:
-		 *
-		 * ```text
-		 * 概念 → 定义 / 父概念 / 子概念 / 用它的谓词 / 实例 / 相关事实 / 登记修订史
-		 * 断言边 → 事实 → 命题 → 证据 → 出处 → 产生步骤 → 复核态
-		 * ```
-		 *
-		 * 数据**不在这里拼**:组装住在宿主半的 `inspectGraphSelection`(判据只有一处),
-		 * 这一层只请求与渲染。请求失败不清空旧详情——把上一次的结果换成一片空白,
-		 * 读的人会以为「这条知识没了」。
+		 * 数据仍然不在这里拼:组装住在宿主半的 `inspectGraphSelection`(经 `/api/clearai/inspector`),
+		 * 这一层只请求与渲染。卡上只说人话:种类、释义、上下位、关系、用到它的结论;
+		 * 编号、等级代码、证据 id 都不上屏(结论的来历在下面的结论列表里点开看)。
+		 * 请求失败不清空旧内容——把上一次的结果换成一片空白,读的人会以为「这条知识没了」。
 		 */
-		const GraphInspector = ({ selection, sessionId, onFilter, onClose, inspector: injected }) => {
+		const GraphInspector = ({ selection, sessionId, onFilter, onClose, inspector: injected, names }) => {
 			const [state, setState] = React.useState({ loading: false, inspector: null, error: null })
 			const key = selection === null ? '' : `${selection.kind}:${selection.id}`
 			React.useEffect(() => {
-				/**
-				 * 宿主已经把这份读数喂进来时不再问一次。这条缝同时服务两件事:
-				 * 全屏工作区(一次取好、两处渲染)与测试(同步渲染桩里等不到异步结果)。
-				 */
+				/** 宿主已经把读数喂进来时不再问一次(全屏工作区与测试都走这条缝)。 */
 				if (injected !== undefined) return undefined
 				if (key === '' || typeof sessionId !== 'string' || sessionId === '') return undefined
 				let live = true
@@ -3445,472 +1840,399 @@ window.__ModuleLoader__.load({
 			const data = injected === undefined ? state.inspector : injected
 			const busy = injected === undefined && state.loading === true
 			const failure = injected === undefined ? state.error : null
-			const line = (label, value) => (value === null || value === undefined || value === '' ? null : h('div', { style: S.kv }, h('span', { style: S.faint }, `${t(label)}:`), ` ${String(value)}`))
-			/** 事实的一张卡:链的每一段都在这里,读的人不必再去别处找。 */
-			const factCard = (fact, index) =>
-				h(
-					'div',
-					{ key: `f-${fact.id ?? index}`, style: { ...S.chipCard, marginTop: 6 } },
-					h('div', { style: S.chipCardTitle }, `${String(fact.id ?? '')} · ${String(fact.text ?? '')}`),
-					h('div', { style: S.faint }, `${String(fact.level ?? '—')} · ${String(fact.status ?? '')}${fact.at === null || fact.at === undefined ? '' : ` · ${new Date(fact.at).toISOString().slice(0, 19)}`}`),
-					line('边界', fact.scope),
-					fact.hypothesis === null
-						? h('div', { style: S.faint }, t('这条事实没有命题关联(旧账本):不拿文本相等去猜身份。'))
-						: h(
-								'div',
-								null,
-								line('命题', `${fact.hypothesis.id} — ${String(fact.hypothesis.claim ?? '')}`),
-								line('推翻条件', fact.hypothesis.refuteWhen),
-								line('支持到', `${String(fact.hypothesis.supportedLevel ?? '—')}${fact.hypothesis.refutations > 0 ? ` · 推翻 ${fact.hypothesis.refutations}` : ''}`),
-							),
-					...fact.assertions.map((assertion, position) => h('div', { key: `a-${position}`, style: S.kv }, h('span', { style: S.faint }, `${t('断言')}:`), ` ${String(assertion.chip ?? '')}`)),
-					fact.evidence.length === 0
-						? h('div', { style: S.faint }, t('没有证据引用(旧事实或自判)。'))
-						: h(
-								'div',
-								null,
-								...fact.evidence.map((item) =>
-									h(
-										'div',
-										{ key: `e-${item.id}` },
-										line('证据', `${item.id} · ${item.verdict} · ${item.level} · ${item.evaluator}`),
-										item.basis === null ? null : line('依据', item.basis),
-										item.origins.length === 0 ? null : line('出处', item.origins.map((origin) => `${origin.kind}${origin.path === undefined ? '' : `:${origin.path}`}${origin.session === undefined ? '' : `:${origin.session}`}`).join('、')),
-										item.step === null ? null : line('产生步骤', `${item.step.plan}/${item.step.id} · ${String(item.step.doneCriteria ?? '')}`),
-									),
-								),
-							),
-					fact.review === null ? null : line('复核', `${fact.review.decision}${fact.review.reason === null ? '' : ` — ${fact.review.reason}`}`),
-					fact.conflicts.length === 0 ? null : line('冲突', t('这条事实参与了一对冲突读数(只暴露,不裁决)')),
-				)
+			const definition = data?.definition ?? {}
+			const relations = data?.relations ?? {}
+			const kv = (label, value) => (value === null || value === undefined || value === '' ? [] : [h('span', { key: `k-${label}` }, label), h('span', { key: `v-${label}` }, String(value))])
+			const value = definition.value === undefined || definition.value === null ? null : `${String(definition.value)}${definition.unit ? ` ${String(definition.unit)}` : ''}`
+			/** 用到它的结论:写进长期知识的那几条;被人撤回的标「已替换」,卷进矛盾的标「有矛盾」。 */
+			const factTrust = (fact) => (fact.review?.decision === 'retracted' ? 'replaced' : (fact.conflicts ?? []).length > 0 ? 'conflict' : 'credible')
+			const facts = Array.isArray(data?.facts) ? data.facts : []
+			const title = String(selection.label ?? data?.selection?.label ?? selection.id)
+			/** 关系串里的主语 / 宾语是实例 id(`i_jepa`):换成图上的名字(`I-JEPA`)再上屏。 */
+			const named = (text) => [...(names ?? new Map()).entries()].sort((left, right) => right[0].length - left[0].length).reduce((out, [ref, label]) => out.split(ref).join(label), String(text ?? ''))
 			return h(
 				'div',
-				{ style: { ...S.chipCard, marginTop: 6, maxHeight: 360, overflow: 'auto' } },
+				{ className: 'clearai-card' },
 				h(
 					'div',
-					{ style: S.inline },
-					h('span', { style: S.chipCardTitle }, data === null ? `${String(selection.label ?? selection.id)}` : `${String(data.selection.label ?? data.selection.id)}`),
-					h('span', { style: S.faint }, `${String(selection.kind)} · ${String(selection.id)}`),
+					{ className: 'clearai-card-head' },
+					h('span', { className: 'clearai-card-kind' }, KIND_WORD[selection.kind] ?? t('关系')),
+					h('span', { className: 'clearai-card-title' }, title),
 					h('span', { style: { flex: '1 1 auto' } }),
-					h('span', { style: S.chipAction, onClick: onFilter }, t('按此筛选')),
-					h('span', { style: S.chipAction, onClick: onClose }, t('关闭')),
+					h('span', { className: 'clearai-link', onClick: onFilter }, t('只看相关')),
+					h('span', { className: 'clearai-link', onClick: onClose }, t('关闭')),
 				),
-				busy === true ? h('div', { style: S.faint }, t('正在取这条知识的读数…')) : null,
-				failure !== null ? h('div', { style: S.faint }, `${t('取不到读数')}:${failure}`) : null,
-				busy === false && failure === null && data === null ? h('div', { style: S.faint }, t('宿主没有这个对象的读数(可能刚被废止,或它不在当前词汇里)。')) : null,
+				busy === true ? h('div', { className: 'clearai-quiet' }, t('正在取…')) : null,
+				failure !== null ? h('div', { className: 'clearai-quiet' }, `${t('取不到')}${t(':')}${failure}`) : null,
+				busy === false && failure === null && data === null ? h('div', { className: 'clearai-quiet' }, t('这一项已经不在当前的词里了(可能刚被废止)。')) : null,
 				data === null
 					? null
 					: h(
 							'div',
-							null,
-							data.definition?.gloss === undefined || data.definition.gloss === null ? null : h('div', { style: S.kv }, h('span', { style: S.faint }, `${t('释义')}:`), ` ${String(data.definition.gloss)}`),
-							line('依据', data.definition?.basis),
-							line('状态', data.definition?.status),
-							line('父概念', data.definition?.parentLabel ?? data.definition?.parent),
-							line('主词域', data.definition?.domainLabel ?? data.definition?.domain),
-							line('值域', data.definition?.range === null || data.definition?.range === undefined ? null : JSON.stringify(data.definition.range)),
-							line('形态', data.definition?.form),
-							line('取值', data.definition?.value === undefined || data.definition?.value === null ? null : `${String(data.definition.value)}${data.definition.unit === null || data.definition.unit === undefined ? '' : ` ${String(data.definition.unit)}`}`),
-							line('类型', data.definition?.typeLabel ?? data.definition?.type),
-							line('引用', data.definition?.uses),
-							data.note === null || data.note === undefined ? null : h('div', { style: S.faint }, String(data.note)),
-							data.relations === undefined || data.relations === null
-								? null
-								: h(
-										'div',
-										null,
-										(data.relations.children ?? []).length === 0 ? null : line('子概念', data.relations.children.map((item) => item.label).join('、')),
-										(data.relations.predicates ?? []).length === 0 ? null : line('相关谓词', data.relations.predicates.map((item) => `${item.label}(${item.id})`).join('、')),
-										(data.relations.instances ?? []).length === 0 ? null : line('实例', data.relations.instances.map((item) => `${item.label}×${item.factCount}`).join('、')),
-										(data.relations.edges ?? []).length === 0 ? null : line('关系边', data.relations.edges.map((edge) => `${edge.direction === 'out' ? '→' : '←'}${edge.chip}`).join('、')),
-										(data.relations.subjects ?? []).length === 0 ? null : line('主词', data.relations.subjects.map((item) => item.ref).join('、')),
-									),
-							(data.facts ?? []).length === 0 ? null : h('div', { style: { ...S.faint, marginTop: 6 } }, `${t('相关事实')} ${data.facts.length}${data.factsTruncated > 0 ? t('(还有更多,未列出)') : ''}:`),
-							...(data.facts ?? []).map(factCard),
-							(data.conflicts ?? []).length === 0 ? null : h('div', { style: { ...S.faint, marginTop: 6 } }, `${t('冲突')} ${data.conflicts.length}:${data.conflicts.map((conflict) => `${conflict.predicate} · ${conflict.subject}`).join('、')}`),
-							(data.history ?? []).length === 0 ? null : h('div', { style: { ...S.faint, marginTop: 6 } }, `${t('历史')}:`),
-							...(data.history ?? []).map((event, index) =>
-								h('div', { key: `h-${index}`, style: S.kv }, h('span', { style: S.faint }, event.at === null || event.at === undefined ? '—' : new Date(event.at).toISOString().slice(0, 19)), ` ${String(event.summary ?? event.kind)}${event.reason === null || event.reason === undefined ? '' : ` — ${String(event.reason)}`}`),
+							{ className: 'clearai-kv' },
+							...kv(t('释义'), definition.gloss),
+							...kv(t('上位'), definition.parentLabel ?? definition.parent),
+							...kv(t('下位'), (relations.children ?? []).map((item) => item.label).join('、')),
+							...kv(t('主语'), definition.domainLabel ?? definition.domain),
+							...kv(t('类型'), definition.typeLabel ?? definition.type),
+							...kv(t('取值'), value),
+							...kv(t('依据'), definition.basis),
+							...kv(t('关系'), (relations.edges ?? []).slice(0, 6).map((edge) => named(edge.chip)).join('、')),
+							...kv(t('实例'), (relations.instances ?? []).slice(0, 6).map((item) => item.label).join('、')),
+							definition.status === 'deprecated' ? h('span', { key: 'dep', style: { gridColumn: '1 / -1' }, className: 'clearai-quiet' }, t('这个词已废止,旧结论里的用法照样可读。')) : null,
+						),
+				facts.length === 0
+					? null
+					: h(
+							'div',
+							{ className: 'clearai-card-facts' },
+							h('div', { className: 'clearai-group-head' }, t('用到它的结论'), h('span', null, `${facts.length}${data.factsTruncated > 0 ? '+' : ''}`)),
+							...facts.slice(0, 4).map((fact, index) =>
+								h(
+									'div',
+									{ key: `f-${index}`, className: 'clearai-card-fact' },
+									factTrust(fact) === 'conflict' ? h('span', { className: 'clearai-trust', 'data-trust': 'conflict' }, t('有矛盾')) : h(TrustTag, { trust: factTrust(fact) }),
+									h('span', null, brief(fact.text, 60)),
+									fact.scope && fact.scope !== fact.hypothesis?.refuteWhen ? h('span', { className: 'clearai-row-sub' }, `${t('范围:')}${brief(fact.scope, 40)}`) : null,
+								),
 							),
 						),
 			)
 		}
 
 		/**
-		 * **图带 / 图谱工作区(React Flow)**。
-		 *
-		 * 渲染交给 @xyflow/react——拖节点、拖画布、滚轮缩放、框选、MiniMap 都是库的事,
-		 * 我们不再手写 SVG 交互。这一层只做三件 ClearAI 自己的事:
-		 *   · **适配投影**:graphProjection() 的节点 / 边 → React Flow 的 nodes / edges,
-		 *     类型 / 冲突 / 状态的视觉编码在这里(不在投影里,投影是语义不是样式);
-		 *   · **点击语义**:点节点 / 边 = 打开 Inspector;过滤是 Inspector 里的显式动作;
-		 *   · **全屏工作区**:position: fixed 的真 overlay,打开时自动 fit。
+		 * **星图(React Flow)**:本体图 / 实体图二选一。
 		 *
-		 * 数据不在这里拼:Inspector 的证据链住在宿主半(inspectGraphSelection),
-		 * 这一层只拿投影与路由的结果。所有交互状态(viewport / 选中 / 拖动)是界面状态,
-		 * 一个字节都不进账本。
-		 */
-		const GraphBand = ({ lexicon, layer, onLayer, fullscreen, onToggleFullscreen, onFilter, sessionId, unlanded }) => {
+		 * 渲染交给 @xyflow/react——拖节点、拖画布、滚轮缩放都是库的事。这一层只做三件 ClearAI 自己的事:
+		 *   · **适配投影**:graphProjection() 的节点 / 边 → React Flow 的 nodes / edges;
+		 *     视觉编码在这里(投影是语义不是样式):点 + 衬线标签;概念是空心圈、实例是实心点、
+		 *     取值是小点;边实线 = 已验证(写进长期知识的断言),虚线 = 待核验(登记了、没过独立裁决),
+		 *     淡线 = 上下位;卷进矛盾的点和边用告警色。
+		 *   · **点击语义**:点节点 / 边 = 打开小卡;「只看相关」是卡上的显式动作。
+		 *   · **全屏**:position: fixed 的真 overlay,打开时自动适配。
+		 */
+		const GraphBand = ({ lexicon, layer, onLayer, fullscreen, onToggleFullscreen, onFilter, sessionId, unlanded, focus }) => {
 			const [picked, setPicked] = React.useState(null)
 			const graph = lexicon?.graph ?? { nodes: [], edges: [], bounds: { width: 0, height: 0 } }
 			const conflicts = Array.isArray(lexicon?.conflicts) ? lexicon.conflicts : []
 			const conflicted = new Set(conflicts.flatMap((item) => item.sides.map((side) => side.fact)).filter((id) => typeof id === 'string'))
-			const allNodes = graph.nodes.filter((node) => node.layer === layer)
-			const allEdges = graph.edges.filter((edge) => edge.layer === layer && typeof edge.from === 'string' && typeof edge.to === 'string')
-			const nodeById = new Map(allNodes.map((node) => [node.id, node]))
+			const layerNodes = graph.nodes.filter((node) => node.layer === layer)
+			const layerEdges = graph.edges.filter((edge) => edge.layer === layer && typeof edge.from === 'string' && typeof edge.to === 'string')
+			const nodeById = new Map(layerNodes.map((node) => [node.id, node]))
+			const problems = Array.isArray(lexicon?.problems) ? lexicon.problems : []
 
-		/** 图上的标签只放得下一小段:截断加省略号,全文在 Inspector 里(点开就有)。 */
-		const trimLabel = (text, limit) => {
-			const value = String(text ?? '')
-			return value.length <= limit ? value : `${value.slice(0, limit - 1)}…`
-		}
+			/**
+			 * **目录嵌套就是子图**:概念的父是 `node.parent`(is_a),实体的父是 `node.container`(组成)。
+			 * 一个父可以收起,收起后它的整棵子树藏起来,子树上的边改连到这个父身上(去掉自环、去重)。
+			 * 点多(> 40)时默认收到第一层,点开 +N 再往下看;点少时全展开。
+			 */
+			const parentOf = (node) => {
+				const id = node.kind === 'concept' ? (typeof node.parent === 'string' && node.parent !== '' ? `term:${node.parent}` : null) : (node.container ?? null)
+				return id !== null && id !== node.id && nodeById.has(id) ? id : null
+			}
+			const parentById = new Map(layerNodes.map((node) => [node.id, parentOf(node)]))
+			const childCount = new Map()
+			for (const [, parent] of parentById) if (parent !== null) childCount.set(parent, (childCount.get(parent) ?? 0) + 1)
+			const depthOfNode = (id) => {
+				let depth = 0
+				const seen = new Set([id])
+				for (let at = parentById.get(id); at !== null && at !== undefined && !seen.has(at); at = parentById.get(at)) {
+					seen.add(at)
+					depth += 1
+				}
+				return depth
+			}
+			const [toggled, setToggled] = React.useState({})
+			React.useEffect(() => {
+				setToggled({})
+			}, [layer])
+			const crowded = layerNodes.length > 40
+			const isCollapsed = (id) => (childCount.get(id) ?? 0) > 0 && (toggled[id] ?? (crowded && depthOfNode(id) >= 1))
+			/** 往上找第一个没被收起的祖先挡住的点:自己可见就是自己。 */
+			const shownAs = (id) => {
+				let shown = id
+				const seen = new Set([id])
+				for (let at = parentById.get(id); at !== null && at !== undefined && !seen.has(at); at = parentById.get(at)) {
+					seen.add(at)
+					if (isCollapsed(at)) shown = at
+				}
+				return shown
+			}
+			const hiddenUnder = new Map()
+			for (const node of layerNodes) {
+				const shown = shownAs(node.id)
+				if (shown !== node.id) hiddenUnder.set(shown, (hiddenUnder.get(shown) ?? 0) + 1)
+			}
+			const allNodes = layerNodes.filter((node) => shownAs(node.id) === node.id)
+			const allEdges = (() => {
+				const out = []
+				const seen = new Set()
+				for (const edge of layerEdges) {
+					const from = nodeById.has(edge.from) ? shownAs(edge.from) : edge.from
+					const to = nodeById.has(edge.to) ? shownAs(edge.to) : edge.to
+					if (from === to) continue
+					if (from === edge.from && to === edge.to) {
+						out.push(edge)
+						continue
+					}
+					const key = `${edge.kind}|${edge.label ?? ''}|${from}|${to}`
+					if (seen.has(key)) continue
+					seen.add(key)
+					out.push({ ...edge, id: `${edge.id}@${from}>${to}`, from, to })
+				}
+				return out
+			})()
+			const toggle = (id) => setToggled((current) => ({ ...current, [id]: !isCollapsed(id) }))
+			const countOf = (name) => graph.nodes.filter((node) => node.layer === name).length
+			const entityNames = new Map(graph.nodes.filter((node) => node.kind === 'instance' && typeof node.ref === 'string' && node.ref !== '' && node.label !== node.ref).map((node) => [String(node.ref), String(node.label)]))
+
+			/** 图上的标签只放得下一小段:截断加省略号,全文在小卡里。 */
+			const trimLabel = (text, limit) => {
+				const value = String(text ?? '')
+				return value.length <= limit ? value : `${value.slice(0, limit - 1)}…`
+			}
 
-			/** 视觉编码:类型 → 颜色(概念蓝 / 值形态橙 / 实例绿 / 字面值紫)。 */
-			const nodeStyle = (node) => ({
-				background: node.kind === 'concept' ? 'rgba(74,163,255,0.16)' : node.kind === 'value_type' ? 'rgba(217,119,6,0.16)' : node.kind === 'instance' ? 'rgba(22,163,74,0.16)' : 'rgba(147,51,234,0.16)',
-				border: node.status === 'deprecated' ? '1px dashed rgba(127,127,127,0.4)' : `1px solid ${node.kind === 'concept' ? 'rgba(74,163,255,0.4)' : node.kind === 'value_type' ? 'rgba(217,119,6,0.4)' : node.kind === 'instance' ? 'rgba(22,163,74,0.4)' : 'rgba(147,51,234,0.4)'}`,
-				borderRadius: 6,
-				padding: '6px 12px',
-				fontSize: 12,
-				width: 168,
-				textAlign: 'center',
-			})
+			/**
+			 * **节点位置是受控的,所以必须自己接住拖动**:不给 `onNodesChange`,
+			 * React Flow 内部的拖动没有地方落地,节点根本拖不动。位置是界面状态,换层或图变了就清掉。
+			 */
+			const [dragged, setDragged] = React.useState({})
+			const graphKey = `${layer}|${layerNodes.length}|${layerEdges.length}`
+			React.useEffect(() => {
+				setDragged({})
+			}, [graphKey])
+			const onNodesChange = React.useCallback((changes) => {
+				setDragged((current) => {
+					let next = current
+					for (const change of changes) {
+						if (change?.type !== 'position' || change.position === undefined) continue
+						if (next === current) next = { ...current }
+						next[change.id] = change.position
+					}
+					return next
+				})
+			}, [])
 
-		/**
-		 * **节点位置是受控的,所以必须自己接住拖动**。
-		 *
-		 * React Flow 的 `nodes` 是受控 prop:不给 `onNodesChange`,它内部的拖动**没有地方落地**——
-		 * 表现就是**节点根本拖不动**(拖前拖后 transform 一模一样)。
-		 * 位置是**界面状态**(布局不是知识,不进账本),所以它住在这里;
-		 * 换层或图变了就清掉,免得上一张图的拖动痕迹贴到新图上。
-		 */
-		const [dragged, setDragged] = React.useState({})
-		const graphKey = `${layer}|${allNodes.length}|${allEdges.length}`
-		React.useEffect(() => {
-			setDragged({})
-		}, [graphKey])
-		const onNodesChange = React.useCallback((changes) => {
-			setDragged((current) => {
-				let next = current
-				for (const change of changes) {
-					if (change?.type !== 'position' || change.position === undefined) continue
-					if (next === current) next = { ...current }
-					next[change.id] = change.position
-				}
-				return next
-			})
-		}, [])
+			/** 一个点的状态:矛盾 > 废止 > 待核验(只登记、没有写进长期知识的事实)> 平常。 */
+			const nodeState = (node) => {
+				if (Array.isArray(node.facts) && node.facts.some((id) => conflicted.has(id))) return 'conflict'
+				if (node.status === 'deprecated') return 'off'
+				if (node.kind !== 'concept' && node.kind !== 'value_type' && node.source === 'asserted' && (node.facts ?? []).length === 0) return 'pending'
+				return 'on'
+			}
+			const selectedId = picked?.kind === 'node' ? picked.node.id : (focus ?? null)
 
 			/**
-			 * 投影节点 → React Flow 节点。
-			 *
-			 * 坐标 = **力导向松弛过的投影坐标**:投影给的按层折行排布作起点(确定性、读得懂),
-			 * FA2 再把它松弛成这个图**自己的形状**(枢纽、簇)。拿不到 FA2 时就是起点本身。
+			 * 投影节点 → React Flow 节点。坐标 = 力导向松弛过的投影坐标(起点确定 ⇒ 同一份账本同一张图)。
+			 * 尺寸显式给:只写在 style 里的话,React Flow 要等测量完成才知道它多大。
 			 */
-			const rfNodes = forceLayout(allNodes.map((node) => ({
-								id: node.id,
-				type: 'default',
-				/** 拖过的以拖动为准(界面状态);没拖过的用布局算出来的。 */
-				position: dragged[node.id] ?? { x: node.x ?? 0, y: node.y ?? 0 },
-				/**
-				 * **尺寸要显式给**。只写在 `style` 里的话,React Flow 要等测量完成才知道它多大,
-				 * 而 **MiniMap 在测量完成之前拿不到宽高就直接跳过这些节点**——缩略图因此是一块空白
-				 * (真机截图里就是那样)。`initialWidth/initialHeight` 是官方的「测量前尺寸」。
-				 */
-				initialWidth: 168,
-				initialHeight: 34,
-				/** 图上只放得下一小段;全文在 Inspector 里,点开就有。 */
-				data: { label: trimLabel(`${node.label ?? node.ref ?? node.id}${node.uses > 0 ? ` (${node.uses})` : ''}`, 22) },
-				style: nodeStyle(node),
-				/** 冲突节点标红。 */
-				...(Array.isArray(node.facts) && node.facts.some((id) => conflicted.has(id)) ? { className: 'clearai-node-conflict' } : {}),
-			})), allEdges.map((edge) => ({ source: edge.from, target: edge.to })))
+			/**
+			 * 小图(十来个点)不跑力导向:几个点、几条边时它常常把点排成一条线。
+			 * 改成一圈:连得最多的那个点居中(它是这张图的主语),其余按投影顺序绕一圈——确定、好读。
+			 * 点少(六个以内)时不放中心:边都是圈上的弦,不会从某个点身上穿过去、压住它的标签。
+			 */
+			const small = allNodes.length <= 14
+			const ring = (() => {
+				if (!small) return null
+				const degree = new Map(allNodes.map((node) => [node.id, 0]))
+				for (const edge of allEdges) {
+					if (degree.has(edge.from)) degree.set(edge.from, degree.get(edge.from) + 1)
+					if (degree.has(edge.to)) degree.set(edge.to, degree.get(edge.to) + 1)
+				}
+				const hub = allNodes.length >= 7 ? [...allNodes].sort((left, right) => degree.get(right.id) - degree.get(left.id))[0] : null
+				const around = allNodes.filter((node) => node !== hub)
+				const radius = 120 + around.length * 14
+				const out = new Map()
+				if (hub !== null) out.set(hub.id, { x: 0, y: 0 })
+				around.forEach((node, index) => {
+					const angle = -Math.PI / 2 + (index / around.length) * Math.PI * 2
+					out.set(node.id, { x: Math.cos(angle) * radius * 1.6, y: Math.sin(angle) * radius })
+				})
+				return out
+			})()
+			const layout = small ? (nodes) => nodes : forceLayout
+			const rfNodes = layout(
+				allNodes.map((node) => ({
+					id: node.id,
+					type: 'default',
+					position: dragged[node.id] ?? ring?.get(node.id) ?? { x: node.x ?? 0, y: node.y ?? 0 },
+					initialWidth: 120,
+					initialHeight: 26,
+					selected: node.id === selectedId,
+					data: {
+						label: h(
+							'span',
+							{ className: 'clearai-star', 'data-kind': node.kind, 'data-state': nodeState(node), 'data-sel': node.id === selectedId ? '1' : '0' },
+							h('i', null),
+							h('span', null, trimLabel(node.kind === 'value_type' ? (FORM_WORD[node.ref] ?? node.label ?? node.ref) : (node.label ?? node.ref ?? node.id), 16)),
+							(childCount.get(node.id) ?? 0) > 0
+								? h(
+										'b',
+										{
+											className: 'clearai-fold',
+											title: isCollapsed(node.id) ? t('展开下一层') : t('收起下一层'),
+											onClick: (event) => {
+												event.stopPropagation()
+												toggle(node.id)
+											},
+										},
+										isCollapsed(node.id) ? `+${hiddenUnder.get(node.id) ?? 0}` : '−',
+									)
+								: null,
+						),
+					},
+					className: 'clearai-star-node',
+					style: { background: 'transparent', border: 0, padding: 0, width: 'auto', boxShadow: 'none' },
+				})),
+				allEdges.map((edge) => ({ source: edge.from, target: edge.to })),
+			)
 
-			/** 投影边 → React Flow 边(类型 / 冲突的视觉编码)。 */
+			/** 投影边 → React Flow 边:实线已验证、虚线待核验、淡线上下位、告警色是矛盾。 */
+			const edgeTone = (edge) => {
+				if (edge.kind === 'assertion' && conflicted.has(edge.fact)) return { stroke: 'var(--dsw-alias-state-warn-primary)', strokeWidth: 1.4 }
+				if (edge.kind === 'is_a') return { stroke: 'var(--dsw-alias-border-l3)', strokeWidth: 1, strokeDasharray: '1 3' }
+				if (edge.status === 'retracted') return { stroke: 'var(--dsw-alias-border-l2)', strokeWidth: 1, strokeDasharray: '2 4' }
+				if (edge.kind === 'assertion' && edge.status !== 'live') return { stroke: 'var(--dsw-alias-label-tertiary)', strokeWidth: 1.1, strokeDasharray: '5 4' }
+				return { stroke: edge.kind === 'assertion' ? 'var(--dsw-alias-label-secondary)' : 'var(--dsw-alias-label-tertiary)', strokeWidth: edge.kind === 'assertion' ? 1.3 : 1 }
+			}
 			const rfEdges = allEdges.map((edge) => ({
 				id: edge.id,
 				source: edge.from,
 				target: edge.to,
-				label: edge.label ?? '',
-				labelStyle: { fontSize: 9 },
-				labelBgStyle: { fill: 'var(--dsw-alias-bg-layer-1)', fillOpacity: 0.85 },
-				animated: edge.kind === 'assertion' && edge.status === 'live',
-				style: {
-					stroke: edge.kind === 'assertion' && conflicted.has(edge.fact) ? '#dc2626' : edge.kind === 'is_a' ? 'rgba(127,127,127,0.4)' : 'rgba(74,163,255,0.5)',
-					strokeWidth: edge.kind === 'assertion' ? 1.5 : 1,
-					...(edge.kind === 'is_a' ? { strokeDasharray: '4 3' } : {}),
-				},
+				type: 'straight',
+				label: edge.kind === 'is_a' ? '' : (edge.label ?? ''),
+				labelStyle: { fontSize: 10, fill: 'var(--dsw-alias-label-secondary)' },
+				labelBgStyle: { fill: 'var(--dsw-alias-bg-base)', fillOpacity: 0.9 },
+				labelBgPadding: [3, 1],
+				style: edgeTone(edge),
 			}))
 
-			/** 点击语义:点节点 / 边 = 打开 Inspector。 */
 			const onNodeClick = (_event, node) => {
 				const original = nodeById.get(node.id)
-				if (original === undefined) return
-				setPicked({ kind: 'node', node: original })
+				if (original !== undefined) setPicked({ kind: 'node', node: original })
 			}
 			const onEdgeClick = (_event, edge) => {
 				const original = allEdges.find((item) => item.id === edge.id)
-				if (original === undefined) return
-				setPicked({ kind: 'edge', edge: original })
+				if (original !== undefined) setPicked({ kind: 'edge', edge: original })
 			}
+			/** 结论那边点了「相关」里的一个主语:当成在图上点了它。 */
+			React.useEffect(() => {
+				if (focus === null || focus === undefined) return
+				const original = nodeById.get(focus)
+				if (original !== undefined) setPicked({ kind: 'node', node: original })
+			}, [focus])
 
-			/** Inspector 要看的对象。 */
 			const inspection =
 				picked === null
 					? null
 					: picked.kind === 'edge'
 						? { kind: 'edge', id: picked.edge.id, label: picked.edge.label }
 						: { kind: picked.node.kind, id: picked.node.kind === 'concept' ? String(picked.node.ref ?? '') : picked.node.id, label: picked.node.label ?? picked.node.ref ?? picked.node.id }
-			/** 「按此筛选」:概念筛概念、实例筛实体、断言边筛谓词。 */
-			const filterTarget = picked === null ? null : picked.kind === 'edge' ? picked.edge.predicate ?? null : String(picked.node.ref ?? '')
+			/** 「只看相关」:概念筛概念、实例筛实体、断言边筛谓词。 */
+			const filterTarget = picked === null ? null : picked.kind === 'edge' ? (picked.edge.predicate ?? null) : String(picked.node.ref ?? '')
 
 			/**
-			 * React Flow 的**实例**(用来 fit / 重新适配)。
-			 *
-			 * 注意:v12 里给 `<ReactFlow ref={…}>` 传 ref 拿到的是 DOM 节点,不是带 `fitView` 的
-			 * 实例——这样写调用会**静默变成空操作**。实例要从 `onInit` 拿。
-			 * 真机上踩到过:内联图带先按小画布 fit 了一次,切到全屏后画布大了十倍却没重新适配,
-			 * 于是图缩在左上角一小块(截图里一眼可见)。
+			 * React Flow 的**实例**(用来适配)要从 `onInit` 拿:v12 里 ref 拿到的是 DOM 节点,
+			 * 在它上面调 `fitView` 会静默变成空操作。画布的几何或内容变了就重新适配一次。
 			 */
 			const rfRef = React.useRef(null)
-			/**
-			 * **什么时候重新适配**:画布的**几何**或**内容**变了就得重来一次。
-			 *
-			 * 三件都会让刚才那张图不在眼前:打开/关闭工作区(画布尺寸变了)、
-			 * 切层(整套节点换了)、开/关详情抽屉(画布变窄)。
-			 * React Flow 的视口变换**不会自己跟**这些变化——不重算就得到「详情读得到、图却空了」
-			 * (真机截图里就是这个样子)。这里只在**这几件事发生**时重算,人自己拖过/缩过的视角
-			 * 不会因为数据刷新被夺走。
-			 */
 			React.useEffect(() => {
-				const timer = setTimeout(() => rfRef.current?.fitView?.({ padding: 0.15, duration: 200 }), 60)
+				const timer = setTimeout(() => rfRef.current?.fitView?.({ padding: 0.18, duration: 200 }), 60)
 				return () => clearTimeout(timer)
 			}, [fullscreen, layer, picked !== null, allNodes.length])
 
-			const shell = fullscreen === true ? { position: 'fixed', inset: 0, zIndex: 40, background: 'var(--dsw-alias-bg-layer-1)', padding: 12, display: 'flex', flexDirection: 'column', overflow: 'hidden' } : { ...S.section, padding: 6 }
-			const canvasBox = fullscreen === true ? { flex: '1 1 auto', minHeight: 240, minWidth: 0, overflow: 'hidden', border: '1px solid rgba(127,127,127,0.18)', borderRadius: 6 } : { height: 208, overflow: 'hidden', border: '1px solid rgba(127,127,127,0.18)', borderRadius: 6 }
-			/**
-			 * **工作区里详情走右侧抽屉,不占画布的高度。**
-			 *
-			 * 这条不是审美:详情摆在画布下方时,它一出现画布就变矮,而 React Flow 的视口变换
-			 * 不会跟着变——于是**刚点开的那个节点直接掉出可视区**(真机上就是这样:详情读得到,
-			 * 图却空了)。侧栏只压缩宽度,而宽度方向的适配本来就有 `fitView` 管。
-			 * 内联图带不适用:那里只有两百来像素高,横向没地方放抽屉。
-			 */
+			/** 全屏时小卡走右侧抽屉:摆在画布下方会把画布压矮,刚点开的那个点直接掉出可视区。 */
 			const sideBySide = fullscreen === true
-
+			const empty =
+				layer === 'entity'
+					? `${typeof unlanded === 'number' && unlanded > 0 ? `${t('有 ')}${unlanded}${t(' 个断言的主语还没写成实体文件。')}` : t('实体图还空着。')}${t('clear/ontology/entities/ 下的实体文件、写进长期知识的断言会出现在这里。')}`
+					: t('本体图还空着。模型在 clear/ontology/concepts/ 和 relations/ 下写概念与关系文件之后,它们会长在这里。')
 			return h(
 				'div',
-				{ style: shell },
-				h(
-					'div',
-					{ style: S.inline },
-					h('span', { style: { ...S.tag, cursor: 'pointer', opacity: layer === 'ontology' ? 1 : 0.5 }, onClick: () => { setPicked(null); onLayer('ontology') } }, t('本体图')),
-					h('span', { style: { ...S.tag, cursor: 'pointer', opacity: layer === 'entity' ? 1 : 0.5 }, onClick: () => { setPicked(null); onLayer('entity') } }, t('实体图')),
-					h('span', { style: { ...S.faint, flex: '1 1 auto' } }, t('点节点看知识详情')),
-					h('span', { style: S.chipAction, onClick: () => rfRef.current?.fitView({ padding: 0.15, duration: 200 }) }, t('适配')),
-					h('span', { style: S.chipAction, onClick: onToggleFullscreen }, fullscreen === true ? t('关闭工作区') : t('打开图谱工作区')),
-				),
+				{ className: 'clearai-graph', 'data-full': fullscreen === true ? '1' : '0' },
 				h(
 					'div',
-					{ style: { display: 'flex', flexDirection: sideBySide ? 'row' : 'column', gap: 8, flex: '1 1 auto', minHeight: 0, alignItems: 'stretch' } },
+					{ className: 'clearai-graph-bar' },
 					h(
-						'div',
-						{ style: { display: 'flex', flexDirection: 'column', gap: 6, flex: '1 1 auto', minWidth: 0, minHeight: 0 } },
-				XYFlow === null || XYFlow.ReactFlow === undefined || XYFlow.ReactFlow === null
-					? h('div', { style: S.faint }, `${t('图组件不可用')}(${String(XYFLOW_LOAD.reason ?? '')}):${t('投影还在,事实与命题照常可读。')}`)
-					: allNodes.length === 0
-					? h(
-							'div',
-							{ style: S.faint },
-							/**
-							 * **空态要说清"这一层的东西从哪来"**,不能只说「暂无」。
-							 * 实体层尤其:它是本项目里唯一需要**独立写入口**的一层(RegisterInstance),
-							 * 而图上看不见它时,人最容易得出的错结论是「断言都写了,图迟早会自己长出来」。
-							 * 所以两句:为什么是空的 + 什么不算数。
-							 * 别的层仍是一句平静的「暂无」:那里确实只是还没登记。
-							 */
-							layer === 'entity'
-								? `${typeof unlanded === 'number' && unlanded > 0 ? `${unlanded}${t(' 个断言主体还没落到这一层:')}` : t('这一层还没有实例节点。')}${t('实例靠 RegisterInstance 登记(带出处);断言挂在命题上不算「已知」。')}`
-								: t('此层暂无节点。'),
-						)
-					: h(
-							'div',
-							{ style: canvasBox },
-							h(XYFlow.ReactFlow, {
-								onInit: (instance) => {
-									rfRef.current = instance
-								},
-								onNodesChange,
-								nodes: rfNodes,
-								edges: rfEdges,
-								onNodeClick,
-								onEdgeClick,
-								onPaneClick: () => setPicked(null),
-								fitView: true,
-								minZoom: 0.2,
-								maxZoom: 3,
-								proOptions: { hideAttribution: true },
-								style: { background: 'transparent' },
-								nodesDraggable: true,
-								nodesConnectable: false,
-								elementsSelectable: true,
-								panOnDrag: true,
-								zoomOnScroll: true,
-								zoomOnDoubleClick: false,
-							},
-							h(XYFlow.Controls, { showInteractive: false }),
-							h(XYFlow.MiniMap, {
-								pannable: true,
-								zoomable: true,
-								/**
-								 * **缩略图要看得懂**:默认节点是灰白的,在大图上等于一块空白方块——
-								 * 这里按类型给实色(与画布上的淡色底不同:缩略图里小块面积小,淡色看不见)。
-								 * 遮罩(视口指示)也调淡一点,别把整张缩略图盖成一个白框。
-								 */
-								nodeColor: (node) => {
-									const layerKind = nodeById.get(node.id)?.kind ?? ''
-									if (layerKind === 'concept') return '#6ea8fe'
-									if (layerKind === 'value_type') return '#e0a458'
-									if (layerKind === 'instance') return '#4caf7d'
-									if (layerKind === 'literal') return '#a97fe0'
-									return '#9aa4b2'
-								},
-								maskColor: 'rgba(127,127,127,0.18)',
-								maskStrokeColor: 'rgba(127,127,127,0.45)',
-								style: { background: 'var(--dsw-alias-bg-layer-2)', border: '1px solid rgba(127,127,127,0.25)' },
-							}),
-							h(XYFlow.Background, { variant: 'dots', gap: 20, size: 1, color: 'rgba(127,127,127,0.15)' }),
-						),
+						'span',
+						{ className: 'clearai-seg' },
+						h('span', { 'data-on': layer === 'ontology' ? '1' : '0', onClick: () => { setPicked(null); onLayer('ontology') } }, `${t('本体图')} ${countOf('ontology')}`),
+						h('span', { 'data-on': layer === 'entity' ? '1' : '0', onClick: () => { setPicked(null); onLayer('entity') } }, `${t('实体图')} ${countOf('entity')}`),
 					),
-				allNodes.length > 0
-					? h('div', { style: S.faint }, `${allNodes.length} ${t('个节点')} · ${allEdges.length} ${t('条边')}${conflicts.length > 0 ? ` · ${t('冲突')} ${conflicts.length}` : ''}`)
-					: null,
+					h(
+						'span',
+						{ className: 'clearai-legend' },
+						h('span', { 'data-l': 'solid' }, t('已验证')),
+						h('span', { 'data-l': 'dash' }, t('待核验')),
+						conflicts.length > 0 ? h('span', { 'data-l': 'warn' }, `${t('矛盾')} ${conflicts.length}`) : null,
 					),
+					h('span', { style: { flex: '1 1 auto' } }),
+					allNodes.length === 0 ? null : h('span', { className: 'clearai-link', onClick: () => rfRef.current?.fitView?.({ padding: 0.18, duration: 200 }) }, t('适配')),
+					h('span', { className: 'clearai-link', onClick: onToggleFullscreen }, fullscreen === true ? t('退出全屏') : t('全屏')),
+				),
+				h(
+					'div',
+					{ className: 'clearai-graph-body', 'data-side': sideBySide ? '1' : '0' },
+					XYFlow === null || XYFlow.ReactFlow === undefined || XYFlow.ReactFlow === null
+						? h('div', { className: 'clearai-graph-empty' }, `${t('图组件不可用')}(${String(XYFLOW_LOAD.reason ?? '')}):${t('结论照常可读。')}`)
+						: allNodes.length === 0
+							? h('div', { className: 'clearai-graph-empty' }, empty)
+							: h(
+									'div',
+									{ className: 'clearai-graph-canvas' },
+									h(
+										XYFlow.ReactFlow,
+										{
+											onInit: (instance) => {
+												rfRef.current = instance
+											},
+											onNodesChange,
+											nodes: rfNodes,
+											edges: rfEdges,
+											onNodeClick,
+											onEdgeClick,
+											onPaneClick: () => setPicked(null),
+											fitView: true,
+											minZoom: 0.2,
+											maxZoom: 3,
+											proOptions: { hideAttribution: true },
+											style: { background: 'transparent' },
+											nodesDraggable: true,
+											nodesConnectable: false,
+											elementsSelectable: true,
+											panOnDrag: true,
+											zoomOnScroll: true,
+											zoomOnDoubleClick: false,
+										},
+										h(XYFlow.Controls, { showInteractive: false }),
+										h(XYFlow.Background, { variant: 'dots', gap: 22, size: 1, color: 'var(--dsw-alias-border-l2)' }),
+									),
+								),
 					picked === null
 						? null
 						: h(
 								'div',
-								{ style: sideBySide ? { width: 380, flex: '0 0 auto', overflowY: 'auto', minHeight: 0 } : { flex: '0 0 auto' } },
-								h(GraphInspector, {
-									selection: inspection,
-									sessionId,
-									onFilter: () => onFilter(filterTarget),
-									onClose: () => setPicked(null),
-								}),
+								{ className: 'clearai-graph-side' },
+								h(GraphInspector, { selection: inspection, sessionId, names: entityNames, onFilter: () => onFilter(filterTarget), onClose: () => setPicked(null) }),
 							),
 				),
-			)
-		}
-
-		/**
-		 * **词汇维护区**(折叠):词条表、健康度、废止列表、货架入口。
-		 * 默认收起——它是参考材料,不挡结论;**0 条目 0 命题而有词条时自动展开**:
-		 * 语言先于句子时,立好的词得有地方站。
-		 */
-		const VocabBlock = ({ lexicon, open, onToggle, openPreview, sessionId }) => {
-			const terms = Array.isArray(lexicon?.terms) ? lexicon.terms : []
-			const predicates = Array.isArray(lexicon?.predicates) ? lexicon.predicates : []
-			const health = Array.isArray(lexicon?.health) ? lexicon.health : []
-			const warnings = health.filter((issue) => issue.severity === 'warning')
-			const deprecated = [...terms, ...predicates].filter((entry) => entry.status === 'deprecated')
-			/** 编辑是**具名动词的图形前端**:抽屉里填字段,提交走人门通道,面板从不写文件。 */
-			const [drawer, setDrawer] = React.useState(null)
-			const [busy, setBusy] = React.useState(false)
-			const [error, setError] = React.useState(null)
-			const submitOnto = (action, entry) => {
-				setBusy(true)
-				setError(null)
-				fetch('/api/clearai/gate', {
-					method: 'POST',
-					headers: { 'content-type': 'application/json' },
-					body: JSON.stringify({ sessionId, action, entry }),
-				})
-					.then((response) => response.json())
-					.then((result) => {
-						if (result.ok !== true) setError((result.problems ?? [result.error ?? 'failed']).join(';').slice(0, 200))
-						else setDrawer(null)
-					})
-					.catch((thrown) => setError(String(thrown?.message ?? thrown)))
-					.finally(() => setBusy(false))
-			}
-			if (terms.length === 0 && predicates.length === 0) return null
-			return h(
-				'div',
-				{ style: S.section },
-				h(
-					'div',
-					{ style: { ...S.head, cursor: 'pointer' }, onClick: onToggle },
-					`${t('词汇')}(${terms.length} ${t('概念')} · ${predicates.length} ${t('谓词')}${deprecated.length > 0 ? ` · ${deprecated.length} ${t('已废止')}` : ''}) ${open === true ? '▾' : '▸'}`,
-				),
-				open === false
+				/** 读时的跨文件检查只标不拦:有问题的那一份不进图,这里说清是哪个文件、哪里不对。 */
+				problems.length === 0
 					? null
 					: h(
-							'div',
-							null,
-							...terms.map((term) => h('div', { key: `vt-${term.id}`, style: S.row }, h('span', { style: S.mono }, term.id), h('span', { style: S.faint }, ` ${String(term.label ?? '')}${term.status === 'deprecated' ? ` · ${t('已废止')}` : ''}${term.parent ? ` ↖${term.parent}` : ''}`), term.status === 'deprecated' ? null : h('span', { style: S.chipAction, onClick: () => { const reason = window?.prompt?.(`${t('废止')} ${term.id}:${t('为什么?')}`) ; if (typeof reason === 'string' && reason.trim() !== '') submitOnto('deprecate_entry', { id: term.id, reason: reason.trim() }) } }, t('废止')))),
-							...predicates.map((predicate) => h('div', { key: `vp-${predicate.id}`, style: S.row }, h('span', { style: S.mono }, predicate.id), h('span', { style: S.faint }, ` ${String(predicate.label ?? '')}${predicate.functional === true ? ` · ${t('单值')}` : ''}${predicate.status === 'deprecated' ? ` · ${t('已废止')}` : ''}`), predicate.status === 'deprecated' ? null : h('span', { style: S.chipAction, onClick: () => { const reason = window?.prompt?.(`${t('废止')} ${predicate.id}:${t('为什么?')}`) ; if (typeof reason === 'string' && reason.trim() !== '') submitOnto('deprecate_entry', { id: predicate.id, reason: reason.trim() }) } }, t('废止')))),
-							warnings.length > 0 ? h('div', { style: S.row }, `${t('健康')}:`, ...warnings.map((issue, index) => h('div', { key: `vh-${index}`, style: S.faint }, `  ${issue.id}:${issue.detail}`))) : null,
-							deprecated.length > 0
-								? h('div', { style: S.row }, ...deprecated.map((entry) => h('div', { key: `vd-${entry.id}`, style: S.faint }, `  ${entry.id} — ${String(entry.deprecated?.reason ?? '')}`)))
-								: null,
-							openPreview === undefined ? null : h('span', { style: S.chipAction, onClick: () => openPreview('clear/ontology/domain.md') }, t('打开词汇货架(原生预览)')),
-							/**
-							 * **编辑入口(阶段 E)**:登记概念 / 登记谓词两个表单抽屉;条目行的
-							 * 修订与废止在各自那行(见下)。提交 = 一次人门动词;判据在宿主半,
-							 * 界面只把表单递过去、把问题清单带回来。
-							 */
-							h('div', { style: S.inline },
-								h('span', { style: S.chipAction, onClick: () => setDrawer({ kind: 'term' }) }, `+ ${t('概念')}`),
-								h('span', { style: S.chipAction, onClick: () => setDrawer({ kind: 'predicate' }) }, `+ ${t('谓词')}`),
+							'details',
+							{ className: 'clearai-graph-problems' },
+							h('summary', null, `${t('本体文件有 ')}${problems.length}${t(' 处问题(这些不进图)')}`),
+							...problems.slice(0, 12).map((item, index) =>
+								h('div', { key: `${item.path ?? ''}#${index}`, 'data-sev': item.severity === 'error' ? 'error' : item.severity === 'info' ? 'info' : 'warning' }, h('code', null, String(item.path ?? '')), ` ${String(item.detail ?? item.code ?? '')}`),
 							),
-							drawer === null
-								? null
-								: h(OntoDrawer, { drawer, setDrawer, busy, error, onSubmit: submitOnto }),
+							problems.length > 12 ? h('div', null, `… ${problems.length - 12}`) : null,
 						),
 			)
 		}
 
-		/**
-		 * **词汇抽屉**:登记概念/谓词的最小表单。字段与动词参数一一对应;
-		 * 判据不在这里重复——服务端拒了就把问题清单原样亮出来。
-		 */
-		const OntoDrawer = ({ drawer, setDrawer, busy, error, onSubmit }) => {
-			const [form, setForm] = React.useState({ id: '', label: '', gloss: '', basis: '', parent: '', domain: '', unit: '', form: 'quantity', functional: false })
-			const field = (key, placeholder) =>
-				h('input', {
-					value: form[key] ?? '',
-					placeholder,
-					style: { ...S.chip, cursor: 'text', width: '100%' },
-					onInput: (event) => setForm({ ...form, [key]: event?.target?.value ?? '' }),
-				})
-			const isTerm = drawer.kind === 'term'
-			const entry = isTerm
-				? { id: form.id, label: form.label, gloss: form.gloss, basis: form.basis, parent: form.parent === '' ? undefined : form.parent }
-				: { id: form.id, label: form.label, gloss: form.gloss, basis: form.basis, domain: form.domain === '' ? undefined : form.domain, range: { form: form.form, unit: form.unit === '' ? undefined : form.unit }, functional: form.functional === true ? true : undefined }
-			return h(
-				'div',
-				{ style: S.chipCard },
-				h('div', { style: S.chipCardTitle }, isTerm ? t('登记概念') : t('登记谓词')),
-				field('id', 'id(snake_case)'),
-				field('label', isTerm ? t('名称') : t('名称')),
-				field('gloss', t('释义(一句话)')),
-				isTerm ? field('parent', `${t('父概念')} id(可选)`) : field('domain', `${t('主词域')} id(可选)`),
-				isTerm === true ? null : field('unit', `${t('单位')}(可选)`),
-				isTerm === true ? null : h('label', { style: S.faint }, h('input', { type: 'checkbox', checked: form.functional === true, onChange: (event) => setForm({ ...form, functional: event?.target?.checked === true }) }), ` ${t('单值')}`),
-				field('basis', `${t('依据')}(必填)`),
-				error === null ? null : h('div', { style: { color: '#dc2626', fontSize: 11 } }, String(error)),
-				h('div', { style: S.chipActions },
-					h('span', { style: S.chipAction, onClick: busy === true ? undefined : () => onSubmit(isTerm === true ? 'register_term' : 'register_predicate', entry) }, busy === true ? t('提交中…') : t('提交')),
-					h('span', { style: S.chipAction, onClick: () => setDrawer(null) }, t('取消')),
-				),
-			)
-		}
-
-		const LocalizedDeliverables = withLocale(Deliverables)
-		const LocalizedFacts = withLocale(Facts)
+		const LocalizedFacts = withLocale(Atlas)
 		const LocalizedWorldTree = withLocale(WorldTree)
-		const LocalizedBrainTab = withLocale(BrainTab)
 
 		/** 会话预设的 id:面板只在这个模式的会话里出现。 */
 		const PRESET_ID = 'clearai'
@@ -4052,8 +2374,7 @@ window.__ModuleLoader__.load({
 			 * 右栏页签却是 Worldlines)。惰性取值让原生每次渲染现问一次,切换语言立刻跟上。
 			 */
 			const rightRail = [
-				{ id: 'clearai-worldtree', kind: 'clearai-worldtree', label: () => t('世界树'), order: 15, description: () => t('计划的拓扑与闸门:脊柱步、车道、收敛点、人工决策点'), icon: NATIVE_ICONS.IconBranchOutline16 },
-				{ id: 'clearai-brain', kind: 'clearai-brain', label: () => t('技能 · 记忆'), order: 20, description: () => t('合并目录、本会话用法、可引用可采纳'), icon: NATIVE_ICONS.IconSkillOutline16 },
+				{ id: 'clearai-worldtree', kind: 'clearai-worldtree', label: () => t('世界树'), order: 15, description: () => t('计划的步骤与闸门'), icon: NATIVE_ICONS.IconBranchOutline16 },
 			]
 			const shown = new Set()
 			const syncRail = () => {
@@ -4084,8 +2405,7 @@ window.__ModuleLoader__.load({
 					}
 					const body =
 						tab.body ??
-						(tab.id === 'clearai-worldtree'
-							? (props) =>
+						((props) =>
 									h(LocalizedWorldTree, {
 										...props,
 										openPreview: openPreviewFor(props),
@@ -4106,8 +2426,7 @@ window.__ModuleLoader__.load({
 												return false
 											}
 										},
-									})
-							: (props) => h(LocalizedBrainTab, { ...props, isCurrentPreset, openRail, openPreview: openPreviewFor(props) }))
+									}))
 					own.push(ctx.effect(() => slots.inject('sidebar.right.pane.tab', () => slots.register({ name: 'sidebar.right.pane.tab', key: tab.id }, body)), `clearai: rail body ${tab.id}`))
 					own.push(ctx.effect(() => slots.inject('sidebar.right.pane.tab.title', () => slots.register({ name: 'sidebar.right.pane.tab.title', key: tab.id }, () => tab.label)), `clearai: rail title ${tab.id}`))
 					railDisposers.set(tab.id, () => {
@@ -4124,7 +2443,7 @@ window.__ModuleLoader__.load({
 			const railDisposers = new Map()
 
 			/**
-			 * 打开右栏的某张页签(跨面跳转:点「需要你 N」→ 进展)。
+			 * 打开右栏的某张页签(跨面跳转:点「待处理 N」→ 进展)。
 			 * 不再有我们自己的「预览」页签了:预览走**原生**的文档预览(`openNativePreview`)——
 			 * 那一条既有 markdown/图片/pdf/html 的渲染,也有它自己的分页读盘。
 			 */
@@ -4162,15 +2481,8 @@ window.__ModuleLoader__.load({
 			/** 每个座位按自己的 props 造一个打开器:共用一个「反正差不多」的闭包就是上面那个 bug。 */
 			const openPreviewFor = (props) => (path) => openNativePreview(sidebarRight, sessionIdFor(props), path)
 
-			/**
-			 * 中栏视图:**产物**(中栏第一眼该看「我拿到了什么」)。
-			 * 原来占着中栏的「循环」面板搬进右栏「进展」——那种全景适合与对话并排,
-			 * 而中栏这个位子(native 已有 chat / trajectory)该留给**结果**。
-			 */
-			occupy('conversation.view', () => ({ id: 'clearai-deliverables', order: 15, label: t('产物') }), (props) => h(LocalizedDeliverables, { ...props, openRail, openPreview: openPreviewFor(props) }))
 			/**
 			 * 中栏视图:**事实**——整条闭环一屏看完(假设是起点,事实是沉淀)。
-			 * 放在「产物」之后:先看拿到了什么,再看**凭什么**(以及已经确认了什么)。
 			 * 这一格与模型读的 `clear/knowledge/facts/INDEX.md` 是**同一张表**。
 			 */
 			/**
@@ -4200,17 +2512,11 @@ window.__ModuleLoader__.load({
 			 * 而我们只在**当前会话是本预设**时占座(`occupy`),会话切走就还给它。
 			 */
 			occupy('conversation.input.plan', { priority: -1 }, (props) => h(PlanChip, { ...props, openRail }))
-			occupy('conversation.input.left', { id: 'clearai-continuation', order: 110 }, (props) => h(ContinuationNote, props))
-			/**
-			 * **续跑档控制搬进工具行**(控制归工具行,事实归输入框下方)。
-			 * `conversation.input.left` 是**加法**座位(list),与原生「完全权限」并排——
-			 * 同一类东西(我能改的)放同一行,这是原生的排版,不是我们发明的。
-			 */
 			// 输入框下方的常驻派生条(运行态卡在人这一侧的对应物)
 			/**
 			 * **输入框下那一条不再注册**:它说的话(阶段 / 完成度 / 当前步)与原生目标提示、
 			 * 与工具行那颗计划 chip 重复 ✗,却**独占一行把输入框顶上去** ✗。
-			 * 唯一可点、且只有我们知道的那件事(「需要你 N」)已经并进计划 chip(同一行,一点直达世界树)。
+			 * 唯一可点、且只有我们知道的那件事(「待处理 N」)已经并进计划 chip(同一行,一点直达世界树)。
 			 */
 			ctx.effect(() => sessions.list.subscribe(() => {
 				for (const sync of seats) sync()
@@ -4232,12 +2538,12 @@ window.__ModuleLoader__.load({
 		 * 真的跑一遍渲染路径(捕 undefined 字段访问这类只有渲染时才炸的错)。
 		 * 仍然不是给别的包用的接口。
 		 */
-		exports.__components = { PlanChip, ContinuationNote, Deliverables, WorldTree, BrainTab, GraphBand, GraphInspector, VocabBlock, AssertionChips, Inbox, TreeDetail, Facts, FactShelf, PropositionShelf, PropositionRow, GapShelf, LevelGuide, ClearAIMark, LOOP_LABEL, PROPOSITION_GROUPS }
+		exports.__components = { PlanChip, WorldTree, GraphBand, GraphInspector, NeedYou, TreeDetail, Atlas, AtlasHeader, ConclusionList, ConclusionRow, ConclusionDetail, StationBar, TrustTimeline, ClearAIMark, LOOP_LABEL }
 		/**
 		 * 测试缝之三:命题那一列的**派生**是纯函数(分组、处境、来路、证据链),
 		 * 渲染本身没法在没浏览器的地方细究——把它导出去,让测试直接断言派生结果。
 		 */
-		exports.__propositions = { evidenceOf, transitionsOf, whereOf, judgeOf, originsOf, stepOfFact }
+		exports.__propositions = { evidenceOf, originsOf, stepOfFact, conclusionsOf }
 		/** 测试缝之四:本体格的过滤判据(纯函数)。 */
 		exports.__ontology = { termMatches }
 		return module.exports