hebbian 0.3.3 → 0.5.0

package/dist/bin/hebbian.js

@@ -18,7 +18,7 @@ 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;
+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;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
@@ -76,6 +76,8 @@ var init_constants = __esm({
     MAX_CORRECTIONS_PER_SESSION = 10;
     MIN_CORRECTION_LENGTH = 15;
     DIGEST_LOG_DIR = "hippocampus/digest_log";
+    SESSION_STATE_DIR = "hippocampus/session_state";
+    PROTECTED_REGIONS_CONTRA = ["brainstem", "limbic", "sensors"];
   }
 });
 
@@ -417,7 +419,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} |`);
   }
@@ -439,7 +441,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("|---|------|---------|----------|");
@@ -465,7 +467,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) |`);
   }
@@ -477,7 +479,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}`);
@@ -491,7 +493,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);
@@ -574,7 +576,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}]`);
@@ -584,7 +586,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("");
@@ -593,7 +596,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]** ";
@@ -758,7 +761,9 @@ var init_update_check = __esm({
 // src/fire.ts
 var fire_exports = {};
 __export(fire_exports, {
+  contraNeuron: () => contraNeuron,
   fireNeuron: () => fireNeuron,
+  getCurrentContra: () => getCurrentContra,
   getCurrentCounter: () => getCurrentCounter
 });
 import { readdirSync as readdirSync3, renameSync, writeFileSync as writeFileSync4, existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
@@ -781,6 +786,33 @@ function fireNeuron(brainRoot, neuronPath) {
   console.log(`\u{1F525} fired: ${neuronPath} (${current} \u2192 ${newCounter})`);
   return newCounter;
 }
+function contraNeuron(brainRoot, neuronPath) {
+  const fullPath = join5(brainRoot, neuronPath);
+  if (!existsSync6(fullPath)) {
+    return 0;
+  }
+  const current = getCurrentContra(fullPath);
+  const newContra = current + 1;
+  if (current > 0) {
+    renameSync(join5(fullPath, `${current}.contra`), join5(fullPath, `${newContra}.contra`));
+  } else {
+    writeFileSync4(join5(fullPath, `${newContra}.contra`), "", "utf8");
+  }
+  return newContra;
+}
+function getCurrentContra(dir) {
+  let max = 0;
+  try {
+    for (const entry of readdirSync3(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 {
@@ -1216,31 +1248,187 @@ var init_watch = __esm({
   }
 });
 
+// src/candidates.ts
+var candidates_exports = {};
+__export(candidates_exports, {
+  CANDIDATE_DECAY_DAYS: () => CANDIDATE_DECAY_DAYS,
+  CANDIDATE_THRESHOLD: () => CANDIDATE_THRESHOLD,
+  fromCandidatePath: () => fromCandidatePath,
+  growCandidate: () => growCandidate,
+  listCandidates: () => listCandidates,
+  promoteCandidates: () => promoteCandidates,
+  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";
+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 = join12(brainRoot, candidatePath);
+  if (!existsSync11(src)) return false;
+  const dst = join12(brainRoot, targetPath);
+  if (existsSync11(dst)) {
+    fireNeuron(brainRoot, targetPath);
+    rmSync(src, { recursive: true, force: true });
+  } else {
+    mkdirSync6(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 = join12(brainRoot, region, CANDIDATE_SEGMENT);
+    walkNeuronDirs(candidateRoot, (neuronDir) => {
+      const rel = relative3(join12(brainRoot, region), neuronDir);
+      const candidatePath = `${region}/${rel}`;
+      const targetPath = fromCandidatePath(candidatePath);
+      const counter = readCounter(neuronDir);
+      const mtime = statSync4(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 = join12(brainRoot, region, CANDIDATE_SEGMENT);
+    walkNeuronDirs(candidateRoot, (neuronDir) => {
+      const rel = relative3(join12(brainRoot, region), neuronDir);
+      const candidatePath = `${region}/${rel}`;
+      const targetPath = fromCandidatePath(candidatePath);
+      const counter = readCounter(neuronDir);
+      const mtime = statSync4(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 (!existsSync11(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(join12(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;
+  }
+}
+var CANDIDATE_THRESHOLD, CANDIDATE_DECAY_DAYS, CANDIDATE_SEGMENT;
+var init_candidates = __esm({
+  "src/candidates.ts"() {
+    "use strict";
+    init_constants();
+    init_grow();
+    init_fire();
+    CANDIDATE_THRESHOLD = 3;
+    CANDIDATE_DECAY_DAYS = 14;
+    CANDIDATE_SEGMENT = "_candidates";
+  }
+});
+
 // src/episode.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync4, writeFileSync as writeFileSync9, mkdirSync as mkdirSync6, existsSync as existsSync11 } from "fs";
-import { join as join12 } from "path";
-function logEpisode(brainRoot, type, path, detail) {
-  const logDir = join12(brainRoot, SESSION_LOG_DIR);
-  if (!existsSync11(logDir)) {
-    mkdirSync6(logDir, { recursive: true });
+var episode_exports = {};
+__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 { join as join13 } from "path";
+function logEpisode(brainRoot, type, path, detail, extra) {
+  const logDir = join13(brainRoot, SESSION_LOG_DIR);
+  if (!existsSync12(logDir)) {
+    mkdirSync7(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 } : {}
   };
   writeFileSync9(
-    join12(logDir, `memory${nextSlot}.neuron`),
+    join13(logDir, `memory${nextSlot}.neuron`),
     JSON.stringify(episode),
     "utf8"
   );
 }
+function readEpisodes(brainRoot) {
+  const logDir = join13(brainRoot, SESSION_LOG_DIR);
+  if (!existsSync12(logDir)) return [];
+  const episodes = [];
+  let entries;
+  try {
+    entries = readdirSync8(logDir);
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    if (!entry.startsWith("memory") || !entry.endsWith(".neuron")) continue;
+    try {
+      const content = readFileSync4(join13(logDir, entry), "utf8");
+      if (content.trim()) {
+        episodes.push(JSON.parse(content));
+      }
+    } catch {
+    }
+  }
+  episodes.sort((a, b) => a.ts.localeCompare(b.ts));
+  return episodes;
+}
 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;
@@ -1267,11 +1455,11 @@ __export(inbox_exports, {
   ensureInbox: () => ensureInbox,
   processInbox: () => processInbox
 });
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync10, existsSync as existsSync12, mkdirSync as mkdirSync7 } from "fs";
-import { join as join13 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync10, existsSync as existsSync13, mkdirSync as mkdirSync8 } from "fs";
+import { join as join14 } from "path";
 function processInbox(brainRoot) {
-  const inboxPath = join13(brainRoot, INBOX_DIR, CORRECTIONS_FILE);
-  if (!existsSync12(inboxPath)) {
+  const inboxPath = join14(brainRoot, INBOX_DIR, CORRECTIONS_FILE);
+  if (!existsSync13(inboxPath)) {
     return { processed: 0, skipped: 0, errors: [] };
   }
   const content = readFileSync5(inboxPath, "utf8").trim();
@@ -1326,16 +1514,18 @@ function processInbox(brainRoot) {
 }
 function applyCorrection(brainRoot, correction) {
   const neuronPath = correction.path;
-  const fullPath = join13(brainRoot, neuronPath);
+  const fullPath = join14(brainRoot, neuronPath);
   const counterAdd = Math.max(1, correction.counter_add || 1);
-  if (existsSync12(fullPath)) {
+  if (existsSync13(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) {
@@ -1354,12 +1544,12 @@ function isPathSafe(path) {
   return true;
 }
 function ensureInbox(brainRoot) {
-  const inboxDir = join13(brainRoot, INBOX_DIR);
-  if (!existsSync12(inboxDir)) {
-    mkdirSync7(inboxDir, { recursive: true });
+  const inboxDir = join14(brainRoot, INBOX_DIR);
+  if (!existsSync13(inboxDir)) {
+    mkdirSync8(inboxDir, { recursive: true });
   }
-  const filePath = join13(inboxDir, CORRECTIONS_FILE);
-  if (!existsSync12(filePath)) {
+  const filePath = join14(inboxDir, CORRECTIONS_FILE);
+  if (!existsSync13(filePath)) {
     writeFileSync10(filePath, "", "utf8");
   }
   return filePath;
@@ -1375,7 +1565,7 @@ var init_inbox = __esm({
   "src/inbox.ts"() {
     "use strict";
     init_constants();
-    init_grow();
+    init_candidates();
     init_fire();
     init_signal();
     init_episode();
@@ -1672,17 +1862,25 @@ __export(hooks_exports, {
   installHooks: () => installHooks,
   uninstallHooks: () => uninstallHooks
 });
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync11, existsSync as existsSync13, mkdirSync as mkdirSync8, readdirSync as readdirSync8 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync11, existsSync as existsSync14, mkdirSync as mkdirSync9, readdirSync as readdirSync9 } from "fs";
 import { execSync as execSync2 } from "child_process";
-import { join as join14, resolve as resolve2 } from "path";
-function installHooks(brainRoot, projectRoot) {
+import { join as join15, resolve as resolve2 } from "path";
+function installHooks(brainRoot, projectRoot, global) {
   const root = projectRoot || process.cwd();
   const resolvedBrain = resolve2(brainRoot);
-  if (!existsSync13(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 (!existsSync14(resolvedBrain) || !hasBrainRegions(resolvedBrain)) {
     initBrain(resolvedBrain);
   }
-  const settingsDir = join14(root, SETTINGS_DIR);
-  const settingsPath = join14(settingsDir, SETTINGS_FILE);
+  const settingsDir = global ? resolve2(process.env.HOME || "~", SETTINGS_DIR) : join15(root, SETTINGS_DIR);
+  const settingsFile = global ? "settings.json" : SETTINGS_FILE;
+  const settingsPath = join15(settingsDir, settingsFile);
   const defaultBrain = resolve2(root, "brain");
   const brainFlag = resolvedBrain === defaultBrain ? "" : ` --brain ${resolvedBrain}`;
   let npxBin = "npx";
@@ -1691,7 +1889,7 @@ function installHooks(brainRoot, projectRoot) {
   } catch {
   }
   let settings = {};
-  if (existsSync13(settingsPath)) {
+  if (existsSync14(settingsPath)) {
     try {
       settings = JSON.parse(readFileSync6(settingsPath, "utf8"));
     } catch {
@@ -1708,8 +1906,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`
       }
     },
@@ -1717,7 +1915,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`
       }
@@ -1740,18 +1938,20 @@ function installHooks(brainRoot, projectRoot) {
       hooks[event].push(group);
     }
   }
-  if (!existsSync13(settingsDir)) {
-    mkdirSync8(settingsDir, { recursive: true });
+  if (!existsSync14(settingsDir)) {
+    mkdirSync9(settingsDir, { recursive: true });
   }
   writeFileSync11(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 = join14(root, SETTINGS_DIR, SETTINGS_FILE);
-  if (!existsSync13(settingsPath)) {
+  const settingsDir = global ? resolve2(process.env.HOME || "~", SETTINGS_DIR) : join15(root, SETTINGS_DIR);
+  const settingsFile = global ? "settings.json" : SETTINGS_FILE;
+  const settingsPath = join15(settingsDir, settingsFile);
+  if (!existsSync14(settingsPath)) {
     console.log("No hooks installed (settings.local.json not found)");
     return;
   }
@@ -1784,15 +1984,17 @@ function uninstallHooks(projectRoot) {
   writeFileSync11(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 = join14(root, SETTINGS_DIR, SETTINGS_FILE);
+  const settingsDir = global ? resolve2(process.env.HOME || "~", SETTINGS_DIR) : join15(root, SETTINGS_DIR);
+  const settingsFile = global ? "settings.json" : SETTINGS_FILE;
+  const settingsPath = join15(settingsDir, settingsFile);
   const status = {
     installed: false,
     path: settingsPath,
     events: []
   };
-  if (!existsSync13(settingsPath)) {
+  if (!existsSync14(settingsPath)) {
     console.log(`\u274C hebbian hooks not installed (${settingsPath} not found)`);
     return status;
   }
@@ -1828,9 +2030,9 @@ function checkHooks(projectRoot) {
   return status;
 }
 function hasBrainRegions(dir) {
-  if (!existsSync13(dir)) return false;
+  if (!existsSync14(dir)) return false;
   try {
-    const entries = readdirSync8(dir);
+    const entries = readdirSync9(dir);
     return REGIONS.some((r) => entries.includes(r));
   } catch {
     return false;
@@ -1854,8 +2056,8 @@ __export(digest_exports, {
   extractCorrections: () => extractCorrections,
   readHookInput: () => readHookInput
 });
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync12, existsSync as existsSync14, mkdirSync as mkdirSync9 } from "fs";
-import { join as join15, basename } from "path";
+import { readFileSync as readFileSync7, 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;
   try {
@@ -1870,13 +2072,13 @@ function readHookInput(stdin) {
   }
 }
 function digestTranscript(brainRoot, transcriptPath, sessionId) {
-  if (!existsSync14(transcriptPath)) {
+  if (!existsSync15(transcriptPath)) {
     throw new Error(`Transcript not found: ${transcriptPath}`);
   }
   const resolvedSessionId = sessionId || basename(transcriptPath, ".jsonl");
-  const logDir = join15(brainRoot, DIGEST_LOG_DIR);
-  const logPath = join15(logDir, `${resolvedSessionId}.jsonl`);
-  if (existsSync14(logPath)) {
+  const logDir = join16(brainRoot, DIGEST_LOG_DIR);
+  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 };
   }
@@ -1891,7 +2093,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++;
@@ -2108,11 +2310,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 = join15(brainRoot, DIGEST_LOG_DIR);
-  if (!existsSync14(logDir)) {
-    mkdirSync9(logDir, { recursive: true });
+  const logDir = join16(brainRoot, DIGEST_LOG_DIR);
+  if (!existsSync15(logDir)) {
+    mkdirSync10(logDir, { recursive: true });
   }
-  const logPath = join15(logDir, `${sessionId}.jsonl`);
+  const logPath = join16(logDir, `${sessionId}.jsonl`);
   const lines = entries.map(
     (e) => JSON.stringify({
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -2130,7 +2332,7 @@ var init_digest = __esm({
   "src/digest.ts"() {
     "use strict";
     init_constants();
-    init_grow();
+    init_candidates();
     init_episode();
     NEGATION_PATTERNS = [
       /\bdon[''\u2019]?t\b/i,
@@ -2171,11 +2373,649 @@ var init_digest = __esm({
   }
 });
 
+// src/outcome.ts
+var outcome_exports = {};
+__export(outcome_exports, {
+  buildOutcomeSummary: () => buildOutcomeSummary,
+  captureSessionStart: () => captureSessionStart,
+  classifyOutcome: () => classifyOutcome,
+  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 { join as join17 } 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 = join17(brainRoot, SESSION_STATE_DIR);
+  if (!existsSync16(stateDir)) {
+    mkdirSync11(stateDir, { recursive: true });
+  }
+  const state = { ts: (/* @__PURE__ */ new Date()).toISOString(), sha, status, neurons, uuid };
+  writeFileSync13(join17(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 = join17(brainRoot, SESSION_STATE_DIR);
+  if (!existsSync16(stateDir)) return null;
+  let latest = null;
+  try {
+    for (const entry of readdirSync10(stateDir)) {
+      if (!entry.startsWith("state_") || !entry.endsWith(".json")) continue;
+      const fullPath = join17(stateDir, entry);
+      const mtime = statSync5(fullPath).mtimeMs;
+      if (!latest || mtime > latest.mtime) {
+        latest = { path: fullPath, mtime };
+      }
+    }
+  } catch {
+    return null;
+  }
+  if (!latest) return null;
+  try {
+    return JSON.parse(readFileSync8(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 = join17(brainRoot, SESSION_STATE_DIR);
+  const filePath = join17(stateDir, `state_${uuid}.json`);
+  try {
+    if (existsSync16(filePath)) rmSync2(filePath);
+  } catch {
+  }
+}
+var init_outcome = __esm({
+  "src/outcome.ts"() {
+    "use strict";
+    init_constants();
+    init_scanner();
+    init_subsumption();
+    init_fire();
+    init_episode();
+  }
+});
+
+// src/evolve.ts
+var evolve_exports = {};
+__export(evolve_exports, {
+  buildBrainSummary: () => buildBrainSummary,
+  buildPrompt: () => buildPrompt,
+  callGemini: () => callGemini,
+  executeActions: () => executeActions,
+  parseActions: () => parseActions,
+  runEvolve: () => runEvolve,
+  validateActions: () => validateActions
+});
+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";
+  }
+}
+var MAX_ACTIONS, PROTECTED_REGIONS, DEFAULT_MODEL, API_TIMEOUT, RETRY_DELAY;
+var init_evolve = __esm({
+  "src/evolve.ts"() {
+    "use strict";
+    init_episode();
+    init_scanner();
+    init_constants();
+    init_fire();
+    init_candidates();
+    init_signal();
+    init_rollback();
+    init_decay();
+    init_outcome();
+    MAX_ACTIONS = 10;
+    PROTECTED_REGIONS = ["brainstem", "limbic", "sensors"];
+    DEFAULT_MODEL = "gemini-2.0-flash-lite";
+    API_TIMEOUT = 3e4;
+    RETRY_DELAY = 5e3;
+  }
+});
+
+// src/doctor.ts
+var doctor_exports = {};
+__export(doctor_exports, {
+  runDoctor: () => runDoctor
+});
+import { existsSync as existsSync17, readFileSync as readFileSync9, readdirSync as readdirSync11 } from "fs";
+import { join as join18 } from "path";
+import { execSync as execSync4 } from "child_process";
+async function runDoctor(brainRoot) {
+  let passed = 0, warnings = 0, failed = 0;
+  const ok = (msg) => {
+    console.log(`  \u2705 ${msg}`);
+    passed++;
+  };
+  const warn = (msg, fix) => {
+    console.log(`  \u26A0\uFE0F  ${msg}`);
+    if (fix) console.log(`     \u2192 ${fix}`);
+    warnings++;
+  };
+  const fail = (msg, fix) => {
+    console.log(`  \u274C ${msg}`);
+    if (fix) console.log(`     \u2192 ${fix}`);
+    failed++;
+  };
+  console.log("\n\u{1FA7A} hebbian doctor\n");
+  console.log("Node.js");
+  const nodeVer = process.versions.node;
+  const [major] = nodeVer.split(".").map(Number);
+  if ((major ?? 0) >= 22) {
+    ok(`Node.js ${nodeVer} (>= 22 required)`);
+  } else {
+    fail(`Node.js ${nodeVer} \u2014 need >= 22`, "nvm install 22 && nvm use 22");
+  }
+  console.log("\nnpm package");
+  try {
+    const pkgPath = new URL("../package.json", import.meta.url).pathname;
+    const pkg = JSON.parse(readFileSync9(pkgPath, "utf8"));
+    const local = pkg.version || "unknown";
+    let remote = "";
+    try {
+      const out = execSync4("npm view hebbian version 2>/dev/null", { timeout: 5e3 }).toString().trim();
+      remote = out;
+    } catch {
+    }
+    if (remote && remote !== local) {
+      warn(`hebbian ${local} installed, ${remote} available`, "npm i -g hebbian@latest");
+    } else {
+      ok(`hebbian ${local}${remote ? " (up to date)" : ""}`);
+    }
+  } catch {
+    warn("Could not read package.json");
+  }
+  console.log("\nbrain structure");
+  if (!existsSync17(brainRoot)) {
+    fail(`Brain not found at ${brainRoot}`, "hebbian init ./brain");
+  } else {
+    ok(`Brain root: ${brainRoot}`);
+    for (const region of REGIONS) {
+      const regionDir = join18(brainRoot, region);
+      if (existsSync17(regionDir)) {
+        ok(`Region: ${region}`);
+      } else {
+        warn(`Missing region: ${region}`, `mkdir -p ${regionDir}`);
+      }
+    }
+  }
+  console.log("\nClaude Code hooks");
+  const settingsPath = join18(process.cwd(), ".claude", "settings.local.json");
+  if (!existsSync17(settingsPath)) {
+    warn("No .claude/settings.local.json found", "hebbian claude install");
+  } else {
+    try {
+      const settings = JSON.parse(readFileSync9(settingsPath, "utf8"));
+      const hooks = settings.hooks || {};
+      const hasStop = Object.entries(hooks).some(
+        ([event, entries]) => event === "Stop" && Array.isArray(entries) && entries.some(
+          (e) => typeof e === "object" && e !== null && "command" in e && typeof e.command === "string" && e.command.includes("hebbian digest")
+        )
+      );
+      const hasStart = Object.entries(hooks).some(
+        ([event, entries]) => event === "SessionStart" && Array.isArray(entries) && entries.some(
+          (e) => typeof e === "object" && e !== null && "command" in e && typeof e.command === "string" && e.command.includes("hebbian emit")
+        )
+      );
+      if (hasStop && hasStart) {
+        ok("SessionStart + Stop hooks installed");
+      } else {
+        if (!hasStart) warn("SessionStart hook missing", "hebbian claude install");
+        if (!hasStop) warn("Stop hook missing", "hebbian claude install");
+      }
+    } catch {
+      fail("Malformed .claude/settings.local.json", "hebbian claude install");
+    }
+  }
+  console.log("\nnpx resolution");
+  try {
+    const resolved = execSync4("which npx", { timeout: 3e3 }).toString().trim();
+    ok(`npx: ${resolved}`);
+  } catch {
+    fail("npx not found in PATH", "Install Node.js from https://nodejs.org");
+  }
+  console.log("\ncandidates");
+  try {
+    let total = 0;
+    for (const region of REGIONS) {
+      const candidateDir = join18(brainRoot, region, "_candidates");
+      if (existsSync17(candidateDir)) {
+        const entries = readdirSync11(candidateDir, { withFileTypes: true });
+        const count = entries.filter((e) => e.isDirectory()).length;
+        total += count;
+      }
+    }
+    if (total === 0) {
+      ok("No pending candidates");
+    } else {
+      warn(`${total} candidate(s) pending`, "hebbian candidates   \u2014 to view");
+    }
+  } catch {
+    warn("Could not scan candidates");
+  }
+  console.log(`
+${"\u2500".repeat(40)}`);
+  console.log(`  passed: ${passed}  warnings: ${warnings}  failed: ${failed}`);
+  if (failed > 0) {
+    console.log("  Fix the \u274C issues above, then re-run `hebbian doctor`");
+  } else if (warnings > 0) {
+    console.log("  Looking mostly good! Review \u26A0\uFE0F  warnings above.");
+  } else {
+    console.log("  All checks passed. \u{1F389}");
+  }
+  console.log("");
+  return { passed, warnings, failed };
+}
+var init_doctor = __esm({
+  "src/doctor.ts"() {
+    "use strict";
+    init_constants();
+  }
+});
+
 // src/cli.ts
 init_constants();
 import { parseArgs } from "util";
 import { resolve as resolve3 } from "path";
-var VERSION = "0.3.2";
+var VERSION = "0.5.0";
 var HELP = `
 hebbian v${VERSION} \u2014 Folder-as-neuron brain for any AI agent.
 
@@ -2199,6 +3039,11 @@ COMMANDS:
   inbox                           Process corrections inbox
   claude install|uninstall|status Manage Claude Code hooks
   digest [--transcript <path>]    Extract corrections from conversation
+  candidates [promote]            List candidates or promote graduated ones
+  evolve [--dry-run]              LLM-powered brain evolution (Gemini)
+  session start|end               Capture/detect session outcomes
+  sessions                        Show session outcome history
+  doctor                          Self-diagnostic (hooks, brain, versions)
   diag                            Print brain diagnostics
   stats                           Print brain statistics
 
@@ -2213,6 +3058,7 @@ EXAMPLES:
   hebbian fire cortex/frontend/NO_console_log --brain ./my-brain
   hebbian emit claude --brain ./my-brain
   hebbian emit all
+  GEMINI_API_KEY=... hebbian evolve --dry-run
 `.trim();
 function readStdin() {
   return new Promise((resolve4) => {
@@ -2238,6 +3084,8 @@ async function main(argv) {
       days: { type: "string", short: "d" },
       port: { type: "string", short: "p" },
       transcript: { type: "string", short: "t" },
+      "dry-run": { type: "boolean" },
+      global: { type: "boolean", short: "g" },
       help: { type: "boolean", short: "h" },
       version: { type: "boolean", short: "v" }
     },
@@ -2358,18 +3206,23 @@ async function main(argv) {
     }
     case "claude": {
       const sub = positionals[1];
+      const isGlobal = values.global === true;
       const { installHooks: installHooks2, uninstallHooks: uninstallHooks2, checkHooks: checkHooks2 } = await Promise.resolve().then(() => (init_hooks(), hooks_exports));
       switch (sub) {
         case "install": {
-          const installBrain = values.brain ? resolve3(values.brain) : resolve3("./brain");
-          installHooks2(installBrain);
+          const installBrain = values.brain ? resolve3(values.brain) : isGlobal ? process.env.HEBBIAN_BRAIN ? resolve3(process.env.HEBBIAN_BRAIN) : "" : resolve3("./brain");
+          if (isGlobal && !installBrain) {
+            console.error("\u274C --global requires --brain <path> or HEBBIAN_BRAIN env var");
+            process.exit(1);
+          }
+          installHooks2(installBrain, void 0, isGlobal);
           break;
         }
         case "uninstall":
-          uninstallHooks2();
+          uninstallHooks2(void 0, isGlobal);
           break;
         case "status": {
-          checkHooks2();
+          checkHooks2(void 0, isGlobal);
           console.log(`   version: v${VERSION}`);
           const { checkForUpdates: checkUpdates, formatUpdateBanner: formatBanner } = await Promise.resolve().then(() => (init_update_check(), update_check_exports));
           const updateStatus = await checkUpdates(VERSION);
@@ -2378,7 +3231,7 @@ async function main(argv) {
           break;
         }
         default:
-          console.error("Usage: hebbian claude <install|uninstall|status>");
+          console.error("Usage: hebbian claude <install|uninstall|status> [--global]");
           process.exit(1);
       }
       break;
@@ -2401,6 +3254,70 @@ async function main(argv) {
       }
       break;
     }
+    case "candidates": {
+      const subCmd = positionals[1];
+      const { listCandidates: listCandidates2, promoteCandidates: promoteCandidates2 } = await Promise.resolve().then(() => (init_candidates(), candidates_exports));
+      if (subCmd === "promote") {
+        const result = promoteCandidates2(brainRoot);
+        console.log(`\u{1F393} promoted: ${result.promoted.length}, decayed: ${result.decayed.length}`);
+      } else {
+        const candidates = listCandidates2(brainRoot);
+        if (candidates.length === 0) {
+          console.log("No pending candidates");
+        } else {
+          console.log(`Candidates (promote at counter=${3}):`);
+          for (const c of candidates) {
+            const bar = "\u2588".repeat(c.counter) + "\u2591".repeat(Math.max(0, 3 - c.counter));
+            console.log(`  ${bar} ${c.counter}/3  ${c.targetPath}  (${c.daysInactive}d idle)`);
+          }
+        }
+      }
+      break;
+    }
+    case "evolve": {
+      const dryRun = values["dry-run"] === true;
+      const { runEvolve: runEvolve2 } = await Promise.resolve().then(() => (init_evolve(), evolve_exports));
+      await runEvolve2(brainRoot, dryRun);
+      break;
+    }
+    case "session": {
+      const sub = positionals[1];
+      const { captureSessionStart: captureSessionStart2, detectOutcome: detectOutcome2 } = await Promise.resolve().then(() => (init_outcome(), outcome_exports));
+      switch (sub) {
+        case "start":
+          captureSessionStart2(brainRoot);
+          break;
+        case "end":
+          detectOutcome2(brainRoot);
+          break;
+        default:
+          console.error("Usage: hebbian session <start|end>");
+          process.exit(1);
+      }
+      break;
+    }
+    case "sessions": {
+      const { readEpisodes: readEpisodes2 } = await Promise.resolve().then(() => (init_episode(), episode_exports));
+      const episodes = readEpisodes2(brainRoot).filter((e) => e.outcome);
+      if (episodes.length === 0) {
+        console.log("No session outcomes recorded yet");
+      } else {
+        console.log("Session Outcomes:");
+        for (const ep of episodes.reverse()) {
+          const icon = ep.outcome === "revert" ? "\u{1F504}" : "\u2705";
+          const neurons = ep.neurons ? `${ep.neurons.length} neurons` : "";
+          console.log(`  ${icon} ${ep.ts.slice(0, 19)} ${ep.outcome} ${neurons}`);
+        }
+        console.log(`
+Total: ${episodes.length} sessions`);
+      }
+      break;
+    }
+    case "doctor": {
+      const { runDoctor: runDoctor2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
+      await runDoctor2(brainRoot);
+      break;
+    }
     case "diag":
     case "stats": {
       const { scanBrain: scanBrain2 } = await Promise.resolve().then(() => (init_scanner(), scanner_exports));