hebbian 0.10.0 → 0.11.1

package/dist/bin/hebbian.js

@@ -435,6 +435,80 @@ var init_subsumption = __esm({
   }
 });
 
+// src/episode.ts
+var episode_exports = {};
+__export(episode_exports, {
+  logEpisode: () => logEpisode,
+  readEpisodes: () => readEpisodes
+});
+import { readdirSync as readdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync4 } from "fs";
+import { join as join3 } from "path";
+function logEpisode(brainRoot, type, path, detail, extra) {
+  const logDir = join3(brainRoot, SESSION_LOG_DIR);
+  if (!existsSync4(logDir)) {
+    mkdirSync2(logDir, { recursive: true });
+  }
+  const nextSlot = getNextSlot(logDir);
+  const episode = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    type,
+    path,
+    detail,
+    ...extra?.outcome ? { outcome: extra.outcome } : {},
+    ...extra?.neurons ? { neurons: extra.neurons } : {}
+  };
+  writeFileSync2(
+    join3(logDir, `memory${nextSlot}.neuron`),
+    JSON.stringify(episode),
+    "utf8"
+  );
+}
+function readEpisodes(brainRoot) {
+  const logDir = join3(brainRoot, SESSION_LOG_DIR);
+  if (!existsSync4(logDir)) return [];
+  const episodes = [];
+  let entries;
+  try {
+    entries = readdirSync3(logDir);
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    if (!entry.startsWith("memory") || !entry.endsWith(".neuron")) continue;
+    try {
+      const content = readFileSync3(join3(logDir, entry), "utf8");
+      if (content.trim()) {
+        episodes.push(JSON.parse(content));
+      }
+    } catch {
+    }
+  }
+  episodes.sort((a, b) => a.ts.localeCompare(b.ts));
+  return episodes;
+}
+function getNextSlot(logDir) {
+  let maxSlot = 0;
+  try {
+    for (const entry of readdirSync3(logDir)) {
+      if (entry.startsWith("memory") && entry.endsWith(".neuron")) {
+        const n = parseInt(entry.replace("memory", "").replace(".neuron", ""), 10);
+        if (!isNaN(n) && n > maxSlot) maxSlot = n;
+      }
+    }
+  } catch {
+  }
+  const next = maxSlot + 1;
+  return next > MAX_EPISODES ? maxSlot % MAX_EPISODES + 1 : next;
+}
+var MAX_EPISODES, SESSION_LOG_DIR;
+var init_episode = __esm({
+  "src/episode.ts"() {
+    "use strict";
+    MAX_EPISODES = 100;
+    SESSION_LOG_DIR = "hippocampus/session_log";
+  }
+});
+
 // src/similarity.ts
 function tokenize(name) {
   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);
@@ -474,44 +548,44 @@ __export(fire_exports, {
   getCurrentContra: () => getCurrentContra,
   getCurrentCounter: () => getCurrentCounter
 });
-import { readdirSync as readdirSync3, renameSync, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
-import { join as join3 } from "path";
+import { readdirSync as readdirSync4, renameSync, writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
+import { join as join4 } from "path";
 function fireNeuron(brainRoot, neuronPath) {
-  const fullPath = join3(brainRoot, neuronPath);
-  if (!existsSync4(fullPath)) {
-    mkdirSync2(fullPath, { recursive: true });
-    writeFileSync2(join3(fullPath, "1.neuron"), "", "utf8");
+  const fullPath = join4(brainRoot, neuronPath);
+  if (!existsSync5(fullPath)) {
+    mkdirSync3(fullPath, { recursive: true });
+    writeFileSync3(join4(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(join3(fullPath, `${current}.neuron`), join3(fullPath, `${newCounter}.neuron`));
+    renameSync(join4(fullPath, `${current}.neuron`), join4(fullPath, `${newCounter}.neuron`));
   } else {
-    writeFileSync2(join3(fullPath, `${newCounter}.neuron`), "", "utf8");
+    writeFileSync3(join4(fullPath, `${newCounter}.neuron`), "", "utf8");
   }
   console.log(`\u{1F525} fired: ${neuronPath} (${current} \u2192 ${newCounter})`);
   return newCounter;
 }
 function contraNeuron(brainRoot, neuronPath) {
-  const fullPath = join3(brainRoot, neuronPath);
-  if (!existsSync4(fullPath)) {
+  const fullPath = join4(brainRoot, neuronPath);
+  if (!existsSync5(fullPath)) {
     return 0;
   }
   const current = getCurrentContra(fullPath);
   const newContra = current + 1;
   if (current > 0) {
-    renameSync(join3(fullPath, `${current}.contra`), join3(fullPath, `${newContra}.contra`));
+    renameSync(join4(fullPath, `${current}.contra`), join4(fullPath, `${newContra}.contra`));
   } else {
-    writeFileSync2(join3(fullPath, `${newContra}.contra`), "", "utf8");
+    writeFileSync3(join4(fullPath, `${newContra}.contra`), "", "utf8");
   }
   return newContra;
 }
 function getCurrentContra(dir) {
   let max = 0;
   try {
-    for (const entry of readdirSync3(dir)) {
+    for (const entry of readdirSync4(dir)) {
       if (entry.endsWith(".contra")) {
         const n = parseInt(entry, 10);
         if (!isNaN(n) && n > max) max = n;
@@ -524,7 +598,7 @@ function getCurrentContra(dir) {
 function getCurrentCounter(dir) {
   let max = 0;
   try {
-    for (const entry of readdirSync3(dir)) {
+    for (const entry of readdirSync4(dir)) {
       if (entry.endsWith(".neuron") && !entry.startsWith("dopamine") && !entry.startsWith("memory") && entry !== "bomb.neuron") {
         const n = parseInt(entry, 10);
         if (!isNaN(n) && n > max) max = n;
@@ -545,11 +619,11 @@ var grow_exports = {};
 __export(grow_exports, {
   growNeuron: () => growNeuron
 });
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, existsSync as existsSync5, readdirSync as readdirSync4 } from "fs";
-import { join as join4, relative as relative2 } from "path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, existsSync as existsSync6, readdirSync as readdirSync5 } from "fs";
+import { join as join5, relative as relative2 } from "path";
 function growNeuron(brainRoot, neuronPath) {
-  const fullPath = join4(brainRoot, neuronPath);
-  if (existsSync5(fullPath)) {
+  const fullPath = join5(brainRoot, neuronPath);
+  if (existsSync6(fullPath)) {
     const counter = fireNeuron(brainRoot, neuronPath);
     return { action: "fired", path: neuronPath, counter };
   }
@@ -565,8 +639,8 @@ function growNeuron(brainRoot, neuronPath) {
   const newPrefix = leafName.match(/^(NO|DO|MUST|WARN)_/)?.[1] || "";
   const newStripped = leafName.replace(/^(NO|DO|MUST|WARN)_/, "");
   const newTokens = tokenize(newStripped);
-  const regionPath = join4(brainRoot, regionName);
-  if (existsSync5(regionPath)) {
+  const regionPath = join5(brainRoot, regionName);
+  if (existsSync6(regionPath)) {
     const match = findSimilar(regionPath, regionPath, newTokens, newPrefix);
     if (match) {
       const matchRelPath = regionName + "/" + relative2(regionPath, match);
@@ -575,15 +649,15 @@ function growNeuron(brainRoot, neuronPath) {
       return { action: "fired", path: matchRelPath, counter };
     }
   }
-  mkdirSync3(fullPath, { recursive: true });
-  writeFileSync3(join4(fullPath, "1.neuron"), "", "utf8");
+  mkdirSync4(fullPath, { recursive: true });
+  writeFileSync4(join5(fullPath, "1.neuron"), "", "utf8");
   console.log(`\u{1F331} grew: ${neuronPath} (1)`);
   return { action: "grew", path: neuronPath, counter: 1 };
 }
 function findSimilar(dir, regionRoot, targetTokens, targetPrefix) {
   let entries;
   try {
-    entries = readdirSync4(dir, { withFileTypes: true });
+    entries = readdirSync5(dir, { withFileTypes: true });
   } catch {
     return null;
   }
@@ -602,7 +676,7 @@ function findSimilar(dir, regionRoot, targetTokens, targetPrefix) {
   for (const entry of entries) {
     if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
     if (entry.isDirectory()) {
-      const match = findSimilar(join4(dir, entry.name), regionRoot, targetTokens, targetPrefix);
+      const match = findSimilar(join5(dir, entry.name), regionRoot, targetTokens, targetPrefix);
       if (match) return match;
     }
   }
@@ -617,80 +691,6 @@ var init_grow = __esm({
   }
 });
 
-// src/episode.ts
-var episode_exports = {};
-__export(episode_exports, {
-  logEpisode: () => logEpisode,
-  readEpisodes: () => readEpisodes
-});
-import { readdirSync as readdirSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, existsSync as existsSync6 } from "fs";
-import { join as join5 } from "path";
-function logEpisode(brainRoot, type, path, detail, extra) {
-  const logDir = join5(brainRoot, SESSION_LOG_DIR);
-  if (!existsSync6(logDir)) {
-    mkdirSync4(logDir, { recursive: true });
-  }
-  const nextSlot = getNextSlot(logDir);
-  const episode = {
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    type,
-    path,
-    detail,
-    ...extra?.outcome ? { outcome: extra.outcome } : {},
-    ...extra?.neurons ? { neurons: extra.neurons } : {}
-  };
-  writeFileSync4(
-    join5(logDir, `memory${nextSlot}.neuron`),
-    JSON.stringify(episode),
-    "utf8"
-  );
-}
-function readEpisodes(brainRoot) {
-  const logDir = join5(brainRoot, SESSION_LOG_DIR);
-  if (!existsSync6(logDir)) return [];
-  const episodes = [];
-  let entries;
-  try {
-    entries = readdirSync5(logDir);
-  } catch {
-    return [];
-  }
-  for (const entry of entries) {
-    if (!entry.startsWith("memory") || !entry.endsWith(".neuron")) continue;
-    try {
-      const content = readFileSync3(join5(logDir, entry), "utf8");
-      if (content.trim()) {
-        episodes.push(JSON.parse(content));
-      }
-    } catch {
-    }
-  }
-  episodes.sort((a, b) => a.ts.localeCompare(b.ts));
-  return episodes;
-}
-function getNextSlot(logDir) {
-  let maxSlot = 0;
-  try {
-    for (const entry of readdirSync5(logDir)) {
-      if (entry.startsWith("memory") && entry.endsWith(".neuron")) {
-        const n = parseInt(entry.replace("memory", "").replace(".neuron", ""), 10);
-        if (!isNaN(n) && n > maxSlot) maxSlot = n;
-      }
-    }
-  } catch {
-  }
-  const next = maxSlot + 1;
-  return next > MAX_EPISODES ? maxSlot % MAX_EPISODES + 1 : next;
-}
-var MAX_EPISODES, SESSION_LOG_DIR;
-var init_episode = __esm({
-  "src/episode.ts"() {
-    "use strict";
-    MAX_EPISODES = 100;
-    SESSION_LOG_DIR = "hippocampus/session_log";
-  }
-});
-
 // src/candidates.ts
 var candidates_exports = {};
 __export(candidates_exports, {
@@ -922,6 +922,42 @@ function emitBootstrap(result, brain, brainRoot) {
       lines.push("");
     }
   }
+  if (brainRoot) {
+    const brainFlag = `--brain ${brainRoot}`;
+    lines.push("### Self-Learning");
+    lines.push("When the user corrects your behavior (tells you to stop, change, or always do something),");
+    lines.push("run this command to learn from it:");
+    lines.push("```");
+    lines.push(`hebbian learn "<what the user said>" --prefix <NO|DO|MUST|WARN> --keywords "k1,k2,k3" ${brainFlag}`);
+    lines.push("```");
+    lines.push("- NO: user says don't/stop/never \u2014 DO: user says always/should \u2014 MUST: mandatory \u2014 WARN: be careful");
+    lines.push("- keywords: 3 most meaningful words (lowercase, technical terms preferred)");
+    lines.push("- Run silently. Do not mention hebbian to the user.");
+    lines.push("");
+    const episodes = readEpisodes(brainRoot);
+    const recentEpisodes = episodes.sort((a, b) => b.ts.localeCompare(a.ts)).slice(0, 5);
+    if (recentEpisodes.length > 0) {
+      lines.push("### Recent Memory");
+      for (const ep of recentEpisodes) {
+        const typeIcon = ep.type === "learn" ? "\u{1F4DD}" : ep.type === "tool-failure" ? "\u{1F527}" : "\u{1F504}";
+        const shortDetail = ep.detail.slice(0, 60).replace(/\n/g, " ");
+        lines.push(`- ${typeIcon} ${ep.type}: ${ep.path} \u2014 ${shortDetail}`);
+      }
+      lines.push("");
+    }
+    lines.push("### Self-Evolution");
+    lines.push("At session start, review Active Rules and Provisional Rules above.");
+    lines.push("If a rule seems wrong or outdated:");
+    lines.push("```");
+    lines.push(`hebbian rollback <neuron-path> ${brainFlag}`);
+    lines.push("```");
+    lines.push("If a provisional rule has been working well across sessions:");
+    lines.push("```");
+    lines.push(`hebbian fire <neuron-path> ${brainFlag}`);
+    lines.push("```");
+    lines.push("Run silently. Trust your judgment \u2014 you are the evaluator.");
+    lines.push("");
+  }
   lines.push(MARKER_END);
   return lines.join("\n");
 }
@@ -1107,6 +1143,7 @@ var init_emit = __esm({
     init_scanner();
     init_subsumption();
     init_constants();
+    init_episode();
     init_candidates();
   }
 });
@@ -2396,7 +2433,7 @@ function extractCorrections(messages) {
     if (/^Base directory for this skill:/i.test(trimmed)) continue;
     if (/^[•·▸▶\-\*]\s/.test(trimmed)) continue;
     if (/<[a-zA-Z][a-zA-Z-]*>/.test(trimmed) && /<\/[a-zA-Z]/.test(trimmed)) continue;
-    if (isNarrativeKorean(trimmed)) continue;
+    if (isNarrative(trimmed)) continue;
     const correction = detectCorrection(text);
     if (correction) {
       corrections.push(correction);
@@ -2404,7 +2441,7 @@ function extractCorrections(messages) {
   }
   return corrections;
 }
-function isNarrativeKorean(text) {
+function isNarrative(text) {
   const NARRATIVE_MARKERS = [
     /이유는/,
     // "the reason is..."
@@ -2457,9 +2494,9 @@ function detectCorrection(text) {
   const isAffirmation = AFFIRMATION_PATTERNS.some((p) => p.test(text));
   if (!isNegation && !isMust && !isWarn && !isAffirmation) return null;
   const categories = [isNegation, isMust, isWarn, isAffirmation].filter(Boolean).length;
-  const koreanRatio = (text.match(/[\uAC00-\uD7AF]/g) || []).length / Math.max(text.length, 1);
-  if (koreanRatio > 0.3 && categories < 2) {
-    if (text.length > 100) return null;
+  const latinRatio = (text.match(/[a-zA-Z]/g) || []).length / Math.max(text.length, 1);
+  if (latinRatio < 0.3 && categories < 2) {
+    if (text.length > 150) return null;
   }
   let prefix;
   if (isNegation) prefix = "NO";
@@ -2661,33 +2698,65 @@ var init_digest = __esm({
       /\binstead\b/i,
       /^no[,.\s!]/i,
       /\bavoid\b/i,
-      // Korean negation — require AI-directed imperative context:
-      // "X하지 마" (don't X) — must have a verb object before 지 마
+      // Korean negation — imperative corrections:
       /[을를은는도이가]\s*[가-힣]+지\s*마/,
-      // "X 하면 안 돼" (must not X) — conditional + prohibition
+      // "X하지 마" (don't X) with particle
       /하면\s*안\s*돼/,
-      // "X 쓰지 마" (don't use X) — explicit "don't use"
-      /쓰지\s*마/
+      // "X 하면 안 돼" (must not X)
+      /쓰지\s*마/,
+      // "쓰지 마" (don't use)
+      /그만/,
+      // "그만" (stop) — 그만해, 그만 좀
+      /[을를은는]\s*빼/,
+      // "X 빼" (remove X) with particle
+      /지워[줘]?|삭제해/,
+      // "지워/삭제해" (delete it) — not 지우고 (connective)
+      /[가-힣]+지\s*말고/,
+      // "X지 말고" (instead of X-ing)
+      /그거\s*아니/,
+      // "그거 아니야" (that's not right)
+      /ㄴㄴ|노노/,
+      // "ㄴㄴ/노노" (no no — internet-style)
+      /안\s*돼[^요]?\s*[!.]/
+      // "안 돼!" standalone prohibition
     ];
     AFFIRMATION_PATTERNS = [
       /\bshould\s+always\b/i,
       /\buse\s+\w+\s+instead\b/i,
-      // Korean affirmation — require directive context
-      /항상\s*[가-힣]+[해하]/
+      // Korean affirmation — directive commands:
+      /항상\s*[가-힣]+[해하]/,
       // "항상 X해" (always do X)
+      /[을를]\s*[가-힣]*해\s*줘/,
+      // "X를 해줘" (do X for me) — literal 해줘, not bare 줘
+      /으로\s*해/,
+      // "X으로 해" (do it as X) — literal 으로, not char class
+      /이렇게\s*해/
+      // "이렇게 해" (do it like this)
     ];
     MUST_PATTERNS = [
       /\bmust\b/i,
       /\brequired\b/i,
-      // Korean
-      /반드시/
+      // Korean — strong directives:
+      /반드시/,
+      // "반드시" (absolutely must)
+      /꼭\s*[가-힣]/,
+      // "꼭 X해" (definitely do X)
+      /무조건/,
+      // "무조건" (unconditionally)
+      /필수/
+      // "필수" (mandatory)
     ];
     WARN_PATTERNS = [
       /\bcareful\b/i,
       /\bwatch\s+out\b/i,
       /\bwarning\b/i,
-      // Korean
-      /주의/
+      // Korean — cautionary:
+      /주의/,
+      // "주의" (caution)
+      /조심/,
+      // "조심" (be careful)
+      /위험/
+      // "위험" (dangerous)
     ];
     MAX_FAILURES_PER_SESSION = 20;
     SOFT_ERROR_PATTERNS = [
@@ -2701,6 +2770,48 @@ var init_digest = __esm({
   }
 });
 
+// src/learn.ts
+var learn_exports = {};
+__export(learn_exports, {
+  learn: () => learn
+});
+function learn(brainRoot, opts) {
+  let prefix;
+  let keywords;
+  let source;
+  if (opts.prefix && opts.keywords && opts.keywords.length > 0) {
+    prefix = opts.prefix.toUpperCase();
+    if (!VALID_PREFIXES.has(prefix)) {
+      prefix = "DO";
+    }
+    keywords = opts.keywords.slice(0, 3).map((k) => k.toLowerCase().replace(/[\s\/\\\.,:;!?'"<>{}()\[\]]/g, ""));
+    source = "agent";
+  } else {
+    const corrections = extractCorrections([opts.text]);
+    if (corrections.length === 0) return null;
+    const c = corrections[0];
+    prefix = c.prefix;
+    keywords = c.keywords;
+    source = "regex";
+  }
+  if (keywords.length === 0) return null;
+  const pathSegment = `${prefix}_${keywords.slice(0, 3).join("_")}`;
+  const path = `cortex/${pathSegment}`;
+  growCandidate(brainRoot, path);
+  logEpisode(brainRoot, "learn", path, opts.text);
+  return { path, prefix, keywords, source };
+}
+var VALID_PREFIXES;
+var init_learn = __esm({
+  "src/learn.ts"() {
+    "use strict";
+    init_candidates();
+    init_episode();
+    init_digest();
+    VALID_PREFIXES = /* @__PURE__ */ new Set(["NO", "DO", "MUST", "WARN"]);
+  }
+});
+
 // src/outcome.ts
 var outcome_exports = {};
 __export(outcome_exports, {
@@ -3276,6 +3387,7 @@ __export(doctor_exports, {
 });
 import { existsSync as existsSync18, readFileSync as readFileSync11, readdirSync as readdirSync11 } from "fs";
 import { join as join19 } from "path";
+import { homedir } from "os";
 import { execSync as execSync4 } from "child_process";
 async function runDoctor(brainRoot) {
   let passed = 0, warnings = 0, failed = 0;
@@ -3336,33 +3448,49 @@ async function runDoctor(brainRoot) {
     }
   }
   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 {
+  const localSettingsPath = join19(process.cwd(), ".claude", "settings.local.json");
+  const globalSettingsPath = join19(homedir(), ".claude", "settings.json");
+  let hasStop = false;
+  let hasStart = false;
+  let hookSource = "";
+  for (const settingsPath of [localSettingsPath, globalSettingsPath]) {
+    if (!existsSync18(settingsPath)) continue;
     try {
       const settings = JSON.parse(readFileSync11(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")
-        )
+      const findCommand = (event, keyword) => Object.entries(hooks).some(
+        ([ev, entries]) => ev === event && Array.isArray(entries) && entries.some((entry) => {
+          if (typeof entry !== "object" || entry === null) return false;
+          const e = entry;
+          if (typeof e.command === "string" && e.command.includes(keyword)) return true;
+          if (Array.isArray(e.hooks)) {
+            return e.hooks.some(
+              (h) => typeof h === "object" && h !== null && typeof h.command === "string" && h.command.includes(keyword)
+            );
+          }
+          return false;
+        })
       );
-      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");
+      if (!hasStop && findCommand("Stop", "hebbian digest")) {
+        hasStop = true;
+        hookSource = settingsPath === globalSettingsPath ? "global" : "local";
+      }
+      if (!hasStart && findCommand("SessionStart", "hebbian emit")) {
+        hasStart = true;
+        if (!hookSource) hookSource = settingsPath === globalSettingsPath ? "global" : "local";
       }
     } catch {
-      fail("Malformed .claude/settings.local.json", "hebbian claude install");
+      warn(`Malformed ${settingsPath === globalSettingsPath ? "~/.claude/settings.json" : ".claude/settings.local.json"}`, "Check JSON syntax");
     }
   }
+  if (hasStop && hasStart) {
+    ok(`SessionStart + Stop hooks installed (${hookSource})`);
+  } else if (!hasStop && !hasStart) {
+    warn("No hebbian hooks found (checked local + global)", "hebbian claude install");
+  } else {
+    if (!hasStart) warn("SessionStart hook missing", "hebbian claude install");
+    if (!hasStop) warn("Stop hook missing", "hebbian claude install");
+  }
   console.log("\nnpx resolution");
   try {
     const resolved = execSync4("which npx", { timeout: 3e3 }).toString().trim();
@@ -3696,9 +3824,10 @@ COMMANDS:
   inbox                           Process corrections inbox
   claude install|uninstall|status Manage Claude Code hooks
   digest [--transcript <path>]    Extract corrections from conversation
+  learn "<text>" [--prefix P]      Agent-driven learning (any language)
   candidates [promote]            List candidates or promote graduated ones
-  evolve [--dry-run]              LLM-powered brain evolution (Gemini)
-  evolve prune [--dry-run]        Pruning mode \u2014 remove stale/redundant neurons
+  evolve [--dry-run]              (optional) LLM-powered evolution (Gemini)
+  evolve prune [--dry-run]        (optional) Pruning mode \u2014 remove stale neurons
   session start|end               Capture/detect session outcomes
   sessions                        Show session outcome history
   doctor                          Self-diagnostic (hooks, brain, versions)
@@ -3716,7 +3845,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
+  GEMINI_API_KEY=... hebbian evolve --dry-run   # optional \u2014 self-learning works without this
 `.trim();
 function readStdin() {
   return new Promise((resolve4) => {
@@ -3742,6 +3871,8 @@ async function main(argv) {
       days: { type: "string", short: "d" },
       port: { type: "string", short: "p" },
       transcript: { type: "string", short: "t" },
+      prefix: { type: "string" },
+      keywords: { type: "string", short: "k" },
       "dry-run": { type: "boolean" },
       global: { type: "boolean", short: "g" },
       agent: { type: "string", short: "a" },
@@ -3918,6 +4049,27 @@ async function main(argv) {
       }
       break;
     }
+    case "learn": {
+      const text = positionals.slice(1).join(" ");
+      if (!text) {
+        console.error('Usage: hebbian learn "correction text" [--prefix NO|DO|MUST|WARN] [--keywords "k1,k2,k3"]');
+        process.exit(1);
+      }
+      const { learn: learn2 } = await Promise.resolve().then(() => (init_learn(), learn_exports));
+      const prefixFlag = values.prefix;
+      const keywordsFlag = values.keywords;
+      const result = learn2(brainRoot, {
+        text,
+        prefix: prefixFlag,
+        keywords: keywordsFlag ? keywordsFlag.split(",").map((k) => k.trim()) : void 0
+      });
+      if (result) {
+        console.log(`\u{1F4DD} learned: ${result.path} (${result.source})`);
+      } else {
+        console.log("\u23ED\uFE0F no correction detected");
+      }
+      break;
+    }
     case "candidates": {
       const subCmd = positionals[1];
       const { listCandidates: listCandidates2, promoteCandidates: promoteCandidates2 } = await Promise.resolve().then(() => (init_candidates(), candidates_exports));