clearai-dsh 0.4.0 → 0.5.0

package/lib/knowledge-view.js

@@ -18,7 +18,7 @@
  * 面向人的新字符串一律先落在 `GLOSSARY`(内部词 → 一句 plain + 在哪看 + 下一步做什么);
  * `client.js` 的 `LOCALE_ZH/LOCALE_EN` 与它同源登记。
  */
-import { graphProjection, ontologyOutline } from './domain-language.js'
+import { graphProjection } from './domain-language.js'
 import { bilingual, tr } from './lang.js'
 
 /** 卡文本上限。模型每一步只读这一张卡,而卡是**每回合**重算的:它必须小到能进预算。 */
@@ -192,7 +192,8 @@ export const LEVELS = ['L0', 'L1', 'L2', 'L3', 'L4']
  * **说人话的三张小表**(第六阶段)。内部名不改;卡、工具结果与面板上一律写右边那一列。
  * 模型读到什么就会照着说什么——所以卡先说人话,答复才说得出人话。
  */
-export const LEVEL_WORD = bilingual({ L0: ['自己推了一遍', 'reasoned through alone'], L1: ['引用已有材料', 'cites existing material'], L2: ['可复算', 'reproducible'], L3: ['独立核验', 'independent check'], L4: ['人放行', 'released by a person'] })
+/** 等级只说三档:L0–L2 合并成「自己检验」(旧账里的 L0 / L1 也这么读),L3 独立评估,L4 人放行。 */
+export const LEVEL_WORD = bilingual({ L0: ['自己检验', 'self-tested'], L1: ['自己检验', 'self-tested'], L2: ['自己检验', 'self-tested'], L3: ['独立核验', 'independent check'], L4: ['人放行', 'released by a person'] })
 export const VERDICT_WORD = bilingual({ support: ['支持', 'support'], refute: ['推翻', 'refute'], inconclusive: ['不确定', 'inconclusive'] })
 /** 判断短名的上限(汉字);没起名时取主张开头这么宽。与内核同一个数。 */
 export const HANDLE_LIMIT = 12
@@ -337,6 +338,15 @@ export function readingOf(hypothesis) {
 /** 步骤状态的人话。 */
 const STEP_WORD = bilingual({ open: ['待做', 'to do'], advanced: ['已交付', 'delivered'], void: ['已作废', 'voided'] })
 
+/** 一条事实在卡上的一行:原话、边界、等级;来自别的会话的标出来。 */
+function factLine(fact) {
+	const scope = oneLine(fact?.scope ?? '')
+	return tr(
+		`  · 「${clamp(fact?.text, 100)}」${scope === '' ? '' : ` — 边界:${clamp(scope, 80)}`}${fact?.level ? ` · ${fact.level}` : ''}${fact?.foreign === true ? ' · 以前的会话' : ''}`,
+		`  · "${clamp(fact?.text, 100)}"${scope === '' ? '' : ` — boundary: ${clamp(scope, 80)}`}${fact?.level ? ` · ${fact.level}` : ''}${fact?.foreign === true ? ' · earlier session' : ''}`,
+	)
+}
+
 /**
  * **卡的正文**。它只读已经算好的 `view` 与 `(state, derived)`,不重算任何判据——
  * 同一份账本永远给出同一串字节:卡里**不带时刻**——时间戳会让同一个状态的卡每分钟变一次,
@@ -358,8 +368,6 @@ function cardLines(state, derived, options, view) {
 	const evidence = Array.isArray(state?.evidence) ? state.evidence : []
 	const facts = Array.isArray(state?.facts) ? state.facts : []
 	const hostHealth = Array.isArray(state?.hostHealth) ? state.hostHealth : []
-	const graph = graphProjection(state)
-	const entityNodes = graph.nodes.filter((node) => node.layer === 'entity')
 	const promotedIds = new Set(facts.map((fact) => fact?.hypothesis).filter((id) => typeof id === 'string'))
 	const byId = new Map(hypotheses.map((hypothesis) => [hypothesis.id, hypothesis]))
 	const nameOf = (id) => (byId.has(id) ? tr(`「${handleOf(byId.get(id))}」`, `"${handleOf(byId.get(id))}"`) : tr('一条已不在账上的判断', 'a judgment no longer on record'))
@@ -423,16 +431,53 @@ function cardLines(state, derived, options, view) {
 		}
 		if (plan.steps.length > 12) push(tr(`  · 还有 ${plan.steps.length - 12} 步没展开(右栏「世界树」里有全部)`, `  · ${plan.steps.length - 12} more steps not shown (all are in the World Tree on the right)`), 2)
 		const first = plan.steps.find((step) => step.status === 'open')
-		if (first !== undefined) push(tr(`- 下一步:交付第 ${first.ordinal} 步(${first.id})——只能交付第一个没做完的步`, `- Next: deliver step ${first.ordinal} (${first.id}); only the first unfinished step can be delivered`))
+		if (first !== undefined) {
+			push(tr(`- 下一步:交付第 ${first.ordinal} 步(${first.id})——只能交付第一个没做完的步`, `- Next: deliver step ${first.ordinal} (${first.id}); only the first unfinished step can be delivered`))
+			/** 预期可选,但卡上提醒:没写下来的预期,落空了也看不见。 */
+			if (typeof first.expect === 'string' && first.expect !== '') push(tr(`  预期:${clamp(first.expect, 160)}——结果对不上的地方写进 anomalies,不要解释过去`, `  Expected: ${clamp(first.expect, 160)}; whatever does not match goes in anomalies, do not explain it away`))
+			else push(tr('  动手前写下预期(RevisePlan action="expect":预计看到什么、从哪条关系或经验来),落空才看得见', '  Before acting, write the expectation (RevisePlan action="expect": what you expect and from which relation or lesson), so a miss is visible'), 1)
+		}
 		else if (goal !== null && String(goal.status) === 'open') push(tr('- 下一步:计划的步都做完了,ClosePlan 收尾,然后 Conclude 结案或开下一阶段', '- Next: every step is done; ClosePlan, then Conclude or start the next stage'))
 		if (plan.blocked !== undefined && plan.blocked !== null) push(tr(`- 计划停下等人:${plan.blocked.reason}(连续 ${plan.blocked.attempts} 次没过,已经问人怎么办;没人答就等着)`, `- Plan stopped, waiting for a person: ${plan.blocked.reason} (failed ${plan.blocked.attempts}× in a row; a person has been asked; wait if nobody answers)`))
 	}
+	/**
+	 * **未解释项**:卡上最不能省的一格。开着的逐条摆出来,直到被解释、写明理由排除、或交给人;
+	 * 评估者报的标出来(那是做的人自己没看见的)。
+	 */
+	const anomalies = Array.isArray(state?.anomalies) ? state.anomalies : []
+	const openAnomalies = anomalies.filter((item) => item?.status === 'open')
+	if (openAnomalies.length > 0) {
+		push(tr(`- 未解释(${openAnomalies.length} 条开着;用 Anomaly 解释、排除或交给人,不要解释过去):`, `- Unexplained (${openAnomalies.length} open; explain, rule out or hand to a person with Anomaly; do not explain them away):`))
+		for (const item of openAnomalies.slice(0, 8)) push(tr(`  · ${item.id}${item.by === 'evaluator' ? '(评估者发现)' : ''}:${clamp(item.what, 140)}${item.anchor ? ` · 在 ${clamp(item.anchor, 30)}` : ''}`, `  · ${item.id}${item.by === 'evaluator' ? ' (found by the evaluator)' : ''}: ${clamp(item.what, 140)}${item.anchor ? ` · on ${clamp(item.anchor, 30)}` : ''}`))
+		if (openAnomalies.length > 8) push(tr(`  · 还有 ${openAnomalies.length - 8} 条`, `  · ${openAnomalies.length - 8} more`), 1)
+	}
+	const settledAnomalies = anomalies.length - openAnomalies.length
+	if (settledAnomalies > 0) {
+		const escalated = anomalies.filter((item) => item?.status === 'escalated').length
+		push(tr(`- 已处理的未解释:${settledAnomalies} 条${escalated > 0 ? `(${escalated} 条交给人)` : ''},结案时随交付交给评估者`, `- Unexplained items handled: ${settledAnomalies}${escalated > 0 ? ` (${escalated} handed to a person)` : ''}; they go to the evaluator with the delivery`), 2)
+	}
 	if (evidence.length > 0) {
 		const last = evidence[evidence.length - 1]
 		const who = last.evaluator === 'independent' ? LEVEL_WORD.L3 : LEVEL_WORD[last.level] ?? tr('自己判的', 'self-judged')
 		const target = last.hypothesis === null || last.hypothesis === undefined ? tr('目标判据', 'goal criteria') : nameOf(last.hypothesis)
 		push(tr(`- 最近一次结果:${target}${VERDICT_WORD[last.verdict] ?? last.verdict}(${who})`, `- Latest result: ${target} ${VERDICT_WORD[last.verdict] ?? last.verdict} (${who})`), 1)
 	}
+	/**
+	 * **经验**:以前结案时核过的「下次怎么做」。只在要做决定的时候摆出来:立题前、定计划前、
+	 * 下一步动手而还没写预期时。与眼下目标和下一步提到同一装置或量的排在前面。
+	 */
+	const lessonRows = Array.isArray(derived?.lessonRows) ? derived.lessonRows : []
+	const nextStep = plan === null ? null : (plan.steps.find((step) => step.status === 'open') ?? null)
+	const deciding = goal === null || String(goal.status) !== 'open' || plan === null || (nextStep !== null && (typeof nextStep.expect !== 'string' || nextStep.expect === ''))
+	if (lessonRows.length > 0 && deciding) {
+		const context = `${goal?.claim ?? ''}\n${nextStep?.do ?? ''}`.toLowerCase()
+		const score = (lesson) => (lesson.about ?? []).filter((item) => item !== '' && context.includes(String(item).toLowerCase())).length
+		const ranked = lessonRows.map((lesson, index) => ({ lesson, index, score: score(lesson) })).sort((a, b) => b.score - a.score || a.index - b.index)
+		const kindWord = { trap: tr('坑', 'trap'), check: tr('先核', 'check'), shortcut: tr('别走的捷径', 'misleading shortcut'), prior: tr('先验', 'prior') }
+		push(tr(`- 以前留下的经验(${lessonRows.length} 条;定计划、写预期前先看,用上了就在预期里写明来自哪条):`, `- Lessons left earlier (${lessonRows.length}; read before planning or writing an expectation, and name the one you use in the expectation):`), 1)
+		for (const { lesson } of ranked.slice(0, 6)) push(`  · ${lesson.id} · ${kindWord[lesson.kind] ?? lesson.kind} · ${clamp(lesson.text, 160)}${lesson.boundary ? tr(`(不适用:${clamp(lesson.boundary, 80)})`, ` (does not apply: ${clamp(lesson.boundary, 80)})`) : ''}`, 1)
+		if (lessonRows.length > 6) push(tr(`  · 还有 ${lessonRows.length - 6} 条(clear/knowledge/lessons/)`, `  · ${lessonRows.length - 6} more (clear/knowledge/lessons/)`), 2)
+	}
 	/** 事实行含别的会话留下的(`foreign`):攒下来的东西从这里开始被看见。 */
 	const factRows = Array.isArray(derived?.factRows) ? derived.factRows : facts
 	if (factRows.length > 0) {
@@ -447,23 +492,21 @@ function cardLines(state, derived, options, view) {
 		)
 	}
 	/**
-	 * **本体大纲**:概念树与实体树的前两层(每支标节点数)、关系总数、跨文件问题。
-	 * 细节在 clear/ontology/ 下的文件里,模型自己去读。
+	 * **立题之前**(或上一个目标已结):以前留下的事实原话与边界直接摆出来(最多 5 条)。立题是最该看已知的时刻,
+	 * 这时还没有判断可以拿来做词面命中,所以按新近给。
+	 */
+	if (goal === null || String(goal.status) !== 'open') {
+		const usable = factRows.filter((fact) => fact?.review?.decision !== 'retracted' && fact?.refuted !== true)
+		if (usable.length > 0) {
+			push(tr('- 以前留下的事实(立题前先看;要复检哪条,就在判断上写 retests,claim 照抄原话):', '- Facts left earlier (read before framing; to re-test one, put retests on a judgment with the original statement as the claim):'), 1)
+			for (const fact of usable.slice(-5).reverse()) push(factLine(fact), 1)
+		}
+	}
+	/**
+	 * 本体提纲与计数不上卡(它从没改变过下一步):卡上只出现被判断引用到的本体项(见下面的预检)。
+	 * 跨文件问题照旧报——那是要修的东西。
 	 */
-	const outline = ontologyOutline(state)
 	const ontologyProblems = Array.isArray(state?.ontologyProblems) ? state.ontologyProblems : []
-	if (outline.concepts.total > 0 || outline.entities.total > 0 || outline.relations > 0) {
-		const entityRelations = Array.isArray(state?.entityAssertions) ? state.entityAssertions.length : 0
-		push(
-			tr(
-				`- 本体(clear/ontology/):${outline.concepts.total} 个概念 · ${outline.relations} 种关系 · ${outline.entities.total} 个实体 · ${entityRelations} 条实体关系`,
-				`- Ontology (clear/ontology/): ${outline.concepts.total} concepts · ${outline.relations} relation types · ${outline.entities.total} entities · ${entityRelations} entity relations`,
-			),
-			1,
-		)
-		if (outline.concepts.lines.length > 0) push(tr(`  · 概念树:${outline.concepts.lines.join(';')}${outline.concepts.more > 0 ? `;顶层还有 ${outline.concepts.more} 个` : ''}`, `  · Concept tree: ${outline.concepts.lines.join('; ')}${outline.concepts.more > 0 ? `; ${outline.concepts.more} more at the top level` : ''}`), 1)
-		if (outline.entities.lines.length > 0) push(tr(`  · 实体树:${outline.entities.lines.join(';')}${outline.entities.more > 0 ? `;顶层还有 ${outline.entities.more} 个` : ''}`, `  · Entity tree: ${outline.entities.lines.join('; ')}${outline.entities.more > 0 ? `; ${outline.entities.more} more at the top level` : ''}`), 1)
-	} else if (entityNodes.length > 0) push(tr(`- 实体图上 ${entityNodes.length} 个实例`, `- ${entityNodes.length} instances on the entity graph`), 1)
 	if (ontologyProblems.length > 0) {
 		push(tr(`- 本体文件有 ${ontologyProblems.length} 处问题(有问题的节点或关系没进图):`, `- Ontology files have ${ontologyProblems.length} problems (the affected nodes or relations stay off the graph):`), 1)
 		for (const item of ontologyProblems.slice(0, 5)) push(`  · ${item.path}: ${clamp(item.detail, 160)}`, 1)
@@ -474,14 +517,30 @@ function cardLines(state, derived, options, view) {
 	}
 	if (knowledge.mode === 'knowledge') {
 		const preflight = view.deliver.preflight
-		if (preflight !== null && (preflight.terms.length > 0 || preflight.predicates.length > 0)) {
+		if (preflight !== null && (preflight.terms.length > 0 || preflight.predicates.length > 0 || preflight.facts.length > 0)) {
+			/**
+			 * **递原文,不递名单**:命中的概念给它的释义(度量就是口径),命中的事实给原话与边界。
+			 * 只给名字,模型得自己去翻文件——真跑里它从不去翻,本体于是从没影响过一次判断。
+			 */
 			const more = (count) => (count > 0 ? tr(`(还有 ${count} 个)`, ` (${count} more)`) : '')
 			const named = (entry) => (entry.label === entry.id ? entry.id : `${entry.label}(${entry.id})`)
-			const none = tr('无', 'none')
-			const terms = preflight.terms.map(named).join(tr('、', ', ')) || none
-			const predicates = preflight.predicates.map(named).join(tr('、', ', ')) || none
-			push(tr(`- 已有的词,可直接用:概念 ${terms}${more(preflight.termsTruncated)};关系 ${predicates}${more(preflight.predicatesTruncated)}`, `- Existing terms you can use: concepts ${terms}${more(preflight.termsTruncated)}; relations ${predicates}${more(preflight.predicatesTruncated)}`), 1)
-			if (preflight.facts.length > 0) push(tr(`  · 能复用的已知 ${preflight.facts.length} 条${preflight.factsTruncated > 0 ? `(还有 ${preflight.factsTruncated} 条)` : ''}`, `  · ${preflight.facts.length} known facts to reuse${preflight.factsTruncated > 0 ? ` (${preflight.factsTruncated} more)` : ''}`), 1)
+			if (preflight.terms.length > 0) {
+				push(tr(`- 这些判断用到的概念(释义就是口径,算法变了先改它)${more(preflight.termsTruncated)}:`, `- Concepts these judgments use (the gloss is the definition; if how it is computed changes, update it first)${more(preflight.termsTruncated)}:`), 1)
+				for (const term of preflight.terms.slice(0, 4)) push(`  · ${named(term)}:${clamp(term.gloss, 100) || tr('(没写释义)', '(no gloss)')}${term.unit ? tr(`(单位 ${term.unit})`, ` (unit ${term.unit})`) : ''}`, 1)
+			}
+			/** 带形状或核对办法的关系逐条给(预期从这里来);其余只给名字。 */
+			const SHAPE_WORD = { increasing: tr('单调升', 'increasing'), decreasing: tr('单调降', 'decreasing'), peak: tr('有峰', 'has a peak'), threshold: tr('有阈值', 'has a threshold'), coupled: tr('与别的量耦合', 'coupled with another quantity') }
+			const telling = preflight.predicates.filter((predicate) => predicate.shape || predicate.check)
+			const plain = preflight.predicates.filter((predicate) => !(predicate.shape || predicate.check))
+			if (telling.length > 0) {
+				push(tr('- 用到的关系(预期从这里来):', '- Relations in use (expectations come from these):'), 1)
+				for (const predicate of telling.slice(0, 4)) push(`  · ${named(predicate)}${predicate.shape ? tr(`:${SHAPE_WORD[predicate.shape] ?? predicate.shape}`, `: ${SHAPE_WORD[predicate.shape] ?? predicate.shape}`) : ''}${predicate.gloss ? tr(`(${clamp(predicate.gloss, 80)})`, ` (${clamp(predicate.gloss, 80)})`) : ''}${predicate.check ? tr(` · 读数这样核:${clamp(predicate.check, 80)}`, ` · check readings by: ${clamp(predicate.check, 80)}`) : ''}`, 1)
+			}
+			if (plain.length > 0) push(tr(`- 用到的关系:${plain.slice(0, 6).map(named).join('、')}${more(preflight.predicatesTruncated)}`, `- Relations in use: ${plain.slice(0, 6).map(named).join(', ')}${more(preflight.predicatesTruncated)}`), 2)
+			if (preflight.facts.length > 0) {
+				push(tr(`- 和这些判断有关的已知${more(preflight.factsTruncated)}(引用前看边界;要复检就在判断上写 retests):`, `- Known facts related to these judgments${more(preflight.factsTruncated)} (check the boundary before citing; to re-test, put retests on a judgment):`), 1)
+				for (const fact of preflight.facts.slice(0, 3)) push(factLine(fact), 1)
+			}
 		} else
 			push(
 				tr(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clearai-dsh",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "ClearAI: an ontology-first DSH agent preset — evidence-checked research that grows into a domain ontology.",
   "type": "module",
   "private": false,
@@ -37,7 +37,7 @@
   ],
   "engines": {
     "node": ">=22",
-    "dsh": ">=0.1.7-alpha.1"
+    "dsh": ">=0.2.0-rc.2"
   },
   "dependencies": {
     "zod": "^4.6.1"

package/presets/clearai/agent.cordis.yml

@@ -135,7 +135,7 @@
 
 # ── 认识论内核(本预设的灵魂) ───────────────────────────────────────────────
 
-# 6 件意图工具(目标 2 + 计划 4,见 `MECHANISM_TOOLS`;领域本体没有工具,
+# 7 件意图工具(目标 2 + 计划 5,见 `MECHANISM_TOOLS`;领域本体没有工具,
 #   模型用原生文件工具直接写 clear/ontology/{concepts,relations,entities}/**.json)
 # + 一个 guard + 每回合派生的运行态卡 + 面板数据路由。
 # 逐条对照 docs/loop-philosophy.md 的哲学,见 ./plugins/clearai-kernel.js 的文件头。
@@ -191,6 +191,9 @@
     auditProvider: spawn
     auditTimeoutMs: 240000
     # 评估者只读:工具面只给 read/glob/grep;provider 不支持时会降级,降级事实写进台账
+    # 评估者可以复跑:内核把工作区(不含 clear/)复制到临时目录,评估者在副本里跑产物自带的脚本核数字,
+    # 工具面因此多一个 bash;原工作区只读。L3「可重跑」这才名副其实。
+    auditRerun: true
     auditToolFilter:
       - read
       - glob
@@ -205,7 +208,7 @@
     # 当场抛错——未知机制 / 未知工具 / 未知段 / 已关机制却仍列着它的工具,四种错法都在装配期炸,
     # 而不是静默少装一件工具、等某一轮才发现。
     #
-    # 这里只写**机制开关**;tools / sections 缺省 = 目录全量(6 件意图工具、3 段提示词,全部在场)。
+    # 这里只写**机制开关**;tools / sections 缺省 = 目录全量(7 件意图工具、3 段提示词,全部在场)。
     # 这些数字不靠人眼维持:`node tools/verify-truth-table.mjs` 会拿代码算出来的数核对它们。
     # 要裁剪就把 tools 或 sections 显式写出来:
     #   tools: [Frame, CreatePlan, AdvancePlan, ...]      # 名字必须都在工具目录里

package/presets/clearai/clearai.patch.yml

@@ -152,7 +152,7 @@
 
           # ── 认识论内核(本预设的灵魂) ───────────────────────────────────────────────
 
-          # 6 件意图工具(目标 2 + 计划 4,见 `MECHANISM_TOOLS`;领域本体没有工具,
+          # 7 件意图工具(目标 2 + 计划 5,见 `MECHANISM_TOOLS`;领域本体没有工具,
           #   模型用原生文件工具直接写 clear/ontology/{concepts,relations,entities}/**.json)
           # + 一个 guard + 每回合派生的运行态卡 + 面板数据路由。
           # 逐条对照 docs/loop-philosophy.md 的哲学,见 ./plugins/clearai-kernel.js 的文件头。
@@ -208,6 +208,9 @@
               auditProvider: spawn
               auditTimeoutMs: 240000
               # 评估者只读:工具面只给 read/glob/grep;provider 不支持时会降级,降级事实写进台账
+              # 评估者可以复跑:内核把工作区(不含 clear/)复制到临时目录,评估者在副本里跑产物自带的脚本核数字,
+              # 工具面因此多一个 bash;原工作区只读。L3「可重跑」这才名副其实。
+              auditRerun: true
               auditToolFilter:
                 - read
                 - glob
@@ -222,7 +225,7 @@
               # 当场抛错——未知机制 / 未知工具 / 未知段 / 已关机制却仍列着它的工具,四种错法都在装配期炸,
               # 而不是静默少装一件工具、等某一轮才发现。
               #
-              # 这里只写**机制开关**;tools / sections 缺省 = 目录全量(6 件意图工具、3 段提示词,全部在场)。
+              # 这里只写**机制开关**;tools / sections 缺省 = 目录全量(7 件意图工具、3 段提示词,全部在场)。
               # 这些数字不靠人眼维持:`node tools/verify-truth-table.mjs` 会拿代码算出来的数核对它们。
               # 要裁剪就把 tools 或 sections 显式写出来:
               #   tools: [Frame, CreatePlan, AdvancePlan, ...]      # 名字必须都在工具目录里