ygl-trees 0.81.0 → 0.82.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 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 的差距由挂链补平）
@@ -289,7 +294,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 172 例) + build (tsc + tsdown) + demo（101 条断言）+ contract:audit（86 项）
 pnpm bench         # 性能基准七席（startup/写路径/检索/索引），每席含 RSS 内存端点 → tmp/bench-results.json
 node benchmarks/bench.js --quick   # 缩小规模快速跑
 pnpm pack:check    # 发布就绪门禁：打包 → 隔离安装 → 驱动发布产物跑命令面 + --json 纯净性
@@ -313,7 +318,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

@@ -210,6 +210,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
@@ -694,7 +696,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

@@ -8810,6 +8810,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 +11750,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 +11828,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));
 	}
@@ -11842,6 +12026,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
@@ -12291,7 +12477,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/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.0",
   "description": "猿光 · 科技树 — database-centric CLI for research → production → knowledge reuse, built for AI agents.",
   "type": "commonjs",
   "main": "dist/apps/cli/index.js",
@@ -26,9 +26,9 @@
     "reflect-metadata": "^0.2.2",
     "typeorm": "^1.1.2",
     "@deepseek-ai/cordis": "~4.0.5-alpha.2",
+    "@deepseek-ai/cosmokit": "~1.8.6-alpha.2",
     "@deepseek-ai/schemastery": "~3.18.5-alpha.2",
-    "@deepseek-ai/cordis-plugin-timer": "~1.1.7-alpha.2",
-    "@deepseek-ai/cosmokit": "~1.8.6-alpha.2"
+    "@deepseek-ai/cordis-plugin-timer": "~1.1.7-alpha.2"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

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-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. 迁移与保真