ygl-trees 0.80.0 → 0.82.0

package/dist/packages/knowledge/skills/src/cmds.js

@@ -40,6 +40,7 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const fmt_1 = require("../../../core/text/src/fmt");
 const text_1 = require("../../../core/text/src/text");
+const eventbus_1 = require("../../../core/text/src/eventbus");
 const orm_1 = require("../../../core/database/src/orm");
 const writes = __importStar(require("../../../research/pipeline/src/writes"));
 const reads_1 = require("../../../research/pipeline/src/reads");
@@ -178,6 +179,32 @@ function run(env, action, rest, args) {
             }
             store.db.run("DELETE FROM kb_fts WHERE id=?", [id]);
             store.db.run("DELETE FROM kb_notes WHERE id=?", [id]);
+            // 0.81: kb.rm event — doctor check 10 replays *.add events against base
+            // tables; a legit removal used to look like a phantom write. Logging the
+            // rm (mirroring source/evidence rm paths) lets doctor reconcile.
+            try {
+                const ev = {
+                    id: `ev${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`,
+                    ts: new Date().toISOString(),
+                    actor: process.env.YGL_SESSION || "cli",
+                    kind: "kb.rm",
+                    entity: "kb_note",
+                    entity_id: id,
+                    payload: JSON.stringify({ title: String(note.title || "") }),
+                    level: "info",
+                };
+                store.db.run("INSERT INTO events(id,ts,actor,kind,entity,entity_id,payload,level) VALUES(?,?,?,?,?,?,?,?)", [ev.id, ev.ts, ev.actor, ev.kind, ev.entity, ev.entity_id, ev.payload, ev.level]);
+                (0, eventbus_1.emitEvent)({
+                    kind: "kb.rm",
+                    entity: "kb_note",
+                    entityId: id,
+                    payload: JSON.stringify({ title: String(note.title || "") }),
+                    ts: ev.ts,
+                });
+            }
+            catch {
+                // event logging is best-effort — the delete itself already succeeded
+            }
             (0, fmt_1.ok)(ctx, `note removed: ${id}  ${String(note.title || "").slice(0, 40)}`);
             return 0;
         }

package/dist/packages/ops/tools/src/db-cmds.js

@@ -328,6 +328,22 @@ function run(env, action, rest, args) {
         }
         case "timeline": {
             // v2: workspace growth timeline — events per day with entity milestones
+            // 0.81 ⑧: --actor <a> / --session <s> narrow the stream for multi-agent
+            // reconciliation (actor column / payload.session); a filtered run also
+            // shows a raw tail so 对账 doesn't need db sql.
+            const actorF = String(args.flags.actor || "");
+            const sessionF = String(args.flags.session || "");
+            const conds = [];
+            const params = [];
+            if (actorF) {
+                conds.push("actor=?");
+                params.push(actorF);
+            }
+            if (sessionF) {
+                conds.push(`payload LIKE ?`);
+                params.push(`%"session":"${sessionF}"%`);
+            }
+            const where = conds.length ? ` WHERE ${conds.join(" AND ")}` : "";
             const days = db.all(`
         SELECT date(ts) as day, COUNT(*) as events,
           SUM(CASE WHEN kind LIKE 'project%' THEN 1 ELSE 0 END) as projects,
@@ -335,19 +351,22 @@ function run(env, action, rest, args) {
           SUM(CASE WHEN kind LIKE 'claim%' THEN 1 ELSE 0 END) as claims,
           SUM(CASE WHEN kind LIKE 'kb%' THEN 1 ELSE 0 END) as kb,
           SUM(CASE WHEN kind LIKE 'node%' THEN 1 ELSE 0 END) as nodes
-        FROM events GROUP BY date(ts) ORDER BY day
-      `);
+        FROM events${where} GROUP BY date(ts) ORDER BY day
+      `, params);
             if (!days.length) {
                 (0, fmt_1.ok)(ctx, "no events yet");
                 return 0;
             }
+            const tail = conds.length
+                ? db.all(`SELECT ts, actor, kind, entity_id FROM events${where} ORDER BY ts DESC LIMIT 20`, params)
+                : [];
             // F2 fix: --json outputs pure JSON (frozen contract ④)
             if (ctx.json) {
-                console.log(JSON.stringify({ timeline: days, total: days.reduce((s2, d) => s2 + d.events, 0) }, null, 2));
+                console.log(JSON.stringify({ timeline: days, total: days.reduce((s2, d) => s2 + d.events, 0), ...(tail.length ? { tail } : {}) }, null, 2));
                 return 0;
             }
             const maxEvents = Math.max(...days.map(d => d.events));
-            (0, fmt_1.head)(ctx, "Workspace Timeline");
+            (0, fmt_1.head)(ctx, `Workspace Timeline${actorF ? ` · actor=${actorF}` : ""}${sessionF ? ` · session=${sessionF}` : ""}`);
             let totalP = 0, totalS = 0, totalC = 0, totalK = 0, totalN = 0;
             for (const d of days) {
                 totalP += d.projects;
@@ -372,6 +391,12 @@ function run(env, action, rest, args) {
             }
             (0, fmt_1.out)(ctx, "");
             (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.dim, `  累计: ${totalP}项目 · ${totalS}来源 · ${totalC}断言 · ${totalK}知识 · ${totalN}节点变更`, ctx.color));
+            if (tail.length) {
+                (0, fmt_1.out)(ctx, "");
+                (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.dim, `  最近 ${tail.length} 条（按时间倒序）:`, ctx.color));
+                for (const t of tail)
+                    (0, fmt_1.out)(ctx, `  ${String(t.ts).slice(0, 19)}  ${String(t.actor).padEnd(12)} ${String(t.kind).padEnd(14)} ${String(t.entity_id || "")}`);
+            }
             return 0;
         }
         case "workspace": {

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

@@ -235,26 +235,36 @@ 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" },
-            { kind: "source.add", table: "sources", label: "source" },
-            { kind: "evidence.add", table: "evidence", label: "evidence" },
-        ];
         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)`);
+            const rows = db.all(phantomSql(spec));
             for (const r of rows)
                 phantoms.push(`${spec.label} ${r.id} (${String(r.ts).slice(0, 16)})`);
         }
+        // 0.81 ①: downgrade to warn — a missing row can also mean a legit delete
+        // made BEFORE 0.81 (rm events didn't exist then) or via raw db sql; only
+        // the receipt-vs-table comparison says "lost", and that distinction is
+        // not worth failing doctor (which gates scripts) over.
         checks.push({
             name: "write_integrity",
-            status: phantoms.length ? "fail" : "pass",
+            status: phantoms.length ? "warn" : "pass",
             detail: phantoms.length
-                ? `${phantoms.length} phantom write event(s) in last 48h: ${phantoms.slice(0, 3).join(", ")}${phantoms.length > 3 ? " …" : ""} — event logged but row missing (rollback or 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",
         });
     }
@@ -316,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/ops/tools/src/rels.js

@@ -9,7 +9,7 @@ exports.run = run;
 const fmt_1 = require("../../../core/text/src/fmt");
 const text_1 = require("../../../core/text/src/text");
 const orm_1 = require("../../../core/database/src/orm");
-exports.REL_TYPES = ["node", "claim", "evidence", "source", "query", "kb", "artifact", "skill"];
+exports.REL_TYPES = ["node", "claim", "evidence", "source", "query", "kb", "artifact", "task", "skill"];
 /** Resolve one `<type>:<ref>` against the database → { type, id, display }.
  *  Throws RelError(code) on unknown type / missing row. */
 class RelError extends Error {
@@ -25,9 +25,15 @@ const DISPLAY = {
         // node:<tree>/<key> explicit, or node:<key> resolved in the current tree
         const [treeName, key] = ref.includes("/") ? [ref.slice(0, ref.indexOf("/")), ref.slice(ref.indexOf("/") + 1)] : [null, ref];
         const cur = treeName || db.metaGet("current_tree") || "";
+        if (!cur) {
+            // 0.81: bare node:<key> with NO current tree used to die as a generic
+            // "node not found" — name the real cause (parallel session cleared the
+            // selection) and both ways out.
+            throw new RelError(1, `no current tree — qualify as node:<tree>/${key} or run 'ygl-trees tree use <name>' first`);
+        }
         const rows = db.all("SELECT n.id, n.key, n.name FROM nodes n JOIN trees t ON t.id=n.tree_id WHERE (t.name=? OR t.id=?) AND (n.key=? OR n.id=?)", [cur, cur, key, key]);
         if (!rows.length)
-            throw new RelError(1, `node not found: ${ref}`);
+            throw new RelError(1, `node not found: ${ref}${treeName ? "" : ` (searched current tree '${cur}' — qualify as node:<tree>/${key} for another tree)`}`);
         return { id: String(rows[0].id), display: String(rows[0].name || rows[0].key) };
     },
     claim: (db, ref) => {
@@ -66,6 +72,14 @@ const DISPLAY = {
             throw new RelError(1, `artifact not found: ${ref}`);
         return { id: String(r.id), display: String(r.title) };
     },
+    task: (db, ref) => {
+        // tasks are artifacts kind='task' (0.81: task:<id|title> so `task add
+        // --node` can link without spelling artifact:)
+        const r = db.get("SELECT id, title FROM artifacts WHERE kind='task' AND (id=? OR title=?) LIMIT 1", [ref, ref]);
+        if (!r)
+            throw new RelError(1, `task not found: ${ref}`);
+        return { id: String(r.id), display: String(r.title) };
+    },
     skill: (db, ref) => {
         const r = db.get("SELECT name, description FROM skills WHERE name=? LIMIT 1", [ref]);
         if (!r)

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

@@ -204,8 +204,11 @@ function run(env, action, rest, args) {
                 (0, fmt_1.bad)(ctx, "need --title and/or --url");
                 return 2;
             }
-            if (url && !/^https?:\/\/|^file:\/\/|^session:\/\//.test(url)) {
-                (0, fmt_1.bad)(ctx, `--url must be http(s)://, file:// or session:// (got: "${(0, text_1.clip)(url, 30)}")`);
+            if (url && !/^[a-z][a-z0-9+.-]*:\/\//i.test(url)) {
+                // 0.81: any RFC-3986 scheme is a valid carrier — cross-agent refs
+                // (a2a://peer/task), session://, file://, http(s):// … url_hash
+                // dedupe protects the rest (user report: a2a:// rejected).
+                (0, fmt_1.bad)(ctx, `--url must be <scheme>:// — https://, file://, session://, a2a:// … (got: "${(0, text_1.clip)(url, 30)}")`);
                 return 2;
             }
             const spec = {
@@ -482,8 +485,19 @@ function run(env, action, rest, args) {
         if (subAction === "add") {
             if ((0, flagcheck_1.rejectBare)(ctx, args.flags, ["confidence", "text"]))
                 return 2;
-            if ((0, flagcheck_1.validateEnum)(ctx, args.flags, "confidence", ["A", "B", "C"]))
-                return 2;
+            // 0.81: confidence accepts the letter grades (A|B|C) OR a numeric
+            // level — 0-1 decimal (0.92) or 0-100 percentage (92, 85%). Column
+            // stays TEXT; raw input is stored as given.
+            {
+                const raw = String(args.flags.confidence ?? "");
+                if (raw !== "" && !/^[ABC]$/.test(raw)) {
+                    const n = Number(raw.replace(/%$/, ""));
+                    if (!Number.isFinite(n) || n < 0 || n > 100) {
+                        (0, fmt_1.bad)(ctx, `--confidence must be A|B|C or a number 0-1 / 0-100(%) (got: "${(0, text_1.clip)(raw, 20)}")`);
+                        return 2;
+                    }
+                }
+            }
             const text = rest.slice(1).join(" ") || String(args.flags.text || "");
             if (!text) {
                 (0, fmt_1.bad)(ctx, 'missing claim text: research claim add "<text>"');

package/dist/packages/research/produce/src/produce-cmds.js

@@ -43,6 +43,7 @@ const flagcheck_1 = require("../../../core/text/src/flagcheck");
 const text_1 = require("../../../core/text/src/text");
 const orm_1 = require("../../../core/database/src/orm");
 const writes = __importStar(require("../../pipeline/src/writes"));
+const rels_1 = require("../../../ops/tools/src/rels");
 function run(env, action, rest, args) {
     const { ctx, store } = env;
     // R12: the `task` command group rides this router — translate its verbs
@@ -187,26 +188,40 @@ function run(env, action, rest, args) {
         }
         // ── task group rides the produce router (`ygl-trees task ...`, R12) ──
         case "task-add": {
-            if ((0, flagcheck_1.rejectBare)(ctx, args.flags, ["note"]))
+            if ((0, flagcheck_1.rejectBare)(ctx, args.flags, ["note", "node"]))
                 return 2;
             const title = rest.join(" ");
             if (!title) {
-                (0, fmt_1.bad)(ctx, 'usage: task add "<title>" [--note ...]');
+                (0, fmt_1.bad)(ctx, 'usage: task add "<title>" [--note ...] [--node <tree>/<key>]');
                 return 2;
             }
             const note = String(args.flags.note || "");
+            const nodeRef = args.flags.node !== undefined ? String(args.flags.node) : "";
             return (0, orm_1.getOrm)(env.db.path)
                 .then((ds) => writes.taskAdd(ds, pid, title, note))
                 .then((row) => {
-                if (ctx.json)
-                    console.log(JSON.stringify(row, null, 2));
-                else
-                    (0, fmt_1.ok)(ctx, `task added: ${row.id}  ${title}`);
-                return 0;
+                if (!nodeRef) {
+                    if (ctx.json)
+                        console.log(JSON.stringify(row, null, 2));
+                    else
+                        (0, fmt_1.ok)(ctx, `task added: ${row.id}  ${title}`);
+                    return 0;
+                }
+                // 0.81 ⑦: tasks join the relation fabric — `task add --node` links
+                // the fresh task to a tree node (rel=tracked-by) in the same breath,
+                // so task lists and node timelines stop being parallel pipelines.
+                return (0, rels_1.relAdd)(env, `node:${nodeRef}`, `task:${row.id}`, "tracked-by")
+                    .then((r) => {
+                    if (ctx.json)
+                        console.log(JSON.stringify({ ...row, node: nodeRef, relation: "tracked-by" }, null, 2));
+                    else
+                        (0, fmt_1.ok)(ctx, `task added: ${row.id}  ${title}  (tracked-by node:${nodeRef})`);
+                    return 0;
+                });
             })
                 .catch((e) => {
                 (0, fmt_1.bad)(ctx, e?.message || String(e));
-                return 1;
+                return e instanceof rels_1.RelError && e.code === 2 ? 2 : 1;
             });
         }
         case "task-list": {

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);
@@ -242,10 +343,30 @@ function run(env, action, rest, args) {
             });
         }
         if (sub === "cond") {
-            if (!key) {
-                (0, fmt_1.bad)(ctx, "usage: node cond <key> --name <cond> [--kind ..] [--op >=|==|<=|!=|has] [--value n] [--op eval [--value q] | eval-choice --options k=d,.. --answer k | eval-score --levels a,b,.. --min-score n] [--optional] [--effect gate|cost_mul] [--weight n]");
+            // 0.81 action-word consistency: `node cond add <key>` used to parse
+            // "add" as the node key ("node not found: add"); link/unlock style
+            // now works, and the long-missing `node cond rm <key> --name <n>`
+            // finally exists (was db-sql-only cleanup).
+            let cKey = key;
+            const cAct = key === "add" ? "add" : key === "rm" || key === "remove" ? "rm" : "";
+            if (cAct)
+                cKey = rest[1];
+            if (cAct === "rm") {
+                const name = flagStr("name");
+                if (!cKey || !name) {
+                    (0, fmt_1.bad)(ctx, "usage: node cond rm <key> --name <cond>");
+                    return 2;
+                }
+                return runTreeWrite((ds) => treeWrites.condRemove(ds, tid, cKey, name), (r) => {
+                    (0, fmt_1.ok)(ctx, `condition removed: ${cKey} · ${name}  (was ${r.required ? "必检" : "可选"}/${r.effect})`);
+                    return 0;
+                });
+            }
+            if (!cKey) {
+                (0, fmt_1.bad)(ctx, "usage: node cond [add|rm] <key> --name <cond> [--kind ..] [--op >=|==|<=|!=|has] [--value n] [--op eval [--value q] | eval-choice --options k=d,.. --answer k | eval-score --levels a,b,.. --min-score n] [--optional] [--effect gate|cost_mul] [--weight n]");
                 return 2;
             }
+            const k = cKey;
             if ((0, flagcheck_1.rejectBare)(ctx, args.flags, ["name", "value", "op", "effect", "weight", "options", "answer", "levels", "min-score"]))
                 return 2;
             if ((0, flagcheck_1.validateEnum)(ctx, args.flags, "op", [">=", "==", "<=", "!=", "has", "eval", "eval-choice", "eval-score"]))
@@ -254,7 +375,7 @@ function run(env, action, rest, args) {
                 return 2;
             const name = flagStr("name");
             if (!name) {
-                (0, fmt_1.table)(ctx, trees.condList(tid, key), ["id", "name", "kind", "op", "value", "必检", "effect"], [
+                (0, fmt_1.table)(ctx, trees.condList(tid, k), ["id", "name", "kind", "op", "value", "必检", "effect"], [
                     "id",
                     "name",
                     "kind",
@@ -307,7 +428,7 @@ function run(env, action, rest, args) {
                     value = (0, eval_1.packEvalScoreSpec)(q, levels, min);
                 }
             }
-            return runTreeWrite((ds) => treeWrites.condAdd(ds, tid, key, {
+            return runTreeWrite((ds) => treeWrites.condAdd(ds, tid, k, {
                 name,
                 kind: flagStr("kind", "flag"),
                 expr: flagStr("expr") || undefined,
@@ -317,7 +438,7 @@ function run(env, action, rest, args) {
                 effect: flagStr("effect", "gate"),
                 weight: flagNum("weight", 1),
             }), (c) => {
-                (0, fmt_1.ack)(ctx, c, `condition added: ${key} · ${c.name}  [${c.required ? "必检" : "可选"}/${c.effect}]`);
+                (0, fmt_1.ack)(ctx, c, `condition added: ${k} · ${c.name}  [${c.required ? "必检" : "可选"}/${c.effect}]`);
                 return 0;
             });
         }
@@ -696,6 +817,16 @@ function run(env, action, rest, args) {
             return 0;
         }
         if (sub === "list" || sub === undefined) {
+            // Contract ⑤ extension (user report: `node list --tree X` silently
+            // swallowed the unknown flag and listed the CURRENT tree). node list
+            // takes exactly -t <tree> / --json — any other flag is a typo worth
+            // an explicit rc=2 instead of silent misdirection.
+            for (const f of Object.keys(args.flags || {})) {
+                if (!["t", "json", "no-color"].includes(f)) {
+                    (0, fmt_1.bad)(ctx, `unknown flag --${f} for 'node list' — tree selection is '-t <tree>' (positional <tree> also works)`);
+                    return 2;
+                }
+            }
             (0, fmt_1.table)(ctx, trees.nodeList(tid), ["key", "name", "kind", "tier", "cost", "状态", "必检父", "子节点"], [
                 "key",
                 "name",

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

@@ -8,6 +8,7 @@ exports.nodeDel = nodeDel;
 exports.link = link;
 exports.unlink = unlink;
 exports.condAdd = condAdd;
+exports.condRemove = condRemove;
 exports.stateSet = stateSet;
 exports.rebuildIndex = rebuildIndex;
 exports.importTree = importTree;
@@ -270,6 +271,28 @@ async function condAdd(ds, treeId, keyOrId, o) {
         return rows[0];
     });
 }
+/** 0.81: `node cond rm <key> --name <n>` — remove one condition by natural
+ * key. Throws "node not found" / "condition not found: <name> (node X has:
+ * ...)" (named, per frozen contract ④). Mirrors condAdd: transactional +
+ * event (node.cond-rm) + markDirty. */
+async function condRemove(ds, treeId, keyOrId, name) {
+    return ds.transaction(async (mgr) => {
+        const n = (await mgr.query(`SELECT id FROM nodes WHERE tree_id=? AND (key=? OR id=?)`, [treeId, keyOrId, keyOrId]));
+        if (!n.length)
+            throw new Error(`node not found: ${keyOrId}`);
+        const existing = (await mgr.query(`SELECT * FROM node_conditions WHERE node_id=? AND name=?`, [n[0].id, name]));
+        if (!existing.length) {
+            const all = (await mgr.query(`SELECT name FROM node_conditions WHERE node_id=?`, [n[0].id]));
+            const have = all.map((r) => r.name).join(", ") || "(none)";
+            throw new Error(`condition not found: ${name} (node ${keyOrId} has: ${have})`);
+        }
+        const row = existing[0];
+        await mgr.query(`DELETE FROM node_conditions WHERE id=?`, [row.id]);
+        await markDirty(mgr, treeId);
+        await logEvent(mgr, "node.cond-rm", row.id, { tree: treeId, node: keyOrId, name, kind: row.kind, op: row.op, required: !!row.required, effect: row.effect });
+        return { ...row, removed: true };
+    });
+}
 async function stateSet(ds, treeId, keyOrId, status, context = "default", level = 0) {
     return ds.transaction(async (mgr) => {
         const n = (await mgr.query(`SELECT id FROM nodes WHERE tree_id=? AND (key=? OR id=?)`, [treeId, keyOrId, keyOrId]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ygl-trees",
-  "version": "0.80.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/cordis-plugin-timer": "~1.1.7-alpha.2",
     "@deepseek-ai/cosmokit": "~1.8.6-alpha.2",
-    "@deepseek-ai/schemastery": "~3.18.5-alpha.2"
+    "@deepseek-ai/schemastery": "~3.18.5-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

@@ -45,6 +45,7 @@ ygl-trees skill link --global    # 连接到 ~/.agents/skills/（全局）
 ygl-trees agent ask "<问题>"       # 自然语言路由（projects/search/tree/health/...）
 ygl-trees db time-travel "日期"    # 查询过去某时刻的工作区状态
 ygl-trees db timeline              # 增长时间线（events/天+里程碑）
+ygl-trees db timeline --actor <a> [--session <s>]  # 按 actor/会话过滤 + 最近 20 条原始事件（多 Agent 对账）
 ygl-trees db workspace list        # 多工作区管理
 ygl-trees db obsidian [dir]        # 导出 Obsidian markdown vault
 ygl-trees skill init <name>        # 模板创建技能
@@ -57,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 可访问
@@ -84,8 +85,9 @@ PG 迁移预检：`db migrate pg` 前自动逐表扫描 INTEGER 列类型——
 ## 3. 健康检查与任务
 
 ```bash
-ygl-trees doctor                     # 10 项健康检查（schema/索引/FTS/重复/孤儿/config/锁存活/eval信封/插件/幻影写入）
+ygl-trees doctor                     # 10 项健康检查（schema/索引/FTS/重复/孤儿/config/锁存活/eval信封/插件/幻影写入→warn）
 ygl-trees task add "<标题>"           # 建任务（todo 起步）
+ygl-trees task add "验证 X" --node <tree>/<key>   # 建任务并挂树节点（tracked-by，0.81）
 ygl-trees task list                  # 按状态分组
 ygl-trees task done <id>             # 勾销（全程留痕）
 ```

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

@@ -33,13 +33,15 @@ ygl-trees research source add --adjudication "会话内裁决：三条件已逐
 ```
 
 来源按 `(project, url_hash)` 去重；`--query` 顺带建立召回关联（query list 显示召回数）。
-`--url` 收 http(s):// · file:// · session://（0.80）。
+`--url` 收任意 `<scheme>://`（https/file/session/a2a/…，0.81）——跨 Agent 引用免落盘。
 
 ## 2. 摘录与断言
 
 ```bash
 ygl-trees research evidence add <sourceId> --quote "原文片段" --locator "§2"
-ygl-trees research claim add "断言文本" --confidence A
+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 resolve <claimId> --as contested --note "矛盾待查"  # 人工仲裁出口
 ```