hebbian 0.8.2 → 0.10.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,19 @@ 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("");
+    }
+  }
   lines.push(MARKER_END);
   return lines.join("\n");
 }
@@ -766,7 +975,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 +991,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 +1106,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 +1139,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 +1162,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 +1183,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 +1201,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 +1213,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"];
@@ -1762,24 +1775,21 @@ var NEGATION_PATTERNS = [
   /\bnever\b/i,
   /\binstead\b/i,
   /^no[,.\s!]/i,
-  /\bdon[''\u2019]?t\s+use\b/i,
   /\bavoid\b/i,
-  // Korean negation — specific verb forms only to avoid matching incidental 않/대신 in explanations
-  /하지\s*마/,
-  /안\s*돼/,
-  /쓰지\s*마/,
-  /[가-힣]+지\s*마/,
-  /하지\s*않/,
-  // "do not" specifically
-  /쓰지\s*않/
-  // "do not use" specifically
+  // Korean negation — require AI-directed imperative context:
+  // "X하지 마" (don't X) — must have a verb object before 지 마
+  /[을를은는도이가]\s*[가-힣]+지\s*마/,
+  // "X 하면 안 돼" (must not X) — conditional + prohibition
+  /하면\s*안\s*돼/,
+  // "X 쓰지 마" (don't use X) — explicit "don't use"
+  /쓰지\s*마/
 ];
 var AFFIRMATION_PATTERNS = [
-  /\balways\b/i,
   /\bshould\s+always\b/i,
   /\buse\s+\w+\s+instead\b/i,
-  // Korean affirmation
-  /항상/
+  // Korean affirmation — require directive context
+  /항상\s*[가-힣]+[해하]/
+  // "항상 X해" (always do X)
 ];
 var MUST_PATTERNS = [
   /\bmust\b/i,
@@ -1841,7 +1851,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 };
@@ -1998,12 +2009,15 @@ function extractCorrections(messages) {
   const corrections = [];
   for (const text of messages) {
     if (corrections.length >= MAX_CORRECTIONS_PER_SESSION) break;
+    const trimmed = text.trim();
     if (text.length < MIN_CORRECTION_LENGTH) continue;
-    if (/^[\/!]/.test(text.trim())) continue;
-    if (text.trim().endsWith("?")) continue;
-    if (/^<[a-zA-Z]/.test(text.trim())) continue;
-    if (/^Base directory for this skill:/i.test(text.trim())) continue;
-    if (/^[•·▸▶\-\*]\s/.test(text.trim())) continue;
+    if (/^[\/!]/.test(trimmed)) continue;
+    if (/[?？]\s*[!！]?\s*$/.test(trimmed)) continue;
+    if (/^<[a-zA-Z]/.test(trimmed)) continue;
+    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;
     const correction = detectCorrection(text);
     if (correction) {
       corrections.push(correction);
@@ -2011,12 +2025,63 @@ function extractCorrections(messages) {
   }
   return corrections;
 }
+function isNarrativeKorean(text) {
+  const NARRATIVE_MARKERS = [
+    /이유는/,
+    // "the reason is..."
+    /예를\s*들면/,
+    // "for example..."
+    /그래서/,
+    // "so/therefore..."
+    /그런데/,
+    // "but then..."
+    /왜냐하면/,
+    // "because..."
+    /거든/,
+    // "...you see" (explanatory)
+    /있었[던거어]/,
+    // "there was..." (past narrative)
+    /중인데/,
+    // "...in the middle of" (ongoing situation)
+    /거 같은데/,
+    // "it seems like..." (speculation)
+    /어떻게\s*생각/
+    // "what do you think?" (asking opinion)
+  ];
+  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));
   const isWarn = WARN_PATTERNS.some((p) => p.test(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;
+  }
   let prefix;
   if (isNegation) prefix = "NO";
   else if (isMust) prefix = "MUST";