@nxuss/lemma 1.34.0 → 1.36.0

package/README.md

@@ -35,6 +35,17 @@ lemma start     # gateway + dashboard on http://localhost:8081
 >
 > **🆕 v1.22.0 — Lemma auto-activates in every LLM client.** `npm i -g @nxuss/lemma` registers the skill in your **user** catalog (auto-loads in every `muse` session, any project) and `lemma init` wires each project for Muse, Claude Code, Cursor, Codex, Windsurf, Kiro and OpenCode. Health check: `lemma doctor`.
 >
+> **🆕 v1.35.0 — recall *before* the answer, and memories that notice when the world moved.** A
+> status question ("what's still pending?") touches no file, so no post-tool hook ever fired for it
+> and an agent answered from stale notes. `lemma init` now also installs a `UserPromptSubmit` hook
+> that names the memories bearing on the prompt (with age and freshness) and reminds the agent to
+> verify live git/CI state for status questions. `store_memory` takes `refs` — a commit, or an MR /
+> issue with the state it asserts — and `verify_memory` checks them (`git`, `gh`, `glab`; anything it
+> cannot read is `unverified`, never `fresh`). Also: `search_memory` shows each hit's age and lists
+> below-floor near-misses as orientation only, `get_memory` stops saying "tracks nothing" for
+> claim-tracked entries, `lemma-checkpoint` leaves a store draft the next prompt surfaces once, and a
+> stale MCP build is reported by the prompt hook. Re-run `lemma init` after updating.
+>
 > **🆕 v1.34.0 — Dashboard fixes.** The header shows the real running version (from `/health`), the debugger's pause/resume now works against the proxy, the Vite dev proxy points at the right port, and `npm run build` rebuilds the dashboard so the published UI is never stale.
 >
 > **🆕 v1.33.0 — C# (.NET) support, honestly labeled.** New per-project language detection
@@ -172,6 +183,14 @@ lemma start     # gateway + dashboard on http://localhost:8081
   are recovered from the command; OpenCode gets a plugin, since it has no hook protocol.
   Windsurf/Devin post-hooks can't inject context, and Kiro's hooks spend tokens by design, so
   neither is wired.
+- **Recall before the agent answers, and memories that know when the world moved** — a
+  `UserPromptSubmit` hook (`lemma-brain-ingest --prompt-submit`, Claude Code) points at the
+  memories a prompt substantially covers and, for status-style questions, says to verify live state
+  first: file-hash freshness can't see an MR merge. `store_memory` / `update_memory` accept
+  `refs` (`{kind:'commit',sha}`, or `{kind:'mr'|'issue',provider,id,state}`), and `verify_memory`
+  checks them with `git` / `gh` / `glab` — stale when they moved, `unverified` (never `fresh`) when
+  they can't be read. The session-end checkpoint leaves a one-shot reminder to store what was
+  verified.
 - **A team Brain, shared through git** — `brain_team push` writes this project's fresh, tracked
   memories to `.lemma-brain/memories/<id>.json`: one sorted-key JSON file per memory, so two people
   sharing at once never conflict, every shared memory goes through code review, and deleting one is
@@ -294,6 +313,7 @@ lemma_toolbox { "action": "call",   "tool":  "terraform_drift", "args": {} }
 | `lemma activate <key>` | Activate a Pro license. |
 | `lemma-checkpoint [projectRoot]` | Derive a session checkpoint from repo state (branch, changed files, commits) with no assistant call. |
 | `lemma-brain-ingest [projectRoot] [--changelog] [--team-pull]` | Feed The Brain from git commits and `CHANGELOG.md`, incrementally; `--team-pull` imports the repo's `.lemma-brain/`. |
+| `lemma-brain-ingest --prompt-submit` | Read a Claude Code `UserPromptSubmit` payload on stdin and reply with the memories that bear on the prompt (id, age, freshness) plus, for a "what is pending" question, a reminder to verify live git/CI state — or nothing. Also surfaces the last session's store draft and a stale MCP build, once each. |
 | `lemma-brain-ingest --hook-result [--host=claude\|codex\|cursor\|opencode]` | Read a host post-tool payload on stdin: capture red → green fixes from the agent's own shell, and reply with a Brain note (memory ids, failed attempts, known fixes) in that host's format — or nothing. |
 
 Wire the standalone bins into hooks so memory doesn't depend on the assistant remembering to call a tool:
@@ -311,6 +331,23 @@ Wire the standalone bins into hooks so memory doesn't depend on the assistant re
   "hooks": [{ "type": "command", "command": "lemma-brain-ingest --hook-result" }] }] } }
 ```
 
+```jsonc
+// …and the same file gets the recall-before-answer hook (no matcher: it fires on every prompt)
+{ "hooks": { "UserPromptSubmit": [{ "hooks": [{ "type": "command",
+  "command": "lemma-brain-ingest --prompt-submit" }] }] } }
+```
+
+Attach external state when you store something whose truth depends on it, so `verify_memory` can
+tell when it goes stale:
+
+```jsonc
+// store_memory arguments (excerpt)
+{ "refs": [
+  { "kind": "commit", "sha": "2c8a8cb" },                                  // holds while an ancestor of HEAD
+  { "kind": "mr", "provider": "gitlab", "id": "1061", "state": "merged" }  // stale once its state differs
+] }
+```
+
 Codex (`~/.codex/hooks.json`, `--host=codex`), Cursor (`~/.cursor/hooks.json`, `postToolUse` +
 `postToolUseFailure`, `--host=cursor`) and OpenCode (a plugin in `~/.config/opencode/plugins/`) are
 wired the same way by `lemma init` when their config directory exists. Existing hooks are kept;

package/bin/brain-ingest.js

@@ -15,6 +15,7 @@
  *
  * Usage: lemma-brain-ingest [projectRoot] [--max N] [--changelog] [--no-commits] [--team-pull]
  *        lemma-brain-ingest --hook-result [--host=claude|codex|cursor|opencode] < payload.json
+ *        lemma-brain-ingest --prompt-submit < payload.json
  *
  * --team-pull   Import the repo's shared memories from .lemma-brain/ (post-merge/post-checkout).
  * --hook-result Read a host PostToolUse hook payload on stdin (Claude Code shape) and:
@@ -29,6 +30,13 @@
  *               `lemma init` wires it for each host it finds, e.g. .claude/settings.local.json:
  *                 "hooks": { "PostToolUse": [{ "matcher": "Bash|Read|Edit|MultiEdit|Write|NotebookEdit",
  *                   "hooks": [{ "type": "command", "command": "lemma-brain-ingest --hook-result" }] }] }
+ * --prompt-submit Read a Claude Code UserPromptSubmit payload on stdin and answer with the
+ *               Brain's memories that bear on the prompt (ids, age, freshness) plus, for a
+ *               "what is pending" style question, a reminder to verify live state with
+ *               git/gh/glab. This is the recall point that exists before the agent answers: a
+ *               status question touches no file, so no PostToolUse hook ever fires for it.
+ *               Silent when nothing matches. Wired by `lemma init` in
+ *               .claude/settings.local.json under hooks.UserPromptSubmit.
  */
 
 const path = require('path');
@@ -72,8 +80,28 @@ function hookResult(args) {
   if (out) process.stdout.write(out);
 }
 
+function promptSubmit() {
+  const dist = path.join(__dirname, '..', 'dist', 'cjs');
+  let recallForPrompt, formatHostOutput;
+  try {
+    ({ recallForPrompt } = require(path.join(dist, 'subconscious', 'HostRecall.js')));
+    ({ formatHostOutput } = require(path.join(dist, 'subconscious', 'HostAdapters.js')));
+  } catch {
+    return; // no build — a hook must stay silent and harmless
+  }
+  let payload;
+  try {
+    payload = JSON.parse(readStdin());
+  } catch {
+    return;
+  }
+  const out = formatHostOutput('claude', recallForPrompt(payload, payload && payload.cwd, undefined, { mcpEntry: path.join(dist, 'mcp', 'index.js') }), 'UserPromptSubmit');
+  if (out) process.stdout.write(out);
+}
+
 function main() {
   const args = process.argv.slice(2);
+  if (args.includes('--prompt-submit')) return promptSubmit();
   if (args.includes('--hook-result')) return hookResult(args);
   const maxIndex = args.indexOf('--max');
   const maxCommits = maxIndex >= 0 ? parseInt(args[maxIndex + 1], 10) : undefined;

package/bin/checkpoint.js

@@ -35,6 +35,12 @@ function main() {
     console.error('[lemma-checkpoint] Not a git repository — nothing to capture.');
     return;
   }
+  // Leave a draft for the next session's first prompt: a SessionEnd hook can't speak to the
+  // model, and what was verified this session is exactly what a later status question needs.
+  try {
+    const { writeStoreDraft } = require(path.join(__dirname, '..', 'dist', 'cjs', 'utils', 'StoreDraft.js'));
+    writeStoreDraft(projectRoot);
+  } catch { /* the draft is a courtesy */ }
   console.error(
     `[lemma-checkpoint] Saved: ${result.filesModified.length} file(s) changed → ${path.join(projectRoot, '.lemma/session')}`
   );