hebbian 0.2.0 → 0.3.0

package/dist/bin/hebbian.js

@@ -10,7 +10,15 @@ var __export = (target, all) => {
 };
 
 // src/constants.ts
-var REGIONS, REGION_PRIORITY, REGION_ICONS, REGION_KO, EMIT_THRESHOLD, SPOTLIGHT_DAYS, JACCARD_THRESHOLD, MAX_DEPTH, EMIT_TARGETS, SIGNAL_TYPES, MARKER_START, MARKER_END;
+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";
@@ -64,6 +72,10 @@ var init_constants = __esm({
     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";
   }
 });
 
@@ -72,10 +84,10 @@ var init_exports = {};
 __export(init_exports, {
   initBrain: () => initBrain
 });
-import { mkdirSync, writeFileSync, existsSync, readdirSync } from "fs";
+import { mkdirSync, writeFileSync, existsSync as existsSync2, readdirSync } from "fs";
 import { join } from "path";
 function initBrain(brainPath) {
-  if (existsSync(brainPath)) {
+  if (existsSync2(brainPath)) {
     const entries = readdirSync(brainPath);
     if (entries.some((e) => REGIONS.includes(e))) {
       console.log(`\u26A0\uFE0F  Brain already exists at ${brainPath}`);
@@ -108,7 +120,7 @@ ${template.description}
   console.log(`   7 regions created: ${REGIONS.join(", ")}`);
   console.log("");
   console.log("   Next steps:");
-  console.log(`   hebbian grow brainstem/\u7981your_rule --brain ${brainPath}`);
+  console.log(`   hebbian grow brainstem/NO_your_rule --brain ${brainPath}`);
   console.log(`   hebbian emit claude --brain ${brainPath}`);
 }
 var REGION_TEMPLATES;
@@ -119,7 +131,7 @@ var init_init = __esm({
     REGION_TEMPLATES = {
       brainstem: {
         description: "Absolute principles. Immutable. Read-only conscience.\nP0 \u2014 highest priority. bomb here halts EVERYTHING.",
-        starters: ["\u7981fallback", "\u63A8execute_not_debate"]
+        starters: ["NO_fallback", "DO_execute_not_debate"]
       },
       limbic: {
         description: "Emotional filters and somatic markers.\nP1 \u2014 automatic, influences downstream regions.",
@@ -154,13 +166,13 @@ var scanner_exports = {};
 __export(scanner_exports, {
   scanBrain: () => scanBrain
 });
-import { readdirSync as readdirSync2, statSync, readFileSync, existsSync as existsSync2 } from "fs";
+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 (!existsSync2(regionPath)) {
+    if (!existsSync3(regionPath)) {
       regions.push({
         name: regionName,
         priority: REGION_PRIORITY[regionName],
@@ -279,7 +291,7 @@ function walkRegion(dir, regionRoot, depth) {
 }
 function readAxons(regionPath) {
   const axonPath = join2(regionPath, ".axon");
-  if (!existsSync2(axonPath)) return [];
+  if (!existsSync3(axonPath)) return [];
   try {
     const content = readFileSync(axonPath, "utf8").trim();
     return content.split(/[\n,]+/).map((s) => s.trim()).filter(Boolean);
@@ -352,7 +364,7 @@ __export(emit_exports, {
   printDiag: () => printDiag,
   writeAllTiers: () => writeAllTiers
 });
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+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 = [];
@@ -522,7 +534,7 @@ function writeAllTiers(brainRoot, result, brain) {
   const indexContent = emitIndex(result, brain);
   writeFileSync2(join3(brainRoot, "_index.md"), indexContent, "utf8");
   for (const region of result.activeRegions) {
-    if (existsSync3(region.path)) {
+    if (existsSync4(region.path)) {
       const rulesContent = emitRegionRules(region);
       writeFileSync2(join3(region.path, "_rules.md"), rulesContent, "utf8");
     }
@@ -530,10 +542,10 @@ function writeAllTiers(brainRoot, result, brain) {
 }
 function writeTarget(filePath, content) {
   const dir = dirname(filePath);
-  if (dir !== "." && !existsSync3(dir)) {
+  if (dir !== "." && !existsSync4(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
-  if (existsSync3(filePath)) {
+  if (existsSync4(filePath)) {
     const existing = readFileSync2(filePath, "utf8");
     const startIdx = existing.indexOf(MARKER_START);
     const endIdx = existing.indexOf(MARKER_END);
@@ -582,8 +594,8 @@ 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 "**[\uC808\uB300]** ";
-  if (counter >= 5) return "**[\uBC18\uB4DC\uC2DC]** ";
+  if (counter >= 10) return "**[ABSOLUTE]** ";
+  if (counter >= 5) return "**[MUST]** ";
   return "";
 }
 var init_emit = __esm({
@@ -601,11 +613,11 @@ __export(fire_exports, {
   fireNeuron: () => fireNeuron,
   getCurrentCounter: () => getCurrentCounter
 });
-import { readdirSync as readdirSync3, renameSync, writeFileSync as writeFileSync3, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
+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 (!existsSync4(fullPath)) {
+  if (!existsSync5(fullPath)) {
     mkdirSync3(fullPath, { recursive: true });
     writeFileSync3(join4(fullPath, "1.neuron"), "", "utf8");
     console.log(`\u{1F331} grew + fired: ${neuronPath} (1)`);
@@ -676,11 +688,11 @@ var grow_exports = {};
 __export(grow_exports, {
   growNeuron: () => growNeuron
 });
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, existsSync as existsSync5, readdirSync as readdirSync4 } from "fs";
+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 (existsSync5(fullPath)) {
+  if (existsSync6(fullPath)) {
     const counter = fireNeuron(brainRoot, neuronPath);
     return { action: "fired", path: neuronPath, counter };
   }
@@ -692,7 +704,7 @@ function growNeuron(brainRoot, neuronPath) {
   const leafName = parts[parts.length - 1];
   const newTokens = tokenize(leafName);
   const regionPath = join5(brainRoot, regionName);
-  if (existsSync5(regionPath)) {
+  if (existsSync6(regionPath)) {
     const match = findSimilar(regionPath, regionPath, newTokens);
     if (match) {
       const matchRelPath = regionName + "/" + relative2(regionPath, match);
@@ -773,14 +785,14 @@ var signal_exports = {};
 __export(signal_exports, {
   signalNeuron: () => signalNeuron
 });
-import { writeFileSync as writeFileSync5, existsSync as existsSync6, readdirSync as readdirSync5 } from "fs";
+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 (!existsSync6(fullPath)) {
+  if (!existsSync7(fullPath)) {
     throw new Error(`Neuron not found: ${neuronPath}`);
   }
   switch (signalType) {
@@ -828,7 +840,7 @@ var decay_exports = {};
 __export(decay_exports, {
   runDecay: () => runDecay
 });
-import { readdirSync as readdirSync6, statSync as statSync2, writeFileSync as writeFileSync6, existsSync as existsSync7 } from "fs";
+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;
@@ -836,7 +848,7 @@ function runDecay(brainRoot, days) {
   let decayed = 0;
   for (const regionName of REGIONS) {
     const regionPath = join8(brainRoot, regionName);
-    if (!existsSync7(regionPath)) continue;
+    if (!existsSync8(regionPath)) continue;
     const result = decayWalk(regionPath, threshold, 0);
     scanned += result.scanned;
     decayed += result.decayed;
@@ -960,10 +972,10 @@ __export(snapshot_exports, {
   gitSnapshot: () => gitSnapshot
 });
 import { execSync } from "child_process";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { join as join10 } from "path";
 function gitSnapshot(brainRoot) {
-  if (!existsSync8(join10(brainRoot, ".git"))) {
+  if (!existsSync9(join10(brainRoot, ".git"))) {
     try {
       execSync("git rev-parse --is-inside-work-tree", { cwd: brainRoot, stdio: "pipe" });
     } catch {
@@ -1024,11 +1036,11 @@ async function startWatch(brainRoot) {
       if (debounceTimer) clearTimeout(debounceTimer);
       debounceTimer = setTimeout(recompile, 200);
     });
-    await new Promise((resolve2) => {
+    await new Promise((resolve4) => {
       process.on("SIGINT", () => {
         watcher.close();
         console.log("\n\u{1F44B} watch stopped.");
-        resolve2();
+        resolve4();
       });
     });
   } catch (err) {
@@ -1051,11 +1063,908 @@ var init_watch = __esm({
   }
 });
 
+// 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 } from "path";
-import { existsSync as existsSync9 } from "fs";
-var VERSION = "0.1.0";
+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.
 
@@ -1075,6 +1984,10 @@ COMMANDS:
   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
 
@@ -1085,16 +1998,26 @@ OPTIONS:
 
 EXAMPLES:
   hebbian init ./my-brain
-  hebbian grow cortex/frontend/\u7981console_log --brain ./my-brain
-  hebbian fire cortex/frontend/\u7981console_log --brain ./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 resolveBrainRoot(brainFlag) {
-  if (brainFlag) return resolve(brainFlag);
-  if (process.env.HEBBIAN_BRAIN) return resolve(process.env.HEBBIAN_BRAIN);
-  if (existsSync9(resolve("./brain"))) return resolve("./brain");
-  return resolve(process.env.HOME || "~", "hebbian", "brain");
+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({
@@ -1103,6 +2026,7 @@ async function main(argv) {
       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" }
     },
@@ -1127,7 +2051,7 @@ async function main(argv) {
         process.exit(1);
       }
       const { initBrain: initBrain2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-      await initBrain2(resolve(target));
+      await initBrain2(resolve3(target));
       break;
     }
     case "emit": {
@@ -1202,6 +2126,56 @@ async function main(argv) {
       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));