hebbian 0.7.1 → 0.8.0

package/dist/bin/hebbian.js

@@ -25,6 +25,7 @@ __export(constants_exports, {
   MAX_DEPTH: () => MAX_DEPTH,
   MIN_CORRECTION_LENGTH: () => MIN_CORRECTION_LENGTH,
   OUTCOME_TYPES: () => OUTCOME_TYPES,
+  PROPAGATION_EPISODE_TYPES: () => PROPAGATION_EPISODE_TYPES,
   PROTECTED_REGIONS_CONTRA: () => PROTECTED_REGIONS_CONTRA,
   REGIONS: () => REGIONS,
   REGION_ICONS: () => REGION_ICONS,
@@ -33,6 +34,7 @@ __export(constants_exports, {
   SESSION_STATE_DIR: () => SESSION_STATE_DIR,
   SHARED_DIR: () => SHARED_DIR,
   SIGNAL_TYPES: () => SIGNAL_TYPES,
+  SKILLS_DIR: () => SKILLS_DIR,
   SPOTLIGHT_DAYS: () => SPOTLIGHT_DAYS,
   resolveAgentBrain: () => resolveAgentBrain,
   resolveBrainRoot: () => resolveBrainRoot,
@@ -52,7 +54,7 @@ function resolveAgentBrain(brainRoot, agentName) {
 function resolveSharedBrain(brainRoot) {
   return resolve(brainRoot, "shared");
 }
-var REGIONS, REGION_PRIORITY, REGION_ICONS, REGION_KO, EMIT_THRESHOLD, SPOTLIGHT_DAYS, JACCARD_THRESHOLD, DECAY_DAYS, MAX_DEPTH, EMIT_TARGETS, SIGNAL_TYPES, MARKER_START, MARKER_END, HOOK_MARKER, MAX_CORRECTIONS_PER_SESSION, MIN_CORRECTION_LENGTH, DIGEST_LOG_DIR, OUTCOME_TYPES, SESSION_STATE_DIR, PROTECTED_REGIONS_CONTRA, AGENTS_DIR, SHARED_DIR;
+var REGIONS, REGION_PRIORITY, REGION_ICONS, REGION_KO, EMIT_THRESHOLD, SPOTLIGHT_DAYS, JACCARD_THRESHOLD, DECAY_DAYS, MAX_DEPTH, EMIT_TARGETS, SIGNAL_TYPES, MARKER_START, MARKER_END, HOOK_MARKER, MAX_CORRECTIONS_PER_SESSION, MIN_CORRECTION_LENGTH, DIGEST_LOG_DIR, OUTCOME_TYPES, SESSION_STATE_DIR, PROTECTED_REGIONS_CONTRA, AGENTS_DIR, SHARED_DIR, SKILLS_DIR, PROPAGATION_EPISODE_TYPES;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
@@ -116,6 +118,8 @@ var init_constants = __esm({
     PROTECTED_REGIONS_CONTRA = ["brainstem", "limbic", "sensors"];
     AGENTS_DIR = "agents";
     SHARED_DIR = "shared";
+    SKILLS_DIR = "skills";
+    PROPAGATION_EPISODE_TYPES = ["tool-failure", "retry-pattern"];
   }
 });
 
@@ -156,6 +160,12 @@ ${template.description}
     }
   }
   mkdirSync(join(brainPath, "_agents", "global_inbox"), { recursive: true });
+  mkdirSync(join(brainPath, "skills"), { recursive: true });
+  writeFileSync(
+    join(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(", ")}`);
@@ -229,7 +239,8 @@ var init_init = __esm({
 // src/scanner.ts
 var scanner_exports = {};
 __export(scanner_exports, {
-  scanBrain: () => scanBrain
+  scanBrain: () => scanBrain,
+  scanSkills: () => scanSkills
 });
 import { readdirSync as readdirSync2, statSync, readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
 import { join as join2, relative, sep } from "path";
@@ -354,6 +365,11 @@ function walkRegion(dir, regionRoot, depth) {
   }
   return neurons;
 }
+function scanSkills(brainRoot) {
+  const skillsPath = join2(brainRoot, SKILLS_DIR);
+  if (!existsSync3(skillsPath)) return [];
+  return walkRegion(skillsPath, skillsPath, 0);
+}
 function readAxons(regionPath) {
   const axonPath = join2(regionPath, ".axon");
   if (!existsSync3(axonPath)) return [];
@@ -944,8 +960,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] || "";
@@ -1314,6 +1330,80 @@ 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, {
@@ -1323,10 +1413,11 @@ __export(candidates_exports, {
   growCandidate: () => growCandidate,
   listCandidates: () => listCandidates,
   promoteCandidates: () => promoteCandidates,
+  propagateToShared: () => propagateToShared,
   toCandidatePath: () => toCandidatePath
 });
-import { existsSync as existsSync11, mkdirSync as mkdirSync6, readdirSync as readdirSync7, renameSync as renameSync3, rmSync, statSync as statSync4 } from "fs";
-import { join as join12, dirname as dirname3, relative as relative3 } from "path";
+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}`);
@@ -1340,20 +1431,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 = join12(brainRoot, candidatePath);
-  if (!existsSync11(src)) return false;
-  const dst = join12(brainRoot, targetPath);
-  if (existsSync11(dst)) {
+  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 {
-    mkdirSync6(dirname3(dst), { recursive: true });
+    mkdirSync7(dirname3(dst), { recursive: true });
     renameSync3(src, dst);
   }
   console.log(`\u{1F393} promoted: ${candidatePath} \u2192 ${targetPath}`);
@@ -1365,15 +1457,16 @@ function promoteCandidates(brainRoot) {
   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);
+    const candidateRoot = join13(brainRoot, region, CANDIDATE_SEGMENT);
     walkNeuronDirs(candidateRoot, (neuronDir) => {
-      const rel = relative3(join12(brainRoot, region), 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 });
@@ -1388,9 +1481,9 @@ function listCandidates(brainRoot) {
   const results = [];
   const now = Date.now();
   for (const region of REGIONS) {
-    const candidateRoot = join12(brainRoot, region, CANDIDATE_SEGMENT);
+    const candidateRoot = join13(brainRoot, region, CANDIDATE_SEGMENT);
     walkNeuronDirs(candidateRoot, (neuronDir) => {
-      const rel = relative3(join12(brainRoot, region), neuronDir);
+      const rel = relative3(join13(brainRoot, region), neuronDir);
       const candidatePath = `${region}/${rel}`;
       const targetPath = fromCandidatePath(candidatePath);
       const counter = readCounter(neuronDir);
@@ -1402,9 +1495,9 @@ function listCandidates(brainRoot) {
   return results;
 }
 function walkNeuronDirs(dir, cb) {
-  if (!existsSync11(dir)) return;
+  if (!existsSync12(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);
@@ -1412,7 +1505,7 @@ function walkNeuronDirs(dir, cb) {
     }
     for (const entry of entries) {
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
-        walkNeuronDirs(join12(dir, entry.name), cb);
+        walkNeuronDirs(join13(dir, entry.name), cb);
       }
     }
   } catch {
@@ -1420,13 +1513,33 @@ 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;
   }
 }
+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"() {
@@ -1434,86 +1547,13 @@ var init_candidates = __esm({
     init_constants();
     init_grow();
     init_fire();
+    init_episode();
     CANDIDATE_THRESHOLD = 3;
     CANDIDATE_DECAY_DAYS = 14;
     CANDIDATE_SEGMENT = "_candidates";
   }
 });
 
-// src/episode.ts
-var episode_exports = {};
-__export(episode_exports, {
-  logEpisode: () => logEpisode,
-  readEpisodes: () => readEpisodes
-});
-import { readdirSync as readdirSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync9, mkdirSync as mkdirSync7, existsSync as existsSync12 } from "fs";
-import { join as join13 } from "path";
-function logEpisode(brainRoot, type, path, detail, extra) {
-  const logDir = join13(brainRoot, SESSION_LOG_DIR);
-  if (!existsSync12(logDir)) {
-    mkdirSync7(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(
-    join13(logDir, `memory${nextSlot}.neuron`),
-    JSON.stringify(episode),
-    "utf8"
-  );
-}
-function readEpisodes(brainRoot) {
-  const logDir = join13(brainRoot, SESSION_LOG_DIR);
-  if (!existsSync12(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 = readFileSync5(join13(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 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;
-      }
-    }
-  } 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/inbox.ts
 var inbox_exports = {};
 __export(inbox_exports, {
@@ -3013,6 +3053,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;
@@ -3037,7 +3078,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");
@@ -3082,6 +3127,7 @@ var init_evolve = __esm({
     init_constants();
     init_fire();
     init_candidates();
+    init_grow();
     init_signal();
     init_rollback();
     init_decay();
@@ -3235,11 +3281,260 @@ var init_doctor = __esm({
   }
 });
 
+// src/cron.ts
+var cron_exports = {};
+__export(cron_exports, {
+  checkCron: () => checkCron,
+  generateFeedbackPlist: () => generateFeedbackPlist,
+  generatePrunePlist: () => generatePrunePlist,
+  installCron: () => installCron,
+  uninstallCron: () => uninstallCron
+});
+import { writeFileSync as writeFileSync15, existsSync as existsSync19, unlinkSync as unlinkSync2 } from "fs";
+import { join as join20 } from "path";
+import { execSync as execSync5 } from "child_process";
+function getLaunchAgentsDir() {
+  return join20(process.env.HOME || "~", "Library", "LaunchAgents");
+}
+function getPlistPath(label) {
+  return join20(getLaunchAgentsDir(), `${label}.plist`);
+}
+function getNpxPath() {
+  try {
+    return execSync5("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 {
+    execSync5(`launchctl unload ${plistPath} 2>/dev/null`, { encoding: "utf8" });
+  } catch {
+  }
+  writeFileSync15(plistPath, plistContent, "utf8");
+  execSync5(`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 (!existsSync19(plistPath)) {
+    console.log(`\u26A0\uFE0F ${type} cron not installed`);
+    return;
+  }
+  try {
+    execSync5(`launchctl unload ${plistPath}`, { encoding: "utf8" });
+  } catch {
+  }
+  unlinkSync2(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: existsSync19(plistPath), path: plistPath };
+}
+var PLIST_LABEL, FEEDBACK_PLIST_LABEL;
+var init_cron = __esm({
+  "src/cron.ts"() {
+    "use strict";
+    PLIST_LABEL = "com.hebbian.nightly-prune";
+    FEEDBACK_PLIST_LABEL = "com.hebbian.feedback";
+  }
+});
+
+// src/feedback.ts
+var feedback_exports = {};
+__export(feedback_exports, {
+  propagateToAgents: () => propagateToAgents,
+  runFeedback: () => runFeedback,
+  scanSharedBrain: () => scanSharedBrain
+});
+import { existsSync as existsSync20, readdirSync as readdirSync12, statSync as statSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync16, mkdirSync as mkdirSync12 } from "fs";
+import { join as join21 } from "path";
+function scanSharedBrain(brainRoot) {
+  const sharedRoot = join21(brainRoot, SHARED_DIR);
+  if (!existsSync20(sharedRoot)) return [];
+  const watermark = readWatermark(sharedRoot);
+  const deltas = [];
+  for (const region of REGIONS) {
+    const regionPath = join21(sharedRoot, region);
+    if (!existsSync20(regionPath)) continue;
+    walkForNeurons(regionPath, regionPath, (neuronDir, counter) => {
+      const modTime = statSync6(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 = join21(brainRoot, AGENTS_DIR);
+  if (!existsSync20(agentsDir) || deltas.length === 0) {
+    return { scanned: deltas.length, propagated: 0, agents: [] };
+  }
+  const agentNames = readdirSync12(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 = join21(agentsDir, agent);
+      if (!existsSync20(join21(agentBrain, "cortex")) && !existsSync20(join21(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(join21(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 = join21(sharedRoot, WATERMARK_FILE);
+  if (!existsSync20(wmPath)) return 0;
+  try {
+    const data = JSON.parse(readFileSync12(wmPath, "utf8"));
+    return data.timestamp || 0;
+  } catch {
+    return 0;
+  }
+}
+function writeWatermark(sharedRoot, timestamp) {
+  const wmPath = join21(sharedRoot, WATERMARK_FILE);
+  mkdirSync12(sharedRoot, { recursive: true });
+  writeFileSync16(wmPath, JSON.stringify({ timestamp, ts: new Date(timestamp).toISOString() }), "utf8");
+}
+function walkForNeurons(dir, regionRoot, cb) {
+  let entries;
+  try {
+    entries = readdirSync12(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(join21(dir, entry.name), regionRoot, cb);
+    }
+  }
+}
+var WATERMARK_FILE, WARN_PREFIX;
+var init_feedback = __esm({
+  "src/feedback.ts"() {
+    "use strict";
+    init_constants();
+    init_grow();
+    init_episode();
+    WATERMARK_FILE = "_feedback_watermark.json";
+    WARN_PREFIX = "WARN_shared_";
+  }
+});
+
 // src/cli.ts
 init_constants();
 import { parseArgs } from "util";
 import { resolve as resolve3 } from "path";
-var VERSION = "0.7.1";
+var VERSION = "0.8.0";
 var HELP = `
 hebbian v${VERSION} \u2014 Folder-as-neuron brain for any AI agent.
 
@@ -3550,6 +3845,44 @@ Total: ${episodes.length} sessions`);
       await runDoctor2(brainRoot);
       break;
     }
+    case "cron": {
+      const sub = positionals[1];
+      const { installCron: installCron2, uninstallCron: uninstallCron2, checkCron: checkCron2 } = await Promise.resolve().then(() => (init_cron(), cron_exports));
+      switch (sub) {
+        case "install":
+          installCron2(brainRoot, "prune");
+          break;
+        case "uninstall":
+          uninstallCron2("prune");
+          break;
+        case "status": {
+          const status = checkCron2("prune");
+          console.log(`Pruning cron: ${status.installed ? "\u2705 installed" : "\u274C not installed"}`);
+          if (status.installed) console.log(`   ${status.path}`);
+          const fbStatus = checkCron2("feedback");
+          console.log(`Feedback cron: ${fbStatus.installed ? "\u2705 installed" : "\u274C not installed"}`);
+          if (fbStatus.installed) console.log(`   ${fbStatus.path}`);
+          break;
+        }
+        default:
+          console.error("Usage: hebbian cron <install|uninstall|status>");
+          process.exit(1);
+      }
+      break;
+    }
+    case "feedback": {
+      const sub = positionals[1];
+      const { runFeedback: runFeedback2 } = await Promise.resolve().then(() => (init_feedback(), feedback_exports));
+      switch (sub) {
+        case "scan":
+          runFeedback2(brainRoot);
+          break;
+        default:
+          console.error("Usage: hebbian feedback <scan>");
+          process.exit(1);
+      }
+      break;
+    }
     case "diag":
     case "stats": {
       const { scanBrain: scanBrain2 } = await Promise.resolve().then(() => (init_scanner(), scanner_exports));