hebbian 0.7.1 → 0.8.0

package/dist/index.js

@@ -73,6 +73,8 @@ function resolveSharedBrain(brainRoot) {
 }
 var AGENTS_DIR = "agents";
 var SHARED_DIR = "shared";
+var SKILLS_DIR = "skills";
+var PROPAGATION_EPISODE_TYPES = ["tool-failure", "retry-pattern"];
 
 // src/scanner.ts
 import { readdirSync, statSync, readFileSync, existsSync as existsSync2 } from "fs";
@@ -198,6 +200,11 @@ function walkRegion(dir, regionRoot, depth) {
   }
   return neurons;
 }
+function scanSkills(brainRoot) {
+  const skillsPath = join(brainRoot, SKILLS_DIR);
+  if (!existsSync2(skillsPath)) return [];
+  return walkRegion(skillsPath, skillsPath, 0);
+}
 function readAxons(regionPath) {
   const axonPath = join(regionPath, ".axon");
   if (!existsSync2(axonPath)) return [];
@@ -413,8 +420,8 @@ function growNeuron(brainRoot, neuronPath) {
   }
   const parts = neuronPath.split("/");
   const regionName = parts[0];
-  if (!REGIONS.includes(regionName)) {
-    throw new Error(`Invalid region: ${regionName}. Valid: ${REGIONS.join(", ")}`);
+  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] || "";
@@ -952,6 +959,12 @@ ${template.description}
     }
   }
   mkdirSync4(join10(brainPath, "_agents", "global_inbox"), { recursive: true });
+  mkdirSync4(join10(brainPath, "skills"), { recursive: true });
+  writeFileSync7(
+    join10(brainPath, "skills", "_rules.md"),
+    "# Skills Library\n\nExecutable patterns learned through experience.\nNot part of the subsumption cascade \u2014 retrieval only.\n",
+    "utf8"
+  );
   autoGitignore(brainPath);
   console.log(`\u{1F9E0} Brain initialized at ${brainPath}`);
   console.log(`   7 regions created: ${REGIONS.join(", ")}`);
@@ -993,8 +1006,73 @@ import { readFileSync as readFileSync5, writeFileSync as writeFileSync9, existsS
 import { join as join13 } from "path";
 
 // src/candidates.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, readdirSync as readdirSync7, renameSync as renameSync3, rmSync, statSync as statSync3 } from "fs";
-import { join as join11, dirname as dirname3, relative as relative3 } from "path";
+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";
@@ -1011,20 +1089,21 @@ function growCandidate(brainRoot, 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 = join11(brainRoot, candidatePath);
-  if (!existsSync10(src)) return false;
-  const dst = join11(brainRoot, targetPath);
-  if (existsSync10(dst)) {
+  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 {
-    mkdirSync5(dirname3(dst), { recursive: true });
+    mkdirSync6(dirname3(dst), { recursive: true });
     renameSync3(src, dst);
   }
   console.log(`\u{1F393} promoted: ${candidatePath} \u2192 ${targetPath}`);
@@ -1036,15 +1115,16 @@ function promoteCandidates(brainRoot) {
   const decayMs = CANDIDATE_DECAY_DAYS * 24 * 60 * 60 * 1e3;
   const now = Date.now();
   for (const region of REGIONS) {
-    const candidateRoot = join11(brainRoot, region, CANDIDATE_SEGMENT);
+    const candidateRoot = join12(brainRoot, region, CANDIDATE_SEGMENT);
     walkNeuronDirs(candidateRoot, (neuronDir) => {
-      const rel = relative3(join11(brainRoot, region), 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 });
@@ -1059,9 +1139,9 @@ function listCandidates(brainRoot) {
   const results = [];
   const now = Date.now();
   for (const region of REGIONS) {
-    const candidateRoot = join11(brainRoot, region, CANDIDATE_SEGMENT);
+    const candidateRoot = join12(brainRoot, region, CANDIDATE_SEGMENT);
     walkNeuronDirs(candidateRoot, (neuronDir) => {
-      const rel = relative3(join11(brainRoot, region), neuronDir);
+      const rel = relative3(join12(brainRoot, region), neuronDir);
       const candidatePath = `${region}/${rel}`;
       const targetPath = fromCandidatePath(candidatePath);
       const counter = readCounter(neuronDir);
@@ -1073,9 +1153,9 @@ function listCandidates(brainRoot) {
   return results;
 }
 function walkNeuronDirs(dir, cb) {
-  if (!existsSync10(dir)) return;
+  if (!existsSync11(dir)) return;
   try {
-    const entries = readdirSync7(dir, { withFileTypes: true });
+    const entries = readdirSync8(dir, { withFileTypes: true });
     const hasNeuron = entries.some((e) => e.isFile() && e.name.endsWith(".neuron"));
     if (hasNeuron) {
       cb(dir);
@@ -1083,7 +1163,7 @@ function walkNeuronDirs(dir, cb) {
     }
     for (const entry of entries) {
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
-        walkNeuronDirs(join11(dir, entry.name), cb);
+        walkNeuronDirs(join12(dir, entry.name), cb);
       }
     }
   } catch {
@@ -1091,75 +1171,32 @@ function walkNeuronDirs(dir, cb) {
 }
 function readCounter(dir) {
   try {
-    const files = readdirSync7(dir).filter((f) => /^\d+\.neuron$/.test(f));
+    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;
   }
 }
-
-// src/episode.ts
-import { readdirSync as readdirSync8, readFileSync as readFileSync4, writeFileSync as writeFileSync8, mkdirSync as mkdirSync6, existsSync as existsSync11 } from "fs";
-import { join as join12 } from "path";
-var MAX_EPISODES = 100;
-var SESSION_LOG_DIR = "hippocampus/session_log";
-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 } : {}
-  };
-  writeFileSync8(
-    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 = readdirSync8(logDir);
-  } catch {
-    return [];
-  }
-  for (const entry of entries) {
-    if (!entry.startsWith("memory") || !entry.endsWith(".neuron")) continue;
-    try {
-      const content = readFileSync4(join12(logDir, entry), "utf8");
-      if (content.trim()) {
-        episodes.push(JSON.parse(content));
-      }
-    } catch {
-    }
-  }
-  episodes.sort((a, b) => a.ts.localeCompare(b.ts));
-  return episodes;
-}
-function getNextSlot(logDir) {
-  let maxSlot = 0;
+function propagateToShared(brainRoot, targetPath) {
   try {
-    for (const entry of readdirSync8(logDir)) {
-      if (entry.startsWith("memory") && entry.endsWith(".neuron")) {
-        const n = parseInt(entry.replace("memory", "").replace(".neuron", ""), 10);
-        if (!isNaN(n) && n > maxSlot) maxSlot = n;
-      }
-    }
+    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;
   }
-  const next = maxSlot + 1;
-  return next > MAX_EPISODES ? maxSlot % MAX_EPISODES + 1 : next;
 }
 
 // src/inbox.ts
@@ -2566,6 +2603,7 @@ function validateActions(actions, _brain) {
       return false;
     }
     const region = action.path.split("/")[0];
+    if (region === SKILLS_DIR) return true;
     if (!region || PROTECTED_REGIONS.includes(region)) {
       console.log(`   \u{1F6E1}\uFE0F blocked: ${action.type} ${action.path} (protected region)`);
       return false;
@@ -2590,7 +2628,11 @@ function executeActions(brainRoot, actions) {
           fireNeuron(brainRoot, action.path);
           break;
         case "grow":
-          growCandidate(brainRoot, action.path);
+          if (action.path.startsWith(SKILLS_DIR + "/")) {
+            growNeuron(brainRoot, action.path);
+          } else {
+            growCandidate(brainRoot, action.path);
+          }
           break;
         case "signal":
           signalNeuron(brainRoot, action.path, action.signal || "dopamine");
@@ -2626,6 +2668,226 @@ function actionIcon(type) {
       return "\u2753";
   }
 }
+
+// src/cron.ts
+import { writeFileSync as writeFileSync14, existsSync as existsSync17, unlinkSync } from "fs";
+import { join as join18 } from "path";
+import { execSync as execSync4 } from "child_process";
+var PLIST_LABEL = "com.hebbian.nightly-prune";
+var FEEDBACK_PLIST_LABEL = "com.hebbian.feedback";
+function getLaunchAgentsDir() {
+  return join18(process.env.HOME || "~", "Library", "LaunchAgents");
+}
+function getPlistPath(label) {
+  return join18(getLaunchAgentsDir(), `${label}.plist`);
+}
+function getNpxPath() {
+  try {
+    return execSync4("which npx", { encoding: "utf8" }).trim();
+  } catch {
+    return "/opt/homebrew/bin/npx";
+  }
+}
+function generatePrunePlist(brainRoot, hour = 2, minute = 0) {
+  const npx = getNpxPath();
+  const apiKey = process.env.GEMINI_API_KEY || "";
+  const home = process.env.HOME || "/Users/sweetheart";
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${PLIST_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${npx}</string>
+    <string>hebbian</string>
+    <string>evolve</string>
+    <string>prune</string>
+    <string>--brain</string>
+    <string>${brainRoot}</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>GEMINI_API_KEY</key>
+    <string>${apiKey}</string>
+    <key>PATH</key>
+    <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+  </dict>
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Hour</key>
+    <integer>${hour}</integer>
+    <key>Minute</key>
+    <integer>${minute}</integer>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${home}/Library/Logs/hebbian-prune.log</string>
+  <key>StandardErrorPath</key>
+  <string>${home}/Library/Logs/hebbian-prune.log</string>
+</dict>
+</plist>`;
+}
+function generateFeedbackPlist(brainRoot, intervalMinutes = 15) {
+  const npx = getNpxPath();
+  const home = process.env.HOME || "/Users/sweetheart";
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${FEEDBACK_PLIST_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${npx}</string>
+    <string>hebbian</string>
+    <string>feedback</string>
+    <string>scan</string>
+    <string>--brain</string>
+    <string>${brainRoot}</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+  </dict>
+  <key>StartInterval</key>
+  <integer>${intervalMinutes * 60}</integer>
+  <key>StandardOutPath</key>
+  <string>${home}/Library/Logs/hebbian-feedback.log</string>
+  <key>StandardErrorPath</key>
+  <string>${home}/Library/Logs/hebbian-feedback.log</string>
+</dict>
+</plist>`;
+}
+function installCron(brainRoot, type = "prune") {
+  const label = type === "prune" ? PLIST_LABEL : FEEDBACK_PLIST_LABEL;
+  const plistPath = getPlistPath(label);
+  const plistContent = type === "prune" ? generatePrunePlist(brainRoot) : generateFeedbackPlist(brainRoot);
+  try {
+    execSync4(`launchctl unload ${plistPath} 2>/dev/null`, { encoding: "utf8" });
+  } catch {
+  }
+  writeFileSync14(plistPath, plistContent, "utf8");
+  execSync4(`launchctl load ${plistPath}`, { encoding: "utf8" });
+  console.log(`\u2705 ${type} cron installed: ${plistPath}`);
+}
+function uninstallCron(type = "prune") {
+  const label = type === "prune" ? PLIST_LABEL : FEEDBACK_PLIST_LABEL;
+  const plistPath = getPlistPath(label);
+  if (!existsSync17(plistPath)) {
+    console.log(`\u26A0\uFE0F ${type} cron not installed`);
+    return;
+  }
+  try {
+    execSync4(`launchctl unload ${plistPath}`, { encoding: "utf8" });
+  } catch {
+  }
+  unlinkSync(plistPath);
+  console.log(`\u{1F5D1}\uFE0F ${type} cron uninstalled`);
+}
+function checkCron(type = "prune") {
+  const label = type === "prune" ? PLIST_LABEL : FEEDBACK_PLIST_LABEL;
+  const plistPath = getPlistPath(label);
+  return { installed: existsSync17(plistPath), path: plistPath };
+}
+
+// src/feedback.ts
+import { existsSync as existsSync18, readdirSync as readdirSync11, statSync as statSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync15, mkdirSync as mkdirSync11 } from "fs";
+import { join as join19 } from "path";
+var WATERMARK_FILE = "_feedback_watermark.json";
+var WARN_PREFIX = "WARN_shared_";
+function scanSharedBrain(brainRoot) {
+  const sharedRoot = join19(brainRoot, SHARED_DIR);
+  if (!existsSync18(sharedRoot)) return [];
+  const watermark = readWatermark(sharedRoot);
+  const deltas = [];
+  for (const region of REGIONS) {
+    const regionPath = join19(sharedRoot, region);
+    if (!existsSync18(regionPath)) continue;
+    walkForNeurons(regionPath, regionPath, (neuronDir, counter) => {
+      const modTime = statSync5(neuronDir).mtime;
+      if (modTime.getTime() <= watermark) return;
+      const name = neuronDir.split("/").pop() || "";
+      if (name.startsWith(WARN_PREFIX)) return;
+      const relPath = region + "/" + neuronDir.slice(regionPath.length + 1);
+      deltas.push({ path: relPath, counter, modTime });
+    });
+  }
+  return deltas;
+}
+function propagateToAgents(brainRoot, deltas) {
+  const agentsDir = join19(brainRoot, AGENTS_DIR);
+  if (!existsSync18(agentsDir) || deltas.length === 0) {
+    return { scanned: deltas.length, propagated: 0, agents: [] };
+  }
+  const agentNames = readdirSync11(agentsDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && !e.name.startsWith("_")).map((e) => e.name);
+  let propagated = 0;
+  const touchedAgents = /* @__PURE__ */ new Set();
+  for (const delta of deltas) {
+    const neuronName = delta.path.split("/").pop() || "";
+    const warnPath = delta.path.replace(/\/([^/]+)$/, `/${WARN_PREFIX}${neuronName}`);
+    for (const agent of agentNames) {
+      const agentBrain = join19(agentsDir, agent);
+      if (!existsSync18(join19(agentBrain, "cortex")) && !existsSync18(join19(agentBrain, "brainstem"))) continue;
+      try {
+        growNeuron(agentBrain, warnPath);
+        logEpisode(agentBrain, "feedback", warnPath, `shared learning: ${delta.path}`);
+        propagated++;
+        touchedAgents.add(agent);
+      } catch {
+      }
+    }
+  }
+  return { scanned: deltas.length, propagated, agents: [...touchedAgents] };
+}
+function runFeedback(brainRoot) {
+  const deltas = scanSharedBrain(brainRoot);
+  if (deltas.length === 0) {
+    console.log("\u{1F4E1} feedback: no new shared neurons");
+    return { scanned: 0, propagated: 0, agents: [] };
+  }
+  const result = propagateToAgents(brainRoot, deltas);
+  const latestTime = Math.max(...deltas.map((d) => d.modTime.getTime()));
+  writeWatermark(join19(brainRoot, SHARED_DIR), latestTime);
+  console.log(`\u{1F4E1} feedback: ${result.scanned} shared neuron(s) \u2192 ${result.propagated} warning(s) to ${result.agents.join(", ")}`);
+  return result;
+}
+function readWatermark(sharedRoot) {
+  const wmPath = join19(sharedRoot, WATERMARK_FILE);
+  if (!existsSync18(wmPath)) return 0;
+  try {
+    const data = JSON.parse(readFileSync10(wmPath, "utf8"));
+    return data.timestamp || 0;
+  } catch {
+    return 0;
+  }
+}
+function writeWatermark(sharedRoot, timestamp) {
+  const wmPath = join19(sharedRoot, WATERMARK_FILE);
+  mkdirSync11(sharedRoot, { recursive: true });
+  writeFileSync15(wmPath, JSON.stringify({ timestamp, ts: new Date(timestamp).toISOString() }), "utf8");
+}
+function walkForNeurons(dir, regionRoot, cb) {
+  let entries;
+  try {
+    entries = readdirSync11(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const neuronFiles = entries.filter((e) => e.isFile() && /^\d+\.neuron$/.test(e.name));
+  if (neuronFiles.length > 0) {
+    const counter = Math.max(...neuronFiles.map((f) => parseInt(f.name, 10)));
+    cb(dir, counter);
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
+    if (entry.isDirectory()) {
+      walkForNeurons(join19(dir, entry.name), regionRoot, cb);
+    }
+  }
+}
 export {
   AGENTS_DIR,
   DECAY_DAYS,
@@ -2640,6 +2902,7 @@ export {
   MAX_DEPTH,
   MIN_CORRECTION_LENGTH,
   OUTCOME_TYPES,
+  PROPAGATION_EPISODE_TYPES,
   PROTECTED_REGIONS_CONTRA,
   REGIONS,
   REGION_ICONS,
@@ -2648,10 +2911,12 @@ export {
   SESSION_STATE_DIR,
   SHARED_DIR,
   SIGNAL_TYPES,
+  SKILLS_DIR,
   SPOTLIGHT_DAYS,
   appendCorrection,
   buildOutcomeSummary,
   captureSessionStart,
+  checkCron,
   checkHooks,
   classifyOutcome,
   clearReports,
@@ -2668,6 +2933,8 @@ export {
   extractCorrections,
   fireNeuron,
   fromCandidatePath,
+  generateFeedbackPlist,
+  generatePrunePlist,
   getCurrentCounter,
   getLastActivity,
   getPendingReports,
@@ -2675,6 +2942,7 @@ export {
   growCandidate,
   growNeuron,
   initBrain,
+  installCron,
   installHooks,
   jaccardSimilarity,
   listCandidates,
@@ -2683,6 +2951,8 @@ export {
   printDiag,
   processInbox,
   promoteCandidates,
+  propagateToAgents,
+  propagateToShared,
   readEpisodes,
   readHookInput,
   resolveAgentBrain,
@@ -2692,14 +2962,18 @@ export {
   runDecay,
   runDedup,
   runEvolve,
+  runFeedback,
   runSubsumption,
   scanBrain,
+  scanSharedBrain,
+  scanSkills,
   signalNeuron,
   startAPI,
   startWatch,
   stem,
   toCandidatePath,
   tokenize,
+  uninstallCron,
   uninstallHooks,
   writeAllTiers
 };