Not a chatbot.
An organism.

# core/brain/plasticity.py — Online Self-DPO on F_fast (LoRA rank-16)
def micro_consolidation(self, chosen_tokens, rejected_tokens, context_x):
    """
    chosen  = corrected [THINK] tokens (after [CONFLICT])
    rejected = flawed [THINK] tokens (before [CONFLICT])
    DPO: push F_fast away from rejected, toward chosen.
    Reference model = W_reference (frozen forever — NEVER use W_base here).
    """
    fast_chosen_lp  = self._get_logps(chosen_tokens,   use_fast=True)
    fast_reject_lp  = self._get_logps(rejected_tokens,  use_fast=True)
    ref_chosen_lp   = self._get_logps(chosen_tokens,   use_fast=False).detach()
    ref_reject_lp   = self._get_logps(rejected_tokens,  use_fast=False).detach()

    chosen_ratio  = fast_chosen_lp  - ref_chosen_lp
    rejected_ratio = fast_reject_lp - ref_reject_lp
    dpo_loss = -F.logsigmoid(self.beta * (chosen_ratio - rejected_ratio)).mean()

    # Anti-forgetting: F_fast must not distort past resolved ACT latents
    idx = torch.randint(0, min(self.replay_ptr, 1024), (4,))
    h_past = self.replay_buffer[idx]
    orthogonal_penalty = F.mse_loss(self._apply_fast(h_past), h_past)

    loss = dpo_loss + 0.1 * orthogonal_penalty
    loss.backward()

    # AdamW update on F_fast only — gradient clip norm=1.0
    torch.nn.utils.clip_grad_norm_(
        [fw[k] for fw in self.fast_weights.values() for k in ('A', 'B')], 1.0
    )
    self._adamw_step()   # updates F_fast only — W_base untouched

# core/memory/hippocampus.py
def accumulate(self, activation, emotional_delta, perplexity, model_initiated):
    surprise  = self._gaussian_surprise(perplexity)  # peak at ppl=50
    initiative = 0.15 if model_initiated else 0.0

    importance = (
        0.50 * emotional_delta +
        0.35 * surprise       +
        0.15 * initiative
    )

    if importance < self.importance_threshold:  # gate: 0.2
        return importance

    self._buffer.append(BufferEntry(activation, importance))
    return importance

def _gaussian_surprise(self, ppl: float) -> float:
    if ppl < 5 or ppl > 150:      # too trivial or too noisy
        return 0.0
    log_ppl = math.log(ppl)
    z = (log_ppl - self._log_opt) / self._sigma
    return math.exp(-z * z / 2)  # Gaussian peak at ppl=50

# core/curiosity/explorer.py
def _curiosity_score(emotions: dict) -> float:
    """
    Mild fear ≠ suppression. fear + curiosity = AWE (Plutchik dyad).
    Only fear > 0.45 suppresses exploration.
    Neutral defaults → score ≈ 0.49 → naturally curious.
    """
    pos = (
        0.45 * emotions.get("anticipation", 0.5) +
        0.30 * emotions.get("surprise",     0.3) +
        0.25 * emotions.get("joy",           0.4)
    )
    fear_suppression = max(0.0, emotions.get("fear", 0.1) - 0.45) * 0.8
    neg = (
        fear_suppression                          +
        0.25 * emotions.get("anger",   0.05) +
        0.20 * emotions.get("sadness", 0.1)
    )
    return max(0.0, min(1.0, pos - neg))

# core/brain/hebbian_mlp.py — Knowledge capacity growth
def maybe_grow(self) -> bool:
    """Returns True if capacity expanded (version increments)."""
    active = self.H_mlp[:, :self.active_k]
    col_norms = active.norm(dim=0)        # norm per knowledge column
    saturation = (col_norms > self._saturation_threshold).float().mean()

    if saturation < self._growth_trigger:   # e.g. 0.8
        return False

    old_k = self.active_k
    self.active_k = min(self.active_k + 4, self.H_mlp.shape[1])

    # New columns: small random — NOT zero (dead state)
    self.H_mlp[:, old_k:self.active_k] = (
        torch.randn_like(self.H_mlp[:, old_k:self.active_k]) * 0.01
    )
    return True   # → organism_version() increments

# Version: 1.0 + (growth_events * 0.1)
def organism_version(self) -> float:
    return 1.0 + self._growth_events * 0.1

# core/consciousness/sleep.py — 7-step consolidation at 03:00
async def sleep_consolidation(brain, hippocampus, memory, ewc, lexicon):
    # 1. Collect high-importance activations
    important = hippocampus.get_for_consolidation(min_importance=0.5)

    # 2+3. GHA: update H_q/H_k (character) + H_mlp (knowledge > 0.7)
    brain.sleep_consolidation(high_imp_activations=important)

    # 4. EWC — protect personality built over weeks
    ewc.update_fisher(brain.live_named_params())

    # 5. Flush lexicon cross-context connections → long-term memory
    if lexicon:
        for conn in lexicon.flush_connections():
            memory.store(conn["content"], importance=0.75)

    # 6. Reindex — past memories re-encoded through improved brain
    memory.reindex(brain)

    # 7. Dream replay — random memories strengthen consolidation
    for dream in memory.sample_weighted(n=20):
        brain.encode(dream)