hebbian 0.1.0 → 0.3.0

package/dist/bin/hebbian.js

@@ -0,0 +1,2199 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/constants.ts
+import { resolve } from "path";
+import { existsSync } from "fs";
+function resolveBrainRoot(brainFlag) {
+  if (brainFlag) return resolve(brainFlag);
+  if (process.env.HEBBIAN_BRAIN) return resolve(process.env.HEBBIAN_BRAIN);
+  if (existsSync(resolve("./brain"))) return resolve("./brain");
+  return resolve(process.env.HOME || "~", "hebbian", "brain");
+}
+var REGIONS, REGION_PRIORITY, REGION_ICONS, REGION_KO, EMIT_THRESHOLD, SPOTLIGHT_DAYS, JACCARD_THRESHOLD, MAX_DEPTH, EMIT_TARGETS, SIGNAL_TYPES, MARKER_START, MARKER_END, HOOK_MARKER, MAX_CORRECTIONS_PER_SESSION, MIN_CORRECTION_LENGTH, DIGEST_LOG_DIR;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    REGIONS = [
+      "brainstem",
+      "limbic",
+      "hippocampus",
+      "sensors",
+      "cortex",
+      "ego",
+      "prefrontal"
+    ];
+    REGION_PRIORITY = {
+      brainstem: 0,
+      limbic: 1,
+      hippocampus: 2,
+      sensors: 3,
+      cortex: 4,
+      ego: 5,
+      prefrontal: 6
+    };
+    REGION_ICONS = {
+      brainstem: "\u{1F6E1}\uFE0F",
+      limbic: "\u{1F493}",
+      hippocampus: "\u{1F4DD}",
+      sensors: "\u{1F441}\uFE0F",
+      cortex: "\u{1F9E0}",
+      ego: "\u{1F3AD}",
+      prefrontal: "\u{1F3AF}"
+    };
+    REGION_KO = {
+      brainstem: "\uC591\uC2EC/\uBCF8\uB2A5",
+      limbic: "\uAC10\uC815 \uD544\uD130",
+      hippocampus: "\uAE30\uB85D/\uAE30\uC5B5",
+      sensors: "\uD658\uACBD \uC81C\uC57D",
+      cortex: "\uC9C0\uC2DD/\uAE30\uC220",
+      ego: "\uC131\uD5A5/\uD1A4",
+      prefrontal: "\uBAA9\uD45C/\uACC4\uD68D"
+    };
+    EMIT_THRESHOLD = 5;
+    SPOTLIGHT_DAYS = 7;
+    JACCARD_THRESHOLD = 0.6;
+    MAX_DEPTH = 6;
+    EMIT_TARGETS = {
+      gemini: ".gemini/GEMINI.md",
+      cursor: ".cursorrules",
+      claude: "CLAUDE.md",
+      copilot: ".github/copilot-instructions.md",
+      generic: ".neuronrc"
+    };
+    SIGNAL_TYPES = ["dopamine", "bomb", "memory"];
+    MARKER_START = "<!-- HEBBIAN:START -->";
+    MARKER_END = "<!-- HEBBIAN:END -->";
+    HOOK_MARKER = "[hebbian]";
+    MAX_CORRECTIONS_PER_SESSION = 10;
+    MIN_CORRECTION_LENGTH = 15;
+    DIGEST_LOG_DIR = "hippocampus/digest_log";
+  }
+});
+
+// src/init.ts
+var init_exports = {};
+__export(init_exports, {
+  initBrain: () => initBrain
+});
+import { mkdirSync, writeFileSync, existsSync as existsSync2, readdirSync } from "fs";
+import { join } from "path";
+function initBrain(brainPath) {
+  if (existsSync2(brainPath)) {
+    const entries = readdirSync(brainPath);
+    if (entries.some((e) => REGIONS.includes(e))) {
+      console.log(`\u26A0\uFE0F  Brain already exists at ${brainPath}`);
+      return;
+    }
+  }
+  mkdirSync(brainPath, { recursive: true });
+  for (const regionName of REGIONS) {
+    const regionDir = join(brainPath, regionName);
+    mkdirSync(regionDir, { recursive: true });
+    const template = REGION_TEMPLATES[regionName];
+    const icon = REGION_ICONS[regionName];
+    const ko = REGION_KO[regionName];
+    writeFileSync(
+      join(regionDir, "_rules.md"),
+      `# ${icon} ${regionName} (${ko})
+
+${template.description}
+`,
+      "utf8"
+    );
+    for (const starter of template.starters) {
+      const neuronDir = join(regionDir, starter);
+      mkdirSync(neuronDir, { recursive: true });
+      writeFileSync(join(neuronDir, "1.neuron"), "", "utf8");
+    }
+  }
+  mkdirSync(join(brainPath, "_agents", "global_inbox"), { recursive: true });
+  console.log(`\u{1F9E0} Brain initialized at ${brainPath}`);
+  console.log(`   7 regions created: ${REGIONS.join(", ")}`);
+  console.log("");
+  console.log("   Next steps:");
+  console.log(`   hebbian grow brainstem/NO_your_rule --brain ${brainPath}`);
+  console.log(`   hebbian emit claude --brain ${brainPath}`);
+}
+var REGION_TEMPLATES;
+var init_init = __esm({
+  "src/init.ts"() {
+    "use strict";
+    init_constants();
+    REGION_TEMPLATES = {
+      brainstem: {
+        description: "Absolute principles. Immutable. Read-only conscience.\nP0 \u2014 highest priority. bomb here halts EVERYTHING.",
+        starters: ["NO_fallback", "DO_execute_not_debate"]
+      },
+      limbic: {
+        description: "Emotional filters and somatic markers.\nP1 \u2014 automatic, influences downstream regions.",
+        starters: []
+      },
+      hippocampus: {
+        description: "Memory and episode recording.\nP2 \u2014 accumulated experience, session logs.",
+        starters: []
+      },
+      sensors: {
+        description: "Environment constraints and input validation.\nP3 \u2014 read-only, set by environment.",
+        starters: []
+      },
+      cortex: {
+        description: "Knowledge and skills. The largest region.\nP4 \u2014 learnable, grows with corrections.",
+        starters: []
+      },
+      ego: {
+        description: "Personality, tone, and communication style.\nP5 \u2014 set by user preference.",
+        starters: []
+      },
+      prefrontal: {
+        description: "Goals, projects, and planning.\nP6 \u2014 lowest priority, longest time horizon.",
+        starters: []
+      }
+    };
+  }
+});
+
+// src/scanner.ts
+var scanner_exports = {};
+__export(scanner_exports, {
+  scanBrain: () => scanBrain
+});
+import { readdirSync as readdirSync2, statSync, readFileSync, existsSync as existsSync3 } from "fs";
+import { join as join2, relative, sep } from "path";
+function scanBrain(brainRoot) {
+  const regions = [];
+  for (const regionName of REGIONS) {
+    const regionPath = join2(brainRoot, regionName);
+    if (!existsSync3(regionPath)) {
+      regions.push({
+        name: regionName,
+        priority: REGION_PRIORITY[regionName],
+        path: regionPath,
+        neurons: [],
+        axons: [],
+        hasBomb: false
+      });
+      continue;
+    }
+    const neurons = walkRegion(regionPath, regionPath, 0);
+    const axons = readAxons(regionPath);
+    const hasBomb = neurons.some((n) => n.hasBomb);
+    regions.push({
+      name: regionName,
+      priority: REGION_PRIORITY[regionName],
+      path: regionPath,
+      neurons,
+      axons,
+      hasBomb
+    });
+  }
+  return { root: brainRoot, regions };
+}
+function walkRegion(dir, regionRoot, depth) {
+  if (depth > MAX_DEPTH) return [];
+  const neurons = [];
+  let entries;
+  try {
+    entries = readdirSync2(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  let counter = 0;
+  let contra = 0;
+  let dopamine = 0;
+  let hasBomb = false;
+  let hasMemory = false;
+  let isDormant = false;
+  let modTime = /* @__PURE__ */ new Date(0);
+  let hasTraceFile = false;
+  for (const entry of entries) {
+    if (entry.name.startsWith("_")) continue;
+    if (entry.isFile()) {
+      const name = entry.name;
+      if (name.endsWith(".neuron") && !name.startsWith("dopamine") && !name.startsWith("memory") && name !== "bomb.neuron") {
+        const n = parseInt(name, 10);
+        if (!isNaN(n) && n > counter) {
+          counter = n;
+          hasTraceFile = true;
+          try {
+            const st = statSync(join2(dir, name));
+            if (st.mtime > modTime) modTime = st.mtime;
+          } catch {
+          }
+        }
+      }
+      if (name.endsWith(".contra")) {
+        const n = parseInt(name, 10);
+        if (!isNaN(n) && n > contra) {
+          contra = n;
+          hasTraceFile = true;
+        }
+      }
+      if (name.startsWith("dopamine") && name.endsWith(".neuron")) {
+        const n = parseInt(name.replace("dopamine", ""), 10);
+        if (!isNaN(n) && n > dopamine) {
+          dopamine = n;
+          hasTraceFile = true;
+        }
+      }
+      if (name === "bomb.neuron") {
+        hasBomb = true;
+        hasTraceFile = true;
+      }
+      if (name.startsWith("memory") && name.endsWith(".neuron")) {
+        hasMemory = true;
+        hasTraceFile = true;
+      }
+      if (name.endsWith(".dormant")) {
+        isDormant = true;
+        hasTraceFile = true;
+      }
+    }
+  }
+  if (hasTraceFile) {
+    const relPath = relative(regionRoot, dir) || ".";
+    const folderName = dir.split(sep).pop() || "";
+    const total = counter + contra + dopamine;
+    const intensity = counter - contra + dopamine;
+    const polarity = total > 0 ? intensity / total : 0;
+    neurons.push({
+      name: folderName,
+      path: relPath,
+      fullPath: dir,
+      counter,
+      contra,
+      dopamine,
+      intensity,
+      polarity: Math.round(polarity * 100) / 100,
+      hasBomb,
+      hasMemory,
+      isDormant,
+      depth,
+      modTime
+    });
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
+    if (entry.isDirectory()) {
+      const subNeurons = walkRegion(join2(dir, entry.name), regionRoot, depth + 1);
+      neurons.push(...subNeurons);
+    }
+  }
+  return neurons;
+}
+function readAxons(regionPath) {
+  const axonPath = join2(regionPath, ".axon");
+  if (!existsSync3(axonPath)) return [];
+  try {
+    const content = readFileSync(axonPath, "utf8").trim();
+    return content.split(/[\n,]+/).map((s) => s.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+var init_scanner = __esm({
+  "src/scanner.ts"() {
+    "use strict";
+    init_constants();
+  }
+});
+
+// src/subsumption.ts
+var subsumption_exports = {};
+__export(subsumption_exports, {
+  runSubsumption: () => runSubsumption
+});
+function runSubsumption(brain) {
+  const activeRegions = [];
+  const blockedRegions = [];
+  let bombSource = "";
+  let firedNeurons = 0;
+  let totalNeurons = 0;
+  let totalCounter = 0;
+  let blocked = false;
+  for (const region of brain.regions) {
+    totalNeurons += region.neurons.length;
+    if (blocked) {
+      blockedRegions.push(region);
+      continue;
+    }
+    if (region.hasBomb) {
+      bombSource = region.name;
+      blockedRegions.push(region);
+      blocked = true;
+      continue;
+    }
+    activeRegions.push(region);
+    for (const neuron of region.neurons) {
+      if (!neuron.isDormant) {
+        firedNeurons++;
+        totalCounter += neuron.counter;
+      }
+    }
+  }
+  return {
+    activeRegions,
+    blockedRegions,
+    bombSource,
+    firedNeurons,
+    totalNeurons,
+    totalCounter
+  };
+}
+var init_subsumption = __esm({
+  "src/subsumption.ts"() {
+    "use strict";
+  }
+});
+
+// src/emit.ts
+var emit_exports = {};
+__export(emit_exports, {
+  emitBootstrap: () => emitBootstrap,
+  emitIndex: () => emitIndex,
+  emitRegionRules: () => emitRegionRules,
+  emitToTarget: () => emitToTarget,
+  printDiag: () => printDiag,
+  writeAllTiers: () => writeAllTiers
+});
+import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3, dirname } from "path";
+function emitBootstrap(result, brain) {
+  const lines = [];
+  const now = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+Z$/, "");
+  lines.push(MARKER_START);
+  lines.push(`<!-- Generated: ${now} -->`);
+  lines.push("<!-- Axiom: Folder=Neuron | File=Trace | Path=Sentence -->");
+  lines.push(`<!-- Active: ${result.firedNeurons}/${result.totalNeurons} neurons | Total activation: ${result.totalCounter} -->`);
+  lines.push("");
+  if (result.bombSource) {
+    lines.push(`## \u{1F6A8} CIRCUIT BREAKER: ${result.bombSource}`);
+    lines.push("**ALL OPERATIONS HALTED. REPAIR REQUIRED.**");
+    lines.push("");
+    lines.push(MARKER_END);
+    return lines.join("\n");
+  }
+  lines.push("## hebbian Active Rules");
+  lines.push("");
+  lines.push(`### ${REGION_ICONS.ego} Persona`);
+  for (const region of result.activeRegions) {
+    if (region.name === "ego") {
+      const top = sortedActive(region.neurons, 10);
+      for (const n of top) {
+        lines.push(`- ${pathToSentence(n.path)}`);
+      }
+      break;
+    }
+  }
+  lines.push("");
+  lines.push("### \u{1F517} Subsumption Cascade");
+  lines.push("```");
+  lines.push("brainstem \u2190\u2192 limbic \u2190\u2192 hippocampus \u2190\u2192 sensors \u2190\u2192 cortex \u2190\u2192 ego \u2190\u2192 prefrontal");
+  lines.push("  (P0)         (P1)       (P2)          (P3)       (P4)     (P5)      (P6)");
+  lines.push("```");
+  lines.push("Lower P always overrides higher P. bomb = full stop.");
+  lines.push("");
+  lines.push(`### ${REGION_ICONS.brainstem} Core Directives TOP 5`);
+  for (const region of result.activeRegions) {
+    if (region.name === "brainstem") {
+      const top = sortedActive(region.neurons, 5);
+      top.forEach((n, i) => {
+        lines.push(`${i + 1}. **${pathToSentence(n.path)}**`);
+      });
+      break;
+    }
+  }
+  lines.push("");
+  lines.push("### Active Regions");
+  lines.push("| Region | Neurons | Activation |");
+  lines.push("|--------|---------|------------|");
+  for (const region of result.activeRegions) {
+    const active = region.neurons.filter((n) => !n.isDormant);
+    const activation = active.reduce((sum, n) => sum + n.counter, 0);
+    const icon = REGION_ICONS[region.name] || "";
+    lines.push(`| ${icon} ${region.name} | ${active.length} | ${activation} |`);
+  }
+  lines.push("");
+  lines.push(MARKER_END);
+  return lines.join("\n");
+}
+function emitIndex(result, brain) {
+  const lines = [];
+  lines.push("# hebbian Brain Index");
+  lines.push("");
+  lines.push(`> ${result.firedNeurons} active / ${result.totalNeurons} total neurons | activation: ${result.totalCounter}`);
+  lines.push("");
+  if (result.bombSource) {
+    lines.push(`## \u{1F6A8} CIRCUIT BREAKER: ${result.bombSource}`);
+    lines.push("");
+    return lines.join("\n");
+  }
+  const allNeurons = result.activeRegions.flatMap(
+    (r) => r.neurons.filter((n) => !n.isDormant && n.counter >= EMIT_THRESHOLD)
+  );
+  allNeurons.sort((a, b) => b.counter - a.counter);
+  lines.push("## Top 10 Active Neurons");
+  lines.push("| # | Path | Counter | Strength |");
+  lines.push("|---|------|---------|----------|");
+  for (const n of allNeurons.slice(0, 10)) {
+    const strength = n.counter >= 10 ? "\u{1F534}" : n.counter >= 5 ? "\u{1F7E1}" : "\u26AA";
+    lines.push(`| ${allNeurons.indexOf(n) + 1} | ${n.path} | ${n.counter} | ${strength} |`);
+  }
+  lines.push("");
+  const cutoff = new Date(Date.now() - SPOTLIGHT_DAYS * 24 * 60 * 60 * 1e3);
+  const spotlightNeurons = result.activeRegions.flatMap(
+    (r) => r.neurons.filter((n) => !n.isDormant && n.counter < EMIT_THRESHOLD && n.modTime > cutoff)
+  );
+  if (spotlightNeurons.length > 0) {
+    lines.push("## Spotlight (Probation)");
+    for (const n of spotlightNeurons) {
+      lines.push(`- ${n.path} (${n.counter}) \u2014 new`);
+    }
+    lines.push("");
+  }
+  lines.push("## Regions");
+  lines.push("| Region | Active | Dormant | Activation | Rules |");
+  lines.push("|--------|--------|---------|------------|-------|");
+  for (const region of result.activeRegions) {
+    const active = region.neurons.filter((n) => !n.isDormant);
+    const dormant = region.neurons.filter((n) => n.isDormant);
+    const activation = active.reduce((sum, n) => sum + n.counter, 0);
+    const icon = REGION_ICONS[region.name] || "";
+    lines.push(`| ${icon} ${region.name} | ${active.length} | ${dormant.length} | ${activation} | [_rules.md](${region.name}/_rules.md) |`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function emitRegionRules(region) {
+  const icon = REGION_ICONS[region.name] || "";
+  const ko = REGION_KO[region.name] || "";
+  const active = region.neurons.filter((n) => !n.isDormant);
+  const dormant = region.neurons.filter((n) => n.isDormant);
+  const activation = active.reduce((sum, n) => sum + n.counter, 0);
+  const lines = [];
+  lines.push(`# ${icon} ${region.name} (${ko})`);
+  lines.push(`> Active: ${active.length} | Dormant: ${dormant.length} | Activation: ${activation}`);
+  lines.push("");
+  if (region.axons.length > 0) {
+    lines.push("## Connections");
+    for (const axon of region.axons) {
+      lines.push(`- \u2194 ${axon}`);
+    }
+    lines.push("");
+  }
+  if (active.length > 0) {
+    lines.push("## Rules");
+    const sorted = [...active].sort((a, b) => b.counter - a.counter);
+    for (const n of sorted) {
+      const indent = "  ".repeat(Math.min(n.depth, 4));
+      const prefix = strengthPrefix(n.counter);
+      const signals = [];
+      if (n.dopamine > 0) signals.push(`\u{1F7E2}+${n.dopamine}`);
+      if (n.hasBomb) signals.push("\u{1F4A3}");
+      if (n.hasMemory) signals.push("\u{1F4BE}");
+      const signalStr = signals.length > 0 ? ` ${signals.join(" ")}` : "";
+      lines.push(`${indent}- ${prefix}${pathToSentence(n.path)} (${n.counter})${signalStr}`);
+    }
+    lines.push("");
+  }
+  if (dormant.length > 0) {
+    lines.push("## Dormant");
+    for (const n of dormant) {
+      lines.push(`- ~~${pathToSentence(n.path)} (${n.counter})~~`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function emitToTarget(brainRoot, target) {
+  const brain = scanBrain(brainRoot);
+  const result = runSubsumption(brain);
+  const content = emitBootstrap(result, brain);
+  if (target === "all") {
+    for (const [name, filePath] of Object.entries(EMIT_TARGETS)) {
+      writeTarget(filePath, content);
+      console.log(`\u{1F4E4} emitted: ${name} \u2192 ${filePath}`);
+    }
+  } else if (EMIT_TARGETS[target]) {
+    writeTarget(EMIT_TARGETS[target], content);
+    console.log(`\u{1F4E4} emitted: ${target} \u2192 ${EMIT_TARGETS[target]}`);
+  } else {
+    throw new Error(`Unknown target: ${target}. Valid: ${Object.keys(EMIT_TARGETS).join(", ")}, all`);
+  }
+  writeAllTiers(brainRoot, result, brain);
+}
+function writeAllTiers(brainRoot, result, brain) {
+  const indexContent = emitIndex(result, brain);
+  writeFileSync2(join3(brainRoot, "_index.md"), indexContent, "utf8");
+  for (const region of result.activeRegions) {
+    if (existsSync4(region.path)) {
+      const rulesContent = emitRegionRules(region);
+      writeFileSync2(join3(region.path, "_rules.md"), rulesContent, "utf8");
+    }
+  }
+}
+function writeTarget(filePath, content) {
+  const dir = dirname(filePath);
+  if (dir !== "." && !existsSync4(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  if (existsSync4(filePath)) {
+    const existing = readFileSync2(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");
+      return;
+    }
+  }
+  writeFileSync2(filePath, content, "utf8");
+}
+function printDiag(brain, result) {
+  console.log("");
+  console.log(`\u{1F9E0} hebbian Brain Diagnostics`);
+  console.log(`   Root: ${brain.root}`);
+  console.log(`   Neurons: ${result.firedNeurons} active / ${result.totalNeurons} total`);
+  console.log(`   Activation: ${result.totalCounter}`);
+  if (result.bombSource) {
+    console.log(`   \u{1F4A3} BOMB: ${result.bombSource} \u2014 cascade halted!`);
+  }
+  console.log("");
+  for (const region of brain.regions) {
+    const icon = REGION_ICONS[region.name] || "";
+    const active = region.neurons.filter((n) => !n.isDormant);
+    const dormant = region.neurons.filter((n) => n.isDormant);
+    const activation = active.reduce((sum, n) => sum + n.counter, 0);
+    const isBlocked = result.blockedRegions.some((r) => r.name === region.name);
+    const status = region.hasBomb ? "\u{1F4A3} BOMB" : isBlocked ? "\u{1F6AB} BLOCKED" : "\u2705 ACTIVE";
+    console.log(`   ${icon} ${region.name} [${status}]`);
+    console.log(`      neurons: ${active.length} active, ${dormant.length} dormant | activation: ${activation}`);
+    if (region.axons.length > 0) {
+      console.log(`      axons: ${region.axons.join(", ")}`);
+    }
+    const top3 = sortedActive(region.neurons, 3);
+    for (const n of top3) {
+      console.log(`      \u251C ${n.path} (${n.counter})`);
+    }
+  }
+  console.log("");
+}
+function pathToSentence(path) {
+  return path.replace(/\//g, " > ").replace(/_/g, " ");
+}
+function sortedActive(neurons, n) {
+  return [...neurons].filter((neuron) => !neuron.isDormant).sort((a, b) => b.counter - a.counter).slice(0, n);
+}
+function strengthPrefix(counter) {
+  if (counter >= 10) return "**[ABSOLUTE]** ";
+  if (counter >= 5) return "**[MUST]** ";
+  return "";
+}
+var init_emit = __esm({
+  "src/emit.ts"() {
+    "use strict";
+    init_scanner();
+    init_subsumption();
+    init_constants();
+  }
+});
+
+// src/fire.ts
+var fire_exports = {};
+__export(fire_exports, {
+  fireNeuron: () => fireNeuron,
+  getCurrentCounter: () => getCurrentCounter
+});
+import { readdirSync as readdirSync3, renameSync, writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
+import { join as join4 } from "path";
+function fireNeuron(brainRoot, neuronPath) {
+  const fullPath = join4(brainRoot, neuronPath);
+  if (!existsSync5(fullPath)) {
+    mkdirSync3(fullPath, { recursive: true });
+    writeFileSync3(join4(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(join4(fullPath, `${current}.neuron`), join4(fullPath, `${newCounter}.neuron`));
+  } else {
+    writeFileSync3(join4(fullPath, `${newCounter}.neuron`), "", "utf8");
+  }
+  console.log(`\u{1F525} fired: ${neuronPath} (${current} \u2192 ${newCounter})`);
+  return newCounter;
+}
+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(/[_\-\s]+/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 mkdirSync4, writeFileSync as writeFileSync4, existsSync as existsSync6, readdirSync as readdirSync4 } from "fs";
+import { join as join5, relative as relative2 } from "path";
+function growNeuron(brainRoot, neuronPath) {
+  const fullPath = join5(brainRoot, neuronPath);
+  if (existsSync6(fullPath)) {
+    const counter = fireNeuron(brainRoot, neuronPath);
+    return { action: "fired", path: neuronPath, counter };
+  }
+  const parts = neuronPath.split("/");
+  const regionName = parts[0];
+  if (!REGIONS.includes(regionName)) {
+    throw new Error(`Invalid region: ${regionName}. Valid: ${REGIONS.join(", ")}`);
+  }
+  const leafName = parts[parts.length - 1];
+  const newTokens = tokenize(leafName);
+  const regionPath = join5(brainRoot, regionName);
+  if (existsSync6(regionPath)) {
+    const match = findSimilar(regionPath, regionPath, newTokens);
+    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 };
+    }
+  }
+  mkdirSync4(fullPath, { recursive: true });
+  writeFileSync4(join5(fullPath, "1.neuron"), "", "utf8");
+  console.log(`\u{1F331} grew: ${neuronPath} (1)`);
+  return { action: "grew", path: neuronPath, counter: 1 };
+}
+function findSimilar(dir, regionRoot, targetTokens) {
+  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 existingTokens = tokenize(folderName);
+    const similarity = jaccardSimilarity(targetTokens, existingTokens);
+    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(join5(dir, entry.name), regionRoot, targetTokens);
+      if (match) return match;
+    }
+  }
+  return null;
+}
+var init_grow = __esm({
+  "src/grow.ts"() {
+    "use strict";
+    init_constants();
+    init_similarity();
+    init_fire();
+  }
+});
+
+// src/rollback.ts
+var rollback_exports = {};
+__export(rollback_exports, {
+  rollbackNeuron: () => rollbackNeuron
+});
+import { renameSync as renameSync2 } from "fs";
+import { join as join6 } from "path";
+function rollbackNeuron(brainRoot, neuronPath) {
+  const fullPath = join6(brainRoot, neuronPath);
+  const current = getCurrentCounter(fullPath);
+  if (current === 0) {
+    throw new Error(`Neuron not found: ${neuronPath}`);
+  }
+  if (current <= 1) {
+    throw new Error(`Counter already at minimum (1): ${neuronPath}`);
+  }
+  const newCounter = current - 1;
+  renameSync2(join6(fullPath, `${current}.neuron`), join6(fullPath, `${newCounter}.neuron`));
+  console.log(`\u23EA rollback: ${neuronPath} (${current} \u2192 ${newCounter})`);
+  return newCounter;
+}
+var init_rollback = __esm({
+  "src/rollback.ts"() {
+    "use strict";
+    init_fire();
+  }
+});
+
+// src/signal.ts
+var signal_exports = {};
+__export(signal_exports, {
+  signalNeuron: () => signalNeuron
+});
+import { writeFileSync as writeFileSync5, existsSync as existsSync7, readdirSync as readdirSync5 } from "fs";
+import { join as join7 } 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 = join7(brainRoot, neuronPath);
+  if (!existsSync7(fullPath)) {
+    throw new Error(`Neuron not found: ${neuronPath}`);
+  }
+  switch (signalType) {
+    case "bomb": {
+      writeFileSync5(join7(fullPath, "bomb.neuron"), "", "utf8");
+      console.log(`\u{1F4A3} bomb planted: ${neuronPath}`);
+      break;
+    }
+    case "dopamine": {
+      const level = getNextSignalLevel(fullPath, "dopamine");
+      writeFileSync5(join7(fullPath, `dopamine${level}.neuron`), "", "utf8");
+      console.log(`\u{1F7E2} dopamine +${level}: ${neuronPath}`);
+      break;
+    }
+    case "memory": {
+      const level = getNextSignalLevel(fullPath, "memory");
+      writeFileSync5(join7(fullPath, `memory${level}.neuron`), "", "utf8");
+      console.log(`\u{1F4BE} memory +${level}: ${neuronPath}`);
+      break;
+    }
+  }
+}
+function getNextSignalLevel(dir, prefix) {
+  let max = 0;
+  try {
+    for (const entry of readdirSync5(dir)) {
+      if (entry.startsWith(prefix) && entry.endsWith(".neuron")) {
+        const n = parseInt(entry.replace(prefix, ""), 10);
+        if (!isNaN(n) && n > max) max = n;
+      }
+    }
+  } catch {
+  }
+  return max + 1;
+}
+var init_signal = __esm({
+  "src/signal.ts"() {
+    "use strict";
+    init_constants();
+  }
+});
+
+// src/decay.ts
+var decay_exports = {};
+__export(decay_exports, {
+  runDecay: () => runDecay
+});
+import { readdirSync as readdirSync6, statSync as statSync2, writeFileSync as writeFileSync6, existsSync as existsSync8 } from "fs";
+import { join as join8 } 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 = join8(brainRoot, regionName);
+    if (!existsSync8(regionPath)) continue;
+    const result = decayWalk(regionPath, threshold, 0);
+    scanned += result.scanned;
+    decayed += result.decayed;
+  }
+  console.log(`\u{1F4A4} decay: scanned ${scanned} neurons, decayed ${decayed} (>${days} days inactive)`);
+  return { scanned, decayed };
+}
+function decayWalk(dir, threshold, depth) {
+  if (depth > MAX_DEPTH) return { scanned: 0, decayed: 0 };
+  let scanned = 0;
+  let decayed = 0;
+  let entries;
+  try {
+    entries = readdirSync6(dir, { withFileTypes: true });
+  } catch {
+    return { scanned: 0, decayed: 0 };
+  }
+  let hasNeuronFile = false;
+  let isDormant = false;
+  let latestMod = 0;
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      if (entry.name.endsWith(".neuron")) {
+        hasNeuronFile = true;
+        try {
+          const st = statSync2(join8(dir, entry.name));
+          if (st.mtimeMs > latestMod) latestMod = st.mtimeMs;
+        } catch {
+        }
+      }
+      if (entry.name.endsWith(".dormant")) {
+        isDormant = true;
+      }
+    }
+  }
+  if (hasNeuronFile) {
+    scanned++;
+    if (!isDormant && latestMod < threshold) {
+      const age = Math.floor((Date.now() - latestMod) / (24 * 60 * 60 * 1e3));
+      writeFileSync6(
+        join8(dir, "decay.dormant"),
+        `Dormant since ${(/* @__PURE__ */ new Date()).toISOString()} (${age} days inactive)`,
+        "utf8"
+      );
+      decayed++;
+    }
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
+    if (entry.isDirectory()) {
+      const sub = decayWalk(join8(dir, entry.name), threshold, depth + 1);
+      scanned += sub.scanned;
+      decayed += sub.decayed;
+    }
+  }
+  return { scanned, decayed };
+}
+var init_decay = __esm({
+  "src/decay.ts"() {
+    "use strict";
+    init_constants();
+  }
+});
+
+// src/dedup.ts
+var dedup_exports = {};
+__export(dedup_exports, {
+  runDedup: () => runDedup
+});
+import { writeFileSync as writeFileSync7 } from "fs";
+import { join as join9 } from "path";
+function runDedup(brainRoot) {
+  const brain = scanBrain(brainRoot);
+  let scanned = 0;
+  let merged = 0;
+  for (const region of brain.regions) {
+    const neurons = region.neurons.filter((n) => !n.isDormant);
+    scanned += neurons.length;
+    const consumed = /* @__PURE__ */ new Set();
+    for (let i = 0; i < neurons.length; i++) {
+      if (consumed.has(i)) continue;
+      const ni = neurons[i];
+      const tokensI = tokenize(ni.name);
+      for (let j = i + 1; j < neurons.length; j++) {
+        if (consumed.has(j)) continue;
+        const nj = neurons[j];
+        const tokensJ = tokenize(nj.name);
+        const sim = jaccardSimilarity(tokensI, tokensJ);
+        if (sim >= JACCARD_THRESHOLD) {
+          const [keep, drop] = ni.counter >= nj.counter ? [ni, nj] : [nj, ni];
+          const relKeep = `${region.name}/${keep.path}`;
+          fireNeuron(brainRoot, relKeep);
+          writeFileSync7(
+            join9(drop.fullPath, "dedup.dormant"),
+            `Merged into ${keep.path} on ${(/* @__PURE__ */ new Date()).toISOString()}`,
+            "utf8"
+          );
+          consumed.add(ni === drop ? i : j);
+          merged++;
+          console.log(`\u{1F500} merged: "${drop.path}" \u2192 "${keep.path}" (sim=${sim.toFixed(2)})`);
+        }
+      }
+    }
+  }
+  console.log(`\u{1F9F9} dedup: scanned ${scanned} neurons, merged ${merged}`);
+  return { scanned, merged };
+}
+var init_dedup = __esm({
+  "src/dedup.ts"() {
+    "use strict";
+    init_constants();
+    init_similarity();
+    init_fire();
+    init_scanner();
+  }
+});
+
+// src/snapshot.ts
+var snapshot_exports = {};
+__export(snapshot_exports, {
+  gitSnapshot: () => gitSnapshot
+});
+import { execSync } from "child_process";
+import { existsSync as existsSync9 } from "fs";
+import { join as join10 } from "path";
+function gitSnapshot(brainRoot) {
+  if (!existsSync9(join10(brainRoot, ".git"))) {
+    try {
+      execSync("git rev-parse --is-inside-work-tree", { cwd: brainRoot, stdio: "pipe" });
+    } catch {
+      console.log("\u26A0\uFE0F  Not a git repository. Run `git init` in the brain directory first.");
+      return false;
+    }
+  }
+  try {
+    const status = execSync("git status --porcelain .", { cwd: brainRoot, encoding: "utf8" });
+    if (!status.trim()) {
+      console.log("\u2705 No changes to snapshot.");
+      return false;
+    }
+    execSync("git add .", { cwd: brainRoot, stdio: "pipe" });
+    const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    execSync(`git commit -m "hebbian snapshot ${ts}"`, { cwd: brainRoot, stdio: "pipe" });
+    console.log(`\u{1F4F8} snapshot: committed brain state at ${ts}`);
+    return true;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`\u274C snapshot failed: ${message}`);
+    return false;
+  }
+}
+var init_snapshot = __esm({
+  "src/snapshot.ts"() {
+    "use strict";
+  }
+});
+
+// src/watch.ts
+var watch_exports = {};
+__export(watch_exports, {
+  startWatch: () => startWatch
+});
+import { watch } from "fs";
+async function startWatch(brainRoot) {
+  let lastHash = "";
+  let debounceTimer = null;
+  function recompile() {
+    const brain = scanBrain(brainRoot);
+    const result = runSubsumption(brain);
+    const hash = computeHash(result);
+    if (hash === lastHash) return;
+    lastHash = hash;
+    writeAllTiers(brainRoot, result, brain);
+    const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+    console.log(`[${ts}] \u{1F504} recompiled \u2014 ${result.firedNeurons} neurons, activation ${result.totalCounter}${result.bombSource ? ` \u{1F4A3} BOMB: ${result.bombSource}` : ""}`);
+  }
+  recompile();
+  console.log(`\u{1F440} watching: ${brainRoot}`);
+  console.log("   Press Ctrl+C to stop.\n");
+  try {
+    const watcher = watch(brainRoot, { recursive: true }, (eventType, filename) => {
+      if (!filename) return;
+      if (filename.endsWith("_index.md") || filename.endsWith("_rules.md")) return;
+      if (filename.startsWith(".") || filename.includes("/_") || filename.includes("\\_")) return;
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(recompile, 200);
+    });
+    await new Promise((resolve4) => {
+      process.on("SIGINT", () => {
+        watcher.close();
+        console.log("\n\u{1F44B} watch stopped.");
+        resolve4();
+      });
+    });
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code === "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM") {
+      console.error("Recursive fs.watch not supported on this platform. Use Node.js >= 22.");
+    } else {
+      throw err;
+    }
+  }
+}
+function computeHash(result) {
+  return `${result.firedNeurons}:${result.totalCounter}:${result.bombSource}:${result.activeRegions.length}`;
+}
+var init_watch = __esm({
+  "src/watch.ts"() {
+    "use strict";
+    init_scanner();
+    init_subsumption();
+    init_emit();
+  }
+});
+
+// src/episode.ts
+import { readdirSync as readdirSync7, readFileSync as readFileSync3, writeFileSync as writeFileSync8, mkdirSync as mkdirSync5, existsSync as existsSync10 } from "fs";
+import { join as join11 } from "path";
+function logEpisode(brainRoot, type, path, detail) {
+  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
+  };
+  writeFileSync8(
+    join11(logDir, `memory${nextSlot}.neuron`),
+    JSON.stringify(episode),
+    "utf8"
+  );
+}
+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/inbox.ts
+var inbox_exports = {};
+__export(inbox_exports, {
+  appendCorrection: () => appendCorrection,
+  ensureInbox: () => ensureInbox,
+  processInbox: () => processInbox
+});
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync9, existsSync as existsSync11, mkdirSync as mkdirSync6 } from "fs";
+import { join as join12 } from "path";
+function processInbox(brainRoot) {
+  const inboxPath = join12(brainRoot, INBOX_DIR, CORRECTIONS_FILE);
+  if (!existsSync11(inboxPath)) {
+    return { processed: 0, skipped: 0, errors: [] };
+  }
+  const content = readFileSync4(inboxPath, "utf8").trim();
+  if (!content) {
+    return { processed: 0, skipped: 0, errors: [] };
+  }
+  const lines = content.split("\n").filter(Boolean);
+  let processed = 0;
+  let skipped = 0;
+  const errors = [];
+  for (const line of lines) {
+    let correction;
+    try {
+      correction = JSON.parse(line);
+    } catch {
+      errors.push(`Malformed JSON: ${line.slice(0, 80)}`);
+      skipped++;
+      continue;
+    }
+    if (!correction.path || !correction.type) {
+      errors.push(`Missing path or type: ${line.slice(0, 80)}`);
+      skipped++;
+      continue;
+    }
+    if (!isPathSafe(correction.path)) {
+      errors.push(`Path traversal blocked: ${correction.path}`);
+      skipped++;
+      continue;
+    }
+    const region = correction.path.split("/")[0];
+    if (!region || !REGIONS.includes(region)) {
+      errors.push(`Invalid region in path: ${correction.path}`);
+      skipped++;
+      continue;
+    }
+    try {
+      applyCorrection(brainRoot, correction);
+      processed++;
+    } catch (err) {
+      errors.push(`Failed to apply ${correction.path}: ${err.message}`);
+      skipped++;
+    }
+  }
+  writeFileSync9(inboxPath, "", "utf8");
+  console.log(`\u{1F4E5} inbox: processed ${processed}, skipped ${skipped}`);
+  if (errors.length > 0) {
+    for (const err of errors) {
+      console.log(`   \u26A0\uFE0F  ${err}`);
+    }
+  }
+  return { processed, skipped, errors };
+}
+function applyCorrection(brainRoot, correction) {
+  const neuronPath = correction.path;
+  const fullPath = join12(brainRoot, neuronPath);
+  const counterAdd = Math.max(1, correction.counter_add || 1);
+  if (existsSync11(fullPath)) {
+    for (let i = 0; i < counterAdd; i++) {
+      fireNeuron(brainRoot, neuronPath);
+    }
+  } else {
+    growNeuron(brainRoot, neuronPath);
+    for (let i = 1; i < counterAdd; i++) {
+      fireNeuron(brainRoot, neuronPath);
+    }
+  }
+  if (correction.dopamine && correction.dopamine > 0) {
+    const author = (correction.author || "").toLowerCase();
+    if (DOPAMINE_ALLOWED_ROLES.includes(author)) {
+      signalNeuron(brainRoot, neuronPath, "dopamine");
+    }
+  }
+  logEpisode(brainRoot, "inbox", neuronPath, correction.text || "");
+}
+function isPathSafe(path) {
+  if (path.includes("..")) return false;
+  if (path.startsWith("/")) return false;
+  if (path.includes("\\")) return false;
+  if (path.includes("\0")) return false;
+  return true;
+}
+function ensureInbox(brainRoot) {
+  const inboxDir = join12(brainRoot, INBOX_DIR);
+  if (!existsSync11(inboxDir)) {
+    mkdirSync6(inboxDir, { recursive: true });
+  }
+  const filePath = join12(inboxDir, CORRECTIONS_FILE);
+  if (!existsSync11(filePath)) {
+    writeFileSync9(filePath, "", "utf8");
+  }
+  return filePath;
+}
+function appendCorrection(brainRoot, correction) {
+  const filePath = ensureInbox(brainRoot);
+  const line = JSON.stringify(correction) + "\n";
+  const existing = readFileSync4(filePath, "utf8");
+  writeFileSync9(filePath, existing + line, "utf8");
+}
+var INBOX_DIR, CORRECTIONS_FILE, DOPAMINE_ALLOWED_ROLES;
+var init_inbox = __esm({
+  "src/inbox.ts"() {
+    "use strict";
+    init_constants();
+    init_grow();
+    init_fire();
+    init_signal();
+    init_episode();
+    INBOX_DIR = "_inbox";
+    CORRECTIONS_FILE = "corrections.jsonl";
+    DOPAMINE_ALLOWED_ROLES = ["pm", "admin", "lead"];
+  }
+});
+
+// src/api.ts
+var api_exports = {};
+__export(api_exports, {
+  clearReports: () => clearReports,
+  getLastActivity: () => getLastActivity,
+  getPendingReports: () => getPendingReports,
+  startAPI: () => startAPI
+});
+import { createServer } from "http";
+function buildHealthJSON(brainRoot) {
+  const brain = scanBrain(brainRoot);
+  const result = runSubsumption(brain);
+  return {
+    status: "ok",
+    brain: brainRoot,
+    neurons: result.totalNeurons,
+    activeNeurons: result.firedNeurons,
+    totalActivation: result.totalCounter,
+    bombSource: result.bombSource || null,
+    lastActivity: new Date(lastAPIActivity).toISOString(),
+    uptime: process.uptime()
+  };
+}
+function buildBrainJSON(brainRoot) {
+  const brain = scanBrain(brainRoot);
+  const result = runSubsumption(brain);
+  return {
+    root: brain.root,
+    regions: brain.regions.map((region) => ({
+      name: region.name,
+      icon: REGION_ICONS[region.name] || "",
+      ko: REGION_KO[region.name] || "",
+      priority: region.priority,
+      hasBomb: region.hasBomb,
+      neurons: region.neurons.map((n) => ({
+        name: n.name,
+        path: n.path,
+        counter: n.counter,
+        contra: n.contra,
+        dopamine: n.dopamine,
+        hasBomb: n.hasBomb,
+        hasMemory: n.hasMemory,
+        isDormant: n.isDormant,
+        depth: n.depth,
+        modTime: n.modTime.getTime()
+      })),
+      axons: region.axons
+    })),
+    bombSource: result.bombSource || null,
+    firedNeurons: result.firedNeurons,
+    totalNeurons: result.totalNeurons,
+    totalCounter: result.totalCounter
+  };
+}
+function json(res, data, status = 200) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type"
+  });
+  res.end(body);
+}
+function error(res, message, status = 400) {
+  json(res, { error: message }, status);
+}
+async function readBody(req) {
+  return new Promise((resolve4, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve4(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
+async function parseJSON(req) {
+  const body = await readBody(req);
+  if (!body.trim()) return {};
+  return JSON.parse(body);
+}
+async function handleRequest(req, res, brainRoot) {
+  const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+  const path = url.pathname;
+  const method = req.method || "GET";
+  if (method === "OPTIONS") {
+    json(res, null, 204);
+    return;
+  }
+  const isMutation = method === "POST";
+  if (isMutation) lastAPIActivity = Date.now();
+  try {
+    if (method === "GET") {
+      switch (path) {
+        case "/api/health":
+          json(res, buildHealthJSON(brainRoot));
+          return;
+        case "/api/brain":
+          json(res, buildBrainJSON(brainRoot));
+          return;
+        case "/api/read": {
+          const region = url.searchParams.get("region");
+          if (!region || !REGIONS.includes(region)) {
+            error(res, `Invalid region. Valid: ${REGIONS.join(", ")}`);
+            return;
+          }
+          const brain = scanBrain(brainRoot);
+          const result = runSubsumption(brain);
+          const regionData = result.activeRegions.find((r) => r.name === region);
+          if (!regionData) {
+            error(res, `Region "${region}" is blocked or empty`);
+            return;
+          }
+          const top3 = [...regionData.neurons].filter((n) => !n.isDormant).sort((a, b) => b.counter - a.counter).slice(0, 3);
+          for (const n of top3) {
+            fireNeuron(brainRoot, `${region}/${n.path}`);
+          }
+          json(res, {
+            region,
+            neurons: regionData.neurons,
+            fired: top3.map((n) => n.path)
+          });
+          return;
+        }
+        case "/api/reports":
+          json(res, { reports: pendingReports });
+          return;
+        default:
+          error(res, "Not found", 404);
+          return;
+      }
+    }
+    if (method === "POST") {
+      const body = await parseJSON(req);
+      switch (path) {
+        case "/api/grow": {
+          const neuronPath = body.path;
+          if (!neuronPath) {
+            error(res, 'Missing "path"');
+            return;
+          }
+          const result = growNeuron(brainRoot, neuronPath);
+          json(res, result);
+          return;
+        }
+        case "/api/fire": {
+          const neuronPath = body.path;
+          if (!neuronPath) {
+            error(res, 'Missing "path"');
+            return;
+          }
+          const counter = fireNeuron(brainRoot, neuronPath);
+          json(res, { path: neuronPath, counter });
+          return;
+        }
+        case "/api/signal": {
+          const neuronPath = body.path;
+          const signalType = body.type;
+          if (!neuronPath || !signalType) {
+            error(res, 'Missing "path" or "type"');
+            return;
+          }
+          signalNeuron(brainRoot, neuronPath, signalType);
+          json(res, { path: neuronPath, type: signalType });
+          return;
+        }
+        case "/api/rollback": {
+          const neuronPath = body.path;
+          if (!neuronPath) {
+            error(res, 'Missing "path"');
+            return;
+          }
+          const counter = rollbackNeuron(brainRoot, neuronPath);
+          json(res, { path: neuronPath, counter });
+          return;
+        }
+        case "/api/decay": {
+          const days = typeof body.days === "number" ? body.days : 30;
+          const result = runDecay(brainRoot, days);
+          json(res, result);
+          return;
+        }
+        case "/api/dedup": {
+          const result = runDedup(brainRoot);
+          json(res, result);
+          return;
+        }
+        case "/api/inject": {
+          const brain = scanBrain(brainRoot);
+          const result = runSubsumption(brain);
+          writeAllTiers(brainRoot, result, brain);
+          json(res, { injected: true });
+          return;
+        }
+        case "/api/inbox": {
+          const result = processInbox(brainRoot);
+          json(res, result);
+          return;
+        }
+        case "/api/report": {
+          const message = body.message;
+          const priority = body.priority || "normal";
+          if (!message) {
+            error(res, 'Missing "message"');
+            return;
+          }
+          const entry = {
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            message,
+            priority
+          };
+          pendingReports.push(entry);
+          json(res, entry);
+          return;
+        }
+        default:
+          error(res, "Not found", 404);
+          return;
+      }
+    }
+    error(res, "Method not allowed", 405);
+  } catch (err) {
+    error(res, err.message, 500);
+  }
+}
+function startAPI(brainRoot, port = 9090) {
+  const server = createServer((req, res) => {
+    handleRequest(req, res, brainRoot).catch((err) => {
+      error(res, err.message, 500);
+    });
+  });
+  server.listen(port, () => {
+    console.log(`\u{1F9E0} hebbian API listening on http://localhost:${port}`);
+    console.log(`   Brain: ${brainRoot}`);
+    console.log("");
+    console.log("   Endpoints:");
+    console.log("   GET  /api/health          Process health + brain stats");
+    console.log("   GET  /api/brain           Full brain state JSON");
+    console.log("   GET  /api/read?region=X   Read region (auto-fires top 3)");
+    console.log("   GET  /api/reports         List pending reports");
+    console.log('   POST /api/grow            {"path":"cortex/..."}');
+    console.log('   POST /api/fire            {"path":"cortex/..."}');
+    console.log('   POST /api/signal          {"path":"...","type":"dopamine"}');
+    console.log('   POST /api/rollback        {"path":"cortex/..."}');
+    console.log('   POST /api/decay           {"days":30}');
+    console.log("   POST /api/dedup           Batch merge similar neurons");
+    console.log("   POST /api/inject          Force re-emit all tiers");
+    console.log("   POST /api/inbox           Process corrections inbox");
+    console.log('   POST /api/report          {"message":"...","priority":"normal"}');
+  });
+  return server;
+}
+function getLastActivity() {
+  return lastAPIActivity;
+}
+function getPendingReports() {
+  return pendingReports;
+}
+function clearReports() {
+  pendingReports.length = 0;
+}
+var lastAPIActivity, pendingReports;
+var init_api = __esm({
+  "src/api.ts"() {
+    "use strict";
+    init_scanner();
+    init_subsumption();
+    init_fire();
+    init_rollback();
+    init_grow();
+    init_signal();
+    init_decay();
+    init_dedup();
+    init_emit();
+    init_inbox();
+    init_constants();
+    lastAPIActivity = Date.now();
+    pendingReports = [];
+  }
+});
+
+// src/hooks.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  checkHooks: () => checkHooks,
+  installHooks: () => installHooks,
+  uninstallHooks: () => uninstallHooks
+});
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync10, existsSync as existsSync12, mkdirSync as mkdirSync7 } from "fs";
+import { join as join13, resolve as resolve2 } from "path";
+function installHooks(brainRoot, projectRoot) {
+  const root = projectRoot || process.cwd();
+  const settingsDir = join13(root, SETTINGS_DIR);
+  const settingsPath = join13(settingsDir, SETTINGS_FILE);
+  const defaultBrain = resolve2(root, "brain");
+  const resolvedBrain = resolve2(brainRoot);
+  const brainFlag = resolvedBrain === defaultBrain ? "" : ` --brain ${resolvedBrain}`;
+  let settings = {};
+  if (existsSync12(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync5(settingsPath, "utf8"));
+    } catch {
+      console.log(`\u26A0\uFE0F  settings.local.json was malformed, overwriting`);
+    }
+  }
+  if (!settings.hooks || typeof settings.hooks !== "object") {
+    settings.hooks = {};
+  }
+  const hooks = settings.hooks;
+  const hebbianHooks = [
+    {
+      event: "SessionStart",
+      matcher: "startup|resume",
+      entry: {
+        type: "command",
+        command: `hebbian emit claude${brainFlag}`,
+        timeout: 10,
+        statusMessage: `${HOOK_MARKER} refreshing brain`
+      }
+    },
+    {
+      event: "Stop",
+      entry: {
+        type: "command",
+        command: `hebbian digest${brainFlag}`,
+        timeout: 30,
+        statusMessage: `${HOOK_MARKER} digesting session`
+      }
+    }
+  ];
+  for (const { event, matcher, entry } of hebbianHooks) {
+    if (!hooks[event]) {
+      hooks[event] = [];
+    }
+    const existingIdx = hooks[event].findIndex(
+      (group2) => group2.hooks.some((h) => h.statusMessage?.startsWith(HOOK_MARKER))
+    );
+    const group = {
+      ...matcher ? { matcher } : {},
+      hooks: [entry]
+    };
+    if (existingIdx >= 0) {
+      hooks[event][existingIdx] = group;
+    } else {
+      hooks[event].push(group);
+    }
+  }
+  if (!existsSync12(settingsDir)) {
+    mkdirSync7(settingsDir, { recursive: true });
+  }
+  writeFileSync10(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  console.log(`\u2705 hebbian hooks installed at ${settingsPath}`);
+  console.log(`   SessionStart \u2192 hebbian emit claude${brainFlag}`);
+  console.log(`   Stop \u2192 hebbian digest${brainFlag}`);
+}
+function uninstallHooks(projectRoot) {
+  const root = projectRoot || process.cwd();
+  const settingsPath = join13(root, SETTINGS_DIR, SETTINGS_FILE);
+  if (!existsSync12(settingsPath)) {
+    console.log("No hooks installed (settings.local.json not found)");
+    return;
+  }
+  let settings;
+  try {
+    settings = JSON.parse(readFileSync5(settingsPath, "utf8"));
+  } catch {
+    console.log("settings.local.json is malformed, nothing to uninstall");
+    return;
+  }
+  if (!settings.hooks || typeof settings.hooks !== "object") {
+    console.log("No hooks found in settings.local.json");
+    return;
+  }
+  const hooks = settings.hooks;
+  let removed = 0;
+  for (const event of Object.keys(hooks)) {
+    const before = hooks[event].length;
+    hooks[event] = hooks[event].filter(
+      (group) => !group.hooks.some((h) => h.statusMessage?.startsWith(HOOK_MARKER))
+    );
+    removed += before - hooks[event].length;
+    if (hooks[event].length === 0) {
+      delete hooks[event];
+    }
+  }
+  if (Object.keys(hooks).length === 0) {
+    delete settings.hooks;
+  }
+  writeFileSync10(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  console.log(`\u2705 removed ${removed} hebbian hook(s) from ${settingsPath}`);
+}
+function checkHooks(projectRoot) {
+  const root = projectRoot || process.cwd();
+  const settingsPath = join13(root, SETTINGS_DIR, SETTINGS_FILE);
+  const status = {
+    installed: false,
+    path: settingsPath,
+    events: []
+  };
+  if (!existsSync12(settingsPath)) {
+    console.log(`\u274C hebbian hooks not installed (${settingsPath} not found)`);
+    return status;
+  }
+  let settings;
+  try {
+    settings = JSON.parse(readFileSync5(settingsPath, "utf8"));
+  } catch {
+    console.log(`\u274C settings.local.json is malformed`);
+    return status;
+  }
+  if (!settings.hooks || typeof settings.hooks !== "object") {
+    console.log(`\u274C no hooks in ${settingsPath}`);
+    return status;
+  }
+  const hooks = settings.hooks;
+  for (const event of Object.keys(hooks)) {
+    const hasHebbian = hooks[event].some(
+      (group) => group.hooks.some((h) => h.statusMessage?.startsWith(HOOK_MARKER))
+    );
+    if (hasHebbian) {
+      status.events.push(event);
+    }
+  }
+  status.installed = status.events.length > 0;
+  if (status.installed) {
+    console.log(`\u2705 hebbian hooks installed at ${settingsPath}`);
+    for (const event of status.events) {
+      console.log(`   ${event} \u2714`);
+    }
+  } else {
+    console.log(`\u274C hebbian hooks not found in ${settingsPath}`);
+  }
+  return status;
+}
+var SETTINGS_DIR, SETTINGS_FILE;
+var init_hooks = __esm({
+  "src/hooks.ts"() {
+    "use strict";
+    init_constants();
+    SETTINGS_DIR = ".claude";
+    SETTINGS_FILE = "settings.local.json";
+  }
+});
+
+// src/digest.ts
+var digest_exports = {};
+__export(digest_exports, {
+  digestTranscript: () => digestTranscript,
+  extractCorrections: () => extractCorrections,
+  readHookInput: () => readHookInput
+});
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync11, existsSync as existsSync13, mkdirSync as mkdirSync8 } from "fs";
+import { join as join14, basename } from "path";
+function readHookInput(stdin) {
+  if (!stdin.trim()) return null;
+  try {
+    const input = JSON.parse(stdin);
+    if (input.transcript_path) {
+      const sessionId = input.session_id || basename(input.transcript_path, ".jsonl");
+      return { transcriptPath: input.transcript_path, sessionId };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function digestTranscript(brainRoot, transcriptPath, sessionId) {
+  if (!existsSync13(transcriptPath)) {
+    throw new Error(`Transcript not found: ${transcriptPath}`);
+  }
+  const resolvedSessionId = sessionId || basename(transcriptPath, ".jsonl");
+  const logDir = join14(brainRoot, DIGEST_LOG_DIR);
+  const logPath = join14(logDir, `${resolvedSessionId}.jsonl`);
+  if (existsSync13(logPath)) {
+    console.log(`\u23ED already digested session ${resolvedSessionId}, skip`);
+    return { corrections: 0, skipped: 0, transcriptPath, sessionId: resolvedSessionId };
+  }
+  const messages = parseTranscript(transcriptPath);
+  const corrections = extractCorrections(messages);
+  if (corrections.length === 0) {
+    console.log(`\u{1F4DD} digest: no corrections found in session ${resolvedSessionId}`);
+    writeAuditLog(brainRoot, resolvedSessionId, []);
+    return { corrections: 0, skipped: messages.length, transcriptPath, sessionId: resolvedSessionId };
+  }
+  let applied = 0;
+  const auditEntries = [];
+  for (const correction of corrections) {
+    try {
+      growNeuron(brainRoot, correction.path);
+      logEpisode(brainRoot, "digest", correction.path, correction.text);
+      auditEntries.push({ correction, applied: true });
+      applied++;
+    } catch (err) {
+      console.log(`   \u26A0\uFE0F failed to apply: ${correction.path} \u2014 ${err.message}`);
+      auditEntries.push({ correction, applied: false });
+    }
+  }
+  writeAuditLog(brainRoot, resolvedSessionId, auditEntries);
+  console.log(`\u{1F4DD} digest: ${applied} correction(s) from session ${resolvedSessionId}`);
+  return {
+    corrections: applied,
+    skipped: messages.length - corrections.length,
+    transcriptPath,
+    sessionId: resolvedSessionId
+  };
+}
+function parseTranscript(transcriptPath) {
+  const content = readFileSync6(transcriptPath, "utf8");
+  const lines = content.split("\n").filter(Boolean);
+  const messages = [];
+  for (const line of lines) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry.type !== "user") continue;
+    if (!entry.message || entry.message.role !== "user") continue;
+    const text = extractText(entry.message.content);
+    if (text) messages.push(text);
+  }
+  return messages;
+}
+function extractText(content) {
+  if (!content) return null;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const texts = content.filter((block) => block.type === "text" && block.text).map((block) => block.text);
+    return texts.length > 0 ? texts.join("\n") : null;
+  }
+  return null;
+}
+function extractCorrections(messages) {
+  const corrections = [];
+  for (const text of messages) {
+    if (corrections.length >= MAX_CORRECTIONS_PER_SESSION) break;
+    if (text.length < MIN_CORRECTION_LENGTH) continue;
+    if (/^[\/!]/.test(text.trim())) continue;
+    if (text.trim().endsWith("?")) continue;
+    const correction = detectCorrection(text);
+    if (correction) {
+      corrections.push(correction);
+    }
+  }
+  return corrections;
+}
+function detectCorrection(text) {
+  const isNegation = NEGATION_PATTERNS.some((p) => p.test(text));
+  const isAffirmation = AFFIRMATION_PATTERNS.some((p) => p.test(text));
+  if (!isNegation && !isAffirmation) return null;
+  const prefix = isNegation ? "NO" : "DO";
+  const keywords = extractKeywords(text);
+  if (keywords.length === 0) return null;
+  const pathSegment = `${prefix}_${keywords.slice(0, 4).join("_")}`;
+  const path = `cortex/${pathSegment}`;
+  return { text, path, prefix, keywords };
+}
+function extractKeywords(text) {
+  const STOP_WORDS = /* @__PURE__ */ new Set([
+    "the",
+    "a",
+    "an",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "shall",
+    "can",
+    "need",
+    "dare",
+    "ought",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "with",
+    "at",
+    "by",
+    "from",
+    "as",
+    "into",
+    "through",
+    "during",
+    "before",
+    "after",
+    "above",
+    "below",
+    "and",
+    "but",
+    "or",
+    "nor",
+    "not",
+    "so",
+    "yet",
+    "both",
+    "either",
+    "neither",
+    "each",
+    "every",
+    "all",
+    "any",
+    "few",
+    "more",
+    "most",
+    "other",
+    "some",
+    "such",
+    "no",
+    "only",
+    "own",
+    "same",
+    "than",
+    "too",
+    "very",
+    "just",
+    "because",
+    "until",
+    "while",
+    "that",
+    "this",
+    "these",
+    "those",
+    "it",
+    "its",
+    "i",
+    "me",
+    "my",
+    "we",
+    "us",
+    "you",
+    "your",
+    "he",
+    "she",
+    "they",
+    "them",
+    "what",
+    "which",
+    "who",
+    "whom",
+    // Correction-specific stop words
+    "don",
+    "dont",
+    "stop",
+    "never",
+    "always",
+    "instead",
+    "use",
+    "avoid",
+    "please",
+    "must",
+    "should",
+    "like",
+    "want",
+    "think"
+  ]);
+  const tokens = tokenize(text);
+  return tokens.filter((t) => !STOP_WORDS.has(t) && t.length > 2);
+}
+function writeAuditLog(brainRoot, sessionId, entries) {
+  const logDir = join14(brainRoot, DIGEST_LOG_DIR);
+  if (!existsSync13(logDir)) {
+    mkdirSync8(logDir, { recursive: true });
+  }
+  const logPath = join14(logDir, `${sessionId}.jsonl`);
+  const lines = entries.map(
+    (e) => JSON.stringify({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      path: e.correction.path,
+      text: e.correction.text,
+      prefix: e.correction.prefix,
+      keywords: e.correction.keywords,
+      applied: e.applied
+    })
+  );
+  writeFileSync11(logPath, lines.join("\n") + (lines.length > 0 ? "\n" : ""), "utf8");
+}
+var NEGATION_PATTERNS, AFFIRMATION_PATTERNS;
+var init_digest = __esm({
+  "src/digest.ts"() {
+    "use strict";
+    init_constants();
+    init_grow();
+    init_episode();
+    init_similarity();
+    NEGATION_PATTERNS = [
+      /\bdon[''\u2019]?t\b/i,
+      /\bdo not\b/i,
+      /\bstop\s+\w+ing\b/i,
+      /\bnever\b/i,
+      /\binstead\b/i,
+      /^no[,.\s!]/i,
+      /\bdon[''\u2019]?t\s+use\b/i,
+      /\bavoid\b/i,
+      // Korean negation
+      /하지\s*마/,
+      /안\s*돼/,
+      /대신/,
+      /쓰지\s*마/,
+      /않/
+    ];
+    AFFIRMATION_PATTERNS = [
+      /\balways\b/i,
+      /\bmust\b/i,
+      /\bshould\s+always\b/i,
+      /\buse\s+\w+\s+instead\b/i,
+      // Korean affirmation
+      /항상/,
+      /반드시/
+    ];
+  }
+});
+
+// src/cli.ts
+init_constants();
+import { parseArgs } from "util";
+import { resolve as resolve3 } from "path";
+var VERSION = "0.3.0";
+var HELP = `
+hebbian v${VERSION} \u2014 Folder-as-neuron brain for any AI agent.
+
+  "Neurons that fire together, wire together." \u2014 Donald Hebb (1949)
+
+USAGE:
+  hebbian <command> [options]
+
+COMMANDS:
+  init <path>                     Create brain with 7 regions
+  emit <target> [--brain <path>]  Compile rules (claude/cursor/gemini/copilot/generic/all)
+  fire <neuron-path>              Increment neuron counter (+1)
+  grow <neuron-path>              Create neuron (with merge detection)
+  rollback <neuron-path>          Decrement neuron counter (min=1)
+  signal <type> <neuron-path>     Add signal (dopamine/bomb/memory)
+  decay [--days N]                Mark inactive neurons dormant (default 30)
+  dedup                           Batch merge similar neurons (Jaccard >= 0.6)
+  snapshot                        Git commit current brain state
+  watch                           Watch for changes + auto-recompile
+  api [--port N]                  Start REST API server (default 9090)
+  inbox                           Process corrections inbox
+  claude install|uninstall|status Manage Claude Code hooks
+  digest [--transcript <path>]    Extract corrections from conversation
+  diag                            Print brain diagnostics
+  stats                           Print brain statistics
+
+OPTIONS:
+  --brain <path>   Brain directory (default: $HEBBIAN_BRAIN or ./brain)
+  --help, -h       Show this help
+  --version, -v    Show version
+
+EXAMPLES:
+  hebbian init ./my-brain
+  hebbian grow cortex/frontend/NO_console_log --brain ./my-brain
+  hebbian fire cortex/frontend/NO_console_log --brain ./my-brain
+  hebbian emit claude --brain ./my-brain
+  hebbian emit all
+`.trim();
+function readStdin() {
+  return new Promise((resolve4) => {
+    if (process.stdin.isTTY) {
+      resolve4("");
+      return;
+    }
+    const chunks = [];
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => resolve4(Buffer.concat(chunks).toString("utf8")));
+    process.stdin.on("error", () => resolve4(""));
+    setTimeout(() => {
+      process.stdin.destroy();
+      resolve4(Buffer.concat(chunks).toString("utf8"));
+    }, 1e3);
+  });
+}
+async function main(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    options: {
+      brain: { type: "string", short: "b" },
+      days: { type: "string", short: "d" },
+      port: { type: "string", short: "p" },
+      transcript: { type: "string", short: "t" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" }
+    },
+    allowPositionals: true,
+    strict: false
+  });
+  if (values.version) {
+    console.log(`hebbian v${VERSION}`);
+    return;
+  }
+  const command = positionals[0];
+  if (values.help || !command) {
+    console.log(HELP);
+    return;
+  }
+  const brainRoot = resolveBrainRoot(values.brain);
+  switch (command) {
+    case "init": {
+      const target = positionals[1];
+      if (!target) {
+        console.error("Usage: hebbian init <path>");
+        process.exit(1);
+      }
+      const { initBrain: initBrain2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+      await initBrain2(resolve3(target));
+      break;
+    }
+    case "emit": {
+      const target = positionals[1];
+      if (!target) {
+        console.error("Usage: hebbian emit <target> (claude/cursor/gemini/copilot/generic/all)");
+        process.exit(1);
+      }
+      const { emitToTarget: emitToTarget2 } = await Promise.resolve().then(() => (init_emit(), emit_exports));
+      await emitToTarget2(brainRoot, target);
+      break;
+    }
+    case "fire": {
+      const neuronPath = positionals[1];
+      if (!neuronPath) {
+        console.error("Usage: hebbian fire <neuron-path>");
+        process.exit(1);
+      }
+      const { fireNeuron: fireNeuron2 } = await Promise.resolve().then(() => (init_fire(), fire_exports));
+      await fireNeuron2(brainRoot, neuronPath);
+      break;
+    }
+    case "grow": {
+      const neuronPath = positionals[1];
+      if (!neuronPath) {
+        console.error("Usage: hebbian grow <neuron-path>");
+        process.exit(1);
+      }
+      const { growNeuron: growNeuron2 } = await Promise.resolve().then(() => (init_grow(), grow_exports));
+      await growNeuron2(brainRoot, neuronPath);
+      break;
+    }
+    case "rollback": {
+      const neuronPath = positionals[1];
+      if (!neuronPath) {
+        console.error("Usage: hebbian rollback <neuron-path>");
+        process.exit(1);
+      }
+      const { rollbackNeuron: rollbackNeuron2 } = await Promise.resolve().then(() => (init_rollback(), rollback_exports));
+      await rollbackNeuron2(brainRoot, neuronPath);
+      break;
+    }
+    case "signal": {
+      const signalType = positionals[1];
+      const neuronPath = positionals[2];
+      if (!signalType || !neuronPath) {
+        console.error("Usage: hebbian signal <type> <neuron-path>  (type: dopamine/bomb/memory)");
+        process.exit(1);
+      }
+      const { signalNeuron: signalNeuron2 } = await Promise.resolve().then(() => (init_signal(), signal_exports));
+      await signalNeuron2(brainRoot, neuronPath, signalType);
+      break;
+    }
+    case "decay": {
+      const days = values.days ? parseInt(values.days, 10) : 30;
+      const { runDecay: runDecay2 } = await Promise.resolve().then(() => (init_decay(), decay_exports));
+      await runDecay2(brainRoot, days);
+      break;
+    }
+    case "dedup": {
+      const { runDedup: runDedup2 } = await Promise.resolve().then(() => (init_dedup(), dedup_exports));
+      runDedup2(brainRoot);
+      break;
+    }
+    case "snapshot": {
+      const { gitSnapshot: gitSnapshot2 } = await Promise.resolve().then(() => (init_snapshot(), snapshot_exports));
+      gitSnapshot2(brainRoot);
+      break;
+    }
+    case "watch": {
+      const { startWatch: startWatch2 } = await Promise.resolve().then(() => (init_watch(), watch_exports));
+      await startWatch2(brainRoot);
+      break;
+    }
+    case "api": {
+      const port = values.port ? parseInt(values.port, 10) : 9090;
+      const { startAPI: startAPI2 } = await Promise.resolve().then(() => (init_api(), api_exports));
+      startAPI2(brainRoot, port);
+      await new Promise(() => {
+      });
+      break;
+    }
+    case "inbox": {
+      const { processInbox: processInbox2 } = await Promise.resolve().then(() => (init_inbox(), inbox_exports));
+      processInbox2(brainRoot);
+      break;
+    }
+    case "claude": {
+      const sub = positionals[1];
+      const { installHooks: installHooks2, uninstallHooks: uninstallHooks2, checkHooks: checkHooks2 } = await Promise.resolve().then(() => (init_hooks(), hooks_exports));
+      switch (sub) {
+        case "install":
+          installHooks2(brainRoot);
+          break;
+        case "uninstall":
+          uninstallHooks2();
+          break;
+        case "status":
+          checkHooks2();
+          break;
+        default:
+          console.error("Usage: hebbian claude <install|uninstall|status>");
+          process.exit(1);
+      }
+      break;
+    }
+    case "digest": {
+      const transcriptFlag = values.transcript;
+      const { digestTranscript: digestTranscript2, readHookInput: readHookInput2 } = await Promise.resolve().then(() => (init_digest(), digest_exports));
+      if (transcriptFlag) {
+        digestTranscript2(brainRoot, resolve3(transcriptFlag));
+      } else {
+        const stdin = await readStdin();
+        const hookInput = readHookInput2(stdin);
+        if (hookInput) {
+          digestTranscript2(brainRoot, hookInput.transcriptPath, hookInput.sessionId);
+        } else {
+          console.error("Usage: hebbian digest --transcript <path>");
+          console.error("  Or pipe hook input via stdin (Claude Code Stop hook)");
+          process.exit(1);
+        }
+      }
+      break;
+    }
+    case "diag":
+    case "stats": {
+      const { scanBrain: scanBrain2 } = await Promise.resolve().then(() => (init_scanner(), scanner_exports));
+      const { runSubsumption: runSubsumption2 } = await Promise.resolve().then(() => (init_subsumption(), subsumption_exports));
+      const brain = scanBrain2(brainRoot);
+      const result = runSubsumption2(brain);
+      const { printDiag: printDiag2 } = await Promise.resolve().then(() => (init_emit(), emit_exports));
+      printDiag2(brain, result);
+      break;
+    }
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.log(HELP);
+      process.exit(1);
+  }
+}
+main(process.argv.slice(2)).catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});
+//# sourceMappingURL=hebbian.js.map