@lorekit/cli 1.32.1 → 1.33.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lorekit/cli",
-  "version": "1.32.1",
+  "version": "1.33.1",
   "description": "Install the LoreKit shared-memory skill and run health checks for the LoreKit MCP server.",
   "license": "MIT",
   "repository": {

package/src/core/lessons.mjs

@@ -3,11 +3,12 @@
 // Storage is reached through the resolved store (local | remote), never a
 // backend directly, so the same read path serves every mode.
 import { deriveScope } from '../scope.mjs';
-// The precedence merge and the literal substring matcher come from the
-// dependency-free `lessons-pure.mjs` — the SAME primitives `tree` and `search`
-// use, so the hook can't drift from them, and the hot path never pulls in the
-// `lessons-view.mjs` render/`util` stack.
-import { resolvePrecedence, matchesQuery } from '../lessons-pure.mjs';
+// The cross-scope precedence merge comes from the dependency-free
+// `lessons-pure.mjs` — the SAME `resolvePrecedence` `tree` uses, so the hook
+// can't drift from it, and the hot path never pulls in the `lessons-view.mjs`
+// render/`util` stack. (Failure-relevance matching is the store's job now, so
+// the hook no longer needs `matchesQuery` — `search` still does.)
+import { resolvePrecedence } from '../lessons-pure.mjs';
 // The deep-link builder is the SAME pure module the `link` command and the
 // `--link` flag use, so the hook's confirmation/nudge links are JSON-encoded
 // correctly (a raw `?scope=global` silently means "all scopes") and can't drift
@@ -135,23 +136,57 @@ export function failureQuery(toolName, toolResponse) {
   return terms;
 }
 
-// Lessons whose key OR value literally contains ANY of the failure `terms`
-// (case-insensitive, via the shared `matchesQuery` — never a regex), capped at
-// `cap`. Pure and best-effort: no terms or no lessons → empty (the caller then
-// falls back to the write-nudge alone). Preserves `lessons` order, so the
-// most-specific scope's relevant lesson surfaces first.
-export function relevantLessons(lessons, terms, cap = MAX_RELEVANT) {
-  if (!Array.isArray(lessons) || !lessons.length || !Array.isArray(terms) || !terms.length) {
-    return [];
-  }
+// De-duplicate store-search hits by `scope::key` and cap them, PRESERVING the
+// store's order — which is NOT relevance ordering: the remote store filters by
+// FTS but orders by `updated_at desc` (recency), and the local one yields scope
+// precedence (most-specific first) only WITHIN a tier — `LocalStore.search`
+// walks the scope hierarchy in `readOrder`, but `TwoTierStore.search` merges
+// project-tier hits ahead of home-tier ones, so a `global` lesson in the project
+// tier outranks a `repo::` one in home. Pure and total — any non-array input
+// degrades to [] rather than throwing (this runs inside the best-effort failure
+// hook).
+export function dedupeRelevant(entries, cap = MAX_RELEVANT) {
+  if (!Array.isArray(entries)) return [];
+  const limit = Math.max(0, cap);
+  const seen = new Set();
   const out = [];
-  for (const l of lessons) {
-    if (terms.some((t) => matchesQuery(l, t))) out.push(l);
-    if (out.length >= cap) break;
+  for (const e of entries) {
+    if (out.length >= limit) break; // checked BEFORE the push, so cap 0 yields []
+    if (!e || !e.key) continue;
+    const id = `${e.scope ?? ''}::${e.key}`;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    out.push(e);
   }
   return out;
 }
 
+// Retrieve lessons relevant to a tool failure by QUERYING the store across the
+// scope hierarchy — as opposed to post-filtering the SessionStart-injected set,
+// which could only ever resurface a lesson that was going to be shown anyway (a
+// lesson in a sibling scope, or one past the per-scope read cap, was
+// unreachable). A SINGLE `store.search` carries ALL the distilled failure terms
+// (OR semantics), so the offline store is walked once rather than once per term.
+// MATCHING is DELEGATED to the store — substring over the full scope for local,
+// server-side FTS (with stemming, so `connect` matches `connection`) for remote.
+// ORDERING is not: the remote returns `updated_at desc`, so the top-`cap` slice
+// is the most RECENT matches, not the most relevant ones. Hits are de-duped and
+// capped by the pure `dedupeRelevant`, keeping the store's own ordering (see its
+// docblock). Best-effort: an unusable/throwing store returns [] so the
+// caller falls back to the write-nudge alone.
+export async function relevantLessonsFromStore(store, scope, terms, { cap = MAX_RELEVANT } = {}) {
+  if (!store || typeof store.search !== 'function') return [];
+  if (!scope || !Array.isArray(scope.readOrder) || scope.readOrder.length === 0) return [];
+  if (!Array.isArray(terms) || terms.length === 0) return [];
+  try {
+    const res = await store.search({ q: terms, scopes: scope.readOrder });
+    if (!res || !res.ok || !Array.isArray(res.entries)) return [];
+    return dedupeRelevant(res.entries, cap);
+  } catch {
+    return []; // best-effort: a failed search falls back to the nudge alone
+  }
+}
+
 // Render the relevant-lessons block injected alongside the failure nudge, or
 // null when nothing matched. Same compact-index shape as `formatLessons`, with a
 // touch more hook per line (there are at most MAX_RELEVANT and they're directly

package/src/hook.mjs

@@ -13,7 +13,7 @@ import {
   retrospectiveNudge,
   failureNudge,
   failureQuery,
-  relevantLessons,
+  relevantLessonsFromStore,
   formatRelevantLessons,
   writeConfirmation,
 } from './core/lessons.mjs';
@@ -148,9 +148,13 @@ async function run(args) {
     try {
       const store = createStore(control);
       if (store) {
-        const { lessons } = await fetchLessons(store, root);
+        // QUERY the store across the scope hierarchy for lessons matching this
+        // failure — not a post-filter of the SessionStart-injected set, which
+        // could only ever resurface an already-shown lesson. Matching is the
+        // store's job (server FTS with stemming for remote, full-scope substring
+        // for local), so a paraphrased prior lesson can still surface.
         const terms = failureQuery(parsed.toolName, parsed.toolResponse);
-        relevant = formatRelevantLessons(relevantLessons(lessons, terms));
+        relevant = formatRelevantLessons(await relevantLessonsFromStore(store, scope, terms));
       }
     } catch {
       relevant = null; // never let a lesson lookup break the failure nudge

package/src/store/local.mjs

@@ -205,14 +205,22 @@ class LocalStore {
   }
 
   // search({ q, scopes, tags }) → { ok, entries } — keyword over key/tags/body.
+  // `q` is a single needle (string) OR a list of needles (string[]); a list
+  // matches an entry when ANY needle is a substring (OR semantics). Either way
+  // this walks each scope EXACTLY ONCE — the failure hook passes all its terms
+  // in one call rather than one call per term, so N terms no longer re-read the
+  // store N times. An empty query (or empty list) returns everything, unchanged.
   async search({ q, scopes, tags } = {}) {
-    const needle = String(q || '').toLowerCase();
+    const needles = (Array.isArray(q) ? q : [q])
+      .map((n) => String(n || '').toLowerCase())
+      .filter(Boolean);
+    const matchAll = needles.length === 0;
     const out = [];
     for (const scope of scopes || []) {
       const { entries } = await this.list({ scope, tags });
       for (const e of entries) {
         const hay = `${e.key}\n${(e.tags || []).join(' ')}\n${e.value || ''}`.toLowerCase();
-        if (!needle || hay.includes(needle)) out.push(e);
+        if (matchAll || needles.some((n) => hay.includes(n))) out.push(e);
       }
     }
     return { ok: true, entries: out };

package/src/store/remote.mjs

@@ -71,8 +71,13 @@ class RemoteStore {
   }
 
   async search({ q, scopes, tags } = {}) {
+    // A list of terms collapses into ONE `websearch` query joined by `OR`, so a
+    // multi-term failure lookup is a single round-trip (the server FTS ORs them
+    // and stems each). `failureQuery` distils terms to `[a-z0-9]+` tokens, so no
+    // FTS metacharacter reaches the query string. A plain string passes through.
+    const query = Array.isArray(q) ? q.filter(Boolean).join(' OR ') : q;
     const body = {};
-    if (q) body.q = q;
+    if (query) body.q = query;
     if (scopes?.length) body.scopes = scopes;
     if (tags?.length) body.tags = tags;
     const res = await this._rest('/memories/search', { method: 'POST', body });