@nxuss/lemma 1.28.0 → 1.30.0

package/README.md

@@ -5,7 +5,7 @@
 [![MCP Tools](https://img.shields.io/badge/MCP%20tools-110-ff69b4?style=flat-square)](https://github.com/Nxusbets/lemma)
 [![Security](https://img.shields.io/badge/privacy-firewall%20active-blueviolet?style=flat-square)](https://github.com/Nxusbets/lemma)
 [![Caching](https://img.shields.io/badge/semantic%20memory-enabled-success?style=flat-square)](https://github.com/Nxusbets/lemma)
-[![Tests](https://img.shields.io/badge/tests-964%20passing-00c853?style=flat-square)](https://github.com/Nxusbets/lemma)
+[![Tests](https://img.shields.io/badge/tests-987%20passing-00c853?style=flat-square)](https://github.com/Nxusbets/lemma)
 
 ```text
     __
@@ -35,6 +35,23 @@ 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.30.0 — the Brain speaks through your agent's own tools, for zero tokens.** Agents read,
+> edit and test with their native tools, so the Brain used to stay silent unless the model
+> remembered `search_memory`. Now a post-tool hook answers at the three moments a memory is worth
+> the most: reading a file the Brain has notes on (their ids), editing code where an approach
+> already **failed**, and a test/build/lint failing with an error the Brain has a recorded **fix**
+> for. Local BM25 + hashes, no model tokens; ids and one line only (~35 tokens), and silent by
+> default — no match, a stale fix, or a note already given this session says nothing. `lemma init`
+> wires it for **Claude Code, Codex, Cursor and OpenCode**. Also fixes `store()`'s dedup leaking
+> across projects (the same fix in a second repo was dropped as a "duplicate").
+>
+> **🆕 v1.29.0 — the dashboard shows what the Brain knows.** `lemma start` now opens with a
+> 🧠 Brain panel: how many files of your codebase it carries evidence about, how many times a
+> memory reached an agent's context, growth this week, how much of it is verifiable against the
+> code, where memories come from (manual, red → green fixes, tests, commits, team), and the most
+> recalled ones. Token savings stay as a footnote — the Brain's value is agents not re-discovering
+> context. Same numbers in `brain_stats` and at `GET /api/brain/stats`.
+>
 > **🆕 v1.28.0 — the Brain goes team-wide through git, and fills itself.** `brain_team push`
 > writes your verified memories into the repo (`.lemma-brain/memories/`, one reviewable JSON file
 > each, paths relative to the repo root); `brain_team pull` — automatic on merge/checkout once
@@ -84,6 +101,16 @@ lemma start     # gateway + dashboard on http://localhost:8081
   it, never one without the other). `store_memory` derives `filePaths`/`symbols` by default from
   whatever the session already read, wrote, or patched when the caller doesn't pass them —
   flagged as auto-derived in the response, correctable, but no longer opt-in.
+- **A Brain that speaks up on its own, through the host's tools** — a post-tool hook
+  (`lemma-brain-ingest --hook-result --host=claude|codex|cursor|opencode`) points at memories when
+  the agent reads a file they're about to matter for, warns when an edit touches a documented
+  failed attempt, and names the recorded fix when a verdict command fails with an error already
+  fixed in *this* project (term overlap between error headlines decides "the same failure", not
+  BM25 rank). No model tokens to compute, ids instead of bodies, deduped per host session, and a
+  pointer never counts as reuse. Codex's shell reads (`cat`, `sed -n`, …) and `apply_patch` edits
+  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.
 - **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
@@ -194,8 +221,8 @@ lemma_toolbox { "action": "call",   "tool":  "terraform_drift", "args": {} }
 
 | Command | Action |
 | :--- | :--- |
-| `lemma init` | Bootstraps config, auto-configures MCP for OpenCode, Claude Desktop, Cursor, Windsurf, Kiro, VS Code, and installs the git hooks that feed the Brain (`--no-hooks` to skip). |
-| `lemma start` | Launches proxy, cache engine, and dashboard at `http://localhost:8081`. |
+| `lemma init` | Bootstraps config, auto-configures MCP for OpenCode, Claude Desktop, Cursor, Windsurf, Kiro, VS Code, and installs the hooks that feed the Brain: git hooks, plus the tool hooks for Claude Code, Codex, Cursor and OpenCode (`--no-hooks` to skip). |
+| `lemma start` | Launches proxy, cache engine, and dashboard at `http://localhost:8081` (gateway savings + Brain knowledge panel). |
 | `lemma stop` / `lemma status` / `lemma stats` | Stop, health check, and net token/cost report (reports `NET COST` when a session is underwater). |
 | `lemma mcp` | Starts the stdin/stdout MCP server for IDE integration. |
 | `lemma heal` / `lemma autopilot` / `lemma watch` | Diagnose+repair the last crash / toggle autonomous fix-apply / silent patch-only watcher. |
@@ -203,7 +230,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 --hook-result` | Read a host `PostToolUse` payload on stdin and capture red → green fixes from the agent's own shell. |
+| `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:
 
@@ -214,12 +241,18 @@ Wire the standalone bins into hooks so memory doesn't depend on the assistant re
 ```
 
 ```jsonc
-// .claude/settings.json — red → green fixes from Claude Code's own Bash tool become memories
-{ "hooks": { "PostToolUse": [{ "matcher": "Bash", "hooks": [{ "type": "command",
-  "command": "lemma-brain-ingest --hook-result" }] }] } }
+// .claude/settings.local.json — what `lemma init` writes: fixes from Claude Code's own Bash
+// become memories, and native Read/Edit/Bash get Brain notes back
+{ "hooks": { "PostToolUse": [{ "matcher": "Bash|Read|Edit|MultiEdit|Write|NotebookEdit",
+  "hooks": [{ "type": "command", "command": "lemma-brain-ingest --hook-result" }] }] } }
 ```
 
-The git side needs nothing by hand: `lemma init` installs `post-commit` (commit → memory) and
+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;
+a file that isn't valid JSON is left alone and the snippet printed instead.
+
+The git side needs nothing by hand either: `lemma init` installs `post-commit` (commit → memory) and
 `post-merge`/`post-checkout` (pull the team's `.lemma-brain/`). With a versioned hooks dir
 (`core.hooksPath`, e.g. husky) it prints the lines to add instead of editing team files.
 

package/bin/brain-ingest.js

@@ -14,13 +14,20 @@
  * and never double-store. `--max N` only matters the first time there is no marker yet.
  *
  * Usage: lemma-brain-ingest [projectRoot] [--max N] [--changelog] [--no-commits] [--team-pull]
- *        lemma-brain-ingest --hook-result < payload.json
+ *        lemma-brain-ingest --hook-result [--host=claude|codex|cursor|opencode] < 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's Bash tool shape) and
- *               feed it to FixCapture, so a test that goes red → green through the agent's own
- *               shell becomes a memory too. Wire it in .claude/settings.json:
- *                 "hooks": { "PostToolUse": [{ "matcher": "Bash",
+ * --hook-result Read a host PostToolUse hook payload on stdin (Claude Code shape) and:
+ *               - feed a Bash run to FixCapture, so a test that goes red → green through the
+ *                 agent's own shell becomes a memory too;
+ *               - answer with a HostRecall note (as `additionalContext`, the only PostToolUse
+ *                 output the host puts in the model's context) when a Read touches a file the
+ *                 Brain has memories about, an edit touches a documented failed attempt, or a
+ *                 failing verdict command matches a recorded fix. Silent otherwise.
+ *               --host=claude|codex|cursor|opencode picks the payload/reply dialect
+ *               (default claude; see src/subconscious/HostAdapters.ts).
+ *               `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" }] }] }
  */
 
@@ -34,27 +41,40 @@ function readStdin() {
   }
 }
 
-function hookResult() {
-  const distPath = path.join(__dirname, '..', 'dist', 'cjs', 'utils', 'FixCapture.js');
-  let recordHookPayload;
+function hookResult(args) {
+  const dist = path.join(__dirname, '..', 'dist', 'cjs');
+  let recordHookPayload, recallForHookPayload, normalizeHostPayload, formatHostOutput, parseHost;
   try {
-    ({ recordHookPayload } = require(distPath));
+    ({ recordHookPayload } = require(path.join(dist, 'utils', 'FixCapture.js')));
+    ({ recallForHookPayload } = require(path.join(dist, 'subconscious', 'HostRecall.js')));
+    ({ normalizeHostPayload, formatHostOutput, parseHost } = require(path.join(dist, 'subconscious', 'HostAdapters.js')));
   } catch {
     return; // no build — a hook must stay silent and harmless
   }
-  let payload;
+  const hostArg = args.find((a) => a.startsWith('--host='));
+  const host = parseHost(hostArg ? hostArg.slice('--host='.length) : undefined);
+  let raw;
   try {
-    payload = JSON.parse(readStdin());
+    raw = JSON.parse(readStdin());
   } catch {
     return;
   }
-  const res = recordHookPayload(payload, payload && payload.cwd);
-  if (res && res.captured) console.error(res.note.trim());
+  const notes = [];
+  for (const payload of normalizeHostPayload(host, raw)) {
+    try {
+      const res = recordHookPayload(payload, payload.cwd);
+      if (res && res.captured) console.error(res.note.trim());
+    } catch { /* capture failing must not cost the recall below */ }
+    const note = recallForHookPayload(payload, payload.cwd);
+    if (note && !notes.includes(note)) notes.push(note);
+  }
+  const out = formatHostOutput(host, notes.join('\n'));
+  if (out) process.stdout.write(out);
 }
 
 function main() {
   const args = process.argv.slice(2);
-  if (args.includes('--hook-result')) return hookResult();
+  if (args.includes('--hook-result')) return hookResult(args);
   const maxIndex = args.indexOf('--max');
   const maxCommits = maxIndex >= 0 ? parseInt(args[maxIndex + 1], 10) : undefined;
   const includeChangelog = args.includes('--changelog');