hebbian 0.1.0

package/lib/emit.js

@@ -0,0 +1,376 @@
+// hebbian — 3-Tier Emit System + Multi-Target Output
+//
+// Tier 1: Bootstrap (~500 tokens) — auto-loaded by AI (CLAUDE.md, .cursorrules, etc.)
+// Tier 2: _index.md — brain overview (AI reads at conversation start)
+// Tier 3: {region}/_rules.md — per-region detail (AI reads on demand)
+//
+// Multi-target: claude, cursor, gemini, copilot, generic, all
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { scanBrain } from './scanner.js';
+import { runSubsumption } from './subsumption.js';
+import {
+	REGIONS, REGION_ICONS, REGION_KO, EMIT_TARGETS,
+	EMIT_THRESHOLD, SPOTLIGHT_DAYS, MARKER_START, MARKER_END,
+} from './constants.js';
+
+/**
+ * @typedef {import('./scanner.js').Neuron} Neuron
+ * @typedef {import('./scanner.js').Region} Region
+ * @typedef {import('./subsumption.js').SubsumptionResult} SubsumptionResult
+ */
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// TIER 1: Bootstrap (~500 tokens)
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+/**
+ * Generate Tier 1 bootstrap content.
+ * @param {SubsumptionResult} result
+ * @param {import('./scanner.js').Brain} brain
+ * @returns {string}
+ */
+export function emitBootstrap(result, brain) {
+	const lines = [];
+	const now = 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('');
+
+	// Circuit breaker
+	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('');
+
+	// Persona (ego region)
+	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('');
+
+	// Subsumption cascade
+	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('');
+
+	// TOP 5 brainstem rules
+	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('');
+
+	// Active regions summary
+	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');
+}
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// TIER 2: Index (_index.md)
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+/**
+ * Generate Tier 2 brain index content.
+ * @param {SubsumptionResult} result
+ * @param {import('./scanner.js').Brain} brain
+ * @returns {string}
+ */
+export 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');
+	}
+
+	// Top 10 neurons by counter
+	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('');
+
+	// Spotlight: new neurons (< SPOTLIGHT_DAYS old, counter < EMIT_THRESHOLD)
+	const cutoff = new Date(Date.now() - SPOTLIGHT_DAYS * 24 * 60 * 60 * 1000);
+	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}) — new`);
+		}
+		lines.push('');
+	}
+
+	// Per-region summary
+	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');
+}
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// TIER 3: Per-region rules ({region}/_rules.md)
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+/**
+ * Generate Tier 3 per-region rules content.
+ * @param {Region} region
+ * @returns {string}
+ */
+export 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('');
+
+	// Axons
+	if (region.axons.length > 0) {
+		lines.push('## Connections');
+		for (const axon of region.axons) {
+			lines.push(`- \u2194 ${axon}`);
+		}
+		lines.push('');
+	}
+
+	// Neuron tree
+	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('');
+	}
+
+	// Dormant section
+	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');
+}
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// MULTI-TARGET OUTPUT
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+/**
+ * Emit rules to a specific target or all targets.
+ * @param {string} brainRoot
+ * @param {string} target - Target name or "all"
+ */
+export 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} → ${filePath}`);
+		}
+	} else if (EMIT_TARGETS[target]) {
+		writeTarget(EMIT_TARGETS[target], content);
+		console.log(`\u{1F4E4} emitted: ${target} → ${EMIT_TARGETS[target]}`);
+	} else {
+		throw new Error(`Unknown target: ${target}. Valid: ${Object.keys(EMIT_TARGETS).join(', ')}, all`);
+	}
+
+	// Always write tier 2 + tier 3 into the brain
+	writeAllTiers(brainRoot, result, brain);
+}
+
+/**
+ * Write all 3 tiers into the brain directory.
+ * @param {string} brainRoot
+ * @param {SubsumptionResult} result
+ * @param {import('./scanner.js').Brain} brain
+ */
+export function writeAllTiers(brainRoot, result, brain) {
+	// Tier 2: _index.md
+	const indexContent = emitIndex(result, brain);
+	writeFileSync(join(brainRoot, '_index.md'), indexContent, 'utf8');
+
+	// Tier 3: per-region _rules.md
+	for (const region of result.activeRegions) {
+		if (existsSync(region.path)) {
+			const rulesContent = emitRegionRules(region);
+			writeFileSync(join(region.path, '_rules.md'), rulesContent, 'utf8');
+		}
+	}
+}
+
+/**
+ * Write content to a target file, using marker-based injection if file already exists.
+ * @param {string} filePath
+ * @param {string} content
+ */
+function writeTarget(filePath, content) {
+	const dir = dirname(filePath);
+	if (dir !== '.' && !existsSync(dir)) {
+		mkdirSync(dir, { recursive: true });
+	}
+
+	if (existsSync(filePath)) {
+		// Marker-based injection: replace between markers, preserve surrounding content
+		const existing = readFileSync(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);
+			writeFileSync(filePath, before + content + after, 'utf8');
+			return;
+		}
+	}
+
+	writeFileSync(filePath, content, 'utf8');
+}
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// DIAGNOSTICS (for CLI `hebbian diag` / `hebbian stats`)
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+/**
+ * Print brain diagnostics to stdout.
+ * @param {import('./scanner.js').Brain} brain
+ * @param {SubsumptionResult} result
+ */
+export 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} — 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('');
+}
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// HELPERS
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+/** Convert a neuron relative path to a human-readable sentence. */
+function pathToSentence(path) {
+	return path.replace(/\//g, ' > ').replace(/_/g, ' ');
+}
+
+/** Sort non-dormant neurons by counter (descending), take first N. */
+function sortedActive(neurons, n) {
+	return [...neurons]
+		.filter((neuron) => !neuron.isDormant)
+		.sort((a, b) => b.counter - a.counter)
+		.slice(0, n);
+}
+
+/** Strength prefix based on counter value. */
+function strengthPrefix(counter) {
+	if (counter >= 10) return '**[절대]** ';
+	if (counter >= 5) return '**[반드시]** ';
+	return '';
+}

package/lib/fire.js

@@ -0,0 +1,59 @@
+// hebbian — Fire Neuron (increment counter)
+//
+// Firing = reinforcing a synaptic pathway.
+// The counter file is renamed: N.neuron → (N+1).neuron
+
+import { readdirSync, renameSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Increment a neuron's counter by 1.
+ * If the neuron doesn't exist, auto-grows it with counter=1.
+ *
+ * @param {string} brainRoot - Absolute path to brain root
+ * @param {string} neuronPath - Relative path (e.g. "cortex/frontend/禁console_log")
+ * @returns {number} New counter value
+ */
+export function fireNeuron(brainRoot, neuronPath) {
+	const fullPath = join(brainRoot, neuronPath);
+
+	// Auto-grow if neuron doesn't exist
+	if (!existsSync(fullPath)) {
+		mkdirSync(fullPath, { recursive: true });
+		writeFileSync(join(fullPath, '1.neuron'), '', 'utf8');
+		console.log(`\u{1F331} grew + fired: ${neuronPath} (1)`);
+		return 1;
+	}
+
+	// Find current counter
+	const current = getCurrentCounter(fullPath);
+	const newCounter = current + 1;
+
+	// Rename: N.neuron → (N+1).neuron
+	if (current > 0) {
+		renameSync(join(fullPath, `${current}.neuron`), join(fullPath, `${newCounter}.neuron`));
+	} else {
+		writeFileSync(join(fullPath, `${newCounter}.neuron`), '', 'utf8');
+	}
+
+	console.log(`\u{1F525} fired: ${neuronPath} (${current} → ${newCounter})`);
+	return newCounter;
+}
+
+/**
+ * Get current counter value from the highest N.neuron file.
+ * @param {string} dir
+ * @returns {number}
+ */
+export function getCurrentCounter(dir) {
+	let max = 0;
+	try {
+		for (const entry of readdirSync(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;
+}

package/lib/grow.js

@@ -0,0 +1,98 @@
+// hebbian — Grow Neuron (with synaptic consolidation)
+//
+// Creates a new neuron (folder + 1.neuron).
+// Before creating, checks for similar existing neurons via Jaccard similarity.
+// If a match is found (>= 0.6), fires the existing neuron instead.
+// This prevents duplication and strengthens existing pathways.
+//
+// "Consolidation over duplication." — Hebb's principle.
+
+import { mkdirSync, writeFileSync, existsSync, readdirSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { REGIONS, JACCARD_THRESHOLD } from './constants.js';
+import { tokenize, jaccardSimilarity } from './similarity.js';
+import { fireNeuron } from './fire.js';
+
+/**
+ * Grow a new neuron at the given path.
+ * If a similar neuron already exists in the same region, fires it instead.
+ *
+ * @param {string} brainRoot - Absolute path to brain root
+ * @param {string} neuronPath - Relative path (e.g. "cortex/frontend/禁console_log")
+ * @returns {{ action: 'grew' | 'fired', path: string, counter: number }}
+ */
+export function growNeuron(brainRoot, neuronPath) {
+	const fullPath = join(brainRoot, neuronPath);
+
+	// If neuron already exists, just fire it
+	if (existsSync(fullPath)) {
+		const counter = fireNeuron(brainRoot, neuronPath);
+		return { action: 'fired', path: neuronPath, counter };
+	}
+
+	// Extract region name and leaf name
+	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);
+
+	// Search for similar neurons in the same region
+	const regionPath = join(brainRoot, regionName);
+	if (existsSync(regionPath)) {
+		const match = findSimilar(regionPath, regionPath, newTokens);
+		if (match) {
+			const matchRelPath = regionName + '/' + relative(regionPath, match);
+			console.log(`\u{1F504} consolidation: "${neuronPath}" ≈ "${matchRelPath}" (firing existing)`);
+			const counter = fireNeuron(brainRoot, matchRelPath);
+			return { action: 'fired', path: matchRelPath, counter };
+		}
+	}
+
+	// No match — create new neuron
+	mkdirSync(fullPath, { recursive: true });
+	writeFileSync(join(fullPath, '1.neuron'), '', 'utf8');
+	console.log(`\u{1F331} grew: ${neuronPath} (1)`);
+	return { action: 'grew', path: neuronPath, counter: 1 };
+}
+
+/**
+ * Walk a region and find a neuron whose name is similar to the given tokens.
+ * @param {string} dir - Current directory
+ * @param {string} regionRoot - Region root for relative paths
+ * @param {string[]} targetTokens - Tokens to compare against
+ * @returns {string|null} Absolute path of matching neuron, or null
+ */
+function findSimilar(dir, regionRoot, targetTokens) {
+	let entries;
+	try {
+		entries = readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return null;
+	}
+
+	// Check if this directory has .neuron files (is a neuron)
+	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;
+		}
+	}
+
+	// Recurse into subdirectories
+	for (const entry of entries) {
+		if (entry.name.startsWith('_') || entry.name.startsWith('.')) continue;
+		if (entry.isDirectory()) {
+			const match = findSimilar(join(dir, entry.name), regionRoot, targetTokens);
+			if (match) return match;
+		}
+	}
+
+	return null;
+}

package/lib/init.js

@@ -0,0 +1,89 @@
+// hebbian — Brain Initialization
+//
+// Creates a brain directory with 7 canonical regions and starter neurons.
+// Each region gets a _rules.md explaining its purpose.
+
+import { mkdirSync, writeFileSync, existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { REGIONS, REGION_ICONS, REGION_KO } from './constants.js';
+
+/** @type {Record<string, { description: string, starters: string[] }>} */
+const REGION_TEMPLATES = {
+	brainstem: {
+		description: 'Absolute principles. Immutable. Read-only conscience.\nP0 — highest priority. bomb here halts EVERYTHING.',
+		starters: ['禁fallback', '推execute_not_debate'],
+	},
+	limbic: {
+		description: 'Emotional filters and somatic markers.\nP1 — automatic, influences downstream regions.',
+		starters: [],
+	},
+	hippocampus: {
+		description: 'Memory and episode recording.\nP2 — accumulated experience, session logs.',
+		starters: [],
+	},
+	sensors: {
+		description: 'Environment constraints and input validation.\nP3 — read-only, set by environment.',
+		starters: [],
+	},
+	cortex: {
+		description: 'Knowledge and skills. The largest region.\nP4 — learnable, grows with corrections.',
+		starters: [],
+	},
+	ego: {
+		description: 'Personality, tone, and communication style.\nP5 — set by user preference.',
+		starters: [],
+	},
+	prefrontal: {
+		description: 'Goals, projects, and planning.\nP6 — lowest priority, longest time horizon.',
+		starters: [],
+	},
+};
+
+/**
+ * Initialize a new brain directory with 7 regions.
+ * @param {string} brainPath - Absolute path to create the brain at
+ */
+export function initBrain(brainPath) {
+	if (existsSync(brainPath)) {
+		const entries = readdirSync(brainPath);
+		if (entries.some((e) => REGIONS.includes(e))) {
+			console.log(`\u{26A0}\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];
+
+		// Write _rules.md template
+		writeFileSync(
+			join(regionDir, '_rules.md'),
+			`# ${icon} ${regionName} (${ko})\n\n${template.description}\n`,
+			'utf8',
+		);
+
+		// Create starter neurons
+		for (const starter of template.starters) {
+			const neuronDir = join(regionDir, starter);
+			mkdirSync(neuronDir, { recursive: true });
+			writeFileSync(join(neuronDir, '1.neuron'), '', 'utf8');
+		}
+	}
+
+	// Create _agents inbox
+	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/禁your_rule --brain ${brainPath}`);
+	console.log(`   hebbian emit claude --brain ${brainPath}`);
+}

package/lib/rollback.js

@@ -0,0 +1,34 @@
+// hebbian — Rollback Neuron (decrement counter)
+//
+// Undo a firing. Counter cannot go below 1 (minimum activation).
+
+import { renameSync } from 'node:fs';
+import { join } from 'node:path';
+import { getCurrentCounter } from './fire.js';
+
+/**
+ * Decrement a neuron's counter by 1. Minimum counter is 1.
+ *
+ * @param {string} brainRoot - Absolute path to brain root
+ * @param {string} neuronPath - Relative path
+ * @returns {number} New counter value
+ * @throws {Error} If counter is already at minimum (1) or neuron doesn't exist
+ */
+export function rollbackNeuron(brainRoot, neuronPath) {
+	const fullPath = join(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;
+	renameSync(join(fullPath, `${current}.neuron`), join(fullPath, `${newCounter}.neuron`));
+
+	console.log(`\u{23EA} rollback: ${neuronPath} (${current} → ${newCounter})`);
+	return newCounter;
+}