@nxuss/lemma 1.29.0 → 1.30.1

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-1003%20passing-00c853?style=flat-square)](https://github.com/Nxusbets/lemma)
 
 ```text
     __
@@ -35,6 +35,26 @@ 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.1 — `lemma init` now really installs the Brain's hooks, and big search results stop eating
+> your context.** Dogfooding found that `lemma init` finished "successfully" without installing the
+> git hooks (`post-commit`, `post-merge`, `post-checkout`) or the Claude Code / Codex / Cursor /
+> OpenCode tool hooks that v1.28–v1.30 advertised — so commits never became memories. Fixed
+> (idempotent, merge-only, `--no-hooks` to skip); re-run `lemma init` after updating.
+> `search_workspace` also had a match cap but no size cap: one hit inside a minified bundle returned
+> the whole line (~75k tokens reproduced). Lines are now a 240-char window around the hit and the
+> result is capped at ~8k tokens, with what was dropped disclosed. Plus 10% smaller tool schemas
+> (−938 tokens per session).
+>
+> **🆕 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
@@ -91,6 +111,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
@@ -201,7 +231,7 @@ 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 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. |
@@ -210,7 +240,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:
 
@@ -221,12 +251,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');

package/bin/init.js

@@ -904,9 +904,41 @@ function parseInitArgs(argv = process.argv) {
     showHelp: args.includes('--help') || args.includes('-h'),
     wantDaemon: args.includes('--daemon'),
     wantGateway: args.includes('--gateway'),
+    // Hooks that feed the Brain are project/host config, not a background service: on by default.
+    wantHooks: !args.includes('--no-hooks'),
   };
 }
 
+// The hooks that feed the Brain (git post-commit/post-merge/post-checkout, and the PostToolUse
+// hook of each agent host) live in src/cli/{gitHooks,hostHooks}.ts. They were only wired into the
+// commander `init` in src/cli/lemma-proxy.ts, which the `lemma` binary (lemma-proxy.cjs → this
+// file) never reaches — so `lemma init` reported success and installed none of them.
+function installBrainFeeds(cwd = process.cwd(), home = os.homedir(), mods = null) {
+  const lines = [];
+  let git, host;
+  try {
+    const dir = path.join(__dirname, '..', 'dist', 'cjs', 'cli');
+    git = (mods && mods.gitHooks) || require(path.join(dir, 'gitHooks.js'));
+    host = (mods && mods.hostHooks) || require(path.join(dir, 'hostHooks.js'));
+  } catch {
+    return { ok: false, lines: ['Brain hooks skipped: dist/ not built (run `npm run build:cjs`, then `lemma init` again)'] };
+  }
+  try {
+    const hooks = git.installBrainHooks(cwd);
+    const changed = [...hooks.installed, ...hooks.updated];
+    if (hooks.manual) lines.push(`Git hooks live in versioned ${hooks.manual.hooksDir}/ — not touching them. To feed the Brain, add:\n${hooks.manual.snippet}`);
+    else if (changed.length > 0) lines.push(`Git hooks feed the Brain (${changed.join(', ')})`);
+    else if (hooks.skippedReason) lines.push(`Git hooks skipped: ${hooks.skippedReason}`);
+    for (const { host: name, outcome } of host.installHostHooks(cwd, home)) {
+      if (outcome.status === 'manual') lines.push(`${outcome.file} couldn't be merged safely — not touching it. For ${name}, add:\n${outcome.snippet}`);
+      else if (outcome.status !== 'unchanged') lines.push(`${name} hook ${outcome.status} (${outcome.file})`);
+    }
+  } catch (e) {
+    return { ok: false, lines: [`Could not install the Brain hooks: ${e.message}`] };
+  }
+  return { ok: true, lines };
+}
+
 function applyEnvToCurrentProcess() {
   const proxyUrl = `http://localhost:${PORT}`;
   process.env.LEMMA_PROXY_PORT = PORT;
@@ -984,7 +1016,7 @@ async function main(argv = process.argv) {
     process.stderr.write(`
   Lemma Init — project setup (project-local files + MCP registrations only)
 
-  Usage: lemma init [--daemon] [--gateway]
+  Usage: lemma init [--daemon] [--gateway] [--no-hooks]
 
     --daemon    Install + start the background cache-proxy daemon
                 (launchd KeepAlive on macOS, systemd user unit on Linux).
@@ -993,6 +1025,8 @@ async function main(argv = process.argv) {
     --gateway   Reroute this user's Claude Code model traffic through the proxy
                 (~/.claude/settings.json). Requires ANTHROPIC_API_KEY in env.
                 Without it, Claude Code keeps its own auth untouched.
+    --no-hooks  Skip the hooks that feed the Brain (git post-commit/post-merge/
+                post-checkout; Claude Code, Codex, Cursor and OpenCode tool hooks).
 
 `);
     return;
@@ -1018,11 +1052,12 @@ async function main(argv = process.argv) {
 
   // --gateway is opt-in: flipping the user's global Claude Code auth without being
   // asked is exactly how Pro subscribers end up billed as API usage.
+  let gatewayResult = { activated: false };
   if (!opts.wantGateway) {
     skip('Claude Code gateway not requested — model traffic + auth untouched (MCP tools only). Re-run with --gateway to route it via the proxy.');
   } else {
     const anthropicApiKey = process.env.ANTHROPIC_API_KEY || '';
-    const gatewayResult = configureClaudeCodeGateway(anthropicApiKey);
+    gatewayResult = configureClaudeCodeGateway(anthropicApiKey);
     if (gatewayResult.activated) {
       ok(`Claude Code gateway activated (~/.claude/settings.json → ANTHROPIC_BASE_URL=http://localhost:${PORT})`);
     } else {
@@ -1095,6 +1130,14 @@ async function main(argv = process.argv) {
     skip('Proxy daemon not installed (opt-in via `lemma init --daemon`)');
   }
 
+  if (opts.wantHooks) {
+    const feeds = installBrainFeeds(process.cwd());
+    for (const line of feeds.lines) (feeds.ok ? ok : warn)(line);
+    if (feeds.ok && feeds.lines.length === 0) skip('Brain hooks already installed');
+  } else {
+    skip('Brain hooks not installed (--no-hooks)');
+  }
+
   const envFile = createEnvFile();
   ok(`Env file created: ${envFile}`);
 
@@ -1128,4 +1171,4 @@ if (require.main === module) {
   });
 }
 
-module.exports = { main, configureMuse, configureMuseUserSkill, updateAgentsMd, MUSE_SKILL_CONTENT, LEMMA_RULES_CONTENT, installProxyDaemon, removeProxyDaemon, parseInitArgs, createEnvFile };
+module.exports = { main, configureMuse, configureMuseUserSkill, updateAgentsMd, MUSE_SKILL_CONTENT, LEMMA_RULES_CONTENT, installProxyDaemon, removeProxyDaemon, parseInitArgs, createEnvFile, installBrainFeeds };

package/dist/cjs/cli/hostHooks.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Installs the hooks that let the Brain speak through each agent host's own tools (see
+ * HostRecall / HostAdapters) and capture red → green fixes run through the host's shell (see
+ * FixCapture). Without them the Brain only ever saw Lemma's MCP tools — and agents mostly read,
+ * edit and test with their native ones.
+ *
+ *  - Claude Code — `.claude/settings.local.json` PostToolUse (personal, never the team's
+ *    versioned settings.json; gitignored if the repo doesn't ignore it yet).
+ *  - Codex       — `~/.codex/hooks.json` PostToolUse, same format as Claude Code.
+ *  - Cursor      — `~/.cursor/hooks.json` postToolUse + postToolUseFailure.
+ *  - OpenCode    — a plugin in `~/.config/opencode/plugins/` (it has no hook protocol).
+ *
+ * Codex/Cursor/OpenCode go in user-level config: their project-level files are the team's and
+ * versioned, and the hook is repo-agnostic anyway (silent wherever the Brain has nothing).
+ *
+ * Same constraints as the git hook installer:
+ *  - Merge, never overwrite. Other hooks and settings are kept exactly as they were; Lemma's
+ *    entry is found by its command and updated in place (idempotent).
+ *  - A config file that isn't valid JSON — or a plugin file Lemma didn't write — is left alone,
+ *    and the caller gets what to add by hand.
+ *  - Never break a tool call: the command is guarded so a missing binary is a silent no-op.
+ */
+export declare function hookCommand(host: 'claude' | 'codex' | 'cursor'): string;
+export declare const CLAUDE_HOOK_COMMAND: string;
+export declare const CLAUDE_HOOK_MATCHER = "Bash|Read|Edit|MultiEdit|Write|NotebookEdit";
+export declare const CODEX_HOOK_MATCHER = "Bash|apply_patch|Edit|Write";
+export declare const CURSOR_POST_MATCHER = "Read|Shell|Write";
+export declare const CURSOR_FAILURE_MATCHER = "Shell";
+export interface HookInstallOutcome {
+    status: 'installed' | 'updated' | 'unchanged' | 'manual';
+    file: string;
+    /** Set when the file couldn't be merged safely; holds what to add by hand. */
+    snippet?: string;
+    /** True when `.claude/settings.local.json` was appended to .gitignore (Claude Code only). */
+    gitignored?: boolean;
+}
+export declare function installClaudeHooks(cwd?: string): HookInstallOutcome;
+export declare function installCodexHooks(home?: string): HookInstallOutcome;
+/** Cursor format: `{ version: 1, hooks: { <event>: [{ command, matcher? }] } }`. */
+export declare function installCursorHooks(home?: string): HookInstallOutcome;
+/**
+ * OpenCode has no hook protocol, so the hook is a plugin: it forwards each finished tool call
+ * to `lemma-brain-ingest --host=opencode` and appends the note it prints (if any) to the tool's
+ * output — the only place a plugin can put text the model reads. Arguments are taken from
+ * tool.execute.before, keyed by call id, because the after-hook's input doesn't carry them.
+ */
+export declare const OPENCODE_PLUGIN = "// managed by `lemma init` \u2014 delete this file to disable Lemma Brain recall in OpenCode\nimport { spawnSync } from \"node:child_process\";\n\nexport const LemmaBrainRecall = async ({ directory }) => {\n  const argsByCall = new Map();\n  return {\n    \"tool.execute.before\": async (input, output) => {\n      if (!input || !input.callID) return;\n      argsByCall.set(input.callID, (output && output.args) || {});\n      if (argsByCall.size > 200) argsByCall.delete(argsByCall.keys().next().value);\n    },\n    \"tool.execute.after\": async (input, output) => {\n      try {\n        const args = argsByCall.get(input.callID) || input.args || {};\n        argsByCall.delete(input.callID);\n        if (!output || typeof output.output !== \"string\") return;\n        const payload = { tool: input.tool, sessionID: input.sessionID, args, output: output.output, metadata: output.metadata || {}, directory };\n        const r = spawnSync(\"lemma-brain-ingest\", [\"--hook-result\", \"--host=opencode\"], { input: JSON.stringify(payload), encoding: \"utf8\", timeout: 5000 });\n        const note = typeof r.stdout === \"string\" ? r.stdout.trim() : \"\";\n        if (note) output.output += \"\\n\\n\" + note;\n      } catch {\n        // A recall hint must never be the reason a tool call fails.\n      }\n    },\n  };\n};\n";
+export declare function installOpenCodePlugin(home?: string): HookInstallOutcome;
+export interface HostHookReport {
+    host: 'Claude Code' | 'Codex' | 'Cursor' | 'OpenCode';
+    outcome: HookInstallOutcome;
+}
+/**
+ * Claude Code is always wired (project-local file). The other hosts only when their config
+ * directory already exists — Lemma doesn't create a Cursor or Codex setup on a machine that has
+ * neither.
+ */
+export declare function installHostHooks(cwd?: string, home?: string): HostHookReport[];
+//# sourceMappingURL=hostHooks.d.ts.map

package/dist/cjs/cli/hostHooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostHooks.d.ts","sourceRoot":"","sources":["../../../src/cli/hostHooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AASH,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAGvE;AAED,eAAO,MAAM,mBAAmB,QAAwB,CAAC;AACzD,eAAO,MAAM,mBAAmB,gDAAgD,CAAC;AACjF,eAAO,MAAM,kBAAkB,gCAAgC,CAAC;AAChE,eAAO,MAAM,mBAAmB,qBAAqB,CAAC;AACtD,eAAO,MAAM,sBAAsB,UAAU,CAAC;AAE9C,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAC;IACzD,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6FAA6F;IAC7F,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAuED,wBAAgB,kBAAkB,CAAC,GAAG,GAAE,MAAsB,GAAG,kBAAkB,CAKlF;AAED,wBAAgB,iBAAiB,CAAC,IAAI,GAAE,MAAqB,GAAG,kBAAkB,CAEjF;AAED,oFAAoF;AACpF,wBAAgB,kBAAkB,CAAC,IAAI,GAAE,MAAqB,GAAG,kBAAkB,CAkClF;AAID;;;;;GAKG;AACH,eAAO,MAAM,eAAe,szCA0B3B,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,IAAI,GAAE,MAAqB,GAAG,kBAAkB,CAYrF;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,aAAa,GAAG,OAAO,GAAG,QAAQ,GAAG,UAAU,CAAC;IACtD,OAAO,EAAE,kBAAkB,CAAC;CAC7B;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,GAAE,MAAsB,EAAE,IAAI,GAAE,MAAqB,GAAG,cAAc,EAAE,CAO3G"}

package/dist/cjs/cli/hostHooks.js

@@ -0,0 +1,235 @@
+"use strict";
+/**
+ * Installs the hooks that let the Brain speak through each agent host's own tools (see
+ * HostRecall / HostAdapters) and capture red → green fixes run through the host's shell (see
+ * FixCapture). Without them the Brain only ever saw Lemma's MCP tools — and agents mostly read,
+ * edit and test with their native ones.
+ *
+ *  - Claude Code — `.claude/settings.local.json` PostToolUse (personal, never the team's
+ *    versioned settings.json; gitignored if the repo doesn't ignore it yet).
+ *  - Codex       — `~/.codex/hooks.json` PostToolUse, same format as Claude Code.
+ *  - Cursor      — `~/.cursor/hooks.json` postToolUse + postToolUseFailure.
+ *  - OpenCode    — a plugin in `~/.config/opencode/plugins/` (it has no hook protocol).
+ *
+ * Codex/Cursor/OpenCode go in user-level config: their project-level files are the team's and
+ * versioned, and the hook is repo-agnostic anyway (silent wherever the Brain has nothing).
+ *
+ * Same constraints as the git hook installer:
+ *  - Merge, never overwrite. Other hooks and settings are kept exactly as they were; Lemma's
+ *    entry is found by its command and updated in place (idempotent).
+ *  - A config file that isn't valid JSON — or a plugin file Lemma didn't write — is left alone,
+ *    and the caller gets what to add by hand.
+ *  - Never break a tool call: the command is guarded so a missing binary is a silent no-op.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPENCODE_PLUGIN = exports.CURSOR_FAILURE_MATCHER = exports.CURSOR_POST_MATCHER = exports.CODEX_HOOK_MATCHER = exports.CLAUDE_HOOK_MATCHER = exports.CLAUDE_HOOK_COMMAND = void 0;
+exports.hookCommand = hookCommand;
+exports.installClaudeHooks = installClaudeHooks;
+exports.installCodexHooks = installCodexHooks;
+exports.installCursorHooks = installCursorHooks;
+exports.installOpenCodePlugin = installOpenCodePlugin;
+exports.installHostHooks = installHostHooks;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const HOOK_MARK = 'lemma-brain-ingest --hook-result';
+function hookCommand(host) {
+    const flag = host === 'claude' ? '' : ` --host=${host}`;
+    return `command -v lemma-brain-ingest >/dev/null 2>&1 && ${HOOK_MARK}${flag} || true`;
+}
+exports.CLAUDE_HOOK_COMMAND = hookCommand('claude');
+exports.CLAUDE_HOOK_MATCHER = 'Bash|Read|Edit|MultiEdit|Write|NotebookEdit';
+exports.CODEX_HOOK_MATCHER = 'Bash|apply_patch|Edit|Write';
+exports.CURSOR_POST_MATCHER = 'Read|Shell|Write';
+exports.CURSOR_FAILURE_MATCHER = 'Shell';
+const isOurs = (h) => typeof h?.command === 'string' && h.command.includes(HOOK_MARK);
+function readJsonObject(file) {
+    if (!fs_1.default.existsSync(file))
+        return {};
+    try {
+        const v = JSON.parse(fs_1.default.readFileSync(file, 'utf8'));
+        return v && typeof v === 'object' && !Array.isArray(v) ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeJson(file, value) {
+    fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+    fs_1.default.writeFileSync(file, JSON.stringify(value, null, 2) + '\n');
+}
+/**
+ * Claude Code / Codex format: `hooks.<Event>[] = { matcher, hooks: [{ type, command }] }`.
+ * Lemma's hook object is identified by its command; when a user put their own hooks in the same
+ * entry, Lemma's moves to an entry of its own instead of widening their matcher.
+ */
+function mergeMatcherHooks(file, event, matcher, command) {
+    const wanted = { matcher, hooks: [{ type: 'command', command }] };
+    const settings = readJsonObject(file);
+    if (!settings) {
+        return { status: 'manual', file, snippet: JSON.stringify({ hooks: { [event]: [wanted] } }, null, 2) };
+    }
+    settings.hooks = settings.hooks && typeof settings.hooks === 'object' ? settings.hooks : {};
+    const list = Array.isArray(settings.hooks[event]) ? settings.hooks[event] : [];
+    const ours = list.find((e) => Array.isArray(e?.hooks) && e.hooks.some(isOurs));
+    let status;
+    if (!ours) {
+        list.push(wanted);
+        status = 'installed';
+    }
+    else if (JSON.stringify({ matcher: ours.matcher, hooks: ours.hooks }) === JSON.stringify(wanted)) {
+        status = 'unchanged';
+    }
+    else if (ours.hooks.every(isOurs)) {
+        ours.matcher = matcher;
+        ours.hooks = wanted.hooks;
+        status = 'updated';
+    }
+    else {
+        ours.hooks = ours.hooks.filter((h) => !isOurs(h));
+        list.push(wanted);
+        status = 'updated';
+    }
+    settings.hooks[event] = list;
+    if (status !== 'unchanged')
+        writeJson(file, settings);
+    return { status, file };
+}
+function ensureClaudeLocalIgnored(cwd) {
+    const rel = path_1.default.join('.claude', 'settings.local.json');
+    try {
+        (0, child_process_1.execFileSync)('git', ['-C', cwd, 'check-ignore', '-q', rel], { stdio: 'ignore' });
+        return false; // already ignored
+    }
+    catch (e) {
+        // Exit 1 = not ignored; anything else (not a repo, no git) = nothing to protect.
+        if (e?.status !== 1)
+            return false;
+    }
+    const gitignore = path_1.default.join(cwd, '.gitignore');
+    const rule = '.claude/settings.local.json';
+    const existing = fs_1.default.existsSync(gitignore) ? fs_1.default.readFileSync(gitignore, 'utf8') : '';
+    if (existing.split('\n').some((l) => l.trim() === rule))
+        return false;
+    fs_1.default.appendFileSync(gitignore, `${existing && !existing.endsWith('\n') ? '\n' : ''}${rule}\n`);
+    return true;
+}
+function installClaudeHooks(cwd = process.cwd()) {
+    const res = mergeMatcherHooks(path_1.default.join(cwd, '.claude', 'settings.local.json'), 'PostToolUse', exports.CLAUDE_HOOK_MATCHER, exports.CLAUDE_HOOK_COMMAND);
+    if (res.status === 'manual')
+        return res;
+    const gitignored = ensureClaudeLocalIgnored(cwd);
+    return { ...res, ...(gitignored ? { gitignored } : {}) };
+}
+function installCodexHooks(home = os_1.default.homedir()) {
+    return mergeMatcherHooks(path_1.default.join(home, '.codex', 'hooks.json'), 'PostToolUse', exports.CODEX_HOOK_MATCHER, hookCommand('codex'));
+}
+/** Cursor format: `{ version: 1, hooks: { <event>: [{ command, matcher? }] } }`. */
+function installCursorHooks(home = os_1.default.homedir()) {
+    const file = path_1.default.join(home, '.cursor', 'hooks.json');
+    const command = hookCommand('cursor');
+    const wanted = {
+        postToolUse: { command, matcher: exports.CURSOR_POST_MATCHER },
+        postToolUseFailure: { command, matcher: exports.CURSOR_FAILURE_MATCHER },
+    };
+    const config = readJsonObject(file);
+    if (!config) {
+        return {
+            status: 'manual',
+            file,
+            snippet: JSON.stringify({ version: 1, hooks: Object.fromEntries(Object.entries(wanted).map(([k, v]) => [k, [v]])) }, null, 2),
+        };
+    }
+    const fresh = !fs_1.default.existsSync(file);
+    if (typeof config.version !== 'number')
+        config.version = 1;
+    config.hooks = config.hooks && typeof config.hooks === 'object' ? config.hooks : {};
+    let changed = false;
+    let added = false;
+    for (const [event, entry] of Object.entries(wanted)) {
+        const list = Array.isArray(config.hooks[event]) ? config.hooks[event] : [];
+        const i = list.findIndex(isOurs);
+        if (i < 0) {
+            list.push(entry);
+            changed = added = true;
+        }
+        else if (JSON.stringify(list[i]) !== JSON.stringify(entry)) {
+            list[i] = entry;
+            changed = true;
+        }
+        config.hooks[event] = list;
+    }
+    if (changed)
+        writeJson(file, config);
+    return { status: !changed ? 'unchanged' : fresh || added ? 'installed' : 'updated', file };
+}
+const OPENCODE_MARK = '// managed by `lemma init` — delete this file to disable Lemma Brain recall in OpenCode';
+/**
+ * OpenCode has no hook protocol, so the hook is a plugin: it forwards each finished tool call
+ * to `lemma-brain-ingest --host=opencode` and appends the note it prints (if any) to the tool's
+ * output — the only place a plugin can put text the model reads. Arguments are taken from
+ * tool.execute.before, keyed by call id, because the after-hook's input doesn't carry them.
+ */
+exports.OPENCODE_PLUGIN = `${OPENCODE_MARK}
+import { spawnSync } from "node:child_process";
+
+export const LemmaBrainRecall = async ({ directory }) => {
+  const argsByCall = new Map();
+  return {
+    "tool.execute.before": async (input, output) => {
+      if (!input || !input.callID) return;
+      argsByCall.set(input.callID, (output && output.args) || {});
+      if (argsByCall.size > 200) argsByCall.delete(argsByCall.keys().next().value);
+    },
+    "tool.execute.after": async (input, output) => {
+      try {
+        const args = argsByCall.get(input.callID) || input.args || {};
+        argsByCall.delete(input.callID);
+        if (!output || typeof output.output !== "string") return;
+        const payload = { tool: input.tool, sessionID: input.sessionID, args, output: output.output, metadata: output.metadata || {}, directory };
+        const r = spawnSync("lemma-brain-ingest", ["--hook-result", "--host=opencode"], { input: JSON.stringify(payload), encoding: "utf8", timeout: 5000 });
+        const note = typeof r.stdout === "string" ? r.stdout.trim() : "";
+        if (note) output.output += "\\n\\n" + note;
+      } catch {
+        // A recall hint must never be the reason a tool call fails.
+      }
+    },
+  };
+};
+`;
+function installOpenCodePlugin(home = os_1.default.homedir()) {
+    const file = path_1.default.join(home, '.config', 'opencode', 'plugins', 'lemma-brain-recall.js');
+    if (fs_1.default.existsSync(file)) {
+        const current = fs_1.default.readFileSync(file, 'utf8');
+        if (!current.startsWith(OPENCODE_MARK))
+            return { status: 'manual', file, snippet: exports.OPENCODE_PLUGIN };
+        if (current === exports.OPENCODE_PLUGIN)
+            return { status: 'unchanged', file };
+        fs_1.default.writeFileSync(file, exports.OPENCODE_PLUGIN);
+        return { status: 'updated', file };
+    }
+    fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+    fs_1.default.writeFileSync(file, exports.OPENCODE_PLUGIN);
+    return { status: 'installed', file };
+}
+/**
+ * Claude Code is always wired (project-local file). The other hosts only when their config
+ * directory already exists — Lemma doesn't create a Cursor or Codex setup on a machine that has
+ * neither.
+ */
+function installHostHooks(cwd = process.cwd(), home = os_1.default.homedir()) {
+    const out = [{ host: 'Claude Code', outcome: installClaudeHooks(cwd) }];
+    const has = (...p) => fs_1.default.existsSync(path_1.default.join(home, ...p));
+    if (has('.codex'))
+        out.push({ host: 'Codex', outcome: installCodexHooks(home) });
+    if (has('.cursor'))
+        out.push({ host: 'Cursor', outcome: installCursorHooks(home) });
+    if (has('.config', 'opencode') || has('.opencode'))
+        out.push({ host: 'OpenCode', outcome: installOpenCodePlugin(home) });
+    return out;
+}
+//# sourceMappingURL=hostHooks.js.map

package/dist/cjs/cli/hostHooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostHooks.js","sourceRoot":"","sources":["../../../src/cli/hostHooks.ts"],"names":[],"mappings":"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"}

package/dist/cjs/cli/lemma-proxy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lemma-proxy.d.ts","sourceRoot":"","sources":["../../../src/cli/lemma-proxy.ts"],"names":[],"mappings":";AAgdA,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CA8DvF;AAqfD,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAGtD;AAgtDD,wBAAsB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA8KhL"}
+{"version":3,"file":"lemma-proxy.d.ts","sourceRoot":"","sources":["../../../src/cli/lemma-proxy.ts"],"names":[],"mappings":";AAidA,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CA8DvF;AAqfD,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAGtD;AA4tDD,wBAAsB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA8KhL"}

package/dist/cjs/cli/lemma-proxy.js

@@ -58,6 +58,7 @@ const ContextInjector_1 = require("../proxy/ContextInjector");
 const SavingsLedger_1 = require("../utils/SavingsLedger");
 const ProjectStore_1 = require("../proxy/ProjectStore");
 const gitHooks_1 = require("./gitHooks");
+const hostHooks_1 = require("./hostHooks");
 const TheBrainV2_1 = require("../subconscious/TheBrainV2");
 const chroma = new chromadb_1.ChromaClient({ host: 'localhost', port: 8000 });
 const dummyEmbeddingFunction = { generate: (texts) => Promise.resolve([]) };
@@ -2518,7 +2519,7 @@ commander_1.program.command('init')
     .description('Initialize Lemma in the current project (auto-discovery)')
     .option('--no-configure', 'Skip automatic configuration of editors, shell overrides, and Claude Desktop')
     .option('--yes', 'Skip prompts and accept defaults')
-    .option('--no-hooks', 'Skip installing the git hooks that feed the Brain (post-commit, post-merge, post-checkout)')
+    .option('--no-hooks', 'Skip installing the hooks that feed the Brain (git post-commit/post-merge/post-checkout; Claude Code, Codex, Cursor and OpenCode tool hooks)')
     .action(async (opts) => {
     const project = detectProject();
     console.log(`\n🛠️  Initializing Lemma for [${project}]...`);
@@ -2541,6 +2542,21 @@ commander_1.program.command('init')
         else if (changed.length > 0) {
             console.log(`✅ Git hooks feed the Brain (${changed.join(', ')}): commits become memories, merges pull .lemma-brain/`);
         }
+        try {
+            for (const { host, outcome } of (0, hostHooks_1.installHostHooks)(process.cwd())) {
+                if (outcome.status === 'manual') {
+                    console.log(`⚠️  ${outcome.file} couldn't be merged safely — not touching it. So the Brain speaks through ${host}'s own tools, add:\n${outcome.snippet}`);
+                }
+                else if (outcome.status !== 'unchanged') {
+                    console.log(`✅ ${host} hook ${outcome.status} (${outcome.file}): the Brain flags memories on native reads/edits and known fixes on failing tests`);
+                }
+                if (outcome.gitignored)
+                    console.log('✅ Added .claude/settings.local.json to .gitignore');
+            }
+        }
+        catch (e) {
+            console.log(`⚠️  Could not install the agent host hooks: ${e.message}`);
+        }
     }
     const envFile = path_1.default.join(process.cwd(), '.env');
     const lemmaConfig = `\n# Lemma AI Gateway Configuration\nOPENAI_BASE_URL=http://localhost:8081/v1\nLEMMA_PROJECT=${project}\n`;