ygl-trees 0.82.0 → 0.82.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # 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 同纪律）；跨树扫描前置于树解析，无当前树也能跑

package/README.md

@@ -138,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 查看全表
@@ -294,7 +296,7 @@ ygl-trees agent ask "<question>"     natural language interface
 ## 五b、开发与运维工具
 
 ```bash
-pnpm test          # 四段制回归：unit (vitest 172 例) + build (tsc + tsdown) + demo（101 条断言）+ 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 纯净性

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（工程产出）
@@ -664,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"],
             ]],

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) {
@@ -11979,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（工程产出）
@@ -12429,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"]
 			]

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ygl-trees",
-  "version": "0.82.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,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/cordis-plugin-timer": "~1.1.7-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"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

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)