hebbian 0.9.0 → 0.10.0

package/dist/bin/hebbian.js

@@ -435,6 +435,412 @@ var init_subsumption = __esm({
   }
 });
 
+// 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);
+}
+function stem(word) {
+  const suffixes = ["ing", "tion", "sion", "ness", "ment", "able", "ible", "ful", "less", "ous", "ive", "ity", "ies", "ed", "er", "es", "ly", "al", "en"];
+  for (const suffix of suffixes) {
+    if (word.length > suffix.length + 2 && word.endsWith(suffix)) {
+      return word.slice(0, -suffix.length);
+    }
+  }
+  return word;
+}
+function jaccardSimilarity(a, b) {
+  if (a.length === 0 && b.length === 0) return 1;
+  if (a.length === 0 || b.length === 0) return 0;
+  const setA = new Set(a);
+  const setB = new Set(b);
+  let intersection = 0;
+  for (const item of setA) {
+    if (setB.has(item)) intersection++;
+  }
+  const union = (/* @__PURE__ */ new Set([...setA, ...setB])).size;
+  return intersection / union;
+}
+var init_similarity = __esm({
+  "src/similarity.ts"() {
+    "use strict";
+  }
+});
+
+// src/fire.ts
+var fire_exports = {};
+__export(fire_exports, {
+  contraNeuron: () => contraNeuron,
+  fireNeuron: () => fireNeuron,
+  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";
+function fireNeuron(brainRoot, neuronPath) {
+  const fullPath = join3(brainRoot, neuronPath);
+  if (!existsSync4(fullPath)) {
+    mkdirSync2(fullPath, { recursive: true });
+    writeFileSync2(join3(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`));
+  } else {
+    writeFileSync2(join3(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)) {
+    return 0;
+  }
+  const current = getCurrentContra(fullPath);
+  const newContra = current + 1;
+  if (current > 0) {
+    renameSync(join3(fullPath, `${current}.contra`), join3(fullPath, `${newContra}.contra`));
+  } else {
+    writeFileSync2(join3(fullPath, `${newContra}.contra`), "", "utf8");
+  }
+  return newContra;
+}
+function getCurrentContra(dir) {
+  let max = 0;
+  try {
+    for (const entry of readdirSync3(dir)) {
+      if (entry.endsWith(".contra")) {
+        const n = parseInt(entry, 10);
+        if (!isNaN(n) && n > max) max = n;
+      }
+    }
+  } catch {
+  }
+  return max;
+}
+function getCurrentCounter(dir) {
+  let max = 0;
+  try {
+    for (const entry of readdirSync3(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;
+      }
+    }
+  } catch {
+  }
+  return max;
+}
+var init_fire = __esm({
+  "src/fire.ts"() {
+    "use strict";
+  }
+});
+
+// src/grow.ts
+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";
+function growNeuron(brainRoot, neuronPath) {
+  const fullPath = join4(brainRoot, neuronPath);
+  if (existsSync5(fullPath)) {
+    const counter = fireNeuron(brainRoot, neuronPath);
+    return { action: "fired", path: neuronPath, counter };
+  }
+  if (neuronPath.includes("..") || neuronPath.startsWith("/")) {
+    throw new Error(`Invalid neuron path: "${neuronPath}" (path traversal not allowed)`);
+  }
+  const parts = neuronPath.split("/");
+  const regionName = parts[0];
+  if (regionName !== SKILLS_DIR && !REGIONS.includes(regionName)) {
+    throw new Error(`Invalid region: ${regionName}. Valid: ${REGIONS.join(", ")}, ${SKILLS_DIR}`);
+  }
+  const leafName = parts[parts.length - 1];
+  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 match = findSimilar(regionPath, regionPath, newTokens, newPrefix);
+    if (match) {
+      const matchRelPath = regionName + "/" + relative2(regionPath, match);
+      console.log(`\u{1F504} consolidation: "${neuronPath}" \u2248 "${matchRelPath}" (firing existing)`);
+      const counter = fireNeuron(brainRoot, matchRelPath);
+      return { action: "fired", path: matchRelPath, counter };
+    }
+  }
+  mkdirSync3(fullPath, { recursive: true });
+  writeFileSync3(join4(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 });
+  } catch {
+    return null;
+  }
+  const hasNeuron = entries.some((e) => e.isFile() && e.name.endsWith(".neuron"));
+  if (hasNeuron) {
+    const folderName = dir.split("/").pop() || "";
+    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 (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(join4(dir, entry.name), regionRoot, targetTokens, targetPrefix);
+      if (match) return match;
+    }
+  }
+  return null;
+}
+var init_grow = __esm({
+  "src/grow.ts"() {
+    "use strict";
+    init_constants();
+    init_similarity();
+    init_fire();
+  }
+});
+
+// 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, {
+  CANDIDATE_DECAY_DAYS: () => CANDIDATE_DECAY_DAYS,
+  CANDIDATE_THRESHOLD: () => CANDIDATE_THRESHOLD,
+  fromCandidatePath: () => fromCandidatePath,
+  growCandidate: () => growCandidate,
+  listCandidates: () => listCandidates,
+  promoteCandidates: () => promoteCandidates,
+  propagateToShared: () => propagateToShared,
+  toCandidatePath: () => toCandidatePath
+});
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readdirSync as readdirSync6, renameSync as renameSync2, rmSync, statSync as statSync2 } from "fs";
+import { join as join6, dirname as dirname2, relative as relative3 } from "path";
+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 = join6(brainRoot, candidatePath);
+  if (!existsSync7(src)) return false;
+  const dst = join6(brainRoot, targetPath);
+  if (existsSync7(dst)) {
+    fireNeuron(brainRoot, targetPath);
+    rmSync(src, { recursive: true, force: true });
+  } else {
+    mkdirSync5(dirname2(dst), { recursive: true });
+    renameSync2(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 = join6(brainRoot, region, CANDIDATE_SEGMENT);
+    walkNeuronDirs(candidateRoot, (neuronDir) => {
+      const rel = relative3(join6(brainRoot, region), neuronDir);
+      const candidatePath = `${region}/${rel}`;
+      const targetPath = fromCandidatePath(candidatePath);
+      const counter = readCounter(neuronDir);
+      const mtime = statSync2(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 = join6(brainRoot, region, CANDIDATE_SEGMENT);
+    walkNeuronDirs(candidateRoot, (neuronDir) => {
+      const rel = relative3(join6(brainRoot, region), neuronDir);
+      const candidatePath = `${region}/${rel}`;
+      const targetPath = fromCandidatePath(candidatePath);
+      const counter = readCounter(neuronDir);
+      const mtime = statSync2(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 (!existsSync7(dir)) return;
+  try {
+    const entries = readdirSync6(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(join6(dir, entry.name), cb);
+      }
+    }
+  } catch {
+  }
+}
+function readCounter(dir) {
+  try {
+    const files = readdirSync6(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 = join6(multiBrainRoot, "shared");
+    if (!existsSync7(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;
+  }
+}
+var CANDIDATE_THRESHOLD, CANDIDATE_DECAY_DAYS, CANDIDATE_SEGMENT;
+var init_candidates = __esm({
+  "src/candidates.ts"() {
+    "use strict";
+    init_constants();
+    init_grow();
+    init_fire();
+    init_episode();
+    CANDIDATE_THRESHOLD = 3;
+    CANDIDATE_DECAY_DAYS = 14;
+    CANDIDATE_SEGMENT = "_candidates";
+  }
+});
+
 // src/emit.ts
 var emit_exports = {};
 __export(emit_exports, {
@@ -445,9 +851,9 @@ __export(emit_exports, {
   printDiag: () => printDiag,
   writeAllTiers: () => writeAllTiers
 });
-import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join3, dirname as dirname2 } from "path";
-function emitBootstrap(result, brain) {
+import { existsSync as existsSync8, readFileSync as readFileSync4, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6 } from "fs";
+import { join as join7, dirname as dirname3 } from "path";
+function emitBootstrap(result, brain, brainRoot) {
   const lines = [];
   const now = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+Z$/, "");
   lines.push(MARKER_START);
@@ -503,6 +909,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");
 }
@@ -597,7 +1016,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);
@@ -613,33 +1032,33 @@ function emitToTarget(brainRoot, target) {
 }
 function writeAllTiers(brainRoot, result, brain) {
   const indexContent = emitIndex(result, brain);
-  writeFileSync2(join3(brainRoot, "_index.md"), indexContent, "utf8");
+  writeFileSync5(join7(brainRoot, "_index.md"), indexContent, "utf8");
   for (const region of result.activeRegions) {
-    if (existsSync4(region.path)) {
+    if (existsSync8(region.path)) {
       const rulesContent = emitRegionRules(region);
-      writeFileSync2(join3(region.path, "_rules.md"), rulesContent, "utf8");
+      writeFileSync5(join7(region.path, "_rules.md"), rulesContent, "utf8");
     }
   }
 }
 function writeTarget(filePath, content) {
-  const dir = dirname2(filePath);
-  if (dir !== "." && !existsSync4(dir)) {
-    mkdirSync2(dir, { recursive: true });
+  const dir = dirname3(filePath);
+  if (dir !== "." && !existsSync8(dir)) {
+    mkdirSync6(dir, { recursive: true });
   }
-  if (existsSync4(filePath)) {
-    const existing = readFileSync3(filePath, "utf8");
+  if (existsSync8(filePath)) {
+    const existing = readFileSync4(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);
-      writeFileSync2(filePath, before + content + after, "utf8");
+      writeFileSync5(filePath, before + content + after, "utf8");
       return;
     }
-    writeFileSync2(filePath, content + "\n\n" + existing, "utf8");
+    writeFileSync5(filePath, content + "\n\n" + existing, "utf8");
     return;
   }
-  writeFileSync2(filePath, content, "utf8");
+  writeFileSync5(filePath, content, "utf8");
 }
 function printDiag(brain, result) {
   console.log("");
@@ -688,6 +1107,7 @@ var init_emit = __esm({
     init_scanner();
     init_subsumption();
     init_constants();
+    init_candidates();
   }
 });
 
@@ -697,19 +1117,19 @@ __export(update_check_exports, {
   checkForUpdates: () => checkForUpdates,
   formatUpdateBanner: () => formatUpdateBanner
 });
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3, statSync as statSync2, unlinkSync } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync6, statSync as statSync3, unlinkSync } from "fs";
+import { join as join8 } from "path";
 function getStateDir() {
-  return join4(process.env.HOME || "~", ".hebbian");
+  return join8(process.env.HOME || "~", ".hebbian");
 }
 function ensureStateDir(stateDir) {
-  if (!existsSync5(stateDir)) {
-    mkdirSync3(stateDir, { recursive: true });
+  if (!existsSync9(stateDir)) {
+    mkdirSync7(stateDir, { recursive: true });
   }
 }
 function isCacheStale(cachePath, type) {
   try {
-    const mtime = statSync2(cachePath).mtimeMs;
+    const mtime = statSync3(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;
@@ -718,10 +1138,10 @@ function isCacheStale(cachePath, type) {
   }
 }
 function readCache(stateDir) {
-  const cachePath = join4(stateDir, "last-update-check");
-  if (!existsSync5(cachePath)) return null;
+  const cachePath = join8(stateDir, "last-update-check");
+  if (!existsSync9(cachePath)) return null;
   try {
-    const line = readFileSync4(cachePath, "utf8").trim();
+    const line = readFileSync5(cachePath, "utf8").trim();
     if (line.startsWith("UP_TO_DATE")) {
       if (isCacheStale(cachePath, "UP_TO_DATE")) return null;
       const ver = line.split(/\s+/)[1];
@@ -739,13 +1159,13 @@ function readCache(stateDir) {
 }
 function writeCache(stateDir, line) {
   ensureStateDir(stateDir);
-  writeFileSync3(join4(stateDir, "last-update-check"), line, "utf8");
+  writeFileSync6(join8(stateDir, "last-update-check"), line, "utf8");
 }
 function isSnoozed(stateDir, remoteVersion) {
-  const snoozePath = join4(stateDir, "update-snoozed");
-  if (!existsSync5(snoozePath)) return false;
+  const snoozePath = join8(stateDir, "update-snoozed");
+  if (!existsSync9(snoozePath)) return false;
   try {
-    const [ver, levelStr, epochStr] = readFileSync4(snoozePath, "utf8").trim().split(/\s+/);
+    const [ver, levelStr, epochStr] = readFileSync5(snoozePath, "utf8").trim().split(/\s+/);
     if (ver !== remoteVersion) {
       unlinkSync(snoozePath);
       return false;
@@ -789,233 +1209,51 @@ async function checkForUpdates(currentVersion) {
     }
     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, {
-  contraNeuron: () => contraNeuron,
-  fireNeuron: () => fireNeuron,
-  getCurrentContra: () => getCurrentContra,
-  getCurrentCounter: () => getCurrentCounter
-});
-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 = 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(join5(fullPath, `${current}.neuron`), join5(fullPath, `${newCounter}.neuron`));
-  } else {
-    writeFileSync4(join5(fullPath, `${newCounter}.neuron`), "", "utf8");
-  }
-  console.log(`\u{1F525} fired: ${neuronPath} (${current} \u2192 ${newCounter})`);
-  return newCounter;
-}
-function contraNeuron(brainRoot, neuronPath) {
-  const fullPath = join5(brainRoot, neuronPath);
-  if (!existsSync6(fullPath)) {
-    return 0;
-  }
-  const current = getCurrentContra(fullPath);
-  const newContra = current + 1;
-  if (current > 0) {
-    renameSync(join5(fullPath, `${current}.contra`), join5(fullPath, `${newContra}.contra`));
-  } else {
-    writeFileSync4(join5(fullPath, `${newContra}.contra`), "", "utf8");
-  }
-  return newContra;
-}
-function getCurrentContra(dir) {
-  let max = 0;
-  try {
-    for (const entry of readdirSync3(dir)) {
-      if (entry.endsWith(".contra")) {
-        const n = parseInt(entry, 10);
-        if (!isNaN(n) && n > max) max = n;
-      }
-    }
-  } catch {
-  }
-  return max;
-}
-function getCurrentCounter(dir) {
-  let max = 0;
-  try {
-    for (const entry of readdirSync3(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;
-      }
-    }
-  } catch {
-  }
-  return max;
-}
-var init_fire = __esm({
-  "src/fire.ts"() {
-    "use strict";
-  }
-});
-
-// 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);
-}
-function stem(word) {
-  const suffixes = ["ing", "tion", "sion", "ness", "ment", "able", "ible", "ful", "less", "ous", "ive", "ity", "ies", "ed", "er", "es", "ly", "al", "en"];
-  for (const suffix of suffixes) {
-    if (word.length > suffix.length + 2 && word.endsWith(suffix)) {
-      return word.slice(0, -suffix.length);
-    }
-  }
-  return word;
-}
-function jaccardSimilarity(a, b) {
-  if (a.length === 0 && b.length === 0) return 1;
-  if (a.length === 0 || b.length === 0) return 0;
-  const setA = new Set(a);
-  const setB = new Set(b);
-  let intersection = 0;
-  for (const item of setA) {
-    if (setB.has(item)) intersection++;
-  }
-  const union = (/* @__PURE__ */ new Set([...setA, ...setB])).size;
-  return intersection / union;
-}
-var init_similarity = __esm({
-  "src/similarity.ts"() {
-    "use strict";
-  }
-});
-
-// src/grow.ts
-var grow_exports = {};
-__export(grow_exports, {
-  growNeuron: () => growNeuron
-});
-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 = join6(brainRoot, neuronPath);
-  if (existsSync7(fullPath)) {
-    const counter = fireNeuron(brainRoot, neuronPath);
-    return { action: "fired", path: neuronPath, counter };
-  }
-  if (neuronPath.includes("..") || neuronPath.startsWith("/")) {
-    throw new Error(`Invalid neuron path: "${neuronPath}" (path traversal not allowed)`);
-  }
-  const parts = neuronPath.split("/");
-  const regionName = parts[0];
-  if (regionName !== SKILLS_DIR && !REGIONS.includes(regionName)) {
-    throw new Error(`Invalid region: ${regionName}. Valid: ${REGIONS.join(", ")}, ${SKILLS_DIR}`);
-  }
-  const leafName = parts[parts.length - 1];
-  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)`);
-      const counter = fireNeuron(brainRoot, matchRelPath);
-      return { action: "fired", path: matchRelPath, counter };
-    }
-  }
-  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, targetPrefix) {
-  let entries;
-  try {
-    entries = readdirSync4(dir, { withFileTypes: true });
-  } catch {
-    return null;
-  }
-  const hasNeuron = entries.some((e) => e.isFile() && e.name.endsWith(".neuron"));
-  if (hasNeuron) {
-    const folderName = dir.split("/").pop() || "";
-    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 (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(join6(dir, entry.name), regionRoot, targetTokens, targetPrefix);
-      if (match) return match;
+        return { type: "upgrade_available", current: currentVersion, latest: cached.latest };
+      }
     }
   }
-  return null;
+  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 };
 }
-var init_grow = __esm({
-  "src/grow.ts"() {
+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";
-    init_constants();
-    init_similarity();
-    init_fire();
+    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)
+    };
   }
 });
 
@@ -1024,10 +1262,10 @@ var rollback_exports = {};
 __export(rollback_exports, {
   rollbackNeuron: () => rollbackNeuron
 });
-import { renameSync as renameSync2 } from "fs";
-import { join as join7 } from "path";
+import { renameSync as renameSync3 } from "fs";
+import { join as join9 } from "path";
 function rollbackNeuron(brainRoot, neuronPath) {
-  const fullPath = join7(brainRoot, neuronPath);
+  const fullPath = join9(brainRoot, neuronPath);
   const current = getCurrentCounter(fullPath);
   if (current === 0) {
     throw new Error(`Neuron not found: ${neuronPath}`);
@@ -1036,7 +1274,7 @@ function rollbackNeuron(brainRoot, neuronPath) {
     throw new Error(`Counter already at minimum (1): ${neuronPath}`);
   }
   const newCounter = current - 1;
-  renameSync2(join7(fullPath, `${current}.neuron`), join7(fullPath, `${newCounter}.neuron`));
+  renameSync3(join9(fullPath, `${current}.neuron`), join9(fullPath, `${newCounter}.neuron`));
   console.log(`\u23EA rollback: ${neuronPath} (${current} \u2192 ${newCounter})`);
   return newCounter;
 }
@@ -1052,31 +1290,31 @@ var signal_exports = {};
 __export(signal_exports, {
   signalNeuron: () => signalNeuron
 });
-import { writeFileSync as writeFileSync6, existsSync as existsSync8, readdirSync as readdirSync5 } from "fs";
-import { join as join8 } from "path";
+import { writeFileSync as writeFileSync7, existsSync as existsSync10, readdirSync as readdirSync7 } from "fs";
+import { join as join10 } 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 = join8(brainRoot, neuronPath);
-  if (!existsSync8(fullPath)) {
+  const fullPath = join10(brainRoot, neuronPath);
+  if (!existsSync10(fullPath)) {
     throw new Error(`Neuron not found: ${neuronPath}`);
   }
   switch (signalType) {
     case "bomb": {
-      writeFileSync6(join8(fullPath, "bomb.neuron"), "", "utf8");
+      writeFileSync7(join10(fullPath, "bomb.neuron"), "", "utf8");
       console.log(`\u{1F4A3} bomb planted: ${neuronPath}`);
       break;
     }
     case "dopamine": {
       const level = getNextSignalLevel(fullPath, "dopamine");
-      writeFileSync6(join8(fullPath, `dopamine${level}.neuron`), "", "utf8");
+      writeFileSync7(join10(fullPath, `dopamine${level}.neuron`), "", "utf8");
       console.log(`\u{1F7E2} dopamine +${level}: ${neuronPath}`);
       break;
     }
     case "memory": {
       const level = getNextSignalLevel(fullPath, "memory");
-      writeFileSync6(join8(fullPath, `memory${level}.neuron`), "", "utf8");
+      writeFileSync7(join10(fullPath, `memory${level}.neuron`), "", "utf8");
       console.log(`\u{1F4BE} memory +${level}: ${neuronPath}`);
       break;
     }
@@ -1085,7 +1323,7 @@ function signalNeuron(brainRoot, neuronPath, signalType) {
 function getNextSignalLevel(dir, prefix) {
   let max = 0;
   try {
-    for (const entry of readdirSync5(dir)) {
+    for (const entry of readdirSync7(dir)) {
       if (entry.startsWith(prefix) && entry.endsWith(".neuron")) {
         const n = parseInt(entry.replace(prefix, ""), 10);
         if (!isNaN(n) && n > max) max = n;
@@ -1107,15 +1345,15 @@ var decay_exports = {};
 __export(decay_exports, {
   runDecay: () => runDecay
 });
-import { readdirSync as readdirSync6, statSync as statSync3, writeFileSync as writeFileSync7, existsSync as existsSync9 } from "fs";
-import { join as join9 } from "path";
+import { readdirSync as readdirSync8, statSync as statSync4, writeFileSync as writeFileSync8, existsSync as existsSync11 } from "fs";
+import { join as join11 } 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 = join9(brainRoot, regionName);
-    if (!existsSync9(regionPath)) continue;
+    const regionPath = join11(brainRoot, regionName);
+    if (!existsSync11(regionPath)) continue;
     const result = decayWalk(regionPath, threshold, 0);
     scanned += result.scanned;
     decayed += result.decayed;
@@ -1129,7 +1367,7 @@ function decayWalk(dir, threshold, depth) {
   let decayed = 0;
   let entries;
   try {
-    entries = readdirSync6(dir, { withFileTypes: true });
+    entries = readdirSync8(dir, { withFileTypes: true });
   } catch {
     return { scanned: 0, decayed: 0 };
   }
@@ -1141,7 +1379,7 @@ function decayWalk(dir, threshold, depth) {
       if (entry.name.endsWith(".neuron")) {
         hasNeuronFile = true;
         try {
-          const st = statSync3(join9(dir, entry.name));
+          const st = statSync4(join11(dir, entry.name));
           if (st.mtimeMs > latestMod) latestMod = st.mtimeMs;
         } catch {
         }
@@ -1155,8 +1393,8 @@ function decayWalk(dir, threshold, depth) {
     scanned++;
     if (!isDormant && latestMod < threshold) {
       const age = Math.floor((Date.now() - latestMod) / (24 * 60 * 60 * 1e3));
-      writeFileSync7(
-        join9(dir, "decay.dormant"),
+      writeFileSync8(
+        join11(dir, "decay.dormant"),
         `Dormant since ${(/* @__PURE__ */ new Date()).toISOString()} (${age} days inactive)`,
         "utf8"
       );
@@ -1166,7 +1404,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(join9(dir, entry.name), threshold, depth + 1);
+      const sub = decayWalk(join11(dir, entry.name), threshold, depth + 1);
       scanned += sub.scanned;
       decayed += sub.decayed;
     }
@@ -1185,8 +1423,8 @@ var dedup_exports = {};
 __export(dedup_exports, {
   runDedup: () => runDedup
 });
-import { writeFileSync as writeFileSync8 } from "fs";
-import { join as join10 } from "path";
+import { writeFileSync as writeFileSync9 } from "fs";
+import { join as join12 } from "path";
 function runDedup(brainRoot) {
   const brain = scanBrain(brainRoot);
   let scanned = 0;
@@ -1208,8 +1446,8 @@ function runDedup(brainRoot) {
           const [keep, drop] = ni.counter >= nj.counter ? [ni, nj] : [nj, ni];
           const relKeep = `${region.name}/${keep.path}`;
           fireNeuron(brainRoot, relKeep);
-          writeFileSync8(
-            join10(drop.fullPath, "dedup.dormant"),
+          writeFileSync9(
+            join12(drop.fullPath, "dedup.dormant"),
             `Merged into ${keep.path} on ${(/* @__PURE__ */ new Date()).toISOString()}`,
             "utf8"
           );
@@ -1239,10 +1477,10 @@ __export(snapshot_exports, {
   gitSnapshot: () => gitSnapshot
 });
 import { execSync } from "child_process";
-import { existsSync as existsSync10 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { join as join13 } from "path";
 function gitSnapshot(brainRoot) {
-  if (!existsSync10(join11(brainRoot, ".git"))) {
+  if (!existsSync12(join13(brainRoot, ".git"))) {
     try {
       execSync("git rev-parse --is-inside-work-tree", { cwd: brainRoot, stdio: "pipe" });
     } catch {
@@ -1330,230 +1568,6 @@ var init_watch = __esm({
   }
 });
 
-// src/episode.ts
-var episode_exports = {};
-__export(episode_exports, {
-  logEpisode: () => logEpisode,
-  readEpisodes: () => readEpisodes
-});
-import { readdirSync as readdirSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync9, mkdirSync as mkdirSync6, existsSync as existsSync11 } from "fs";
-import { join as join12 } from "path";
-function logEpisode(brainRoot, type, path, detail, extra) {
-  const logDir = join12(brainRoot, SESSION_LOG_DIR);
-  if (!existsSync11(logDir)) {
-    mkdirSync6(logDir, { recursive: true });
-  }
-  const nextSlot = getNextSlot(logDir);
-  const episode = {
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    type,
-    path,
-    detail,
-    ...extra?.outcome ? { outcome: extra.outcome } : {},
-    ...extra?.neurons ? { neurons: extra.neurons } : {}
-  };
-  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 = readFileSync5(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 {
-    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;
-}
-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, {
-  CANDIDATE_DECAY_DAYS: () => CANDIDATE_DECAY_DAYS,
-  CANDIDATE_THRESHOLD: () => CANDIDATE_THRESHOLD,
-  fromCandidatePath: () => fromCandidatePath,
-  growCandidate: () => growCandidate,
-  listCandidates: () => listCandidates,
-  promoteCandidates: () => promoteCandidates,
-  propagateToShared: () => propagateToShared,
-  toCandidatePath: () => toCandidatePath
-});
-import { existsSync as existsSync12, mkdirSync as mkdirSync7, readdirSync as readdirSync8, renameSync as renameSync3, rmSync, statSync as statSync4 } from "fs";
-import { join as join13, dirname as dirname3, relative as relative3 } from "path";
-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 = join13(brainRoot, candidatePath);
-  if (!existsSync12(src)) return false;
-  const dst = join13(brainRoot, targetPath);
-  if (existsSync12(dst)) {
-    fireNeuron(brainRoot, targetPath);
-    rmSync(src, { recursive: true, force: true });
-  } else {
-    mkdirSync7(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 = join13(brainRoot, region, CANDIDATE_SEGMENT);
-    walkNeuronDirs(candidateRoot, (neuronDir) => {
-      const rel = relative3(join13(brainRoot, region), neuronDir);
-      const candidatePath = `${region}/${rel}`;
-      const targetPath = fromCandidatePath(candidatePath);
-      const counter = readCounter(neuronDir);
-      const mtime = statSync4(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 = join13(brainRoot, region, CANDIDATE_SEGMENT);
-    walkNeuronDirs(candidateRoot, (neuronDir) => {
-      const rel = relative3(join13(brainRoot, region), neuronDir);
-      const candidatePath = `${region}/${rel}`;
-      const targetPath = fromCandidatePath(candidatePath);
-      const counter = readCounter(neuronDir);
-      const mtime = statSync4(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 (!existsSync12(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(join13(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 = join13(multiBrainRoot, "shared");
-    if (!existsSync12(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;
-  }
-}
-var CANDIDATE_THRESHOLD, CANDIDATE_DECAY_DAYS, CANDIDATE_SEGMENT;
-var init_candidates = __esm({
-  "src/candidates.ts"() {
-    "use strict";
-    init_constants();
-    init_grow();
-    init_fire();
-    init_episode();
-    CANDIDATE_THRESHOLD = 3;
-    CANDIDATE_DECAY_DAYS = 14;
-    CANDIDATE_SEGMENT = "_candidates";
-  }
-});
-
 // src/inbox.ts
 var inbox_exports = {};
 __export(inbox_exports, {
@@ -2225,7 +2239,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 };
@@ -2415,6 +2430,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));
@@ -2616,6 +2651,7 @@ var init_digest = __esm({
     "use strict";
     init_constants();
     init_candidates();
+    init_fire();
     init_episode();
     NEGATION_PATTERNS = [
       /\bdon[''\u2019]?t\b/i,