clearai-dsh 0.3.1 → 0.5.0

package/lib/fold.js

@@ -16,11 +16,9 @@
  * 与预设内核的契约:`meta = { kind: 'clearai', v: 1, mutation: { t, ... } }`。
  * 词汇表由本文件的 `applyMutation` 定义;预设侧只负责产出,不负责解释。
  */
-import { applyLexiconMutation, deriveConflicts, emptyLexicon, formatAssertion, graphProjection, lexiconHealth, normalizeLexicon, objectKey, termUsage, VALUE_FORMS } from './domain-language.js'
-import { knowledgeView } from './knowledge-view.js'
-
-/** 世界线分支状态的秩。秩只增;一旦出现 adopted,整个分叉的分支状态冻结。 */
-const BRANCH_RANK = { exploring: 0, evaluated: 1, adopted: 2, pruned: 2 }
+import { applyLexiconMutation, changedDefinitions, materializeOntology, classifyWorkspacePath, deriveConflicts, emptyLexicon, factFromFile, formatAssertion, lessonFromFile, graphProjection, lexiconHealth, normalizeLexicon, objectKey, termUsage, VALUE_FORMS } from './domain-language.js'
+import { handleOf, knowledgeView, trustOf } from './knowledge-view.js'
+import { bilingual, detectLanguage, messageText, tr, withLanguage } from './lang.js'
 
 /** 五个等级,由低到高。等级是「这条证据有多大程度只能靠信任做的人」的刻度(见 docs/verification-loop.md 的等级表)。 */
 const LEVELS = ['L0', 'L1', 'L2', 'L3', 'L4']
@@ -42,11 +40,35 @@ export const MUTATION_KIND = 'clearai'
  *           没有断言的事实照旧可读——形状变了才 +1,不是语义变了才 +1。
  *   v10 → v11:**实体账本**独立于目标裁决:`entities`(登记的实例)、`entityAssertions`
  *           (登记那一刻就成立的边)、`hostHealth`(宿主读面降级的账),以及
- *           `hypotheses[].skips`(跳级理由)与 `goal.criteriaHistory`(判据修订)。
+ *           `hypotheses[].skips`(跳级理由,v14 删)与 `goal.criteriaHistory`(判据修订)。
  *           旧日志这三块都是空表:实体图仍只从 `facts[].assertions` 长出来,逐字节不变。
- * 投影缓存按版本判定,所以旧缓存会被丢弃、从日志重折一遍——用量是**从日志折出来的**,重折才完整。
+ *   v11 → v12:**宿主已有的交还宿主**:分叉 / 世界线(`forks`)、侦察(`scouts`)、外脑与技能目录
+ *           (`brain`、`brainCandidates`、`skillPromotions`、`skillCatalog`、`skillUsage`)、章程读数
+ *           (`constitution`)与写入计数(`writeCalls`)都从状态里删了。旧日志里的对应事件类型
+ *           (`fork/*`、`worldline/*`、`scout/*`、`branch/*`、`git/*`、`clearai/brain` 段、相关人门动作)
+ *           不认识就原样跳过,其余部分照常折出来。
+ *   v12 → v13:**步骤完成与结果分开**:步骤的 `tests` 折成 `{hypotheses: id[], level}`(旧账的单条
+ *           `hypothesis` 照旧读);证据带上它针对的判断(`hypothesis`);`step/advanced` 带上交付本身
+ *           (`delivery`:谁判的、凭什么、出处),`step.evidence` 变成 id 数组;结算事实带上两项裁决
+ *           (`holds` / `results`)。
+ *   v13 → v14:**缺口与关口收窄**:跳级理由整套删除——假设上不再有 `skips`,派生里不再有
+ *           `untouchedLevels`;旧日志里的 `level/skipped` 不认识就原样跳过。缺口只留三种
+ *           (`untouched_claims`、`prose_only_claims`、`entities_unlanded`)。
+ *   v14 → v15:**攒下来的东西住在文件里**:多了 `workspace.files`(工作区里事实文件与本体文件
+ *           的内容快照,由 `workspace/synced` 折进来);事实带上 `definitions`(升格那一刻用到的
+ *           词条含义指纹)。派生的事实行合并其它会话留下的事实(`foreign`),并给出
+ *           `definitionsChanged`。本体(词汇、实体、实体关系)改为从本体文件折出来,跨文件问题记在
+ *           `ontologyProblems`。旧日志里没有这些,折出来就是空的。
+ *   v15 → v16:多了 `language`(人说话用的语言,从人的消息折出来):系统写给人的话、面板里的读数都跟着它。
+ *   v16 → v17:**预期与未解释**:步骤带 `expect`(`step/expected` 也能补写);多了 `anomalies`(未解释项,
+ *           `anomaly/opened` / `anomaly/resolved` 折进来,评估者报的随 `audit/settled` 一起来);目标带
+ *           `irreversible`(不可逆动作的命令特征);放行带 `action`。对手判断(`rival` / `split_by`)删了,
+ *           旧账里的这两格不再读。
+ *   v17 → v18:多了 `lessons`(经验:结案时经独立评估核过的「下次要留意什么」,`lesson/recorded` 折进来;
+ *           别的会话留下的从 `clear/knowledge/lessons/<id>.json` 经 `workspace/synced` 进来)。
+ * 投影缓存按版本判定,所以旧缓存会被丢弃、从日志重折一遍。
  */
-export const STATE_VERSION = 11
+export const STATE_VERSION = 18
 
 /**
  * **只留台账、不折进视图**的变更类型(词汇表的另一半)。
@@ -56,11 +78,10 @@ export const STATE_VERSION = 11
  *   · 发行自检按它比对内核实际落的每一类事实 —— 既没折、又不在清单里的,是**真的缺口**;
  *   · 读代码的人不必逐条 grep 才知道哪些事实不上界面。
  *
- * 这四类都是**账本事实**:它们记「系统/账本做了什么」,不改变任何派生量
- * (准入检查、提交流水、快照、恢复),面板只展示当前可读取的证据与记录,
- * 而不是从投影里再长一份。
+ * 它们记「系统做了什么」(准入检查),不改变任何派生量。
+ * 旧日志里的 `git/*`(已删除的账本)不再列出:不认识的类型原样返回,本来就会被安静跳过。
  */
-export const LEDGER_ONLY_MUTATIONS = ['admission/checked', 'git/committed', 'git/restored', 'git/snapshot']
+export const LEDGER_ONLY_MUTATIONS = ['admission/checked']
 
 /** 空状态。`init` 与「日志里还没有任何变更」都必须给出同一个形状。 */
 export function emptyState() {
@@ -72,45 +93,15 @@ export function emptyState() {
 		audits: [],
 		materials: [],
 		facts: [],
-		forks: [],
-		/** 系统按触发派出去的侦察(子角色不是模型自由委派):结论进资料面,这里留一条记录 */
-		scouts: [],
-		/** 工作区里等人采纳的候选技能(内核扫描后落的事实)与已采纳的记录 */
-		brainCandidates: [],
-		skillPromotions: [],
-		/**
-		 * 外脑全景(技能清单 + 记忆索引)。**由内核扫描后随投影下发**——面板在浏览器里读不了盘,
-		 * 而内核每个 pre-step 都在扫;清单走投影(变了才发),正文才走宿主路由(点开时才读)。
-		 */
-		brain: null,
-		/**
-		 * 宿主原生的**合并技能目录**(预设自带 / 项目 / 用户 / 我们投影的 `clear/skills` 合并后的表)。
-		 * 内核每个 pre-step 调一次 `ctx.skills.snapshot`,变了才发——于是面板与模型看的是**同一张表**。
-		 */
-		skillCatalog: null,
-		/**
-		 * 本会话的技能加载记录。**纯派生,零新账**:
-		 * 模型加载 = 日志里的 `tool/call name='skill'`;人引用 = 一条含 `/名字` 的用户消息。
-		 */
-		skillUsage: {},
 		blocks: {},
 		releases: [],
 		/**
-		 * 运行档(人在场 / 无人值守)。**它是部署预设的初值,不是可切换的开关**:
-		 *   · 人门动词 `set_autonomy` 已摘除,面板上那个开关已经不存在;
-		 *   · `effective` = 内核随投影下发的那一份(只有内核知道组合配置),**只用于展示**;
-		 *   · `override`  = 历史日志里可能留下的人门记录。读取侧保留它只是为了旧会话仍然读得通,
-		 *     当前**没有任何写入者**——不要据此认为现在还能切换档位。
-		 *   · 它也不影响续跑:要不要继续由门状态算出来(见内核 turnDemand)。
-		 */
-		autonomy: { override: null, effective: null },
-		/**
-		 * 项目章程(`PROJECT.md`)的读数(内核扫描后随投影下发)。
-		 * 为什么要有它:章程的**读**侧早就接在原生指令文件上了,但**写**侧只有一句提示词——
-		 * 结果是跑完几轮、交付了产物,章程还是铺工作区那天的模板,谁也没发现——不提醒它就会一直漂着。
-		 * 事实摆在这里,人与模型都看得见「它还是不是空壳」。
+		 * **未解释项**(认识论里的「反常」):和预期或本体对不上的观测。只有三个去处:
+		 * 被解释(`explained`)、写明理由排除(`ruled_out`)、交给人(`escalated`);没去处的就是开着(`open`)。
 		 */
-		constitution: null,
+		anomalies: [],
+		/** **经验**:本会话结案写下的(别的会话的在工作区文件里,派生时合进来)。 */
+		lessons: [],
 		/**
 		 * **本体形状**:内核随投影下发的那份声明(对象/状态/边/等级)。
 		 * 为什么进投影而不是在界面里手抄:面板那一格的页眉要从**声明**生成——
@@ -149,87 +140,38 @@ export function emptyState() {
 		 */
 		hostHealth: [],
 		/**
-		 * **续跑窗口的账**:我们向平台说过的那句话——「这个窗口归我布防 / 我按了暂停 /
-		 * 我收兵了 / 它不在了而那不是我们干的」。形状见 `applyMutation` 的 `continuation/set`。
+		 * **工作区文件快照**(`workspace/synced`):路径 → `{ digest, data }` 或 `{ digest, error }`。
 		 *
-		 * 为什么它必须在投影里而不是内核内存里:宿主的 `paused` 相位分不清「人按的」与
-		 * 「策略按的」,而这两者的处置正好相反(人按的绝不覆盖,自己按的要能恢复)。
-		 * 只记在内存里,一次重启就把我们自己的暂停误报成人的暂停——那是一句**不实的话**;
-		 * 而「我们说过的话要有账」本来就是这套设计的纪律(意图工具不能断言事实)。
+		 * 攒下来的东西(事实、本体)住在项目文件里,跨会话活着;而投影只吃账本。内核每一拍把
+		 * 这两处的**变化**折成一条变更,于是文件内容也是账本里一条可重放的事实——重放、分叉、
+		 * 离线复判读到的都是那一刻的文件,而不是此刻盘上的。
+		 */
+		workspace: { files: {} },
+		/**
+		 * **本体文件的跨文件问题**(第二道校验,只提示):引用断了、类型对不上、单值关系两个取值……
+		 * 有问题的节点或边不进图,问题列在这里,卡片与本体页都读它。
 		 */
-		continuation: null,
+		ontologyProblems: [],
+		/**
+		 * **人说话用的语言**('zh' / 'en';还没听到人说话时为 null)。从人的消息里折出来:
+		 * 工具结果、运行态卡、面板读数都跟着它(见 `lang.js`)。
+		 */
+		language: null,
 		/** 正在飞的工具调用(来自 tool/call):让「评估者在裁决」成为一条可看见的事实 */
 		inFlight: null,
 		/** 本会话自己写过的路径(来自 tool/call 的 write/edit):L4 来源分离的判据 */
 		written: [],
-		/**
-		 * **会改工作区的工具调用**的一次计数(来自 tool/call 的 write/edit/bash/pwsh)。
-		 *
-		 * 为什么要有它:`written` 只认 write/edit,而探索最常走 bash(脚本自己产出文件),
-		 * 于是「这个会话到底动过工作区没有」用 `written` 答不全。内核在**回合边界**上要问的
-		 * 正是这一句(是否值得记一次工作区快照),所以这里记一个只增的计数——
-		 * 它是日志折出来的,可重放,不是第二本账。
-		 */
-		writeCalls: 0,
 	}
 }
 
 /**
- * 等裁决的三个工具:它们的调用在飞时,派生阶段是 `auditing`。
+ * 等裁决的工具:它们的调用在飞时,派生阶段是 `auditing`。`CloseGoal` 是 `Conclude` 的旧名,留着让旧日志照样折。
  * 其余工具不等外部裁决,不该让面板在每次调用时跳一下。
  */
-const VERDICT_WAITERS = new Set(['AdvancePlan', 'AdvanceWorldline', 'CloseGoal'])
+const VERDICT_WAITERS = new Set(['AdvancePlan', 'Conclude', 'CloseGoal'])
 
 /** 记下来的自写路径有上限:它是判据,不是档案(档案在会话日志里)。 */
 const MAX_WRITTEN = 512
-/**
- * 会**改工作区**的工具名。`bash`/`pwsh` 也算:脚本自己产出文件,内核分辨不了只读与写入,
- * 所以宁可偏保守——多记一笔快照,也不漏掉探索产出。
- */
-const WRITE_CAPABLE_TOOLS = new Set(['write', 'edit', 'bash', 'pwsh'])
-
-/**
- * 技能引用手势:与原生 `dsh-tool-skill` 的 `SKILL_GESTURE` **同一条正则**。
- *
- * 为什么不各写一条:这条正则是「技能正文会不会被注入」的**充要条件**
- * (`dsh-tool-skill/lib/index.js` 的 `invokedSkillNames`:只认 `source.kind === 'user'` 的
- * 文本块)。面板数出来的用法与原生真的做了什么必须是同一件事,否则读数就是编的。
- */
-const SKILL_GESTURE = /(^|\s)\/([a-z0-9]+(?:-[a-z0-9]+)*)(?=\s|$)/g
-/** 每条技能留最近几次记录(用量是判据不是档案;要全量去会话日志里查)。 */
-const MAX_SKILL_EVENTS = 8
-/** 最多跟踪多少条技能,免得一个失控的会话把投影撑大。 */
-const MAX_SKILLS_TRACKED = 64
-
-/** 从一条消息的文本块里取出被引用的技能名(与原生同一条正则、同一套去重)。 */
-function invokedSkillNames(message) {
-	const names = []
-	for (const block of Array.isArray(message?.content) ? message.content : []) {
-		if (block?.type !== 'text' || typeof block.text !== 'string') continue
-		for (const match of block.text.matchAll(SKILL_GESTURE)) if (match[2] !== undefined && !names.includes(match[2])) names.push(match[2])
-	}
-	return names
-}
-
-/** 这一次加载落在哪一步上(「在第 3 步」这个指针的由来)。 */
-function stepPointer(state) {
-	const plan = state.plans.find((item) => item.status === 'active') ?? null
-	if (plan === null) return { plan: null, step: null, ordinal: null }
-	const step = plan.steps.find((item) => item.status === 'open') ?? null
-	return { plan: plan.id, step: step === null ? null : step.id, ordinal: step === null ? null : step.ordinal }
-}
-
-function recordSkillUse(state, name, by, at, pointer) {
-	const usage = state.skillUsage ?? (state.skillUsage = {})
-	if (usage[name] === undefined && Object.keys(usage).length >= MAX_SKILLS_TRACKED) return
-	const entry = usage[name] ?? { name, model: 0, human: 0, events: [], lastAt: null }
-	if (by === 'model') entry.model += 1
-	else entry.human += 1
-	entry.events.push({ by, at, plan: pointer.plan, step: pointer.step, ordinal: pointer.ordinal })
-	if (entry.events.length > MAX_SKILL_EVENTS) entry.events.splice(0, entry.events.length - MAX_SKILL_EVENTS)
-	entry.lastAt = at
-	usage[name] = entry
-}
 
 /** 深拷贝(状态是纯 JSON,这是唯一需要的工具)。 */
 function clone(value) {
@@ -257,6 +199,16 @@ function factFromHypothesis(facts, goalId, hypothesisId, claim) {
 	})
 }
 
+/**
+ * 步骤检验的判断一律折成 `{hypotheses: id[], level}`:新账写 `hypotheses`(可多条),
+ * 旧账只有单条 `hypothesis`。读面只认这一种形状。
+ */
+export function normalizeTests(tests) {
+	if (tests === undefined || tests === null || typeof tests !== 'object') return null
+	const hypotheses = Array.isArray(tests.hypotheses) ? tests.hypotheses.map(String) : typeof tests.hypothesis === 'string' && tests.hypothesis !== '' ? [tests.hypothesis] : []
+	return { hypotheses, level: tests.level ?? null }
+}
+
 function appendSteps(plan, rawSteps) {
 	for (const raw of rawSteps) {
 		plan.steps.push({
@@ -265,7 +217,9 @@ function appendSteps(plan, rawSteps) {
 			do: raw.do,
 			artifacts: raw.artifacts ?? [],
 			done_criteria: raw.done_criteria,
-			tests: raw.tests ?? null,
+			tests: normalizeTests(raw.tests),
+			/** 动手前写下的预期(可选);落空的地方记成未解释项。 */
+			expect: typeof raw.expect === 'string' && raw.expect !== '' ? raw.expect : null,
 			status: 'open',
 			evidence: null,
 			advancedAt: null,
@@ -287,6 +241,7 @@ export function applyMutation(state, mutation) {
 	if (mutation === null || typeof mutation !== 'object' || typeof mutation.t !== 'string') return state
 	const at = typeof mutation.at === 'number' ? mutation.at : 0
 	const next = clone(state)
+	if (!Array.isArray(next.anomalies)) next.anomalies = []
 	const RANK = { open: 0, blocked: 0, advanced: 1, void: 1 }
 	const settle = (step, status) => {
 		if (step === undefined || step === null) return
@@ -304,6 +259,7 @@ export function applyMutation(state, mutation) {
 				previous.claim = mutation.claim
 				previous.done_criteria = mutation.done_criteria
 				previous.promote_at_level = mutation.promote_at_level
+				if (Array.isArray(mutation.irreversible)) previous.irreversible = clone(mutation.irreversible)
 				/** 修订可以带上新的速览与判据清单(没带就保持旧值——「不提供」不等于「清空」)。 */
 				if (typeof mutation.headline === 'string' && mutation.headline !== '') previous.headline = mutation.headline
 				if (Array.isArray(mutation.criteria)) previous.criteria = clone(mutation.criteria)
@@ -316,6 +272,8 @@ export function applyMutation(state, mutation) {
 					claim: mutation.claim,
 					done_criteria: mutation.done_criteria,
 					promote_at_level: mutation.promote_at_level,
+					/** 不可逆动作:`{action, command}`,命令里出现 `command` 那段原文就要人放行。 */
+					irreversible: Array.isArray(mutation.irreversible) ? clone(mutation.irreversible) : [],
 					status: 'open',
 					revision: mutation.revision ?? 1,
 					reasons: [mutation.reason ?? null],
@@ -357,14 +315,20 @@ export function applyMutation(state, mutation) {
 					if (String(known.claim ?? '') !== claim) continue
 					known.refute_when = hypothesis.refute_when
 					known.version = hypothesis.version ?? known.version
+					if (typeof hypothesis.name === 'string' && hypothesis.name !== '') known.name = hypothesis.name
+					if (typeof hypothesis.retests === 'string' && hypothesis.retests !== '') known.retests = hypothesis.retests
 					if (Array.isArray(hypothesis.assertions)) known.assertions = clone(hypothesis.assertions)
 					continue
 				}
 				next.hypotheses.push({
 					id: hypothesis.id,
 					goal: mutation.id,
+					/** 短名(第六阶段起,模型自己起);旧日志没有它,读的一侧取主张开头。 */
+					...(typeof hypothesis.name === 'string' && hypothesis.name !== '' ? { name: hypothesis.name } : {}),
 					claim,
 					refute_when: hypothesis.refute_when,
+					/** 复检的是哪条已有事实(事实 id;可以是别的会话留下的)。 */
+					...(typeof hypothesis.retests === 'string' && hypothesis.retests !== '' ? { retests: hypothesis.retests } : {}),
 					status: 'proposed',
 					version: hypothesis.version ?? 1,
 					/**
@@ -372,12 +336,6 @@ export function applyMutation(state, mutation) {
 					 * 不写断言照旧成立(宽松+校验);写了就是「这条主张用这门语言怎么说」。
 					 */
 					assertions: Array.isArray(hypothesis.assertions) ? clone(hypothesis.assertions) : null,
-					/**
-					 * **跳级理由**(`level/skipped` 折进来)。跳级本身不违规(首次测量没有廉价路
-					 * 可走),但「我直接上了 L3、下面几级从没走过」必须能说清为什么不适用——
-					 * 理由落在这里,`derive()` 会把被理由覆盖的层从 `untouchedLevels` 里减掉。
-					 */
-					skips: [],
 					at,
 				})
 			}
@@ -423,31 +381,12 @@ export function applyMutation(state, mutation) {
 				closedAt: null,
 				summary: null,
 				blocked: undefined,
-				/**
-				 * 授权记号(ClearAI `plan.confirmed_at` / `confirmed_by`)。
-				 * 两种取得方式,都可考:**显式动作**(人在原生审阅卡上批准 → `by:'user'`)与
-				 * **行为**(交付过一步 → `by:'progress'`,见内核 AdvancePlan)。
-				 * 第三种来源 `by:'autonomy'`(无人值守档在立约时自动确认)**已删除**:
-				 * 那会让「计划经人确认」这条证据变成系统自己签的。读取侧不需要兼容它,
-				 * 因为删除发生在写入侧,历史日志里最多出现 `user` 与 `progress`。
-				 * 注意这是一个**记号**,不是闸门:没确认的计划照样能被交付推起来,那一刻记号按事实补写。
-				 */
-				confirmed_at: mutation.confirmed_at ?? null,
-				confirmed_by: mutation.confirmed_by ?? null,
 				steps: [],
 			}
 			next.plans.push(plan)
 			appendSteps(plan, mutation.steps ?? [])
 			break
 		}
-		case 'plan/confirmed': {
-			// 第一次授权为准(`stamp_confirmed_by_progress` 同款幂等:已确认就不再改写)。
-			const plan = planOf(mutation.plan)
-			if (plan === undefined || plan.confirmed_at !== null) break
-			plan.confirmed_at = mutation.at ?? new Date(at).toISOString()
-			plan.confirmed_by = mutation.by ?? 'user'
-			break
-		}
 		case 'plan/amended': {
 			const plan = planOf(mutation.plan)
 			if (plan === undefined || plan.status !== 'active') break
@@ -461,6 +400,44 @@ export function applyMutation(state, mutation) {
 			step.criteria_versions.push(mutation.new_criteria) // 旧版本留着,什么都不删
 			break
 		}
+		case 'step/expected': {
+			const step = stepOf(mutation.plan, mutation.step)
+			if (step === undefined || step.status !== 'open') break
+			step.expect = String(mutation.expect ?? '') || null
+			break
+		}
+		case 'anomaly/opened': {
+			if (next.anomalies.some((item) => item.id === mutation.id)) break
+			next.anomalies.push({ id: mutation.id, what: String(mutation.what ?? ''), anchor: mutation.anchor ?? null, step: mutation.step ?? null, by: mutation.by ?? 'model', status: 'open', reason: null, explainedBy: null, at, resolvedAt: null })
+			break
+		}
+		case 'lesson/recorded': {
+			if (!Array.isArray(next.lessons)) next.lessons = []
+			if (next.lessons.some((item) => item.id === mutation.id)) break
+			next.lessons.push({
+				id: mutation.id,
+				goal: mutation.goal ?? null,
+				text: String(mutation.text ?? ''),
+				kind: mutation.kind ?? 'trap',
+				about: Array.isArray(mutation.about) ? mutation.about.map(String) : [],
+				evidence: mutation.evidence ?? null,
+				boundary: mutation.boundary ?? null,
+				status: 'active',
+				path: mutation.path ?? null,
+				at,
+			})
+			break
+		}
+		case 'anomaly/resolved': {
+			const item = next.anomalies.find((entry) => entry.id === mutation.id)
+			if (item === undefined || item.status !== 'open') break
+			if (!['explained', 'ruled_out', 'escalated'].includes(mutation.outcome)) break
+			item.status = mutation.outcome
+			item.reason = mutation.reason ?? null
+			item.explainedBy = mutation.by ?? null
+			item.resolvedAt = at
+			break
+		}
 		case 'plan/voided': {
 			const step = stepOf(mutation.plan, mutation.step)
 			if (step === undefined) break
@@ -503,7 +480,6 @@ export function applyMutation(state, mutation) {
 				note: mutation.note ?? null,
 				path: mutation.path ?? null,
 				step: mutation.step ?? null,
-				branch: mutation.branch ?? null,
 				at,
 			})
 			break
@@ -560,11 +536,21 @@ export function applyMutation(state, mutation) {
 			const audit = next.audits.find((item) => item.id === mutation.id)
 			if (audit !== undefined) {
 				audit.verdict = mutation.verdict
+				/** 两项裁决:交付成立吗 + 每条判断的结果。旧账没有这两格,`verdict` 那时说的就是交付成立吗。 */
+				audit.holds = mutation.holds ?? null
+				audit.results = Array.isArray(mutation.results) ? mutation.results : []
 				audit.shortfalls = mutation.shortfalls ?? []
 				audit.basis = mutation.basis ?? null
 				audit.card_path = mutation.card_path ?? null
 				if (mutation.digest !== undefined) audit.digest = mutation.digest ?? null
 			}
+			/** 评估者报的、做的人没登记的异常:记成未解释项(id 由裁决 id 派生,重放幂等)。 */
+			const found = Array.isArray(mutation.anomalies) ? mutation.anomalies : []
+			for (const [index, item] of found.entries()) {
+				const id = `${mutation.id}#u${index + 1}`
+				if (next.anomalies.some((entry) => entry.id === id)) continue
+				next.anomalies.push({ id, what: String(item?.what ?? ''), anchor: null, step: mutation.step ?? null, by: 'evaluator', matters: item?.matters ?? null, status: 'open', reason: null, explainedBy: null, at, resolvedAt: null })
+			}
 			break
 		}
 		case 'evidence/recorded': {
@@ -572,7 +558,8 @@ export function applyMutation(state, mutation) {
 				id: mutation.id,
 				step: mutation.step,
 				plan: mutation.plan,
-				branch: mutation.branch ?? null,
+				/** 针对哪条判断;旧账没有这一格(`undefined`),按步骤检验的判断找回来。 */
+				hypothesis: mutation.hypothesis,
 				verdict: mutation.verdict,
 				level: mutation.level,
 				evaluator: mutation.evaluator,
@@ -595,24 +582,27 @@ export function applyMutation(state, mutation) {
 			const step = stepOf(mutation.plan, mutation.step)
 			if (step !== undefined) {
 				settle(step, 'advanced')
-				step.evidence = mutation.evidence
+				/** 新账是证据 id 的数组(每条判断一份,不检验判断就是空数组);旧账是单个 id。 */
+				step.evidence = Array.isArray(mutation.evidence) ? mutation.evidence : mutation.evidence === undefined || mutation.evidence === null ? [] : [mutation.evidence]
+				/** 交付本身:谁判的、凭什么、出处。旧账没有,读面退回到证据。 */
+				step.delivery =
+					mutation.evaluator === undefined
+						? null
+						: { evaluator: mutation.evaluator, basis: mutation.basis ?? null, refs: Array.isArray(mutation.refs) ? mutation.refs : [], origins: Array.isArray(mutation.origins) ? mutation.origins : [] }
 				step.advancedAt = at
 			}
 			break
 		}
 		case 'human/released': {
-			/**
-			 * 放行绑在**哪条轴**上要说清:主线绑步骤、世界线绑分支。
-			 * `via` 记它凭什么算数——现在只有 `approval`(原生审批栈的权威记录),不推断。
-			 */
+			/** `via` 记它凭什么算数——现在只有 `approval`(原生审批栈的权威记录),不推断。 */
 			next.releases.push({
 				step: mutation.step ?? null,
 				plan: mutation.plan ?? null,
-				fork: mutation.fork ?? null,
-				branch: mutation.branch ?? null,
 				via: mutation.via ?? null,
 				at,
 				call: mutation.call ?? null,
+				/** 放行的是哪件不可逆动作(拦在命令上的那道门);步级放行没有这一格。 */
+				...(typeof mutation.action === 'string' && mutation.action !== '' ? { action: mutation.action } : {}),
 			})
 			break
 		}
@@ -633,10 +623,47 @@ export function applyMutation(state, mutation) {
 				evidence: mutation.evidence ?? [],
 				path: mutation.path ?? null,
 				assertions: Array.isArray(mutation.assertions) ? clone(mutation.assertions) : null,
+				/** 升格那一刻,断言用到的词条各自的含义指纹:之后定义改了,这条事实要复核。 */
+				definitions: mutation.definitions !== null && typeof mutation.definitions === 'object' && !Array.isArray(mutation.definitions) ? clone(mutation.definitions) : null,
 				at,
 			})
 			break
 		}
+		/**
+		 * **工作区同步**(`workspace/synced`,内核发):事实文件与本体文件这一拍的变化。
+		 * 每条 change 是一个文件的新样子(`data` 或读不成时的 `error`),或 `removed`。
+		 * 按路径覆盖,所以同一批变化折两遍结果一样。
+		 */
+		case 'workspace/synced': {
+			const files = next.workspace !== null && typeof next.workspace === 'object' && next.workspace.files !== null && typeof next.workspace.files === 'object' ? next.workspace.files : {}
+			next.workspace = { ...(next.workspace ?? {}), files }
+			for (const change of Array.isArray(mutation.changes) ? mutation.changes : []) {
+				const path = typeof change?.path === 'string' ? change.path : ''
+				if (path === '') continue
+				if (change.removed === true) {
+					delete files[path]
+					continue
+				}
+				files[path] = change.error !== undefined && change.error !== null ? { digest: change.digest ?? null, error: String(change.error) } : { digest: change.digest ?? null, data: change.data ?? null }
+			}
+			/**
+			 * **本体从文件折出来**:词汇、实体、实体断言整份按文件重算——文件就是权威,
+			 * 账本里只记「那一刻文件是什么样」。旧会话里工具写下的本体事件仍折得出来,
+			 * 但一旦这个会话同步过本体文件,就以文件为准(旧会话不迁移)。
+			 */
+			const touchedOntology = (mutation.changes ?? []).some((change) => {
+				const kind = classifyWorkspacePath(change?.path)?.kind
+				return kind !== undefined && kind !== 'fact' && kind !== 'lesson'
+			})
+			if (touchedOntology || Object.keys(files).some((path) => !['fact', 'lesson'].includes(classifyWorkspacePath(path)?.kind))) {
+				const ontology = materializeOntology(files)
+				next.lexicon = ontology.lexicon
+				next.entities = ontology.entities
+				next.entityAssertions = ontology.entityAssertions
+				next.ontologyProblems = ontology.problems
+			}
+			break
+		}
 		case 'fact/reviewed': {
 			/**
 			 * **人审查过一条被推翻标记的事实**:撤回它,或判证据不可靠、维持原事实。
@@ -650,260 +677,6 @@ export function applyMutation(state, mutation) {
 			fact.review = { decision: mutation.decision === 'retracted' ? 'retracted' : 'kept', reason: mutation.reason ?? null, at, by: mutation.by ?? 'user' }
 			break
 		}
-		case 'worldline/prepared': {
-			const fork = next.forks.find((item) => item.id === mutation.fork)
-			if (fork === undefined) break
-			fork.tier = mutation.tier
-			fork.base = mutation.base ?? null
-			fork.degradedReason = mutation.reason ?? null
-			for (const entry of mutation.branches ?? []) {
-				const branch = fork.branches.find((item) => item.id === entry.id)
-				if (branch !== undefined) {
-					branch.worktree_path = entry.path
-					branch.git_branch = entry.branch
-					branch.worktree_removed = false
-				}
-			}
-			break
-		}
-		case 'fork/merge_skipped': {
-			const fork = next.forks.find((item) => item.id === mutation.fork)
-			if (fork === undefined) break
-			fork.mergeSkipped = { branch: mutation.branch ?? null, reason: mutation.reason ?? null }
-			break
-		}
-		case 'worldline/executing': {
-			const fork = next.forks.find((item) => item.id === mutation.fork)
-			const branch = fork?.branches.find((item) => item.id === mutation.branch)
-			if (branch === undefined) break
-			branch.execution = { child: mutation.child ?? null, capability: mutation.capability ?? null, ok: null, conclusion: null }
-			break
-		}
-		case 'worldline/executed': {
-			const fork = next.forks.find((item) => item.id === mutation.fork)
-			const branch = fork?.branches.find((item) => item.id === mutation.branch)
-			if (branch === undefined) break
-			branch.execution = { ...(branch.execution ?? { child: mutation.child ?? null, capability: null }), ok: mutation.ok === true, conclusion: mutation.conclusion ?? null, note: mutation.note ?? null }
-			break
-		}
-		case 'worldline/removed': {
-			const fork = next.forks.find((item) => item.id === mutation.fork)
-			const branch = fork?.branches.find((item) => item.id === mutation.branch)
-			if (branch === undefined) break
-			branch.worktree_removed = true
-			branch.kept_ref = mutation.kept_ref !== false
-			break
-		}
-		case 'fork/merged': {
-			const fork = next.forks.find((item) => item.id === mutation.fork)
-			if (fork === undefined) break
-			fork.merge = {
-				branch: mutation.branch,
-				commit: mutation.commit ?? null,
-				mode: mutation.mode ?? 'merged',
-				snapshotCommit: mutation.snapshot_commit ?? null,
-				// 临时采纳 = 分差不足以称结论(或由判断而来):它不是结论,是待复核的决定。
-				provisional: mutation.provisional === true,
-				by: mutation.by ?? 'metric',
-				decisionNote: mutation.decision_note ?? null,
-				margin: mutation.margin ?? null,
-			}
-			fork.mergeConflict = null
-			break
-		}
-		case 'fork/merge_conflict': {
-			const fork = next.forks.find((item) => item.id === mutation.fork)
-			if (fork === undefined) break
-			fork.mergeConflict = { branch: mutation.branch, winner: mutation.winner ?? null, margin: mutation.margin ?? null, detail: mutation.detail ?? null }
-			break
-		}
-		case 'scout/dispatched': {
-			next.scouts.push({
-				id: mutation.id,
-				step: mutation.step,
-				plan: mutation.plan ?? null,
-				trigger: mutation.trigger ?? null,
-				child: mutation.child ?? null,
-				capability: mutation.capability ?? null,
-				// 任务身份:同一个身份已经正常回灌过的,再派时会被复用而不是重跑(幂等派遣)。
-				digest: mutation.digest ?? null,
-				conclusion: null,
-				note: null,
-				path: null,
-				at,
-			})
-			break
-		}
-		case 'scout/settled': {
-			const scout = next.scouts.find((item) => item.id === mutation.id)
-			if (scout !== undefined) {
-				scout.conclusion = mutation.conclusion ?? null
-				scout.note = mutation.note ?? null
-				scout.path = mutation.path ?? null
-			}
-			break
-		}
-		case 'fork/created': {
-			if (next.forks.some((fork) => fork.step === mutation.step)) break // 一步只分叉一次
-			next.forks.push({
-				id: mutation.id,
-				step: mutation.step,
-				plan: mutation.plan,
-				question: mutation.question,
-				decide_by: mutation.decide_by,
-				settled: false,
-				abandoned: false,
-				abandonReason: null,
-				/** 横评仲裁的判决(`fork/arbitrated`)与它的会话 id(面板可旁观)。 */
-				arbitration: null,
-				arbitrationSession: null,
-				/** 人在面板上的裁决(结构化记录,by:'user');null = 还没裁。 */
-				humanDecision: null,
-				verdict: null,
-				undecidable: null,
-				/**
-				 * 算术算出来的推荐(`fork/recommended`):人裁决那条路上**唯一的输入**。
-				 * 它是事实(系统算过),不是状态——分支秩不动,收敛仍然只走 ConvergeFork。
-				 */
-				recommended: null,
-				recommendMargin: null,
-				recommendProvisional: false,
-				recommendBy: null,
-				/**
-				 * 采纳时**没能合并**的原因(`fork/merge_skipped`):面板据此说清「决定登记了,
-				 * 赢家的产物要靠一次普通交付落位」。不转发它,这句话就永远说不出来。
-				 */
-				mergeSkipped: null,
-				at,
-				branches: (mutation.options ?? []).map((option) => ({
-					id: option.id,
-					label: option.label,
-					approach: option.approach,
-					done_criteria: option.done_criteria,
-					workspace: option.workspace ?? null,
-					artifacts: option.artifacts ?? [],
-					level: option.level ?? 'L0',
-					status: 'exploring',
-					card_path: null,
-					evaluator_session: null,
-					humanDecision: null,
-				reading: null,
-					validity: null,
-					verdict: null,
-					basis: null,
-					evaluator: null,
-					evidence: null,
-					at: null,
-				})),
-			})
-			break
-		}
-		case 'branch/delivered': {
-			const fork = next.forks.find((item) => item.id === mutation.fork)
-			const branch = fork?.branches.find((item) => item.id === mutation.branch)
-			if (branch === undefined) break
-			if ((BRANCH_RANK[branch.status] ?? 0) < BRANCH_RANK.evaluated) branch.status = 'evaluated'
-			branch.reading = mutation.reading ?? null
-			branch.validity = mutation.validity ?? null
-			branch.verdict = mutation.verdict ?? null
-			branch.basis = mutation.basis ?? null
-			branch.evaluator = mutation.evaluator ?? null
-			branch.evidence = mutation.evidence ?? null
-			// 评估卡与评估者会话:仲裁用卡(注入),面板用会话(旁观入口)。
-			branch.card_path = mutation.card_path ?? null
-			branch.evaluator_session = mutation.evaluator_session ?? null
-			branch.at = at
-			break
-		}
-		case 'fork/recommended': {
-			/**
-			 * 算术算出来的推荐。**只记事实,不动状态**:分支秩不变、`settled` 不变——
-			 * 采纳永远还是要走 `ConvergeFork`(或人的一次裁决)。它存在的理由只有一个:
-			 * 人门卡与面板读的是投影里的这个字段,不落账它们就只能写「推荐:无」。
-			 */
-			const fork = next.forks.find((item) => item.id === mutation.fork)
-			if (fork === undefined) break
-			fork.recommended = mutation.branch ?? null
-			fork.recommendMargin = mutation.margin ?? null
-			fork.recommendProvisional = mutation.provisional === true
-			fork.recommendBy = mutation.by ?? null
-			break
-		}
-		case 'fork/converged': {
-			const fork = next.forks.find((item) => item.id === mutation.fork)
-			if (fork === undefined) break
-			fork.settled = true
-			fork.undecidable = null
-			fork.verdict = { winner: mutation.winner, margin: mutation.margin ?? null, tie: mutation.tie === true, metric: mutation.metric ?? null, direction: mutation.direction ?? null }
-			for (const branch of fork.branches) {
-				if ((BRANCH_RANK[branch.status] ?? 0) >= BRANCH_RANK.adopted) continue // 一旦采纳,状态冻结
-				branch.status = branch.id === mutation.winner ? 'adopted' : 'pruned'
-			}
-			break
-		}
-		case 'fork/arbitration_dispatched': {
-			const fork = next.forks.find((item) => item.id === mutation.fork)
-			if (fork === undefined) break
-			fork.arbitrationSession = mutation.arbiter_session ?? null
-			break
-		}
-		case 'fork/arbitrated': {
-			const fork = next.forks.find((item) => item.id === mutation.fork)
-			if (fork === undefined) break
-			// 判决写进节点(唯一真相仍是投影):采纳与否由内核重判一次决定,这里只记事实。
-			fork.arbitration = {
-				winner: mutation.winner ?? null,
-				ranking: mutation.ranking ?? [],
-				reason: mutation.reason ?? '',
-				confidence: mutation.confidence ?? 'low',
-				arbiter_session: mutation.arbiter_run_id ?? null,
-			}
-			break
-		}
-		case 'fork/undecidable': {
-			const fork = next.forks.find((item) => item.id === mutation.fork)
-			if (fork === undefined) break
-			fork.undecidable = { code: mutation.code, reason: mutation.reason, readings: mutation.readings ?? [] }
-			break
-		}
-		case 'fork/abandoned': {
-			const fork = next.forks.find((item) => item.id === mutation.fork)
-			if (fork === undefined) break
-			fork.abandoned = true
-			fork.abandonReason = mutation.reason ?? null
-			break
-		}
-		case 'continuation/set': {
-			/**
-			 * 续跑窗口的账。四种状态就是「我们说过的话」的全部:
-			 *   · `armed`     —— 我们布了防(或按策略恢复了它):此刻它在为我们跑。
-			 *   · `paused`    —— **我们**按下的暂停,`why` 是真实理由(等裁决 / 等人门 / 阶段边界)。
-			 *   · `stopped`   —— 我们收的兵(目标达成 / 如实放弃 / 计划触礁)。
-			 *   · `withdrawn` —— 它不在了,而**不是我们清的**(我们的清除永远与建同拍):
-			 *                    这是平台上唯一说得出口的解释,所以它也只说这些,不说「谁」干的。
-			 * 一条记录:**窗口在会话里是单数**,所以后一条覆盖前一条,不留历史(历史在会话日志里)。
-			 */
-			next.continuation = {
-				state: typeof mutation.state === 'string' ? mutation.state : 'unknown',
-				goal: mutation.goal ?? null,
-				target: mutation.target ?? null,
-				why: mutation.why ?? null,
-				/**
-				 * 平台对象上那句身份文本的**最后一次观测值**:我们写下它时记我们的,
-				 * 别人改写之后重记他的。判据是「平台上的文本 === 这条记录」⇒ 还是我们的。
-				 */
-				label: mutation.label ?? null,
-				at,
-			}
-			break
-		}
-		/**
-		 * **领域词汇的六个事件**:接纳 / 版本化修订 / 黏性废止(概念与谓词各三条)。
-		 *
-		 * 折法在这里只做解释:把事件折成 `lexicon`。校验(引用是否存在、形状对不对、
-		 * 语义变化有没有偷偷走修订)全部发生在**落账之前**——预设侧的工具与宿主路由
-		 * 用的是 `domain-language.js` 的同一份判据;折法不重复判一遍,否则两份判据必然漂。
-		 */
 		case 'ontology/term_added':
 		case 'ontology/predicate_added':
 		case 'ontology/term_revised':
@@ -972,19 +745,6 @@ export function applyMutation(state, mutation) {
 			})
 			break
 		}
-		/**
-		 * **跳级理由**(`level/skipped`):这一级为什么在本项目里不适用。
-		 *
-		 * 折法只记事实,不改派生:`derive()` 把被理由覆盖的层从 `untouchedLevels` 里减掉,
-		 * 于是「跳级没理由」这条缺口会自动消失——理由本身就是它的出口。
-		 */
-		case 'level/skipped': {
-			const hypothesis = next.hypotheses.find((item) => item.id === mutation.hypothesis)
-			if (hypothesis === undefined) break
-			hypothesis.skips = Array.isArray(hypothesis.skips) ? hypothesis.skips : []
-			hypothesis.skips.push({ levels: Array.isArray(mutation.levels) ? mutation.levels.slice() : [], reason: mutation.reason ?? null, at })
-			break
-		}
 		/**
 		 * **判据修订**(`criteria/revised`):改「怎样算完成」这件事本身。
 		 *
@@ -1063,6 +823,16 @@ function stampAt(mutations, time) {
  * 宿主读已发布 V3 日志时把旧形状抬升成 `plugin:clearai`;但事件被**直接**喂进这个纯函数时
  * (测试、旧导出、重放工具)仍带着旧形状,所以两侧都认。
  */
+/** 人写的一条消息是哪种语言(插件消息、续跑提示不算)。 */
+function humanLanguage(message) {
+	if (message === null || typeof message !== 'object' || message.role !== 'user') return null
+	const kind = message.source?.kind
+	if (kind !== undefined && kind !== 'user') return null
+	const text = messageText(message)
+	if (text.startsWith(HUMAN_GATE_MARK)) return null
+	return detectLanguage(text)
+}
+
 function isClearaiSource(source) {
 	if (source === null || typeof source !== 'object' || !Array.isArray(source.sections)) return false
 	return source.kind === 'plugin:clearai' || (source.kind === 'plugin' && source.plugin === 'clearai')
@@ -1078,6 +848,13 @@ function isClearaiSource(source) {
  */
 export function applyEvent(state, event) {
 	if (event === null || typeof event !== 'object') return state
+	// 人说话用的语言:每一条人写的消息都可能改判(没有信号就不改)。这一拍折出来的文字(本体问题等)也用它。
+	const spoken = event.type === 'user/message' ? humanLanguage(event.data) : null
+	const base = spoken !== null && spoken !== state?.language ? { ...state, language: spoken } : state
+	return withLanguage(base?.language, () => foldEvent(base, event))
+}
+
+function foldEvent(state, event) {
 	if (event.type === 'user/message') {
 		// 内核观察到的事实(候选技能、采纳记录、合并目录)走**插件消息的结构化 section**——
 		// 记在会话日志里,所以状态仍然可以从日志重放出来,而不是靠一句散文。
@@ -1100,8 +877,6 @@ export function applyEvent(state, event) {
 			 * 原来找到目录就 return,于是同一条消息里的**运行档被吃掉**,
 			 * 表现是投影里的 effective 档永远停在「还没定档」,而机制那边早就按新档跑了。
 			 */
-			const brain = source.sections.find((section) => section?.name === 'clearai/brain')
-			const tier = source.sections.find((section) => section?.name === 'clearai/autonomy')
 			/**
 			 * 内核在**回合之间**观察到的事实(目前:世界线执行者跑完)。
 			 * 与工具结果里的 `meta.mutations` **同形**,所以直接走同一个 `applyMutations`——
@@ -1122,28 +897,9 @@ export function applyEvent(state, event) {
 				}
 			}
 			const facts = source.sections.find((section) => section?.name === 'clearai/mutations')
-			if (brain !== undefined || tier !== undefined || facts !== undefined) {
+			if (facts !== undefined) {
 				let next = clone(state)
 				let touched = false
-				if (brain !== undefined && typeof brain.text === 'string') {
-					try {
-						const payload = JSON.parse(brain.text)
-						if (Array.isArray(payload?.candidates)) next.brainCandidates = payload.candidates
-						if (payload?.overview !== undefined) next.brain = payload.overview
-						// 章程读数:只有真的变了才会出现在 payload 里(内核那侧按文件系统指纹去重)。
-						if (payload?.constitution !== undefined) next.constitution = payload.constitution
-						// 合并目录:内核从宿主的 skills 服务取的那张表(变了才发)。
-						if (payload?.catalog !== null && typeof payload?.catalog === 'object' && Array.isArray(payload.catalog.entries)) {
-							next.skillCatalog = { complete: payload.catalog.complete === true, entries: payload.catalog.entries, at: typeof event.time === 'number' ? event.time : null }
-						}
-						for (const name of Array.isArray(payload?.promoted) ? payload.promoted : []) {
-							next.skillPromotions = [...(next.skillPromotions ?? []), { name, by: 'user', at: typeof event.time === 'number' ? event.time : Date.now() }]
-						}
-						touched = true
-					} catch {
-						// 坏 payload:如实少一条外脑事实,但不吞掉同一条消息里别的事实。
-					}
-				}
 				if (facts !== undefined && typeof facts.text === 'string') {
 					try {
 						const payload = JSON.parse(facts.text)
@@ -1155,61 +911,18 @@ export function applyEvent(state, event) {
 						// 同上:坏 payload 不当事实,也不影响别的。
 					}
 				}
-				if (tier !== undefined && typeof tier.text === 'string') {
-					try {
-						const payload = JSON.parse(tier.text)
-						const value = String(payload?.value ?? '')
-						if (value === 'attended' || value === 'unattended') {
-							next.autonomy = {
-								...(next.autonomy ?? {}),
-								effective: { value, preset: String(payload?.preset ?? value), source: payload?.source === 'session' ? 'session' : 'preset', at: typeof event.time === 'number' ? event.time : null },
-							}
-							touched = true
-						}
-					} catch {
-						// 同上:坏 payload 不当事实,也不影响别的。
-					}
-				}
 				if (touched) return next
 			}
 		}
-		// 人在面板上按下的人门动作 → 落成**事实**(不是请求):确认计划就地生效;
-		// 世界线的裁决记在分叉上,由内核的 ConvergeFork/AbandonFork 落实(合并与清理是内核的活)。
+		// 旧日志里人在面板上按下的人门动作 → 照旧落成**事实**(面板已不再发)。
 		const gate = parseHumanGate(event.data)
-		// 人引用技能:一条含 `/名字` 的**用户消息**。这就是原生 pre-step 注入正文的判据,
-		// 所以「人用过它」不是我们的推测,而是这条消息本身。插件与注入消息都不算(署名必须是人)。
-		const quoted = source !== null && typeof source === 'object' && source.kind === 'user' ? invokedSkillNames(event.data) : []
-		if (gate === null && quoted.length === 0) return state
+		if (gate === null) return state
 		const at = typeof event.time === 'number' ? event.time : Date.now()
 		const next = clone(state)
-		for (const name of quoted) recordSkillUse(next, name, 'human', at, stepPointer(state))
-		if (gate === null) return next
-		// **旧日志容忍分支**(写入者已摘除,只有旧日志可能带着):人切运行档曾经是一条人门动作,旧会话里可能留着。
-		// 读到它就照旧记成一条**人的事实**,让历史会话仍然读得通;当前面板上已经没有这个开关,
-		// 新的会话不会再产生这一条。不要据此认为"现在还能切档"——要删这个分支得先确认没有旧日志。
-		if (gate.action === 'set_autonomy') {
-			const value = String(gate.value ?? '')
-			if (!AUTONOMY_VALUES.includes(value)) return next
-			next.autonomy = { ...(next.autonomy ?? {}), override: { value, at } }
-			return next
-		}
 		/**
 		 * 人审查一条事实:标的在 `value`(面板送出的是事实 id),缘由在 `note`。
 		 * 已经审过的不再改(第一次决定为准,与计划授权那条同一条纪律)。
 		 */
-		/**
-		 * 人认可一次**临时采纳**:它是那道门唯一的机械出口。
-		 *
-		 * 「临时采纳」的语义是「分差不足以称结论」;原来它只能靠人说话,而门开着会按住续跑
-		 * ⇒ 什么都不做的话系统一直等。认可是**人的决定**,落一条 `by:'user'` 的确认留着痕迹;
-		 * 「要改判据」那条路仍然在(说一句话,模型重做一条世界线)。
-		 */
-		if (gate.action === 'confirm_provisional') {
-			const provisionalFork = next.forks.find((item) => item.id === (gate.fork ?? null))
-			if (provisionalFork?.merge?.provisional !== true || provisionalFork.merge.confirmed !== undefined) return next
-			provisionalFork.merge = { ...provisionalFork.merge, confirmed: { at, by: 'user' } }
-			return next
-		}
 		if (gate.action === 'retract_fact' || gate.action === 'keep_fact') {
 			const fact = next.facts.find((item) => item.id === (gate.value ?? null))
 			if (fact === undefined || fact.review !== undefined) return next
@@ -1239,31 +952,12 @@ export function applyEvent(state, event) {
 			next.lexicon = applyLexiconMutation(next.lexicon, { t: kind, ...entry, by: 'user' }, at)
 			return next
 		}
-		const fork = next.forks.find((item) => item.id === (gate.fork ?? null))
-		if (fork === undefined) return next
-		fork.humanDecision = {
-			action: gate.action,
-			branch: gate.branch ?? null,
-			note: gate.note ?? null,
-			at,
-		}
 		return next
 	}
 	if (event.type === 'tool/call') {
 		const data = event.data ?? {}
 		if (typeof data.name !== 'string') return state
 		const next = clone(state)
-		if (data.name === 'skill') {
-			// 模型加载技能 = 原生 `skill` 工具的一次调用。工具名与参数形状照原样认,不猜别的写法。
-			let args = null
-			try {
-				args = typeof data.arguments === 'string' ? JSON.parse(data.arguments) : data.arguments
-			} catch {
-				args = null
-			}
-			const name = args === null || typeof args !== 'object' || typeof args.name !== 'string' ? '' : args.name.trim()
-			if (name !== '') recordSkillUse(next, name, 'model', typeof event.time === 'number' ? event.time : 0, stepPointer(state))
-		}
 		if (data.name === 'write' || data.name === 'edit') {
 			let args = null
 			try {
@@ -1277,11 +971,6 @@ export function applyEvent(state, event) {
 				if (next.written.length > MAX_WRITTEN) next.written.splice(0, next.written.length - MAX_WRITTEN)
 			}
 		}
-		/**
-		 * 会改工作区的那几件工具都记一笔:`write`/`edit` 是直接的,`bash`/`pwsh` 是间接的
-		 * (脚本自己产出文件,内核看不见)。计数只增,判据留给用它的地方。
-		 */
-		if (WRITE_CAPABLE_TOOLS.has(data.name)) next.writeCalls = (next.writeCalls ?? 0) + 1
 		next.inFlight = VERDICT_WAITERS.has(data.name) ? { name: data.name, callId: data.callId ?? null, at: typeof event.time === 'number' ? event.time : 0 } : null
 		return next
 	}
@@ -1316,10 +1005,30 @@ export function applyEvent(state, event) {
 /** 假设的终态:到了这里就不再是「还要继续做的活」。 */
 const TERMINAL_HYPOTHESIS = new Set(['refuted', 'superseded', 'retracted'])
 
+/**
+ * **断言主体落图了吗**:一条判断的断言里,主体还不是实体图节点的那些(去重)。
+ *
+ * 节点有几种来路,都带出处或独立裁决:实体文件(`clear/ontology/entities/`)里的实体与它们的关系、升格事实里的主体,
+ * 以及它们以 instance 形态引出的宾语。`derive()` 把读数挂在每条判断上(`unlanded`),
+ * 缺口 ③ 与 `Conclude` 的实体门读的都是它——「卡上说落了」与「门说没落」不会出现两种读数。
+ */
+function subjectsOffGraph(hypothesis, nodes) {
+	const seen = new Map()
+	for (const assertion of Array.isArray(hypothesis?.assertions) ? hypothesis.assertions : []) {
+		const id = String(assertion?.subject?.id ?? '').trim()
+		const type = String(assertion?.subject?.type ?? '').trim()
+		if (id === '' || type === '') continue
+		const key = `${type}|${id}`
+		if (seen.has(key) || nodes.has(key)) continue
+		seen.set(key, { id, type })
+	}
+	return [...seen.values()]
+}
+
 /**
  * **知识模式(分诊)与缺口读数。**
  *
- * 判据是**结构的,不是词法的**:这里不猜「这句话像不像研究任务」。立约(`SetGoal`)并用
+ * 判据是**结构的,不是词法的**:这里不猜「这句话像不像研究任务」。立约(`Frame`)并用
  * 相互竞争的假设登记它,是模型自己已经做出的那次承诺——它意味着这件事要跨多轮、要有依据、
  * 要有可复核的结论。日常问答从不立约,于是从不进这一档。用词面启发式去猜任务类型,
  * 正是真跑里评估者抓到的那类「硬编码比例」的老路:猜错了没人能复核,而结构判据可以。
@@ -1344,48 +1053,11 @@ export function deriveKnowledge(state, hypotheses, factRows, lexicon) {
 	const gaps = []
 	if (mode === 'knowledge') {
 		/**
-		 * ① 语言还没立起来:跨轮复用与「按概念取用已知」都要求先有词汇。
-		 *    判据是**两个都空**——只有概念没有谓词时,关系还说不出来,但语言已经开张了,
-		 *    那是进展不是缺口(否则每注册一个概念就多一条永远擦不掉的抱怨)。
-		 */
-		if (terms.length === 0 && predicates.length === 0) {
-			gaps.push({
-				code: 'no_language',
-				count: registered.length,
-				detail: `${registered.length} 条在验命题,但还没有任何概念与谓词:换一轮只能靠重读散文取用它们`,
-				nextAction: '先 RegisterTerm 立词,再 RegisterPredicate 说清它们之间是什么关系',
-			})
-		}
-		/**
-		 * ② 只有散文主张的命题:断言是可选的(「加法,不是门槛」),所以这里**不是违规**,
-		 *    而是「这条主张还不能被机器比对」。只算非终态的:被推翻/被替代的不再欠这一笔。
-		 */
-		const proseOnly = registered.filter((item) => !Array.isArray(item.assertions) || item.assertions.length === 0)
-		if (proseOnly.length > 0) {
-			gaps.push({
-				code: 'prose_only_claims',
-				count: proseOnly.length,
-				detail: `${proseOnly.length} 条在验命题只有散文主张:两条结论是不是在说同一件事,只能靠重读判断`,
-				nextAction: '用 SetGoal 的修订把这条主张写成断言(主词–谓词–宾语),引用已登记的 id',
-			})
-		}
-		/**
-		 * ③ **升格时没带断言**。只算 0.2.0 那条路走出来的事实(`hypothesis` 已关联)——
-		 *    更早的事实补不上断言(见已知缺口),把它们算成欠账就是一条永远还不掉的抱怨。
-		 */
-		const unstructured = factRows.filter((fact) => typeof fact.hypothesis === 'string' && fact.hypothesis !== '' && (!Array.isArray(fact.assertions) || fact.assertions.length === 0))
-		if (unstructured.length > 0) {
-			gaps.push({
-				code: 'unstructured_facts',
-				count: unstructured.length,
-				detail: `${unstructured.length} 条已升格事实没有断言:它们进不了实体图,也不能按概念取用`,
-				nextAction: '下次升格时带上 assertions;这条老事实的形态靠新一次升格补',
-			})
-		}
-		/**
-		 * ④ **从没被证据碰过的命题**。只在这次会话已经真的跑出过证据之后才报——计划刚立、
-		 *    一步都还没走时,所有假设都是「没碰过」,那是正常的起点而不是缺口。
-		 *    它和结案时那条 `unjudged` 是同一条先例:**不逼裁决,但不许把「没看过」写成「没问题」**。
+		 * 缺口只留三种,都是「这一轮的结论还不能被复用」的直接读数,每种都指得到今天就能补的动作。
+		 *
+		 * ① **从没被证据碰过的判断**。只在这次会话已经真的跑出过证据之后才报——计划刚立、
+		 *    一步都还没走时,所有判断都是「没碰过」,那是正常的起点而不是缺口。
+		 *    不逼裁决,但不许把「没看过」写成「没问题」。
 		 */
 		if (Array.isArray(state?.evidence) && state.evidence.length > 0) {
 			const untouched = registered.filter((item) => item.refutations + item.inconclusive === 0 && item.supportedLevel === null)
@@ -1393,89 +1065,57 @@ export function deriveKnowledge(state, hypotheses, factRows, lexicon) {
 				gaps.push({
 					code: 'untouched_claims',
 					count: untouched.length,
-					detail: `${untouched.length} 条在验命题还没有任何证据碰过(支持 / 推翻 / 无法判定都算碰过)`,
-					nextAction: '给它派一个带 tests 的步骤并交付:支持 / 推翻 / 无法判定都算碰过',
+					detail: tr(`${untouched.length} 条验证中的判断还没有任何证据碰过(支持 / 推翻 / 不确定都算碰过)`, `${untouched.length} judgments under test have not been touched by any evidence (support, refute and inconclusive all count)`),
+					nextAction: tr('给它派一个带 tests 的步骤并交付:支持 / 推翻 / 无法判定都算碰过', 'Give it a step with tests and deliver it: support, refute and inconclusive all count'),
 				})
 			}
 		}
 		/**
-		 * ⑤ **实体层空着**。判据是整数可清点的:非终态命题的断言主体去重数(wanted)与实体层
-		 *    节点数。两个数都从账本现算,没有一个字是猜的。
-		 *
-		 *    为什么必须有这一条:实体层从前是升格的副产品,于是「断言齐备、门槛也放行」却
-		 *    因为另一条无关判据被卡住时,卡上四项全绿而**实体图是空的**——「看得见的边界」
-		 *    在这里漏过一整层。诚实出口是两条:登记并落断言,或如实说清不值得留下形态。
-		 */
-		const assertions = registered.flatMap((item) => (Array.isArray(item.assertions) ? item.assertions : []))
-		const wantedKeys = new Set(assertions.map((assertion) => `${String(assertion?.subject?.type ?? '')}|${String(assertion?.subject?.id ?? '')}`).filter((key) => key !== '|'))
-		/**
-		 * **判据是"每一个主体都落地了吗",不是"图上有没有东西"。**
-		 *
-		 * 弱判据(实体层节点数 === 0)有一个便宜的绕法:随便登记一个**无关**节点,
-		 * 缺口就消失,而真正该落地的那几个主体仍然只在命题上。于是这道门形同虚设。
-		 * 所以这里逐个主体判它有没有落成实体层节点,`count` 就是**还没落地的个数**。
+		 * ② 只有散文主张的判断:断言是可选的,所以这里**不是违规**,也不拦结案,
+		 *    而是「这条主张还不能被机器比对、下一轮也按概念取不到」。只算非终态的。
 		 */
+		const proseOnly = registered.filter((item) => !Array.isArray(item.assertions) || item.assertions.length === 0)
+		if (proseOnly.length > 0) {
+			gaps.push({
+				code: 'prose_only_claims',
+				count: proseOnly.length,
+				detail: tr(`${proseOnly.length} 条验证中的判断只有散文主张:两条结论是不是在说同一件事,只能靠重读判断`, `${proseOnly.length} judgments under test are prose only: whether two conclusions say the same thing can only be judged by rereading them`),
+				nextAction: tr('先在 clear/ontology/ 下写概念、关系与主体的实体文件,再用 Frame 修订把主张写成断言(主词–谓词–宾语)', 'First write concept, relation and subject entity files under clear/ontology/, then revise with Frame to turn the claim into assertions (subject–predicate–object)'),
+			})
+		}
 		/**
-		 * **"落地"的判据是"这句断言在图上有边",不是"图上有这个节点"。**
+		 * ③ **断言主体没落图**。判据与 `Conclude` 的实体门是同一条(每条判断上的 `unlanded`):
+		 *    断言的主体是不是实体图上带出处的节点。逐个主体判,`count` 就是还没落地的个数——
+		 *    随便登记一个无关节点不会让它消失。
 		 *
-		 * 只数节点会漏掉最要命的那种形态:实例登记了(图上有节点),而关于它的那句话还挂在命题上
-		 * ——图有节点、没有边,"实体图长出来了"仍然是一句空话。所以这里取**断言边的起点集合**:
-		 * 一条边要么来自带出处的实体断言(`Assert`),要么来自过了独立裁决的升格事实。
+		 *    为什么看节点、不看边:边由升格本身落下(事实带着它的断言进图),
+		 *    要求在升格之前另在实体文件里把同一句话再写一遍,只是让模型重复劳动。
 		 */
-		const graph = graphProjection(state)
-		const landedKeys = new Set(graph.edges.filter((edge) => edge.kind === 'assertion').map((edge) => String(edge.from)))
-		const unlanded = [...wantedKeys].filter((key) => !landedKeys.has(`term:${key}`) && !landedKeys.has(key))
+		const unlanded = [...new Map(registered.flatMap((item) => item.unlanded ?? []).map((item) => [`${item.type}|${item.id}`, item])).values()]
 		if (unlanded.length > 0) {
 			gaps.push({
 				code: 'entities_unlanded',
 				count: unlanded.length,
-				detail: `${unlanded.length} 个断言主体还没有落到实体图（共 ${wantedKeys.size} 个）：断言只挂在命题上，不构成「已知」`,
-				nextAction: '先 RegisterInstance 把实例连出处登记下来；确实不值得留下形态就如实说清',
-			})
-		}
-		/**
-		 * ⑥ **跳级没有理由**。`derive()` 已经把写明理由的层从 `untouchedLevels` 里减掉,
-		 *    所以这里数出来的每一个都是真的欠一句解释的层——出口只有一条:
-		 *    用 `ExplainLevelSkip` 写清「为什么这一级在本项目里不适用」。
-		 */
-		const skipped = registered
-			.map((item) => ({ id: item.id, levels: Array.isArray(item.untouchedLevels) ? item.untouchedLevels : [] }))
-			.filter((item) => item.levels.length > 0)
-		const skippedCount = skipped.reduce((sum, item) => sum + item.levels.length, 0)
-		if (skippedCount > 0) {
-			gaps.push({
-				code: 'levels_skipped',
-				count: skippedCount,
-				detail: `${skippedCount} 处跳级没有理由（${skipped.map((item) => `命题 ${item.id} 缺 ${item.levels.join('/')}`).join('；')}）`,
-				nextAction: '用 ExplainLevelSkip 写明「为什么这一级在本项目里不适用」',
+				detail: tr(
+					`${unlanded.length} 个断言主体还没有落到实体图(${unlanded.map((item) => `${item.type}|${item.id}`).join('、')}):断言只挂在命题上,不构成「已知」`,
+					`${unlanded.length} assertion subjects are not on the entity graph yet (${unlanded.map((item) => `${item.type}|${item.id}`).join(', ')}): the assertions hang on the proposition only and are not "known"`,
+				),
+				nextAction: tr(
+					'给这些主体各写一个实体文件(clear/ontology/entities/<id>.json,带类型与出处);确实不值得留下形态就把断言从判断上拿掉(Frame 修订)',
+					'Write an entity file for each subject (clear/ontology/entities/<id>.json, with type and source); if one is really not worth keeping, drop the assertion from the judgment (Frame revision)',
+				),
 			})
 		}
-		/**
-		 * ⑦ **注册了却没人用的概念**。它和货架上「零引用的概念」那一节读**同一份**引用面
-		 *    (`termUsage`),所以两处不会出现「货架说没人用、缺口说用了」这种两种读数。
-		 */
-		if (terms.length > 0 && registered.length > 0) {
-			const usage = termUsage(lexicon, factRows, Array.isArray(state?.entityAssertions) ? state.entityAssertions : [])
-			const orphans = terms.filter((term) => term.status !== 'deprecated' && (usage.get(term.id) ?? 0) === 0)
-			if (orphans.length > 0) {
-				gaps.push({
-					code: 'orphan_terms',
-					count: orphans.length,
-					detail: `${orphans.length} 个概念没有任何结论引用它们（它们还只是约定，不是已知）`,
-					nextAction: '要么在断言里用起来，要么在货架上如实标出「未被引用」',
-				})
-			}
-		}
 	}
 	return {
 		mode,
 		/** 一句人话:为什么进了这一档(或为什么没进)。它进卡,所以不许写成术语。 */
 		why:
 			mode === 'knowledge'
-				? `目标还开着,带着 ${registered.length} 条登记过的命题——这是跨轮、要依据、要可复核结论的活`
+				? tr(`目标还开着,带着 ${registered.length} 条登记过的命题——这是跨轮、要依据、要可复核结论的活`, `The goal is open with ${registered.length} registered propositions: work across turns that needs evidence and checkable conclusions`)
 				: open
-					? '目标还开着,但没有登记命题:按普通任务推进'
-					: '没有开着的目标:按普通任务推进',
+					? tr('目标还开着,但没有登记命题:按普通任务推进', 'The goal is open but has no registered propositions: proceed as an ordinary task')
+					: tr('没有开着的目标:按普通任务推进', 'No open goal: proceed as an ordinary task'),
 		gaps,
 	}
 }
@@ -1483,10 +1123,10 @@ export function deriveKnowledge(state, hypotheses, factRows, lexicon) {
 /**
  * **知识预检(preflight)**:进入知识模式那一刻,把「已知」主动送到模型面前。
  *
- * 解决的问题:真跑里模型不查就开工——不是因为不知道有 \`QueryKnowledge\`,
+ * 解决的问题:真跑里模型不查就开工——不是因为没有查询的入口,
  * 而是因为**没人提醒它此刻该查**。提示词会被读成建议;卡里的读数不会。
  * 于是这里把相关性判断做成投影:从当前目标与命题的文本出发,圈出**有界**的一组
- * 已有词汇、事实与冲突,随运行态卡注入。模型只在这份摘要不够用时才需要精确查询。
+ * 已有词汇、事实与冲突,随运行态卡注入。模型只在这份摘要不够用时才需要去读全文。
  *
  * 三条纪律(与缺口读数同一套):
  *   · **只读**:不产生变更,不新增状态——它就是 \`derive\` 的另一个读面;
@@ -1506,7 +1146,9 @@ export function knowledgePreflight(state, derived) {
 	const factRows = Array.isArray(derived?.factRows) ? derived.factRows : []
 	const conflicts = Array.isArray(derived?.conflicts) ? derived.conflicts : []
 	/** 命题的文本面:目标主张 + 每条命题的主张(去空白后做包含判断)。 */
-	const claimText = [state?.goal?.claim, ...hypotheses.map((item) => item.claim)].filter((text) => typeof text === 'string' && text !== '').map((text) => String(text).replace(/\s+/g, ''))
+	/** 加上下一步要做什么与它的预期:预期引用的关系也要递到眼前。 */
+	const nextStep = (derived?.activePlan?.steps ?? []).find((step) => step?.status === 'open') ?? null
+	const claimText = [state?.goal?.claim, ...hypotheses.map((item) => item.claim), nextStep?.do, nextStep?.expect].filter((text) => typeof text === 'string' && text !== '').map((text) => String(text).replace(/\s+/g, ''))
 	/** 命题已经引用的谓词(断言在假设上时就该算「在用」)。 */
 	const usedPredicates = new Set(hypotheses.flatMap((item) => (Array.isArray(item.assertions) ? item.assertions : [])).map((assertion) => String(assertion?.predicate ?? '')))
 	const hits = (entry) => {
@@ -1518,19 +1160,27 @@ export function knowledgePreflight(state, derived) {
 	const matchedPredicates = predicates.filter((predicate) => usedPredicates.has(predicate.id) || hits(predicate))
 	const matchedTermIds = new Set(matchedTerms.map((term) => term.id))
 	const matchedPredicateIds = new Set(matchedPredicates.map((predicate) => predicate.id))
-	/** 事实:断言引用了命中的谓词,或主词类型是命中的概念。 */
-	const matchedFacts = factRows.filter((fact) =>
-		(Array.isArray(fact.assertions) ? fact.assertions : []).some((assertion) => matchedPredicateIds.has(String(assertion?.predicate ?? '')) || matchedTermIds.has(String(assertion?.subject?.type ?? ''))),
+	/**
+	 * 事实:断言引用了命中的谓词或概念;**或**升格时按词面挂上的定义里有命中的词(真跑里事实几乎都没有断言,
+	 * 只认断言等于从不命中);**或**有判断用 `retests` 指着它。撤回的不给。
+	 */
+	const retested = new Set(hypotheses.map((item) => item.retests).filter((id) => typeof id === 'string'))
+	const matchedFacts = factRows.filter(
+		(fact) =>
+			fact.review?.decision !== 'retracted' &&
+			(retested.has(fact.id) ||
+				Object.keys(fact.definitions ?? {}).some((id) => matchedTermIds.has(id) || matchedPredicateIds.has(id)) ||
+				(Array.isArray(fact.assertions) ? fact.assertions : []).some((assertion) => matchedPredicateIds.has(String(assertion?.predicate ?? '')) || matchedTermIds.has(String(assertion?.subject?.type ?? '')))),
 	)
 	return {
 		mode: 'knowledge',
 		/** 词面命中的词汇:模型接下来要写的结论大概率会用到它们。 */
-		terms: matchedTerms.slice(0, LIMIT).map((term) => ({ id: term.id, label: term.label, gloss: term.gloss, parent: term.parent ?? null, status: term.status, uses: term.uses ?? 0, basis: term.basis ?? null })),
+		terms: matchedTerms.slice(0, LIMIT).map((term) => ({ id: term.id, label: term.label, gloss: term.gloss, kind: term.kind ?? null, unit: term.unit ?? null, parent: term.parent ?? null, status: term.status, uses: term.uses ?? 0, basis: term.basis ?? null })),
 		termsTruncated: Math.max(0, matchedTerms.length - LIMIT),
-		predicates: matchedPredicates.slice(0, LIMIT).map((predicate) => ({ id: predicate.id, label: predicate.label, domain: predicate.domain, range: predicate.range, functional: predicate.functional === true, status: predicate.status, uses: predicate.uses ?? 0, basis: predicate.basis ?? null })),
+		predicates: matchedPredicates.slice(0, LIMIT).map((predicate) => ({ id: predicate.id, label: predicate.label, gloss: predicate.gloss ?? '', kind: predicate.kind ?? null, shape: predicate.shape ?? null, check: predicate.check ?? null, domain: predicate.domain, range: predicate.range, functional: predicate.functional === true, status: predicate.status, uses: predicate.uses ?? 0, basis: predicate.basis ?? null })),
 		predicatesTruncated: Math.max(0, matchedPredicates.length - LIMIT),
 		/** 命中的既有事实(可复用的「已知」)。 */
-		facts: matchedFacts.slice(0, LIMIT).map((fact) => ({ id: fact.id, text: fact.text, level: fact.level ?? null, scope: fact.scope ?? null, hypothesis: fact.hypothesis ?? null, review: fact.review?.decision ?? null })),
+		facts: matchedFacts.slice(0, LIMIT).map((fact) => ({ id: fact.id, text: fact.text, level: fact.level ?? null, scope: fact.scope ?? null, hypothesis: fact.hypothesis ?? null, review: fact.review?.decision ?? null, foreign: fact.foreign === true })),
 		factsTruncated: Math.max(0, matchedFacts.length - LIMIT),
 		/** 冲突:有就带上(它们约束「哪些结论还不能随便写)。 */
 		conflicts: conflicts.map((conflict) => ({ predicate: conflict.predicate, subject: conflict.subject })),
@@ -1707,12 +1357,12 @@ function factChain(context, fact) {
  */
 function factHistory(fact, evidence) {
 	const events = []
-	if (fact?.at !== undefined && fact?.at !== null) events.push({ kind: 'fact/promoted', at: fact.at, summary: `升格为事实(支持到 ${fact.level ?? '—'})` })
+	if (fact?.at !== undefined && fact?.at !== null) events.push({ kind: 'fact/promoted', at: fact.at, summary: tr(`升格为事实(支持到 ${fact.level ?? '—'})`, `Promoted to fact (supported to ${fact.level ?? '—'})`) })
 	if (fact?.review !== undefined && fact?.review !== null) {
 		events.push({
 			kind: 'fact/reviewed',
 			at: fact.review.at ?? null,
-			summary: fact.review.decision === 'retracted' ? '人审查后**撤回**(记录保留)' : '人审查后**维持**(判证据不可靠)',
+			summary: fact.review.decision === 'retracted' ? tr('人审查后**撤回**(记录保留)', 'A person reviewed it and **retracted** it (the record is kept)') : tr('人审查后**维持**(判证据不可靠)', 'A person reviewed it and **kept** it (the evidence was judged unreliable)'),
 			reason: fact.review.reason ?? null,
 		})
 	}
@@ -1723,12 +1373,12 @@ function factHistory(fact, evidence) {
 /** 词汇条目的留痕:登记 / 历次修订 / 废止。登记与修订本来就存在词条里(折法保留的)。 */
 function entryHistory(entry, label) {
 	const events = []
-	if (entry?.at !== undefined && entry?.at !== null) events.push({ kind: `${label}_added`, at: entry.at, summary: `登记(依据:${entry.basis ?? '—'})`, by: entry.by ?? null })
+	if (entry?.at !== undefined && entry?.at !== null) events.push({ kind: `${label}_added`, at: entry.at, summary: tr(`登记(依据:${entry.basis ?? '—'})`, `Registered (basis: ${entry.basis ?? '—'})`), by: entry.by ?? null })
 	for (const revision of Array.isArray(entry?.revisions) ? entry.revisions : []) {
-		events.push({ kind: `${label}_revised`, at: revision.at ?? null, summary: `修订到 v${revision.version ?? '?'}`, reason: revision.reason ?? null, by: revision.by ?? null })
+		events.push({ kind: `${label}_revised`, at: revision.at ?? null, summary: tr(`修订到 v${revision.version ?? '?'}`, `Revised to v${revision.version ?? '?'}`), reason: revision.reason ?? null, by: revision.by ?? null })
 	}
 	if (entry?.deprecated !== undefined && entry?.deprecated !== null) {
-		events.push({ kind: `${label}_deprecated`, at: entry.deprecated.at ?? null, summary: '废止(黏性终态,没有复活)', reason: entry.deprecated.reason ?? null, by: entry.deprecated.by ?? null })
+		events.push({ kind: `${label}_deprecated`, at: entry.deprecated.at ?? null, summary: tr('废止(黏性终态,没有复活)', 'Deprecated (final; it does not come back)'), reason: entry.deprecated.reason ?? null, by: entry.deprecated.by ?? null })
 	}
 	return events.filter((event) => event.at !== null || event.kind.endsWith('_deprecated')).sort((left, right) => (left.at ?? 0) - (right.at ?? 0))
 }
@@ -1786,7 +1436,7 @@ function inspectConcept(context, termId) {
 		history: entryHistory(term, 'term'),
 		actions: { canFilter: true, canExpand: true, canEdit: true },
 		/** 词汇是**约定**,不需要证据等级——把它说清楚,免得读的人以为它「没验」。 */
-		note: '概念是约定,不是主张:它不带证据等级。用这个词写下的句子才需要。',
+		note: tr('概念是约定,不是主张:它不带证据等级。用这个词写下的句子才需要。', 'A concept is a convention, not a claim: it carries no evidence level. Only sentences written with it do.'),
 	}
 }
 
@@ -1807,7 +1457,7 @@ function inspectValueType(context, form) {
 		/** 值形态由系统固定,不进领域本体、也没有版本史——如实说空,不编一段。 */
 		history: [],
 		actions: { canFilter: true, canExpand: false, canEdit: false },
-		note: '值形态由系统固定(statement / quantity / formula / code / reference),不独立治理,所以没有版本史。',
+		note: tr('值形态由系统固定(statement / quantity / formula / code / reference),不独立治理,所以没有版本史。', 'Value forms are fixed by the system (statement / quantity / formula / code / reference); they are not governed separately, so they have no version history.'),
 	}
 }
 
@@ -1851,7 +1501,7 @@ function inspectPredicate(context, predicateId) {
 			.map((conflict) => ({ predicate: conflict.predicate, subject: conflict.subject, sides: conflict.sides.map((side) => ({ fact: side.fact ?? null, value: side.value ?? null })) })),
 		history: entryHistory(predicate, 'predicate'),
 		actions: { canFilter: true, canExpand: true, canEdit: true },
-		note: predicate.functional === true ? '单值谓词:同一主词上两条未撤回的确认事实取值不同时,系统给出一对冲突读数(只暴露,不裁决)。' : null,
+		note: predicate.functional === true ? tr('单值谓词:同一主词上两条未撤回的确认事实取值不同时,系统给出一对冲突读数(只暴露,不裁决)。', 'Single-valued predicate: when two unretracted confirmed facts give different values for the same subject, the system reports a conflict pair (surfaced, not resolved).') : null,
 	}
 }
 
@@ -1903,7 +1553,7 @@ function inspectInstance(context, key) {
 			.map((conflict) => ({ predicate: conflict.predicate, subject: conflict.subject, sides: conflict.sides.map((side) => ({ fact: side.fact ?? null, value: side.value ?? null })) })),
 		history: [],
 		actions: { canFilter: true, canExpand: true, canEdit: false },
-		note: '实例由断言投影出来,不单独注册、也不做实体消解(同名即同节点);它没有自己的版本史。',
+		note: tr('实例由断言投影出来,不单独注册、也不做实体消解(同名即同节点);它没有自己的版本史。', 'Instances are projected from assertions; they are not registered separately and not resolved (same name means same node); they have no version history of their own.'),
 	}
 }
 
@@ -1944,7 +1594,7 @@ function inspectLiteral(context, key) {
 		conflicts: [],
 		history: [],
 		actions: { canFilter: true, canExpand: true, canEdit: false },
-		note: '字面值是断言里的客体,由事实投影出来;它没有独立生命周期。',
+		note: tr('字面值是断言里的客体,由事实投影出来;它没有独立生命周期。', 'A literal value is the object of an assertion, projected from facts; it has no lifecycle of its own.'),
 	}
 }
 
@@ -1980,18 +1630,42 @@ function inspectEdge(context, edgeId) {
 		conflicts: chain.conflicts,
 		history: chain.history,
 		actions: { canFilter: true, canExpand: true, canEdit: false },
-		note: predicate?.functional === true ? '这条边落在单值谓词上:同一主词出现第二个不同取值时会产生冲突(只暴露,不裁决)。' : null,
+		note: predicate?.functional === true ? tr('这条边落在单值谓词上:同一主词出现第二个不同取值时会产生冲突(只暴露,不裁决)。', 'This edge uses a single-valued predicate: a second, different value for the same subject produces a conflict (surfaced, not resolved).') : null,
+	}
+}
+
+
+/**
+ * **可信度怎么变的**:按证据落账的先后重放一遍,每一笔记下「之前 → 之后」。
+ * 面板「点开一条」的第二段读的就是它;分组判据仍只有 `trustOf` 一处,这里只是逐笔调用。
+ * 升格(写进长期知识)和撤回不在这里——它们由读的一侧接在末尾(见 `view`)。
+ */
+function trustHistory(hypothesis, rows) {
+	const history = [{ kind: 'proposed', at: hypothesis.at ?? null, to: 'testing' }]
+	let replay = { status: 'proposed', supportedLevel: null, refutations: 0, inconclusive: 0 }
+	const ordered = rows
+		.map((item, index) => ({ item, index }))
+		.sort((left, right) => (left.item.at ?? 0) - (right.item.at ?? 0) || left.index - right.index)
+		.map(({ item }) => item)
+	for (const item of ordered) {
+		const from = trustOf(replay)
+		if (item.verdict === 'refute') replay = { ...replay, refutations: replay.refutations + 1 }
+		else if (item.verdict === 'inconclusive') replay = { ...replay, inconclusive: replay.inconclusive + 1 }
+		else if (item.verdict === 'support' && LEVELS.indexOf(String(item.level ?? '').toUpperCase()) > LEVELS.indexOf(String(replay.supportedLevel ?? '').toUpperCase())) replay = { ...replay, supportedLevel: item.level }
+		history.push({ kind: 'evidence', id: item.id ?? null, at: item.at ?? null, plan: item.plan ?? null, step: item.step ?? null, verdict: item.verdict, level: item.level ?? null, evaluator: item.evaluator ?? null, basis: item.basis ?? null, from, to: trustOf(replay) })
 	}
+	return history
 }
 
 /** 五种值形态的名字与一句话解释(名字取自 `domain-language` 的枚举,这里只加给人读的说明)。 */
-const VALUE_FORM_GLOSS = {
-	statement: '短陈述字符串',
-	quantity: '数值 + 单位',
-	formula: '公式源码(LaTeX;本版不做语义解析)',
-	code: '指向工作区里真有的文件路径',
-	reference: '外部引用(文献 / URL / 编号)',
+const VALUE_FORM_GLOSS_TEXT = {
+	statement: ['短陈述字符串', 'A short statement string'],
+	quantity: ['数值 + 单位', 'A number plus a unit'],
+	formula: ['公式源码(LaTeX;本版不做语义解析)', 'Formula source (LaTeX; its meaning is not parsed)'],
+	code: ['指向工作区里真有的文件路径', 'A path to a file that exists in the workspace'],
+	reference: ['外部引用(文献 / URL / 编号)', 'An external reference (paper / URL / identifier)'],
 }
+const VALUE_FORM_GLOSS = bilingual(VALUE_FORM_GLOSS_TEXT)
 
 export function derive(state) {
 	const activePlan = state.plans.find((plan) => plan.status === 'active') ?? null
@@ -2012,11 +1686,16 @@ export function derive(state) {
 			.map((item) => item.hypothesis)
 			.filter((id) => typeof id === 'string' && id !== ''),
 	)
+	const instanceNodes = new Set(graphProjection(state).nodes.filter((node) => node.kind === 'instance').map((node) => String(node.id)))
 	const hypotheses = state.hypotheses.map((hypothesis) => {
 		const rows = []
 		for (const item of state.evidence) {
+			if (item.hypothesis !== undefined) {
+				if (item.hypothesis === hypothesis.id) rows.push(item)
+				continue
+			}
 			const step = stepOf(item.plan, item.step)
-			if (step?.tests?.hypothesis === hypothesis.id) rows.push(item)
+			if ((normalizeTests(step?.tests)?.hypotheses ?? []).includes(hypothesis.id)) rows.push(item)
 		}
 		const refutations = rows.filter((item) => item.verdict === 'refute').length
 		const inconclusive = rows.filter((item) => item.verdict === 'inconclusive').length
@@ -2029,40 +1708,13 @@ export function derive(state) {
 		else if (status === 'proposed' && rows.length > 0) status = 'alive'
 		// 被推翻是黏性终态:「已被替代」不该改写「已被推翻」——两件事。
 		if (status !== 'superseded' && status !== 'refuted' && status !== 'retracted' && refutations > 0) status = 'refuted'
-		/**
-		 * **从没被走过的等级**(派生,零新账)。
-		 *
-		 * 等级衡量的是「这条结论在多大程度上只能靠信任做的人」,而它逐级上升的补偿是
-		 * 独立裁决与人放行。所以「我直接在 L3 上交付、L0/L1/L2 从没走过」本身不是违规
-		 * (首次测量没有廉价路可走),但**它必须看得见**——与「假设从没被证据碰过」记成
-		 * `unjudged` 是同一条先例:不逼裁决,但不许把「没看过」写成「没问题」。
-		 *
-		 * 只列**低于已用到过的最高等级**、且一条证据都没有的那些级;没走过任何等级时为空
-		 * (还没有声明可谈)。
-		 */
-		const used = new Set(rows.map((item) => String(item.level ?? '').toUpperCase()))
-		const top = [...used].reduce((best, level) => Math.max(best, LEVELS.indexOf(level)), -1)
-		/**
-		 * **写明理由的跳级不算「没走过」**:`level/skipped` 记的就是「这一级在本项目里
-		 * 为什么不适用」。所以减掉它——于是 `levels_skipped` 缺口与卡上那一行读的都是
-		 * 减完的结果:「写明理由」是那条缺口唯一的出口,而且它真的会让缺口消失。
-		 */
-		const skipCovered = new Set(
-			(Array.isArray(hypothesis.skips) ? hypothesis.skips : [])
-				.flatMap((skip) => (Array.isArray(skip?.levels) ? skip.levels : []))
-				.map((level) => String(level).toUpperCase()),
-		)
-		const untouchedLevels = top <= 0 ? [] : LEVELS.slice(0, top).filter((level) => !used.has(level) && !skipCovered.has(level))
-		return { ...hypothesis, status, supportedLevel: supportedLevel < 0 ? null : `L${supportedLevel}`, refutations, inconclusive, untouchedLevels }
+		return { ...hypothesis, status, supportedLevel: supportedLevel < 0 ? null : `L${supportedLevel}`, refutations, inconclusive, unlanded: subjectsOffGraph(hypothesis, instanceNodes), history: trustHistory(hypothesis, rows) }
 	})
 
 	/**
 	 * `plan_is_authorized`:有记号 **或** 已经真的推进过(行为即授权)。
 	 * 第二个分支在 ClearAI 那边是给存量文档用的;这里同样留着——事实与意图冲突时以事实为准。
 	 */
-	const planIsAuthorized = (plan) =>
-		plan !== null && (plan.confirmed_at !== null || plan.steps.some((step) => step.status !== 'open'))
-	const planConfirmationPending = activePlan !== null && activePlan.status === 'active' && !planIsAuthorized(activePlan)
 	let phase = null
 	let progress = null
 	if (state.goal !== null) {
@@ -2106,140 +1758,44 @@ export function derive(state) {
 		}
 	}
 
-	/**
-	 * 世界线的**派生状态**(语义:见 recon 的「四条结束方式」):
-	 *
-	 *   · `failed`   —— 执行者没跑成(`worldline/executed{ok:false}`)。**它不是落选**:
-	 *     落选意味着它跑完了、被尺子排到了后面;失败是「世界没给它机会」。原来的实现在这两件事上
-	 *     共用一个状态(都还是 exploring),于是界面会一直为一条死掉的线呼吸——那是说假话。
-	 *   · `orphaned` —— 承载它的**步骤被作废**了,而它还没收口。它既不是被人裁掉(没人做过这个决定),
-	 *     也不是被算术排掉(没有尺子排过它):它是「随承诺撤回而终止」。这是两个已存在事实的**推论**,
-	 *     不是第五种存储状态——零新账,也**不改写历史**(绝不把它写成「已放弃」)。
-	 */
-	const forks = state.forks.map((fork) => {
-		const owner = (activePlan ?? closedPlans[closedPlans.length - 1] ?? null)?.steps.find((step) => step.id === fork.step) ?? null
-		const ownerVoided = owner !== null && owner.status === 'void'
-		return {
-			...fork,
-			ownerStatus: owner === null ? null : owner.status,
-			ownerVoidReason: ownerVoided ? (owner.voidReason ?? null) : null,
-			orphaned: ownerVoided && !fork.settled && !fork.abandoned,
-			phase: fork.abandoned
-				? 'abandoned'
-				: fork.settled
-					? 'settled'
-					: ownerVoided
-						? 'orphaned'
-						: fork.branches.every((branch) => (BRANCH_RANK[branch.status] ?? 0) >= BRANCH_RANK.evaluated)
-							? 'deciding'
-							: 'exploring',
-			branches: fork.branches.map((branch) => ({
-				...branch,
-				// 派生,不落库:执行没跑成,而状态还停在探索中。
-				failed: branch.status === 'exploring' && branch.execution !== null && branch.execution !== undefined && branch.execution.ok === false,
-				orphaned: ownerVoided && !fork.settled && !fork.abandoned && branch.status === 'exploring',
-				/**
-				 * **执行者未归**(与「失败」「孤儿」同一族的假话——不说破就会被当成还在跑):
-				 *
-				 * 执行者是异步派的,所以「它在跑」是一条会过期的状态。分叉一旦收口(收敛或放弃),
-				 * 那条世界线就**没有归宿**了——回灌也进不了任何决定。可 `execution.ok` 仍是 `null`,
-				 * 于是卡片会永远写「(执行中,结论会自动回灌)」:**一句实现了不了的承诺**。
-				 *
-				 * 两条已有事实的推论:分叉是终局 + 执行者没报过。零新账,也不改写 `execution` 本身
-				 * (它仍然是「没报过」这个已发生的事实)。
-				 */
-				unreturned: (fork.settled === true || fork.abandoned === true) && branch.execution !== null && branch.execution !== undefined && branch.execution.ok === null,
-			})),
-		}
-	})
-
-	/**
-	 * 收件箱:每一道门都是**状态锚**(由派生事实算出,不依赖中断记录)——门一解决,条目自然消失,
-	 * 不可能残留成僵尸。
-	 * 条目只带**分诊信息**(标题/摘要/指向),不带全部正文:收件箱是分诊,不是问诊。
-	 *
-	 * 这里**只放真门**:不拍板就真的推不动的那种。计划确认不再是条目(它是记号,
-	 * 不是闸门;见 HUMAN_GATE_ACTIONS 的收敛记录)——收件箱里的每一条都经得起「等人是必须的吗」。
-	 */
-	const inbox = []
-	for (const fork of forks) {
-		// 人已经裁决过的不再等他(ClearAI 的条目是状态锚:状态一变,条目自然消失)。
-		if (fork.phase !== 'deciding' || (fork.humanDecision ?? null) !== null) continue
-		const label = fork.branches.find((branch) => branch.id === fork.recommended)?.label ?? null
-		inbox.push({
-			kind: 'fork_adopt',
-			title: '世界线裁决',
-			summary: `${fork.question} · ${fork.branches.length} 条世界线探索完毕,待采纳一条${label === null ? '' : ` · 推荐★${label}`}`,
-			plan: fork.plan ?? null,
-			step: fork.step,
-			/** 条目要指得出**是哪一盘分叉**:界面那条「用提问卡决定」的手势按它去取题目与选项。 */
-			fork: fork.id,
-			human_action: 'adopt_branch',
-			/** 门要什么:**点击**(有白名单动词)还是**一句话**(语义判断归模型)。 */
-			needs: 'click',
-		})
-	}
-	for (const fork of forks) {
-		// 人已经认可过就不再等他(状态锚:状态一变,条目自然消失)。
-		if (fork.merge?.provisional !== true || (fork.merge.confirmed ?? null) !== null) continue
-		inbox.push({
-			kind: 'provisional_review',
-			title: '临时采纳待复核',
-			summary: `${fork.question} · 已**临时**采纳「${fork.branches.find((branch) => branch.id === fork.merge.branch)?.label ?? fork.merge.branch}」:${fork.merge.decisionNote ?? '分差不足以称结论'}`,
-			plan: fork.plan ?? null,
-			step: fork.step,
-			/** 标的:认可是对**哪一盘分叉**的认可。 */
-			fork: fork.id,
-			/** 认可是一个动作(一键);「要改判据」那条路仍然靠说一句话,由模型重做一条世界线。 */
-			human_action: 'confirm_provisional',
-			/**
-			 * **一键认可**:它曾经是「要一句话」的门,而「认可就什么都不用做」有个洞——
-			 * 门开着 ⇒ 续跑停着 ⇒ 什么都不做的话系统一直等,等一个永远不会来的动作。
-			 * 认可是一次决定,决定就该有按钮;要改判据那条路仍然在(说一句话,模型重做一条世界线)。
-			 */
-			needs: 'click',
-			ask: '要改判据就重做一条世界线(说一句即可)',
-		})
-	}
-	for (const candidate of state.brainCandidates ?? []) {
-		inbox.push({
-			kind: 'skill_candidate',
-			title: `候选技能:${candidate.name}`,
-			summary: `${String(candidate.description ?? '').slice(0, 120)}——模型自己写的 SOP,采纳后才进它的技能目录。`,
-			plan: null,
-			step: null,
-			human_action: 'promote_skill',
-			skill: candidate.name,
-			needs: 'click',
-		})
-	}
-	if (activePlan !== null && activePlan.blocked !== undefined) {
-		inbox.push({
-			kind: 'plan_blocked',
-			title: '计划被拦',
-			summary: `连续 ${activePlan.blocked.attempts} 次未过观测准入:${activePlan.blocked.reason}`,
-			plan: activePlan.id,
-			step: activePlan.blocked.step ?? null,
-			// 「解除阻塞」不是一次点击能表达的事(要改计划或改判据),所以它没有人门动作:
-			// 人说一句「按 X 改」,语义判断归模型(ClearAI 删掉 NL 白名单的同一条理由)。
-			human_action: null,
-			needs: 'word',
-			ask: '说一句怎么改(改计划 / 补判据),语义判断归模型',
-		})
-	}
-	// `has_open_gate`:有一道门开着——调度侧据此不驱动(ClearAI:两个谓词同集)。
-	const hasOpenGate = inbox.length > 0
-
 	/**
 	 * 事实那一行的**两个读数**(都派生,不另存):
 	 *   · `refuted`——它的假设收到过推翻证据 ⇒ 这条事实要复核;
 	 *   · `review` ——人已经审查过(撤回 / 维持),决定连缘由一起留着。
 	 */
-	const factRows = (state.facts ?? []).map((fact) => {
+	const lexicon = normalizeLexicon(state.lexicon)
+	/** 声明了 `retests` 的判断被推翻 ⇒ 它复检的那条事实也算被推翻(跨会话只认事实 id)。 */
+	const retestRefuted = new Set(hypotheses.filter((item) => typeof item.retests === 'string' && (item.refutations ?? 0) > 0).map((item) => item.retests))
+	const ownFacts = (state.facts ?? []).map((fact) => {
 		const linked = typeof fact.hypothesis === 'string' && fact.hypothesis !== ''
 		const owner = hypotheses.find((item) => (linked ? item.id === fact.hypothesis : String(item.claim ?? '') === String(fact.text ?? '')))
-		return { ...fact, refuted: (owner?.refutations ?? 0) > 0, review: fact.review ?? null }
+		return { ...fact, refuted: (owner?.refutations ?? 0) > 0 || retestRefuted.has(fact.id), review: fact.review ?? null, foreign: false }
 	})
+	/**
+	 * **别的会话留下的事实**(住在 `clear/knowledge/facts/<id>.json`,经 `workspace/synced` 进账)。
+	 * 同一个 id 本会话账上也有就以账上那条为准(它带着推翻读数);文件上的复核结论照样认。
+	 * 它们的假设不在本会话,所以推翻要在这里重新检验一次才算:本会话的判断用 `retests` 指向它,
+	 * 那条判断被推翻,这条事实就标「被推翻」。
+	 */
+	const ownIds = new Set(ownFacts.map((fact) => fact.id))
+	const foreignFacts = []
+	for (const [path, file] of Object.entries(state.workspace?.files ?? {})) {
+		if (classifyWorkspacePath(path)?.kind !== 'fact' || file?.data === undefined) continue
+		const row = factFromFile(file.data, path)
+		if (row === null) continue
+		if (ownIds.has(row.id)) {
+			const own = ownFacts.find((fact) => fact.id === row.id)
+			if (own.review === null && row.review !== null) own.review = row.review
+			continue
+		}
+		foreignFacts.push({ ...row, refuted: retestRefuted.has(row.id), foreign: true })
+	}
+	foreignFacts.sort((a, b) => (a.at ?? 0) - (b.at ?? 0))
+	/**
+	 * `definitionsChanged`:升格那一刻用到的词条,**含义**此后改过或已不在的那些 id。
+	 * 只是读数,不撤回事实:改了定义的人知道为什么改,复核交给人与证据。
+	 */
+	const factRows = [...foreignFacts, ...ownFacts].map((fact) => ({ ...fact, definitionsChanged: changedDefinitions(lexicon, fact.definitions) }))
 
 	/**
 	 * **领域词汇的派生读数**(两条,都不新存东西):
@@ -2250,28 +1806,43 @@ export function derive(state) {
 	 * 两者都吃 `factRows` 而不是 `state.facts`:事实的复核态与推翻标记是派生的,
 	 * 在这里重算一遍就等于第二份判据。
 	 */
-	const lexicon = normalizeLexicon(state.lexicon)
+	/**
+	 * **经验行**:本会话写下的,加上别的会话留在 `clear/knowledge/lessons/` 的。同 id 以文件为准
+	 * (人可以在文件上标 `status: "retracted"` 撤回);撤回的不再推送。新的在前。
+	 */
+	const lessonById = new Map()
+	for (const item of state.lessons ?? []) lessonById.set(item.id, { ...item })
+	for (const [path, file] of Object.entries(state.workspace?.files ?? {})) {
+		if (classifyWorkspacePath(path)?.kind !== 'lesson' || file?.data === undefined) continue
+		const row = lessonFromFile(file.data, path)
+		if (row !== null) lessonById.set(row.id, { ...lessonById.get(row.id), ...row, at: row.at ?? lessonById.get(row.id)?.at ?? null })
+	}
+	const lessonRows = [...lessonById.values()].filter((item) => item.status !== 'retracted').sort((a, b) => (b.at ?? 0) - (a.at ?? 0))
 	const conflicts = deriveConflicts(factRows, lexicon)
 	const lexiconIssues = lexiconHealth(lexicon, factRows)
-	for (const fact of factRows) {
-		/**
-		 * **推翻证据只标记事实,撤不撤由人定**(数据本身也可能是错的)。
-		 * 两种结局都要能一键落地,否则这道门没有出口:维持也是一次决定,而且它必须落账,
-		 * 不然「没决定」与「决定维持」在门的状态上长得一模一样,系统会一直等。
-		 */
-		if (fact.refuted !== true || fact.review !== null) continue
-		inbox.push({
-			kind: 'fact_refutation',
-			title: '事实被推翻,等你决定',
-			summary: `「${String(fact.text ?? '').slice(0, 90)}」出现了推翻证据:撤回它,或判证据不可靠、维持原事实。`,
-			plan: null,
-			step: null,
-			/** 标的:面板把 `value` 原样写进人门动作,宿主据此核标的存在、fold 据此落账。 */
-			value: fact.id,
-			human_action: 'retract_fact',
-			needs: 'click',
+	/**
+	 * **待处理**(第六阶段,取代空了的收件箱):只陈述、不放按钮——决定在对话里说,
+	 * 或由开门的那次调用用原生提问卡问。两类:计划连拦停下了;已写进长期知识的结论互相矛盾。
+	 * 都是派生读数:计划一解封、矛盾一方被推翻,条目自然消失。
+	 */
+	const needYou = []
+	if (activePlan !== null && activePlan.blocked !== undefined) needYou.push({ kind: 'plan_blocked', text: tr(`计划停下了:${String(activePlan.blocked.reason ?? '连续没过')},怎么改?`, `The plan stopped: ${String(activePlan.blocked.reason ?? 'it kept failing')}. How should it change?`) })
+	for (const conflict of conflicts) {
+		const values = (conflict.sides ?? []).map((side) => String(side.value ?? '?'))
+		needYou.push({
+			kind: 'conflict',
+			text: tr(
+				`${String(conflict.subject ?? '')}的${String(conflict.predicate ?? '')}:${values.map((value) => `「${value}」`).join('和')}矛盾,以哪个为准?`,
+				`${String(conflict.predicate ?? '')} of ${String(conflict.subject ?? '')}: ${values.map((value) => `"${value}"`).join(' and ')} conflict. Which one holds?`,
+			),
 		})
 	}
+	for (const fact of factRows) {
+		if (fact.definitionsChanged.length === 0 || fact.review?.decision === 'retracted') continue
+		const head = String(fact.text ?? '').replace(/\s+/g, ' ').trim()
+		needYou.push({ kind: 'definition_changed', fact: fact.id, text: tr(`「${head.length > 40 ? `${head.slice(0, 39)}…` : head}」用到的 ${fact.definitionsChanged.join('、')} 定义已变,这条结论还成立吗?`, `The definitions of ${fact.definitionsChanged.join(', ')} used by "${head.length > 40 ? `${head.slice(0, 39)}…` : head}" changed. Does this conclusion still hold?`) })
+	}
+
 
 	const settlement = state.evidence.map((item) => {
 		const step = stepOf(item.plan, item.step)
@@ -2293,14 +1864,11 @@ export function derive(state) {
 		activePlan,
 		closedPlans,
 		pendingAudit,
-		forks,
 		factRows,
+		lessonRows,
 		settlement,
 		stepOf,
-		inbox,
-		hasOpenGate,
-		planConfirmationPending,
-		planIsAuthorized,
+		needYou,
 		/** 领域词汇与它的两条派生读数(见上面那段:冲突与健康度都只是读数)。 */
 		lexicon,
 		conflicts,
@@ -2315,52 +1883,36 @@ export function derive(state) {
  *
  * 人在面板上按的每一个动作,都经宿主平面的路由变成**一条用户消息**进会话日志——
  * 内容是一行结构化标记,不是自然语言。为什么要这样:
- *   · **可审计**:谁在什么时候做了什么(采纳哪条世界线、扶正哪个技能、把档切成什么),
+ *   · **可审计**:谁在什么时候做了什么(撤回或维持哪条事实、改了哪个词条),
  *     就在日志里(`source.kind==='user'`);
  *   · **不做 NLU**:ClearAI 把确认短语白名单整体删掉了,理由是「语义判断只归模型,
  *     harness 只做顺序可判定的题」。标记进得来、自然语言进不来,是同一条纪律;
  *   · **agent 不可达**:这些动词**没有工具 schema**——模型能调的工具面里不存在它们,
  *     它只能看见「人做了什么」这条事实。
  *
- * 动词表只有 3 个(奥卡姆:另外砍掉的两个都是**重复**):
+ * 砍掉的动词(奥卡姆:都是**重复**,或者它服务的机制已经删除):
  *   · `confirm_plan` —— 原生 `dsh-plan-mode` 就是「用户复核的出口」;而我们自己的
  *     `planIsAuthorized` 本来就承认「交付第一步即授权」。计划确认从来不是闸门(它是记号),
  *     少一个假装成闸门的按钮,界面就不再暗示一条不存在的约束。需要人拍板时用原生
  *     `ask_user_question`(它同样把人的答复留在日志里,署名一样是人)。
  *   · `invoke_skill` —— 原生 `/` 技能触发器(`dsh-client-ui-skill` 注册 trigger `/`,
  *     `dsh-client-ui-input-trigger` 出候选菜单)做的正是同一件事,而且带候选菜单。
- * 留下的三个各有原生没有的职责:
- *   · `adopt_branch`/`abandon_fork` —— `ConvergeFork` 只认「算术」或「人门」两条路,
- *     算不出来时这是唯一的结构化人裁决通道(不做 NLU 是纪律,不是懒);
- *   · `promote_skill` —— 候选技能扶正是**只有人能触发**的写动作(模型不能自举)。
+ *   · `adopt_branch` / `abandon_fork` / `confirm_provisional` —— 世界线已删除,并行探索交给原生子任务;
+ *   · `promote_skill` —— 外脑已删除,技能走原生技能目录。
+ * 旧日志里的这些动作不再折:`parseHumanGate` 按动词表拒收,原样跳过。
  *
- * 已摘除:`set_autonomy`。「在场与否」是**运行时状态**(有没有门开着、有没有裁决在飞),
- * 不是人在面板上按的一个开关;那个档位还顺手把「计划经人确认」变成系统自己签的。
- * 折法里仍留一条**只读**容忍分支(见 `applyEvent` 的注释):旧会话日志里可能有一条这样的记录,
- * 而历史必须继续读得通——但**当前没有任何写入者**,面板上也没有这个开关。
+ * 已摘除:`set_autonomy`(运行档整个删了,旧日志里的这条记录原样跳过);
+ * `retract_fact` / `keep_fact`(这道门改由内核当场问人,见下面的 `LEGACY_GATE_ACTIONS`)。
  */
 export const HUMAN_GATE_MARK = '[clearai·人门]'
-/** 面板上允许出现的动词。表外的动词一律拒(与贡献表同一套「表外的名字不许出现」)。 */
-export const HUMAN_GATE_ACTIONS = [
-	'adopt_branch',
-	'abandon_fork',
-	'promote_skill',
-	'retract_fact',
-	'keep_fact',
-	'confirm_provisional',
-	/**
-	 * **本体四动词(人的通道)**:面板抽屉发的就是它们;模型有同名语义的工具
-	 * (`RegisterTerm` 等),但这两个面落的是**同一套判据与同一本账**——判据在宿主半的
-	 * `domain` 门里,词汇事件只有一种折法。这个数组在内核那一侧有一份**逐字镜像**
-	 * (预设面不能 import 这一层),两边相等由 authority-boundary 套件钉死。
-	 */
-	'register_term',
-	'register_predicate',
-	'revise_term',
-	'deprecate_entry',
-]
-/** 运行档的两个取值。**只用于读取旧日志**里的 `set_autonomy` 记录;当前没有写入口。 */
-export const AUTONOMY_VALUES = ['attended', 'unattended']
+/**
+ * **只在读旧日志时认**的动词。面板早已没有写入口(第六阶段把 `/api/clearai/gate` 整条拿掉):
+ * 撤回 / 维持事实从第三阶段起由内核在那次交付里当场问人;本体四动词随编辑抽屉一起删,
+ * 要改词汇就在对话里说,模型去改 `clear/ontology/` 下的文件。
+ * 但旧会话里人按过的决定必须照旧折出来,否则重放时一条审过的事实会变回「待复核」、
+ * 人登记的词会凭空消失。
+ */
+const LEGACY_GATE_ACTIONS = ['retract_fact', 'keep_fact', 'register_term', 'register_predicate', 'revise_term', 'deprecate_entry']
 
 /** 从一条用户消息里认出人门标记;不是标记就返回 null。 */
 export function parseHumanGate(message) {
@@ -2376,90 +1928,60 @@ export function parseHumanGate(message) {
 	try {
 		const parsed = JSON.parse(line)
 		if (parsed === null || typeof parsed !== 'object') return null
-		if (!HUMAN_GATE_ACTIONS.includes(String(parsed.action))) return null
+		if (!LEGACY_GATE_ACTIONS.includes(String(parsed.action))) return null
 		return parsed
 	} catch {
 		return null
 	}
 }
 
-/**
- * 技能面:合并目录(内核发的)+ 本会话用量(从日志折的)。
- *
- * 用量**不做跨会话统计**(第一性原理:判据混杂、没有决策者据此行动,
- * 更好的原语是「一次具体实例 + 可点开的指针」)。这里给的正是那个指针:谁在哪一步加载的、
- * 那一步**现在**是什么结果——现算,所以技能用完那一步后来又交付了,这里也跟着变。
- */
-function skillUsageView(state) {
-	const usage = state.skillUsage ?? {}
-	return Object.values(usage)
-		.map((entry) => {
-			const events = Array.isArray(entry.events) ? entry.events : []
-			const last = events.length === 0 ? null : events[events.length - 1]
-			const plan = last === null ? null : (state.plans.find((item) => item.id === last.plan) ?? null)
-			const step = plan === null || last.step === null ? null : (plan.steps.find((item) => item.id === last.step) ?? null)
-			return {
-				name: entry.name,
-				model: entry.model ?? 0,
-				human: entry.human ?? 0,
-				lastAt: entry.lastAt ?? null,
-				last:
-					last === null
-						? null
-						: {
-								by: last.by,
-								at: last.at ?? null,
-								plan: last.plan ?? null,
-								step: last.step ?? null,
-								ordinal: last.ordinal ?? null,
-								// 指针落在的这一步现在的结果(现算):advanced / open / void
-								outcome: step === null ? null : step.status,
-								evidence: step === null ? null : (step.evidence ?? null),
-								stepDo: step === null ? null : step.do,
-							},
-			}
-		})
-		.sort((left, right) => String(left.name).localeCompare(String(right.name)))
+/** 一条判断升格成的事实(按 id 关联;旧账本按文本找回)。 */
+function factOf(state, hypothesis) {
+	return (state.facts ?? []).find((item) => item.hypothesis === hypothesis.id) ?? (state.facts ?? []).find((item) => item.hypothesis === undefined && String(item.text ?? '') === String(hypothesis.claim ?? '')) ?? null
+}
+
+function factRow(state, hypothesis) {
+	const fact = factOf(state, hypothesis)
+	return fact === null ? null : { id: fact.id, text: fact.text ?? null, scope: fact.scope ?? null, level: fact.level ?? null, at: fact.at ?? null, retracted: fact.review?.decision === 'retracted' }
+}
+
+/** 面板读的历程:步骤换成「第几步」,末尾接上升格与撤回(它们不是证据,但同样改了可信度)。 */
+function historyRows(state, hypothesis) {
+	const ordinalOf = (planId, stepId) => {
+		const plan = state.plans.find((item) => item.id === planId)
+		return plan?.steps?.find((step) => step.id === stepId)?.ordinal ?? null
+	}
+	const rows = (hypothesis.history ?? []).map((row) => (row.kind === 'evidence' ? { ...row, ordinal: ordinalOf(row.plan, row.step) } : { ...row }))
+	const fact = factOf(state, hypothesis)
+	const last = () => rows[rows.length - 1]?.to ?? 'testing'
+	if (fact !== null) rows.push({ kind: 'promoted', at: fact.at ?? null, level: fact.level ?? null, from: last(), to: 'credible' })
+	if (fact?.review?.decision === 'retracted') rows.push({ kind: 'retracted', at: fact.review.at ?? null, reason: fact.review.reason ?? null, from: last(), to: 'replaced' })
+	return rows
 }
 
 /** 面板契约。浏览器读的就是这个,一字不改。 */
 export function view(state, sessionId) {
 	const derived = derive(state)
+	const promotedIds = new Set((state.facts ?? []).map((fact) => fact?.hypothesis).filter((id) => typeof id === 'string'))
 	const plan = derived.activePlan ?? derived.closedPlans[derived.closedPlans.length - 1] ?? null
 	const sid = sessionId === undefined || sessionId === null ? (state.sessionId ?? null) : String(sessionId)
 	return {
 		ok: true,
 		mounted: true,
 		sessionId: sid,
-		/** 收件箱(面板「需要你 N」的数据面):只有分诊信息,正文在各自的视图里。 */
-		inbox: derived.inbox,
-		hasOpenGate: derived.hasOpenGate,
-		/**
-		 * 运行档:`value` = 当档(内核下发的那份)、`source` 说明它从哪来(部署预设 / 旧日志里的人门记录)。
-		 * 面板与卡片都读这里 —— 投影是唯一真相。
-		 * 注意**它不是可切换的开关**:`set_autonomy` 已摘除,现在只有部署预设会下发新值;
-		 * `source === 'session'` 只可能来自旧日志。
-		 */
-		/** 项目章程的读数(面板「技能 · 记忆」页签顶部那一行;点开走原生预览)。 */
-		constitution: state.constitution ?? null,
+		/** 待处理:只陈述的几行(计划停下、结论矛盾);面板顶上与输入框旁读同一份。 */
+		needYou: derived.needYou,
 		/**
 		 * 被闸门裁断过几次(`block/counted`):世界树的**分段通道**画的就是它——
 		 * 这一步磨了几轮、其中几次被驳回。事实在投影里,面板只负责画。
 		 */
 		blocks: state.blocks ?? {},
 		/**
-		 * **人放行**(`human/released`)的痕迹:每一条都带它绑在哪条轴上
-		 * (`step` / `branch`)以及凭据(`via:'approval'`,原生审批栈的权威记录)。
+		 * **人放行**(`human/released`)的痕迹:每一条都带它绑在哪一步上
+		 * 以及凭据(`via:'ask'`:内核那次交付当场问出来的;旧账里是 `approval`)。
 		 * 面板与测试都读这里 —— 推断出来的放行不该有痕迹,所以这份读数本身就是判据。
 		 */
-		releases: (state.releases ?? []).map((item) => ({ step: item.step ?? null, plan: item.plan ?? null, fork: item.fork ?? null, branch: item.branch ?? null, via: item.via ?? null, call: item.call ?? null, at: item.at ?? null })),
-		autonomy: {
-			value: state.autonomy?.effective?.value ?? null,
-			preset: state.autonomy?.effective?.preset ?? null,
-			source: state.autonomy?.effective?.source ?? null,
-			override: state.autonomy?.override ?? null,
-		},
-		brain: state.brain ?? null,
+		releases: (state.releases ?? []).map((item) => ({ step: item.step ?? null, plan: item.plan ?? null, via: item.via ?? null, call: item.call ?? null, at: item.at ?? null })),
 		/** 本体形状(面板页眉据此生成,不手抄)。 */
 		ontology: state.ontology ?? null,
 		/**
@@ -2474,6 +1996,9 @@ export function view(state, sessionId) {
 			conflicts: derived.conflicts,
 			health: derived.lexiconIssues,
 			graph: graphProjection(state),
+			/** 本体文件里的实体(带所在目录的容器)与跨文件问题:本体页的问题列表读它。 */
+			entities: Array.isArray(state.entities) ? state.entities : [],
+			problems: Array.isArray(state.ontologyProblems) ? state.ontologyProblems : [],
 		},
 		/**
 		 * **知识模式(分诊)**:面板据此把「这一格是知识主场还是普通进展」说清楚,
@@ -2496,23 +2021,6 @@ export function view(state, sessionId) {
 		 * 面板可以画它,内核的 pre-step 把它送进卡——判据与缺口读数一样,只有这一处。
 		 */
 		preflight: knowledgePreflight(state, derived),
-		/**
-		 * 续跑窗口的账:面板读它,于是「续跑停着——等裁决」这种**平台说不出来的话**
-		 * 有地方说。轮数与相位仍然只在原生 dock 上出现(一个事实只在**一块**面上说),
-		 * 这里交出去的只有:状态、它服务的事实对象、以及停下来的真实理由。
-		 */
-		continuation:
-			state.continuation === null || state.continuation === undefined
-				? null
-				: {
-						state: state.continuation.state,
-						goal: state.continuation.goal ?? null,
-						target: state.continuation.target ?? null,
-						why: state.continuation.why ?? null,
-						label: state.continuation.label ?? null,
-					},
-		/** 技能面:合并目录 + 本会话用量(「技能 · 记忆」页签的数据面)。 */
-		skills: { catalog: state.skillCatalog ?? null, usage: skillUsageView(state) },
 		goal:
 			state.goal === null
 				? null
@@ -2530,15 +2038,20 @@ export function view(state, sessionId) {
 						closeVerdict: state.goal.closeVerdict ?? null,
 						hypotheses: derived.hypotheses.map((hypothesis) => ({
 							id: hypothesis.id,
+							name: handleOf(hypothesis),
+							/** 可信度分组(已验证 / 待核验 / 验证中 / 不确定 / 已推翻 / 已替换),面板与卡同一份。 */
+							trust: trustOf(hypothesis, promotedIds.has(hypothesis.id)),
 							claim: hypothesis.claim,
 							refuteWhen: hypothesis.refute_when,
 							status: hypothesis.status,
 							supportedLevel: hypothesis.supportedLevel,
 							refutations: hypothesis.refutations,
 							inconclusive: hypothesis.inconclusive,
-							/** 从没被走过的等级(派生):面板据此说清「这一级是跳上来的」。 */
-							untouchedLevels: hypothesis.untouchedLevels,
 							version: hypothesis.version,
+							/** 「可信度怎么变的」:逐笔的之前 → 之后,末尾接上写进长期知识 / 被撤回。 */
+							history: historyRows(state, hypothesis),
+							/** 写进长期知识的那条(没升格就是 null):补充段的「范围」读它。 */
+							fact: factRow(state, hypothesis),
 							/** 断言随假设走(未升格):面板同画芯片(chip 同样在投影侧算好),标注「未升格」。 */
 							assertions: Array.isArray(hypothesis.assertions)
 								? hypothesis.assertions.map((assertion) => ({ ...assertion, chip: formatAssertion(state.lexicon, assertion) }))
@@ -2564,7 +2077,9 @@ export function view(state, sessionId) {
 				doneCriteria: step.done_criteria,
 				tests: step.tests,
 				status: step.status,
-				evidenceId: step.evidence,
+				evidenceIds: step.evidence ?? [],
+				/** 交付本身(谁判的、凭什么、出处);旧账为 null。 */
+				delivery: step.delivery ?? null,
 				advancedAt: step.advancedAt,
 				voidReason: step.voidReason,
 			})),
@@ -2578,10 +2093,6 @@ export function view(state, sessionId) {
 						/** 计划自己的一句话(模型建计划时写的)。**给人看的名字**用它,内部 id 退回 tooltip。 */
 						brief: plan.brief ?? '',
 						blocked: plan.blocked ?? null,
-						// 授权记号(ClearAI `plan.confirmed_at` / `confirmed_by`):面板据此显示计划门。
-						confirmedAt: plan.confirmed_at ?? null,
-						confirmedBy: plan.confirmed_by ?? null,
-						confirmationPending: derived.planConfirmationPending && plan === derived.activePlan,
 						steps: plan.steps.map((step) => ({
 							id: step.id,
 							ordinal: step.ordinal,
@@ -2595,7 +2106,9 @@ export function view(state, sessionId) {
 							doneCriteria: step.done_criteria,
 							tests: step.tests,
 							status: step.status,
-							evidenceId: step.evidence,
+							evidenceIds: step.evidence ?? [],
+							/** 交付本身(谁判的、凭什么、出处);旧账为 null。 */
+							delivery: step.delivery ?? null,
 							advancedAt: step.advancedAt,
 							voidReason: step.voidReason,
 						})),
@@ -2623,12 +2136,11 @@ export function view(state, sessionId) {
 			stepId: item.step,
 			planId: item.plan,
 			/**
-			 * `branch` 与 `anchor` **必须交出去**:面板要给每条证据指一个**出处**——
-			 * 独立证据指评估卡(文件)、自判证据指它锚定的产物。少了这两个字段,
-			 * 「评估卡」那一项永远出不来(成因:世界线证据的评估卡按 `分支` 归属,
-			 * 与证据的 `stepId` 不是同一个 id,只看 stepId 会对不上)。
+			 * `anchor` **必须交出去**:面板要给每条证据指一个**出处**——
+			 * 独立证据指评估卡(文件)、自判证据指它锚定的产物。
 			 */
-			branch: item.branch ?? null,
+			/** 针对哪条判断(旧账为 null:由步骤检验的判断找回来)。 */
+			hypothesis: item.hypothesis ?? null,
 			anchor: item.anchor ?? 'artifact',
 			/** 记账时定下的出处。旧日志没有这个字段 ⇒ 客户端走只读回退。 */
 			origins: item.origins ?? [],
@@ -2666,6 +2178,8 @@ export function view(state, sessionId) {
 		facts: derived.factRows.map((item) => ({
 			id: item.id,
 			text: item.text,
+			/** 产出它的那条判断(旧账本没有,面板把这种事实单独列成一行)。 */
+			hypothesis: item.hypothesis ?? null,
 			/** 边界(推翻条件)与支持等级:面板与货架都要显示它——「已知」必须带边界。 */
 			scope: item.scope ?? null,
 			level: item.level ?? null,
@@ -2681,91 +2195,6 @@ export function view(state, sessionId) {
 			refuted: item.refuted === true,
 			review: item.review ?? null,
 		})),
-		/**
-		 * 侦察记录:**结局要能看出来**。
-		 *
-		 * 失效模式:中断一次跑动之后「状态上全部显示执行完成」,而宿主其实报了失败。
-		 * 两处都修了:内核改成按 `stopReason` 落账(aborted/error 不算完成),这里把 `note` 交出去
-		 * 并派生成三态——跑着 / 正常回灌 / 没正常结束。面板与资料面据此分诊,而不是一律当"完成"。
-		 */
-		scouts: (state.scouts ?? []).map((item) => ({
-			id: item.id,
-			stepId: item.step,
-			trigger: item.trigger,
-			child: item.child,
-			capability: item.capability,
-			digest: item.digest ?? null,
-			conclusion: item.conclusion,
-			at: item.at,
-			note: item.note ?? null,
-			path: item.path ?? null,
-			status: item.conclusion === null || item.conclusion === undefined ? 'running' : item.note === null || item.note === undefined ? 'settled' : 'failed',
-		})),
-		forks: derived.forks.map((fork) => ({
-			tier: fork.tier ?? null,
-			degradedReason: fork.degradedReason ?? null,
-			merge: fork.merge ?? null,
-			mergeConflict: fork.mergeConflict ?? null,
-			/** 临时采纳:分差不足以称结论(或由判断而来)→ 面板要给「待复核」标记。 */
-			provisional: fork.merge?.provisional === true,
-			decisionNote: fork.merge?.decisionNote ?? null,
-			/** 人在面板上的裁决(结构化记录,by:'user'):内核的工具据此落实它。 */
-			humanDecision: fork.humanDecision ?? null,
-			id: fork.id,
-			stepId: fork.step,
-			question: fork.question,
-			phase: fork.phase,
-			decided: fork.settled,
-			abandonReason: fork.abandonReason,
-			/** 承载它的步骤现在是什么状态(void = 承诺已撤回)——面板据此说「随步骤作废而终止」。 */
-			ownerStatus: fork.ownerStatus ?? null,
-			ownerVoidReason: fork.ownerVoidReason ?? null,
-			/** 派生:步骤作废 + 还没收口。不是新状态,是两个事实的推论(见 derive 里的说明)。 */
-			orphaned: fork.orphaned === true,
-			decideBy: { metric: fork.decide_by?.metric ?? null, direction: fork.decide_by?.direction ?? null },
-			verdict: fork.verdict,
-			undecidable: fork.undecidable,
-			/**
-			 * 算术推荐(`fork/recommended`):人门卡与面板的「推荐★」读的就是它。
-			 * 它只在分叉**还没收口**时才有意义——收口之后 `verdict.winner` 才是结论。
-			 */
-			recommended: fork.recommended ?? null,
-			recommendMargin: fork.recommendMargin ?? null,
-			recommendProvisional: fork.recommendProvisional === true,
-			recommendBy: fork.recommendBy ?? null,
-			/** 采纳时没能合并(以及为什么):决定登记了,产物靠一次普通交付落位。 */
-			mergeSkipped: fork.mergeSkipped ?? null,
-			arbitration: fork.arbitration ?? null,
-			arbitrationSession: fork.arbitrationSession ?? null,
-			branches: fork.branches.map((branch) => ({
-				id: branch.id,
-				label: branch.label,
-				approach: branch.approach,
-				doneCriteria: branch.done_criteria,
-				workspace: branch.workspace,
-				level: branch.level,
-				status: branch.status,
-				reading: branch.reading,
-				validity: branch.validity,
-				/** 派生:执行没跑成(`execution.ok === false`)。**它不是落选**——面板要分开说。 */
-				failed: branch.failed === true,
-				orphaned: branch.orphaned === true,
-				/** 派生:分叉已收口而执行者没报过 ⇒ 那句「结论会自动回灌」作废(见 derive 里的说明)。 */
-				unreturned: branch.unreturned === true,
-				execution: branch.execution ?? null,
-				verdict: branch.verdict,
-				basis: branch.basis,
-				evaluator: branch.evaluator,
-				execution: branch.execution ?? null,
-				cardPath: branch.card_path ?? null,
-				evaluatorSession: branch.evaluator_session ?? null,
-				gitBranch: branch.git_branch ?? null,
-				worktreePath: branch.worktree_path ?? null,
-				worktreeRemoved: branch.worktree_removed === true,
-				keptRef: branch.kept_ref !== false,
-				at: branch.at,
-			})),
-		})),
 	}
 }