ygl-trees 0.78.0 → 0.80.0

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

@@ -11,6 +11,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parsePrediction = parsePrediction;
+exports.loadStateSource = loadStateSource;
 exports.measureCriterion = measureCriterion;
 exports.measureNpmVersions = measureNpmVersions;
 exports.auditPredictions = auditPredictions;
@@ -31,25 +32,89 @@ function parsePrediction(text, created) {
     }
     return { horizon, deadline: "" };
 }
-/** Locally measurable criterion matchers. Null → manual. */
-function measureCriterion(crit, db) {
-    // 树≥N / kb≥N — workspace counts (pure local truth)
-    const tree = crit.match(/树\s*≥\s*(\d+)/);
-    const kb = crit.match(/kb\s*≥\s*(\d+)/);
-    if (!tree && !kb)
+/** 0.79.1 --state bridge: load a flat counter map from a JSON file path or an
+ *  http(s) URL (e.g. a DSH API endpoint). Nested objects flatten to dot keys
+ *  ({counts:{y:12}} → "counts.y"); only finite numbers are kept. Null on any
+ *  failure — the audit degrades those criteria back to manual. */
+async function loadStateSource(src, fetchImpl = fetch) {
+    try {
+        let text;
+        if (/^https?:\/\//.test(src)) {
+            const ctl = new AbortController();
+            const t = setTimeout(() => ctl.abort(), 3000);
+            const r = await fetchImpl(src, { signal: ctl.signal });
+            clearTimeout(t);
+            if (!r.ok)
+                return null;
+            text = await r.text();
+        }
+        else {
+            text = require("node:fs").readFileSync(src, "utf8");
+        }
+        const flat = {};
+        const walk = (obj, prefix) => {
+            if (!obj || typeof obj !== "object")
+                return;
+            for (const [k, v] of Object.entries(obj)) {
+                const key = prefix ? `${prefix}.${k}` : k;
+                if (typeof v === "number" && Number.isFinite(v))
+                    flat[key] = v;
+                else if (v && typeof v === "object" && !Array.isArray(v))
+                    walk(v, key);
+            }
+        };
+        walk(JSON.parse(text), "");
+        return flat;
+    }
+    catch {
         return null;
+    }
+}
+/** Locally measurable criterion matchers. Null → manual.
+ *  Precedence: 树/kb workspace counts (local truth) → any `key≥N` whose key
+ *  exists in the optional --state counter map (external truth, 0.79.1). */
+function measureCriterion(crit, db, state) {
     const parts = [];
     const hits = [];
+    const tree = crit.match(/树\s*≥\s*(\d+)/);
     if (tree) {
         const n = db.get("SELECT COUNT(*) c FROM trees").c;
         parts.push(`trees=${n}/${tree[1]}`);
         hits.push(n >= +tree[1]);
     }
+    const kb = crit.match(/kb\s*≥\s*(\d+)/);
     if (kb) {
         const n = db.get("SELECT COUNT(*) c FROM kb_notes").c;
         parts.push(`kb=${n}/${kb[1]}`);
         hits.push(n >= +kb[1]);
     }
+    if (state) {
+        const seen = new Set();
+        for (const m of crit.matchAll(/([\w\u4e00-\u9fa5][\w\u4e00-\u9fa5.-]*)\s*≥\s*(\d+)/g)) {
+            const key = m[1], need = +m[2];
+            if (key === "树" || key === "kb" || seen.has(key))
+                continue;
+            // 0.79.1: suffix match — a bare criterion key (`y_imported`) binds to a
+            // nested flattened state key (`counts.y_imported`) so users don't have
+            // to know the state file's shape. Exact match wins; else the SHALLOWEST
+            // `.*.<key>` (fewest dots) keeps resolution deterministic.
+            let stateKey = key in state ? key : null;
+            if (!stateKey) {
+                const cands = Object.keys(state).filter((sk) => sk.endsWith("." + key) && Number.isFinite(state[sk]));
+                if (cands.length) {
+                    cands.sort((a, b) => (a.split(".").length - b.split(".").length) || a.localeCompare(b));
+                    stateKey = cands[0];
+                }
+            }
+            if (!stateKey || !Number.isFinite(state[stateKey]))
+                continue;
+            seen.add(key);
+            parts.push(`${key}=${state[stateKey]}/${need}${stateKey !== key ? ` (${stateKey})` : ""}`);
+            hits.push(state[stateKey] >= need);
+        }
+    }
+    if (!parts.length)
+        return null;
     const hasOr = crit.includes(" 或 ");
     const hit = hasOr ? hits.some(Boolean) : hits.every(Boolean);
     return { actual: parts.join(" · "), hit };
@@ -86,7 +151,11 @@ async function auditPredictions(inp) {
         const m = c.text.match(/\d{4}-\d{2}-\d{2}\s*前\s*(.+?)(?:——|$)/) || c.text.match(/\]\s*(.+?)(?:——|$)/);
         const criterion = m ? m[1].trim() : "";
         const daysLeft = deadline ? Math.round((Date.parse(deadline) - Date.parse(today)) / 86400000) : null;
-        let measure = measureCriterion(criterion, inp.db);
+        // 0.79.1 (user report): a claim the human already arbitrated (supported /
+        // refuted) is CLOSED — the audit reports the terminal state instead of
+        // re-judging it, so the backtest table stops accumulating settled rows.
+        const resolved = c.status === "supported" || c.status === "refuted";
+        let measure = measureCriterion(criterion, inp.db, inp.state);
         // npm version criterion → registry probe (opt-out for offline/tests)
         if (!measure && /npm 再发\s*≥\s*(\d+)\s*个版本/.test(criterion)) {
             const need = +criterion.match(/npm 再发\s*≥\s*(\d+)/)[1];
@@ -102,7 +171,11 @@ async function auditPredictions(inp) {
         }
         let verdict;
         let hint;
-        if (!measure) {
+        if (resolved) {
+            verdict = "resolved";
+            hint = `已人工仲裁：${c.status}（回测终态，不再复判）`;
+        }
+        else if (!measure) {
             verdict = "manual";
             hint = "外部世界判据——人工核验后 claim resolve";
         }
@@ -112,7 +185,7 @@ async function auditPredictions(inp) {
             verdict = measure.hit ? "hit" : "miss";
         rows.push({
             claim_id: c.id, horizon, deadline, criterion,
-            actual: measure ? measure.actual + (verdict === "pending" && measure.hit ? " · 已达标" : "") : "—",
+            actual: measure ? measure.actual + (!resolved && verdict === "pending" && measure.hit ? " · 已达标" : "") : "—",
             verdict, days_left: daysLeft, hint,
         });
     }

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

@@ -133,6 +133,12 @@ function run(env, action, rest, args) {
         case "spec": {
             const title = rest[0] || String(args.flags.title || "");
             const body = readBody();
+            // Feedback confirmation ①: --design-type is a produce design flag; spec
+            // silently swallowing it let a decision record land as a plain spec.
+            if (args.flags["design-type"] !== undefined) {
+                (0, fmt_1.bad)(ctx, "--design-type belongs to 'produce design' (spec does not take it; if this is a design decision, use: produce design <title> --design-type decision)");
+                return 2;
+            }
             if (!title || !body) {
                 (0, fmt_1.bad)(ctx, "usage: produce spec <title> --body|-f <file>");
                 return 2;

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

@@ -41,6 +41,23 @@ const entities_1 = require("../../pipeline/src/entities");
 function run(env, action, rest, args) {
     const { ctx, store } = env;
     const name = rest[0];
+    /** Report ③-3: selection changes are events (session-tagged) — see the
+     *  twin helper in techtree/model/src/cmds.ts for the rationale. */
+    function logSelectionEvent(kind, projName) {
+        try {
+            store.db.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,
+                "project",
+                projName,
+                JSON.stringify({ name: projName, session: process.env.YGL_SESSION || "cli" }),
+                "info",
+            ]);
+        }
+        catch { /* telemetry only */ }
+    }
     switch (action) {
         case "new": {
             if (!name) {
@@ -48,12 +65,19 @@ function run(env, action, rest, args) {
                 return 2;
             }
             const question = String(args.flags.q || args.flags.question || "");
+            // Feedback confirmation ②: auto-selecting the new project silently
+            // re-points every flag-less command away from prior work — say so.
+            const prior = store.db.metaGet("current_project");
+            const priorHint = prior && prior !== name
+                ? `  (prior project '${prior}' is no longer selected — project use ${prior} to switch back)`
+                : "";
             return (0, orm_1.getOrm)(env.db.path)
                 .then((ds) => writes.projectCreate(ds, name, question))
                 .then((p) => {
+                logSelectionEvent("project.use", p.name);
                 (0, fmt_1.ack)(ctx, p, p?.duplicate === true
-                    ? `project exists, selected: ${p.name}  (duplicate, not re-created)`
-                    : `project created and selected: ${p.name}`);
+                    ? `project exists, selected: ${p.name}  (duplicate, not re-created)${priorHint}`
+                    : `project created and selected: ${p.name}${priorHint}`);
                 return 0;
             })
                 .catch((e) => {
@@ -86,6 +110,7 @@ function run(env, action, rest, args) {
                 return 1;
             }
             store.db.metaSet("current_project", name);
+            logSelectionEvent("project.use", name);
             (0, fmt_1.ack)(ctx, { project: name }, `now using: ${name}`);
             return 0;
         }

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;
+}