ygl-trees 0.81.0 → 0.82.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.82.1（2026-10-17）预测生命周期护栏：挂证据 ≠ 仲裁
+- **`claim link` 不再抢跑预测仲裁**（用户上报③：`--stance supports` 自动把 [预测·…] 断言置 supported，predict audit 判 supported||refuted → resolved——预测刚挂证据就退出跟踪表，实际无人仲裁）：预测前缀断言挂证据时跳过自动晋升，状态保持 unverified 直到显式 `claim resolve` / 到期回测；证据链接与 stance 照常落库，回执明示 `auto_promote: false`（`--json` 返回 `{claim, evidence, stance, status, auto_promote}`）；普通断言的自动推导不变（回归护栏）
+- **`claim unresolve <claimId>`**（建议②：误晋升后无归位命令）：复位通道把断言重置回 unverified（撤销链接副作用 / 抢跑仲裁），幂等（已 unverified → `duplicate:true`），落 `claim.unresolve` 事件留痕——0.82.1 前被误晋升的预测可用它归队
+- **predict audit `--json` 覆盖确认**（建议③）：`--json` 始终输出全量 rows（含 resolved 终态行），人类视图默认隐藏终态——机器读全量、人看增量，同构无缺口
+- 测试：predlink.spec.ts 5 例（预测不晋升 / 普通照常推导 / unresolve 复位+事件 / 幂等 / 坏 id 点名）→ 177；demo 5j 段 5 断言（挂证据不晋升 / 普通推导回归 / unresolve 复位 / 幂等 / 复位后仍在跟踪表）→ 106
+
+## 0.82.0（2026-10-17）跨树巡检 + 临期 eval 门槛 + 幻影对账一键修复
+- **`node ready --all`**（用户建议②：12 棵树巡检要 24 条命令——每树 tree use + ready）：一次进程扫全部树的就绪集，无需 tree use / `-t`；`--json` 返回 `[{tree, ready[]}]`，人类输出按树分节
+- **`node cond --due [--days N] [--eval]`**（建议③：w1/d90 检验依赖人记得看）：扫描全部 eval 族条件，提取问题文本中的 `YYYY-MM-DD` 期限，列出 N 天内到期（含逾期）的条件（树/节点/deadline/剩余天数）；`--days` 放宽窗口（默认 7）；`--eval` 逐条组装上下文包送判定模型（三题型按 op 自动选择，离线安全回落 pending）——**判定只报告不仲裁**，通过 ≠ 自动解锁，resolve/unlock 保持人工（与 predict audit 同纪律）；跨树扫描前置于树解析，无当前树也能跑
+- **`doctor --fix` 覆盖 write_integrity**（上报①：幻影写入事件只能围观不能修）：`--fix` 把已知幻影事件标记 `reconciled`（payload 增补时间戳，扫描豁免），审计轨迹保留不删事件；warn 文案指路。实测真实工作区：10-16 恢复实验造成的 10 个幻影（kb 47d0d78b18、source f0ad79350f 等）一键对账回 pass
+- 测试：demo 5i 段 7 断言（跨树 ready / 期限提取 / --days 窗口 / --eval 离线 pending / 幻影 warn→fix→pass 全循环）→ 101；`readme-verify.sh` +2（ready --all、cond --due）→ 41
+
 ## 0.81.0（2026-10-17）命令面五处修正 + task 挂树 + 事件流对账
 - **doctor write_integrity 误报修复**（用户上报①：合法 `kb remove` 后 doctor 报 phantom write fail）：`kb rm` 现在落 `kb.rm` 事件（与 source/evidence 对齐）；check 10 的幽灵扫描加 `NOT EXISTS rm 事件` 豁免，且整体降级 fail→warn——无 rm 事件的缺行可能是 0.81 前的合法删除或 db sql 手工清理，不值得炸掉脚本门禁
 - **`--url` 收任意 scheme**（上报②：a2a:// 被拒，跨 Agent 引用被迫落盘）：正则放宽为 RFC-3986 `<scheme>://`，https/file/session/a2a/… 均可；url_hash 去重照常兜底

package/README.md

@@ -91,6 +91,9 @@ ygl-trees node link a b --rel excludes              # 互斥分支
 ygl-trees node can steel --state "research_lab_level=3,has_engineer=1"
 ygl-trees node can a b c --state-file probe.json   # 批量判定：一进程测 N 节点（探针冷启动 1s×N → 1s）
 ygl-trees node ready                                # 当前可解锁集合
+ygl-trees node ready --all                          # 跨树扫描就绪集（无需逐树 tree use）
+ygl-trees node cond --due                           # 临期 eval 门槛（问题文本带 YYYY-MM-DD 期限）
+ygl-trees node cond --due --days 30                 # 放宽窗口；--eval 到期自动送判定模型
 ygl-trees node path advanced-alloy                  # 到目标的最省顺序 + 累计成本
 ygl-trees node ancestors bronze                     # 闭包索引，直接父 depth=1
 ygl-trees node timeline demo                        # 单树成长时间线（add/link/unlock 倒序）
@@ -104,6 +107,8 @@ ygl-trees node import --file tree.json --tree copy  # 严格校验、事务导
 
 **批量判定 + `--state-file`（0.79.1）**：`node can k1 k2 k3` 一次进程判定多节点（多键自动进批模式，`--json` 返回数组）；`--state-file <json>` 喂状态袋，两种形状——**扁平计数** `{"y_imported": 40}` 全节点共享，或**按节点** `{"a": {"y_imported": 40}, "b": {...}}` 各取各袋。探针脚本从此每树起一次进程而非每节点。
 
+**跨树巡检 + 临期门槛（0.82）**：`node ready --all` 一次扫全部树（12 棵树 24 条命令 → 1 条）；`node cond --due [--days N]` 列出问题文本带 `YYYY-MM-DD` 期限且 N 天内到期（含逾期）的 eval 条件——w1/d90 预测门槛不再依赖人记得看；`--eval` 逐条送判定模型（离线安全回落 pending），**判定只报告不仲裁**（通过 ≠ 自动解锁，resolve/unlock 保持人工，与 predict audit 同纪律）。
+
 **决策模型评估门（spec R8；0.14 布尔 → 0.26 三题型 → 0.27 混批 → 0.80 织物并入）**：语义型必检条件用 eval 题型声明，`node can <key> --eval` 会把**节点元数据 + 直接父（关联）+ 祖先链（闭包索引）+ 条件组 + 已解锁集 + --state 袋 + rel 挂接摘要**组装为上下文包，交给评估模型（TypeSafe jev，经 Vercel AI Gateway）判定：
 
 - **rel 织物并入（0.80）**：节点挂接的 evidence（quote 摘要）/ claim（text+status+confidence）/ kb/source（标题）等 rel 关系（双向，≤12 条，文本截 120 字）自动进上下文包的 `attachments`——「证据挂链」纪律从此对语义门槛可见，不必再 `--state k=v` 手动携带裁决事实（实测 P 0.30 → 0.92 的差距由挂链补平）
@@ -133,7 +138,9 @@ evidence add    从来源摘原文片段，带 locator（页码/章节）；长
 claim add       写下断言；--confidence 收 A|B|C 或数值档（0.92 / 85% 原样入库）
 claim link      断言 ↔ 证据，自动算 supported / refuted / contested
                 --by-source：传来源 id 一次挂齐其全部证据；误传来源 id 会列出该来源的证据 id
+                [预测·…] 断言不自动晋升（0.82.1）：挂证据≠仲裁，状态保持 unverified 直到显式 resolve / 到期回测
 claim resolve   人工仲裁出口：--as supported|refuted|contested，事件留痕；后续新证据链接会重新推导
+claim unresolve 复位通道：把断言重置回 unverified（撤销链接副作用 / 抢跑仲裁），幂等 duplicate:true
 predict audit   预测回测：扫描 [预测·N天] 断言，本地可测判据自动测（树/kb 计数、npm 版本数），判 hit/miss/pending/manual——只报告不仲裁，给出待 resolve 建议
                 --state <file|url>：外部计数桥接（如 DSH API 快照），判据里的裸键名后缀匹配嵌套键（y_imported≥12 ← counts.y_imported）
                 已 claim resolve 的预测默认隐藏（回测终态），--all 查看全表
@@ -289,7 +296,7 @@ ygl-trees agent ask "<question>"     natural language interface
 ## 五b、开发与运维工具
 
 ```bash
-pnpm test          # 四段制回归：unit (vitest 172 例) + build (tsc + tsdown) + demo（94 条断言）+ contract:audit（86 项）
+pnpm test          # 四段制回归：unit (vitest 177 例) + build (tsc + tsdown) + demo（106 条断言）+ contract:audit（86 项）
 pnpm bench         # 性能基准七席（startup/写路径/检索/索引），每席含 RSS 内存端点 → tmp/bench-results.json
 node benchmarks/bench.js --quick   # 缩小规模快速跑
 pnpm pack:check    # 发布就绪门禁：打包 → 隔离安装 → 驱动发布产物跑命令面 + --json 纯净性
@@ -313,7 +320,7 @@ serve。serve 从不取写锁（WAL 并发读写安全），`db unlock` 也以
 **多会话安全（0.79）**：`tree use` / `project use` 全部落 `tree.use` / `project.use` 事件（带
 `YGL_SESSION` 会话标识）；`agent brief` 的 `selection_changed` 字段暴露最近 10 分钟的选择变更，
 跨会话变更会置顶提示命令带 `-t/-p` 固定上下文。`kb add` 回执自带 `verified` 自检与工作区回显，
-`doctor` 第 10 项回放近 2 天 kb/source/evidence 写事件对账基表，幻影写入当场点名。
+`doctor` 第 10 项回放近 2 天 kb/source/evidence 写事件对账基表，幻影写入当场点名。`doctor --fix`（0.82）把已知幻影标记 `reconciled`（payload 留痕、扫描跳过、审计轨迹保留）——db 恢复/导入实验造成的旧幻影一键对账。
 
 **提交门禁（无 CI 环境的等效方案）**：`.githooks/pre-push` —— push 分支跑 `pnpm test`，
 **push tag 追加 `pnpm pack:check`**；旁路只能显式 `YGL_SKIP_HOOKS=1`。安装一次：

package/dist/apps/cli/src/bin.js

@@ -163,6 +163,7 @@ ${(0, fmt_1.paint)(fmt_1.C.bold, "research", true)}    collect → screen → ex
   claim link <claimId> <evidenceId> [--stance supports|refutes]
                                       --by-source <claimId> <sourceId>: link ALL evidence under a source
   claim resolve <claimId> --as supported|refuted|contested [--note]
+  claim unresolve <claimId>   reset to unverified (undo auto-promote / early arbitration)
   claim list
 
 ${(0, fmt_1.paint)(fmt_1.C.bold, "produce", true)}     outline → section → report · spec/design（工程产出）
@@ -210,6 +211,8 @@ ${(0, fmt_1.paint)(fmt_1.C.bold, "tree / node", true)}   tech-tree node model
                                      (--eval: eval 题型经决策模型判定；
                                       boolean P / choice P(期望答案) / score ±1 灰带)
   node ready [--state k=v] [--eval]  currently unlockable set
+                                     (--all: sweep every tree — no tree use needed)
+  node cond --due [--days n] [--eval]  eval gates with YYYY-MM-DD deadlines due in n days
   node path <key>                    dependency-order path to target (all locked ancestors; OR branches not optimized)
   node parents|children <key>        direct relations
   node ancestors|descendants <key>   transitive, via closure index
@@ -662,6 +665,7 @@ function generateLlmsManifest() {
                 ["research claim add \"<text>\"", "refutable assertion"],
                 ["research claim link <cid> <eid> --stance supports|refutes", "link claim to evidence"],
                 ["research claim resolve <cid> --as supported|refuted|contested", "manual arbitration"],
+                ["research claim unresolve <cid>", "reset to unverified (undo link auto-promote)"],
                 ["research claim evaluate <cid>", "decision model confidence (0-5 → A/B/C/D)"],
                 ["research evidence assess <eid>", "decision model quality assessment"],
             ]],
@@ -694,7 +698,8 @@ function generateLlmsManifest() {
                 ["node cond <key> --name <c> --kind <k> [--op eval] [--value \"<question>\"]", "add condition (eval = decision model gate)"],
                 ["node index", "rebuild closure + topo order"],
                 ["node can <key> [--state k=v] [--eval]", "can unlock? (required vs optional + cost)"],
-                ["node ready", "currently unlockable set"],
+                ["node ready [--all]", "currently unlockable set (--all: every tree)"],
+                ["node cond --due [--days n] [--eval]", "eval gates with deadlines due in n days"],
                 ["node path <key>", "dependency-order path (OR branches not optimized)"],
                 ["node unlock <key>", "mark unlocked"],
                 ["node list", "list with state column (locked/unlocked)"],

package/dist/bundle/bin.cjs

@@ -4088,6 +4088,7 @@ var writes_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
 	claimAdd: () => claimAdd,
 	claimLink: () => claimLink,
 	claimResolve: () => claimResolve,
+	claimUnresolve: () => claimUnresolve,
 	evidenceAdd: () => evidenceAdd,
 	jobAdd: () => jobAdd,
 	kbAdd: () => kbAdd,
@@ -4343,7 +4344,8 @@ function mapClaim(c) {
 }
 async function claimLink(ds, claimId, evidenceId, stance = "supports") {
 	return ds.transaction(async (mgr) => {
-		if (!(await mgr.query(`SELECT id FROM claims WHERE id=?`, [claimId])).length) throw new Error(`claim not found: ${claimId}`);
+		const c = await mgr.query(`SELECT id, text FROM claims WHERE id=?`, [claimId]);
+		if (!c.length) throw new Error(`claim not found: ${claimId}`);
 		if (!(await mgr.query(`SELECT id FROM evidence WHERE id=?`, [evidenceId])).length) throw new Error(`evidence not found: ${evidenceId}`);
 		await mgr.query(`INSERT INTO claim_evidence(claim_id,evidence_id,stance) VALUES(?,?,?)
        ON CONFLICT(claim_id,evidence_id) DO UPDATE SET stance=excluded.stance`, [
@@ -4351,6 +4353,15 @@ async function claimLink(ds, claimId, evidenceId, stance = "supports") {
 			evidenceId,
 			stance
 		]);
+		if (String(c[0]?.text ?? "").startsWith("[预测·")) {
+			const cur = await mgr.query(`SELECT status FROM claims WHERE id=?`, [claimId]);
+			const status = String(cur?.[0]?.status ?? "unverified");
+			await logEvent$1(mgr, "claim.link", "claim", claimId, `${stance} ${evidenceId} (prediction: auto-promote skipped)`);
+			return {
+				status,
+				auto_promote: false
+			};
+		}
 		const sup = await mgr.query(`SELECT COUNT(*) AS c FROM claim_evidence WHERE claim_id=? AND stance='supports'`, [claimId]);
 		const ref = await mgr.query(`SELECT COUNT(*) AS c FROM claim_evidence WHERE claim_id=? AND stance='refutes'`, [claimId]);
 		const s = Number(sup?.[0]?.c ?? 0);
@@ -4358,7 +4369,33 @@ async function claimLink(ds, claimId, evidenceId, stance = "supports") {
 		const status = s && r ? "contested" : s ? "supported" : r ? "refuted" : "unverified";
 		await mgr.update(Claim, { id: claimId }, { status });
 		await logEvent$1(mgr, "claim.link", "claim", claimId, `${stance} ${evidenceId}`);
-		return { status };
+		return {
+			status,
+			auto_promote: true
+		};
+	});
+}
+/** 0.82.1 (user report ③): reset an auto-promoted / wrongly arbitrated claim
+* back to unverified — the repair channel for link side effects on
+* predictions (and for any claim arbitrated too early). Idempotent: already
+* unverified → duplicate:true, no event spam. */
+async function claimUnresolve(ds, claimId) {
+	return ds.transaction(async (mgr) => {
+		const c = await mgr.query(`SELECT id, status FROM claims WHERE id=?`, [claimId]);
+		if (!c.length) throw new Error(`claim not found: ${claimId}`);
+		if (String(c[0]?.status) === "unverified") return {
+			status: "unverified",
+			duplicate: true
+		};
+		await mgr.update(Claim, { id: claimId }, {
+			status: "unverified",
+			updated: require_text.nowIso()
+		});
+		await logEvent$1(mgr, "claim.unresolve", "claim", claimId, `${c[0]?.status} → unverified`);
+		return {
+			status: "unverified",
+			duplicate: false
+		};
 	});
 }
 async function claimResolve(ds, claimId, status, note = "") {
@@ -7049,7 +7086,15 @@ function run$8(env, action, rest, args) {
 				});
 			}
 			return getOrm(env.db.path).then((ds) => claimLink(ds, rest[1], rest[2], stance)).then((r) => {
-				ok(ctx, `linked; claim status now: ${r.status}`);
+				if (ctx.json) console.log(JSON.stringify({
+					claim: rest[1],
+					evidence: rest[2],
+					stance,
+					status: r.status,
+					auto_promote: r.auto_promote
+				}, null, 2));
+				else if (r.auto_promote === false) ok(ctx, `linked; prediction claim stays ${r.status} — auto-promote skipped (arbitration: claim resolve / deadline audit)`);
+				else ok(ctx, `linked; claim status now: ${r.status}`);
 				try {
 					const { evaluateClaimConfidence } = (init_eval_enhance(), require_rolldown_runtime.__toCommonJS(eval_enhance_exports));
 					const evRows = store.db.all(`SELECT e.quote, ce.stance, s.title AS source_title
@@ -7129,6 +7174,30 @@ function run$8(env, action, rest, args) {
 				return 1;
 			});
 		}
+		if (subAction === "unresolve") {
+			const id = rest[1];
+			if (!id) {
+				bad(ctx, "usage: research claim unresolve <claimId>");
+				return 2;
+			}
+			const c0 = store.db.get("SELECT id, status FROM claims WHERE id=? AND project_id=?", [id, project.id]);
+			if (!c0) {
+				bad(ctx, `claim not found: ${id}`);
+				return 1;
+			}
+			return getOrm(env.db.path).then((ds) => claimUnresolve(ds, id)).then((r) => {
+				if (ctx.json) console.log(JSON.stringify({
+					id,
+					status: r.status,
+					duplicate: r.duplicate
+				}, null, 2));
+				else ok(ctx, r.duplicate ? `claim ${id} already unverified (no change)` : `claim ${id}: ${c0.status} → unverified  (back in tracking; arbitration: claim resolve)`);
+				return 0;
+			}).catch((e) => {
+				bad(ctx, e?.message || String(e));
+				return 1;
+			});
+		}
 		if (subAction === "evaluate") {
 			const id = rest[1];
 			if (!id) {
@@ -8810,6 +8879,167 @@ function run$4(env, action, rest, args) {
 		if (positionalTree) rest = rest.slice(1);
 		else if (!ctx.json) out(ctx, paint(C.yellow, `  ! "${rest[0]}" is not a tree — showing current tree (use -t <tree> to switch)`, ctx.color));
 	}
+	if (env.group === "node" && action === "cond" && args?.flags?.due === true) {
+		const days = flagNum("days", 7);
+		const ctxName = flagStr("context", "default");
+		const conds = db.all(`SELECT nc.id, nc.name, nc.op, nc.value, n.key node_key, n.id node_id, t.id tree_id, t.name tree
+         FROM node_conditions nc JOIN nodes n ON n.id=nc.node_id JOIN trees t ON t.id=n.tree_id
+        WHERE nc.op LIKE 'eval%' ORDER BY t.name, n.key`);
+		const now = Date.now();
+		const due = [];
+		for (const c of conds) {
+			const spec = parseEvalSpec(c.value);
+			const q = spec.q || String(c.name);
+			const m = q.match(/(20\d{2})-(\d{2})-(\d{2})/);
+			if (!m) continue;
+			const dl = Date.parse(`${m[1]}-${m[2]}-${m[3]}T23:59:59Z`);
+			if (!Number.isFinite(dl) || dl > now + days * 864e5) continue;
+			due.push({
+				tree: c.tree,
+				tree_id: c.tree_id,
+				node: c.node_key,
+				node_id: c.node_id,
+				name: String(c.name),
+				op: String(c.op),
+				question: q,
+				envelope: spec,
+				deadline: `${m[1]}-${m[2]}-${m[3]}`,
+				days_left: Math.ceil((dl - now) / 864e5)
+			});
+		}
+		due.sort((a, b) => a.days_left - b.days_left);
+		if (args?.flags?.eval !== true) {
+			if (ctx.json) console.log(JSON.stringify(due, null, 2));
+			else {
+				head(ctx, `临期 eval 门槛 × ${due.length}（${days} 天窗口）`);
+				if (!due.length) out(ctx, paint(C.dim, "  (无临期 eval 条件)", ctx.color));
+				table(ctx, due.map((d) => ({
+					tree: d.tree,
+					node: d.node,
+					cond: d.name,
+					deadline: d.deadline,
+					剩余天数: d.days_left,
+					question: require_text.clip(d.question, 40)
+				})), [
+					"tree",
+					"node",
+					"cond",
+					"deadline",
+					"剩余天数",
+					"question"
+				], [
+					"tree",
+					"node",
+					"cond",
+					"deadline",
+					"剩余天数",
+					"question"
+				]);
+			}
+			return 0;
+		}
+		const offline = !!process.env.YGL_EVAL_OFFLINE || configGetBool(env.db, "eval.offline");
+		const cfgToken = configGet(env.db, "decision_model_llm_token").trim();
+		const token = offline ? "" : cfgToken || evalToken();
+		const endpoint = configGet(env.db, "decision_model_llm_api_base").trim() || "https://ai-gateway.vercel.sh/v4/ai/evaluation-model";
+		const passT = configGetNumber(env.db, "eval.pass_threshold");
+		const failT = configGetNumber(env.db, "eval.fail_threshold");
+		return (async () => {
+			const rows = [];
+			for (const d of due) {
+				const res = await evalMixed(trees.evalContext(d.tree_id, d.node, {}, ctxName), [d.op === "eval-choice" ? {
+					type: "choice",
+					question: d.question,
+					options: d.envelope.options || {},
+					answer: d.envelope.answer || ""
+				} : d.op === "eval-score" ? {
+					type: "score",
+					question: d.question,
+					levels: d.envelope.levels || [],
+					min: d.envelope.min ?? 0
+				} : {
+					type: "boolean",
+					question: d.question
+				}], token, endpoint);
+				if (!res.ok) {
+					rows.push({
+						...d,
+						outcome: "pending",
+						reason: res.error
+					});
+					continue;
+				}
+				const r = res.results[0];
+				const m = d.op === "eval-choice" ? mapChoiceOutcome(r, d.envelope.answer || "", passT, failT) : d.op === "eval-score" ? mapScoreOutcome(r, d.envelope.min ?? 0) : mapOutcome(r, passT, failT);
+				rows.push({
+					...d,
+					...m
+				});
+			}
+			if (ctx.json) console.log(JSON.stringify(rows, null, 2));
+			else {
+				head(ctx, `临期 eval 门槛 — 已判定 × ${rows.length}`);
+				table(ctx, rows.map((d) => ({
+					tree: d.tree,
+					node: d.node,
+					deadline: d.deadline,
+					outcome: d.outcome,
+					p: d.p ?? d.score ?? "",
+					question: require_text.clip(d.question, 36)
+				})), [
+					"tree",
+					"node",
+					"deadline",
+					"判定",
+					"p",
+					"question"
+				], [
+					"tree",
+					"node",
+					"deadline",
+					"outcome",
+					"p",
+					"question"
+				]);
+				out(ctx, paint(C.dim, "  判定只报告不仲裁：通过 ≠ 自动解锁（resolve/unlock 保持人工）", ctx.color));
+			}
+			return 0;
+		})();
+	}
+	if (env.group === "node" && action === "ready" && args?.flags?.all === true) {
+		const state = parseState(args);
+		const ctxName = flagStr("context", "default");
+		const all = db.all("SELECT id, name FROM trees ORDER BY created");
+		const per = [];
+		for (const t of all) {
+			const rows = trees.ready(t.id, ctxName, state);
+			if (rows.length) per.push({
+				tree: t.name,
+				ready: rows
+			});
+		}
+		if (ctx.json) {
+			console.log(JSON.stringify(per, null, 2));
+			return 0;
+		}
+		head(ctx, `Ready across ${all.length} trees`);
+		if (!per.length) out(ctx, paint(C.dim, "  (no tree has ready nodes)", ctx.color));
+		for (const p of per) {
+			out(ctx, paint(C.bold, `  ${p.tree} (${p.ready.length})`, ctx.color));
+			table(ctx, p.ready, [
+				"key",
+				"name",
+				"tier",
+				"cost"
+			], [
+				"key",
+				"name",
+				"tier",
+				"cost"
+			]);
+		}
+		return 0;
+	}
 	let tree;
 	try {
 		tree = positionalTree || trees.treeResolve(sel);
@@ -11589,40 +11819,42 @@ function run(env, action, rest, args) {
 			detail: `profile read failed: ${e?.message || e}`
 		});
 	}
+	const PHANTOM_SPECS = [
+		{
+			kind: "kb.add",
+			table: "kb_notes",
+			label: "kb",
+			rm: "kb.rm"
+		},
+		{
+			kind: "source.add",
+			table: "sources",
+			label: "source",
+			rm: "source.rm"
+		},
+		{
+			kind: "evidence.add",
+			table: "evidence",
+			label: "evidence",
+			rm: "evidence.rm"
+		}
+	];
+	const phantomSql = (spec) => `SELECT e.entity_id id, e.ts FROM events e
+      WHERE e.kind='${spec.kind}'
+        AND e.ts >= datetime('now', '-2 days')
+        AND e.payload NOT LIKE '%"reconciled"%'
+        AND NOT EXISTS (SELECT 1 FROM ${spec.table} t WHERE t.id = e.entity_id)
+        AND NOT EXISTS (SELECT 1 FROM events r WHERE r.kind='${spec.rm}' AND r.entity_id = e.entity_id)`;
 	{
-		const PHANTOM_SPECS = [
-			{
-				kind: "kb.add",
-				table: "kb_notes",
-				label: "kb",
-				rm: "kb.rm"
-			},
-			{
-				kind: "source.add",
-				table: "sources",
-				label: "source",
-				rm: "source.rm"
-			},
-			{
-				kind: "evidence.add",
-				table: "evidence",
-				label: "evidence",
-				rm: "evidence.rm"
-			}
-		];
 		const phantoms = [];
 		for (const spec of PHANTOM_SPECS) {
-			const rows = db.all(`SELECT e.entity_id id, e.ts FROM events e
-          WHERE e.kind='${spec.kind}'
-            AND e.ts >= datetime('now', '-2 days')
-            AND NOT EXISTS (SELECT 1 FROM ${spec.table} t WHERE t.id = e.entity_id)
-            AND NOT EXISTS (SELECT 1 FROM events r WHERE r.kind='${spec.rm}' AND r.entity_id = e.entity_id)`);
+			const rows = db.all(phantomSql(spec));
 			for (const r of rows) phantoms.push(`${spec.label} ${r.id} (${String(r.ts).slice(0, 16)})`);
 		}
 		checks.push({
 			name: "write_integrity",
 			status: phantoms.length ? "warn" : "pass",
-			detail: phantoms.length ? `${phantoms.length} unexplained write event(s) in last 48h: ${phantoms.slice(0, 3).join(", ")}${phantoms.length > 3 ? " …" : ""} — row missing without an rm event (deleted pre-0.81 or via db sql? otherwise: rollback / different workspace — check receipts' workspace line)` : "recent write events all match stored rows"
+			detail: phantoms.length ? `${phantoms.length} unexplained write event(s) in last 48h: ${phantoms.slice(0, 3).join(", ")}${phantoms.length > 3 ? " …" : ""} — row missing without an rm event (deleted pre-0.81 or via db sql? otherwise: rollback / different workspace — check receipts' workspace line; doctor --fix marks known ones reconciled)` : "recent write events all match stored rows"
 		});
 	}
 	const failed = checks.filter((c) => c.status === "fail").length;
@@ -11665,6 +11897,27 @@ function run(env, action, rest, args) {
 				fixes.push("stale lock removed (holder pid dead)");
 			} catch {}
 		}
+		for (const spec of PHANTOM_SPECS) {
+			const rows = db.all(phantomSql(spec));
+			if (!rows.length) continue;
+			let marked = 0;
+			for (const r of rows) try {
+				const cur = db.get("SELECT payload FROM events WHERE kind=? AND entity_id=? LIMIT 1", [spec.kind, r.id]);
+				let payload = "{}";
+				try {
+					payload = cur?.payload && String(cur.payload).trim().startsWith("{") ? String(cur.payload) : "{}";
+				} catch {}
+				const obj = JSON.parse(payload);
+				obj.reconciled = (/* @__PURE__ */ new Date()).toISOString();
+				db.run("UPDATE events SET payload=? WHERE kind=? AND entity_id=?", [
+					JSON.stringify(obj),
+					spec.kind,
+					r.id
+				]);
+				marked++;
+			} catch {}
+			if (marked) fixes.push(`write_integrity: ${marked} ${spec.label} phantom event(s) marked reconciled (audit trail kept)`);
+		}
 		if (fixes.length) for (const f of fixes) ok(ctx, `  fixed: ${f}`);
 		else out(ctx, paint(C.dim, "  (--fix: no auto-fixable issues found)", ctx.color));
 	}
@@ -11795,6 +12048,7 @@ ${paint(C.bold, "research", true)}    collect → screen → extract → claim
   claim link <claimId> <evidenceId> [--stance supports|refutes]
                                       --by-source <claimId> <sourceId>: link ALL evidence under a source
   claim resolve <claimId> --as supported|refuted|contested [--note]
+  claim unresolve <claimId>   reset to unverified (undo auto-promote / early arbitration)
   claim list
 
 ${paint(C.bold, "produce", true)}     outline → section → report · spec/design（工程产出）
@@ -11842,6 +12096,8 @@ ${paint(C.bold, "tree / node", true)}   tech-tree node model
                                      (--eval: eval 题型经决策模型判定；
                                       boolean P / choice P(期望答案) / score ±1 灰带)
   node ready [--state k=v] [--eval]  currently unlockable set
+                                     (--all: sweep every tree — no tree use needed)
+  node cond --due [--days n] [--eval]  eval gates with YYYY-MM-DD deadlines due in n days
   node path <key>                    dependency-order path to target (all locked ancestors; OR branches not optimized)
   node parents|children <key>        direct relations
   node ancestors|descendants <key>   transitive, via closure index
@@ -12243,6 +12499,7 @@ function generateLlmsManifest() {
 				["research claim add \"<text>\"", "refutable assertion"],
 				["research claim link <cid> <eid> --stance supports|refutes", "link claim to evidence"],
 				["research claim resolve <cid> --as supported|refuted|contested", "manual arbitration"],
+				["research claim unresolve <cid>", "reset to unverified (undo link auto-promote)"],
 				["research claim evaluate <cid>", "decision model confidence (0-5 → A/B/C/D)"],
 				["research evidence assess <eid>", "decision model quality assessment"]
 			]
@@ -12291,7 +12548,8 @@ function generateLlmsManifest() {
 				["node cond <key> --name <c> --kind <k> [--op eval] [--value \"<question>\"]", "add condition (eval = decision model gate)"],
 				["node index", "rebuild closure + topo order"],
 				["node can <key> [--state k=v] [--eval]", "can unlock? (required vs optional + cost)"],
-				["node ready", "currently unlockable set"],
+				["node ready [--all]", "currently unlockable set (--all: every tree)"],
+				["node cond --due [--days n] [--eval]", "eval gates with deadlines due in n days"],
 				["node path <key>", "dependency-order path (OR branches not optimized)"],
 				["node unlock <key>", "mark unlocked"],
 				["node list", "list with state column (locked/unlocked)"],

package/dist/packages/ops/tools/src/doctor.js

@@ -235,19 +235,24 @@ function run(env, action, rest, args) {
     // the row did not, the write path lost data (rollback / crash between
     // commit and receipt / a different workspace). This check replays recent
     // write events against the base tables and names the phantom ids.
+    // 0.82 ①: `--fix write_integrity` — doctor --fix marks phantom events
+    // reconciled (payload gains {"reconciled":<iso>}); the scan skips them.
+    // Marking beats deleting: the audit trail stays, the operator said "known".
+    const PHANTOM_SPECS = [
+        { kind: "kb.add", table: "kb_notes", label: "kb", rm: "kb.rm" },
+        { kind: "source.add", table: "sources", label: "source", rm: "source.rm" },
+        { kind: "evidence.add", table: "evidence", label: "evidence", rm: "evidence.rm" },
+    ];
+    const phantomSql = (spec) => `SELECT e.entity_id id, e.ts FROM events e
+      WHERE e.kind='${spec.kind}'
+        AND e.ts >= datetime('now', '-2 days')
+        AND e.payload NOT LIKE '%"reconciled"%'
+        AND NOT EXISTS (SELECT 1 FROM ${spec.table} t WHERE t.id = e.entity_id)
+        AND NOT EXISTS (SELECT 1 FROM events r WHERE r.kind='${spec.rm}' AND r.entity_id = e.entity_id)`;
     {
-        const PHANTOM_SPECS = [
-            { kind: "kb.add", table: "kb_notes", label: "kb", rm: "kb.rm" },
-            { kind: "source.add", table: "sources", label: "source", rm: "source.rm" },
-            { kind: "evidence.add", table: "evidence", label: "evidence", rm: "evidence.rm" },
-        ];
         const phantoms = [];
         for (const spec of PHANTOM_SPECS) {
-            const rows = db.all(`SELECT e.entity_id id, e.ts FROM events e
-          WHERE e.kind='${spec.kind}'
-            AND e.ts >= datetime('now', '-2 days')
-            AND NOT EXISTS (SELECT 1 FROM ${spec.table} t WHERE t.id = e.entity_id)
-            AND NOT EXISTS (SELECT 1 FROM events r WHERE r.kind='${spec.rm}' AND r.entity_id = e.entity_id)`);
+            const rows = db.all(phantomSql(spec));
             for (const r of rows)
                 phantoms.push(`${spec.label} ${r.id} (${String(r.ts).slice(0, 16)})`);
         }
@@ -259,7 +264,7 @@ function run(env, action, rest, args) {
             name: "write_integrity",
             status: phantoms.length ? "warn" : "pass",
             detail: phantoms.length
-                ? `${phantoms.length} unexplained write event(s) in last 48h: ${phantoms.slice(0, 3).join(", ")}${phantoms.length > 3 ? " …" : ""} — row missing without an rm event (deleted pre-0.81 or via db sql? otherwise: rollback / different workspace — check receipts' workspace line)`
+                ? `${phantoms.length} unexplained write event(s) in last 48h: ${phantoms.slice(0, 3).join(", ")}${phantoms.length > 3 ? " …" : ""} — row missing without an rm event (deleted pre-0.81 or via db sql? otherwise: rollback / different workspace — check receipts' workspace line; doctor --fix marks known ones reconciled)`
                 : "recent write events all match stored rows",
         });
     }
@@ -321,6 +326,33 @@ function run(env, action, rest, args) {
                 catch { /* */ }
             }
         }
+        // 0.82 ①: phantom write events → mark reconciled. The operator looked at
+        // the warn, decided the rows are gone for a known reason (db restore /
+        // import experiment / pre-0.81 delete), and wants the warn gone. We
+        // stamp payload.reconciled — the event stays for audit, the scan skips it.
+        for (const spec of PHANTOM_SPECS) {
+            const rows = db.all(phantomSql(spec));
+            if (!rows.length)
+                continue;
+            let marked = 0;
+            for (const r of rows) {
+                try {
+                    const cur = db.get("SELECT payload FROM events WHERE kind=? AND entity_id=? LIMIT 1", [spec.kind, r.id]);
+                    let payload = "{}";
+                    try {
+                        payload = cur?.payload && String(cur.payload).trim().startsWith("{") ? String(cur.payload) : "{}";
+                    }
+                    catch { /* */ }
+                    const obj = JSON.parse(payload);
+                    obj.reconciled = new Date().toISOString();
+                    db.run("UPDATE events SET payload=? WHERE kind=? AND entity_id=?", [JSON.stringify(obj), spec.kind, r.id]);
+                    marked++;
+                }
+                catch { /* best-effort per event */ }
+            }
+            if (marked)
+                fixes.push(`write_integrity: ${marked} ${spec.label} phantom event(s) marked reconciled (audit trail kept)`);
+        }
         if (fixes.length) {
             for (const f of fixes)
                 (0, fmt_1.ok)(ctx, `  fixed: ${f}`);

package/dist/packages/research/pipeline/src/cmds.js

@@ -555,7 +555,17 @@ function run(env, action, rest, args) {
             return (0, orm_1.getOrm)(env.db.path)
                 .then((ds) => writes.claimLink(ds, rest[1], rest[2], stance))
                 .then((r) => {
-                (0, fmt_1.ok)(ctx, `linked; claim status now: ${r.status}`);
+                // 0.82.1: prediction claims never auto-promote on link — the receipt
+                // says so explicitly instead of showing a silently-unchanged status.
+                if (ctx.json) {
+                    console.log(JSON.stringify({ claim: rest[1], evidence: rest[2], stance, status: r.status, auto_promote: r.auto_promote }, null, 2));
+                }
+                else if (r.auto_promote === false) {
+                    (0, fmt_1.ok)(ctx, `linked; prediction claim stays ${r.status} — auto-promote skipped (arbitration: claim resolve / deadline audit)`);
+                }
+                else {
+                    (0, fmt_1.ok)(ctx, `linked; claim status now: ${r.status}`);
+                }
                 // R15 深度集成：链接后自动触发置信度评估（有模型时静默执行）
                 try {
                     const { evaluateClaimConfidence } = require("../../../ops/tools/src/eval-enhance");
@@ -629,6 +639,36 @@ function run(env, action, rest, args) {
                 return 1;
             });
         }
+        // 0.82.1 (user report ③): the repair channel for link side effects —
+        // resets a claim to unverified. Covers predictions auto-promoted before
+        // 0.82.1 AND any claim arbitrated too early (explicit un-arbitration).
+        if (subAction === "unresolve") {
+            const id = rest[1];
+            if (!id) {
+                (0, fmt_1.bad)(ctx, "usage: research claim unresolve <claimId>");
+                return 2;
+            }
+            const c0 = store.db.get("SELECT id, status FROM claims WHERE id=? AND project_id=?", [id, project.id]);
+            if (!c0) {
+                (0, fmt_1.bad)(ctx, `claim not found: ${id}`);
+                return 1;
+            }
+            return (0, orm_1.getOrm)(env.db.path)
+                .then((ds) => writes.claimUnresolve(ds, id))
+                .then((r) => {
+                if (ctx.json)
+                    console.log(JSON.stringify({ id, status: r.status, duplicate: r.duplicate }, null, 2));
+                else
+                    (0, fmt_1.ok)(ctx, r.duplicate
+                        ? `claim ${id} already unverified (no change)`
+                        : `claim ${id}: ${c0.status} → unverified  (back in tracking; arbitration: claim resolve)`);
+                return 0;
+            })
+                .catch((e) => {
+                (0, fmt_1.bad)(ctx, e?.message || String(e));
+                return 1;
+            });
+        }
         // R15.2: claim evaluate — decision model evaluates confidence from linked evidence
         if (subAction === "evaluate") {
             const id = rest[1];

package/dist/packages/research/pipeline/src/writes.js

@@ -5,6 +5,7 @@ exports.sourceAdd = sourceAdd;
 exports.evidenceAdd = evidenceAdd;
 exports.claimAdd = claimAdd;
 exports.claimLink = claimLink;
+exports.claimUnresolve = claimUnresolve;
 exports.claimResolve = claimResolve;
 exports.queryAttach = queryAttach;
 exports.kbAdd = kbAdd;
@@ -178,7 +179,7 @@ async function claimLink(ds, claimId, evidenceId, stance = "supports") {
     return ds.transaction(async (mgr) => {
         // Resolve both ends before writing: a bad/foreign id must surface as a
         // named not-found, not as a raw FOREIGN KEY constraint failure.
-        const c = (await mgr.query(`SELECT id FROM claims WHERE id=?`, [claimId]));
+        const c = (await mgr.query(`SELECT id, text FROM claims WHERE id=?`, [claimId]));
         if (!c.length)
             throw new Error(`claim not found: ${claimId}`);
         const e = (await mgr.query(`SELECT id FROM evidence WHERE id=?`, [evidenceId]));
@@ -186,6 +187,19 @@ async function claimLink(ds, claimId, evidenceId, stance = "supports") {
             throw new Error(`evidence not found: ${evidenceId}`);
         await mgr.query(`INSERT INTO claim_evidence(claim_id,evidence_id,stance) VALUES(?,?,?)
        ON CONFLICT(claim_id,evidence_id) DO UPDATE SET stance=excluded.stance`, [claimId, evidenceId, stance]);
+        // 0.82.1 (user report ③): prediction claims (`[预测·…]` prefix) must NOT
+        // auto-promote on link — predict audit treats supported/refuted as
+        // human-arbitrated (terminal), so a mere evidence link would kick the
+        // prediction out of the tracking table before its deadline. Evidence
+        // linking is evidence gathering; arbitration stays an explicit
+        // `claim resolve` (frozen contract, same discipline as predict audit).
+        const text = String(c[0]?.text ?? "");
+        if (text.startsWith("[预测·")) {
+            const cur = (await mgr.query(`SELECT status FROM claims WHERE id=?`, [claimId]));
+            const status = String(cur?.[0]?.status ?? "unverified");
+            await logEvent(mgr, "claim.link", "claim", claimId, `${stance} ${evidenceId} (prediction: auto-promote skipped)`);
+            return { status, auto_promote: false };
+        }
         const sup = (await mgr.query(`SELECT COUNT(*) AS c FROM claim_evidence WHERE claim_id=? AND stance='supports'`, [claimId]));
         const ref = (await mgr.query(`SELECT COUNT(*) AS c FROM claim_evidence WHERE claim_id=? AND stance='refutes'`, [claimId]));
         const s = Number(sup?.[0]?.c ?? 0);
@@ -193,7 +207,23 @@ async function claimLink(ds, claimId, evidenceId, stance = "supports") {
         const status = s && r ? "contested" : s ? "supported" : r ? "refuted" : "unverified";
         await mgr.update(entities_1.Claim, { id: claimId }, { status });
         await logEvent(mgr, "claim.link", "claim", claimId, `${stance} ${evidenceId}`);
-        return { status };
+        return { status, auto_promote: true };
+    });
+}
+/** 0.82.1 (user report ③): reset an auto-promoted / wrongly arbitrated claim
+ * back to unverified — the repair channel for link side effects on
+ * predictions (and for any claim arbitrated too early). Idempotent: already
+ * unverified → duplicate:true, no event spam. */
+async function claimUnresolve(ds, claimId) {
+    return ds.transaction(async (mgr) => {
+        const c = (await mgr.query(`SELECT id, status FROM claims WHERE id=?`, [claimId]));
+        if (!c.length)
+            throw new Error(`claim not found: ${claimId}`);
+        if (String(c[0]?.status) === "unverified")
+            return { status: "unverified", duplicate: true };
+        await mgr.update(entities_1.Claim, { id: claimId }, { status: "unverified", updated: (0, text_1.nowIso)() });
+        await logEvent(mgr, "claim.unresolve", "claim", claimId, `${c[0]?.status} → unverified`);
+        return { status: "unverified", duplicate: false };
     });
 }
 async function claimResolve(ds, claimId, status, note = "") {

package/dist/packages/techtree/model/src/cmds.js

@@ -168,6 +168,107 @@ function run(env, action, rest, args) {
             (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.yellow, `  ! "${rest[0]}" is not a tree — showing current tree (use -t <tree> to switch)`, ctx.color));
         }
     }
+    // 0.82 report ③: `node cond --due [--days N] [--eval]` — eval conds whose
+    // question carries a YYYY-MM-DD deadline, due (or overdue) within N days
+    // (default 7). --eval runs the decision model on each; judgment only —
+    // resolve/unlock stay human (same discipline as predict audit). Pre-tree-
+    // resolution like ready --all: --due is inherently cross-tree.
+    if (env.group === "node" && action === "cond" && args?.flags?.due === true) {
+        const days = flagNum("days", 7);
+        const ctxName = flagStr("context", "default");
+        const conds = db.all(`SELECT nc.id, nc.name, nc.op, nc.value, n.key node_key, n.id node_id, t.id tree_id, t.name tree
+         FROM node_conditions nc JOIN nodes n ON n.id=nc.node_id JOIN trees t ON t.id=n.tree_id
+        WHERE nc.op LIKE 'eval%' ORDER BY t.name, n.key`);
+        const now = Date.now();
+        const due = [];
+        for (const c of conds) {
+            const spec = (0, eval_1.parseEvalSpec)(c.value);
+            const q = spec.q || String(c.name);
+            const m = q.match(/(20\d{2})-(\d{2})-(\d{2})/);
+            if (!m)
+                continue;
+            const dl = Date.parse(`${m[1]}-${m[2]}-${m[3]}T23:59:59Z`);
+            if (!Number.isFinite(dl) || dl > now + days * 86400000)
+                continue;
+            due.push({
+                tree: c.tree, tree_id: c.tree_id, node: c.node_key, node_id: c.node_id,
+                name: String(c.name), op: String(c.op), question: q, envelope: spec,
+                deadline: `${m[1]}-${m[2]}-${m[3]}`, days_left: Math.ceil((dl - now) / 86400000),
+            });
+        }
+        due.sort((a, b) => a.days_left - b.days_left);
+        if (args?.flags?.eval !== true) {
+            if (ctx.json)
+                console.log(JSON.stringify(due, null, 2));
+            else {
+                (0, fmt_1.head)(ctx, `临期 eval 门槛 × ${due.length}（${days} 天窗口）`);
+                if (!due.length)
+                    (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.dim, "  (无临期 eval 条件)", ctx.color));
+                (0, fmt_1.table)(ctx, due.map((d) => ({ tree: d.tree, node: d.node, cond: d.name, deadline: d.deadline, 剩余天数: d.days_left, question: (0, text_1.clip)(d.question, 40) })), ["tree", "node", "cond", "deadline", "剩余天数", "question"], ["tree", "node", "cond", "deadline", "剩余天数", "question"]);
+            }
+            return 0;
+        }
+        // --eval: one decision-model request per due cond (ready --eval wiring)
+        const offline = !!process.env.YGL_EVAL_OFFLINE || (0, config_1.configGetBool)(env.db, "eval.offline");
+        const cfgToken = (0, config_1.configGet)(env.db, "decision_model_llm_token").trim();
+        const token = offline ? "" : cfgToken || (0, eval_1.evalToken)();
+        const endpoint = (0, config_1.configGet)(env.db, "decision_model_llm_api_base").trim() || eval_1.DEFAULT_ENDPOINT;
+        const passT = (0, config_1.configGetNumber)(env.db, "eval.pass_threshold");
+        const failT = (0, config_1.configGetNumber)(env.db, "eval.fail_threshold");
+        return (async () => {
+            const rows = [];
+            for (const d of due) {
+                const ctxPkg = trees.evalContext(d.tree_id, d.node, {}, ctxName);
+                const q = d.op === "eval-choice" ? { type: "choice", question: d.question, options: d.envelope.options || {}, answer: d.envelope.answer || "" }
+                    : d.op === "eval-score" ? { type: "score", question: d.question, levels: d.envelope.levels || [], min: d.envelope.min ?? 0 }
+                        : { type: "boolean", question: d.question };
+                const res = await (0, eval_1.evalMixed)(ctxPkg, [q], token, endpoint);
+                if (!res.ok) {
+                    rows.push({ ...d, outcome: "pending", reason: res.error });
+                    continue;
+                }
+                const r = res.results[0];
+                const m = d.op === "eval-choice" ? (0, eval_1.mapChoiceOutcome)(r, d.envelope.answer || "", passT, failT)
+                    : d.op === "eval-score" ? (0, eval_1.mapScoreOutcome)(r, d.envelope.min ?? 0)
+                        : (0, eval_1.mapOutcome)(r, passT, failT);
+                rows.push({ ...d, ...m });
+            }
+            if (ctx.json)
+                console.log(JSON.stringify(rows, null, 2));
+            else {
+                (0, fmt_1.head)(ctx, `临期 eval 门槛 — 已判定 × ${rows.length}`);
+                (0, fmt_1.table)(ctx, rows.map((d) => ({ tree: d.tree, node: d.node, deadline: d.deadline, outcome: d.outcome, p: d.p ?? d.score ?? "", question: (0, text_1.clip)(d.question, 36) })), ["tree", "node", "deadline", "判定", "p", "question"], ["tree", "node", "deadline", "outcome", "p", "question"]);
+                (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.dim, "  判定只报告不仲裁：通过 ≠ 自动解锁（resolve/unlock 保持人工）", ctx.color));
+            }
+            return 0;
+        })();
+    }
+    // 0.82 report ②: `node ready --all` sweeps EVERY tree — no tree use / -t
+    // needed (12 trees used to cost 24 commands). Runs before tree resolution
+    // because --all deliberately ignores the current selection.
+    if (env.group === "node" && action === "ready" && args?.flags?.all === true) {
+        const state = parseState(args);
+        const ctxName = flagStr("context", "default");
+        const all = db.all("SELECT id, name FROM trees ORDER BY created");
+        const per = [];
+        for (const t of all) {
+            const rows = trees.ready(t.id, ctxName, state);
+            if (rows.length)
+                per.push({ tree: t.name, ready: rows });
+        }
+        if (ctx.json) {
+            console.log(JSON.stringify(per, null, 2));
+            return 0;
+        }
+        (0, fmt_1.head)(ctx, `Ready across ${all.length} trees`);
+        if (!per.length)
+            (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.dim, "  (no tree has ready nodes)", ctx.color));
+        for (const p of per) {
+            (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.bold, `  ${p.tree} (${p.ready.length})`, ctx.color));
+            (0, fmt_1.table)(ctx, p.ready, ["key", "name", "tier", "cost"], ["key", "name", "tier", "cost"]);
+        }
+        return 0;
+    }
     let tree;
     try {
         tree = positionalTree || trees.treeResolve(sel);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ygl-trees",
-  "version": "0.81.0",
+  "version": "0.82.1",
   "description": "猿光 · 科技树 — database-centric CLI for research → production → knowledge reuse, built for AI agents.",
   "type": "commonjs",
   "main": "dist/apps/cli/index.js",
@@ -26,8 +26,8 @@
     "reflect-metadata": "^0.2.2",
     "typeorm": "^1.1.2",
     "@deepseek-ai/cordis": "~4.0.5-alpha.2",
-    "@deepseek-ai/schemastery": "~3.18.5-alpha.2",
     "@deepseek-ai/cordis-plugin-timer": "~1.1.7-alpha.2",
+    "@deepseek-ai/schemastery": "~3.18.5-alpha.2",
     "@deepseek-ai/cosmokit": "~1.8.6-alpha.2"
   },
   "devDependencies": {

package/skills/ygl-trees-quickstart/SKILL.md

@@ -58,7 +58,7 @@ ygl-trees llms --json              # 结构化 JSON
 
 ```bash
 ygl-trees doctor           # 10 项健康检查（含锁 pid 存活、幻影写入对账）
-ygl-trees doctor --fix     # 一键安全修复（脏索引 + 死 pid 陈旧锁；活 holder 不动）
+ygl-trees doctor --fix     # 一键安全修复（脏索引 + 死 pid 陈旧锁 + 幻影事件标记 reconciled；活 holder 不动）
 ygl-trees db unlock        # 清残留 .ygllock（死 pid 直清；活 holder 回显其命令行并拒绝，--force 强清）
 ygl-trees kb rm <id>       # 删除笔记（与 skill rm 对称）
 ygl-trees webui serve --host 0.0.0.0 --port 8642  # LAN/WSL 可访问

package/skills/ygl-trees-research/SKILL.md

@@ -42,11 +42,13 @@ ygl-trees research evidence add <sourceId> --quote "原文片段" --locator "§2
 ygl-trees research evidence add <sourceId> --file quotes.md         # 长摘录免转义
 ygl-trees research claim add "断言文本" --confidence A               # 档位
 ygl-trees research claim add "断言文本" --confidence 0.92            # 数值档（0.81：0-1 或 0-100%）
-ygl-trees research claim link <claimId> <evidenceId> [--stance refutes]   # 状态自动推导
+ygl-trees research claim link <claimId> <evidenceId> [--stance refutes]   # 状态自动推导（普通断言）
 ygl-trees research claim resolve <claimId> --as contested --note "矛盾待查"  # 人工仲裁出口
+ygl-trees research claim unresolve <claimId>   # 复位回 unverified（0.82.1：撤销链接副作用/抢跑仲裁）
 ```
 
 - 有支持有反对 → `contested`；仲裁后新证据链接会重新推导
+- **预测断言（`[预测·…]` 前缀）挂证据不自动晋升**（0.82.1）：挂证据 ≠ 仲裁，状态保持 unverified 直到显式 resolve / 到期回测——predict audit 才不会把刚挂证据的预测误判已结案；误晋升用 `claim unresolve` 归位（幂等 duplicate:true）
 - 全部命令幂等：同内容重跑返回已存在行（`duplicate: true`，rc=0）
 
 ## 3. 产出
@@ -65,6 +67,7 @@ ygl-trees produce export <reportId> report.md
 - 先 `agent brief --json` 看 next_actions（它会告诉你缺来源/缺证据/缺断言）
 - 每条断言至少一条证据再进报告；contested 的要么补证据要么 resolve
 - 预测断言（`[预测·N天]`）定期 `research predict audit` 回测：本地判据自动测；`--state <file|url>`
-  桥接外部计数（裸键名后缀匹配 `counts.y_imported`）；已 resolve 的默认隐藏（`--all` 查看终态表）
+  桥接外部计数（裸键名后缀匹配 `counts.y_imported`）；已 resolve 的默认隐藏（`--all` 查看终态表，
+  `--json` 始终含全量行含终态——机器读全量、人看增量）
 - `--json` 输出可直接 parse 拿 id；列表命令字段：source(id,title,url,relevance,…)、
   claim(id,text,status,confidence,sup,ref)、evidence(id,source,locator,quote,used_by)

package/skills/ygl-trees-techtree/SKILL.md

@@ -41,6 +41,9 @@ ygl-trees node index && ygl-trees node validate
 ygl-trees node can steel --state "lab_level=3,has_eng=1"   # 三类失败分开列+成本系数
 ygl-trees node can a b c --state-file bags.json            # 批量：一进程测 N 节点（探针 1s×N → 1s）
 ygl-trees node ready                                        # 当前可解锁集合
+ygl-trees node ready --all                                  # 跨树扫描（无需逐树 tree use）
+ygl-trees node cond --due [--days 30]                       # 临期 eval 门槛（问题文本带 YYYY-MM-DD 期限）
+ygl-trees node cond --due --eval                            # 到期逐条送判定模型（只报告不仲裁）
 ygl-trees node path steel                                   # 解锁顺序+累计成本（目标恒最后）
 ygl-trees node ancestors bronze                             # 闭包索引直查，depth=1 是直接父
 ygl-trees node unlock mining && ygl-trees node lock mining
@@ -49,6 +52,8 @@ ygl-trees node unlock mining && ygl-trees node lock mining
 - 写入时环守卫：门控边（prereq/unlock）成环当场拒绝
 - `node can` 输出：missing_required（阻塞）/ blocked_by（被排斥）/ missing_optional（不阻塞）
 - `--state-file` 两种形状：扁平 `{"y_imported":40}` 全节点共享；按节点 `{"a":{"y_imported":40}}` 各取各袋；多键 `--json` 返回数组（0.79.1）
+- `ready --all` / `cond --due` 前置于树解析：无当前树也能跑，跨树巡检一条命令（0.82）
+- `cond --due` 提取 eval 问题文本中的 `YYYY-MM-DD`；默认 7 天窗口（含逾期），`--eval` 判定后仍需人工 resolve/unlock——判定 ≠ 仲裁（0.82）
 
 ## 3. 迁移与保真