hebbian 0.3.4 → 0.5.1

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 {
@@ -844,6 +876,9 @@ function growNeuron(brainRoot, neuronPath) {
     const counter = fireNeuron(brainRoot, neuronPath);
     return { action: "fired", path: neuronPath, counter };
   }
+  if (neuronPath.includes("..") || neuronPath.startsWith("/")) {
+    throw new Error(`Invalid neuron path: "${neuronPath}" (path traversal not allowed)`);
+  }
   const parts = neuronPath.split("/");
   const regionName = parts[0];
   if (!REGIONS.includes(regionName)) {
@@ -1216,41 +1251,174 @@ 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 = join12(brainRoot, SESSION_LOG_DIR);
-  if (!existsSync11(logDir)) return [];
+  const logDir = join13(brainRoot, SESSION_LOG_DIR);
+  if (!existsSync12(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 = readFileSync4(join12(logDir, entry), "utf8");
+      const content = readFileSync4(join13(logDir, entry), "utf8");
       if (content.trim()) {
         episodes.push(JSON.parse(content));
       }
@@ -1263,7 +1431,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;
@@ -1290,11 +1458,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();
@@ -1349,16 +1517,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) {
@@ -1377,12 +1547,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;
@@ -1398,7 +1568,7 @@ var init_inbox = __esm({
   "src/inbox.ts"() {
     "use strict";
     init_constants();
-    init_grow();
+    init_candidates();
     init_fire();
     init_signal();
     init_episode();
@@ -1478,7 +1648,16 @@ function error(res, message, status = 400) {
 async function readBody(req) {
   return new Promise((resolve4, reject) => {
     const chunks = [];
-    req.on("data", (chunk) => chunks.push(chunk));
+    let total = 0;
+    req.on("data", (chunk) => {
+      total += chunk.length;
+      if (total > MAX_BODY_BYTES) {
+        reject(new Error("Request body too large"));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
     req.on("end", () => resolve4(Buffer.concat(chunks).toString("utf8")));
     req.on("error", reject);
   });
@@ -1668,7 +1847,7 @@ function getPendingReports() {
 function clearReports() {
   pendingReports.length = 0;
 }
-var lastAPIActivity, pendingReports;
+var lastAPIActivity, pendingReports, MAX_BODY_BYTES;
 var init_api = __esm({
   "src/api.ts"() {
     "use strict";
@@ -1685,6 +1864,7 @@ var init_api = __esm({
     init_constants();
     lastAPIActivity = Date.now();
     pendingReports = [];
+    MAX_BODY_BYTES = 1048576;
   }
 });
 
@@ -1695,17 +1875,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";
@@ -1714,7 +1902,7 @@ function installHooks(brainRoot, projectRoot) {
   } catch {
   }
   let settings = {};
-  if (existsSync13(settingsPath)) {
+  if (existsSync14(settingsPath)) {
     try {
       settings = JSON.parse(readFileSync6(settingsPath, "utf8"));
     } catch {
@@ -1731,8 +1919,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`
       }
     },
@@ -1740,7 +1928,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`
       }
@@ -1763,18 +1951,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;
   }
@@ -1807,15 +1997,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;
   }
@@ -1851,9 +2043,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;
@@ -1877,8 +2069,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 {
@@ -1893,13 +2085,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 };
   }
@@ -1914,7 +2106,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++;
@@ -1966,6 +2158,8 @@ function extractCorrections(messages) {
     if (text.length < MIN_CORRECTION_LENGTH) continue;
     if (/^[\/!]/.test(text.trim())) continue;
     if (text.trim().endsWith("?")) continue;
+    if (/^<[a-zA-Z]/.test(text.trim())) continue;
+    if (/^Base directory for this skill:/i.test(text.trim())) continue;
     const correction = detectCorrection(text);
     if (correction) {
       corrections.push(correction);
@@ -2131,11 +2325,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(),
@@ -2153,7 +2347,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,
@@ -2194,6 +2388,244 @@ 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 ? "act on this" : parseFloat(ratio) > 0.3 ? "watch" : "";
+    const safePath = neuron.replace(/[\n\r#]/g, " ").trim();
+    lines.push(`- ${safePath}: 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, {
@@ -2205,16 +2637,32 @@ __export(evolve_exports, {
   runEvolve: () => runEvolve,
   validateActions: () => validateActions
 });
+import { existsSync as existsSync17, readFileSync as readFileSync9, writeFileSync as writeFileSync14 } from "fs";
+import { join as join18 } from "path";
 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 };
   }
+  if (!dryRun && process.env.EVOLVE_NO_COOLDOWN !== "1") {
+    const cooldownMs = (parseInt(process.env.EVOLVE_COOLDOWN_SECONDS ?? "60", 10) || 60) * 1e3;
+    const cooldownPath = join18(brainRoot, EVOLVE_COOLDOWN_FILE);
+    if (existsSync17(cooldownPath)) {
+      const lastRun = parseInt(readFileSync9(cooldownPath, "utf8").trim(), 10);
+      const elapsed = Date.now() - lastRun;
+      if (elapsed < cooldownMs) {
+        const remaining = Math.ceil((cooldownMs - elapsed) / 1e3);
+        console.log(`\u23F3 evolve cooldown: ${remaining}s remaining (use EVOLVE_NO_COOLDOWN=1 to bypass)`);
+        return { actions: [], executed: 0, skipped: 0, dryRun };
+      }
+    }
+  }
   const episodes = readEpisodes(brainRoot);
   const brain = scanBrain(brainRoot);
   const summary = buildBrainSummary(brain);
-  const prompt = buildPrompt(summary, episodes);
+  const outcomeSummary = buildOutcomeSummary(brainRoot);
+  const prompt = buildPrompt(summary, episodes, outcomeSummary);
   let rawActions;
   try {
     rawActions = await callGemini(prompt, apiKey);
@@ -2240,6 +2688,7 @@ async function runEvolve(brainRoot, dryRun) {
   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`);
+  writeFileSync14(join18(brainRoot, EVOLVE_COOLDOWN_FILE), String(Date.now()), "utf8");
   return { actions, executed, skipped, dryRun: false };
 }
 function buildBrainSummary(brain) {
@@ -2262,8 +2711,13 @@ function buildBrainSummary(brain) {
   }
   return lines.join("\n");
 }
-function buildPrompt(summary, episodes) {
-  const episodeLines = episodes.length > 0 ? episodes.map((e) => `- [${e.ts}] ${e.type}: ${e.path} \u2014 ${e.detail}`).join("\n") : "(no recent episodes)";
+function sanitizeForPrompt(text) {
+  const firstLine = (text.split("\n")[0] ?? "").trim();
+  return firstLine.replace(/^#+\s*/g, "").slice(0, 200);
+}
+function buildPrompt(summary, episodes, outcomeSummary) {
+  const episodeLines = episodes.length > 0 ? episodes.map((e) => `- [${e.ts}] ${e.type}: ${e.path} \u2014 ${sanitizeForPrompt(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
@@ -2275,6 +2729,7 @@ function buildPrompt(summary, episodes) {
 ## Current Brain
 ${summary}
 
+${outcomeSection}
 ## Recent Episodes (last ${episodes.length})
 ${episodeLines}
 
@@ -2300,7 +2755,7 @@ Respond with a JSON array of actions:
 }
 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 url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`;
   const body = {
     contents: [{ parts: [{ text: prompt }] }],
     generationConfig: {
@@ -2316,7 +2771,7 @@ async function callGemini(prompt, apiKey) {
     try {
       const res = await fetch(url, {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
+        headers: { "Content-Type": "application/json", "x-goog-api-key": apiKey },
         body: JSON.stringify(body),
         signal: AbortSignal.timeout(API_TIMEOUT)
       });
@@ -2370,6 +2825,10 @@ function parseActions(text) {
 }
 function validateActions(actions, _brain) {
   return actions.filter((action) => {
+    if (action.path.includes("..") || action.path.startsWith("/")) {
+      console.log(`   \u26A0\uFE0F blocked: ${action.type} ${action.path} (path traversal)`);
+      return false;
+    }
     const region = action.path.split("/")[0];
     if (!region || PROTECTED_REGIONS.includes(region)) {
       console.log(`   \u{1F6E1}\uFE0F blocked: ${action.type} ${action.path} (protected region)`);
@@ -2395,7 +2854,7 @@ function executeActions(brainRoot, actions) {
           fireNeuron(brainRoot, action.path);
           break;
         case "grow":
-          growNeuron(brainRoot, action.path);
+          growCandidate(brainRoot, action.path);
           break;
         case "signal":
           signalNeuron(brainRoot, action.path, action.signal || "dopamine");
@@ -2431,7 +2890,7 @@ function actionIcon(type) {
       return "\u2753";
   }
 }
-var MAX_ACTIONS, PROTECTED_REGIONS, DEFAULT_MODEL, API_TIMEOUT, RETRY_DELAY;
+var MAX_ACTIONS, PROTECTED_REGIONS, DEFAULT_MODEL, API_TIMEOUT, RETRY_DELAY, EVOLVE_COOLDOWN_FILE;
 var init_evolve = __esm({
   "src/evolve.ts"() {
     "use strict";
@@ -2439,15 +2898,157 @@ var init_evolve = __esm({
     init_scanner();
     init_constants();
     init_fire();
-    init_grow();
+    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;
+    EVOLVE_COOLDOWN_FILE = "hippocampus/evolve_last_run";
+  }
+});
+
+// src/doctor.ts
+var doctor_exports = {};
+__export(doctor_exports, {
+  runDoctor: () => runDoctor
+});
+import { existsSync as existsSync18, readFileSync as readFileSync10, readdirSync as readdirSync11 } from "fs";
+import { join as join19 } 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(readFileSync10(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 (!existsSync18(brainRoot)) {
+    fail(`Brain not found at ${brainRoot}`, "hebbian init ./brain");
+  } else {
+    ok(`Brain root: ${brainRoot}`);
+    for (const region of REGIONS) {
+      const regionDir = join19(brainRoot, region);
+      if (existsSync18(regionDir)) {
+        ok(`Region: ${region}`);
+      } else {
+        warn(`Missing region: ${region}`, `mkdir -p ${regionDir}`);
+      }
+    }
+  }
+  console.log("\nClaude Code hooks");
+  const settingsPath = join19(process.cwd(), ".claude", "settings.local.json");
+  if (!existsSync18(settingsPath)) {
+    warn("No .claude/settings.local.json found", "hebbian claude install");
+  } else {
+    try {
+      const settings = JSON.parse(readFileSync10(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 = join19(brainRoot, region, "_candidates");
+      if (existsSync18(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();
   }
 });
 
@@ -2455,7 +3056,7 @@ var init_evolve = __esm({
 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.
 
@@ -2479,7 +3080,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
 
@@ -2521,6 +3126,7 @@ async function main(argv) {
       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" }
     },
@@ -2641,18 +3247,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);
@@ -2661,7 +3272,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;
@@ -2684,12 +3295,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));