hebbian 0.3.4 → 0.5.1

package/dist/index.js

@@ -56,6 +56,9 @@ var HOOK_MARKER = "[hebbian]";
 var MAX_CORRECTIONS_PER_SESSION = 10;
 var MIN_CORRECTION_LENGTH = 15;
 var DIGEST_LOG_DIR = "hippocampus/digest_log";
+var OUTCOME_TYPES = ["revert", "acceptance"];
+var SESSION_STATE_DIR = "hippocampus/session_state";
+var PROTECTED_REGIONS_CONTRA = ["brainstem", "limbic", "sensors"];
 function resolveBrainRoot(brainFlag) {
   if (brainFlag) return resolve(brainFlag);
   if (process.env.HEBBIAN_BRAIN) return resolve(process.env.HEBBIAN_BRAIN);
@@ -284,6 +287,33 @@ function fireNeuron(brainRoot, neuronPath) {
   console.log(`\u{1F525} fired: ${neuronPath} (${current} \u2192 ${newCounter})`);
   return newCounter;
 }
+function contraNeuron(brainRoot, neuronPath) {
+  const fullPath = join2(brainRoot, neuronPath);
+  if (!existsSync3(fullPath)) {
+    return 0;
+  }
+  const current = getCurrentContra(fullPath);
+  const newContra = current + 1;
+  if (current > 0) {
+    renameSync(join2(fullPath, `${current}.contra`), join2(fullPath, `${newContra}.contra`));
+  } else {
+    writeFileSync(join2(fullPath, `${newContra}.contra`), "", "utf8");
+  }
+  return newContra;
+}
+function getCurrentContra(dir) {
+  let max = 0;
+  try {
+    for (const entry of readdirSync2(dir)) {
+      if (entry.endsWith(".contra")) {
+        const n = parseInt(entry, 10);
+        if (!isNaN(n) && n > max) max = n;
+      }
+    }
+  } catch {
+  }
+  return max;
+}
 function getCurrentCounter(dir) {
   let max = 0;
   try {
@@ -370,6 +400,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)) {
@@ -619,7 +652,7 @@ function emitBootstrap(result, brain) {
   lines.push("|--------|---------|------------|");
   for (const region of result.activeRegions) {
     const active = region.neurons.filter((n) => !n.isDormant);
-    const activation = active.reduce((sum, n) => sum + n.counter, 0);
+    const activation = active.reduce((sum, n) => sum + n.intensity, 0);
     const icon = REGION_ICONS[region.name] || "";
     lines.push(`| ${icon} ${region.name} | ${active.length} | ${activation} |`);
   }
@@ -641,7 +674,7 @@ function emitIndex(result, brain) {
   const allNeurons = result.activeRegions.flatMap(
     (r) => r.neurons.filter((n) => !n.isDormant && n.counter >= EMIT_THRESHOLD)
   );
-  allNeurons.sort((a, b) => b.counter - a.counter);
+  allNeurons.sort((a, b) => b.intensity - a.intensity);
   lines.push("## Top 10 Active Neurons");
   lines.push("| # | Path | Counter | Strength |");
   lines.push("|---|------|---------|----------|");
@@ -667,7 +700,7 @@ function emitIndex(result, brain) {
   for (const region of result.activeRegions) {
     const active = region.neurons.filter((n) => !n.isDormant);
     const dormant = region.neurons.filter((n) => n.isDormant);
-    const activation = active.reduce((sum, n) => sum + n.counter, 0);
+    const activation = active.reduce((sum, n) => sum + n.intensity, 0);
     const icon = REGION_ICONS[region.name] || "";
     lines.push(`| ${icon} ${region.name} | ${active.length} | ${dormant.length} | ${activation} | [_rules.md](${region.name}/_rules.md) |`);
   }
@@ -679,7 +712,7 @@ function emitRegionRules(region) {
   const ko = REGION_KO[region.name] || "";
   const active = region.neurons.filter((n) => !n.isDormant);
   const dormant = region.neurons.filter((n) => n.isDormant);
-  const activation = active.reduce((sum, n) => sum + n.counter, 0);
+  const activation = active.reduce((sum, n) => sum + n.intensity, 0);
   const lines = [];
   lines.push(`# ${icon} ${region.name} (${ko})`);
   lines.push(`> Active: ${active.length} | Dormant: ${dormant.length} | Activation: ${activation}`);
@@ -693,7 +726,7 @@ function emitRegionRules(region) {
   }
   if (active.length > 0) {
     lines.push("## Rules");
-    const sorted = [...active].sort((a, b) => b.counter - a.counter);
+    const sorted = [...active].sort((a, b) => b.intensity - a.intensity);
     for (const n of sorted) {
       const indent = "  ".repeat(Math.min(n.depth, 4));
       const prefix = strengthPrefix(n.counter);
@@ -776,7 +809,7 @@ function printDiag(brain, result) {
     const icon = REGION_ICONS[region.name] || "";
     const active = region.neurons.filter((n) => !n.isDormant);
     const dormant = region.neurons.filter((n) => n.isDormant);
-    const activation = active.reduce((sum, n) => sum + n.counter, 0);
+    const activation = active.reduce((sum, n) => sum + n.intensity, 0);
     const isBlocked = result.blockedRegions.some((r) => r.name === region.name);
     const status = region.hasBomb ? "\u{1F4A3} BOMB" : isBlocked ? "\u{1F6AB} BLOCKED" : "\u2705 ACTIVE";
     console.log(`   ${icon} ${region.name} [${status}]`);
@@ -786,7 +819,8 @@ function printDiag(brain, result) {
     }
     const top3 = sortedActive(region.neurons, 3);
     for (const n of top3) {
-      console.log(`      \u251C ${n.path} (${n.counter})`);
+      const contraStr = n.contra > 0 ? ` contra:${n.contra}` : "";
+      console.log(`      \u251C ${n.path} (counter:${n.counter}${contraStr} intensity:${n.intensity})`);
     }
   }
   console.log("");
@@ -795,7 +829,7 @@ function pathToSentence(path) {
   return path.replace(/\//g, " > ").replace(/_/g, " ");
 }
 function sortedActive(neurons, n) {
-  return [...neurons].filter((neuron) => !neuron.isDormant).sort((a, b) => b.counter - a.counter).slice(0, n);
+  return [...neurons].filter((neuron) => !neuron.isDormant).sort((a, b) => b.intensity - a.intensity).slice(0, n);
 }
 function strengthPrefix(counter) {
   if (counter >= 10) return "**[ABSOLUTE]** ";
@@ -922,46 +956,155 @@ ${template.description}
 import { createServer } from "http";
 
 // src/inbox.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync9, existsSync as existsSync11, mkdirSync as mkdirSync6 } from "fs";
-import { join as join12 } from "path";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync9, existsSync as existsSync12, mkdirSync as mkdirSync7 } from "fs";
+import { join as join13 } from "path";
+
+// src/candidates.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, readdirSync as readdirSync7, renameSync as renameSync3, rmSync, statSync as statSync3 } from "fs";
+import { join as join11, dirname as dirname2, relative as relative3 } from "path";
+var CANDIDATE_THRESHOLD = 3;
+var CANDIDATE_DECAY_DAYS = 14;
+var CANDIDATE_SEGMENT = "_candidates";
+function toCandidatePath(neuronPath) {
+  const slash = neuronPath.indexOf("/");
+  if (slash === -1) throw new Error(`Invalid neuron path (missing region): ${neuronPath}`);
+  return `${neuronPath.slice(0, slash)}/${CANDIDATE_SEGMENT}/${neuronPath.slice(slash + 1)}`;
+}
+function fromCandidatePath(candidatePath) {
+  return candidatePath.replace(`/${CANDIDATE_SEGMENT}/`, "/");
+}
+function growCandidate(brainRoot, neuronPath) {
+  const candidatePath = toCandidatePath(neuronPath);
+  const result = growNeuron(brainRoot, candidatePath);
+  if (result.counter >= CANDIDATE_THRESHOLD) {
+    const ok = moveCandidate(brainRoot, candidatePath, neuronPath);
+    return { ...result, path: ok ? neuronPath : result.path, promoted: ok };
+  }
+  console.log(`   \u{1F331} candidate (${result.counter}/${CANDIDATE_THRESHOLD}): ${candidatePath}`);
+  return { ...result, promoted: false };
+}
+function moveCandidate(brainRoot, candidatePath, targetPath) {
+  const src = join11(brainRoot, candidatePath);
+  if (!existsSync10(src)) return false;
+  const dst = join11(brainRoot, targetPath);
+  if (existsSync10(dst)) {
+    fireNeuron(brainRoot, targetPath);
+    rmSync(src, { recursive: true, force: true });
+  } else {
+    mkdirSync5(dirname2(dst), { recursive: true });
+    renameSync3(src, dst);
+  }
+  console.log(`\u{1F393} promoted: ${candidatePath} \u2192 ${targetPath}`);
+  return true;
+}
+function promoteCandidates(brainRoot) {
+  const promoted = [];
+  const decayed = [];
+  const decayMs = CANDIDATE_DECAY_DAYS * 24 * 60 * 60 * 1e3;
+  const now = Date.now();
+  for (const region of REGIONS) {
+    const candidateRoot = join11(brainRoot, region, CANDIDATE_SEGMENT);
+    walkNeuronDirs(candidateRoot, (neuronDir) => {
+      const rel = relative3(join11(brainRoot, region), neuronDir);
+      const candidatePath = `${region}/${rel}`;
+      const targetPath = fromCandidatePath(candidatePath);
+      const counter = readCounter(neuronDir);
+      const mtime = statSync3(neuronDir).mtimeMs;
+      if (counter >= CANDIDATE_THRESHOLD) {
+        moveCandidate(brainRoot, candidatePath, targetPath);
+        promoted.push(targetPath);
+      } else if (now - mtime > decayMs) {
+        rmSync(neuronDir, { recursive: true, force: true });
+        decayed.push(candidatePath);
+        console.log(`\u{1F480} candidate decayed: ${candidatePath}`);
+      }
+    });
+  }
+  return { promoted, decayed };
+}
+function listCandidates(brainRoot) {
+  const results = [];
+  const now = Date.now();
+  for (const region of REGIONS) {
+    const candidateRoot = join11(brainRoot, region, CANDIDATE_SEGMENT);
+    walkNeuronDirs(candidateRoot, (neuronDir) => {
+      const rel = relative3(join11(brainRoot, region), neuronDir);
+      const candidatePath = `${region}/${rel}`;
+      const targetPath = fromCandidatePath(candidatePath);
+      const counter = readCounter(neuronDir);
+      const mtime = statSync3(neuronDir).mtimeMs;
+      const daysInactive = Math.floor((now - mtime) / (24 * 60 * 60 * 1e3));
+      results.push({ candidatePath, targetPath, counter, daysInactive });
+    });
+  }
+  return results;
+}
+function walkNeuronDirs(dir, cb) {
+  if (!existsSync10(dir)) return;
+  try {
+    const entries = readdirSync7(dir, { withFileTypes: true });
+    const hasNeuron = entries.some((e) => e.isFile() && e.name.endsWith(".neuron"));
+    if (hasNeuron) {
+      cb(dir);
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".")) {
+        walkNeuronDirs(join11(dir, entry.name), cb);
+      }
+    }
+  } catch {
+  }
+}
+function readCounter(dir) {
+  try {
+    const files = readdirSync7(dir).filter((f) => /^\d+\.neuron$/.test(f));
+    if (files.length === 0) return 0;
+    return Math.max(...files.map((f) => parseInt(f, 10)));
+  } catch {
+    return 0;
+  }
+}
 
 // src/episode.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync3, writeFileSync as writeFileSync8, mkdirSync as mkdirSync5, existsSync as existsSync10 } from "fs";
-import { join as join11 } from "path";
+import { readdirSync as readdirSync8, readFileSync as readFileSync3, writeFileSync as writeFileSync8, mkdirSync as mkdirSync6, existsSync as existsSync11 } from "fs";
+import { join as join12 } from "path";
 var MAX_EPISODES = 100;
 var SESSION_LOG_DIR = "hippocampus/session_log";
-function logEpisode(brainRoot, type, path, detail) {
-  const logDir = join11(brainRoot, SESSION_LOG_DIR);
-  if (!existsSync10(logDir)) {
-    mkdirSync5(logDir, { recursive: true });
+function logEpisode(brainRoot, type, path, detail, extra) {
+  const logDir = join12(brainRoot, SESSION_LOG_DIR);
+  if (!existsSync11(logDir)) {
+    mkdirSync6(logDir, { recursive: true });
   }
   const nextSlot = getNextSlot(logDir);
   const episode = {
     ts: (/* @__PURE__ */ new Date()).toISOString(),
     type,
     path,
-    detail
+    detail,
+    ...extra?.outcome ? { outcome: extra.outcome } : {},
+    ...extra?.neurons ? { neurons: extra.neurons } : {}
   };
   writeFileSync8(
-    join11(logDir, `memory${nextSlot}.neuron`),
+    join12(logDir, `memory${nextSlot}.neuron`),
     JSON.stringify(episode),
     "utf8"
   );
 }
 function readEpisodes(brainRoot) {
-  const logDir = join11(brainRoot, SESSION_LOG_DIR);
-  if (!existsSync10(logDir)) return [];
+  const logDir = join12(brainRoot, SESSION_LOG_DIR);
+  if (!existsSync11(logDir)) return [];
   const episodes = [];
   let entries;
   try {
-    entries = readdirSync7(logDir);
+    entries = readdirSync8(logDir);
   } catch {
     return [];
   }
   for (const entry of entries) {
     if (!entry.startsWith("memory") || !entry.endsWith(".neuron")) continue;
     try {
-      const content = readFileSync3(join11(logDir, entry), "utf8");
+      const content = readFileSync3(join12(logDir, entry), "utf8");
       if (content.trim()) {
         episodes.push(JSON.parse(content));
       }
@@ -974,7 +1117,7 @@ function readEpisodes(brainRoot) {
 function getNextSlot(logDir) {
   let maxSlot = 0;
   try {
-    for (const entry of readdirSync7(logDir)) {
+    for (const entry of readdirSync8(logDir)) {
       if (entry.startsWith("memory") && entry.endsWith(".neuron")) {
         const n = parseInt(entry.replace("memory", "").replace(".neuron", ""), 10);
         if (!isNaN(n) && n > maxSlot) maxSlot = n;
@@ -991,8 +1134,8 @@ var INBOX_DIR = "_inbox";
 var CORRECTIONS_FILE = "corrections.jsonl";
 var DOPAMINE_ALLOWED_ROLES = ["pm", "admin", "lead"];
 function processInbox(brainRoot) {
-  const inboxPath = join12(brainRoot, INBOX_DIR, CORRECTIONS_FILE);
-  if (!existsSync11(inboxPath)) {
+  const inboxPath = join13(brainRoot, INBOX_DIR, CORRECTIONS_FILE);
+  if (!existsSync12(inboxPath)) {
     return { processed: 0, skipped: 0, errors: [] };
   }
   const content = readFileSync4(inboxPath, "utf8").trim();
@@ -1047,16 +1190,18 @@ function processInbox(brainRoot) {
 }
 function applyCorrection(brainRoot, correction) {
   const neuronPath = correction.path;
-  const fullPath = join12(brainRoot, neuronPath);
+  const fullPath = join13(brainRoot, neuronPath);
   const counterAdd = Math.max(1, correction.counter_add || 1);
-  if (existsSync11(fullPath)) {
+  if (existsSync12(fullPath)) {
     for (let i = 0; i < counterAdd; i++) {
       fireNeuron(brainRoot, neuronPath);
     }
   } else {
-    growNeuron(brainRoot, neuronPath);
-    for (let i = 1; i < counterAdd; i++) {
-      fireNeuron(brainRoot, neuronPath);
+    const candResult = growCandidate(brainRoot, neuronPath);
+    if (candResult.promoted) {
+      for (let i = 1; i < counterAdd; i++) {
+        fireNeuron(brainRoot, neuronPath);
+      }
     }
   }
   if (correction.dopamine && correction.dopamine > 0) {
@@ -1075,12 +1220,12 @@ function isPathSafe(path) {
   return true;
 }
 function ensureInbox(brainRoot) {
-  const inboxDir = join12(brainRoot, INBOX_DIR);
-  if (!existsSync11(inboxDir)) {
-    mkdirSync6(inboxDir, { recursive: true });
+  const inboxDir = join13(brainRoot, INBOX_DIR);
+  if (!existsSync12(inboxDir)) {
+    mkdirSync7(inboxDir, { recursive: true });
   }
-  const filePath = join12(inboxDir, CORRECTIONS_FILE);
-  if (!existsSync11(filePath)) {
+  const filePath = join13(inboxDir, CORRECTIONS_FILE);
+  if (!existsSync12(filePath)) {
     writeFileSync9(filePath, "", "utf8");
   }
   return filePath;
@@ -1153,10 +1298,20 @@ function json(res, data, status = 200) {
 function error(res, message, status = 400) {
   json(res, { error: message }, status);
 }
+var MAX_BODY_BYTES = 1048576;
 async function readBody(req) {
   return new Promise((resolve3, 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", () => resolve3(Buffer.concat(chunks).toString("utf8")));
     req.on("error", reject);
   });
@@ -1348,19 +1503,27 @@ function clearReports() {
 }
 
 // src/hooks.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync10, existsSync as existsSync12, mkdirSync as mkdirSync7, readdirSync as readdirSync8 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync10, existsSync as existsSync13, mkdirSync as mkdirSync8, readdirSync as readdirSync9 } from "fs";
 import { execSync as execSync2 } from "child_process";
-import { join as join13, resolve as resolve2 } from "path";
+import { join as join14, resolve as resolve2 } from "path";
 var SETTINGS_DIR = ".claude";
 var SETTINGS_FILE = "settings.local.json";
-function installHooks(brainRoot, projectRoot) {
+function installHooks(brainRoot, projectRoot, global) {
   const root = projectRoot || process.cwd();
   const resolvedBrain = resolve2(brainRoot);
-  if (!existsSync12(resolvedBrain) || !hasBrainRegions(resolvedBrain)) {
+  if (global) {
+    const home = process.env.HOME || "~";
+    if (!brainRoot.startsWith("/") && !brainRoot.startsWith(home)) {
+      console.error("\u274C --global requires an absolute --brain path (e.g. --brain ~/brain)");
+      process.exit(1);
+    }
+  }
+  if (!existsSync13(resolvedBrain) || !hasBrainRegions(resolvedBrain)) {
     initBrain(resolvedBrain);
   }
-  const settingsDir = join13(root, SETTINGS_DIR);
-  const settingsPath = join13(settingsDir, SETTINGS_FILE);
+  const settingsDir = global ? resolve2(process.env.HOME || "~", SETTINGS_DIR) : join14(root, SETTINGS_DIR);
+  const settingsFile = global ? "settings.json" : SETTINGS_FILE;
+  const settingsPath = join14(settingsDir, settingsFile);
   const defaultBrain = resolve2(root, "brain");
   const brainFlag = resolvedBrain === defaultBrain ? "" : ` --brain ${resolvedBrain}`;
   let npxBin = "npx";
@@ -1369,7 +1532,7 @@ function installHooks(brainRoot, projectRoot) {
   } catch {
   }
   let settings = {};
-  if (existsSync12(settingsPath)) {
+  if (existsSync13(settingsPath)) {
     try {
       settings = JSON.parse(readFileSync5(settingsPath, "utf8"));
     } catch {
@@ -1386,8 +1549,8 @@ function installHooks(brainRoot, projectRoot) {
       matcher: "startup|resume",
       entry: {
         type: "command",
-        command: `${npxBin} hebbian emit claude${brainFlag}`,
-        timeout: 10,
+        command: `${npxBin} hebbian emit claude${brainFlag} && ${npxBin} hebbian session start${brainFlag}`,
+        timeout: 15,
         statusMessage: `${HOOK_MARKER} refreshing brain`
       }
     },
@@ -1395,7 +1558,7 @@ function installHooks(brainRoot, projectRoot) {
       event: "Stop",
       entry: {
         type: "command",
-        command: `${npxBin} hebbian digest${brainFlag}`,
+        command: `${npxBin} hebbian digest${brainFlag}; ${npxBin} hebbian session end${brainFlag}`,
         timeout: 30,
         statusMessage: `${HOOK_MARKER} digesting session`
       }
@@ -1418,18 +1581,20 @@ function installHooks(brainRoot, projectRoot) {
       hooks[event].push(group);
     }
   }
-  if (!existsSync12(settingsDir)) {
-    mkdirSync7(settingsDir, { recursive: true });
+  if (!existsSync13(settingsDir)) {
+    mkdirSync8(settingsDir, { recursive: true });
   }
   writeFileSync10(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
   console.log(`\u2705 hebbian hooks installed at ${settingsPath}`);
   console.log(`   SessionStart \u2192 ${npxBin} hebbian emit claude${brainFlag}`);
   console.log(`   Stop \u2192 ${npxBin} hebbian digest${brainFlag}`);
 }
-function uninstallHooks(projectRoot) {
+function uninstallHooks(projectRoot, global) {
   const root = projectRoot || process.cwd();
-  const settingsPath = join13(root, SETTINGS_DIR, SETTINGS_FILE);
-  if (!existsSync12(settingsPath)) {
+  const settingsDir = global ? resolve2(process.env.HOME || "~", SETTINGS_DIR) : join14(root, SETTINGS_DIR);
+  const settingsFile = global ? "settings.json" : SETTINGS_FILE;
+  const settingsPath = join14(settingsDir, settingsFile);
+  if (!existsSync13(settingsPath)) {
     console.log("No hooks installed (settings.local.json not found)");
     return;
   }
@@ -1462,15 +1627,17 @@ function uninstallHooks(projectRoot) {
   writeFileSync10(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
   console.log(`\u2705 removed ${removed} hebbian hook(s) from ${settingsPath}`);
 }
-function checkHooks(projectRoot) {
+function checkHooks(projectRoot, global) {
   const root = projectRoot || process.cwd();
-  const settingsPath = join13(root, SETTINGS_DIR, SETTINGS_FILE);
+  const settingsDir = global ? resolve2(process.env.HOME || "~", SETTINGS_DIR) : join14(root, SETTINGS_DIR);
+  const settingsFile = global ? "settings.json" : SETTINGS_FILE;
+  const settingsPath = join14(settingsDir, settingsFile);
   const status = {
     installed: false,
     path: settingsPath,
     events: []
   };
-  if (!existsSync12(settingsPath)) {
+  if (!existsSync13(settingsPath)) {
     console.log(`\u274C hebbian hooks not installed (${settingsPath} not found)`);
     return status;
   }
@@ -1506,9 +1673,9 @@ function checkHooks(projectRoot) {
   return status;
 }
 function hasBrainRegions(dir) {
-  if (!existsSync12(dir)) return false;
+  if (!existsSync13(dir)) return false;
   try {
-    const entries = readdirSync8(dir);
+    const entries = readdirSync9(dir);
     return REGIONS.some((r) => entries.includes(r));
   } catch {
     return false;
@@ -1516,8 +1683,8 @@ function hasBrainRegions(dir) {
 }
 
 // src/digest.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync11, existsSync as existsSync13, mkdirSync as mkdirSync8 } from "fs";
-import { join as join14, basename } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync11, existsSync as existsSync14, mkdirSync as mkdirSync9 } from "fs";
+import { join as join15, basename } from "path";
 var NEGATION_PATTERNS = [
   /\bdon[''\u2019]?t\b/i,
   /\bdo not\b/i,
@@ -1568,13 +1735,13 @@ function readHookInput(stdin) {
   }
 }
 function digestTranscript(brainRoot, transcriptPath, sessionId) {
-  if (!existsSync13(transcriptPath)) {
+  if (!existsSync14(transcriptPath)) {
     throw new Error(`Transcript not found: ${transcriptPath}`);
   }
   const resolvedSessionId = sessionId || basename(transcriptPath, ".jsonl");
-  const logDir = join14(brainRoot, DIGEST_LOG_DIR);
-  const logPath = join14(logDir, `${resolvedSessionId}.jsonl`);
-  if (existsSync13(logPath)) {
+  const logDir = join15(brainRoot, DIGEST_LOG_DIR);
+  const logPath = join15(logDir, `${resolvedSessionId}.jsonl`);
+  if (existsSync14(logPath)) {
     console.log(`\u23ED already digested session ${resolvedSessionId}, skip`);
     return { corrections: 0, skipped: 0, transcriptPath, sessionId: resolvedSessionId };
   }
@@ -1589,7 +1756,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++;
@@ -1641,6 +1808,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);
@@ -1806,11 +1975,11 @@ function extractKeywords(text) {
   return text.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[^a-zA-Z0-9\u3000-\u9FFF\uAC00-\uD7AF]+/g, " ").toLowerCase().split(/\s+/).filter((t) => t.length > 2 && !STOP_WORDS.has(t));
 }
 function writeAuditLog(brainRoot, sessionId, entries) {
-  const logDir = join14(brainRoot, DIGEST_LOG_DIR);
-  if (!existsSync13(logDir)) {
-    mkdirSync8(logDir, { recursive: true });
+  const logDir = join15(brainRoot, DIGEST_LOG_DIR);
+  if (!existsSync14(logDir)) {
+    mkdirSync9(logDir, { recursive: true });
   }
-  const logPath = join14(logDir, `${sessionId}.jsonl`);
+  const logPath = join15(logDir, `${sessionId}.jsonl`);
   const lines = entries.map(
     (e) => JSON.stringify({
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1824,22 +1993,262 @@ function writeAuditLog(brainRoot, sessionId, entries) {
   writeFileSync11(logPath, lines.join("\n") + (lines.length > 0 ? "\n" : ""), "utf8");
 }
 
+// src/evolve.ts
+import { existsSync as existsSync16, readFileSync as readFileSync8, writeFileSync as writeFileSync13 } from "fs";
+import { join as join17 } from "path";
+
+// src/outcome.ts
+import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync15, mkdirSync as mkdirSync10, writeFileSync as writeFileSync12, readFileSync as readFileSync7, readdirSync as readdirSync10, rmSync as rmSync2, statSync as statSync4 } from "fs";
+import { join as join16 } from "path";
+import { randomUUID } from "crypto";
+function captureSessionStart(brainRoot) {
+  let sha;
+  try {
+    sha = execSync3("git rev-parse HEAD", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    console.log("\u23ED\uFE0F session start: not a git repo, skipping");
+    return null;
+  }
+  let status;
+  try {
+    const raw = execSync3("git status --porcelain", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    status = raw ? raw.split("\n") : [];
+  } catch {
+    status = [];
+  }
+  const brain = scanBrain(brainRoot);
+  const result = runSubsumption(brain);
+  const neurons = [];
+  for (const region of result.activeRegions) {
+    for (const neuron of region.neurons) {
+      if (!neuron.isDormant && neuron.counter > 0) {
+        neurons.push(`${region.name}/${neuron.path}`);
+      }
+    }
+  }
+  const uuid = randomUUID();
+  const stateDir = join16(brainRoot, SESSION_STATE_DIR);
+  if (!existsSync15(stateDir)) {
+    mkdirSync10(stateDir, { recursive: true });
+  }
+  const state = { ts: (/* @__PURE__ */ new Date()).toISOString(), sha, status, neurons, uuid };
+  writeFileSync12(join16(stateDir, `state_${uuid}.json`), JSON.stringify(state), "utf8");
+  console.log(`\u{1F4F8} session start: SHA ${sha.slice(0, 7)}, ${neurons.length} active neurons`);
+  return state;
+}
+function detectOutcome(brainRoot) {
+  const state = readLatestSessionState(brainRoot);
+  if (!state) {
+    console.log("\u23ED\uFE0F session end: no session state found, skipping");
+    return null;
+  }
+  let currentSha;
+  try {
+    currentSha = execSync3("git rev-parse HEAD", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    console.log("\u23ED\uFE0F session end: not a git repo, skipping");
+    cleanupSessionState(brainRoot, state.uuid);
+    return null;
+  }
+  let currentStatus;
+  try {
+    const raw = execSync3("git status --porcelain", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    currentStatus = raw ? filterHebbianPaths(raw.split("\n")) : [];
+  } catch {
+    currentStatus = [];
+  }
+  const filteredStartStatus = filterHebbianPaths(state.status);
+  const outcome = classifyOutcome(
+    { ...state, status: filteredStartStatus },
+    currentSha,
+    currentStatus
+  );
+  if (!outcome) {
+    console.log("\u{1F4CA} session end: no changes detected (no-op)");
+    cleanupSessionState(brainRoot, state.uuid);
+    return null;
+  }
+  const neurons = state.neurons;
+  logEpisode(brainRoot, "session-end", "", `outcome:${outcome}`, { outcome, neurons });
+  let result;
+  if (outcome === "revert") {
+    const { affected, skipped } = applyContra(brainRoot, neurons);
+    result = {
+      outcome: "revert",
+      neuronsAffected: affected,
+      protectedSkipped: skipped,
+      detail: `${affected} neurons contra'd (${skipped} protected skipped)`
+    };
+    console.log(`\u{1F4CA} session end: revert \u2014 ${result.detail}`);
+  } else {
+    result = {
+      outcome: "acceptance",
+      neuronsAffected: 0,
+      protectedSkipped: 0,
+      detail: "changes accepted"
+    };
+    console.log("\u{1F4CA} session end: acceptance");
+  }
+  cleanupSessionState(brainRoot, state.uuid);
+  return result;
+}
+function classifyOutcome(state, currentSha, currentStatus) {
+  const headMoved = state.sha !== currentSha;
+  const startStatusSet = new Set(state.status);
+  const endStatusSet = new Set(currentStatus);
+  const newItems = currentStatus.filter((s) => !startStatusSet.has(s));
+  const removedItems = state.status.filter((s) => !endStatusSet.has(s));
+  if (!headMoved) {
+    if (newItems.length === 0 && removedItems.length === 0) {
+      return null;
+    }
+    if (newItems.length > 0) {
+      return "acceptance";
+    }
+    if (removedItems.length > 0) {
+      return "revert";
+    }
+    return null;
+  }
+  if (newItems.length > 0) {
+    return "acceptance";
+  }
+  try {
+    const diffStat = execSync3(
+      `git diff ${state.sha}..${currentSha} --stat`,
+      { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    const logOutput = execSync3(
+      `git log --oneline ${state.sha}..${currentSha}`,
+      { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    if (/\brevert\b/i.test(logOutput)) {
+      return "revert";
+    }
+    if (!diffStat) {
+      return "revert";
+    }
+    return "acceptance";
+  } catch {
+    return null;
+  }
+}
+function applyContra(brainRoot, neurons) {
+  let affected = 0;
+  let skipped = 0;
+  for (const neuronPath of neurons) {
+    const region = neuronPath.split("/")[0] || "";
+    if (PROTECTED_REGIONS_CONTRA.includes(region)) {
+      skipped++;
+      continue;
+    }
+    const result = contraNeuron(brainRoot, neuronPath);
+    if (result > 0) {
+      affected++;
+    }
+  }
+  return { affected, skipped };
+}
+function buildOutcomeSummary(brainRoot) {
+  const episodes = readEpisodes(brainRoot);
+  const outcomeEpisodes = episodes.filter((e) => e.outcome && e.neurons);
+  if (outcomeEpisodes.length === 0) return "";
+  const stats = /* @__PURE__ */ new Map();
+  for (const ep of outcomeEpisodes) {
+    for (const neuron of ep.neurons) {
+      const existing = stats.get(neuron) || { sessions: 0, reverts: 0, acceptances: 0 };
+      existing.sessions++;
+      if (ep.outcome === "revert") existing.reverts++;
+      if (ep.outcome === "acceptance") existing.acceptances++;
+      stats.set(neuron, existing);
+    }
+  }
+  const lines = ["## Outcome Signals (from session history)\n"];
+  lines.push("Neurons with high contra_ratio (>0.5) are consistently present in reverted sessions. Consider pruning or modifying them.\n");
+  const sorted = [...stats.entries()].sort((a, b) => {
+    const ratioA = a[1].sessions > 0 ? a[1].reverts / a[1].sessions : 0;
+    const ratioB = b[1].sessions > 0 ? b[1].reverts / b[1].sessions : 0;
+    return ratioB - ratioA;
+  });
+  for (const [neuron, s] of sorted) {
+    const ratio = s.sessions > 0 ? (s.reverts / s.sessions).toFixed(2) : "0.00";
+    const trend = parseFloat(ratio) > 0.5 ? "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 = join16(brainRoot, SESSION_STATE_DIR);
+  if (!existsSync15(stateDir)) return null;
+  let latest = null;
+  try {
+    for (const entry of readdirSync10(stateDir)) {
+      if (!entry.startsWith("state_") || !entry.endsWith(".json")) continue;
+      const fullPath = join16(stateDir, entry);
+      const mtime = statSync4(fullPath).mtimeMs;
+      if (!latest || mtime > latest.mtime) {
+        latest = { path: fullPath, mtime };
+      }
+    }
+  } catch {
+    return null;
+  }
+  if (!latest) return null;
+  try {
+    return JSON.parse(readFileSync7(latest.path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function filterHebbianPaths(statusLines) {
+  const hebbianPatterns = ["hippocampus/session_state", "hippocampus/session_log", "hippocampus/digest_log", "_inbox/"];
+  return statusLines.filter(
+    (line) => !hebbianPatterns.some((p) => line.includes(p))
+  );
+}
+function cleanupSessionState(brainRoot, uuid) {
+  const stateDir = join16(brainRoot, SESSION_STATE_DIR);
+  const filePath = join16(stateDir, `state_${uuid}.json`);
+  try {
+    if (existsSync15(filePath)) rmSync2(filePath);
+  } catch {
+  }
+}
+
 // src/evolve.ts
 var MAX_ACTIONS = 10;
 var PROTECTED_REGIONS = ["brainstem", "limbic", "sensors"];
 var DEFAULT_MODEL = "gemini-2.0-flash-lite";
 var API_TIMEOUT = 3e4;
 var RETRY_DELAY = 5e3;
+var EVOLVE_COOLDOWN_FILE = "hippocampus/evolve_last_run";
 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 = join17(brainRoot, EVOLVE_COOLDOWN_FILE);
+    if (existsSync16(cooldownPath)) {
+      const lastRun = parseInt(readFileSync8(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);
@@ -1865,6 +2274,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`);
+  writeFileSync13(join17(brainRoot, EVOLVE_COOLDOWN_FILE), String(Date.now()), "utf8");
   return { actions, executed, skipped, dryRun: false };
 }
 function buildBrainSummary(brain) {
@@ -1887,8 +2297,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
@@ -1900,6 +2315,7 @@ function buildPrompt(summary, episodes) {
 ## Current Brain
 ${summary}
 
+${outcomeSection}
 ## Recent Episodes (last ${episodes.length})
 ${episodeLines}
 
@@ -1925,7 +2341,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: {
@@ -1941,7 +2357,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)
       });
@@ -1995,6 +2411,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)`);
@@ -2020,7 +2440,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");
@@ -2068,15 +2488,23 @@ export {
   MAX_CORRECTIONS_PER_SESSION,
   MAX_DEPTH,
   MIN_CORRECTION_LENGTH,
+  OUTCOME_TYPES,
+  PROTECTED_REGIONS_CONTRA,
   REGIONS,
   REGION_ICONS,
   REGION_KO,
   REGION_PRIORITY,
+  SESSION_STATE_DIR,
   SIGNAL_TYPES,
   SPOTLIGHT_DAYS,
   appendCorrection,
+  buildOutcomeSummary,
+  captureSessionStart,
   checkHooks,
+  classifyOutcome,
   clearReports,
+  contraNeuron,
+  detectOutcome,
   digestTranscript,
   emitBootstrap,
   emitIndex,
@@ -2085,17 +2513,21 @@ export {
   ensureInbox,
   extractCorrections,
   fireNeuron,
+  fromCandidatePath,
   getCurrentCounter,
   getLastActivity,
   getPendingReports,
   gitSnapshot,
+  growCandidate,
   growNeuron,
   initBrain,
   installHooks,
   jaccardSimilarity,
+  listCandidates,
   logEpisode,
   printDiag,
   processInbox,
+  promoteCandidates,
   readEpisodes,
   readHookInput,
   resolveBrainRoot,
@@ -2109,6 +2541,7 @@ export {
   startAPI,
   startWatch,
   stem,
+  toCandidatePath,
   tokenize,
   uninstallHooks,
   writeAllTiers