nexo-brain 0.6.0 → 0.7.0

package/README.md

@@ -1,12 +1,12 @@
 # NEXO Brain — Your AI Gets a Brain
 
-[![npm v0.5.0](https://img.shields.io/npm/v/nexo-brain?label=npm&color=purple)](https://www.npmjs.com/package/nexo-brain)
+[![npm v0.6.0](https://img.shields.io/npm/v/nexo-brain?label=npm&color=purple)](https://www.npmjs.com/package/nexo-brain)
 [![F1 0.588 on LoCoMo](https://img.shields.io/badge/LoCoMo_F1-0.588-brightgreen)](https://github.com/wazionapps/nexo/blob/main/benchmarks/locomo/results/)
 [![+55% vs GPT-4](https://img.shields.io/badge/vs_GPT--4-%2B55%25-blue)](https://github.com/snap-research/locomo/issues/33)
 [![GitHub stars](https://img.shields.io/github/stars/wazionapps/nexo?style=social)](https://github.com/wazionapps/nexo/stargazers)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-> **v0.5.0** — Highest published score on [LoCoMo benchmark](https://github.com/snap-research/locomo) (ACL 2024). F1 **0.588** — outperforms GPT-4 (0.379) by 55%. Runs on CPU. No GPU required. [Full results](benchmarks/locomo/results/)
+> **v0.6.0** — Now ships with **full orchestration**: 5 automated hooks, mandatory post-mortem with self-critique, pre-compaction context preservation, reflection engine, and auto-migration. Plus: F1 **0.588** on [LoCoMo](https://github.com/snap-research/locomo) (ACL 2024) — outperforms GPT-4 by 55%. Runs on CPU. [Full results](benchmarks/locomo/results/)
 
 **NEXO Brain transforms any MCP-compatible AI agent from a stateless assistant into a cognitive partner that remembers, learns, forgets, adapts, and builds a relationship with you over time.**
 
@@ -130,9 +130,9 @@ Like a human brain, NEXO Brain has automated processes that run while you're not
 
 If your Mac was asleep during any scheduled process, NEXO Brain catches up in order when it wakes.
 
-## Cognitive Features (v0.3.1)
+## Cognitive Features
 
-NEXO Brain v0.3.1 adds 21 cognitive tools on top of the 76 base tools, bringing the total to **97+ MCP tools**. These features implement cognitive science concepts that go beyond basic memory:
+NEXO Brain provides 21 cognitive tools on top of the 76 base tools, totaling **97+ MCP tools**. These features implement cognitive science concepts that go beyond basic memory:
 
 ### Input Pipeline
 
@@ -198,6 +198,65 @@ NEXO Brain was evaluated on [LoCoMo](https://github.com/snap-research/locomo) (A
 
 Full results in [`benchmarks/locomo/results/`](benchmarks/locomo/results/).
 
+## Full Orchestration System (v0.6.0)
+
+Memory alone doesn't make a co-operator. What makes the difference is the **behavioral loop** — the automated discipline that ensures every session starts informed, runs with guardrails, and ends with self-reflection.
+
+### 5 Automated Hooks
+
+These fire automatically at key moments in every Claude Code session:
+
+| Hook | When | What It Does |
+|------|------|-------------|
+| **SessionStart** | Session opens | Generates a briefing from SQLite: overdue reminders, today's tasks, pending followups, active sessions |
+| **Stop** | Session ends | Mandatory post-mortem: self-critique (5 questions), session buffer entry, followup creation, proactive seeds for next session |
+| **PostToolUse** | After each tool call | Captures meaningful mutations to the Sensory Register |
+| **PreCompact** | Before context compression | Saves checkpoint, reminds operator to write diary — prevents losing the thread |
+| **Caffeinate** | Always (optional) | Keeps Mac awake for nocturnal cognitive processes |
+
+### The Session Lifecycle
+
+```
+Session starts
+    ↓
+SessionStart hook generates briefing
+    ↓
+Operator reads diary, reminders, followups
+    ↓
+Heartbeat on every interaction (sentiment, context shifts)
+    ↓
+Guard check before every code edit
+    ↓
+PreCompact hook saves context if conversation is compressed
+    ↓
+Stop hook triggers mandatory post-mortem:
+  - Self-critique: 5 questions about what could be better
+  - Session buffer: structured entry for the reflection engine
+  - Followups: anything promised gets scheduled
+  - Proactive seeds: what can the next session do without being asked?
+    ↓
+Reflection engine processes buffer (after 3+ sessions)
+    ↓
+Nocturnal processes: decay, consolidation, self-audit, dreaming
+```
+
+### Reflection Engine
+
+After 3+ sessions accumulate, the stop hook triggers `nexo-reflection.py`:
+- Extracts recurring tasks, error patterns, mood trends
+- Updates `user_model.json` with observed behavior
+- No LLM required — runs as pure Python
+
+### Auto-Migration
+
+Existing users upgrading from v0.5.0:
+```bash
+npx nexo-brain  # detects v0.5.0, migrates automatically
+```
+- Updates hooks, core files, plugins, scripts
+- **Never touches your data** (memories, learnings, preferences)
+- Saves updated CLAUDE.md as reference (doesn't overwrite customizations)
+
 ## Quick Start
 
 ### Claude Code (Primary)
@@ -248,10 +307,12 @@ That's it. No need to run `claude` manually. Atlas will greet you immediately
 | Cognitive engine | Python: fastembed, numpy, vector search | pip packages |
 | MCP server | 97+ tools for memory, cognition, learning, guard | ~/.nexo/ |
 | Plugins | Guard, episodic memory, cognitive memory, entities, preferences | ~/.nexo/plugins/ |
-| Hooks | Session capture, briefing, stop detection | ~/.nexo/hooks/ |
+| Hooks (5) | SessionStart briefing, Stop post-mortem, PostToolUse capture, PreCompact checkpoint, Caffeinate | ~/.nexo/hooks/ |
+| Reflection engine | Processes session buffer, extracts patterns, updates user model | ~/.nexo/scripts/ |
+| CLAUDE.md | Complete operator instructions (Codex, hooks, guard, trust, memory) | ~/.claude/CLAUDE.md |
 | LaunchAgents | Decay, sleep, audit, postmortem, catch-up | ~/Library/LaunchAgents/ |
 | Auto-update | Checks for new versions at boot | Built into catch-up |
-| Claude Code config | MCP server + hooks registered | ~/.claude/settings.json |
+| Claude Code config | MCP server + 5 hooks registered | ~/.claude/settings.json |
 
 ### Requirements
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO — Cognitive co-operator for Claude Code. Atkinson-Shiffrin memory, semantic RAG, trust scoring, and metacognitive error prevention.",
   "bin": {

package/src/cognitive.py

@@ -30,13 +30,13 @@ DISCRIMINATING_ENTITIES = {
     # OS / Environment
     "linux", "mac", "macos", "windows", "darwin", "ubuntu", "debian", "alpine",
     # Platforms
-    "nexo", "other", "whatsapp", "chrome", "firefox",
+    "shopify", "wazion", "whatsapp", "chrome", "firefox",
     # Languages / Runtimes
     "python", "php", "javascript", "typescript", "node", "deno", "ruby",
     # Versions
     "v1", "v2", "v3", "v4", "v5", "5.6", "7.4", "8.0", "8.1", "8.2",
     # Infrastructure
-    "vps", "local", "production", "staging",
+    "cloudrun", "gcloud", "vps", "local", "production", "staging",
     # DB
     "mysql", "sqlite", "postgresql", "postgres", "redis",
 }
@@ -468,13 +468,32 @@ def _init_tables(conn: sqlite3.Connection):
             SELECT id, content, source_type, source_id, domain FROM {store}_memories
         """)
 
-    # Temporal indexing columns
+    # Temporal indexing columns (Task C)
     for table in ("stm_memories", "ltm_memories"):
         try:
             conn.execute(f"ALTER TABLE {table} ADD COLUMN temporal_date TEXT DEFAULT ''")
         except Exception:
             pass  # Column already exists
 
+    # Somatic markers — emotional risk memory for files and areas
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS somatic_markers (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            target TEXT NOT NULL,
+            target_type TEXT NOT NULL,
+            risk_score REAL DEFAULT 0.0,
+            incident_count INTEGER DEFAULT 0,
+            last_incident TEXT DEFAULT NULL,
+            last_decay TEXT DEFAULT NULL,
+            last_guard_decay_date TEXT DEFAULT NULL,
+            last_validated_at TEXT DEFAULT NULL,
+            created_at TEXT DEFAULT (datetime('now')),
+            updated_at TEXT DEFAULT (datetime('now')),
+            UNIQUE(target, target_type)
+        )
+    """)
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_somatic_target ON somatic_markers(target)")
+
     conn.commit()
 
 
@@ -574,28 +593,37 @@ def extract_temporal_date(text: str) -> str:
     text_lower = text.lower()
 
     # Pattern 1: "DD Month YYYY" or "Month DD, YYYY" or "D Month, YYYY"
+    # e.g., "8 May, 2023", "May 8, 2023", "25 May, 2023"
     for month_name, month_num in _MONTH_MAP.items():
         # "8 May, 2023" or "8 May 2023"
         match = re.search(rf'(\d{{1,2}})\s+{month_name}[,]?\s+(\d{{4}})', text_lower)
         if match:
-            day, year = match.group(1).zfill(2), match.group(2)
-            return f"{year}-{month_num}-{day}"
+            day = int(match.group(1))
+            year = match.group(2)
+            return f"{year}-{month_num}-{day:02d}"
+
         # "May 8, 2023" or "May 8 2023"
         match = re.search(rf'{month_name}\s+(\d{{1,2}})[,]?\s+(\d{{4}})', text_lower)
         if match:
-            day, year = match.group(1).zfill(2), match.group(2)
-            return f"{year}-{month_num}-{day}"
+            day = int(match.group(1))
+            year = match.group(2)
+            return f"{year}-{month_num}-{day:02d}"
 
-    # Pattern 2: ISO format YYYY-MM-DD
+    # Pattern 2: ISO format "2023-05-08"
     match = re.search(r'(\d{4})-(\d{2})-(\d{2})', text)
     if match:
         return match.group(0)
 
-    # Pattern 3: DD/MM/YYYY or MM/DD/YYYY (assume DD/MM/YYYY)
+    # Pattern 3: "DD/MM/YYYY" or "MM/DD/YYYY" (ambiguous, try DD/MM first)
     match = re.search(r'(\d{1,2})/(\d{1,2})/(\d{4})', text)
     if match:
-        d, m, y = match.group(1).zfill(2), match.group(2).zfill(2), match.group(3)
-        return f"{y}-{m}-{d}"
+        a, b, year = int(match.group(1)), int(match.group(2)), match.group(3)
+        if a > 12:  # Must be DD/MM
+            return f"{year}-{b:02d}-{a:02d}"
+        elif b > 12:  # Must be MM/DD
+            return f"{year}-{a:02d}-{b:02d}"
+        # Ambiguous — default to DD/MM (European)
+        return f"{year}-{b:02d}-{a:02d}"
 
     return ""
 
@@ -670,45 +698,37 @@ def bm25_search(query_text: str, stores: str = "both", top_k: int = 20,
 
 
 def _rrf_fuse(vector_results: list[dict], bm25_results: list[dict],
-              k: int = 60, alpha: float = 0.5) -> list[dict]:
-    """Reciprocal Rank Fusion: combine vector and BM25 results.
+              k: int = 60, alpha: float = 0.7) -> list[dict]:
+    """Reciprocal Rank Fusion: boost vector results with BM25 keyword matches.
 
-    RRF score = alpha * 1/(k + vector_rank) + (1-alpha) * 1/(k + bm25_rank)
-    Higher alpha = more weight on vector search.
-    """
-    # Build score maps by (store, id)
-    scores = {}
-    metadata = {}
-
-    for rank, r in enumerate(vector_results):
-        key = (r["store"], r["id"])
-        scores[key] = alpha * (1.0 / (k + rank + 1))
-        metadata[key] = r
+    BM25 only BOOSTS existing vector results — never adds new ones.
+    This preserves vector search recall while improving precision for keyword-heavy queries.
 
+    RRF score = vector_score + (1-alpha) * 1/(k + bm25_rank) for items found by both.
+    Items only in vector results keep their original score.
+    """
+    # Build BM25 lookup by (store, id)
+    bm25_lookup = {}
     for rank, r in enumerate(bm25_results):
         key = (r["store"], r["id"])
-        bm25_score = (1 - alpha) * (1.0 / (k + rank + 1))
-        if key in scores:
-            scores[key] += bm25_score
-        else:
-            scores[key] = bm25_score
-            metadata[key] = r
-
-    # Sort by fused score descending
-    sorted_keys = sorted(scores.keys(), key=lambda x: scores[x], reverse=True)
+        bm25_lookup[key] = rank + 1  # 1-based rank
 
+    # Boost vector results that also appear in BM25
     fused = []
-    for key in sorted_keys:
-        result = metadata[key].copy()
-        result["rrf_score"] = scores[key]
-        # Preserve original vector score if available
-        if "score" not in result:
-            result["score"] = scores[key]
+    for r in vector_results:
+        result = r.copy()
+        key = (r["store"], r["id"])
+        if key in bm25_lookup:
+            bm25_rank = bm25_lookup[key]
+            boost = (1 - alpha) * (1.0 / (k + bm25_rank))
+            result["score"] = r["score"] + boost
+            result["bm25_boosted"] = True
         fused.append(result)
 
     return fused
 
 
+
 # ============================================================================
 # FEATURE 1: HyDE Query Expansion (adapted from Vestige hyde.rs)
 # Template-based Hypothetical Document Embeddings for improved search recall.
@@ -1091,6 +1111,13 @@ def search(
                     return merged
 
     db = _get_db()
+
+    # Detect temporal queries — boost results with temporal_date
+    _temporal_keywords = {"when", "date", "time", "first", "last", "before", "after",
+                          "cuándo", "cuando", "fecha", "primero", "último", "antes", "después"}
+    query_lower = query_text.lower().split()
+    is_temporal_query = bool(_temporal_keywords & set(query_lower))
+
     if use_hyde:
         query_vec = hyde_expand_query(query_text)
     else:
@@ -1126,6 +1153,11 @@ def search(
             if lifecycle == "pinned":
                 score = min(1.0, score + 0.2)
             if score >= min_score:
+                temporal = ""
+                try:
+                    temporal = row["temporal_date"] or ""
+                except (IndexError, KeyError):
+                    pass
                 results.append({
                     "store": "stm",
                     "id": row["id"],
@@ -1139,6 +1171,7 @@ def search(
                     "access_count": row["access_count"],
                     "score": score,
                     "lifecycle_state": lifecycle,
+                    "temporal_date": temporal,
                 })
 
     # Search LTM (active)
@@ -1204,14 +1237,18 @@ def search(
         if reactivated_ids:
             db.commit()
 
-    # Hybrid search: fuse vector results with BM25 keyword results
+    # Hybrid search: boost vector results with BM25 keyword matches
     if hybrid and query_text:
-        bm25_results = bm25_search(query_text, stores=stores, top_k=top_k * 2,
+        bm25_results = bm25_search(query_text, stores=stores, top_k=top_k * 4,
                                     source_type_filter=source_type_filter)
         if bm25_results:
             results = _rrf_fuse(results, bm25_results, alpha=hybrid_alpha)
-            # Re-apply min_score filter on fused results (use original vector score or rrf_score)
-            results = [r for r in results if r.get("score", 0) >= min_score or r.get("rrf_score", 0) > 0]
+
+    # Temporal boost: for "when" queries, boost results that have temporal_date
+    if is_temporal_query:
+        for r in results:
+            if r.get("temporal_date"):
+                r["score"] = min(1.0, r["score"] + 0.05)
 
     # Sort by score descending, take top-20 for reranking
     results.sort(key=lambda x: x.get("score", 0), reverse=True)
@@ -1296,16 +1333,7 @@ def search(
 
     # Rehearsal: update strength and access_count for returned results
     if rehearse and results:
-        now = datetime.utcnow().isoformat()
-        for r in results:
-            if (r["store"], r["id"]) in reactivated_ids:
-                continue
-            table = "stm_memories" if r["store"] == "stm" else "ltm_memories"
-            db.execute(
-                f"UPDATE {table} SET strength = 1.0, access_count = access_count + 1, last_accessed = ? WHERE id = ?",
-                (now, r["id"])
-            )
-        db.commit()
+        _rehearse_results(results, skip_ids=reactivated_ids)
 
     # Record co-activation for future spreading (Feature 2)
     if results and len(results) >= 2:
@@ -2528,7 +2556,7 @@ def resolve_dissonance(memory_id: int, resolution: str, context: str = "") -> st
     Args:
         memory_id: The LTM memory that conflicts with the new instruction
         resolution: One of:
-            - 'paradigm_shift': the user changed their mind permanently. Decay old memory,
+            - 'paradigm_shift': the user changed his mind permanently. Decay old memory,
               new instruction becomes the standard.
             - 'exception': This is a one-time override. Keep old memory as standard.
             - 'override': Old memory was wrong. Mark as corrupted and decay to dormant.
@@ -2717,6 +2745,25 @@ def get_trust_score() -> float:
     return row[0]
 
 
+def _annotate_adaptive_log(event: str, delta: float):
+    """Retroactively annotate the most recent adaptive_log entry with trust feedback."""
+    try:
+        from db import get_db
+        conn = get_db()
+        conn.execute(
+            "UPDATE adaptive_log SET feedback_event = ?, feedback_delta = ?, "
+            "feedback_ts = datetime('now') "
+            "WHERE id = (SELECT id FROM adaptive_log "
+            "WHERE feedback_event IS NULL "
+            "AND timestamp >= datetime('now', '-5 minutes') "
+            "ORDER BY id DESC LIMIT 1)",
+            (event, int(delta))
+        )
+        conn.commit()
+    except Exception:
+        pass
+
+
 def adjust_trust(event: str, context: str = "", custom_delta: float = None) -> dict:
     """Adjust trust score based on an event.
 
@@ -2744,6 +2791,22 @@ def adjust_trust(event: str, context: str = "", custom_delta: float = None) -> d
     )
     db.commit()
 
+    # Annotate adaptive log for learned weights
+    _annotate_adaptive_log(event, delta)
+
+    # Somatic event logging for repeated_error events (append-only in nexo.db)
+    if event == "repeated_error" and context:
+        try:
+            from db import get_db as get_nexo_db
+            area = context.split(":")[0].strip() if ":" in context else "unknown"
+            get_nexo_db().execute(
+                "INSERT INTO somatic_events (target, target_type, event_type, delta, source) VALUES (?, ?, ?, ?, ?)",
+                (area, "area", "repeated_error", 0.20, f"trust:{event}")
+            )
+            get_nexo_db().commit()
+        except Exception:
+            pass
+
     return {
         "old_score": round(old_score, 1),
         "delta": delta,
@@ -3321,3 +3384,125 @@ def security_scan(content: str) -> dict:
         "risk_score": round(risk_score, 3),
     }
 
+
+# ─── Somatic Markers ────────────────────────────────────────────────
+
+def somatic_accumulate(target: str, target_type: str, delta: float):
+    """Increase risk_score for a target (file or area). Capped at 1.0."""
+    db = _get_db()
+    now = datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S")
+    existing = db.execute(
+        "SELECT id, risk_score, incident_count FROM somatic_markers WHERE target = ? AND target_type = ?",
+        (target, target_type)
+    ).fetchone()
+    if existing:
+        new_score = min(1.0, existing["risk_score"] + delta)
+        db.execute(
+            "UPDATE somatic_markers SET risk_score = ?, incident_count = incident_count + 1, "
+            "last_incident = ?, updated_at = ? WHERE id = ?",
+            (new_score, now, now, existing["id"])
+        )
+    else:
+        db.execute(
+            "INSERT INTO somatic_markers (target, target_type, risk_score, incident_count, last_incident, updated_at) "
+            "VALUES (?, ?, ?, 1, ?, ?)",
+            (target, target_type, min(1.0, delta), now, now)
+        )
+    db.commit()
+
+
+def somatic_guard_decay(target: str, target_type: str):
+    """Validated recovery: multiplicative x0.7 on successful guard check. Max once/day/target."""
+    db = _get_db()
+    today = datetime.utcnow().strftime("%Y-%m-%d")
+    now = datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S")
+    row = db.execute(
+        "SELECT id, risk_score, last_guard_decay_date FROM somatic_markers WHERE target = ? AND target_type = ?",
+        (target, target_type)
+    ).fetchone()
+    if not row or row["risk_score"] <= 0:
+        return
+    if row["last_guard_decay_date"] == today:
+        return
+    new_score = max(0.0, row["risk_score"] * 0.7)
+    if new_score < 0.01:
+        new_score = 0.0
+    db.execute(
+        "UPDATE somatic_markers SET risk_score = ?, last_guard_decay_date = ?, "
+        "last_validated_at = ?, updated_at = datetime('now') WHERE id = ?",
+        (new_score, today, now, row["id"])
+    )
+    db.commit()
+
+
+def somatic_nightly_decay(gamma: float = 0.95):
+    """Apply nightly decay to all somatic markers. Called from cognitive-decay cron."""
+    db = _get_db()
+    rows = db.execute("SELECT id, risk_score FROM somatic_markers WHERE risk_score > 0").fetchall()
+    updated = 0
+    for row in rows:
+        new_score = row["risk_score"] * gamma
+        if new_score < 0.01:
+            new_score = 0.0
+        db.execute(
+            "UPDATE somatic_markers SET risk_score = ?, last_decay = datetime('now'), updated_at = datetime('now') WHERE id = ?",
+            (new_score, row["id"])
+        )
+        updated += 1
+    db.commit()
+    return updated
+
+
+def somatic_project_events():
+    """Project unprojected somatic_events from nexo.db into cognitive.db somatic_markers.
+    Called during nightly cron. Idempotent — each event processed exactly once.
+    """
+    try:
+        from db import get_db
+        conn = get_db()
+        rows = conn.execute(
+            "SELECT id, target, target_type, delta FROM somatic_events WHERE projected = 0 ORDER BY id"
+        ).fetchall()
+        for row in rows:
+            somatic_accumulate(row["target"], row["target_type"], row["delta"])
+            conn.execute("UPDATE somatic_events SET projected = 1 WHERE id = ?", (row["id"],))
+        conn.commit()
+        return len(rows)
+    except Exception:
+        return 0
+
+
+def somatic_get_risk(targets: list, area: str = "") -> dict:
+    """Get risk scores for targets (files) and optional area."""
+    db = _get_db()
+    scores = {}
+    for t in targets:
+        row = db.execute(
+            "SELECT risk_score, incident_count, last_incident FROM somatic_markers WHERE target = ? AND target_type = 'file'",
+            (t,)
+        ).fetchone()
+        if row and row["risk_score"] > 0:
+            scores[t] = {"risk": round(row["risk_score"], 3), "incidents": row["incident_count"],
+                         "last": row["last_incident"] or "unknown"}
+    if area:
+        row = db.execute(
+            "SELECT risk_score, incident_count, last_incident FROM somatic_markers WHERE target = ? AND target_type = 'area'",
+            (area,)
+        ).fetchone()
+        if row and row["risk_score"] > 0:
+            scores[f"area:{area}"] = {"risk": round(row["risk_score"], 3), "incidents": row["incident_count"],
+                                       "last": row["last_incident"] or "unknown"}
+    all_risks = [s["risk"] for s in scores.values()]
+    return {"max_risk": max(all_risks) if all_risks else 0.0, "scores": scores}
+
+
+def somatic_top_risks(limit: int = 10) -> list:
+    """Get top N riskiest targets across all types."""
+    db = _get_db()
+    rows = db.execute(
+        "SELECT target, target_type, risk_score, incident_count, last_incident "
+        "FROM somatic_markers WHERE risk_score > 0 ORDER BY risk_score DESC LIMIT ?",
+        (limit,)
+    ).fetchall()
+    return [dict(r) for r in rows]
+

package/src/db.py

@@ -862,6 +862,42 @@ def _m7_diary_source_and_draft(conn):
     """)
 
 
+def _m8_adaptive_log_and_somatic(conn):
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS adaptive_log (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            timestamp TEXT DEFAULT (datetime('now')),
+            mode TEXT NOT NULL,
+            tension_score REAL NOT NULL,
+            sig_vibe REAL DEFAULT 0,
+            sig_corrections REAL DEFAULT 0,
+            sig_brevity REAL DEFAULT 0,
+            sig_topic REAL DEFAULT 0,
+            sig_tool_errors REAL DEFAULT 0,
+            sig_git_diff REAL DEFAULT 0,
+            context_hint TEXT DEFAULT '',
+            feedback_event TEXT DEFAULT NULL,
+            feedback_delta INTEGER DEFAULT NULL,
+            feedback_ts TEXT DEFAULT NULL
+        )
+    """)
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_adaptive_log_ts ON adaptive_log(timestamp)")
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS somatic_events (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            timestamp TEXT DEFAULT (datetime('now')),
+            target TEXT NOT NULL,
+            target_type TEXT NOT NULL,
+            event_type TEXT NOT NULL,
+            delta REAL NOT NULL,
+            source TEXT DEFAULT '',
+            projected INTEGER DEFAULT 0
+        )
+    """)
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_somatic_events_target ON somatic_events(target)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_somatic_events_projected ON somatic_events(projected)")
+
+
 # Migration registry — APPEND ONLY, never reorder or delete
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
@@ -871,6 +907,7 @@ MIGRATIONS = [
     (5, "change_log_indexes", _m5_change_log_indexes),
     (6, "error_guard_tables", _m6_error_guard_tables),
     (7, "diary_source_and_draft", _m7_diary_source_and_draft),
+    (8, "adaptive_log_and_somatic", _m8_adaptive_log_and_somatic),
 ]
 
 

package/src/hooks/session-stop.sh

@@ -79,7 +79,20 @@ fi
 
 if [ "$SKIP_FALLBACK" = false ]; then
     mkdir -p "$(dirname "$BUFFER")"
-    echo "{\"ts\":\"$TIMESTAMP\",\"tasks\":[\"session ended\"],\"decisions\":[],\"user_patterns\":[],\"files_modified\":[],\"errors_resolved\":[],\"self_critique\":\"hook-fallback, no self-critique captured\",\"mood\":\"unknown\",\"source\":\"hook-fallback\"}" >> "$BUFFER" 2>/dev/null
+    # Read current adaptive mode for the buffer entry
+    ADAPTIVE_MODE="unknown"
+    ADAPTIVE_FILE="$NEXO_HOME/brain/adaptive_state.json"
+    if [ -f "$ADAPTIVE_FILE" ]; then
+        ADAPTIVE_MODE=$(python3 -c "
+import json
+try:
+    d = json.load(open('$ADAPTIVE_FILE'))
+    print(d.get('current_mode', 'unknown').lower())
+except:
+    print('unknown')
+" 2>/dev/null || echo "unknown")
+    fi
+    echo "{\"ts\":\"$TIMESTAMP\",\"tasks\":[\"session ended\"],\"decisions\":[],\"user_patterns\":[],\"files_modified\":[],\"errors_resolved\":[],\"self_critique\":\"hook-fallback, no self-critique captured\",\"mood\":\"unknown\",\"session_end_mode\":\"$ADAPTIVE_MODE\",\"source\":\"hook-fallback\"}" >> "$BUFFER" 2>/dev/null
 fi
 
 # 3. Intra-day reflection trigger