hebbian 0.9.0 → 0.11.0

package/dist/index.js

@@ -614,9 +614,205 @@ function gitSnapshot(brainRoot) {
 import { watch } from "fs";
 
 // src/emit.ts
-import { existsSync as existsSync8, readFileSync as readFileSync2, writeFileSync as writeFileSync6, mkdirSync as mkdirSync3 } from "fs";
-import { join as join9, dirname } from "path";
-function emitBootstrap(result, brain) {
+import { existsSync as existsSync10, readFileSync as readFileSync3, writeFileSync as writeFileSync7, mkdirSync as mkdirSync5 } from "fs";
+import { join as join11, dirname as dirname2 } from "path";
+
+// src/candidates.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readdirSync as readdirSync7, renameSync as renameSync3, rmSync, statSync as statSync3 } from "fs";
+import { join as join10, dirname, relative as relative3 } from "path";
+
+// src/episode.ts
+import { readdirSync as readdirSync6, readFileSync as readFileSync2, writeFileSync as writeFileSync6, mkdirSync as mkdirSync3, existsSync as existsSync8 } from "fs";
+import { join as join9 } from "path";
+var MAX_EPISODES = 100;
+var SESSION_LOG_DIR = "hippocampus/session_log";
+function logEpisode(brainRoot, type, path, detail, extra) {
+  const logDir = join9(brainRoot, SESSION_LOG_DIR);
+  if (!existsSync8(logDir)) {
+    mkdirSync3(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 } : {}
+  };
+  writeFileSync6(
+    join9(logDir, `memory${nextSlot}.neuron`),
+    JSON.stringify(episode),
+    "utf8"
+  );
+}
+function readEpisodes(brainRoot) {
+  const logDir = join9(brainRoot, SESSION_LOG_DIR);
+  if (!existsSync8(logDir)) return [];
+  const episodes = [];
+  let entries;
+  try {
+    entries = readdirSync6(logDir);
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    if (!entry.startsWith("memory") || !entry.endsWith(".neuron")) continue;
+    try {
+      const content = readFileSync2(join9(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 readdirSync6(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;
+}
+
+// src/candidates.ts
+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);
+    if (ok) propagateToShared(brainRoot, 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 = join10(brainRoot, candidatePath);
+  if (!existsSync9(src)) return false;
+  const dst = join10(brainRoot, targetPath);
+  if (existsSync9(dst)) {
+    fireNeuron(brainRoot, targetPath);
+    rmSync(src, { recursive: true, force: true });
+  } else {
+    mkdirSync4(dirname(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 = join10(brainRoot, region, CANDIDATE_SEGMENT);
+    walkNeuronDirs(candidateRoot, (neuronDir) => {
+      const rel = relative3(join10(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);
+        propagateToShared(brainRoot, 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 = join10(brainRoot, region, CANDIDATE_SEGMENT);
+    walkNeuronDirs(candidateRoot, (neuronDir) => {
+      const rel = relative3(join10(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 (!existsSync9(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(join10(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;
+  }
+}
+function propagateToShared(brainRoot, targetPath) {
+  try {
+    const agentsIdx = brainRoot.indexOf("/agents/");
+    if (agentsIdx === -1) return false;
+    const multiBrainRoot = brainRoot.slice(0, agentsIdx);
+    const sharedRoot = join10(multiBrainRoot, "shared");
+    if (!existsSync9(sharedRoot)) return false;
+    const episodes = readEpisodes(brainRoot);
+    const neuronName = targetPath.split("/").pop() || "";
+    const hasRelevantEpisode = episodes.some(
+      (ep) => PROPAGATION_EPISODE_TYPES.includes(ep.type) && (ep.path.includes(neuronName) || ep.detail.includes(neuronName))
+    );
+    if (!hasRelevantEpisode) return false;
+    growNeuron(sharedRoot, targetPath);
+    console.log(`   \u{1F4E1} propagated to shared: ${targetPath}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/emit.ts
+function emitBootstrap(result, brain, brainRoot) {
   const lines = [];
   const now = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+Z$/, "");
   lines.push(MARKER_START);
@@ -672,6 +868,32 @@ function emitBootstrap(result, brain) {
     lines.push(`| ${icon} ${region.name} | ${active.length} | ${activation} |`);
   }
   lines.push("");
+  if (brainRoot) {
+    const candidates = listCandidates(brainRoot);
+    if (candidates.length > 0) {
+      const top = candidates.slice(0, 5);
+      lines.push("### Provisional Rules (evaluating)");
+      lines.push("Follow these during this session. They graduate after 3 sessions.");
+      for (const c of top) {
+        const bar = "\u2588".repeat(c.counter) + "\u2591".repeat(Math.max(0, 3 - c.counter));
+        lines.push(`- ${bar} ${pathToSentence(c.targetPath)}`);
+      }
+      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("");
+  }
   lines.push(MARKER_END);
   return lines.join("\n");
 }
@@ -766,7 +988,7 @@ function emitRegionRules(region) {
 function emitToTarget(brainRoot, target) {
   const brain = scanBrain(brainRoot);
   const result = runSubsumption(brain);
-  const content = emitBootstrap(result, brain);
+  const content = emitBootstrap(result, brain, brainRoot);
   if (target === "all") {
     for (const [name, filePath] of Object.entries(EMIT_TARGETS)) {
       writeTarget(filePath, content);
@@ -782,33 +1004,33 @@ function emitToTarget(brainRoot, target) {
 }
 function writeAllTiers(brainRoot, result, brain) {
   const indexContent = emitIndex(result, brain);
-  writeFileSync6(join9(brainRoot, "_index.md"), indexContent, "utf8");
+  writeFileSync7(join11(brainRoot, "_index.md"), indexContent, "utf8");
   for (const region of result.activeRegions) {
-    if (existsSync8(region.path)) {
+    if (existsSync10(region.path)) {
       const rulesContent = emitRegionRules(region);
-      writeFileSync6(join9(region.path, "_rules.md"), rulesContent, "utf8");
+      writeFileSync7(join11(region.path, "_rules.md"), rulesContent, "utf8");
     }
   }
 }
 function writeTarget(filePath, content) {
-  const dir = dirname(filePath);
-  if (dir !== "." && !existsSync8(dir)) {
-    mkdirSync3(dir, { recursive: true });
+  const dir = dirname2(filePath);
+  if (dir !== "." && !existsSync10(dir)) {
+    mkdirSync5(dir, { recursive: true });
   }
-  if (existsSync8(filePath)) {
-    const existing = readFileSync2(filePath, "utf8");
+  if (existsSync10(filePath)) {
+    const existing = readFileSync3(filePath, "utf8");
     const startIdx = existing.indexOf(MARKER_START);
     const endIdx = existing.indexOf(MARKER_END);
     if (startIdx !== -1 && endIdx !== -1) {
       const before = existing.slice(0, startIdx);
       const after = existing.slice(endIdx + MARKER_END.length);
-      writeFileSync6(filePath, before + content + after, "utf8");
+      writeFileSync7(filePath, before + content + after, "utf8");
       return;
     }
-    writeFileSync6(filePath, content + "\n\n" + existing, "utf8");
+    writeFileSync7(filePath, content + "\n\n" + existing, "utf8");
     return;
   }
-  writeFileSync6(filePath, content, "utf8");
+  writeFileSync7(filePath, content, "utf8");
 }
 function printDiag(brain, result) {
   console.log("");
@@ -897,8 +1119,8 @@ function computeHash(result) {
 }
 
 // src/init.ts
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync7, readFileSync as readFileSync3, existsSync as existsSync9, readdirSync as readdirSync6, appendFileSync } from "fs";
-import { join as join10, dirname as dirname2 } from "path";
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync8, readFileSync as readFileSync4, existsSync as existsSync11, readdirSync as readdirSync8, appendFileSync } from "fs";
+import { join as join12, dirname as dirname3 } from "path";
 var REGION_TEMPLATES = {
   brainstem: {
     description: "Absolute principles. Immutable. Read-only conscience.\nP0 \u2014 highest priority. bomb here halts EVERYTHING.",
@@ -930,22 +1152,22 @@ var REGION_TEMPLATES = {
   }
 };
 function initBrain(brainPath) {
-  if (existsSync9(brainPath)) {
-    const entries = readdirSync6(brainPath);
+  if (existsSync11(brainPath)) {
+    const entries = readdirSync8(brainPath);
     if (entries.some((e) => REGIONS.includes(e))) {
       console.log(`\u26A0\uFE0F  Brain already exists at ${brainPath}`);
       return;
     }
   }
-  mkdirSync4(brainPath, { recursive: true });
+  mkdirSync6(brainPath, { recursive: true });
   for (const regionName of REGIONS) {
-    const regionDir = join10(brainPath, regionName);
-    mkdirSync4(regionDir, { recursive: true });
+    const regionDir = join12(brainPath, regionName);
+    mkdirSync6(regionDir, { recursive: true });
     const template = REGION_TEMPLATES[regionName];
     const icon = REGION_ICONS[regionName];
     const ko = REGION_KO[regionName];
-    writeFileSync7(
-      join10(regionDir, "_rules.md"),
+    writeFileSync8(
+      join12(regionDir, "_rules.md"),
       `# ${icon} ${regionName} (${ko})
 
 ${template.description}
@@ -953,15 +1175,15 @@ ${template.description}
       "utf8"
     );
     for (const starter of template.starters) {
-      const neuronDir = join10(regionDir, starter);
-      mkdirSync4(neuronDir, { recursive: true });
-      writeFileSync7(join10(neuronDir, "1.neuron"), "", "utf8");
+      const neuronDir = join12(regionDir, starter);
+      mkdirSync6(neuronDir, { recursive: true });
+      writeFileSync8(join12(neuronDir, "1.neuron"), "", "utf8");
     }
   }
-  mkdirSync4(join10(brainPath, "_agents", "global_inbox"), { recursive: true });
-  mkdirSync4(join10(brainPath, "skills"), { recursive: true });
-  writeFileSync7(
-    join10(brainPath, "skills", "_rules.md"),
+  mkdirSync6(join12(brainPath, "_agents", "global_inbox"), { recursive: true });
+  mkdirSync6(join12(brainPath, "skills"), { recursive: true });
+  writeFileSync8(
+    join12(brainPath, "skills", "_rules.md"),
     "# Skills Library\n\nExecutable patterns learned through experience.\nNot part of the subsumption cascade \u2014 retrieval only.\n",
     "utf8"
   );
@@ -974,13 +1196,13 @@ ${template.description}
   console.log(`   hebbian emit claude --brain ${brainPath}`);
 }
 function autoGitignore(brainPath) {
-  let dir = dirname2(brainPath);
+  let dir = dirname3(brainPath);
   for (let i = 0; i < 10; i++) {
-    if (existsSync9(join10(dir, ".git"))) {
-      const gitignorePath = join10(dir, ".gitignore");
+    if (existsSync11(join12(dir, ".git"))) {
+      const gitignorePath = join12(dir, ".gitignore");
       const brainDirName = brainPath.replace(dir + "/", "") + "/";
-      if (existsSync9(gitignorePath)) {
-        const content = readFileSync3(gitignorePath, "utf8");
+      if (existsSync11(gitignorePath)) {
+        const content = readFileSync4(gitignorePath, "utf8");
         if (content.includes(brainDirName) || content.includes(brainDirName.replace(/\/$/, ""))) {
           return;
         }
@@ -992,7 +1214,7 @@ ${brainDirName}
       console.log(`   \u{1F4DD} Added ${brainDirName} to .gitignore`);
       return;
     }
-    const parent = dirname2(dir);
+    const parent = dirname3(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -1004,202 +1226,6 @@ import { createServer } from "http";
 // src/inbox.ts
 import { readFileSync as readFileSync5, writeFileSync as writeFileSync9, existsSync as existsSync12, mkdirSync as mkdirSync7 } from "fs";
 import { join as join13 } from "path";
-
-// src/candidates.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync6, readdirSync as readdirSync8, renameSync as renameSync3, rmSync, statSync as statSync3 } from "fs";
-import { join as join12, dirname as dirname3, relative as relative3 } from "path";
-
-// src/episode.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync4, writeFileSync as writeFileSync8, mkdirSync as mkdirSync5, existsSync as existsSync10 } from "fs";
-import { join as join11 } from "path";
-var MAX_EPISODES = 100;
-var SESSION_LOG_DIR = "hippocampus/session_log";
-function logEpisode(brainRoot, type, path, detail, extra) {
-  const logDir = join11(brainRoot, SESSION_LOG_DIR);
-  if (!existsSync10(logDir)) {
-    mkdirSync5(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 } : {}
-  };
-  writeFileSync8(
-    join11(logDir, `memory${nextSlot}.neuron`),
-    JSON.stringify(episode),
-    "utf8"
-  );
-}
-function readEpisodes(brainRoot) {
-  const logDir = join11(brainRoot, SESSION_LOG_DIR);
-  if (!existsSync10(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(join11(logDir, entry), "utf8");
-      if (content.trim()) {
-        episodes.push(JSON.parse(content));
-      }
-    } catch {
-    }
-  }
-  episodes.sort((a, b) => a.ts.localeCompare(b.ts));
-  return episodes;
-}
-function getNextSlot(logDir) {
-  let maxSlot = 0;
-  try {
-    for (const entry of readdirSync7(logDir)) {
-      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;
-}
-
-// src/candidates.ts
-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);
-    if (ok) propagateToShared(brainRoot, neuronPath);
-    return { ...result, path: ok ? neuronPath : result.path, promoted: ok };
-  }
-  console.log(`   \u{1F331} candidate (${result.counter}/${CANDIDATE_THRESHOLD}): ${candidatePath}`);
-  return { ...result, promoted: false };
-}
-function moveCandidate(brainRoot, candidatePath, targetPath) {
-  const src = join12(brainRoot, candidatePath);
-  if (!existsSync11(src)) return false;
-  const dst = join12(brainRoot, targetPath);
-  if (existsSync11(dst)) {
-    fireNeuron(brainRoot, targetPath);
-    rmSync(src, { recursive: true, force: true });
-  } else {
-    mkdirSync6(dirname3(dst), { recursive: true });
-    renameSync3(src, dst);
-  }
-  console.log(`\u{1F393} promoted: ${candidatePath} \u2192 ${targetPath}`);
-  return true;
-}
-function promoteCandidates(brainRoot) {
-  const promoted = [];
-  const decayed = [];
-  const decayMs = CANDIDATE_DECAY_DAYS * 24 * 60 * 60 * 1e3;
-  const now = Date.now();
-  for (const region of REGIONS) {
-    const candidateRoot = join12(brainRoot, region, CANDIDATE_SEGMENT);
-    walkNeuronDirs(candidateRoot, (neuronDir) => {
-      const rel = relative3(join12(brainRoot, region), neuronDir);
-      const candidatePath = `${region}/${rel}`;
-      const targetPath = fromCandidatePath(candidatePath);
-      const counter = readCounter(neuronDir);
-      const mtime = statSync3(neuronDir).mtimeMs;
-      if (counter >= CANDIDATE_THRESHOLD) {
-        moveCandidate(brainRoot, candidatePath, targetPath);
-        propagateToShared(brainRoot, targetPath);
-        promoted.push(targetPath);
-      } else if (now - mtime > decayMs) {
-        rmSync(neuronDir, { recursive: true, force: true });
-        decayed.push(candidatePath);
-        console.log(`\u{1F480} candidate decayed: ${candidatePath}`);
-      }
-    });
-  }
-  return { promoted, decayed };
-}
-function listCandidates(brainRoot) {
-  const results = [];
-  const now = Date.now();
-  for (const region of REGIONS) {
-    const candidateRoot = join12(brainRoot, region, CANDIDATE_SEGMENT);
-    walkNeuronDirs(candidateRoot, (neuronDir) => {
-      const rel = relative3(join12(brainRoot, region), neuronDir);
-      const candidatePath = `${region}/${rel}`;
-      const targetPath = fromCandidatePath(candidatePath);
-      const counter = readCounter(neuronDir);
-      const mtime = 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 (!existsSync11(dir)) return;
-  try {
-    const entries = readdirSync8(dir, { withFileTypes: true });
-    const hasNeuron = entries.some((e) => e.isFile() && e.name.endsWith(".neuron"));
-    if (hasNeuron) {
-      cb(dir);
-      return;
-    }
-    for (const entry of entries) {
-      if (entry.isDirectory() && !entry.name.startsWith(".")) {
-        walkNeuronDirs(join12(dir, entry.name), cb);
-      }
-    }
-  } catch {
-  }
-}
-function readCounter(dir) {
-  try {
-    const files = readdirSync8(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;
-  }
-}
-function propagateToShared(brainRoot, targetPath) {
-  try {
-    const agentsIdx = brainRoot.indexOf("/agents/");
-    if (agentsIdx === -1) return false;
-    const multiBrainRoot = brainRoot.slice(0, agentsIdx);
-    const sharedRoot = join12(multiBrainRoot, "shared");
-    if (!existsSync11(sharedRoot)) return false;
-    const episodes = readEpisodes(brainRoot);
-    const neuronName = targetPath.split("/").pop() || "";
-    const hasRelevantEpisode = episodes.some(
-      (ep) => PROPAGATION_EPISODE_TYPES.includes(ep.type) && (ep.path.includes(neuronName) || ep.detail.includes(neuronName))
-    );
-    if (!hasRelevantEpisode) return false;
-    growNeuron(sharedRoot, targetPath);
-    console.log(`   \u{1F4E1} propagated to shared: ${targetPath}`);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/inbox.ts
 var INBOX_DIR = "_inbox";
 var CORRECTIONS_FILE = "corrections.jsonl";
 var DOPAMINE_ALLOWED_ROLES = ["pm", "admin", "lead"];
@@ -1763,33 +1789,65 @@ var NEGATION_PATTERNS = [
   /\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
 ];
 var 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)
 ];
 var MUST_PATTERNS = [
   /\bmust\b/i,
   /\brequired\b/i,
-  // Korean
-  /반드시/
+  // Korean — strong directives:
+  /반드시/,
+  // "반드시" (absolutely must)
+  /꼭\s*[가-힣]/,
+  // "꼭 X해" (definitely do X)
+  /무조건/,
+  // "무조건" (unconditionally)
+  /필수/
+  // "필수" (mandatory)
 ];
 var WARN_PATTERNS = [
   /\bcareful\b/i,
   /\bwatch\s+out\b/i,
   /\bwarning\b/i,
-  // Korean
-  /주의/
+  // Korean — cautionary:
+  /주의/,
+  // "주의" (caution)
+  /조심/,
+  // "조심" (be careful)
+  /위험/
+  // "위험" (dangerous)
 ];
 function readHookInput(stdin) {
   if (!stdin.trim()) return null;
@@ -1838,7 +1896,8 @@ function digestTranscript(brainRoot, transcriptPath, sessionId) {
     console.log(`\u{1F527} digest: ${toolFailures.length} tool failure(s), ${retries.length} retry pattern(s) logged`);
   }
   const corrections = extractCorrections(messages);
-  if (corrections.length === 0 && toolFailures.length === 0) {
+  const fired = autoFireCandidates(brainRoot, corrections);
+  if (corrections.length === 0 && toolFailures.length === 0 && fired === 0) {
     console.log(`\u{1F4DD} digest: no corrections found in session ${resolvedSessionId}`);
     writeAuditLog(brainRoot, resolvedSessionId, [], totalLines);
     return { corrections: 0, skipped: messages.length, toolFailures: toolFailures.length, transcriptPath, sessionId: resolvedSessionId };
@@ -2003,7 +2062,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);
@@ -2011,7 +2070,7 @@ function extractCorrections(messages) {
   }
   return corrections;
 }
-function isNarrativeKorean(text) {
+function isNarrative(text) {
   const NARRATIVE_MARKERS = [
     /이유는/,
     // "the reason is..."
@@ -2037,6 +2096,26 @@ function isNarrativeKorean(text) {
   const markerCount = NARRATIVE_MARKERS.filter((p) => p.test(text)).length;
   return markerCount >= 2;
 }
+function autoFireCandidates(brainRoot, corrections) {
+  if (corrections.length > 0) return 0;
+  const candidates = listCandidates(brainRoot);
+  if (candidates.length === 0) return 0;
+  let fired = 0;
+  for (const cand of candidates) {
+    try {
+      const newCounter = fireNeuron(brainRoot, cand.candidatePath);
+      fired++;
+      if (newCounter >= CANDIDATE_THRESHOLD) {
+        growCandidate(brainRoot, cand.targetPath);
+      }
+    } catch {
+    }
+  }
+  if (fired > 0) {
+    console.log(`\u{1F504} agent-evaluator: ${fired} candidate(s) advanced (session without corrections)`);
+  }
+  return fired;
+}
 function detectCorrection(text) {
   const isNegation = NEGATION_PATTERNS.some((p) => p.test(text));
   const isMust = MUST_PATTERNS.some((p) => p.test(text));
@@ -2044,9 +2123,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";
@@ -2233,6 +2312,35 @@ function writeAuditLog(brainRoot, sessionId, entries, lineCount) {
   writeFileSync11(logPath, [metaLine, ...entryLines].join("\n") + "\n", "utf8");
 }
 
+// src/learn.ts
+var VALID_PREFIXES = /* @__PURE__ */ new Set(["NO", "DO", "MUST", "WARN"]);
+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 };
+}
+
 // src/evolve.ts
 import { existsSync as existsSync16, readFileSync as readFileSync9, writeFileSync as writeFileSync13 } from "fs";
 import { join as join17 } from "path";
@@ -3036,6 +3144,7 @@ export {
   installCron,
   installHooks,
   jaccardSimilarity,
+  learn,
   listCandidates,
   logEpisode,
   parseToolResults,