ygl-trees 0.77.3 → 0.79.1

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

@@ -74,10 +74,44 @@ function run(env, action, rest, args) {
             .then(fn)
             .then(print)
             .catch((e) => {
-            (0, fmt_1.bad)(ctx, e?.message || String(e));
+            (0, fmt_1.bad)(ctx, enrichNodeNotFound(e?.message || String(e)));
             return 1;
         });
     }
+    /** Report ③-3: selection changes are now first-class events — a parallel
+     *  session flipping current_tree/current_project becomes observable
+     *  (agent brief surfaces it; db timeline shows the history). Session
+     *  identity comes from YGL_SESSION (agents that care can set it). */
+    function logSelectionEvent(database, kind, name) {
+        try {
+            database.run("INSERT INTO events(id,ts,actor,kind,entity,entity_id,payload,level) VALUES(?,?,?,?,?,?,?,?)", [
+                `ev${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`,
+                new Date().toISOString(),
+                process.env.YGL_SESSION || "cli",
+                kind,
+                kind === "tree.use" ? "tree" : "project",
+                name,
+                JSON.stringify({ name, session: process.env.YGL_SESSION || "cli" }),
+                "info",
+            ]);
+        }
+        catch { /* telemetry only — never block the selection */
+        }
+    }
+    /** Report ③ enrichment: "node not found: X" earned a cross-tree lookup —
+     *  if a parallel session flipped current_tree, the key usually exists in
+     *  another tree; name it instead of making the user blind-list. */
+    function enrichNodeNotFound(msg) {
+        const m = /^node not found: (.+)$/.exec(msg);
+        if (!m)
+            return msg;
+        const others = trees.nodeInOtherTrees(m[1], tid);
+        if (others.length) {
+            const names = others.map((o) => `'${o.tree}'`).join(", ");
+            return `${msg}\n  key exists in other tree(s): ${names} — pin it: ygl-trees ${env.group} ... -t ${others[0].tree}`;
+        }
+        return `${msg}  (current tree: '${tree?.name ?? "?"}' — node list to inspect, -t <tree> to switch)`;
+    }
     // ---------------------------------------------------------------- tree group
     if (env.group === "tree") {
         const sub = action; // new | list | use
@@ -91,6 +125,7 @@ function run(env, action, rest, args) {
             const proj = pid ? db.get("SELECT id FROM projects WHERE name=?", [pid]) : null;
             return runTreeWrite((ds) => treeWrites.treeCreate(ds, name, proj?.id || ""), (t) => {
                 db.metaSet("current_tree", t.name);
+                logSelectionEvent(db, "tree.use", t.name);
                 (0, fmt_1.ack)(ctx, t, t?.duplicate === true
                     ? `tree exists, selected: ${t.name}  (duplicate, not re-created)`
                     : `tree created and selected: ${t.name}`);
@@ -114,6 +149,7 @@ function run(env, action, rest, args) {
                 return 1;
             }
             db.metaSet("current_tree", name);
+            logSelectionEvent(db, "tree.use", name);
             (0, fmt_1.ack)(ctx, { tree: name }, `now using tree: ${name}`);
             return 0;
         }
@@ -300,56 +336,52 @@ function run(env, action, rest, args) {
         }
         if (sub === "can") {
             if (!key) {
-                (0, fmt_1.bad)(ctx, "usage: node can <key> [--context ctx] [--state k=v] [--eval]");
+                (0, fmt_1.bad)(ctx, "usage: node can <key...> [--context ctx] [--state k=v] [--state-file file] [--eval]");
                 return 2;
             }
-            const state = parseState(args);
-            const ctxName = flagStr("context", "default");
-            const r = trees.canUnlock(tid, key, ctxName, state);
-            const evalConds = flagBool("eval")
-                ? trees.condList(tid, key).filter((c) => /^eval(-choice|-score)?$/.test(String(c.op)))
-                : [];
-            if (!evalConds.length) {
-                if (ctx.json) {
-                    console.log(JSON.stringify(r, null, 2));
-                    return 0;
-                }
-                (0, fmt_1.head)(ctx, `can unlock: ${r.key}`);
-                (0, fmt_1.out)(ctx, `  ${r.ok ? (0, fmt_1.paint)(fmt_1.C.green, "✓ 可解锁", ctx.color) : (0, fmt_1.paint)(fmt_1.C.red, "✗ 不可解锁", ctx.color)}`);
-                if (r.missing_required.length) {
-                    (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.bold, "  必检未满足", ctx.color));
-                    for (const m of r.missing_required)
-                        (0, fmt_1.out)(ctx, `    - ${m}`);
-                }
-                if (r.blocked_by.length) {
-                    (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.bold, "  被排斥", ctx.color));
-                    for (const b of r.blocked_by)
-                        (0, fmt_1.out)(ctx, `    - ${b}`);
-                }
-                if (r.missing_optional.length) {
-                    (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.dim, "  可选未满足（不阻塞）", ctx.color));
-                    for (const m of r.missing_optional)
-                        (0, fmt_1.out)(ctx, `    - ${m}`);
-                }
-                if (r.cost_multiplier !== 1)
-                    (0, fmt_1.out)(ctx, `  成本系数 ${r.cost_multiplier}`);
-                return 0;
+            // 0.79.1 (R297 user report): batch mode — multiple keys judged in ONE
+            // process (probes used to pay ~1s cold start per node), plus
+            // --state-file for JSON state bags (shared or per-node).
+            const keys = [...new Set(rest.filter(Boolean))];
+            const sharedState = parseState(args);
+            let perKeyBags = null;
+            try {
+                perKeyBags = loadStateFile(args, sharedState);
             }
-            // R8: decision-model boolean evaluation for op=eval conditions.
-            // Offline-safe: no token / network failure → pending (rc=0).
-            // Credential/endpoint priority (user ruling): CONFIG first —
-            // decision_model_llm_token / decision_model_llm_api_base — then env
-            // AI_GATEWAY_API_KEY / ~/.vercel.ai-gateway.env, then the default
-            // Vercel gateway. Thresholds + offline are config-tunable too;
-            // env YGL_EVAL_OFFLINE still wins over config eval.offline.
+            catch (e) {
+                const msg = e?.message || String(e);
+                (0, fmt_1.bad)(ctx, msg);
+                return /^usage:/.test(msg) ? 2 : /must contain a JSON object/.test(msg) ? 2 : 1;
+            }
+            const stateFor = (k) => perKeyBags ? (perKeyBags[k] && typeof perKeyBags[k] === "object" && !Array.isArray(perKeyBags[k]) ? perKeyBags[k] : {}) : sharedState;
+            const ctxName = flagStr("context", "default");
+            // eval-family config read once per run (R8 credential priority:
+            // config decision_model_llm_* first, then env AI_GATEWAY_API_KEY)
             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");
-            const contextPkg = trees.evalContext(tid, key, state, ctxName);
-            return (async () => {
+            /** Judge one node: canUnlock (+ eval gates when --eval). Never throws —
+             *  hard failures come back as {key, error}. */
+            const judgeOne = async (k) => {
+                let r;
+                try {
+                    r = trees.canUnlock(tid, k, ctxName, stateFor(k));
+                }
+                catch (e) {
+                    return { key: k, error: enrichNodeNotFound(e?.message || String(e)) };
+                }
+                const state = stateFor(k);
+                const evalConds = flagBool("eval")
+                    ? trees.condList(tid, k).filter((c) => /^eval(-choice|-score)?$/.test(String(c.op)))
+                    : [];
+                if (!evalConds.length)
+                    return r;
+                // R8: decision-model evaluation for op=eval conditions.
+                // Offline-safe: no token / network failure → pending (rc=0).
+                const contextPkg = trees.evalContext(tid, k, state, ctxName);
                 const evaluated = [];
                 let usageIn = 0, usageOut = 0; // R10.4: token spend per run
                 for (const c of evalConds) {
@@ -398,7 +430,7 @@ function run(env, action, rest, args) {
                 r.ok = r.missing_required.length === 0 && r.blocked_by.length === 0 && pendingList.length === 0;
                 try {
                     const run = process.env.YGL_RUN_ID || "";
-                    db.run("INSERT INTO events(id,ts,actor,kind,entity,entity_id,payload,level) VALUES(?,?,?,?,?,?,?,'info')", [(0, text_1.shortId)(["eval.gate", "node", key], 12), (0, text_1.nowIso)(), "cli", "eval.gate", "node", key,
+                    db.run("INSERT INTO events(id,ts,actor,kind,entity,entity_id,payload,level) VALUES(?,?,?,?,?,?,?,'info')", [(0, text_1.shortId)(["eval.gate", "node", k], 12), (0, text_1.nowIso)(), "cli", "eval.gate", "node", k,
                         JSON.stringify({
                             conds: evaluated.map((e) => ({ name: e.name, type: e.type, outcome: e.outcome, p: e.p ?? null, score: e.score ?? null })),
                             usage: { inputTokens: usageIn, outputTokens: usageOut },
@@ -406,37 +438,90 @@ function run(env, action, rest, args) {
                         })]);
                 }
                 catch { /* audit best-effort */ }
+                return r;
+            };
+            const batch = keys.length > 1;
+            return (async () => {
+                const results = [];
+                for (const k of keys)
+                    results.push(await judgeOne(k));
                 if (ctx.json) {
-                    console.log(JSON.stringify(r, null, 2));
-                    return 0;
-                }
-                (0, fmt_1.head)(ctx, `can unlock: ${r.key}`);
-                (0, fmt_1.out)(ctx, `  ${r.ok ? (0, fmt_1.paint)(fmt_1.C.green, "✓ 可解锁", ctx.color) : pendingList.length ? (0, fmt_1.paint)(fmt_1.C.yellow, "… 待判定（决策模型 pending）", ctx.color) : (0, fmt_1.paint)(fmt_1.C.red, "✗ 不可解锁", ctx.color)}`);
-                if (r.missing_required.length) {
-                    (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.bold, "  必检未满足", ctx.color));
-                    for (const m of r.missing_required)
-                        (0, fmt_1.out)(ctx, `    - ${m}`);
+                    // single key → object (frozen shape); batch → array
+                    console.log(JSON.stringify(batch ? results : results[0], null, 2));
+                    return results.some((r) => r.error) ? 1 : 0;
                 }
-                if (pendingList.length) {
-                    (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.bold, "  决策模型 pending（灰带/未配置，非终态）", ctx.color));
-                    for (const p of pendingList)
-                        (0, fmt_1.out)(ctx, `    - ${p}`);
-                }
-                if (r.blocked_by.length) {
-                    (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.bold, "  被排斥", ctx.color));
-                    for (const b of r.blocked_by)
-                        (0, fmt_1.out)(ctx, `    - ${b}`);
+                if (!batch) {
+                    const r = results[0];
+                    if (r.error) {
+                        (0, fmt_1.bad)(ctx, r.error);
+                        return 1;
+                    }
+                    if (!r.evaluated) {
+                        (0, fmt_1.head)(ctx, `can unlock: ${r.key}`);
+                        (0, fmt_1.out)(ctx, `  ${r.ok ? (0, fmt_1.paint)(fmt_1.C.green, "✓ 可解锁", ctx.color) : (0, fmt_1.paint)(fmt_1.C.red, "✗ 不可解锁", ctx.color)}`);
+                        if (r.missing_required.length) {
+                            (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.bold, "  必检未满足", ctx.color));
+                            for (const m of r.missing_required)
+                                (0, fmt_1.out)(ctx, `    - ${m}`);
+                        }
+                        if (r.blocked_by.length) {
+                            (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.bold, "  被排斥", ctx.color));
+                            for (const b of r.blocked_by)
+                                (0, fmt_1.out)(ctx, `    - ${b}`);
+                        }
+                        if (r.missing_optional.length) {
+                            (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.dim, "  可选未满足（不阻塞）", ctx.color));
+                            for (const m of r.missing_optional)
+                                (0, fmt_1.out)(ctx, `    - ${m}`);
+                        }
+                        if (r.cost_multiplier !== 1)
+                            (0, fmt_1.out)(ctx, `  成本系数 ${r.cost_multiplier}`);
+                        return 0;
+                    }
+                    (0, fmt_1.head)(ctx, `can unlock: ${r.key}`);
+                    (0, fmt_1.out)(ctx, `  ${r.ok ? (0, fmt_1.paint)(fmt_1.C.green, "✓ 可解锁", ctx.color) : r.pending.length ? (0, fmt_1.paint)(fmt_1.C.yellow, "… 待判定（决策模型 pending）", ctx.color) : (0, fmt_1.paint)(fmt_1.C.red, "✗ 不可解锁", ctx.color)}`);
+                    if (r.missing_required.length) {
+                        (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.bold, "  必检未满足", ctx.color));
+                        for (const m of r.missing_required)
+                            (0, fmt_1.out)(ctx, `    - ${m}`);
+                    }
+                    if (r.pending.length) {
+                        (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.bold, "  决策模型 pending（灰带/未配置，非终态）", ctx.color));
+                        for (const p of r.pending)
+                            (0, fmt_1.out)(ctx, `    - ${p}`);
+                    }
+                    if (r.blocked_by.length) {
+                        (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.bold, "  被排斥", ctx.color));
+                        for (const b of r.blocked_by)
+                            (0, fmt_1.out)(ctx, `    - ${b}`);
+                    }
+                    if (r.missing_optional.length) {
+                        (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.dim, "  可选未满足（不阻塞）", ctx.color));
+                        for (const m of r.missing_optional)
+                            (0, fmt_1.out)(ctx, `    - ${m}`);
+                    }
+                    for (const e of r.evaluated)
+                        (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.dim, `  eval ${e.name}: P=${e.p ?? "-"} → ${e.outcome}${e.reason ? ` (${e.reason})` : ""}`, ctx.color));
+                    if (r.cost_multiplier !== 1)
+                        (0, fmt_1.out)(ctx, `  成本系数 ${r.cost_multiplier}`);
+                    return 0;
                 }
-                if (r.missing_optional.length) {
-                    (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.dim, "  可选未满足（不阻塞）", ctx.color));
-                    for (const m of r.missing_optional)
-                        (0, fmt_1.out)(ctx, `    - ${m}`);
+                // batch human view: one compact line per node (probe-friendly)
+                const via = perKeyBags ? "per-node --state-file" : Object.keys(sharedState).length ? "shared state" : "";
+                (0, fmt_1.head)(ctx, `can unlock × ${results.length}${via ? ` (${via})` : ""}`);
+                for (const r of results) {
+                    if (r.error) {
+                        (0, fmt_1.out)(ctx, `  ${(0, fmt_1.paint)(fmt_1.C.red, "✗", ctx.color)} ${r.key}  ${r.error}`);
+                        continue;
+                    }
+                    const mark = r.ok ? (0, fmt_1.paint)(fmt_1.C.green, "✓", ctx.color) : r.pending?.length ? (0, fmt_1.paint)(fmt_1.C.yellow, "…", ctx.color) : (0, fmt_1.paint)(fmt_1.C.red, "✗", ctx.color);
+                    const blockers = [
+                        ...(r.missing_required || []).map((m) => m),
+                        ...(r.blocked_by || []).map((b) => `excluded:${b}`),
+                    ].join(", ");
+                    (0, fmt_1.out)(ctx, `  ${mark} ${r.key}${r.pending?.length ? " (eval pending)" : ""}${blockers ? `  — ${blockers}` : ""}`);
                 }
-                for (const e of evaluated)
-                    (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.dim, `  eval ${e.name}: P=${e.p ?? "-"} → ${e.outcome}${e.reason ? ` (${e.reason})` : ""}`, ctx.color));
-                if (r.cost_multiplier !== 1)
-                    (0, fmt_1.out)(ctx, `  成本系数 ${r.cost_multiplier}`);
-                return 0;
+                return results.some((r) => r.error) ? 1 : 0;
             })().catch((e) => {
                 (0, fmt_1.bad)(ctx, e?.message || String(e));
                 return 1;
@@ -444,6 +529,20 @@ function run(env, action, rest, args) {
         }
         if (sub === "ready") {
             const state = parseState(args);
+            try {
+                // 0.79.1: --state-file flat bag works here too (per-node shape makes
+                // no sense for ready — it judges the whole tree, so flat-only).
+                const bags = loadStateFile(args, state);
+                if (bags) {
+                    (0, fmt_1.bad)(ctx, "--state-file per-node shape (key→object) only applies to batch `node can k1 k2 …`; ready wants a flat counter object");
+                    return 2;
+                }
+            }
+            catch (e) {
+                const msg = e?.message || String(e);
+                (0, fmt_1.bad)(ctx, msg);
+                return /^usage:/.test(msg) || /must contain a JSON object/.test(msg) ? 2 : 1;
+            }
             const ctxName = flagStr("context", "default");
             if (!flagBool("eval")) {
                 const rows = trees.ready(tid, ctxName, state);
@@ -549,7 +648,14 @@ function run(env, action, rest, args) {
                 (0, fmt_1.bad)(ctx, "usage: node path <key>");
                 return 2;
             }
-            const p = trees.pathTo(tid, key, flagStr("context", "default"));
+            let p;
+            try {
+                p = trees.pathTo(tid, key, flagStr("context", "default"));
+            }
+            catch (e) {
+                (0, fmt_1.bad)(ctx, enrichNodeNotFound(e?.message || String(e)));
+                return 1;
+            }
             if (ctx.json) {
                 console.log(JSON.stringify(p, null, 2));
                 return 0;
@@ -610,7 +716,7 @@ function run(env, action, rest, args) {
         if (sub === "show") {
             const n = trees.nodeGet(tid, key);
             if (!n) {
-                (0, fmt_1.bad)(ctx, `node not found: ${key}`);
+                (0, fmt_1.bad)(ctx, enrichNodeNotFound(`node not found: ${key}`));
                 return 1;
             }
             const st = trees.nodeStateOf(tid, key);
@@ -704,11 +810,39 @@ function run(env, action, rest, args) {
             return runTreeWrite((ds) => treeWrites.importTree(ds, spec, { name: flagStr("tree") || undefined, merge: flagBool("merge") }), (r) => {
                 (0, fmt_1.ack)(ctx, { tree: r.tree.name, nodes: r.nodes, edges: r.edges, conditions: r.conditions }, `imported tree ${r.tree.name}: ${r.nodes} nodes, ${r.edges} edges, ${r.conditions} conditions`);
                 db.metaSet("current_tree", r.tree.name);
+                logSelectionEvent(db, "tree.use", r.tree.name);
                 if (!ctx.json)
                     (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.dim, `  index rebuilt; now using tree: ${r.tree.name}`, ctx.color));
                 return 0;
             });
         }
+        // Report ⑤: tree-scoped growth timeline — workspace-level `db timeline`
+        // already existed; this projects a single tree's unlock/add milestones.
+        if (sub === "timeline") {
+            const rows = db.all(`SELECT e.ts, e.kind, e.payload FROM events e
+          WHERE e.entity = 'node'
+            AND e.entity_id IN (SELECT id FROM nodes WHERE tree_id = ?)
+          ORDER BY e.ts DESC LIMIT 30`, [tid]);
+            if (ctx.json) {
+                console.log(JSON.stringify(rows.map((r) => ({
+                    ts: r.ts, kind: r.kind, ...JSON.parse(r.payload || "{}"),
+                })), null, 2));
+                return 0;
+            }
+            (0, fmt_1.head)(ctx, `Timeline — tree '${tree.name}' (last ${rows.length})`);
+            for (const r of rows) {
+                let detail = "";
+                try {
+                    const p = JSON.parse(r.payload || "{}");
+                    detail = [p.key, p.name ? String(p.name).slice(0, 30) : ""].filter(Boolean).join("  ");
+                }
+                catch { /* */ }
+                (0, fmt_1.out)(ctx, `  ${String(r.ts).slice(0, 16)}  ${r.kind.padEnd(14)} ${detail}`);
+            }
+            if (!rows.length)
+                (0, fmt_1.out)(ctx, (0, fmt_1.paint)(fmt_1.C.dim, "  (no node events yet — unlock/add to start the history)", ctx.color));
+            return 0;
+        }
         if (sub === "rm") {
             if (!key) {
                 (0, fmt_1.bad)(ctx, "usage: node rm <key>");
@@ -737,3 +871,33 @@ function parseState(args) {
     }
     return out;
 }
+/**
+ * 0.79.1 (R297 user report): `--state-file <path.json>` loads the state bag
+ * from JSON instead of inline `--state k=v`. Two accepted shapes:
+ *   flat shared   {"y_imported": 12}            → merged over --state, all keys share it
+ *   per-node map  {"node-a": {"y": 1}, ...}     → each judged node gets its own bag
+ * (disambiguated by "every value is a plain object"). Returns the per-node map
+ * when shape B, null when merged into `shared`. Throws on unreadable/invalid.
+ */
+function loadStateFile(args, shared) {
+    const sf = args.flags["state-file"];
+    if (sf === undefined)
+        return null; // flag absent → no bags (plain can/ready)
+    if (sf === true || sf === "")
+        throw new Error("usage: --state-file <path.json>");
+    let parsed;
+    try {
+        parsed = JSON.parse(require("node:fs").readFileSync(String(sf), "utf8"));
+    }
+    catch (e) {
+        throw new Error(`cannot read --state-file ${sf}: ${e?.message || e}`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("--state-file must contain a JSON object (flat counters, or per-node key→object map)");
+    }
+    const vals = Object.values(parsed);
+    if (vals.length && vals.every((v) => v && typeof v === "object" && !Array.isArray(v)))
+        return parsed;
+    Object.assign(shared, parsed);
+    return null;
+}

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

@@ -44,6 +44,14 @@ class TreeStore {
     nodeGet(treeId, keyOrId) {
         return this.db.get("SELECT * FROM nodes WHERE tree_id=? AND (key=? OR id=?)", [treeId, keyOrId, keyOrId]);
     }
+    /** Which OTHER trees contain this key? (Report ③: a parallel session
+     *  flipped current_tree; `node can p_dates` then said just "node not
+     *  found" — the key existed the whole time, in another tree. This lookup
+     *  lets the error name the tree instead of forcing a blind node list.) */
+    nodeInOtherTrees(keyOrId, excludeTreeId) {
+        return this.db.all(`SELECT t.name AS tree, n.key FROM nodes n JOIN trees t ON t.id=n.tree_id
+        WHERE n.tree_id<>? AND (n.key=? OR n.id=?) LIMIT 5`, [excludeTreeId, keyOrId, keyOrId]);
+    }
     /** Runtime state for one node (default context). Separate from nodeGet on
      *  purpose: nodeGet feeds WRITE paths, and a context join there could return
      *  one row per context — silently wrong for link/unlink/rm. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ygl-trees",
-  "version": "0.77.3",
+  "version": "0.79.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/cosmokit": "~1.8.6-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"
   },
   "devDependencies": {
@@ -49,7 +49,8 @@
     ],
     "exclude": [
       "node_modules",
-      "dist"
+      "dist",
+      "tmp"
     ],
     "env": {
       "YGL_TEST": "1"

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

@@ -9,7 +9,7 @@ description: >-
   触发词：ygl-trees 入门、初始化、quickstart、工作区、退出码、exit code、备份、export、
   PostgreSQL、sync、migrate、镜像、job、tick、定时、doctor、健康检查、任务、task、
   关联、rel、插件、plugin、WebUI、webui、仪表盘、dashboard、bench、基准、bundle。
-version: 0.73.0
+version: 0.79.0
 tags: ygl-trees,quickstart,backup,postgres,schedule,doctor,plugin,webui,bench
 ---
 
@@ -56,25 +56,35 @@ ygl-trees llms --json              # 结构化 JSON
 ## 2b. 运维命令速查
 
 ```bash
-ygl-trees doctor           # 9 项健康检查
-ygl-trees doctor --fix     # 一键安全修复（脏索引标记 + 陈旧锁清理）
+ygl-trees doctor           # 10 项健康检查（含锁 pid 存活、幻影写入对账）
+ygl-trees doctor --fix     # 一键安全修复（脏索引 + 死 pid 陈旧锁；活 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 可访问
+ygl-trees webui serve --help   # 只打印用法不启服务（0.79.1 短路）
 ```
 
 PG 迁移预检：`db migrate pg` 前自动逐表扫描 INTEGER 列类型——非整数值会**点名 table.column rowid=N** 而非迁移时才爆。
 
-## 2c. DB 锁行为（0.68）
+## 2b2. 多会话安全（0.79）
 
-- CLI 短命令：进程级锁（保护写窗口，退出自动释放）
-- webui serve：无锁（WAL 并发安全，与 CLI 共存）
+- `tree use` / `project use` 落 `tree.use` / `project.use` 事件（`YGL_SESSION` 会话标识）
+- `agent brief` 的 `selection_changed`：最近 10 分钟选择变更；跨会话变更置顶提示带 `-t`/`-p`
+- `kb add` 回执自检（`verified:true`）+ 工作区回显（防写错 home 的"丢笔记"事故）
+- `research claim link <cid> <sid> --by-source`：来源下全部证据一次挂齐；误传来源 id 会列出其证据 id
+
+## 2c. DB 锁行为（0.68 → 0.79.1）
+
+- CLI 短命令：进程级锁（保护写窗口，退出自动释放）；锁文件记录**持有者命令行**，撞锁/`db unlock`/`doctor` 都回显真实持有者身份
+- webui serve：无锁（WAL 并发安全，与 CLI 共存；从不取写锁）
 - 死锁自愈：下一进程探测持有者 PID，死则即时清（无需手动 rmdir）
+- 无锁进程（serve / `db unlock` 自身）退出绝不误清并行会话的活锁（0.79.1 所有权守卫）
 - YGL_TEST=1：全旁路（测试并行）
 
 ## 3. 健康检查与任务
 
 ```bash
-ygl-trees doctor                     # 9 项健康检查（schema/索引/FTS/重复/孤儿/config/锁/eval信封/插件）
+ygl-trees doctor                     # 10 项健康检查（schema/索引/FTS/重复/孤儿/config/锁存活/eval信封/插件/幻影写入）
 ygl-trees task add "<标题>"           # 建任务（todo 起步）
 ygl-trees task list                  # 按状态分组
 ygl-trees task done <id>             # 勾销（全程留痕）
@@ -120,6 +130,7 @@ ygl-trees db export <file.sql>          # 全部数据表 + 行数摘要
 ygl-trees db sync pg <url>              # 可刷新 PK-only 镜像
 ygl-trees db migrate pg <url> [--fresh] # 一次性完整保真迁移
 ygl-trees job add <title> -- "<cmd>" --every 60   # cron 每分钟跑 job tick
+ygl-trees job add "闸门探针" -- "node probe.mjs" --every 30   # 树节奏化监控：任意命令皆可（0.79.1 实证）
 ```
 
 禁止双后端同写：ygl-trees 永远只写 SQLite，PG 是单向出口。

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

@@ -57,5 +57,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` 查看终态表）
 - `--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

@@ -38,6 +38,7 @@ ygl-trees node index && ygl-trees node validate
 
 ```bash
 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 path steel                                   # 解锁顺序+累计成本（目标恒最后）
 ygl-trees node ancestors bronze                             # 闭包索引直查，depth=1 是直接父
@@ -46,6 +47,7 @@ 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）
 
 ## 3. 迁移与保真