@nxuss/lemma 1.27.1 → 1.28.0

package/README.md

@@ -2,10 +2,10 @@
 
 [![npm version](https://img.shields.io/npm/v/@nxuss/lemma.svg?color=orange&style=flat-square)](https://www.npmjs.com/package/@nxuss/lemma)
 [![License](https://img.shields.io/npm/l/@nxuss/lemma.svg?color=blue&style=flat-square)](https://github.com/Nxusbets/lemma/blob/main/LICENSE)
-[![MCP Tools](https://img.shields.io/badge/MCP%20tools-109-ff69b4?style=flat-square)](https://github.com/Nxusbets/lemma)
+[![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-919%20passing-00c853?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)
 
 ```text
     __
@@ -35,6 +35,18 @@ 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.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
+> `lemma init` installs the hooks — imports a teammate's memories rebased onto *your* checkout. A
+> memory about a file that is byte-identical on your machine arrives **fresh**; one whose file has
+> moved on arrives **stale**, never silently trusted. And memories no longer depend on the model
+> remembering `store_memory`: a test/build/lint command that goes **red → green** is captured as
+> `fix: <the error>` + the files and diff that fixed it — searchable by the exact error message next
+> time — whether it ran through `run_workspace_command` or the agent's own shell (Claude Code
+> `PostToolUse` hook). Commits become memories anchored to their own blobs. Also fixes
+> `lemma-brain-ingest` silently dropping everything it ingested.
+>
 > **🆕 v1.26.0 — a memory without evidence is no longer sold as a verified hit, and the Brain
 > repairs it on the spot.** `search_memory` now splits its results into three buckets — `fresh`
 > (tracked + verified, the only ones credited `tokensSaved`/`hits`), `stale`, and `UNTRACKED`
@@ -64,7 +76,7 @@ lemma start     # gateway + dashboard on http://localhost:8081
   the code they're about to touch has dependent memories — including a documented failed
   attempt — instead of only finding out on the next search. Ranking factors in
   real usage (`hits`), explicit negative feedback (`downvote_memory`), and `cognitive_map` domain
-  tags; a passing `test_oracle` run over an uncommitted diff auto-captures itself; two memories
+  tags; a command that goes red → green auto-captures the fix (see below); two memories
   about the same symbol that disagree on outcome are flagged, not silently both suggested.
   Every hit explains itself (`whyShown` ranking signals + cited `evidence` files/symbols), and
   every reuse books its savings onto the memory itself — `brain_stats` and `brain_upkeep` name
@@ -72,6 +84,27 @@ 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 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
+  a `git rm`. Evidence is stored relative to the repo root and rebased onto each clone on `pull`,
+  hashes untouched — a teammate's memory is verified against *your* files, fresh only if they are
+  byte-identical. Never shared: conversation checkpoints, commit memories (each clone derives its
+  own), untracked or stale memories, evidence outside the repo, or anything derived from a memory
+  that isn't shared. A pulled path that is absolute or escapes the repo is rejected; a memory a
+  teammate deletes leaves your clone into `brain_trash` (restorable), and one you wrote yourself is
+  never removed. Pushing is always explicit; pulling is a no-op when nothing changed, so it runs on
+  every merge/checkout. `brain_team status` shows both sides; `dryRun:true` previews either.
+- **Memories that write themselves** — a verdict command (jest, vitest, pytest, tsc, eslint, `go
+  test`, `cargo test`, `npm test`/`build`/`lint`, …) that fails and later passes stores
+  `fix: <headline error>` with the failure signature, the files whose content changed between the
+  two runs, and their diff — tracked against those files, tagged `confirmed`, source `auto-fix`.
+  A pass with nothing changed since the failure is treated as flaky and stores nothing; a "fix" over
+  15 files is a refactor and stores nothing. It sees `run_workspace_command`, `test_oracle`, and — via
+  `lemma-brain-ingest --hook-result` — the agent's own Bash tool. Commits are ingested with each
+  touched file anchored to its blob *in that commit* (`git show sha:path`), not to the working copy.
+  `lemma init` installs the `post-commit`, `post-merge` and `post-checkout` hooks that drive this
+  (appended to existing hooks, idempotent, never touches a versioned `core.hooksPath` like husky).
 - **A memory that maintains itself** — `brain_upkeep` revalidates the most-reused memories,
   surfaces exact duplicates and merge candidates, dead weight, and savings, each finding with its
   fix. Since v1.26.0 it also **auto-anchors** evidence-free memories whose body names real repo
@@ -106,7 +139,7 @@ lemma start     # gateway + dashboard on http://localhost:8081
   compiler-verified AST location instead of asking the model to output a full-file rewrite.
 - **Infrastructure Command Center** — 22 free tools for Jenkins, OKD/OpenShift, and Terraform:
   discover, connect, deploy, diagnose, and detect drift, all via MCP.
-- **Scoped tool surface** — of the 109 registered tools, only the ones your project shows evidence
+- **Scoped tool surface** — of the 110 registered tools, only the ones your project shows evidence
   of needing are advertised to the model each turn; the rest stay one `lemma_toolbox` call away.
 
 See [`CHANGELOG.md`](CHANGELOG.md) for the full, per-version history.
@@ -115,14 +148,14 @@ See [`CHANGELOG.md`](CHANGELOG.md) for the full, per-version history.
 
 ## 💎 Free vs Pro
 
-59 of the 109 registered tools work with no license; 50 require Pro. Enforced by one allowlist in
+60 of the 110 registered tools work with no license; 50 require Pro. Enforced by one allowlist in
 code (`FREE_TOOLS` in `src/mcp/tools.ts`, including all 22 infrastructure tools), not by narrative.
 A session without a license doesn't even advertise the Pro tools — they stay registered and
 discoverable via `lemma_toolbox`.
 
-| | Free (59) | Pro (50) |
+| | Free (60) | Pro (50) |
 | :--- | :--- | :--- |
-| **Caching & memory** | `smarter_cache`, `state_hash_cache`, `token_receipt`, `search_memory`, `list_memories`, `store_memory`, `downvote_memory`, `verify_memory`, `token_budget`, `brain_upkeep`, `brain_trash`, `brain_merge` | `get_telepathic_hints`, `query_hybrid_consensus`, `semantic_dedup_guard`, `local_semantic_autofix` |
+| **Caching & memory** | `smarter_cache`, `state_hash_cache`, `token_receipt`, `search_memory`, `list_memories`, `store_memory`, `downvote_memory`, `verify_memory`, `token_budget`, `brain_upkeep`, `brain_trash`, `brain_merge`, `brain_team` | `get_telepathic_hints`, `query_hybrid_consensus`, `semantic_dedup_guard`, `local_semantic_autofix` |
 | **Reading & context** | `read_workspace_file`, `scrub_privacy`, `import_tree_context`, `bulk_file_digest`, `auto_context_bundle`, `git_blame_heat`, `type_coverage_report` | `get_ast_hologram`, `smart_file_slice`, `get_symbol_surgical_context`, `diff_only` |
 | **Writing & workspace** | — | `write_workspace_file`, `apply_workspace_patch`, `multi_file_patch`, `search_workspace`, `run_workspace_command`, `validate_patch_sandbox`, `surgical_ast_insert` |
 | **Static analysis** | — | `entropy_score`, `coupling_radar`, `pattern_fossil`, `precrime_static`, `dead_export_necromancer`, `depgraph`, `refactor`, `ast_flow_visualizer`, `cognitive_map` |
@@ -137,8 +170,8 @@ Full per-tool listing: `lemma_toolbox { "action": "list" }`.
 
 ## 🎚️ Tool profiles
 
-Every advertised tool schema is re-sent on **every request** of the session — advertising all 109
-costs ~11,600 tokens/turn. Lemma advertises a scoped surface instead: core tools always, situational
+Every advertised tool schema is re-sent on **every request** of the session — advertising all 110
+costs ~11,900 tokens/turn. Lemma advertises a scoped surface instead: core tools always, situational
 groups (e.g. infrastructure) only when the repo shows evidence for them. Nothing is removed —
 everything stays registered and reachable via `lemma_toolbox`.
 
@@ -161,7 +194,7 @@ lemma_toolbox { "action": "call",   "tool":  "terraform_drift", "args": {} }
 
 | Command | Action |
 | :--- | :--- |
-| `lemma init` | Bootstraps config and auto-configures MCP for OpenCode, Claude Desktop, Cursor, Windsurf, Kiro, VS Code. |
+| `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 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. |
@@ -169,7 +202,8 @@ lemma_toolbox { "action": "call",   "tool":  "terraform_drift", "args": {} }
 | `lemma patches` / `lemma apply <id>` / `lemma discard <id>` | List, apply, or discard a pending Silent Patch Watcher fix. |
 | `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]` | Feed The Brain from git commits and `CHANGELOG.md`, incrementally. |
+| `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. |
 
 Wire the standalone bins into hooks so memory doesn't depend on the assistant remembering to call a tool:
 
@@ -179,11 +213,16 @@ Wire the standalone bins into hooks so memory doesn't depend on the assistant re
   "command": "lemma-checkpoint \"${CLAUDE_PROJECT_DIR:-$PWD}\"" }] }] } }
 ```
 
-```bash
-echo 'lemma-brain-ingest "$(git rev-parse --show-toplevel)" &' >> .git/hooks/post-commit
-chmod +x .git/hooks/post-commit
+```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" }] }] } }
 ```
 
+The git side needs nothing by hand: `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.
+
 Customize via `lemma.config.json`:
 
 ```json

package/bin/brain-ingest.js

@@ -13,18 +13,54 @@
  * last commit ingested, so running this after every commit or by hand both take the same path
  * 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]
+ * Usage: lemma-brain-ingest [projectRoot] [--max N] [--changelog] [--no-commits] [--team-pull]
+ *        lemma-brain-ingest --hook-result < 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",
+ *                   "hooks": [{ "type": "command", "command": "lemma-brain-ingest --hook-result" }] }] }
  */
 
 const path = require('path');
 
+function readStdin() {
+  try {
+    return require('fs').readFileSync(0, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function hookResult() {
+  const distPath = path.join(__dirname, '..', 'dist', 'cjs', 'utils', 'FixCapture.js');
+  let recordHookPayload;
+  try {
+    ({ recordHookPayload } = require(distPath));
+  } catch {
+    return; // no build — a hook must stay silent and harmless
+  }
+  let payload;
+  try {
+    payload = JSON.parse(readStdin());
+  } catch {
+    return;
+  }
+  const res = recordHookPayload(payload, payload && payload.cwd);
+  if (res && res.captured) console.error(res.note.trim());
+}
+
 function main() {
   const args = process.argv.slice(2);
+  if (args.includes('--hook-result')) return hookResult();
   const maxIndex = args.indexOf('--max');
   const maxCommits = maxIndex >= 0 ? parseInt(args[maxIndex + 1], 10) : undefined;
   const includeChangelog = args.includes('--changelog');
   const includeCommits = !args.includes('--no-commits');
-  const positional = args.filter((a, i) => !a.startsWith('--') && i !== maxIndex + 1);
+  const teamPull = args.includes('--team-pull');
+  const positional = args.filter((a, i) => !a.startsWith("--") && (maxIndex < 0 || i !== maxIndex + 1));
   const projectRoot = path.resolve(positional[0] || process.cwd());
 
   const distPath = path.join(__dirname, '..', 'dist', 'cjs', 'subconscious', 'GitIngest.js');
@@ -41,16 +77,42 @@ function main() {
     console.error(`[lemma-brain-ingest] commits: ${res.ingested} stored, ${res.skipped} skipped (up to ${res.lastSha ? res.lastSha.substring(0, 12) : 'none'})`);
   }
 
+  if (teamPull) {
+    try {
+      const { pullTeamBrain } = require(path.join(__dirname, '..', 'dist', 'cjs', 'subconscious', 'TeamBrain.js'));
+      const res = pullTeamBrain(projectRoot);
+      console.error(`[lemma-brain-ingest] team: ${res.message}`);
+    } catch (err) {
+      console.error('[lemma-brain-ingest] team pull skipped:', err && err.message);
+    }
+  }
+
   if (includeChangelog) {
     const res = ingestChangelog(projectRoot);
     console.error(`[lemma-brain-ingest] changelog: ${res.ingested} stored, ${res.skipped} skipped (${res.versionsSeen} version(s) seen)`);
   }
 }
 
+/**
+ * The Brain debounces its writes by 500ms (right for a long-lived server), and process.exit()
+ * below drops pending timers — so without an explicit flush every memory this script stored was
+ * lost the moment it exited. Only flush when the Brain was actually loaded.
+ */
+function flushBrain() {
+  try {
+    const modPath = require.resolve(path.join(__dirname, '..', 'dist', 'cjs', 'subconscious', 'TheBrainV2.js'));
+    if (!require.cache[modPath]) return;
+    require(modPath).getBrain().flushSync();
+  } catch (err) {
+    console.error('[lemma-brain-ingest] flush failed:', err && err.message);
+  }
+}
+
 try {
   main();
 } catch (err) {
   // A hook that fails must never be the reason a commit or session goes bad.
   console.error('[lemma-brain-ingest] Skipped:', err && err.message);
 }
+flushBrain();
 process.exit(0);

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

@@ -0,0 +1,28 @@
+/**
+ * Installs the git hooks that feed the Brain without anyone remembering to: post-commit ingests
+ * the new commit, post-merge/post-checkout pull the team's shared memories (`.lemma-brain/`).
+ *
+ * `lemma-brain-ingest` shipped with a post-commit recipe in its header comment and nothing ever
+ * installed it — on the author's own machine the corpus held 0 commit memories. This is the
+ * missing install step, with the constraints a hook installer owes the repo it touches:
+ *
+ *  - Append, never overwrite. An existing hook keeps running exactly as before; Lemma's part is
+ *    one delimited block, and re-running init replaces that block in place (idempotent).
+ *  - Never break a commit. Every line is guarded by `command -v`, backgrounded, and silenced.
+ *  - Respect `core.hooksPath`. `git rev-parse --git-path hooks` resolves it; when it points inside
+ *    the working tree (husky and friends — versioned hooks), the files are the team's, so they are
+ *    left alone and the caller gets the lines to add instead.
+ */
+export interface HookInstallResult {
+    installed: string[];
+    updated: string[];
+    unchanged: string[];
+    /** Set when hooks live in a versioned directory Lemma won't write to; holds what to add by hand. */
+    manual?: {
+        hooksDir: string;
+        snippet: string;
+    };
+    skippedReason?: string;
+}
+export declare function installBrainHooks(cwd?: string): HookInstallResult;
+//# sourceMappingURL=gitHooks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gitHooks.d.ts","sourceRoot":"","sources":["../../../src/cli/gitHooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAmBH,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,oGAAoG;IACpG,MAAM,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/C,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAcD,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,MAAsB,GAAG,iBAAiB,CA0DhF"}

package/dist/cjs/cli/gitHooks.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Installs the git hooks that feed the Brain without anyone remembering to: post-commit ingests
+ * the new commit, post-merge/post-checkout pull the team's shared memories (`.lemma-brain/`).
+ *
+ * `lemma-brain-ingest` shipped with a post-commit recipe in its header comment and nothing ever
+ * installed it — on the author's own machine the corpus held 0 commit memories. This is the
+ * missing install step, with the constraints a hook installer owes the repo it touches:
+ *
+ *  - Append, never overwrite. An existing hook keeps running exactly as before; Lemma's part is
+ *    one delimited block, and re-running init replaces that block in place (idempotent).
+ *  - Never break a commit. Every line is guarded by `command -v`, backgrounded, and silenced.
+ *  - Respect `core.hooksPath`. `git rev-parse --git-path hooks` resolves it; when it points inside
+ *    the working tree (husky and friends — versioned hooks), the files are the team's, so they are
+ *    left alone and the caller gets the lines to add instead.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installBrainHooks = installBrainHooks;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const BEGIN = '# >>> lemma brain hooks >>>';
+const END = '# <<< lemma brain hooks <<<';
+const HOOK_BODIES = {
+    'post-commit': 'command -v lemma-brain-ingest >/dev/null 2>&1 && (lemma-brain-ingest "$(git rev-parse --show-toplevel)" >/dev/null 2>&1 &)',
+    'post-merge': 'command -v lemma-brain-ingest >/dev/null 2>&1 && (lemma-brain-ingest "$(git rev-parse --show-toplevel)" --team-pull --no-commits >/dev/null 2>&1 &)',
+    // $3 is 1 for a branch checkout, 0 for a file checkout — only a branch switch can change the shared set.
+    'post-checkout': '[ "$3" = "1" ] && command -v lemma-brain-ingest >/dev/null 2>&1 && (lemma-brain-ingest "$(git rev-parse --show-toplevel)" --team-pull --no-commits >/dev/null 2>&1 &)',
+};
+function git(cwd, args) {
+    try {
+        return (0, child_process_1.execFileSync)('git', ['-C', cwd, ...args], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function block(hook) {
+    return `${BEGIN}\n${HOOK_BODIES[hook]}\n${END}\n`;
+}
+function installBrainHooks(cwd = process.cwd()) {
+    const result = { installed: [], updated: [], unchanged: [] };
+    const top = git(cwd, ['rev-parse', '--show-toplevel']);
+    const hooksRel = git(cwd, ['rev-parse', '--git-path', 'hooks']);
+    if (!top || !hooksRel) {
+        result.skippedReason = 'not a git repository';
+        return result;
+    }
+    const hooksDir = path_1.default.resolve(cwd, hooksRel);
+    // Inside the working tree and not under .git → a versioned hooks dir (husky etc.). Compared
+    // on realpaths: git reports the toplevel resolved (/private/var/… on macOS) while hooksDir is
+    // built from the cwd as given (/var/…), and the two would otherwise look unrelated.
+    const real = (p) => { try {
+        return fs_1.default.realpathSync(p);
+    }
+    catch {
+        return p;
+    } };
+    const rel = path_1.default.relative(real(top), real(hooksDir));
+    const insideTree = !rel.startsWith('..') && !path_1.default.isAbsolute(rel);
+    const underGitDir = rel === '.git' || rel.startsWith(`.git${path_1.default.sep}`);
+    if (insideTree && !underGitDir) {
+        result.manual = {
+            hooksDir: rel,
+            snippet: Object.keys(HOOK_BODIES).map((h) => `# ${rel}/${h}\n${HOOK_BODIES[h]}`).join('\n\n'),
+        };
+        return result;
+    }
+    fs_1.default.mkdirSync(hooksDir, { recursive: true });
+    for (const hook of Object.keys(HOOK_BODIES)) {
+        const file = path_1.default.join(hooksDir, hook);
+        let current = null;
+        try {
+            current = fs_1.default.readFileSync(file, 'utf8');
+        }
+        catch { /* no hook yet */ }
+        let next;
+        if (current === null) {
+            next = `#!/bin/sh\n${block(hook)}`;
+        }
+        else {
+            const start = current.indexOf(BEGIN);
+            const end = current.indexOf(END);
+            if (start !== -1 && end > start) {
+                next = current.slice(0, start) + block(hook) + current.slice(end + END.length).replace(/^\n/, '');
+            }
+            else {
+                // Appended after the existing script. A hook that ends in `exit 0` would never reach
+                // it — insert before a trailing bare exit instead of after it.
+                const trailingExit = current.match(/\n(exit\s+\d+\s*)$/);
+                next = trailingExit
+                    ? current.slice(0, trailingExit.index + 1) + block(hook) + trailingExit[1]
+                    : `${current}${current.endsWith('\n') ? '' : '\n'}${block(hook)}`;
+            }
+        }
+        if (next === current) {
+            result.unchanged.push(hook);
+            continue;
+        }
+        fs_1.default.writeFileSync(file, next, 'utf8');
+        try {
+            fs_1.default.chmodSync(file, 0o755);
+        }
+        catch { /* Windows: git for Windows runs hooks via sh regardless */ }
+        (current === null ? result.installed : result.updated).push(hook);
+    }
+    return result;
+}
+//# sourceMappingURL=gitHooks.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gitHooks.js","sourceRoot":"","sources":["../../../src/cli/gitHooks.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":";AA8cA,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;AAwrDD,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":";AA+cA,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;AAmsDD,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

@@ -57,6 +57,7 @@ const ProjectRegistry_1 = require("../proxy/ProjectRegistry");
 const ContextInjector_1 = require("../proxy/ContextInjector");
 const SavingsLedger_1 = require("../utils/SavingsLedger");
 const ProjectStore_1 = require("../proxy/ProjectStore");
+const gitHooks_1 = require("./gitHooks");
 const chroma = new chromadb_1.ChromaClient({ host: 'localhost', port: 8000 });
 const dummyEmbeddingFunction = { generate: (texts) => Promise.resolve([]) };
 const complexityRouter = new ComplexityRouter_1.default();
@@ -2503,6 +2504,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)')
     .action(async (opts) => {
     const project = detectProject();
     console.log(`\n🛠️  Initializing Lemma for [${project}]...`);
@@ -2516,6 +2518,16 @@ commander_1.program.command('init')
     if (ensureGitIgnore()) {
         console.log('✅ Updated .gitignore with Lemma ignore rules');
     }
+    if (opts.hooks !== false) {
+        const hooks = (0, gitHooks_1.installBrainHooks)(process.cwd());
+        const changed = [...hooks.installed, ...hooks.updated];
+        if (hooks.manual) {
+            console.log(`⚠️  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) {
+            console.log(`✅ Git hooks feed the Brain (${changed.join(', ')}): commits become memories, merges pull .lemma-brain/`);
+        }
+    }
     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`;
     if (fs_1.default.existsSync(envFile)) {