hebbian 0.6.0 → 0.7.1

package/README.md

@@ -2,7 +2,7 @@
   <img src="https://img.shields.io/badge/TypeScript-6.0-3178C6?style=flat-square&logo=typescript" />
   <img src="https://img.shields.io/badge/Node.js-22+-339933?style=flat-square&logo=node.js" />
   <img src="https://img.shields.io/badge/Runtime_Deps-0-brightgreen?style=flat-square" />
-  <img src="https://img.shields.io/badge/Tests-277-blue?style=flat-square" />
+  <img src="https://img.shields.io/badge/Tests-317-blue?style=flat-square" />
   <img src="https://img.shields.io/badge/MIT-green?style=flat-square" />
 </p>
 
@@ -158,16 +158,56 @@ hebbian doctor       # full diagnostic
 
 ---
 
+## Tool Failure Detection (v0.6.0+)
+
+hebbian automatically learns from failed commands — no explicit correction needed:
+
+```bash
+# During a session, a bash command fails (exit code ≠ 0)
+# → hebbian digest auto-logs it as a tool-failure episode
+# → evolve sees the pattern and proposes inhibitory neurons
+
+hebbian sessions   # see tool-failure episodes in the log
+```
+
+Retry patterns (same error 3+ times) are flagged separately as `retry-pattern` episodes.
+
+---
+
+## Multi-Brain (v0.7.0+)
+
+Per-agent brains for multi-agent setups:
+
+```bash
+# Individual brain for each agent
+hebbian grow cortex/SOME_RULE --agent cto --brain ./brain
+hebbian grow cortex/OTHER_RULE --agent coo --brain ./brain
+
+# Results in:
+# brain/agents/cto/cortex/SOME_RULE/
+# brain/agents/coo/cortex/OTHER_RULE/
+
+# Shared brain (cross-cutting knowledge)
+# brain/shared/cortex/...
+```
+
+---
+
 ## LLM Evolution
 
 ```bash
 GEMINI_API_KEY=... hebbian evolve --dry-run --brain ./brain
+
+# Pruning mode (nightly cleaner — remove stale/redundant neurons)
+GEMINI_API_KEY=... hebbian evolve prune --dry-run --brain ./brain
 ```
 
 The evolve engine reads the last 100 episodes + current brain state, sends it to Gemini, and proposes up to 10 mutations per cycle. Protected regions (brainstem/limbic/sensors) are blocked.
 
 Actions it can take: `grow` (new neuron), `fire` (strengthen), `signal` (dopamine/bomb), `prune` (weaken), `decay` (mark dormant).
 
+**Pruning mode** uses a cleanup-focused prompt that only removes: stale neurons (30+ days inactive), high contra ratio (>0.7), redundant duplicates. Run nightly via cron.
+
 ---
 
 ## CLI Reference
@@ -200,6 +240,11 @@ hebbian digest [--transcript <path>]
 
 # Evolution
 GEMINI_API_KEY=... hebbian evolve [--dry-run]
+GEMINI_API_KEY=... hebbian evolve prune [--dry-run]   # Pruning mode (청소부)
+
+# Multi-brain (per-agent)
+hebbian grow cortex/RULE --agent cto     # Routes to brain/agents/cto/
+hebbian emit claude --agent coo          # Emits from brain/agents/coo/
 ```
 
 ### Emit Targets
@@ -219,7 +264,7 @@ GEMINI_API_KEY=... hebbian evolve [--dry-run]
 
 | Feature | .cursorrules / CLAUDE.md | Mem0 / MemOS | hebbian |
 |---------|--------------------------|-------------|------|
-| Self-learning | ❌ manual | ✅ vector DB | ✅ filesystem |
+| Self-learning | ❌ manual | ✅ vector DB | ✅ filesystem + tool failures |
 | Infrastructure | $0 | $$$ | **$0** |
 | Switch AI | Manual migration | Full re-setup | **`cp -r brain/`** |
 | Immutable guardrails | None | None | **brainstem + bomb** |

package/dist/bin/hebbian.js

@@ -10,6 +10,34 @@ var __export = (target, all) => {
 };
 
 // src/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  AGENTS_DIR: () => AGENTS_DIR,
+  DECAY_DAYS: () => DECAY_DAYS,
+  DIGEST_LOG_DIR: () => DIGEST_LOG_DIR,
+  EMIT_TARGETS: () => EMIT_TARGETS,
+  EMIT_THRESHOLD: () => EMIT_THRESHOLD,
+  HOOK_MARKER: () => HOOK_MARKER,
+  JACCARD_THRESHOLD: () => JACCARD_THRESHOLD,
+  MARKER_END: () => MARKER_END,
+  MARKER_START: () => MARKER_START,
+  MAX_CORRECTIONS_PER_SESSION: () => MAX_CORRECTIONS_PER_SESSION,
+  MAX_DEPTH: () => MAX_DEPTH,
+  MIN_CORRECTION_LENGTH: () => MIN_CORRECTION_LENGTH,
+  OUTCOME_TYPES: () => OUTCOME_TYPES,
+  PROTECTED_REGIONS_CONTRA: () => PROTECTED_REGIONS_CONTRA,
+  REGIONS: () => REGIONS,
+  REGION_ICONS: () => REGION_ICONS,
+  REGION_KO: () => REGION_KO,
+  REGION_PRIORITY: () => REGION_PRIORITY,
+  SESSION_STATE_DIR: () => SESSION_STATE_DIR,
+  SHARED_DIR: () => SHARED_DIR,
+  SIGNAL_TYPES: () => SIGNAL_TYPES,
+  SPOTLIGHT_DAYS: () => SPOTLIGHT_DAYS,
+  resolveAgentBrain: () => resolveAgentBrain,
+  resolveBrainRoot: () => resolveBrainRoot,
+  resolveSharedBrain: () => resolveSharedBrain
+});
 import { resolve } from "path";
 import { existsSync } from "fs";
 function resolveBrainRoot(brainFlag) {
@@ -18,7 +46,13 @@ function resolveBrainRoot(brainFlag) {
   if (existsSync(resolve("./brain"))) return resolve("./brain");
   return resolve(process.env.HOME || "~", "hebbian", "brain");
 }
-var REGIONS, REGION_PRIORITY, REGION_ICONS, REGION_KO, EMIT_THRESHOLD, SPOTLIGHT_DAYS, JACCARD_THRESHOLD, MAX_DEPTH, EMIT_TARGETS, SIGNAL_TYPES, MARKER_START, MARKER_END, HOOK_MARKER, MAX_CORRECTIONS_PER_SESSION, MIN_CORRECTION_LENGTH, DIGEST_LOG_DIR, SESSION_STATE_DIR, PROTECTED_REGIONS_CONTRA;
+function resolveAgentBrain(brainRoot, agentName) {
+  return resolve(brainRoot, "agents", agentName);
+}
+function resolveSharedBrain(brainRoot) {
+  return resolve(brainRoot, "shared");
+}
+var REGIONS, REGION_PRIORITY, REGION_ICONS, REGION_KO, EMIT_THRESHOLD, SPOTLIGHT_DAYS, JACCARD_THRESHOLD, DECAY_DAYS, MAX_DEPTH, EMIT_TARGETS, SIGNAL_TYPES, MARKER_START, MARKER_END, HOOK_MARKER, MAX_CORRECTIONS_PER_SESSION, MIN_CORRECTION_LENGTH, DIGEST_LOG_DIR, OUTCOME_TYPES, SESSION_STATE_DIR, PROTECTED_REGIONS_CONTRA, AGENTS_DIR, SHARED_DIR;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
@@ -61,6 +95,7 @@ var init_constants = __esm({
     EMIT_THRESHOLD = 5;
     SPOTLIGHT_DAYS = 7;
     JACCARD_THRESHOLD = 0.6;
+    DECAY_DAYS = 30;
     MAX_DEPTH = 6;
     EMIT_TARGETS = {
       gemini: ".gemini/GEMINI.md",
@@ -76,8 +111,11 @@ var init_constants = __esm({
     MAX_CORRECTIONS_PER_SESSION = 10;
     MIN_CORRECTION_LENGTH = 15;
     DIGEST_LOG_DIR = "hippocampus/digest_log";
+    OUTCOME_TYPES = ["revert", "acceptance"];
     SESSION_STATE_DIR = "hippocampus/session_state";
     PROTECTED_REGIONS_CONTRA = ["brainstem", "limbic", "sensors"];
+    AGENTS_DIR = "agents";
+    SHARED_DIR = "shared";
   }
 });
 
@@ -86,8 +124,8 @@ var init_exports = {};
 __export(init_exports, {
   initBrain: () => initBrain
 });
-import { mkdirSync, writeFileSync, existsSync as existsSync2, readdirSync } from "fs";
-import { join } from "path";
+import { mkdirSync, writeFileSync, readFileSync, existsSync as existsSync2, readdirSync, appendFileSync } from "fs";
+import { join, dirname } from "path";
 function initBrain(brainPath) {
   if (existsSync2(brainPath)) {
     const entries = readdirSync(brainPath);
@@ -118,6 +156,7 @@ ${template.description}
     }
   }
   mkdirSync(join(brainPath, "_agents", "global_inbox"), { recursive: true });
+  autoGitignore(brainPath);
   console.log(`\u{1F9E0} Brain initialized at ${brainPath}`);
   console.log(`   7 regions created: ${REGIONS.join(", ")}`);
   console.log("");
@@ -125,6 +164,30 @@ ${template.description}
   console.log(`   hebbian grow brainstem/NO_your_rule --brain ${brainPath}`);
   console.log(`   hebbian emit claude --brain ${brainPath}`);
 }
+function autoGitignore(brainPath) {
+  let dir = dirname(brainPath);
+  for (let i = 0; i < 10; i++) {
+    if (existsSync2(join(dir, ".git"))) {
+      const gitignorePath = join(dir, ".gitignore");
+      const brainDirName = brainPath.replace(dir + "/", "") + "/";
+      if (existsSync2(gitignorePath)) {
+        const content = readFileSync(gitignorePath, "utf8");
+        if (content.includes(brainDirName) || content.includes(brainDirName.replace(/\/$/, ""))) {
+          return;
+        }
+      }
+      appendFileSync(gitignorePath, `
+# hebbian brain (personal learning data)
+${brainDirName}
+`, "utf8");
+      console.log(`   \u{1F4DD} Added ${brainDirName} to .gitignore`);
+      return;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+}
 var REGION_TEMPLATES;
 var init_init = __esm({
   "src/init.ts"() {
@@ -168,7 +231,7 @@ var scanner_exports = {};
 __export(scanner_exports, {
   scanBrain: () => scanBrain
 });
-import { readdirSync as readdirSync2, statSync, readFileSync, existsSync as existsSync3 } from "fs";
+import { readdirSync as readdirSync2, statSync, readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
 import { join as join2, relative, sep } from "path";
 function scanBrain(brainRoot) {
   const regions = [];
@@ -295,7 +358,7 @@ function readAxons(regionPath) {
   const axonPath = join2(regionPath, ".axon");
   if (!existsSync3(axonPath)) return [];
   try {
-    const content = readFileSync(axonPath, "utf8").trim();
+    const content = readFileSync2(axonPath, "utf8").trim();
     return content.split(/[\n,]+/).map((s) => s.trim()).filter(Boolean);
   } catch {
     return [];
@@ -366,8 +429,8 @@ __export(emit_exports, {
   printDiag: () => printDiag,
   writeAllTiers: () => writeAllTiers
 });
-import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join3, dirname } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
 function emitBootstrap(result, brain) {
   const lines = [];
   const now = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+Z$/, "");
@@ -543,12 +606,12 @@ function writeAllTiers(brainRoot, result, brain) {
   }
 }
 function writeTarget(filePath, content) {
-  const dir = dirname(filePath);
+  const dir = dirname2(filePath);
   if (dir !== "." && !existsSync4(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
   if (existsSync4(filePath)) {
-    const existing = readFileSync2(filePath, "utf8");
+    const existing = readFileSync3(filePath, "utf8");
     const startIdx = existing.indexOf(MARKER_START);
     const endIdx = existing.indexOf(MARKER_END);
     if (startIdx !== -1 && endIdx !== -1) {
@@ -618,7 +681,7 @@ __export(update_check_exports, {
   checkForUpdates: () => checkForUpdates,
   formatUpdateBanner: () => formatUpdateBanner
 });
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, statSync as statSync2, unlinkSync } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3, statSync as statSync2, unlinkSync } from "fs";
 import { join as join4 } from "path";
 function getStateDir() {
   return join4(process.env.HOME || "~", ".hebbian");
@@ -642,7 +705,7 @@ function readCache(stateDir) {
   const cachePath = join4(stateDir, "last-update-check");
   if (!existsSync5(cachePath)) return null;
   try {
-    const line = readFileSync3(cachePath, "utf8").trim();
+    const line = readFileSync4(cachePath, "utf8").trim();
     if (line.startsWith("UP_TO_DATE")) {
       if (isCacheStale(cachePath, "UP_TO_DATE")) return null;
       const ver = line.split(/\s+/)[1];
@@ -666,7 +729,7 @@ function isSnoozed(stateDir, remoteVersion) {
   const snoozePath = join4(stateDir, "update-snoozed");
   if (!existsSync5(snoozePath)) return false;
   try {
-    const [ver, levelStr, epochStr] = readFileSync3(snoozePath, "utf8").trim().split(/\s+/);
+    const [ver, levelStr, epochStr] = readFileSync4(snoozePath, "utf8").trim().split(/\s+/);
     if (ver !== remoteVersion) {
       unlinkSync(snoozePath);
       return false;
@@ -1263,7 +1326,7 @@ __export(candidates_exports, {
   toCandidatePath: () => toCandidatePath
 });
 import { existsSync as existsSync11, mkdirSync as mkdirSync6, readdirSync as readdirSync7, renameSync as renameSync3, rmSync, statSync as statSync4 } from "fs";
-import { join as join12, dirname as dirname2, relative as relative3 } from "path";
+import { join as join12, dirname as dirname3, relative as relative3 } from "path";
 function toCandidatePath(neuronPath) {
   const slash = neuronPath.indexOf("/");
   if (slash === -1) throw new Error(`Invalid neuron path (missing region): ${neuronPath}`);
@@ -1290,7 +1353,7 @@ function moveCandidate(brainRoot, candidatePath, targetPath) {
     fireNeuron(brainRoot, targetPath);
     rmSync(src, { recursive: true, force: true });
   } else {
-    mkdirSync6(dirname2(dst), { recursive: true });
+    mkdirSync6(dirname3(dst), { recursive: true });
     renameSync3(src, dst);
   }
   console.log(`\u{1F393} promoted: ${candidatePath} \u2192 ${targetPath}`);
@@ -1383,7 +1446,7 @@ __export(episode_exports, {
   logEpisode: () => logEpisode,
   readEpisodes: () => readEpisodes
 });
-import { readdirSync as readdirSync8, readFileSync as readFileSync4, writeFileSync as writeFileSync9, mkdirSync as mkdirSync7, existsSync as existsSync12 } from "fs";
+import { readdirSync as readdirSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync9, mkdirSync as mkdirSync7, existsSync as existsSync12 } from "fs";
 import { join as join13 } from "path";
 function logEpisode(brainRoot, type, path, detail, extra) {
   const logDir = join13(brainRoot, SESSION_LOG_DIR);
@@ -1418,7 +1481,7 @@ function readEpisodes(brainRoot) {
   for (const entry of entries) {
     if (!entry.startsWith("memory") || !entry.endsWith(".neuron")) continue;
     try {
-      const content = readFileSync4(join13(logDir, entry), "utf8");
+      const content = readFileSync5(join13(logDir, entry), "utf8");
       if (content.trim()) {
         episodes.push(JSON.parse(content));
       }
@@ -1458,14 +1521,14 @@ __export(inbox_exports, {
   ensureInbox: () => ensureInbox,
   processInbox: () => processInbox
 });
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync10, existsSync as existsSync13, mkdirSync as mkdirSync8 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync10, existsSync as existsSync13, mkdirSync as mkdirSync8 } from "fs";
 import { join as join14 } from "path";
 function processInbox(brainRoot) {
   const inboxPath = join14(brainRoot, INBOX_DIR, CORRECTIONS_FILE);
   if (!existsSync13(inboxPath)) {
     return { processed: 0, skipped: 0, errors: [] };
   }
-  const content = readFileSync5(inboxPath, "utf8").trim();
+  const content = readFileSync6(inboxPath, "utf8").trim();
   if (!content) {
     return { processed: 0, skipped: 0, errors: [] };
   }
@@ -1560,7 +1623,7 @@ function ensureInbox(brainRoot) {
 function appendCorrection(brainRoot, correction) {
   const filePath = ensureInbox(brainRoot);
   const line = JSON.stringify(correction) + "\n";
-  const existing = readFileSync5(filePath, "utf8");
+  const existing = readFileSync6(filePath, "utf8");
   writeFileSync10(filePath, existing + line, "utf8");
 }
 var INBOX_DIR, CORRECTIONS_FILE, DOPAMINE_ALLOWED_ROLES;
@@ -1875,7 +1938,7 @@ __export(hooks_exports, {
   installHooks: () => installHooks,
   uninstallHooks: () => uninstallHooks
 });
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync11, existsSync as existsSync14, mkdirSync as mkdirSync9, readdirSync as readdirSync9 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync11, existsSync as existsSync14, mkdirSync as mkdirSync9, readdirSync as readdirSync9 } from "fs";
 import { execSync as execSync2 } from "child_process";
 import { join as join15, resolve as resolve2 } from "path";
 function installHooks(brainRoot, projectRoot, global) {
@@ -1904,7 +1967,7 @@ function installHooks(brainRoot, projectRoot, global) {
   let settings = {};
   if (existsSync14(settingsPath)) {
     try {
-      settings = JSON.parse(readFileSync6(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync7(settingsPath, "utf8"));
     } catch {
       console.log(`\u26A0\uFE0F  settings.local.json was malformed, overwriting`);
     }
@@ -1970,7 +2033,7 @@ function uninstallHooks(projectRoot, global) {
   }
   let settings;
   try {
-    settings = JSON.parse(readFileSync6(settingsPath, "utf8"));
+    settings = JSON.parse(readFileSync7(settingsPath, "utf8"));
   } catch {
     console.log("settings.local.json is malformed, nothing to uninstall");
     return;
@@ -2013,7 +2076,7 @@ function checkHooks(projectRoot, global) {
   }
   let settings;
   try {
-    settings = JSON.parse(readFileSync6(settingsPath, "utf8"));
+    settings = JSON.parse(readFileSync7(settingsPath, "utf8"));
   } catch {
     console.log(`\u274C settings.local.json is malformed`);
     return status;
@@ -2065,13 +2128,14 @@ var init_hooks = __esm({
 // src/digest.ts
 var digest_exports = {};
 __export(digest_exports, {
+  detectRetryPatterns: () => detectRetryPatterns,
   detectToolFailure: () => detectToolFailure,
   digestTranscript: () => digestTranscript,
   extractCorrections: () => extractCorrections,
   parseToolResults: () => parseToolResults,
   readHookInput: () => readHookInput
 });
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync12, existsSync as existsSync15, mkdirSync as mkdirSync10 } from "fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync12, existsSync as existsSync15, mkdirSync as mkdirSync10 } from "fs";
 import { join as join16, basename } from "path";
 function readHookInput(stdin) {
   if (!stdin.trim()) return null;
@@ -2102,8 +2166,13 @@ function digestTranscript(brainRoot, transcriptPath, sessionId) {
   for (const failure of toolFailures) {
     logEpisode(brainRoot, "tool-failure", failure.toolName, failure.errorText);
   }
-  if (toolFailures.length > 0) {
-    console.log(`\u{1F527} digest: ${toolFailures.length} tool failure(s) logged as episodes`);
+  const retries = detectRetryPatterns(toolFailures);
+  for (const retry of retries) {
+    logEpisode(brainRoot, "retry-pattern", retry.toolName, retry.errorText);
+  }
+  const totalSignals = toolFailures.length + retries.length;
+  if (totalSignals > 0) {
+    console.log(`\u{1F527} digest: ${toolFailures.length} tool failure(s), ${retries.length} retry pattern(s) logged`);
   }
   const corrections = extractCorrections(messages);
   if (corrections.length === 0 && toolFailures.length === 0) {
@@ -2139,7 +2208,7 @@ function digestTranscript(brainRoot, transcriptPath, sessionId) {
   };
 }
 function parseTranscript(transcriptPath) {
-  const content = readFileSync7(transcriptPath, "utf8");
+  const content = readFileSync8(transcriptPath, "utf8");
   const lines = content.split("\n").filter(Boolean);
   const messages = [];
   for (const line of lines) {
@@ -2166,7 +2235,7 @@ function extractText(content) {
   return null;
 }
 function parseToolResults(transcriptPath) {
-  const content = readFileSync7(transcriptPath, "utf8");
+  const content = readFileSync8(transcriptPath, "utf8");
   const lines = content.split("\n").filter(Boolean);
   const failures = [];
   for (const line of lines) {
@@ -2188,6 +2257,22 @@ function parseToolResults(transcriptPath) {
   }
   return failures;
 }
+function detectRetryPatterns(failures) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const f of failures) {
+    const key = f.toolName.toLowerCase().trim();
+    const existing = counts.get(key);
+    if (existing) {
+      existing.count++;
+    } else {
+      counts.set(key, { failure: f, count: 1 });
+    }
+  }
+  return [...counts.values()].filter((entry) => entry.count >= 3).map((entry) => ({
+    ...entry.failure,
+    toolName: `[retry x${entry.count}] ${entry.failure.toolName}`
+  }));
+}
 function detectToolFailure(block, toolUseResult) {
   if (!block.is_error) return null;
   let errorText = "";
@@ -2457,7 +2542,7 @@ __export(outcome_exports, {
   detectOutcome: () => detectOutcome
 });
 import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync16, mkdirSync as mkdirSync11, writeFileSync as writeFileSync13, readFileSync as readFileSync8, readdirSync as readdirSync10, rmSync as rmSync2, statSync as statSync5 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync11, writeFileSync as writeFileSync13, readFileSync as readFileSync9, readdirSync as readdirSync10, rmSync as rmSync2, statSync as statSync5 } from "fs";
 import { join as join17 } from "path";
 import { randomUUID } from "crypto";
 function captureSessionStart(brainRoot) {
@@ -2656,7 +2741,7 @@ function readLatestSessionState(brainRoot) {
   }
   if (!latest) return null;
   try {
-    return JSON.parse(readFileSync8(latest.path, "utf8"));
+    return JSON.parse(readFileSync9(latest.path, "utf8"));
   } catch {
     return null;
   }
@@ -2697,9 +2782,9 @@ __export(evolve_exports, {
   runEvolve: () => runEvolve,
   validateActions: () => validateActions
 });
-import { existsSync as existsSync17, readFileSync as readFileSync9, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync10, writeFileSync as writeFileSync14 } from "fs";
 import { join as join18 } from "path";
-async function runEvolve(brainRoot, dryRun) {
+async function runEvolve(brainRoot, dryRun, mode = "default") {
   const apiKey = process.env.GEMINI_API_KEY;
   if (!apiKey) {
     console.error("\u274C GEMINI_API_KEY not set. Get one at https://aistudio.google.com/apikey");
@@ -2709,7 +2794,7 @@ async function runEvolve(brainRoot, dryRun) {
     const cooldownMs = (parseInt(process.env.EVOLVE_COOLDOWN_SECONDS ?? "60", 10) || 60) * 1e3;
     const cooldownPath = join18(brainRoot, EVOLVE_COOLDOWN_FILE);
     if (existsSync17(cooldownPath)) {
-      const lastRun = parseInt(readFileSync9(cooldownPath, "utf8").trim(), 10);
+      const lastRun = parseInt(readFileSync10(cooldownPath, "utf8").trim(), 10);
       const elapsed = Date.now() - lastRun;
       if (elapsed < cooldownMs) {
         const remaining = Math.ceil((cooldownMs - elapsed) / 1e3);
@@ -2722,7 +2807,7 @@ async function runEvolve(brainRoot, dryRun) {
   const brain = scanBrain(brainRoot);
   const summary = buildBrainSummary(brain);
   const outcomeSummary = buildOutcomeSummary(brainRoot);
-  const prompt = buildPrompt(summary, episodes, outcomeSummary);
+  const prompt = mode === "prune" ? buildPrunePrompt(summary, episodes) : buildPrompt(summary, episodes, outcomeSummary);
   let rawActions;
   try {
     rawActions = await callGemini(prompt, apiKey);
@@ -2813,6 +2898,44 @@ Focus on: strengthening repeatedly-used rules, pruning ineffective ones, growing
 Respond with a JSON array of actions:
 [{"type":"fire","path":"cortex/NO_console_log","reason":"fired 3 times in recent sessions"}]`;
 }
+function buildPrunePrompt(summary, episodes) {
+  const episodeLines = episodes.length > 0 ? episodes.map((e) => `- [${e.ts}] ${e.type}: ${sanitizeForPrompt(e.detail)}`).join("\n") : "(no recent episodes)";
+  return `You are the PRUNING engine for a hebbian brain \u2014 a filesystem-based memory system for AI agents.
+
+Your job is CLEANUP. Remove what's stale, redundant, or harmful. Healthy forgetting.
+
+## Axioms
+- Folder = Neuron, File = Firing Trace, Counter = Activation strength
+- 7 regions: brainstem(P0) > limbic(P1) > hippocampus(P2) > sensors(P3) > cortex(P4) > ego(P5) > prefrontal(P6)
+- PROTECTED regions (brainstem, limbic, sensors): NEVER touch these
+
+## Current Brain
+${summary}
+
+## Recent Episodes (last ${episodes.length})
+${episodeLines}
+
+## Pruning Criteria
+1. **Stale neurons** \u2014 counter is low AND no recent episodes mention them. They occupy space but provide no value.
+2. **High contra ratio** \u2014 neurons present in many reverted sessions (contra_ratio > 0.7). They correlate with bad outcomes.
+3. **Redundant neurons** \u2014 two neurons in the same region with very similar names/meaning. Keep the stronger one, prune the weaker.
+4. **Contradicted neurons** \u2014 a newer neuron explicitly overrides an older one. Remove the older.
+
+## Available Actions (pruning-focused)
+- prune: Decrement a neuron's counter. Use for rules that aren't working.
+- decay: Mark inactive neurons as dormant. Use for stale rules with no recent activity.
+- signal: Add bomb signal to block a problematic neuron. Use for neurons that actively cause harm.
+
+Do NOT use grow or fire \u2014 this is a pruning pass, not a growth pass.
+
+## Constraints
+- Max ${MAX_ACTIONS} actions per cycle
+- NEVER target brainstem, limbic, or sensors regions
+- Be conservative \u2014 only prune what you're confident about
+
+Respond with a JSON array of actions:
+[{"type":"prune","path":"cortex/WARN_old_rule","reason":"not fired in 30+ days, no recent episodes"}]`;
+}
 async function callGemini(prompt, apiKey) {
   const model = process.env.EVOLVE_MODEL || DEFAULT_MODEL;
   const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`;
@@ -2977,7 +3100,7 @@ var doctor_exports = {};
 __export(doctor_exports, {
   runDoctor: () => runDoctor
 });
-import { existsSync as existsSync18, readFileSync as readFileSync10, readdirSync as readdirSync11 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync11, readdirSync as readdirSync11 } from "fs";
 import { join as join19 } from "path";
 import { execSync as execSync4 } from "child_process";
 async function runDoctor(brainRoot) {
@@ -3008,7 +3131,7 @@ async function runDoctor(brainRoot) {
   console.log("\nnpm package");
   try {
     const pkgPath = new URL("../package.json", import.meta.url).pathname;
-    const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync11(pkgPath, "utf8"));
     const local = pkg.version || "unknown";
     let remote = "";
     try {
@@ -3044,7 +3167,7 @@ async function runDoctor(brainRoot) {
     warn("No .claude/settings.local.json found", "hebbian claude install");
   } else {
     try {
-      const settings = JSON.parse(readFileSync10(settingsPath, "utf8"));
+      const settings = JSON.parse(readFileSync11(settingsPath, "utf8"));
       const hooks = settings.hooks || {};
       const hasStop = Object.entries(hooks).some(
         ([event, entries]) => event === "Stop" && Array.isArray(entries) && entries.some(
@@ -3116,7 +3239,7 @@ var init_doctor = __esm({
 init_constants();
 import { parseArgs } from "util";
 import { resolve as resolve3 } from "path";
-var VERSION = "0.6.0";
+var VERSION = "0.7.1";
 var HELP = `
 hebbian v${VERSION} \u2014 Folder-as-neuron brain for any AI agent.
 
@@ -3142,6 +3265,7 @@ COMMANDS:
   digest [--transcript <path>]    Extract corrections from conversation
   candidates [promote]            List candidates or promote graduated ones
   evolve [--dry-run]              LLM-powered brain evolution (Gemini)
+  evolve prune [--dry-run]        Pruning mode \u2014 remove stale/redundant neurons
   session start|end               Capture/detect session outcomes
   sessions                        Show session outcome history
   doctor                          Self-diagnostic (hooks, brain, versions)
@@ -3187,6 +3311,7 @@ async function main(argv) {
       transcript: { type: "string", short: "t" },
       "dry-run": { type: "boolean" },
       global: { type: "boolean", short: "g" },
+      agent: { type: "string", short: "a" },
       help: { type: "boolean", short: "h" },
       version: { type: "boolean", short: "v" }
     },
@@ -3202,7 +3327,12 @@ async function main(argv) {
     console.log(HELP);
     return;
   }
-  const brainRoot = resolveBrainRoot(values.brain);
+  let brainRoot = resolveBrainRoot(values.brain);
+  const agentName = values.agent;
+  if (agentName) {
+    const { resolveAgentBrain: resolveAgentBrain2 } = await Promise.resolve().then(() => (init_constants(), constants_exports));
+    brainRoot = resolveAgentBrain2(brainRoot, agentName);
+  }
   switch (command) {
     case "init": {
       const target = positionals[1];
@@ -3377,8 +3507,9 @@ async function main(argv) {
     }
     case "evolve": {
       const dryRun = values["dry-run"] === true;
+      const modeArg = positionals[1] === "prune" ? "prune" : "default";
       const { runEvolve: runEvolve2 } = await Promise.resolve().then(() => (init_evolve(), evolve_exports));
-      await runEvolve2(brainRoot, dryRun);
+      await runEvolve2(brainRoot, dryRun, modeArg);
       break;
     }
     case "session": {