hebbian 0.3.2 → 0.3.4

package/dist/bin/hebbian.js

@@ -555,6 +555,8 @@ function writeTarget(filePath, content) {
       writeFileSync2(filePath, before + content + after, "utf8");
       return;
     }
+    writeFileSync2(filePath, content + "\n\n" + existing, "utf8");
+    return;
   }
   writeFileSync2(filePath, content, "utf8");
 }
@@ -607,28 +609,174 @@ var init_emit = __esm({
   }
 });
 
+// src/update-check.ts
+var update_check_exports = {};
+__export(update_check_exports, {
+  checkForUpdates: () => checkForUpdates,
+  formatUpdateBanner: () => formatUpdateBanner
+});
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, statSync as statSync2, unlinkSync } from "fs";
+import { join as join4 } from "path";
+function getStateDir() {
+  return join4(process.env.HOME || "~", ".hebbian");
+}
+function ensureStateDir(stateDir) {
+  if (!existsSync5(stateDir)) {
+    mkdirSync3(stateDir, { recursive: true });
+  }
+}
+function isCacheStale(cachePath, type) {
+  try {
+    const mtime = statSync2(cachePath).mtimeMs;
+    const ageMinutes = (Date.now() - mtime) / 1e3 / 60;
+    const ttl = type === "UP_TO_DATE" ? TTL_UP_TO_DATE : TTL_UPGRADE_AVAILABLE;
+    return ageMinutes > ttl;
+  } catch {
+    return true;
+  }
+}
+function readCache(stateDir) {
+  const cachePath = join4(stateDir, "last-update-check");
+  if (!existsSync5(cachePath)) return null;
+  try {
+    const line = readFileSync3(cachePath, "utf8").trim();
+    if (line.startsWith("UP_TO_DATE")) {
+      if (isCacheStale(cachePath, "UP_TO_DATE")) return null;
+      const ver = line.split(/\s+/)[1];
+      return { type: "UP_TO_DATE", current: ver };
+    }
+    if (line.startsWith("UPGRADE_AVAILABLE")) {
+      if (isCacheStale(cachePath, "UPGRADE_AVAILABLE")) return null;
+      const [, current, latest] = line.split(/\s+/);
+      return { type: "UPGRADE_AVAILABLE", current, latest };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writeCache(stateDir, line) {
+  ensureStateDir(stateDir);
+  writeFileSync3(join4(stateDir, "last-update-check"), line, "utf8");
+}
+function isSnoozed(stateDir, remoteVersion) {
+  const snoozePath = join4(stateDir, "update-snoozed");
+  if (!existsSync5(snoozePath)) return false;
+  try {
+    const [ver, levelStr, epochStr] = readFileSync3(snoozePath, "utf8").trim().split(/\s+/);
+    if (ver !== remoteVersion) {
+      unlinkSync(snoozePath);
+      return false;
+    }
+    const level = parseInt(levelStr || "1", 10);
+    const epoch = parseInt(epochStr || "0", 10);
+    const now = Math.floor(Date.now() / 1e3);
+    const duration = SNOOZE_DURATIONS[Math.min(level, 3)] ?? SNOOZE_DURATIONS[3];
+    return now < epoch + duration;
+  } catch {
+    return false;
+  }
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const res = await fetch(NPM_REGISTRY_URL, {
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    clearTimeout(timeout);
+    if (!res.ok) return null;
+    const data = await res.json();
+    const version = data.version;
+    if (!version || !/^\d+\.\d+[\d.]*$/.test(version)) return null;
+    return version;
+  } catch {
+    return null;
+  }
+}
+async function checkForUpdates(currentVersion) {
+  if (process.env.HEBBIAN_UPDATE_CHECK === "false") {
+    return { type: "skipped" };
+  }
+  const stateDir = getStateDir();
+  const cached = readCache(stateDir);
+  if (cached) {
+    if (cached.type === "UP_TO_DATE") {
+      return { type: "up_to_date" };
+    }
+    if (cached.type === "UPGRADE_AVAILABLE" && cached.current && cached.latest) {
+      if (cached.current === currentVersion && !isSnoozed(stateDir, cached.latest)) {
+        return { type: "upgrade_available", current: currentVersion, latest: cached.latest };
+      }
+    }
+  }
+  const latest = await fetchLatestVersion();
+  if (!latest) {
+    writeCache(stateDir, `UP_TO_DATE ${currentVersion}`);
+    return { type: "up_to_date" };
+  }
+  if (latest === currentVersion) {
+    writeCache(stateDir, `UP_TO_DATE ${currentVersion}`);
+    return { type: "up_to_date" };
+  }
+  writeCache(stateDir, `UPGRADE_AVAILABLE ${currentVersion} ${latest}`);
+  if (isSnoozed(stateDir, latest)) {
+    return { type: "up_to_date" };
+  }
+  return { type: "upgrade_available", current: currentVersion, latest };
+}
+function formatUpdateBanner(status) {
+  if (status.type !== "upgrade_available") return null;
+  return [
+    ``,
+    `  \u26A1 hebbian v${status.latest} available (current: v${status.current})`,
+    `     npm i -g hebbian@latest`,
+    ``
+  ].join("\n");
+}
+var PACKAGE_NAME, NPM_REGISTRY_URL, FETCH_TIMEOUT_MS, TTL_UP_TO_DATE, TTL_UPGRADE_AVAILABLE, SNOOZE_DURATIONS;
+var init_update_check = __esm({
+  "src/update-check.ts"() {
+    "use strict";
+    PACKAGE_NAME = "hebbian";
+    NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+    FETCH_TIMEOUT_MS = 5e3;
+    TTL_UP_TO_DATE = 60;
+    TTL_UPGRADE_AVAILABLE = 720;
+    SNOOZE_DURATIONS = {
+      1: 86400,
+      // 24h
+      2: 172800,
+      // 48h
+      3: 604800
+      // 7d (and beyond)
+    };
+  }
+});
+
 // src/fire.ts
 var fire_exports = {};
 __export(fire_exports, {
   fireNeuron: () => fireNeuron,
   getCurrentCounter: () => getCurrentCounter
 });
-import { readdirSync as readdirSync3, renameSync, writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
-import { join as join4 } from "path";
+import { readdirSync as readdirSync3, renameSync, writeFileSync as writeFileSync4, existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { join as join5 } from "path";
 function fireNeuron(brainRoot, neuronPath) {
-  const fullPath = join4(brainRoot, neuronPath);
-  if (!existsSync5(fullPath)) {
-    mkdirSync3(fullPath, { recursive: true });
-    writeFileSync3(join4(fullPath, "1.neuron"), "", "utf8");
+  const fullPath = join5(brainRoot, neuronPath);
+  if (!existsSync6(fullPath)) {
+    mkdirSync4(fullPath, { recursive: true });
+    writeFileSync4(join5(fullPath, "1.neuron"), "", "utf8");
     console.log(`\u{1F331} grew + fired: ${neuronPath} (1)`);
     return 1;
   }
   const current = getCurrentCounter(fullPath);
   const newCounter = current + 1;
   if (current > 0) {
-    renameSync(join4(fullPath, `${current}.neuron`), join4(fullPath, `${newCounter}.neuron`));
+    renameSync(join5(fullPath, `${current}.neuron`), join5(fullPath, `${newCounter}.neuron`));
   } else {
-    writeFileSync3(join4(fullPath, `${newCounter}.neuron`), "", "utf8");
+    writeFileSync4(join5(fullPath, `${newCounter}.neuron`), "", "utf8");
   }
   console.log(`\u{1F525} fired: ${neuronPath} (${current} \u2192 ${newCounter})`);
   return newCounter;
@@ -654,7 +802,7 @@ var init_fire = __esm({
 
 // src/similarity.ts
 function tokenize(name) {
-  return name.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[_\-\s]+/g, " ").toLowerCase().split(" ").map(stem).filter((t) => t.length > 1);
+  return name.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9\u3000-\u9FFF\uAC00-\uD7AF]+/g, " ").toLowerCase().split(" ").map(stem).filter((t) => t.length > 1);
 }
 function stem(word) {
   const suffixes = ["ing", "tion", "sion", "ness", "ment", "able", "ible", "ful", "less", "ous", "ive", "ity", "ies", "ed", "er", "es", "ly", "al", "en"];
@@ -688,11 +836,11 @@ var grow_exports = {};
 __export(grow_exports, {
   growNeuron: () => growNeuron
 });
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, existsSync as existsSync6, readdirSync as readdirSync4 } from "fs";
-import { join as join5, relative as relative2 } from "path";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, existsSync as existsSync7, readdirSync as readdirSync4 } from "fs";
+import { join as join6, relative as relative2 } from "path";
 function growNeuron(brainRoot, neuronPath) {
-  const fullPath = join5(brainRoot, neuronPath);
-  if (existsSync6(fullPath)) {
+  const fullPath = join6(brainRoot, neuronPath);
+  if (existsSync7(fullPath)) {
     const counter = fireNeuron(brainRoot, neuronPath);
     return { action: "fired", path: neuronPath, counter };
   }
@@ -702,10 +850,12 @@ function growNeuron(brainRoot, neuronPath) {
     throw new Error(`Invalid region: ${regionName}. Valid: ${REGIONS.join(", ")}`);
   }
   const leafName = parts[parts.length - 1];
-  const newTokens = tokenize(leafName);
-  const regionPath = join5(brainRoot, regionName);
-  if (existsSync6(regionPath)) {
-    const match = findSimilar(regionPath, regionPath, newTokens);
+  const newPrefix = leafName.match(/^(NO|DO|MUST|WARN)_/)?.[1] || "";
+  const newStripped = leafName.replace(/^(NO|DO|MUST|WARN)_/, "");
+  const newTokens = tokenize(newStripped);
+  const regionPath = join6(brainRoot, regionName);
+  if (existsSync7(regionPath)) {
+    const match = findSimilar(regionPath, regionPath, newTokens, newPrefix);
     if (match) {
       const matchRelPath = regionName + "/" + relative2(regionPath, match);
       console.log(`\u{1F504} consolidation: "${neuronPath}" \u2248 "${matchRelPath}" (firing existing)`);
@@ -713,12 +863,12 @@ function growNeuron(brainRoot, neuronPath) {
       return { action: "fired", path: matchRelPath, counter };
     }
   }
-  mkdirSync4(fullPath, { recursive: true });
-  writeFileSync4(join5(fullPath, "1.neuron"), "", "utf8");
+  mkdirSync5(fullPath, { recursive: true });
+  writeFileSync5(join6(fullPath, "1.neuron"), "", "utf8");
   console.log(`\u{1F331} grew: ${neuronPath} (1)`);
   return { action: "grew", path: neuronPath, counter: 1 };
 }
-function findSimilar(dir, regionRoot, targetTokens) {
+function findSimilar(dir, regionRoot, targetTokens, targetPrefix) {
   let entries;
   try {
     entries = readdirSync4(dir, { withFileTypes: true });
@@ -728,16 +878,19 @@ function findSimilar(dir, regionRoot, targetTokens) {
   const hasNeuron = entries.some((e) => e.isFile() && e.name.endsWith(".neuron"));
   if (hasNeuron) {
     const folderName = dir.split("/").pop() || "";
-    const existingTokens = tokenize(folderName);
+    const existingPrefix = folderName.match(/^(NO|DO|MUST|WARN)_/)?.[1] || "";
+    const existingStripped = folderName.replace(/^(NO|DO|MUST|WARN)_/, "");
+    const existingTokens = tokenize(existingStripped);
     const similarity = jaccardSimilarity(targetTokens, existingTokens);
-    if (similarity >= JACCARD_THRESHOLD) {
+    if (targetPrefix !== existingPrefix && targetTokens.length <= 2) {
+    } else if (similarity >= JACCARD_THRESHOLD) {
       return dir;
     }
   }
   for (const entry of entries) {
     if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
     if (entry.isDirectory()) {
-      const match = findSimilar(join5(dir, entry.name), regionRoot, targetTokens);
+      const match = findSimilar(join6(dir, entry.name), regionRoot, targetTokens, targetPrefix);
       if (match) return match;
     }
   }
@@ -758,9 +911,9 @@ __export(rollback_exports, {
   rollbackNeuron: () => rollbackNeuron
 });
 import { renameSync as renameSync2 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 function rollbackNeuron(brainRoot, neuronPath) {
-  const fullPath = join6(brainRoot, neuronPath);
+  const fullPath = join7(brainRoot, neuronPath);
   const current = getCurrentCounter(fullPath);
   if (current === 0) {
     throw new Error(`Neuron not found: ${neuronPath}`);
@@ -769,7 +922,7 @@ function rollbackNeuron(brainRoot, neuronPath) {
     throw new Error(`Counter already at minimum (1): ${neuronPath}`);
   }
   const newCounter = current - 1;
-  renameSync2(join6(fullPath, `${current}.neuron`), join6(fullPath, `${newCounter}.neuron`));
+  renameSync2(join7(fullPath, `${current}.neuron`), join7(fullPath, `${newCounter}.neuron`));
   console.log(`\u23EA rollback: ${neuronPath} (${current} \u2192 ${newCounter})`);
   return newCounter;
 }
@@ -785,31 +938,31 @@ var signal_exports = {};
 __export(signal_exports, {
   signalNeuron: () => signalNeuron
 });
-import { writeFileSync as writeFileSync5, existsSync as existsSync7, readdirSync as readdirSync5 } from "fs";
-import { join as join7 } from "path";
+import { writeFileSync as writeFileSync6, existsSync as existsSync8, readdirSync as readdirSync5 } from "fs";
+import { join as join8 } from "path";
 function signalNeuron(brainRoot, neuronPath, signalType) {
   if (!SIGNAL_TYPES.includes(signalType)) {
     throw new Error(`Invalid signal type: ${signalType}. Valid: ${SIGNAL_TYPES.join(", ")}`);
   }
-  const fullPath = join7(brainRoot, neuronPath);
-  if (!existsSync7(fullPath)) {
+  const fullPath = join8(brainRoot, neuronPath);
+  if (!existsSync8(fullPath)) {
     throw new Error(`Neuron not found: ${neuronPath}`);
   }
   switch (signalType) {
     case "bomb": {
-      writeFileSync5(join7(fullPath, "bomb.neuron"), "", "utf8");
+      writeFileSync6(join8(fullPath, "bomb.neuron"), "", "utf8");
       console.log(`\u{1F4A3} bomb planted: ${neuronPath}`);
       break;
     }
     case "dopamine": {
       const level = getNextSignalLevel(fullPath, "dopamine");
-      writeFileSync5(join7(fullPath, `dopamine${level}.neuron`), "", "utf8");
+      writeFileSync6(join8(fullPath, `dopamine${level}.neuron`), "", "utf8");
       console.log(`\u{1F7E2} dopamine +${level}: ${neuronPath}`);
       break;
     }
     case "memory": {
       const level = getNextSignalLevel(fullPath, "memory");
-      writeFileSync5(join7(fullPath, `memory${level}.neuron`), "", "utf8");
+      writeFileSync6(join8(fullPath, `memory${level}.neuron`), "", "utf8");
       console.log(`\u{1F4BE} memory +${level}: ${neuronPath}`);
       break;
     }
@@ -840,15 +993,15 @@ var decay_exports = {};
 __export(decay_exports, {
   runDecay: () => runDecay
 });
-import { readdirSync as readdirSync6, statSync as statSync2, writeFileSync as writeFileSync6, existsSync as existsSync8 } from "fs";
-import { join as join8 } from "path";
+import { readdirSync as readdirSync6, statSync as statSync3, writeFileSync as writeFileSync7, existsSync as existsSync9 } from "fs";
+import { join as join9 } from "path";
 function runDecay(brainRoot, days) {
   const threshold = Date.now() - days * 24 * 60 * 60 * 1e3;
   let scanned = 0;
   let decayed = 0;
   for (const regionName of REGIONS) {
-    const regionPath = join8(brainRoot, regionName);
-    if (!existsSync8(regionPath)) continue;
+    const regionPath = join9(brainRoot, regionName);
+    if (!existsSync9(regionPath)) continue;
     const result = decayWalk(regionPath, threshold, 0);
     scanned += result.scanned;
     decayed += result.decayed;
@@ -874,7 +1027,7 @@ function decayWalk(dir, threshold, depth) {
       if (entry.name.endsWith(".neuron")) {
         hasNeuronFile = true;
         try {
-          const st = statSync2(join8(dir, entry.name));
+          const st = statSync3(join9(dir, entry.name));
           if (st.mtimeMs > latestMod) latestMod = st.mtimeMs;
         } catch {
         }
@@ -888,8 +1041,8 @@ function decayWalk(dir, threshold, depth) {
     scanned++;
     if (!isDormant && latestMod < threshold) {
       const age = Math.floor((Date.now() - latestMod) / (24 * 60 * 60 * 1e3));
-      writeFileSync6(
-        join8(dir, "decay.dormant"),
+      writeFileSync7(
+        join9(dir, "decay.dormant"),
         `Dormant since ${(/* @__PURE__ */ new Date()).toISOString()} (${age} days inactive)`,
         "utf8"
       );
@@ -899,7 +1052,7 @@ function decayWalk(dir, threshold, depth) {
   for (const entry of entries) {
     if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
     if (entry.isDirectory()) {
-      const sub = decayWalk(join8(dir, entry.name), threshold, depth + 1);
+      const sub = decayWalk(join9(dir, entry.name), threshold, depth + 1);
       scanned += sub.scanned;
       decayed += sub.decayed;
     }
@@ -918,8 +1071,8 @@ var dedup_exports = {};
 __export(dedup_exports, {
   runDedup: () => runDedup
 });
-import { writeFileSync as writeFileSync7 } from "fs";
-import { join as join9 } from "path";
+import { writeFileSync as writeFileSync8 } from "fs";
+import { join as join10 } from "path";
 function runDedup(brainRoot) {
   const brain = scanBrain(brainRoot);
   let scanned = 0;
@@ -941,8 +1094,8 @@ function runDedup(brainRoot) {
           const [keep, drop] = ni.counter >= nj.counter ? [ni, nj] : [nj, ni];
           const relKeep = `${region.name}/${keep.path}`;
           fireNeuron(brainRoot, relKeep);
-          writeFileSync7(
-            join9(drop.fullPath, "dedup.dormant"),
+          writeFileSync8(
+            join10(drop.fullPath, "dedup.dormant"),
             `Merged into ${keep.path} on ${(/* @__PURE__ */ new Date()).toISOString()}`,
             "utf8"
           );
@@ -972,10 +1125,10 @@ __export(snapshot_exports, {
   gitSnapshot: () => gitSnapshot
 });
 import { execSync } from "child_process";
-import { existsSync as existsSync9 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join11 } from "path";
 function gitSnapshot(brainRoot) {
-  if (!existsSync9(join10(brainRoot, ".git"))) {
+  if (!existsSync10(join11(brainRoot, ".git"))) {
     try {
       execSync("git rev-parse --is-inside-work-tree", { cwd: brainRoot, stdio: "pipe" });
     } catch {
@@ -1064,12 +1217,12 @@ var init_watch = __esm({
 });
 
 // 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 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 = join11(brainRoot, SESSION_LOG_DIR);
-  if (!existsSync10(logDir)) {
-    mkdirSync5(logDir, { recursive: true });
+  const logDir = join12(brainRoot, SESSION_LOG_DIR);
+  if (!existsSync11(logDir)) {
+    mkdirSync6(logDir, { recursive: true });
   }
   const nextSlot = getNextSlot(logDir);
   const episode = {
@@ -1078,12 +1231,35 @@ function logEpisode(brainRoot, type, path, detail) {
     path,
     detail
   };
-  writeFileSync8(
-    join11(logDir, `memory${nextSlot}.neuron`),
+  writeFileSync9(
+    join12(logDir, `memory${nextSlot}.neuron`),
     JSON.stringify(episode),
     "utf8"
   );
 }
+function readEpisodes(brainRoot) {
+  const logDir = join12(brainRoot, SESSION_LOG_DIR);
+  if (!existsSync11(logDir)) return [];
+  const episodes = [];
+  let entries;
+  try {
+    entries = readdirSync7(logDir);
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    if (!entry.startsWith("memory") || !entry.endsWith(".neuron")) continue;
+    try {
+      const content = readFileSync4(join12(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 {
@@ -1114,14 +1290,14 @@ __export(inbox_exports, {
   ensureInbox: () => ensureInbox,
   processInbox: () => processInbox
 });
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync9, existsSync as existsSync11, mkdirSync as mkdirSync6 } from "fs";
-import { join as join12 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync10, existsSync as existsSync12, mkdirSync as mkdirSync7 } from "fs";
+import { join as join13 } from "path";
 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();
+  const content = readFileSync5(inboxPath, "utf8").trim();
   if (!content) {
     return { processed: 0, skipped: 0, errors: [] };
   }
@@ -1162,7 +1338,7 @@ function processInbox(brainRoot) {
       skipped++;
     }
   }
-  writeFileSync9(inboxPath, "", "utf8");
+  writeFileSync10(inboxPath, "", "utf8");
   console.log(`\u{1F4E5} inbox: processed ${processed}, skipped ${skipped}`);
   if (errors.length > 0) {
     for (const err of errors) {
@@ -1173,9 +1349,9 @@ 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);
     }
@@ -1201,21 +1377,21 @@ 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)) {
-    writeFileSync9(filePath, "", "utf8");
+  const filePath = join13(inboxDir, CORRECTIONS_FILE);
+  if (!existsSync12(filePath)) {
+    writeFileSync10(filePath, "", "utf8");
   }
   return filePath;
 }
 function appendCorrection(brainRoot, correction) {
   const filePath = ensureInbox(brainRoot);
   const line = JSON.stringify(correction) + "\n";
-  const existing = readFileSync4(filePath, "utf8");
-  writeFileSync9(filePath, existing + line, "utf8");
+  const existing = readFileSync5(filePath, "utf8");
+  writeFileSync10(filePath, existing + line, "utf8");
 }
 var INBOX_DIR, CORRECTIONS_FILE, DOPAMINE_ALLOWED_ROLES;
 var init_inbox = __esm({
@@ -1519,22 +1695,28 @@ __export(hooks_exports, {
   installHooks: () => installHooks,
   uninstallHooks: () => uninstallHooks
 });
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync10, existsSync as existsSync12, mkdirSync as mkdirSync7, readdirSync as readdirSync8 } from "fs";
-import { join as join13, resolve as resolve2 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync11, existsSync as existsSync13, mkdirSync as mkdirSync8, readdirSync as readdirSync8 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { join as join14, resolve as resolve2 } from "path";
 function installHooks(brainRoot, projectRoot) {
   const root = projectRoot || process.cwd();
   const resolvedBrain = resolve2(brainRoot);
-  if (!existsSync12(resolvedBrain) || !hasBrainRegions(resolvedBrain)) {
+  if (!existsSync13(resolvedBrain) || !hasBrainRegions(resolvedBrain)) {
     initBrain(resolvedBrain);
   }
-  const settingsDir = join13(root, SETTINGS_DIR);
-  const settingsPath = join13(settingsDir, SETTINGS_FILE);
+  const settingsDir = join14(root, SETTINGS_DIR);
+  const settingsPath = join14(settingsDir, SETTINGS_FILE);
   const defaultBrain = resolve2(root, "brain");
   const brainFlag = resolvedBrain === defaultBrain ? "" : ` --brain ${resolvedBrain}`;
+  let npxBin = "npx";
+  try {
+    npxBin = execSync2("which npx", { encoding: "utf8" }).trim();
+  } catch {
+  }
   let settings = {};
-  if (existsSync12(settingsPath)) {
+  if (existsSync13(settingsPath)) {
     try {
-      settings = JSON.parse(readFileSync5(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync6(settingsPath, "utf8"));
     } catch {
       console.log(`\u26A0\uFE0F  settings.local.json was malformed, overwriting`);
     }
@@ -1549,7 +1731,7 @@ function installHooks(brainRoot, projectRoot) {
       matcher: "startup|resume",
       entry: {
         type: "command",
-        command: `hebbian emit claude${brainFlag}`,
+        command: `${npxBin} hebbian emit claude${brainFlag}`,
         timeout: 10,
         statusMessage: `${HOOK_MARKER} refreshing brain`
       }
@@ -1558,7 +1740,7 @@ function installHooks(brainRoot, projectRoot) {
       event: "Stop",
       entry: {
         type: "command",
-        command: `hebbian digest${brainFlag}`,
+        command: `${npxBin} hebbian digest${brainFlag}`,
         timeout: 30,
         statusMessage: `${HOOK_MARKER} digesting session`
       }
@@ -1581,24 +1763,24 @@ 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");
+  writeFileSync11(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
   console.log(`\u2705 hebbian hooks installed at ${settingsPath}`);
-  console.log(`   SessionStart \u2192 hebbian emit claude${brainFlag}`);
-  console.log(`   Stop \u2192 hebbian digest${brainFlag}`);
+  console.log(`   SessionStart \u2192 ${npxBin} hebbian emit claude${brainFlag}`);
+  console.log(`   Stop \u2192 ${npxBin} hebbian digest${brainFlag}`);
 }
 function uninstallHooks(projectRoot) {
   const root = projectRoot || process.cwd();
-  const settingsPath = join13(root, SETTINGS_DIR, SETTINGS_FILE);
-  if (!existsSync12(settingsPath)) {
+  const settingsPath = join14(root, SETTINGS_DIR, SETTINGS_FILE);
+  if (!existsSync13(settingsPath)) {
     console.log("No hooks installed (settings.local.json not found)");
     return;
   }
   let settings;
   try {
-    settings = JSON.parse(readFileSync5(settingsPath, "utf8"));
+    settings = JSON.parse(readFileSync6(settingsPath, "utf8"));
   } catch {
     console.log("settings.local.json is malformed, nothing to uninstall");
     return;
@@ -1622,24 +1804,24 @@ function uninstallHooks(projectRoot) {
   if (Object.keys(hooks).length === 0) {
     delete settings.hooks;
   }
-  writeFileSync10(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  writeFileSync11(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
   console.log(`\u2705 removed ${removed} hebbian hook(s) from ${settingsPath}`);
 }
 function checkHooks(projectRoot) {
   const root = projectRoot || process.cwd();
-  const settingsPath = join13(root, SETTINGS_DIR, SETTINGS_FILE);
+  const settingsPath = join14(root, SETTINGS_DIR, SETTINGS_FILE);
   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;
   }
   let settings;
   try {
-    settings = JSON.parse(readFileSync5(settingsPath, "utf8"));
+    settings = JSON.parse(readFileSync6(settingsPath, "utf8"));
   } catch {
     console.log(`\u274C settings.local.json is malformed`);
     return status;
@@ -1669,7 +1851,7 @@ function checkHooks(projectRoot) {
   return status;
 }
 function hasBrainRegions(dir) {
-  if (!existsSync12(dir)) return false;
+  if (!existsSync13(dir)) return false;
   try {
     const entries = readdirSync8(dir);
     return REGIONS.some((r) => entries.includes(r));
@@ -1695,8 +1877,8 @@ __export(digest_exports, {
   extractCorrections: () => extractCorrections,
   readHookInput: () => readHookInput
 });
-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 readFileSync7, writeFileSync as writeFileSync12, existsSync as existsSync14, mkdirSync as mkdirSync9 } from "fs";
+import { join as join15, basename } from "path";
 function readHookInput(stdin) {
   if (!stdin.trim()) return null;
   try {
@@ -1711,13 +1893,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 };
   }
@@ -1751,7 +1933,7 @@ function digestTranscript(brainRoot, transcriptPath, sessionId) {
   };
 }
 function parseTranscript(transcriptPath) {
-  const content = readFileSync6(transcriptPath, "utf8");
+  const content = readFileSync7(transcriptPath, "utf8");
   const lines = content.split("\n").filter(Boolean);
   const messages = [];
   for (const line of lines) {
@@ -1793,17 +1975,24 @@ function extractCorrections(messages) {
 }
 function detectCorrection(text) {
   const isNegation = NEGATION_PATTERNS.some((p) => p.test(text));
+  const isMust = MUST_PATTERNS.some((p) => p.test(text));
+  const isWarn = WARN_PATTERNS.some((p) => p.test(text));
   const isAffirmation = AFFIRMATION_PATTERNS.some((p) => p.test(text));
-  if (!isNegation && !isAffirmation) return null;
-  const prefix = isNegation ? "NO" : "DO";
+  if (!isNegation && !isMust && !isWarn && !isAffirmation) return null;
+  let prefix;
+  if (isNegation) prefix = "NO";
+  else if (isMust) prefix = "MUST";
+  else if (isWarn) prefix = "WARN";
+  else prefix = "DO";
   const keywords = extractKeywords(text);
   if (keywords.length === 0) return null;
-  const pathSegment = `${prefix}_${keywords.slice(0, 4).join("_")}`;
+  const pathSegment = `${prefix}_${keywords.slice(0, 3).join("_")}`;
   const path = `cortex/${pathSegment}`;
   return { text, path, prefix, keywords };
 }
 function extractKeywords(text) {
   const STOP_WORDS = /* @__PURE__ */ new Set([
+    // English stop words
     "the",
     "a",
     "an",
@@ -1885,7 +2074,6 @@ function extractKeywords(text) {
     "those",
     "it",
     "its",
-    "i",
     "me",
     "my",
     "we",
@@ -1914,17 +2102,40 @@ function extractKeywords(text) {
     "should",
     "like",
     "want",
-    "think"
+    "think",
+    "way",
+    "make",
+    "sure",
+    "keep",
+    "try",
+    "let",
+    "get",
+    "put",
+    "set",
+    "new",
+    "also",
+    "using",
+    "used",
+    "when",
+    "where",
+    "how",
+    "why",
+    "here",
+    "there",
+    "careful",
+    "warning",
+    "watch",
+    "out",
+    "required"
   ]);
-  const tokens = tokenize(text);
-  return tokens.filter((t) => !STOP_WORDS.has(t) && t.length > 2);
+  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(),
@@ -1935,16 +2146,15 @@ function writeAuditLog(brainRoot, sessionId, entries) {
       applied: e.applied
     })
   );
-  writeFileSync11(logPath, lines.join("\n") + (lines.length > 0 ? "\n" : ""), "utf8");
+  writeFileSync12(logPath, lines.join("\n") + (lines.length > 0 ? "\n" : ""), "utf8");
 }
-var NEGATION_PATTERNS, AFFIRMATION_PATTERNS;
+var NEGATION_PATTERNS, AFFIRMATION_PATTERNS, MUST_PATTERNS, WARN_PATTERNS;
 var init_digest = __esm({
   "src/digest.ts"() {
     "use strict";
     init_constants();
     init_grow();
     init_episode();
-    init_similarity();
     NEGATION_PATTERNS = [
       /\bdon[''\u2019]?t\b/i,
       /\bdo not\b/i,
@@ -1963,13 +2173,281 @@ var init_digest = __esm({
     ];
     AFFIRMATION_PATTERNS = [
       /\balways\b/i,
-      /\bmust\b/i,
       /\bshould\s+always\b/i,
       /\buse\s+\w+\s+instead\b/i,
       // Korean affirmation
-      /항상/,
+      /항상/
+    ];
+    MUST_PATTERNS = [
+      /\bmust\b/i,
+      /\brequired\b/i,
+      // Korean
       /반드시/
     ];
+    WARN_PATTERNS = [
+      /\bcareful\b/i,
+      /\bwatch\s+out\b/i,
+      /\bwarning\b/i,
+      // Korean
+      /주의/
+    ];
+  }
+});
+
+// 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 prompt = buildPrompt(summary, episodes);
+  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) {
+  const episodeLines = episodes.length > 0 ? episodes.map((e) => `- [${e.ts}] ${e.type}: ${e.path} \u2014 ${e.detail}`).join("\n") : "(no recent episodes)";
+  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}
+
+## 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":
+          growNeuron(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_grow();
+    init_signal();
+    init_rollback();
+    init_decay();
+    MAX_ACTIONS = 10;
+    PROTECTED_REGIONS = ["brainstem", "limbic", "sensors"];
+    DEFAULT_MODEL = "gemini-2.0-flash-lite";
+    API_TIMEOUT = 3e4;
+    RETRY_DELAY = 5e3;
   }
 });
 
@@ -2001,6 +2479,7 @@ COMMANDS:
   inbox                           Process corrections inbox
   claude install|uninstall|status Manage Claude Code hooks
   digest [--transcript <path>]    Extract corrections from conversation
+  evolve [--dry-run]              LLM-powered brain evolution (Gemini)
   diag                            Print brain diagnostics
   stats                           Print brain statistics
 
@@ -2015,6 +2494,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) => {
@@ -2040,6 +2520,7 @@ async function main(argv) {
       days: { type: "string", short: "d" },
       port: { type: "string", short: "p" },
       transcript: { type: "string", short: "t" },
+      "dry-run": { type: "boolean" },
       help: { type: "boolean", short: "h" },
       version: { type: "boolean", short: "v" }
     },
@@ -2075,6 +2556,12 @@ async function main(argv) {
       }
       const { emitToTarget: emitToTarget2 } = await Promise.resolve().then(() => (init_emit(), emit_exports));
       await emitToTarget2(brainRoot, target);
+      const { checkForUpdates: checkForUpdates2, formatUpdateBanner: formatUpdateBanner2 } = await Promise.resolve().then(() => (init_update_check(), update_check_exports));
+      checkForUpdates2(VERSION).then((status) => {
+        const banner = formatUpdateBanner2(status);
+        if (banner) console.error(banner);
+      }).catch(() => {
+      });
       break;
     }
     case "fire": {
@@ -2164,9 +2651,15 @@ async function main(argv) {
         case "uninstall":
           uninstallHooks2();
           break;
-        case "status":
+        case "status": {
           checkHooks2();
+          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);
+          const updateBanner = formatBanner(updateStatus);
+          if (updateBanner) console.error(updateBanner);
           break;
+        }
         default:
           console.error("Usage: hebbian claude <install|uninstall|status>");
           process.exit(1);
@@ -2191,6 +2684,12 @@ async function main(argv) {
       }
       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 "diag":
     case "stats": {
       const { scanBrain: scanBrain2 } = await Promise.resolve().then(() => (init_scanner(), scanner_exports));