hebbian 0.5.3 → 0.7.0

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,11 +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;
@@ -2093,14 +2159,30 @@ function digestTranscript(brainRoot, transcriptPath, sessionId) {
   const logPath = join16(logDir, `${resolvedSessionId}.jsonl`);
   if (existsSync15(logPath)) {
     console.log(`\u23ED already digested session ${resolvedSessionId}, skip`);
-    return { corrections: 0, skipped: 0, transcriptPath, sessionId: resolvedSessionId };
+    return { corrections: 0, skipped: 0, toolFailures: 0, transcriptPath, sessionId: resolvedSessionId };
   }
   const messages = parseTranscript(transcriptPath);
+  const toolFailures = parseToolResults(transcriptPath);
+  for (const failure of toolFailures) {
+    logEpisode(brainRoot, "tool-failure", failure.toolName, failure.errorText);
+  }
+  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) {
+  if (corrections.length === 0 && toolFailures.length === 0) {
     console.log(`\u{1F4DD} digest: no corrections found in session ${resolvedSessionId}`);
     writeAuditLog(brainRoot, resolvedSessionId, []);
-    return { corrections: 0, skipped: messages.length, transcriptPath, sessionId: resolvedSessionId };
+    return { corrections: 0, skipped: messages.length, toolFailures: toolFailures.length, transcriptPath, sessionId: resolvedSessionId };
+  }
+  if (corrections.length === 0) {
+    writeAuditLog(brainRoot, resolvedSessionId, []);
+    return { corrections: 0, skipped: messages.length, toolFailures: toolFailures.length, transcriptPath, sessionId: resolvedSessionId };
   }
   let applied = 0;
   const auditEntries = [];
@@ -2120,12 +2202,13 @@ function digestTranscript(brainRoot, transcriptPath, sessionId) {
   return {
     corrections: applied,
     skipped: messages.length - corrections.length,
+    toolFailures: toolFailures.length,
     transcriptPath,
     sessionId: resolvedSessionId
   };
 }
 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) {
@@ -2151,6 +2234,63 @@ function extractText(content) {
   }
   return null;
 }
+function parseToolResults(transcriptPath) {
+  const content = readFileSync8(transcriptPath, "utf8");
+  const lines = content.split("\n").filter(Boolean);
+  const failures = [];
+  for (const line of lines) {
+    if (failures.length >= MAX_FAILURES_PER_SESSION) break;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry.type !== "user") continue;
+    if (!entry.message || !Array.isArray(entry.message.content)) continue;
+    for (const block of entry.message.content) {
+      if (block.type !== "tool_result") continue;
+      if (!block.is_error) continue;
+      const failure = detectToolFailure(block, entry.toolUseResult);
+      if (failure) failures.push(failure);
+    }
+  }
+  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 = "";
+  if (typeof block.content === "string") {
+    errorText = block.content;
+  } else if (Array.isArray(block.content)) {
+    errorText = block.content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("\n");
+  }
+  if (!errorText && typeof toolUseResult === "string") {
+    errorText = toolUseResult;
+  }
+  if (!errorText) return null;
+  const exitMatch = errorText.match(/^Exit code (\d+)/);
+  const exitCode = exitMatch ? parseInt(exitMatch[1], 10) : 1;
+  const firstLine = errorText.split("\n").find((l) => l.trim() && !l.startsWith("Exit code")) || "unknown";
+  const toolName = firstLine.trim().slice(0, 80);
+  return { toolName, exitCode, errorText: errorText.slice(0, 500) };
+}
 function extractCorrections(messages) {
   const corrections = [];
   for (const text of messages) {
@@ -2343,7 +2483,7 @@ function writeAuditLog(brainRoot, sessionId, entries) {
   );
   writeFileSync12(logPath, lines.join("\n") + (lines.length > 0 ? "\n" : ""), "utf8");
 }
-var NEGATION_PATTERNS, AFFIRMATION_PATTERNS, MUST_PATTERNS, WARN_PATTERNS;
+var NEGATION_PATTERNS, AFFIRMATION_PATTERNS, MUST_PATTERNS, WARN_PATTERNS, MAX_FAILURES_PER_SESSION;
 var init_digest = __esm({
   "src/digest.ts"() {
     "use strict";
@@ -2389,6 +2529,7 @@ var init_digest = __esm({
       // Korean
       /주의/
     ];
+    MAX_FAILURES_PER_SESSION = 20;
   }
 });
 
@@ -2401,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) {
@@ -2600,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;
   }
@@ -2641,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");
@@ -2653,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);
@@ -2666,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);
@@ -2757,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`;
@@ -2921,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) {
@@ -2952,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 {
@@ -2988,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(
@@ -3060,7 +3239,7 @@ var init_doctor = __esm({
 init_constants();
 import { parseArgs } from "util";
 import { resolve as resolve3 } from "path";
-var VERSION = "0.5.3";
+var VERSION = "0.7.0";
 var HELP = `
 hebbian v${VERSION} \u2014 Folder-as-neuron brain for any AI agent.
 
@@ -3086,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)
@@ -3131,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" }
     },
@@ -3146,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];
@@ -3321,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": {