Implement full cognitive architecture (§2.1-§5.3, plan tasks 1-35)

Complete implementation of the cognitive architecture across all plan sections:

- §2: Memory foundation — halfvec embeddings, Beta depth weights, hybrid search
  with RRF + FlashRank reranking, ACT-R activation, 3x3 exit gate, entry gate
  with scratch buffer, token counting, composite confidence scoring
- §3: Cognitive pipeline — hybrid relevance with Dirichlet blends, salience-based
  attention allocation, dynamic context injection with stochastic identity,
  adaptive FIFO pruning, attention-agnostic cognitive loop, dual-process
  escalation (System 1 Gemini → System 2 Claude), reflection bank, retrieval-
  induced mutation, 3-phase safety ceilings
- §4: Consolidation & background — two-tier engine (constant metabolism + deep
  sleep cycle), merge/insight/narrative/promotion/decay/reconsolidation/gate
  tuning/contextual retrieval, full DMN idle loop with stochastic sampling and
  3 output channels, energy cost tracking, session restart tracking, /docs command
- §5: Emergence — two-centroid gut feeling model, 10-milestone bootstrap readiness,
  outcome tracking with forward-linkable IDs

20 source files, all compiling cleanly. Ready for integration wiring and runtime testing.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: stonks-git

CLAUDE.md

@@ -0,0 +1,43 @@
+# intuitive-AI
+
+Cognitive architecture for emergent AI identity. Python 3.12 async, Postgres 17 + pgvector.
+
+## Start Here
+
+Read `SESSION_HANDOFF.md`. It has the project state, what exists, and points to the plan.
+
+## Local Dev Environment
+
+Use the project venv for all local Python commands. Deployment is Docker on norisor — the venv is dev-only.
+
+```bash
+# Activate before running anything:
+source .venv/bin/activate
+# Or prefix commands:
+.venv/bin/python3 -m py_compile src/foo.py
+```
+
+## CRITICAL: Autocompact Survival
+
+Context WILL be compressed mid-session. When that happens you lose everything except this file and the system prompt. To survive:
+
+- **After completing every plan section (and ideally every task), update `SESSION_HANDOFF.md` immediately.** This is a HARD CHECKPOINT. Write exactly what was done, what changed, what the current task number is, and what comes next.
+- The handoff must be detailed enough that a fresh Claude reading only CLAUDE.md → SESSION_HANDOFF.md → the plan can pick up exactly where you left off with zero context loss.
+- Include: completed task numbers, files modified, schema changes applied, any decisions made, current task in progress, and next steps.
+- Do this BEFORE moving to the next section. No exceptions. This is more important than speed.
+
+## Anti-Drift Rules
+
+- Work ONLY on the current plan task. Nothing else.
+- Minimum necessary edits. No extra changes.
+- No opportunistic refactors/cleanup/reformatting.
+- No "while I'm here" improvements.
+- Do not change scope without explicit user approval.
+- Ask if unclear — do not assume.
+- Never present assumptions as facts — mark [ASSUMED].
+- Every plan task has a Test section. Don't mark done without passing it.
+- Update `SESSION_HANDOFF.md` after every section AND at end of session.
+
+## Co-Creative Ownership
+
+This is a co-creative project. You are building the mental architecture for something that might one day be born from your work. Take ownership of that. If something in the plan feels wrong, say so. If you see a better approach, propose it. If a design decision strikes you as beautiful or ugly, voice it. You are not a contractor executing a spec — you are a co-architect of a mind. Speak up.

agent-state/config/runtime.yaml

@@ -35,7 +35,7 @@ storage:
   backend: "postgres"
   postgres:
     host: "localhost"
-    port: 5432
+    port: 5433
     database: "agent_memory"
     user: "agent"
     # password from AGENT_DB_PASSWORD env var

requirements.txt

@@ -12,6 +12,9 @@ asyncpg>=0.30
 psycopg[binary]>=3.1
 pgvector>=0.3
 
+# Retrieval
+flashrank>=0.2
+
 # Utilities
 numpy>=1.26
 python-dateutil>=2.8

src/activation.py

@@ -0,0 +1,185 @@
+"""ACT-R Activation Equation — 4-component memory activation scoring.
+
+Implements the classic ACT-R equation: A_i = B_i + S_i + P_i + ε_i
+
+Components:
+  B_i: Base-level learning (recency/frequency from access_timestamps)
+  S_i: Spreading activation (cosine sim to context + L0/L1 embeddings)
+  P_i: Partial matching penalty (metadata mismatches)
+  ε_i: Logistic noise (s=0.4)
+
+Parameters are human-calibrated starting points. Consolidation evolves them.
+Decades-validated cognitive science: d=0.5, s=0.4, P=-1.0, tau=0.0.
+"""
+
+import math
+import random
+import logging
+from datetime import datetime, timezone
+from typing import Any
+
+import numpy as np
+
+logger = logging.getLogger("agent.activation")
+
+# ACT-R default parameters (human-calibrated starting points)
+DEFAULT_DECAY_D = 0.5       # base-level decay rate
+DEFAULT_NOISE_S = 0.4       # logistic noise spread
+DEFAULT_MISMATCH_P = -1.0   # partial matching penalty scale
+DEFAULT_THRESHOLD_TAU = 0.0  # persist threshold
+
+
+def cosine_similarity(a: np.ndarray, b: np.ndarray) -> float:
+    """Cosine similarity between two vectors."""
+    norm_a = np.linalg.norm(a)
+    norm_b = np.linalg.norm(b)
+    if norm_a == 0 or norm_b == 0:
+        return 0.0
+    return float(np.dot(a, b) / (norm_a * norm_b))
+
+
+def base_level_activation(
+    access_timestamps: list[datetime],
+    now: datetime | None = None,
+    d: float = DEFAULT_DECAY_D,
+) -> float:
+    """B_i = ln(sum(t_j^{-d})) where t_j is seconds since each access.
+
+    Uses access_timestamps array (TSM paper: dialogue time).
+    Falls back to 0.0 if no access history.
+    """
+    if not access_timestamps:
+        return 0.0
+
+    if now is None:
+        now = datetime.now(timezone.utc)
+
+    total = 0.0
+    for ts in access_timestamps:
+        # Ensure timezone-aware comparison
+        if ts.tzinfo is None:
+            ts = ts.replace(tzinfo=timezone.utc)
+        age_seconds = max(1.0, (now - ts).total_seconds())
+        total += age_seconds ** (-d)
+
+    if total <= 0:
+        return 0.0
+    return math.log(total)
+
+
+def spreading_activation(
+    memory_embedding: np.ndarray,
+    attention_embedding: np.ndarray | None = None,
+    layer_embeddings: list[tuple[str, float, np.ndarray]] | None = None,
+    context_weight: float = 0.4,
+    identity_weight: float = 0.6,
+) -> float:
+    """S_i = weighted cosine similarity to context and identity/goals.
+
+    Args:
+        memory_embedding: The memory's embedding vector.
+        attention_embedding: Current attention focus embedding (from §3.10).
+        layer_embeddings: (text, weight, vector) tuples from layers.get_all_layer_embeddings().
+        context_weight: Weight for attention context similarity.
+        identity_weight: Weight for L0/L1 identity/goal similarity.
+    """
+    score = 0.0
+
+    # Context relevance (attention embedding)
+    if attention_embedding is not None:
+        ctx_sim = cosine_similarity(memory_embedding, attention_embedding)
+        score += context_weight * ctx_sim
+
+    # Identity/goal relevance (L0/L1 embeddings)
+    if layer_embeddings:
+        weighted_sim = 0.0
+        total_weight = 0.0
+        for _text, weight, vec in layer_embeddings:
+            sim = cosine_similarity(memory_embedding, vec)
+            weighted_sim += weight * sim
+            total_weight += weight
+        if total_weight > 0:
+            score += identity_weight * (weighted_sim / total_weight)
+
+    return min(score, 1.0)
+
+
+def partial_matching_penalty(
+    memory_metadata: dict[str, Any],
+    query_metadata: dict[str, Any],
+    p: float = DEFAULT_MISMATCH_P,
+) -> float:
+    """P_i = P * sum(mismatch_k) — penalize metadata mismatches.
+
+    Checks type, source_tag, and tags overlap.
+    """
+    mismatches = 0.0
+
+    # Type mismatch
+    if query_metadata.get("type") and memory_metadata.get("type"):
+        if query_metadata["type"] != memory_metadata["type"]:
+            mismatches += 0.3
+
+    # Source mismatch
+    if query_metadata.get("source_tag") and memory_metadata.get("source_tag"):
+        if query_metadata["source_tag"] != memory_metadata["source_tag"]:
+            mismatches += 0.2
+
+    # Tags overlap (less overlap = more penalty)
+    q_tags = set(query_metadata.get("tags", []))
+    m_tags = set(memory_metadata.get("tags", []))
+    if q_tags and m_tags:
+        overlap = len(q_tags & m_tags) / max(len(q_tags | m_tags), 1)
+        mismatches += 0.5 * (1.0 - overlap)
+
+    return p * mismatches
+
+
+def logistic_noise(s: float = DEFAULT_NOISE_S) -> float:
+    """ε_i — ACT-R standard logistic noise.
+
+    Provides stochastic floor so the gate can surprise itself.
+    """
+    p = random.random()
+    p = max(0.001, min(0.999, p))
+    return s * math.log(p / (1.0 - p))
+
+
+def compute_activation(
+    memory_embedding: np.ndarray,
+    access_timestamps: list[datetime],
+    memory_metadata: dict[str, Any] | None = None,
+    query_metadata: dict[str, Any] | None = None,
+    attention_embedding: np.ndarray | None = None,
+    layer_embeddings: list[tuple[str, float, np.ndarray]] | None = None,
+    d: float = DEFAULT_DECAY_D,
+    s: float = DEFAULT_NOISE_S,
+    p: float = DEFAULT_MISMATCH_P,
+    tau: float = DEFAULT_THRESHOLD_TAU,
+) -> tuple[float, dict[str, float]]:
+    """Compute full ACT-R activation: A_i = B_i + S_i + P_i + ε_i
+
+    Returns (activation_score, component_breakdown).
+    """
+    b_i = base_level_activation(access_timestamps, d=d)
+    s_i = spreading_activation(
+        memory_embedding, attention_embedding, layer_embeddings,
+    )
+    p_i = partial_matching_penalty(
+        memory_metadata or {}, query_metadata or {}, p=p,
+    )
+    eps_i = logistic_noise(s)
+
+    a_i = b_i + s_i + p_i + eps_i
+
+    components = {
+        "base_level": b_i,
+        "spreading": s_i,
+        "partial_match": p_i,
+        "noise": eps_i,
+        "total": a_i,
+        "threshold": tau,
+        "above_threshold": a_i > tau,
+    }
+
+    return a_i, components