@lorekit/cli 1.63.1 → 1.64.0

package/README.md

@@ -419,11 +419,17 @@ body below a small length threshold), **untrimmed-value** (real content with
 surrounding whitespace), **empty-key** (blank key), **volatile-key** (the key
 carries a per-sighting identifier — a run of 6+ digits such as a GitHub comment
 id, or a `pr<n>` / `issue<n>` segment — so it never collides, never dedups, and
-freezes `seen_count` at 1), and **malformed-scope** (e.g.
-a single `:` where `::` is expected). `lint` **exits non-zero (1) when any issue
-is found**, so it is usable as a CI gate (`lorekit lint || exit 1`); a clean run —
-or one where only a store is unavailable — exits 0. The pure rule predicates live
-in `lessons-view.mjs` and are unit-tested one rule at a time.
+freezes `seen_count` at 1), **malformed-scope** (e.g.
+a single `:` where `::` is expected), and **unkinded-state-record** (the value
+parses as a JSON object/array but `kind` is unset — bare scalars are excluded,
+caught by `short-value` only when short; a longer bare scalar is judged by no
+rule — because the SessionStart digest excludes non-lesson kinds by *kind*,
+not by shape, so an un-kinded state record renders as a raw JSON blob inline
+in every session's digest; set `--kind bus`/`--kind signal`).
+`lint` **exits non-zero (1) when any issue is found**, so it is usable as a CI
+gate (`lorekit lint || exit 1`); a clean run — or one where only a store is
+unavailable — exits 0. The pure rule predicates live in `lessons-view.mjs` and
+are unit-tested one rule at a time.
 
 ### `lorekit dedupe`
 
@@ -703,7 +709,9 @@ loops: a per-user **home** tier plus an opt-in per-repo **project** tier.
 
 Each tier is foldered by canonical scope, one markdown file per lesson, with
 YAML frontmatter (`scope, key, tags, source_agent, trigger, created, updated,
-archived_at`) and the lesson as the body:
+archived_at, origin_repo, origin_branch, origin_commit, origin_pr,
+expires_at, seen_count, kind, host` — the same column set as `format.mjs`'s
+`FIELDS`) and the lesson as the body:
 
 ```
 ~/.lorekit/            <repo>/.lorekit/     (opt-in)

package/package.json

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

package/skill/lorekit-groom/rules/grooming-pass.md

@@ -56,6 +56,10 @@ Findings are structural, not semantic — each names its rule:
   frozen at 1. Re-key it onto the structural pattern and move the identifier
   into the body.
 - **malformed-scope** — the scope string is invalid.
+- **unkinded-state-record** — the value parses as a JSON object/array but the
+  entry has no `kind`, so it renders as a raw JSON blob in every SessionStart
+  digest instead of being excluded by `isGeneralLesson`. Set `--kind bus` or
+  `--kind signal` on the record.
 
 These are the cheapest wins and the least controversial, so clear them first.
 For each: either **fix it in place** (rewrite a too-short value into a real

package/skill/lorekit-setup/SKILL.md

@@ -4,8 +4,10 @@ description: >
   Sets up a self-improvement loop for a skill, workflow, or agent using LoreKit,
   so a host gets better across runs by reading its own accumulated lessons at
   the start of every run and hardening the proven ones into permanent rules.
-  Designs the two tiers (a fast episodic tier of LoreKit lessons, advisory-only;
-  a slow procedural tier that promotes a recurring lesson into a host rule),
+  Designs the lessons loop (a fast episodic tier of LoreKit lessons, advisory-only;
+  a slow procedural tier that promotes a recurring lesson into a host rule; and,
+  for the rarer judgement-free, independently-checkable case, a third rung that
+  compiles a recurring lesson into a mechanically-enforced CI invariant instead),
   chooses the lesson bucket (tag + key namespace) and scopes, and installs the
   entrenchment guards that stop a learning loop from reinforcing its own
   mistakes. Also covers the non-LLM case: giving a deterministic job (a GitHub

package/src/shared/lessons-view.mjs

@@ -311,6 +311,30 @@ export const LINT_RULES = {
     const reason = scopeIssue(e.scope);
     return reason ? `malformed scope: ${reason}` : null;
   },
+  // A CI state record (ci-state-records.md) is JSON on an entry left with no
+  // `kind`. `fetchLessons`'s `isGeneralLesson(kind)` filter — `kind == null ||
+  // kind === 'lesson'` — is a hard exclusion by kind, not by shape, so a record
+  // like this is NOT excluded from the SessionStart digest: it renders inline as
+  // a raw JSON blob, unreadable next to prose lessons. Conservative by design,
+  // like `volatile-key`: only a value that PARSES as a JSON object or array
+  // fires — a bare scalar (a plain lesson body that happens to be a number or a
+  // quoted string) is excluded. A short bare scalar is caught by `short-value`;
+  // a bare scalar at or above `MIN_VALUE_LEN` (e.g. a 20-char quoted string) is
+  // judged by no rule at all — a known gap, not a claim that `short-value`
+  // covers every bare scalar — and this rule has no opinion on it either way.
+  'unkinded-state-record': (e) => {
+    if (e.kind != null) return null; // an explicit kind is exactly what this rule exists to require.
+    const v = String(e.value ?? '').trim();
+    if (!v) return null; // an empty value is `empty-value`'s to report.
+    let parsed;
+    try {
+      parsed = JSON.parse(v);
+    } catch {
+      return null; // not JSON — an ordinary prose lesson, not this rule's concern.
+    }
+    if (parsed === null || typeof parsed !== 'object') return null; // a bare scalar — short-value's to catch when short, otherwise unjudged.
+    return 'value is a JSON object/array with no kind set — it renders as a raw JSON blob in every SessionStart digest; set --kind bus or --kind signal';
+  },
 };
 
 // Run every lint rule against one normalized entry, returning the findings it

package/src/store/format.mjs

@@ -34,6 +34,13 @@ export const FIELDS = [
   // columns above: a file written before this existed decodes it as absent,
   // which the read projection reports as 0 rather than inventing a count.
   'seen_count',
+  // Taxonomy — `kind` ('lesson'/'bus'/'signal') and `host` (which agent loop
+  // wrote it), mirroring the hosted `memories.kind`/`memories.host` columns.
+  // Appended like the columns above: a file written before these existed
+  // decodes them as absent, which `normalizeEntry` in lessons-view.mjs falls
+  // back to inferring from tags for, same as an absent remote value.
+  'kind',
+  'host',
 ];
 
 // Serialize an entry ({ ...columns, value }) into file text.

package/src/store/local.mjs

@@ -100,7 +100,7 @@ class LocalStore {
   // contract's error surfacing.
   async write({
     scope, key, value, tags, source_agent, trigger, created_at, ttl_days, clear_ttl,
-    origin_repo, origin_branch, origin_commit, origin_pr,
+    origin_repo, origin_branch, origin_commit, origin_pr, kind, host,
   } = {}) {
     const now = new Date().toISOString();
     const existing = this._findByKey(scope, key);
@@ -129,6 +129,10 @@ class LocalStore {
       origin_branch: origin_branch ?? existing?.entry.origin_branch ?? null,
       origin_commit: origin_commit ?? existing?.entry.origin_commit ?? null,
       origin_pr: origin_pr ?? existing?.entry.origin_pr ?? null,
+      // Taxonomy, same last-known-wins provenance as origin above: an
+      // omitted --kind/--host on a re-write must not erase a prior value.
+      kind: kind ?? existing?.entry.kind ?? null,
+      host: host ?? existing?.entry.host ?? null,
       created,
       updated: existing ? now : override || now,
       archived_at: null,
@@ -175,6 +179,8 @@ class LocalStore {
       origin_branch: entry.origin_branch ?? null,
       origin_commit: entry.origin_commit ?? null,
       origin_pr: entry.origin_pr ?? null,
+      kind: entry.kind ?? null,
+      host: entry.host ?? null,
       created: entry.created ?? now,
       updated: entry.updated ?? now,
       archived_at: entry.archived_at ?? null,