hebbian 0.7.1 → 0.8.1

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, {
@@ -2129,6 +2169,7 @@ var init_hooks = __esm({
 var digest_exports = {};
 __export(digest_exports, {
   detectRetryPatterns: () => detectRetryPatterns,
+  detectSoftFailure: () => detectSoftFailure,
   detectToolFailure: () => detectToolFailure,
   digestTranscript: () => digestTranscript,
   extractCorrections: () => extractCorrections,
@@ -2157,12 +2198,21 @@ function digestTranscript(brainRoot, transcriptPath, sessionId) {
   const resolvedSessionId = sessionId || basename(transcriptPath, ".jsonl");
   const logDir = join16(brainRoot, DIGEST_LOG_DIR);
   const logPath = join16(logDir, `${resolvedSessionId}.jsonl`);
-  if (existsSync15(logPath)) {
+  const content = readFileSync8(transcriptPath, "utf8");
+  const allLines = content.split("\n").filter(Boolean);
+  const totalLines = allLines.length;
+  const meta = readAuditMeta(logPath);
+  if (existsSync15(logPath) && !meta) {
     console.log(`\u23ED already digested session ${resolvedSessionId}, skip`);
     return { corrections: 0, skipped: 0, toolFailures: 0, transcriptPath, sessionId: resolvedSessionId };
   }
-  const messages = parseTranscript(transcriptPath);
-  const toolFailures = parseToolResults(transcriptPath);
+  const skipLines = meta ? meta.lineCount : 0;
+  if (skipLines >= totalLines) {
+    return { corrections: 0, skipped: 0, toolFailures: 0, transcriptPath, sessionId: resolvedSessionId };
+  }
+  const newLines = allLines.slice(skipLines);
+  const messages = parseTranscriptFromLines(newLines);
+  const toolFailures = parseToolResultsFromLines(newLines);
   for (const failure of toolFailures) {
     logEpisode(brainRoot, "tool-failure", failure.toolName, failure.errorText);
   }
@@ -2177,11 +2227,11 @@ function digestTranscript(brainRoot, transcriptPath, sessionId) {
   const corrections = extractCorrections(messages);
   if (corrections.length === 0 && toolFailures.length === 0) {
     console.log(`\u{1F4DD} digest: no corrections found in session ${resolvedSessionId}`);
-    writeAuditLog(brainRoot, resolvedSessionId, []);
+    writeAuditLog(brainRoot, resolvedSessionId, [], totalLines);
     return { corrections: 0, skipped: messages.length, toolFailures: toolFailures.length, transcriptPath, sessionId: resolvedSessionId };
   }
   if (corrections.length === 0) {
-    writeAuditLog(brainRoot, resolvedSessionId, []);
+    writeAuditLog(brainRoot, resolvedSessionId, [], totalLines);
     return { corrections: 0, skipped: messages.length, toolFailures: toolFailures.length, transcriptPath, sessionId: resolvedSessionId };
   }
   let applied = 0;
@@ -2197,7 +2247,7 @@ function digestTranscript(brainRoot, transcriptPath, sessionId) {
       auditEntries.push({ correction, applied: false });
     }
   }
-  writeAuditLog(brainRoot, resolvedSessionId, auditEntries);
+  writeAuditLog(brainRoot, resolvedSessionId, auditEntries, totalLines);
   console.log(`\u{1F4DD} digest: ${applied} correction(s) from session ${resolvedSessionId}`);
   return {
     corrections: applied,
@@ -2207,9 +2257,7 @@ function digestTranscript(brainRoot, transcriptPath, sessionId) {
     sessionId: resolvedSessionId
   };
 }
-function parseTranscript(transcriptPath) {
-  const content = readFileSync8(transcriptPath, "utf8");
-  const lines = content.split("\n").filter(Boolean);
+function parseTranscriptFromLines(lines) {
   const messages = [];
   for (const line of lines) {
     let entry;
@@ -2236,7 +2284,9 @@ function extractText(content) {
 }
 function parseToolResults(transcriptPath) {
   const content = readFileSync8(transcriptPath, "utf8");
-  const lines = content.split("\n").filter(Boolean);
+  return parseToolResultsFromLines(content.split("\n").filter(Boolean));
+}
+function parseToolResultsFromLines(lines) {
   const failures = [];
   for (const line of lines) {
     if (failures.length >= MAX_FAILURES_PER_SESSION) break;
@@ -2250,9 +2300,13 @@ function parseToolResults(transcriptPath) {
     if (!entry.message || !Array.isArray(entry.message.content)) continue;
     for (const block of entry.message.content) {
       if (block.type !== "tool_result") continue;
-      if (!block.is_error) continue;
-      const failure = detectToolFailure(block, entry.toolUseResult);
-      if (failure) failures.push(failure);
+      if (block.is_error) {
+        const failure = detectToolFailure(block, entry.toolUseResult);
+        if (failure) failures.push(failure);
+      } else {
+        const failure = detectSoftFailure(block, entry.toolUseResult);
+        if (failure) failures.push(failure);
+      }
     }
   }
   return failures;
@@ -2291,6 +2345,30 @@ function detectToolFailure(block, toolUseResult) {
   const toolName = firstLine.trim().slice(0, 80);
   return { toolName, exitCode, errorText: errorText.slice(0, 500) };
 }
+function detectSoftFailure(block, toolUseResult) {
+  let text = "";
+  if (typeof block.content === "string") {
+    text = block.content;
+  } else if (Array.isArray(block.content)) {
+    text = block.content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("\n");
+  }
+  if (toolUseResult && typeof toolUseResult === "object") {
+    if (toolUseResult.stderr) text += "\n" + toolUseResult.stderr;
+  }
+  if (!text) return null;
+  for (const pattern of SOFT_ERROR_PATTERNS) {
+    const match = text.match(pattern);
+    if (match) {
+      const matchedLine = text.split("\n").find((l) => pattern.test(l)) || "unknown";
+      return {
+        toolName: `[soft] ${matchedLine.trim().slice(0, 70)}`,
+        exitCode: 0,
+        errorText: text.slice(0, 500)
+      };
+    }
+  }
+  return null;
+}
 function extractCorrections(messages) {
   const corrections = [];
   for (const text of messages) {
@@ -2465,13 +2543,28 @@ function extractKeywords(text) {
   ]);
   return text.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[^a-zA-Z0-9\u3000-\u9FFF\uAC00-\uD7AF]+/g, " ").toLowerCase().split(/\s+/).filter((t) => t.length > 2 && !STOP_WORDS.has(t));
 }
-function writeAuditLog(brainRoot, sessionId, entries) {
+function readAuditMeta(logPath) {
+  if (!existsSync15(logPath)) return null;
+  try {
+    const content = readFileSync8(logPath, "utf8");
+    const firstLine = content.split("\n")[0];
+    if (!firstLine) return null;
+    const parsed = JSON.parse(firstLine);
+    if (parsed._meta && typeof parsed.lineCount === "number") {
+      return { lineCount: parsed.lineCount };
+    }
+  } catch {
+  }
+  return null;
+}
+function writeAuditLog(brainRoot, sessionId, entries, lineCount) {
   const logDir = join16(brainRoot, DIGEST_LOG_DIR);
   if (!existsSync15(logDir)) {
     mkdirSync10(logDir, { recursive: true });
   }
   const logPath = join16(logDir, `${sessionId}.jsonl`);
-  const lines = entries.map(
+  const metaLine = JSON.stringify({ _meta: true, lineCount, ts: (/* @__PURE__ */ new Date()).toISOString() });
+  const entryLines = entries.map(
     (e) => JSON.stringify({
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       path: e.correction.path,
@@ -2481,9 +2574,9 @@ function writeAuditLog(brainRoot, sessionId, entries) {
       applied: e.applied
     })
   );
-  writeFileSync12(logPath, lines.join("\n") + (lines.length > 0 ? "\n" : ""), "utf8");
+  writeFileSync12(logPath, [metaLine, ...entryLines].join("\n") + "\n", "utf8");
 }
-var NEGATION_PATTERNS, AFFIRMATION_PATTERNS, MUST_PATTERNS, WARN_PATTERNS, MAX_FAILURES_PER_SESSION;
+var NEGATION_PATTERNS, AFFIRMATION_PATTERNS, MUST_PATTERNS, WARN_PATTERNS, MAX_FAILURES_PER_SESSION, SOFT_ERROR_PATTERNS;
 var init_digest = __esm({
   "src/digest.ts"() {
     "use strict";
@@ -2530,6 +2623,14 @@ var init_digest = __esm({
       /주의/
     ];
     MAX_FAILURES_PER_SESSION = 20;
+    SOFT_ERROR_PATTERNS = [
+      /(?:^|\n)\S*(?:\(\w+\):\d+: )?command not found:/m,
+      // shell: command not found
+      /(?:^|\n)npm error\b/m,
+      // npm error (not npm warn)
+      /(?:^|\n)fatal: /m
+      // git fatal
+    ];
   }
 });
 
@@ -3013,6 +3114,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 +3139,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 +3188,7 @@ var init_evolve = __esm({
     init_constants();
     init_fire();
     init_candidates();
+    init_grow();
     init_signal();
     init_rollback();
     init_decay();
@@ -3235,11 +3342,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 +3906,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));