hebbian 0.3.3 → 0.5.0

package/dist/index.js

@@ -56,6 +56,9 @@ var HOOK_MARKER = "[hebbian]";
 var MAX_CORRECTIONS_PER_SESSION = 10;
 var MIN_CORRECTION_LENGTH = 15;
 var DIGEST_LOG_DIR = "hippocampus/digest_log";
+var OUTCOME_TYPES = ["revert", "acceptance"];
+var SESSION_STATE_DIR = "hippocampus/session_state";
+var PROTECTED_REGIONS_CONTRA = ["brainstem", "limbic", "sensors"];
 function resolveBrainRoot(brainFlag) {
   if (brainFlag) return resolve(brainFlag);
   if (process.env.HEBBIAN_BRAIN) return resolve(process.env.HEBBIAN_BRAIN);
@@ -284,6 +287,33 @@ function fireNeuron(brainRoot, neuronPath) {
   console.log(`\u{1F525} fired: ${neuronPath} (${current} \u2192 ${newCounter})`);
   return newCounter;
 }
+function contraNeuron(brainRoot, neuronPath) {
+  const fullPath = join2(brainRoot, neuronPath);
+  if (!existsSync3(fullPath)) {
+    return 0;
+  }
+  const current = getCurrentContra(fullPath);
+  const newContra = current + 1;
+  if (current > 0) {
+    renameSync(join2(fullPath, `${current}.contra`), join2(fullPath, `${newContra}.contra`));
+  } else {
+    writeFileSync(join2(fullPath, `${newContra}.contra`), "", "utf8");
+  }
+  return newContra;
+}
+function getCurrentContra(dir) {
+  let max = 0;
+  try {
+    for (const entry of readdirSync2(dir)) {
+      if (entry.endsWith(".contra")) {
+        const n = parseInt(entry, 10);
+        if (!isNaN(n) && n > max) max = n;
+      }
+    }
+  } catch {
+  }
+  return max;
+}
 function getCurrentCounter(dir) {
   let max = 0;
   try {
@@ -619,7 +649,7 @@ function emitBootstrap(result, brain) {
   lines.push("|--------|---------|------------|");
   for (const region of result.activeRegions) {
     const active = region.neurons.filter((n) => !n.isDormant);
-    const activation = active.reduce((sum, n) => sum + n.counter, 0);
+    const activation = active.reduce((sum, n) => sum + n.intensity, 0);
     const icon = REGION_ICONS[region.name] || "";
     lines.push(`| ${icon} ${region.name} | ${active.length} | ${activation} |`);
   }
@@ -641,7 +671,7 @@ function emitIndex(result, brain) {
   const allNeurons = result.activeRegions.flatMap(
     (r) => r.neurons.filter((n) => !n.isDormant && n.counter >= EMIT_THRESHOLD)
   );
-  allNeurons.sort((a, b) => b.counter - a.counter);
+  allNeurons.sort((a, b) => b.intensity - a.intensity);
   lines.push("## Top 10 Active Neurons");
   lines.push("| # | Path | Counter | Strength |");
   lines.push("|---|------|---------|----------|");
@@ -667,7 +697,7 @@ function emitIndex(result, brain) {
   for (const region of result.activeRegions) {
     const active = region.neurons.filter((n) => !n.isDormant);
     const dormant = region.neurons.filter((n) => n.isDormant);
-    const activation = active.reduce((sum, n) => sum + n.counter, 0);
+    const activation = active.reduce((sum, n) => sum + n.intensity, 0);
     const icon = REGION_ICONS[region.name] || "";
     lines.push(`| ${icon} ${region.name} | ${active.length} | ${dormant.length} | ${activation} | [_rules.md](${region.name}/_rules.md) |`);
   }
@@ -679,7 +709,7 @@ function emitRegionRules(region) {
   const ko = REGION_KO[region.name] || "";
   const active = region.neurons.filter((n) => !n.isDormant);
   const dormant = region.neurons.filter((n) => n.isDormant);
-  const activation = active.reduce((sum, n) => sum + n.counter, 0);
+  const activation = active.reduce((sum, n) => sum + n.intensity, 0);
   const lines = [];
   lines.push(`# ${icon} ${region.name} (${ko})`);
   lines.push(`> Active: ${active.length} | Dormant: ${dormant.length} | Activation: ${activation}`);
@@ -693,7 +723,7 @@ function emitRegionRules(region) {
   }
   if (active.length > 0) {
     lines.push("## Rules");
-    const sorted = [...active].sort((a, b) => b.counter - a.counter);
+    const sorted = [...active].sort((a, b) => b.intensity - a.intensity);
     for (const n of sorted) {
       const indent = "  ".repeat(Math.min(n.depth, 4));
       const prefix = strengthPrefix(n.counter);
@@ -776,7 +806,7 @@ function printDiag(brain, result) {
     const icon = REGION_ICONS[region.name] || "";
     const active = region.neurons.filter((n) => !n.isDormant);
     const dormant = region.neurons.filter((n) => n.isDormant);
-    const activation = active.reduce((sum, n) => sum + n.counter, 0);
+    const activation = active.reduce((sum, n) => sum + n.intensity, 0);
     const isBlocked = result.blockedRegions.some((r) => r.name === region.name);
     const status = region.hasBomb ? "\u{1F4A3} BOMB" : isBlocked ? "\u{1F6AB} BLOCKED" : "\u2705 ACTIVE";
     console.log(`   ${icon} ${region.name} [${status}]`);
@@ -786,7 +816,8 @@ function printDiag(brain, result) {
     }
     const top3 = sortedActive(region.neurons, 3);
     for (const n of top3) {
-      console.log(`      \u251C ${n.path} (${n.counter})`);
+      const contraStr = n.contra > 0 ? ` contra:${n.contra}` : "";
+      console.log(`      \u251C ${n.path} (counter:${n.counter}${contraStr} intensity:${n.intensity})`);
     }
   }
   console.log("");
@@ -795,7 +826,7 @@ function pathToSentence(path) {
   return path.replace(/\//g, " > ").replace(/_/g, " ");
 }
 function sortedActive(neurons, n) {
-  return [...neurons].filter((neuron) => !neuron.isDormant).sort((a, b) => b.counter - a.counter).slice(0, n);
+  return [...neurons].filter((neuron) => !neuron.isDormant).sort((a, b) => b.intensity - a.intensity).slice(0, n);
 }
 function strengthPrefix(counter) {
   if (counter >= 10) return "**[ABSOLUTE]** ";
@@ -922,46 +953,155 @@ ${template.description}
 import { createServer } from "http";
 
 // src/inbox.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync9, existsSync as existsSync11, mkdirSync as mkdirSync6 } from "fs";
-import { join as join12 } from "path";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync9, existsSync as existsSync12, mkdirSync as mkdirSync7 } from "fs";
+import { join as join13 } from "path";
+
+// src/candidates.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, readdirSync as readdirSync7, renameSync as renameSync3, rmSync, statSync as statSync3 } from "fs";
+import { join as join11, dirname as dirname2, relative as relative3 } from "path";
+var CANDIDATE_THRESHOLD = 3;
+var CANDIDATE_DECAY_DAYS = 14;
+var CANDIDATE_SEGMENT = "_candidates";
+function toCandidatePath(neuronPath) {
+  const slash = neuronPath.indexOf("/");
+  if (slash === -1) throw new Error(`Invalid neuron path (missing region): ${neuronPath}`);
+  return `${neuronPath.slice(0, slash)}/${CANDIDATE_SEGMENT}/${neuronPath.slice(slash + 1)}`;
+}
+function fromCandidatePath(candidatePath) {
+  return candidatePath.replace(`/${CANDIDATE_SEGMENT}/`, "/");
+}
+function growCandidate(brainRoot, neuronPath) {
+  const candidatePath = toCandidatePath(neuronPath);
+  const result = growNeuron(brainRoot, candidatePath);
+  if (result.counter >= CANDIDATE_THRESHOLD) {
+    const ok = moveCandidate(brainRoot, candidatePath, neuronPath);
+    return { ...result, path: ok ? neuronPath : result.path, promoted: ok };
+  }
+  console.log(`   \u{1F331} candidate (${result.counter}/${CANDIDATE_THRESHOLD}): ${candidatePath}`);
+  return { ...result, promoted: false };
+}
+function moveCandidate(brainRoot, candidatePath, targetPath) {
+  const src = join11(brainRoot, candidatePath);
+  if (!existsSync10(src)) return false;
+  const dst = join11(brainRoot, targetPath);
+  if (existsSync10(dst)) {
+    fireNeuron(brainRoot, targetPath);
+    rmSync(src, { recursive: true, force: true });
+  } else {
+    mkdirSync5(dirname2(dst), { recursive: true });
+    renameSync3(src, dst);
+  }
+  console.log(`\u{1F393} promoted: ${candidatePath} \u2192 ${targetPath}`);
+  return true;
+}
+function promoteCandidates(brainRoot) {
+  const promoted = [];
+  const decayed = [];
+  const decayMs = CANDIDATE_DECAY_DAYS * 24 * 60 * 60 * 1e3;
+  const now = Date.now();
+  for (const region of REGIONS) {
+    const candidateRoot = join11(brainRoot, region, CANDIDATE_SEGMENT);
+    walkNeuronDirs(candidateRoot, (neuronDir) => {
+      const rel = relative3(join11(brainRoot, region), neuronDir);
+      const candidatePath = `${region}/${rel}`;
+      const targetPath = fromCandidatePath(candidatePath);
+      const counter = readCounter(neuronDir);
+      const mtime = statSync3(neuronDir).mtimeMs;
+      if (counter >= CANDIDATE_THRESHOLD) {
+        moveCandidate(brainRoot, candidatePath, targetPath);
+        promoted.push(targetPath);
+      } else if (now - mtime > decayMs) {
+        rmSync(neuronDir, { recursive: true, force: true });
+        decayed.push(candidatePath);
+        console.log(`\u{1F480} candidate decayed: ${candidatePath}`);
+      }
+    });
+  }
+  return { promoted, decayed };
+}
+function listCandidates(brainRoot) {
+  const results = [];
+  const now = Date.now();
+  for (const region of REGIONS) {
+    const candidateRoot = join11(brainRoot, region, CANDIDATE_SEGMENT);
+    walkNeuronDirs(candidateRoot, (neuronDir) => {
+      const rel = relative3(join11(brainRoot, region), neuronDir);
+      const candidatePath = `${region}/${rel}`;
+      const targetPath = fromCandidatePath(candidatePath);
+      const counter = readCounter(neuronDir);
+      const mtime = statSync3(neuronDir).mtimeMs;
+      const daysInactive = Math.floor((now - mtime) / (24 * 60 * 60 * 1e3));
+      results.push({ candidatePath, targetPath, counter, daysInactive });
+    });
+  }
+  return results;
+}
+function walkNeuronDirs(dir, cb) {
+  if (!existsSync10(dir)) return;
+  try {
+    const entries = readdirSync7(dir, { withFileTypes: true });
+    const hasNeuron = entries.some((e) => e.isFile() && e.name.endsWith(".neuron"));
+    if (hasNeuron) {
+      cb(dir);
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".")) {
+        walkNeuronDirs(join11(dir, entry.name), cb);
+      }
+    }
+  } catch {
+  }
+}
+function readCounter(dir) {
+  try {
+    const files = readdirSync7(dir).filter((f) => /^\d+\.neuron$/.test(f));
+    if (files.length === 0) return 0;
+    return Math.max(...files.map((f) => parseInt(f, 10)));
+  } catch {
+    return 0;
+  }
+}
 
 // src/episode.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync3, writeFileSync as writeFileSync8, mkdirSync as mkdirSync5, existsSync as existsSync10 } from "fs";
-import { join as join11 } from "path";
+import { readdirSync as readdirSync8, readFileSync as readFileSync3, writeFileSync as writeFileSync8, mkdirSync as mkdirSync6, existsSync as existsSync11 } from "fs";
+import { join as join12 } from "path";
 var MAX_EPISODES = 100;
 var SESSION_LOG_DIR = "hippocampus/session_log";
-function logEpisode(brainRoot, type, path, detail) {
-  const logDir = join11(brainRoot, SESSION_LOG_DIR);
-  if (!existsSync10(logDir)) {
-    mkdirSync5(logDir, { recursive: true });
+function logEpisode(brainRoot, type, path, detail, extra) {
+  const logDir = join12(brainRoot, SESSION_LOG_DIR);
+  if (!existsSync11(logDir)) {
+    mkdirSync6(logDir, { recursive: true });
   }
   const nextSlot = getNextSlot(logDir);
   const episode = {
     ts: (/* @__PURE__ */ new Date()).toISOString(),
     type,
     path,
-    detail
+    detail,
+    ...extra?.outcome ? { outcome: extra.outcome } : {},
+    ...extra?.neurons ? { neurons: extra.neurons } : {}
   };
   writeFileSync8(
-    join11(logDir, `memory${nextSlot}.neuron`),
+    join12(logDir, `memory${nextSlot}.neuron`),
     JSON.stringify(episode),
     "utf8"
   );
 }
 function readEpisodes(brainRoot) {
-  const logDir = join11(brainRoot, SESSION_LOG_DIR);
-  if (!existsSync10(logDir)) return [];
+  const logDir = join12(brainRoot, SESSION_LOG_DIR);
+  if (!existsSync11(logDir)) return [];
   const episodes = [];
   let entries;
   try {
-    entries = readdirSync7(logDir);
+    entries = readdirSync8(logDir);
   } catch {
     return [];
   }
   for (const entry of entries) {
     if (!entry.startsWith("memory") || !entry.endsWith(".neuron")) continue;
     try {
-      const content = readFileSync3(join11(logDir, entry), "utf8");
+      const content = readFileSync3(join12(logDir, entry), "utf8");
       if (content.trim()) {
         episodes.push(JSON.parse(content));
       }
@@ -974,7 +1114,7 @@ function readEpisodes(brainRoot) {
 function getNextSlot(logDir) {
   let maxSlot = 0;
   try {
-    for (const entry of readdirSync7(logDir)) {
+    for (const entry of readdirSync8(logDir)) {
       if (entry.startsWith("memory") && entry.endsWith(".neuron")) {
         const n = parseInt(entry.replace("memory", "").replace(".neuron", ""), 10);
         if (!isNaN(n) && n > maxSlot) maxSlot = n;
@@ -991,8 +1131,8 @@ var INBOX_DIR = "_inbox";
 var CORRECTIONS_FILE = "corrections.jsonl";
 var DOPAMINE_ALLOWED_ROLES = ["pm", "admin", "lead"];
 function processInbox(brainRoot) {
-  const inboxPath = join12(brainRoot, INBOX_DIR, CORRECTIONS_FILE);
-  if (!existsSync11(inboxPath)) {
+  const inboxPath = join13(brainRoot, INBOX_DIR, CORRECTIONS_FILE);
+  if (!existsSync12(inboxPath)) {
     return { processed: 0, skipped: 0, errors: [] };
   }
   const content = readFileSync4(inboxPath, "utf8").trim();
@@ -1047,16 +1187,18 @@ function processInbox(brainRoot) {
 }
 function applyCorrection(brainRoot, correction) {
   const neuronPath = correction.path;
-  const fullPath = join12(brainRoot, neuronPath);
+  const fullPath = join13(brainRoot, neuronPath);
   const counterAdd = Math.max(1, correction.counter_add || 1);
-  if (existsSync11(fullPath)) {
+  if (existsSync12(fullPath)) {
     for (let i = 0; i < counterAdd; i++) {
       fireNeuron(brainRoot, neuronPath);
     }
   } else {
-    growNeuron(brainRoot, neuronPath);
-    for (let i = 1; i < counterAdd; i++) {
-      fireNeuron(brainRoot, neuronPath);
+    const candResult = growCandidate(brainRoot, neuronPath);
+    if (candResult.promoted) {
+      for (let i = 1; i < counterAdd; i++) {
+        fireNeuron(brainRoot, neuronPath);
+      }
     }
   }
   if (correction.dopamine && correction.dopamine > 0) {
@@ -1075,12 +1217,12 @@ function isPathSafe(path) {
   return true;
 }
 function ensureInbox(brainRoot) {
-  const inboxDir = join12(brainRoot, INBOX_DIR);
-  if (!existsSync11(inboxDir)) {
-    mkdirSync6(inboxDir, { recursive: true });
+  const inboxDir = join13(brainRoot, INBOX_DIR);
+  if (!existsSync12(inboxDir)) {
+    mkdirSync7(inboxDir, { recursive: true });
   }
-  const filePath = join12(inboxDir, CORRECTIONS_FILE);
-  if (!existsSync11(filePath)) {
+  const filePath = join13(inboxDir, CORRECTIONS_FILE);
+  if (!existsSync12(filePath)) {
     writeFileSync9(filePath, "", "utf8");
   }
   return filePath;
@@ -1348,19 +1490,27 @@ function clearReports() {
 }
 
 // src/hooks.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync10, existsSync as existsSync12, mkdirSync as mkdirSync7, readdirSync as readdirSync8 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync10, existsSync as existsSync13, mkdirSync as mkdirSync8, readdirSync as readdirSync9 } from "fs";
 import { execSync as execSync2 } from "child_process";
-import { join as join13, resolve as resolve2 } from "path";
+import { join as join14, resolve as resolve2 } from "path";
 var SETTINGS_DIR = ".claude";
 var SETTINGS_FILE = "settings.local.json";
-function installHooks(brainRoot, projectRoot) {
+function installHooks(brainRoot, projectRoot, global) {
   const root = projectRoot || process.cwd();
   const resolvedBrain = resolve2(brainRoot);
-  if (!existsSync12(resolvedBrain) || !hasBrainRegions(resolvedBrain)) {
+  if (global) {
+    const home = process.env.HOME || "~";
+    if (!brainRoot.startsWith("/") && !brainRoot.startsWith(home)) {
+      console.error("\u274C --global requires an absolute --brain path (e.g. --brain ~/brain)");
+      process.exit(1);
+    }
+  }
+  if (!existsSync13(resolvedBrain) || !hasBrainRegions(resolvedBrain)) {
     initBrain(resolvedBrain);
   }
-  const settingsDir = join13(root, SETTINGS_DIR);
-  const settingsPath = join13(settingsDir, SETTINGS_FILE);
+  const settingsDir = global ? resolve2(process.env.HOME || "~", SETTINGS_DIR) : join14(root, SETTINGS_DIR);
+  const settingsFile = global ? "settings.json" : SETTINGS_FILE;
+  const settingsPath = join14(settingsDir, settingsFile);
   const defaultBrain = resolve2(root, "brain");
   const brainFlag = resolvedBrain === defaultBrain ? "" : ` --brain ${resolvedBrain}`;
   let npxBin = "npx";
@@ -1369,7 +1519,7 @@ function installHooks(brainRoot, projectRoot) {
   } catch {
   }
   let settings = {};
-  if (existsSync12(settingsPath)) {
+  if (existsSync13(settingsPath)) {
     try {
       settings = JSON.parse(readFileSync5(settingsPath, "utf8"));
     } catch {
@@ -1386,8 +1536,8 @@ function installHooks(brainRoot, projectRoot) {
       matcher: "startup|resume",
       entry: {
         type: "command",
-        command: `${npxBin} hebbian emit claude${brainFlag}`,
-        timeout: 10,
+        command: `${npxBin} hebbian emit claude${brainFlag} && ${npxBin} hebbian session start${brainFlag}`,
+        timeout: 15,
         statusMessage: `${HOOK_MARKER} refreshing brain`
       }
     },
@@ -1395,7 +1545,7 @@ function installHooks(brainRoot, projectRoot) {
       event: "Stop",
       entry: {
         type: "command",
-        command: `${npxBin} hebbian digest${brainFlag}`,
+        command: `${npxBin} hebbian digest${brainFlag}; ${npxBin} hebbian session end${brainFlag}`,
         timeout: 30,
         statusMessage: `${HOOK_MARKER} digesting session`
       }
@@ -1418,18 +1568,20 @@ function installHooks(brainRoot, projectRoot) {
       hooks[event].push(group);
     }
   }
-  if (!existsSync12(settingsDir)) {
-    mkdirSync7(settingsDir, { recursive: true });
+  if (!existsSync13(settingsDir)) {
+    mkdirSync8(settingsDir, { recursive: true });
   }
   writeFileSync10(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
   console.log(`\u2705 hebbian hooks installed at ${settingsPath}`);
   console.log(`   SessionStart \u2192 ${npxBin} hebbian emit claude${brainFlag}`);
   console.log(`   Stop \u2192 ${npxBin} hebbian digest${brainFlag}`);
 }
-function uninstallHooks(projectRoot) {
+function uninstallHooks(projectRoot, global) {
   const root = projectRoot || process.cwd();
-  const settingsPath = join13(root, SETTINGS_DIR, SETTINGS_FILE);
-  if (!existsSync12(settingsPath)) {
+  const settingsDir = global ? resolve2(process.env.HOME || "~", SETTINGS_DIR) : join14(root, SETTINGS_DIR);
+  const settingsFile = global ? "settings.json" : SETTINGS_FILE;
+  const settingsPath = join14(settingsDir, settingsFile);
+  if (!existsSync13(settingsPath)) {
     console.log("No hooks installed (settings.local.json not found)");
     return;
   }
@@ -1462,15 +1614,17 @@ function uninstallHooks(projectRoot) {
   writeFileSync10(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
   console.log(`\u2705 removed ${removed} hebbian hook(s) from ${settingsPath}`);
 }
-function checkHooks(projectRoot) {
+function checkHooks(projectRoot, global) {
   const root = projectRoot || process.cwd();
-  const settingsPath = join13(root, SETTINGS_DIR, SETTINGS_FILE);
+  const settingsDir = global ? resolve2(process.env.HOME || "~", SETTINGS_DIR) : join14(root, SETTINGS_DIR);
+  const settingsFile = global ? "settings.json" : SETTINGS_FILE;
+  const settingsPath = join14(settingsDir, settingsFile);
   const status = {
     installed: false,
     path: settingsPath,
     events: []
   };
-  if (!existsSync12(settingsPath)) {
+  if (!existsSync13(settingsPath)) {
     console.log(`\u274C hebbian hooks not installed (${settingsPath} not found)`);
     return status;
   }
@@ -1506,9 +1660,9 @@ function checkHooks(projectRoot) {
   return status;
 }
 function hasBrainRegions(dir) {
-  if (!existsSync12(dir)) return false;
+  if (!existsSync13(dir)) return false;
   try {
-    const entries = readdirSync8(dir);
+    const entries = readdirSync9(dir);
     return REGIONS.some((r) => entries.includes(r));
   } catch {
     return false;
@@ -1516,8 +1670,8 @@ function hasBrainRegions(dir) {
 }
 
 // src/digest.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync11, existsSync as existsSync13, mkdirSync as mkdirSync8 } from "fs";
-import { join as join14, basename } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync11, existsSync as existsSync14, mkdirSync as mkdirSync9 } from "fs";
+import { join as join15, basename } from "path";
 var NEGATION_PATTERNS = [
   /\bdon[''\u2019]?t\b/i,
   /\bdo not\b/i,
@@ -1568,13 +1722,13 @@ function readHookInput(stdin) {
   }
 }
 function digestTranscript(brainRoot, transcriptPath, sessionId) {
-  if (!existsSync13(transcriptPath)) {
+  if (!existsSync14(transcriptPath)) {
     throw new Error(`Transcript not found: ${transcriptPath}`);
   }
   const resolvedSessionId = sessionId || basename(transcriptPath, ".jsonl");
-  const logDir = join14(brainRoot, DIGEST_LOG_DIR);
-  const logPath = join14(logDir, `${resolvedSessionId}.jsonl`);
-  if (existsSync13(logPath)) {
+  const logDir = join15(brainRoot, DIGEST_LOG_DIR);
+  const logPath = join15(logDir, `${resolvedSessionId}.jsonl`);
+  if (existsSync14(logPath)) {
     console.log(`\u23ED already digested session ${resolvedSessionId}, skip`);
     return { corrections: 0, skipped: 0, transcriptPath, sessionId: resolvedSessionId };
   }
@@ -1589,7 +1743,7 @@ function digestTranscript(brainRoot, transcriptPath, sessionId) {
   const auditEntries = [];
   for (const correction of corrections) {
     try {
-      growNeuron(brainRoot, correction.path);
+      growCandidate(brainRoot, correction.path);
       logEpisode(brainRoot, "digest", correction.path, correction.text);
       auditEntries.push({ correction, applied: true });
       applied++;
@@ -1806,11 +1960,11 @@ function extractKeywords(text) {
   return text.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[^a-zA-Z0-9\u3000-\u9FFF\uAC00-\uD7AF]+/g, " ").toLowerCase().split(/\s+/).filter((t) => t.length > 2 && !STOP_WORDS.has(t));
 }
 function writeAuditLog(brainRoot, sessionId, entries) {
-  const logDir = join14(brainRoot, DIGEST_LOG_DIR);
-  if (!existsSync13(logDir)) {
-    mkdirSync8(logDir, { recursive: true });
+  const logDir = join15(brainRoot, DIGEST_LOG_DIR);
+  if (!existsSync14(logDir)) {
+    mkdirSync9(logDir, { recursive: true });
   }
-  const logPath = join14(logDir, `${sessionId}.jsonl`);
+  const logPath = join15(logDir, `${sessionId}.jsonl`);
   const lines = entries.map(
     (e) => JSON.stringify({
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1823,6 +1977,462 @@ function writeAuditLog(brainRoot, sessionId, entries) {
   );
   writeFileSync11(logPath, lines.join("\n") + (lines.length > 0 ? "\n" : ""), "utf8");
 }
+
+// src/outcome.ts
+import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync15, mkdirSync as mkdirSync10, writeFileSync as writeFileSync12, readFileSync as readFileSync7, readdirSync as readdirSync10, rmSync as rmSync2, statSync as statSync4 } from "fs";
+import { join as join16 } from "path";
+import { randomUUID } from "crypto";
+function captureSessionStart(brainRoot) {
+  let sha;
+  try {
+    sha = execSync3("git rev-parse HEAD", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    console.log("\u23ED\uFE0F session start: not a git repo, skipping");
+    return null;
+  }
+  let status;
+  try {
+    const raw = execSync3("git status --porcelain", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    status = raw ? raw.split("\n") : [];
+  } catch {
+    status = [];
+  }
+  const brain = scanBrain(brainRoot);
+  const result = runSubsumption(brain);
+  const neurons = [];
+  for (const region of result.activeRegions) {
+    for (const neuron of region.neurons) {
+      if (!neuron.isDormant && neuron.counter > 0) {
+        neurons.push(`${region.name}/${neuron.path}`);
+      }
+    }
+  }
+  const uuid = randomUUID();
+  const stateDir = join16(brainRoot, SESSION_STATE_DIR);
+  if (!existsSync15(stateDir)) {
+    mkdirSync10(stateDir, { recursive: true });
+  }
+  const state = { ts: (/* @__PURE__ */ new Date()).toISOString(), sha, status, neurons, uuid };
+  writeFileSync12(join16(stateDir, `state_${uuid}.json`), JSON.stringify(state), "utf8");
+  console.log(`\u{1F4F8} session start: SHA ${sha.slice(0, 7)}, ${neurons.length} active neurons`);
+  return state;
+}
+function detectOutcome(brainRoot) {
+  const state = readLatestSessionState(brainRoot);
+  if (!state) {
+    console.log("\u23ED\uFE0F session end: no session state found, skipping");
+    return null;
+  }
+  let currentSha;
+  try {
+    currentSha = execSync3("git rev-parse HEAD", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    console.log("\u23ED\uFE0F session end: not a git repo, skipping");
+    cleanupSessionState(brainRoot, state.uuid);
+    return null;
+  }
+  let currentStatus;
+  try {
+    const raw = execSync3("git status --porcelain", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    currentStatus = raw ? filterHebbianPaths(raw.split("\n")) : [];
+  } catch {
+    currentStatus = [];
+  }
+  const filteredStartStatus = filterHebbianPaths(state.status);
+  const outcome = classifyOutcome(
+    { ...state, status: filteredStartStatus },
+    currentSha,
+    currentStatus
+  );
+  if (!outcome) {
+    console.log("\u{1F4CA} session end: no changes detected (no-op)");
+    cleanupSessionState(brainRoot, state.uuid);
+    return null;
+  }
+  const neurons = state.neurons;
+  logEpisode(brainRoot, "session-end", "", `outcome:${outcome}`, { outcome, neurons });
+  let result;
+  if (outcome === "revert") {
+    const { affected, skipped } = applyContra(brainRoot, neurons);
+    result = {
+      outcome: "revert",
+      neuronsAffected: affected,
+      protectedSkipped: skipped,
+      detail: `${affected} neurons contra'd (${skipped} protected skipped)`
+    };
+    console.log(`\u{1F4CA} session end: revert \u2014 ${result.detail}`);
+  } else {
+    result = {
+      outcome: "acceptance",
+      neuronsAffected: 0,
+      protectedSkipped: 0,
+      detail: "changes accepted"
+    };
+    console.log("\u{1F4CA} session end: acceptance");
+  }
+  cleanupSessionState(brainRoot, state.uuid);
+  return result;
+}
+function classifyOutcome(state, currentSha, currentStatus) {
+  const headMoved = state.sha !== currentSha;
+  const startStatusSet = new Set(state.status);
+  const endStatusSet = new Set(currentStatus);
+  const newItems = currentStatus.filter((s) => !startStatusSet.has(s));
+  const removedItems = state.status.filter((s) => !endStatusSet.has(s));
+  if (!headMoved) {
+    if (newItems.length === 0 && removedItems.length === 0) {
+      return null;
+    }
+    if (newItems.length > 0) {
+      return "acceptance";
+    }
+    if (removedItems.length > 0) {
+      return "revert";
+    }
+    return null;
+  }
+  if (newItems.length > 0) {
+    return "acceptance";
+  }
+  try {
+    const diffStat = execSync3(
+      `git diff ${state.sha}..${currentSha} --stat`,
+      { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    const logOutput = execSync3(
+      `git log --oneline ${state.sha}..${currentSha}`,
+      { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    if (/\brevert\b/i.test(logOutput)) {
+      return "revert";
+    }
+    if (!diffStat) {
+      return "revert";
+    }
+    return "acceptance";
+  } catch {
+    return null;
+  }
+}
+function applyContra(brainRoot, neurons) {
+  let affected = 0;
+  let skipped = 0;
+  for (const neuronPath of neurons) {
+    const region = neuronPath.split("/")[0] || "";
+    if (PROTECTED_REGIONS_CONTRA.includes(region)) {
+      skipped++;
+      continue;
+    }
+    const result = contraNeuron(brainRoot, neuronPath);
+    if (result > 0) {
+      affected++;
+    }
+  }
+  return { affected, skipped };
+}
+function buildOutcomeSummary(brainRoot) {
+  const episodes = readEpisodes(brainRoot);
+  const outcomeEpisodes = episodes.filter((e) => e.outcome && e.neurons);
+  if (outcomeEpisodes.length === 0) return "";
+  const stats = /* @__PURE__ */ new Map();
+  for (const ep of outcomeEpisodes) {
+    for (const neuron of ep.neurons) {
+      const existing = stats.get(neuron) || { sessions: 0, reverts: 0, acceptances: 0 };
+      existing.sessions++;
+      if (ep.outcome === "revert") existing.reverts++;
+      if (ep.outcome === "acceptance") existing.acceptances++;
+      stats.set(neuron, existing);
+    }
+  }
+  const lines = ["## Outcome Signals (from session history)\n"];
+  lines.push("Neurons with high contra_ratio (>0.5) are consistently present in reverted sessions. Consider pruning or modifying them.\n");
+  const sorted = [...stats.entries()].sort((a, b) => {
+    const ratioA = a[1].sessions > 0 ? a[1].reverts / a[1].sessions : 0;
+    const ratioB = b[1].sessions > 0 ? b[1].reverts / b[1].sessions : 0;
+    return ratioB - ratioA;
+  });
+  for (const [neuron, s] of sorted) {
+    const ratio = s.sessions > 0 ? (s.reverts / s.sessions).toFixed(2) : "0.00";
+    const trend = parseFloat(ratio) > 0.5 ? "\u2190 act on this" : parseFloat(ratio) > 0.3 ? "\u2190 watch" : "";
+    lines.push(`- ${neuron}: sessions=${s.sessions} reverts=${s.reverts} acceptances=${s.acceptances} contra_ratio=${ratio} ${trend}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function readLatestSessionState(brainRoot) {
+  const stateDir = join16(brainRoot, SESSION_STATE_DIR);
+  if (!existsSync15(stateDir)) return null;
+  let latest = null;
+  try {
+    for (const entry of readdirSync10(stateDir)) {
+      if (!entry.startsWith("state_") || !entry.endsWith(".json")) continue;
+      const fullPath = join16(stateDir, entry);
+      const mtime = statSync4(fullPath).mtimeMs;
+      if (!latest || mtime > latest.mtime) {
+        latest = { path: fullPath, mtime };
+      }
+    }
+  } catch {
+    return null;
+  }
+  if (!latest) return null;
+  try {
+    return JSON.parse(readFileSync7(latest.path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function filterHebbianPaths(statusLines) {
+  const hebbianPatterns = ["hippocampus/session_state", "hippocampus/session_log", "hippocampus/digest_log", "_inbox/"];
+  return statusLines.filter(
+    (line) => !hebbianPatterns.some((p) => line.includes(p))
+  );
+}
+function cleanupSessionState(brainRoot, uuid) {
+  const stateDir = join16(brainRoot, SESSION_STATE_DIR);
+  const filePath = join16(stateDir, `state_${uuid}.json`);
+  try {
+    if (existsSync15(filePath)) rmSync2(filePath);
+  } catch {
+  }
+}
+
+// src/evolve.ts
+var MAX_ACTIONS = 10;
+var PROTECTED_REGIONS = ["brainstem", "limbic", "sensors"];
+var DEFAULT_MODEL = "gemini-2.0-flash-lite";
+var API_TIMEOUT = 3e4;
+var RETRY_DELAY = 5e3;
+async function runEvolve(brainRoot, dryRun) {
+  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");
+    return { actions: [], executed: 0, skipped: 0, dryRun };
+  }
+  const episodes = readEpisodes(brainRoot);
+  const brain = scanBrain(brainRoot);
+  const summary = buildBrainSummary(brain);
+  const outcomeSummary = buildOutcomeSummary(brainRoot);
+  const prompt = buildPrompt(summary, episodes, outcomeSummary);
+  let rawActions;
+  try {
+    rawActions = await callGemini(prompt, apiKey);
+  } catch (err) {
+    const msg = err.message;
+    console.log(`\u23ED\uFE0F evolve skipped: ${msg}`);
+    logEpisode(brainRoot, "evolve-error", "", msg);
+    return { actions: [], executed: 0, skipped: 0, dryRun };
+  }
+  const actions = validateActions(rawActions, brain);
+  const skipped = rawActions.length - actions.length;
+  if (actions.length === 0) {
+    console.log("\u{1F9E0} evolve: no valid actions proposed");
+    return { actions: [], executed: 0, skipped, dryRun };
+  }
+  if (dryRun) {
+    console.log(`\u{1F9E0} evolve (dry-run): ${actions.length} action(s) proposed`);
+    for (const action of actions) {
+      console.log(`  ${actionIcon(action.type)} ${action.type} ${action.path} \u2014 ${action.reason}`);
+    }
+    return { actions, executed: 0, skipped, dryRun: true };
+  }
+  const executed = executeActions(brainRoot, actions);
+  logEpisode(brainRoot, "evolve", "", `${executed} action(s) executed, ${skipped} skipped`);
+  console.log(`\u{1F9E0} evolve: ${executed} action(s) executed, ${skipped} skipped`);
+  return { actions, executed, skipped, dryRun: false };
+}
+function buildBrainSummary(brain) {
+  const lines = ["# Brain State\n"];
+  for (const region of brain.regions) {
+    const neurons = region.neurons;
+    if (neurons.length === 0 && !region.hasBomb) continue;
+    lines.push(`## ${region.name} (P${REGION_PRIORITY[region.name]})`);
+    if (region.hasBomb) lines.push("\u26A0\uFE0F BOMB active \u2014 region blocked");
+    for (const neuron of neurons) {
+      const flags = [];
+      if (neuron.isDormant) flags.push("dormant");
+      if (neuron.hasBomb) flags.push("bomb");
+      if (neuron.hasMemory) flags.push("memory");
+      if (neuron.dopamine > 0) flags.push(`dopamine:${neuron.dopamine}`);
+      const flagStr = flags.length > 0 ? ` [${flags.join(", ")}]` : "";
+      lines.push(`- ${neuron.path} (counter:${neuron.counter}, intensity:${neuron.intensity})${flagStr}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function buildPrompt(summary, episodes, outcomeSummary) {
+  const episodeLines = episodes.length > 0 ? episodes.map((e) => `- [${e.ts}] ${e.type}: ${e.path} \u2014 ${e.detail}`).join("\n") : "(no recent episodes)";
+  const outcomeSection = outcomeSummary || "";
+  return `You are the evolve engine for a hebbian brain \u2014 a filesystem-based memory system for AI agents.
+
+## Axioms
+- Folder = Neuron, File = Firing Trace, Counter = Activation strength
+- 7 regions in subsumption cascade: brainstem(P0) > limbic(P1) > hippocampus(P2) > sensors(P3) > cortex(P4) > ego(P5) > prefrontal(P6)
+- Lower priority ALWAYS overrides higher priority
+- PROTECTED regions (brainstem, limbic, sensors): NEVER propose mutations for these
+
+## Current Brain
+${summary}
+
+${outcomeSection}
+## Recent Episodes (last ${episodes.length})
+${episodeLines}
+
+## Available Actions
+- grow: Create a new neuron at the given path (region/name). Use for recurring patterns that deserve permanent memory.
+- fire: Increment an existing neuron's counter. Use for strengthening well-confirmed rules.
+- signal: Add dopamine (reward), bomb (block), or memory signal. Use sparingly.
+- prune: Decrement a neuron's counter. Use for rules that aren't working or cause issues.
+- decay: Mark inactive neurons as dormant. Use for stale rules with no recent activity.
+
+## Constraints
+- Max ${MAX_ACTIONS} actions per cycle
+- PREFER fire over grow \u2014 strengthen existing neurons before creating new ones
+- NEVER target brainstem, limbic, or sensors regions
+- Each action needs a "reason" explaining why
+
+## Task
+Analyze the brain state and recent episodes. Propose actions to improve the brain.
+Focus on: strengthening repeatedly-used rules, pruning ineffective ones, growing new neurons from repeated patterns.
+
+Respond with a JSON array of actions:
+[{"type":"fire","path":"cortex/NO_console_log","reason":"fired 3 times in recent sessions"}]`;
+}
+async function callGemini(prompt, apiKey) {
+  const model = process.env.EVOLVE_MODEL || DEFAULT_MODEL;
+  const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`;
+  const body = {
+    contents: [{ parts: [{ text: prompt }] }],
+    generationConfig: {
+      responseMimeType: "application/json",
+      temperature: 0.2
+    }
+  };
+  let lastError = null;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    if (attempt > 0) {
+      await new Promise((r) => setTimeout(r, RETRY_DELAY));
+    }
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(API_TIMEOUT)
+      });
+      if (!res.ok) {
+        lastError = new Error(`Gemini API ${res.status}: ${res.statusText}`);
+        continue;
+      }
+      const data = await res.json();
+      if (data.error) {
+        lastError = new Error(`Gemini error: ${data.error.message || "unknown"}`);
+        continue;
+      }
+      const text = data.candidates?.[0]?.content?.parts?.[0]?.text;
+      if (!text) {
+        lastError = new Error("Gemini returned empty response");
+        continue;
+      }
+      return parseActions(text);
+    } catch (err) {
+      lastError = err;
+      continue;
+    }
+  }
+  throw lastError || new Error("Gemini call failed");
+}
+function parseActions(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new Error(`Failed to parse LLM response as JSON: ${text.slice(0, 100)}`);
+  }
+  if (!Array.isArray(parsed)) {
+    throw new Error("LLM response is not an array");
+  }
+  const validTypes = /* @__PURE__ */ new Set(["grow", "fire", "signal", "prune", "decay"]);
+  const actions = [];
+  for (const item of parsed) {
+    if (!item || typeof item !== "object") continue;
+    const { type, path, reason, signal } = item;
+    if (typeof type !== "string" || !validTypes.has(type)) continue;
+    if (typeof path !== "string" || path.length === 0) continue;
+    if (typeof reason !== "string") continue;
+    const action = { type, path, reason };
+    if (type === "signal" && typeof signal === "string") {
+      action.signal = signal;
+    }
+    actions.push(action);
+  }
+  return actions;
+}
+function validateActions(actions, _brain) {
+  return actions.filter((action) => {
+    const region = action.path.split("/")[0];
+    if (!region || PROTECTED_REGIONS.includes(region)) {
+      console.log(`   \u{1F6E1}\uFE0F blocked: ${action.type} ${action.path} (protected region)`);
+      return false;
+    }
+    if (!REGIONS.includes(region)) {
+      console.log(`   \u26A0\uFE0F skipped: ${action.type} ${action.path} (invalid region)`);
+      return false;
+    }
+    if (action.type === "signal" && action.signal && !["dopamine", "bomb", "memory"].includes(action.signal)) {
+      console.log(`   \u26A0\uFE0F skipped: signal ${action.path} (invalid signal type: ${action.signal})`);
+      return false;
+    }
+    return true;
+  }).slice(0, MAX_ACTIONS);
+}
+function executeActions(brainRoot, actions) {
+  let executed = 0;
+  for (const action of actions) {
+    try {
+      switch (action.type) {
+        case "fire":
+          fireNeuron(brainRoot, action.path);
+          break;
+        case "grow":
+          growCandidate(brainRoot, action.path);
+          break;
+        case "signal":
+          signalNeuron(brainRoot, action.path, action.signal || "dopamine");
+          break;
+        case "prune":
+          rollbackNeuron(brainRoot, action.path);
+          break;
+        case "decay":
+          runDecay(brainRoot, 0);
+          break;
+      }
+      console.log(`   ${actionIcon(action.type)} ${action.type} ${action.path}`);
+      executed++;
+    } catch (err) {
+      console.log(`   \u26A0\uFE0F failed: ${action.type} ${action.path} \u2014 ${err.message}`);
+    }
+  }
+  return executed;
+}
+function actionIcon(type) {
+  switch (type) {
+    case "fire":
+      return "\u{1F525}";
+    case "grow":
+      return "\u{1F331}";
+    case "signal":
+      return "\u26A1";
+    case "prune":
+      return "\u2702\uFE0F";
+    case "decay":
+      return "\u{1F4A4}";
+    default:
+      return "\u2753";
+  }
+}
 export {
   DECAY_DAYS,
   DIGEST_LOG_DIR,
@@ -1835,15 +2445,23 @@ export {
   MAX_CORRECTIONS_PER_SESSION,
   MAX_DEPTH,
   MIN_CORRECTION_LENGTH,
+  OUTCOME_TYPES,
+  PROTECTED_REGIONS_CONTRA,
   REGIONS,
   REGION_ICONS,
   REGION_KO,
   REGION_PRIORITY,
+  SESSION_STATE_DIR,
   SIGNAL_TYPES,
   SPOTLIGHT_DAYS,
   appendCorrection,
+  buildOutcomeSummary,
+  captureSessionStart,
   checkHooks,
+  classifyOutcome,
   clearReports,
+  contraNeuron,
+  detectOutcome,
   digestTranscript,
   emitBootstrap,
   emitIndex,
@@ -1852,29 +2470,35 @@ export {
   ensureInbox,
   extractCorrections,
   fireNeuron,
+  fromCandidatePath,
   getCurrentCounter,
   getLastActivity,
   getPendingReports,
   gitSnapshot,
+  growCandidate,
   growNeuron,
   initBrain,
   installHooks,
   jaccardSimilarity,
+  listCandidates,
   logEpisode,
   printDiag,
   processInbox,
+  promoteCandidates,
   readEpisodes,
   readHookInput,
   resolveBrainRoot,
   rollbackNeuron,
   runDecay,
   runDedup,
+  runEvolve,
   runSubsumption,
   scanBrain,
   signalNeuron,
   startAPI,
   startWatch,
   stem,
+  toCandidatePath,
   tokenize,
   uninstallHooks,
   writeAllTiers