nexo-brain 4.0.1 → 4.1.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "description": "Local cognitive runtime for Claude Code \u2014 persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
   "author": {
     "name": "NEXO Brain",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain — Shared brain for AI agents. Persistent memory, semantic RAG, natural forgetting, metacognitive guard, trust scoring, 150+ MCP tools. Works with Claude Code, Codex, Claude Desktop & any MCP client. 100% local, free.",
   "homepage": "https://nexo-brain.com",

package/src/db/__init__.py

@@ -51,6 +51,7 @@ _watchers = _load_submodule("db._watchers")
 _personal_scripts = _load_submodule("db._personal_scripts")
 _skills = _load_submodule("db._skills")
 _hot_context = _load_submodule("db._hot_context")
+_drive = _load_submodule("db._drive")
 
 # Core: connection, constants, init, utils
 from db._core import (
@@ -187,6 +188,13 @@ from db._skills import (
     get_skill_health_report,
 )
 
+# Drive / Curiosity signals
+from db._drive import (
+    create_drive_signal, reinforce_drive_signal, get_drive_signals,
+    get_drive_signal, update_drive_signal_status, decay_drive_signals,
+    find_similar_drive_signal, drive_signal_stats,
+)
+
 # Hot context / recent continuity
 from db._hot_context import (
     DEFAULT_CONTEXT_TTL_HOURS,

package/src/db/_drive.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+"""NEXO DB — Drive/Curiosity signals for autonomous investigation."""
+
+import importlib
+import json
+import sys
+from datetime import datetime, timezone
+
+
+def _core():
+    module = sys.modules.get("db._core")
+    if module is None:
+        module = importlib.import_module("db._core")
+    return module
+
+
+MAX_ACTIVE_SIGNALS = 30
+REINFORCE_BOOST = 0.15
+RISING_THRESHOLD = 0.4
+READY_THRESHOLD = 0.7
+RISING_DECAY_RATE = 0.03  # slower decay once rising
+
+VALID_SIGNAL_TYPES = {"anomaly", "pattern", "connection", "gap", "opportunity"}
+VALID_STATUSES = {"latent", "rising", "ready", "acted", "dismissed"}
+
+
+def _table_exists(conn) -> bool:
+    row = conn.execute(
+        "SELECT 1 FROM sqlite_master WHERE type='table' AND name='drive_signals' LIMIT 1"
+    ).fetchone()
+    return row is not None
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+
+
+def create_drive_signal(
+    signal_type: str,
+    source: str,
+    summary: str,
+    source_id: str = "",
+    area: str = "",
+    tension: float = 0.3,
+    decay_rate: float = 0.05,
+    evidence: list[str] | None = None,
+) -> dict:
+    """Create a new drive signal. Returns the created row as dict."""
+    conn = _core().get_db()
+    if not _table_exists(conn):
+        return {"ok": False, "error": "drive_signals table not yet created"}
+
+    if signal_type not in VALID_SIGNAL_TYPES:
+        return {"ok": False, "error": f"Invalid signal_type: {signal_type}. Must be one of {VALID_SIGNAL_TYPES}"}
+
+    tension = max(0.0, min(1.0, tension))
+    evidence_json = json.dumps(evidence or [summary[:200]], ensure_ascii=False)
+    now = _now_iso()
+
+    # Enforce max active signals — drop weakest latent if at limit
+    active_count = conn.execute(
+        "SELECT COUNT(*) FROM drive_signals WHERE status IN ('latent', 'rising', 'ready')"
+    ).fetchone()[0]
+    if active_count >= MAX_ACTIVE_SIGNALS:
+        conn.execute(
+            "DELETE FROM drive_signals WHERE id = ("
+            "  SELECT id FROM drive_signals"
+            "  WHERE status = 'latent'"
+            "  ORDER BY tension ASC, first_seen ASC"
+            "  LIMIT 1"
+            ")"
+        )
+        conn.commit()
+
+    cursor = conn.execute(
+        "INSERT INTO drive_signals "
+        "(signal_type, source, source_id, area, summary, tension, evidence, "
+        " status, first_seen, last_reinforced, decay_rate) "
+        "VALUES (?, ?, ?, ?, ?, ?, ?, 'latent', ?, ?, ?)",
+        (signal_type, source, source_id, area, summary, tension,
+         evidence_json, now, now, decay_rate),
+    )
+    conn.commit()
+    signal_id = cursor.lastrowid
+    return {"ok": True, "id": signal_id, "tension": tension, "status": "latent"}
+
+
+def reinforce_drive_signal(signal_id: int, observation: str) -> dict:
+    """Reinforce an existing signal: add evidence, boost tension, maybe promote status."""
+    conn = _core().get_db()
+    if not _table_exists(conn):
+        return {"ok": False, "error": "drive_signals table not yet created"}
+
+    row = conn.execute(
+        "SELECT * FROM drive_signals WHERE id = ?", (signal_id,)
+    ).fetchone()
+    if not row:
+        return {"ok": False, "error": f"Signal {signal_id} not found"}
+
+    status = row["status"]
+    if status in ("acted", "dismissed"):
+        return {"ok": False, "error": f"Signal {signal_id} is already {status}"}
+
+    # Update evidence
+    try:
+        evidence = json.loads(row["evidence"] or "[]")
+    except (json.JSONDecodeError, TypeError):
+        evidence = []
+    evidence.append(observation[:500])
+
+    # Boost tension
+    old_tension = float(row["tension"] or 0.3)
+    new_tension = min(1.0, old_tension + REINFORCE_BOOST)
+
+    # Status promotion
+    new_status = status
+    reinforce_count = len(evidence)
+    if new_tension >= READY_THRESHOLD or reinforce_count >= 3:
+        new_status = "ready"
+    elif new_tension >= RISING_THRESHOLD:
+        new_status = "rising"
+
+    # Rising signals decay slower
+    new_decay = RISING_DECAY_RATE if new_status in ("rising", "ready") else float(row["decay_rate"] or 0.05)
+
+    now = _now_iso()
+    conn.execute(
+        "UPDATE drive_signals SET tension = ?, evidence = ?, status = ?, "
+        "decay_rate = ?, last_reinforced = ? WHERE id = ?",
+        (new_tension, json.dumps(evidence, ensure_ascii=False),
+         new_status, new_decay, now, signal_id),
+    )
+    conn.commit()
+    return {
+        "ok": True, "id": signal_id,
+        "old_tension": old_tension, "new_tension": new_tension,
+        "old_status": status, "new_status": new_status,
+        "evidence_count": reinforce_count,
+    }
+
+
+def get_drive_signals(
+    status: str | None = None,
+    area: str | None = None,
+    limit: int = 30,
+) -> list[dict]:
+    """List active drive signals, optionally filtered."""
+    conn = _core().get_db()
+    if not _table_exists(conn):
+        return []
+
+    clauses = []
+    params: list = []
+    if status:
+        clauses.append("status = ?")
+        params.append(status)
+    else:
+        # Default: only active signals
+        clauses.append("status IN ('latent', 'rising', 'ready')")
+    if area:
+        clauses.append("area = ?")
+        params.append(area)
+
+    where = " AND ".join(clauses) if clauses else "1=1"
+    params.append(min(limit, 100))
+
+    rows = conn.execute(
+        f"SELECT * FROM drive_signals WHERE {where} ORDER BY tension DESC, last_reinforced DESC LIMIT ?",
+        params,
+    ).fetchall()
+    return [dict(r) for r in rows]
+
+
+def get_drive_signal(signal_id: int) -> dict | None:
+    """Get a single signal with full details."""
+    conn = _core().get_db()
+    if not _table_exists(conn):
+        return None
+
+    row = conn.execute(
+        "SELECT * FROM drive_signals WHERE id = ?", (signal_id,)
+    ).fetchone()
+    return dict(row) if row else None
+
+
+def update_drive_signal_status(
+    signal_id: int,
+    status: str,
+    outcome: str = "",
+) -> dict:
+    """Transition a signal to a new status (acted/dismissed)."""
+    conn = _core().get_db()
+    if not _table_exists(conn):
+        return {"ok": False, "error": "drive_signals table not yet created"}
+
+    if status not in VALID_STATUSES:
+        return {"ok": False, "error": f"Invalid status: {status}"}
+
+    row = conn.execute(
+        "SELECT * FROM drive_signals WHERE id = ?", (signal_id,)
+    ).fetchone()
+    if not row:
+        return {"ok": False, "error": f"Signal {signal_id} not found"}
+
+    now = _now_iso()
+    updates = {"status": status}
+    if status == "acted":
+        updates["acted_at"] = now
+    if outcome:
+        updates["outcome"] = outcome
+
+    set_clause = ", ".join(f"{k} = ?" for k in updates)
+    params = list(updates.values()) + [signal_id]
+    conn.execute(f"UPDATE drive_signals SET {set_clause} WHERE id = ?", params)
+    conn.commit()
+    return {"ok": True, "id": signal_id, "new_status": status}
+
+
+def decay_drive_signals() -> dict:
+    """Apply daily decay to all active signals. Kill those at or below 0."""
+    conn = _core().get_db()
+    if not _table_exists(conn):
+        return {"decayed": 0, "killed": 0}
+
+    # Ready signals don't decay
+    rows = conn.execute(
+        "SELECT id, tension, decay_rate, status FROM drive_signals "
+        "WHERE status IN ('latent', 'rising')"
+    ).fetchall()
+
+    decayed = 0
+    killed = 0
+    for row in rows:
+        new_tension = float(row["tension"]) - float(row["decay_rate"] or 0.05)
+        if new_tension <= 0:
+            conn.execute("DELETE FROM drive_signals WHERE id = ?", (row["id"],))
+            killed += 1
+        else:
+            conn.execute(
+                "UPDATE drive_signals SET tension = ? WHERE id = ?",
+                (new_tension, row["id"]),
+            )
+            decayed += 1
+
+    conn.commit()
+    return {"decayed": decayed, "killed": killed}
+
+
+def find_similar_drive_signal(summary: str, area: str = "") -> dict | None:
+    """Find an existing active signal similar to the given summary.
+
+    Uses keyword overlap heuristic to avoid duplicates.
+    """
+    conn = _core().get_db()
+    if not _table_exists(conn):
+        return None
+
+    # Extract meaningful words (4+ chars) from summary
+    words = {w.lower() for w in summary.split() if len(w) >= 4}
+    if not words:
+        return None
+
+    clauses = ["status IN ('latent', 'rising', 'ready')"]
+    params: list = []
+    if area:
+        clauses.append("area = ?")
+        params.append(area)
+
+    where = " AND ".join(clauses)
+    rows = conn.execute(
+        f"SELECT * FROM drive_signals WHERE {where} ORDER BY tension DESC",
+        params,
+    ).fetchall()
+
+    best_match = None
+    best_score = 0.0
+    for row in rows:
+        row_words = {w.lower() for w in (row["summary"] or "").split() if len(w) >= 4}
+        if not row_words:
+            continue
+        overlap = len(words & row_words)
+        score = overlap / max(len(words | row_words), 1)
+        if score > best_score and score >= 0.4:  # 40% word overlap threshold
+            best_score = score
+            best_match = dict(row)
+
+    return best_match
+
+
+def drive_signal_stats() -> dict:
+    """Return aggregate stats about drive signals."""
+    conn = _core().get_db()
+    if not _table_exists(conn):
+        return {"total": 0, "by_status": {}, "by_type": {}, "by_area": {}}
+
+    total = conn.execute("SELECT COUNT(*) FROM drive_signals").fetchone()[0]
+
+    by_status = {}
+    for row in conn.execute(
+        "SELECT status, COUNT(*) as cnt FROM drive_signals GROUP BY status"
+    ).fetchall():
+        by_status[row["status"]] = row["cnt"]
+
+    by_type = {}
+    for row in conn.execute(
+        "SELECT signal_type, COUNT(*) as cnt FROM drive_signals "
+        "WHERE status IN ('latent', 'rising', 'ready') GROUP BY signal_type"
+    ).fetchall():
+        by_type[row["signal_type"]] = row["cnt"]
+
+    by_area = {}
+    for row in conn.execute(
+        "SELECT area, COUNT(*) as cnt FROM drive_signals "
+        "WHERE status IN ('latent', 'rising', 'ready') AND area != '' GROUP BY area"
+    ).fetchall():
+        by_area[row["area"]] = row["cnt"]
+
+    return {"total": total, "by_status": by_status, "by_type": by_type, "by_area": by_area}

package/src/db/_schema.py

@@ -752,6 +752,37 @@ def _m30_hot_context_memory(conn):
     _migrate_add_index(conn, "idx_recent_events_session", "recent_events", "session_id, created_at")
 
 
+def _m31_drive_signals(conn):
+    """Drive/Curiosity layer — autonomous tension-based investigation signals."""
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS drive_signals (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            signal_type TEXT NOT NULL,
+            source TEXT NOT NULL,
+            source_id TEXT DEFAULT '',
+            area TEXT DEFAULT '',
+            summary TEXT NOT NULL,
+            tension REAL DEFAULT 0.3,
+            evidence TEXT DEFAULT '[]',
+            status TEXT DEFAULT 'latent',
+            first_seen TEXT DEFAULT (datetime('now')),
+            last_reinforced TEXT,
+            acted_at TEXT,
+            outcome TEXT,
+            decay_rate REAL DEFAULT 0.05
+        )
+    """)
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_drive_status ON drive_signals(status)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_drive_area ON drive_signals(area)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_drive_tension ON drive_signals(tension)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_drive_first_seen ON drive_signals(first_seen)")
+    # Register drive_decay in maintenance_schedule
+    conn.execute(
+        "INSERT OR IGNORE INTO maintenance_schedule (task_name, interval_hours) VALUES (?, ?)",
+        ('drive_decay', 24),
+    )
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -783,6 +814,7 @@ MIGRATIONS = [
     (28, "automation_runs", _m28_automation_runs),
     (29, "item_history_and_soft_delete", _m29_item_history_and_soft_delete),
     (30, "hot_context_memory", _m30_hot_context_memory),
+    (31, "drive_signals", _m31_drive_signals),
 ]
 
 

package/src/maintenance.py

@@ -55,5 +55,8 @@ def _run_task(task_name: str):
             prune_adaptive_log()
         except Exception:
             pass
+    elif task_name == "drive_decay":
+        from db import decay_drive_signals
+        decay_drive_signals()
     elif task_name == "graph_maintenance":
         pass  # Future: orphan cleanup, consolidation

package/src/plugins/protocol.py

@@ -894,6 +894,22 @@ def handle_task_close(
         },
         ttl_hours=24,
     )
+    # ── Drive/Curiosity: detect signals from task evidence (best-effort) ──
+    try:
+        _drive_text = " ".join(filter(None, [
+            outcome_notes, clean_evidence, change_summary, change_why,
+        ]))
+        if _drive_text and len(_drive_text.strip()) >= 15:
+            from tools_drive import detect_drive_signal as _detect_drive
+            _detect_drive(
+                _drive_text[:600],
+                source="task_close",
+                source_id=task_id,
+                area=task.get("area", ""),
+            )
+    except Exception:
+        pass  # Drive detection is best-effort
+
     open_debts = list_protocol_debts(status="open", task_id=task_id, limit=20)
 
     response = {

package/src/scripts/deep-sleep/apply_findings.py

@@ -2039,6 +2039,29 @@ def main():
     except Exception as e:
         print(f"  Skill autopromotion error: {e}", file=sys.stderr)
 
+    # Apply drive synthesis (investigate/dismiss/promote signals)
+    drive_synthesis = synthesis.get("drive_synthesis", {})
+    if drive_synthesis:
+        print("[apply] Processing drive synthesis...")
+        try:
+            from db import update_drive_signal_status, reinforce_drive_signal
+            for item in drive_synthesis.get("investigated", []):
+                signal_id = item.get("signal_id")
+                action_taken = item.get("action_taken", "acted")
+                outcome = item.get("outcome", item.get("finding", ""))
+                if signal_id and outcome:
+                    update_drive_signal_status(signal_id, action_taken, outcome[:500])
+                    stats["applied"] += 1
+                    print(f"  Drive signal #{signal_id}: {action_taken}")
+            for item in drive_synthesis.get("promoted", []):
+                signal_id = item.get("signal_id")
+                reason = item.get("reason", "promoted by Deep Sleep")
+                if signal_id:
+                    reinforce_drive_signal(signal_id, f"Deep Sleep promotion: {reason}"[:500])
+                    print(f"  Drive signal #{signal_id}: promoted")
+        except Exception as e:
+            print(f"  Drive synthesis error: {e}", file=sys.stderr)
+
     # Create followups for abandoned projects
     abandoned_results = create_abandoned_followups(synthesis)
     for r in abandoned_results:

package/src/scripts/deep-sleep/synthesize-prompt.md

@@ -143,6 +143,16 @@ When generating `followup_create`, prefer descriptions that start with a concret
 
 Avoid vague followups that merely restate the diagnosis.
 
+### 10. Drive/Curiosity Synthesis
+Review the active drive signals (accessible via `nexo_drive_signals`). For each READY signal:
+- Investigate silently: check metrics, recall memory, cross-reference learnings
+- If the investigation yields an actionable finding, create an action item and mark the signal as `acted`
+- If the signal is stale or no longer relevant, dismiss it with a reason
+- Cross-reference RISING signals across areas — if two signals from different domains converge, promote to READY
+- Apply decay to LATENT signals that have no recent reinforcement
+
+Drive signals represent NEXO's autonomous curiosity. Treat them as leads worth investigating, not noise to dismiss.
+
 ## Output Format
 
 Return ONLY valid JSON. No markdown code fences. No explanation text.
@@ -273,6 +283,30 @@ Return ONLY valid JSON. No markdown code fences. No explanation text.
     }
   ],
 
+  "drive_synthesis": {
+    "investigated": [
+      {
+        "signal_id": 1,
+        "summary": "What the signal was about",
+        "finding": "What investigation revealed",
+        "action_taken": "acted|dismissed",
+        "outcome": "Concrete result or reason for dismissal"
+      }
+    ],
+    "promoted": [
+      {
+        "signal_id": 2,
+        "reason": "Why this signal was promoted from rising to ready"
+      }
+    ],
+    "cross_area_connections": [
+      {
+        "signal_ids": [3, 7],
+        "connection": "How these signals from different areas relate"
+      }
+    ]
+  },
+
   "trust_calibration": {
     "score": 72,
     "reasoning": "Why this score -- based on corrections, completions, autonomy, proactivity, and user satisfaction signals across ALL sessions",

package/src/server.py

@@ -32,6 +32,12 @@ from tools_system_catalog import (
     handle_system_catalog,
     handle_tool_explain,
 )
+from tools_drive import (
+    handle_drive_signals,
+    handle_drive_reinforce,
+    handle_drive_act,
+    handle_drive_dismiss,
+)
 from user_context import get_context as _get_ctx
 from tools_coordination import (
     handle_track, handle_untrack, handle_files,
@@ -1143,6 +1149,62 @@ def nexo_plugin_remove(filename: str) -> str:
         return f"Error removing plugin {filename}: {e}"
 
 
+# ── Drive / Curiosity (4 tools) ──────────────────────────────────
+
+@mcp.tool
+def nexo_drive_signals(status: str = "", area: str = "", limit: int = 20) -> str:
+    """List autonomous drive/curiosity signals.
+
+    Drive signals are observations NEXO accumulates during normal work.
+    When tension crosses threshold, NEXO investigates silently.
+
+    Args:
+        status: Filter by status (latent, rising, ready, acted, dismissed). Default: active only.
+        area: Filter by operational area (shopify, google-ads, wazion, nexo, etc.).
+        limit: Max signals to return (default 20).
+    """
+    return handle_drive_signals(status, area, limit)
+
+
+@mcp.tool
+def nexo_drive_reinforce(signal_id: int, observation: str) -> str:
+    """Reinforce a drive signal with a new observation.
+
+    Increases tension and may promote the signal status (latent → rising → ready).
+
+    Args:
+        signal_id: Signal ID to reinforce.
+        observation: New observation that supports this signal.
+    """
+    return handle_drive_reinforce(signal_id, observation)
+
+
+@mcp.tool
+def nexo_drive_act(signal_id: int, outcome: str) -> str:
+    """Mark a drive signal as investigated with an outcome.
+
+    Call this after NEXO has autonomously investigated a READY signal.
+
+    Args:
+        signal_id: Signal ID that was investigated.
+        outcome: What was found during investigation.
+    """
+    return handle_drive_act(signal_id, outcome)
+
+
+@mcp.tool
+def nexo_drive_dismiss(signal_id: int, reason: str) -> str:
+    """Dismiss a drive signal (archived, not deleted).
+
+    Call this when a signal is not worth investigating.
+
+    Args:
+        signal_id: Signal ID to dismiss.
+        reason: Why this signal was dismissed.
+    """
+    return handle_drive_dismiss(signal_id, reason)
+
+
 if __name__ == "__main__":
     _server_init()
     mcp.run(**_run_kwargs_from_env())

package/src/tools_drive.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+"""NEXO Drive/Curiosity — autonomous investigation signals.
+
+Public MCP tool handlers + internal detection logic that feeds from
+heartbeat, task_close, and diary consolidation.
+"""
+
+import json
+import re
+from db import (
+    create_drive_signal, reinforce_drive_signal, get_drive_signals,
+    get_drive_signal, update_drive_signal_status, decay_drive_signals,
+    find_similar_drive_signal, drive_signal_stats,
+)
+
+
+# ── Heuristic detection keywords ─────────────────────────────────────
+
+_ANOMALY_PATTERNS = [
+    re.compile(r"\b(subió|bajó|cayó|subi[oó]|baj[oó]|dropped|spiked|jumped)\b.*\b\d+%", re.I),
+    re.compile(r"\b(inesperado|unexpected|anomal|raro|weird|strange)\b", re.I),
+    re.compile(r"\b(error rate|tasa de error|failure|fallo)\b.*\b(subi|increas|grew)\b", re.I),
+]
+
+_PATTERN_INDICATORS = [
+    re.compile(r"\b(otra vez|again|de nuevo|siempre pasa|keeps happening|recurring)\b", re.I),
+    re.compile(r"\b(cada vez que|every time|whenever)\b", re.I),
+    re.compile(r"\b(mismo (problema|error|issue)|same (problem|error|issue))\b", re.I),
+]
+
+_GAP_INDICATORS = [
+    re.compile(r"\b(no sé cómo|don'?t know how|no entiendo|unclear how)\b", re.I),
+    re.compile(r"\b(falta documentación|missing docs|undocumented)\b", re.I),
+]
+
+_OPPORTUNITY_INDICATORS = [
+    re.compile(r"\b(benchmark|media del sector|industry average)\b.*\b(bajo|low|por debajo|below)\b", re.I),
+    re.compile(r"\b(podríamos|could|se podría|we could|opportunity)\b.*\b(automatiz|improve|mejorar|optimiz)\b", re.I),
+]
+
+
+def _classify_signal(text: str) -> str | None:
+    """Classify text into a signal type, or None if nothing interesting."""
+    for pattern in _ANOMALY_PATTERNS:
+        if pattern.search(text):
+            return "anomaly"
+    for pattern in _PATTERN_INDICATORS:
+        if pattern.search(text):
+            return "pattern"
+    for pattern in _GAP_INDICATORS:
+        if pattern.search(text):
+            return "gap"
+    for pattern in _OPPORTUNITY_INDICATORS:
+        if pattern.search(text):
+            return "opportunity"
+    return None
+
+
+def _infer_area(text: str) -> str:
+    """Infer operational area from text keywords."""
+    text_lower = text.lower()
+    area_keywords = {
+        "shopify": ["shopify", "tienda", "pedido", "producto", "sku"],
+        "google-ads": ["google ads", "campaña", "campaign", "cpc", "pmax", "roas", "gads"],
+        "meta-ads": ["meta ads", "facebook", "instagram", "pixel", "capi"],
+        "wazion": ["wazion", "whatsapp", "wa ", "baileys"],
+        "nexo": ["nexo", "brain", "mcp", "cognitive"],
+        "canaririural": ["canarirural", "canari", "reserva", "hospedaje", "alojamiento", "propietario"],
+        "seo": ["seo", "search console", "indexación", "ranking"],
+        "email": ["email", "correo", "inbox", "smtp"],
+    }
+    for area, keywords in area_keywords.items():
+        for kw in keywords:
+            if kw in text_lower:
+                return area
+    return ""
+
+
+def detect_drive_signal(
+    context_hint: str,
+    source: str,
+    source_id: str = "",
+    area: str = "",
+) -> dict | None:
+    """Analyze text for interesting signals. Creates or reinforces.
+
+    Called internally from heartbeat and task_close. Not a public MCP tool.
+    Returns the signal dict if created/reinforced, None otherwise.
+    """
+    if not context_hint or len(context_hint.strip()) < 15:
+        return None
+
+    signal_type = _classify_signal(context_hint)
+    if not signal_type:
+        return None
+
+    inferred_area = area or _infer_area(context_hint)
+
+    # Check for similar existing signal
+    existing = find_similar_drive_signal(context_hint, inferred_area)
+    if existing:
+        result = reinforce_drive_signal(existing["id"], context_hint[:500])
+        return result if result.get("ok") else None
+
+    # Create new
+    result = create_drive_signal(
+        signal_type=signal_type,
+        source=source,
+        source_id=source_id,
+        area=inferred_area,
+        summary=context_hint[:300],
+    )
+    return result if result.get("ok") else None
+
+
+# ── Public MCP tool handlers ─────────────────────────────────────────
+
+def handle_drive_signals(
+    status: str = "",
+    area: str = "",
+    limit: int = 20,
+) -> str:
+    """List drive signals, optionally filtered by status and area."""
+    signals = get_drive_signals(
+        status=status or None,
+        area=area or None,
+        limit=limit,
+    )
+    if not signals:
+        return "No drive signals found."
+
+    stats = drive_signal_stats()
+    lines = [
+        f"DRIVE SIGNALS ({len(signals)} shown, {stats['total']} total):",
+        f"  By status: {json.dumps(stats.get('by_status', {}), ensure_ascii=False)}",
+        "",
+    ]
+    for s in signals:
+        evidence_count = 0
+        try:
+            evidence_count = len(json.loads(s.get("evidence") or "[]"))
+        except (json.JSONDecodeError, TypeError):
+            pass
+        tension_bar = "█" * int(float(s.get("tension", 0)) * 10)
+        lines.append(
+            f"  [{s['id']}] {s['status'].upper()} {tension_bar} "
+            f"t={s['tension']:.2f} ({s['signal_type']}) "
+            f"{'[' + s['area'] + '] ' if s.get('area') else ''}"
+            f"{s['summary'][:80]}"
+            f" ({evidence_count} obs, decay={s.get('decay_rate', 0.05):.2f})"
+        )
+    return "\n".join(lines)
+
+
+def handle_drive_reinforce(signal_id: int, observation: str) -> str:
+    """Manually reinforce a drive signal with a new observation."""
+    if not observation.strip():
+        return "ERROR: observation cannot be empty"
+    result = reinforce_drive_signal(signal_id, observation)
+    if not result.get("ok"):
+        return f"ERROR: {result.get('error', 'unknown')}"
+    return (
+        f"Signal #{signal_id} reinforced: "
+        f"tension {result['old_tension']:.2f} → {result['new_tension']:.2f}, "
+        f"status {result['old_status']} → {result['new_status']}, "
+        f"{result['evidence_count']} observations total"
+    )
+
+
+def handle_drive_act(signal_id: int, outcome: str) -> str:
+    """Mark a drive signal as investigated with an outcome."""
+    if not outcome.strip():
+        return "ERROR: outcome cannot be empty"
+    result = update_drive_signal_status(signal_id, "acted", outcome)
+    if not result.get("ok"):
+        return f"ERROR: {result.get('error', 'unknown')}"
+    return f"Signal #{signal_id} marked as ACTED. Outcome recorded."
+
+
+def handle_drive_dismiss(signal_id: int, reason: str) -> str:
+    """Dismiss a drive signal with a reason (archived, not deleted)."""
+    if not reason.strip():
+        return "ERROR: reason cannot be empty"
+    result = update_drive_signal_status(signal_id, "dismissed", reason)
+    if not result.get("ok"):
+        return f"ERROR: {result.get('error', 'unknown')}"
+    return f"Signal #{signal_id} dismissed. Reason: {reason}"

package/src/tools_sessions.py

@@ -518,6 +518,23 @@ def handle_heartbeat(sid: str, task: str, context_hint: str = '') -> str:
     except Exception:
         pass
 
+    # ── Drive/Curiosity: detect signals from context_hint (best-effort) ──
+    try:
+        if context_hint and len(context_hint.strip()) >= 15:
+            from tools_drive import detect_drive_signal as _detect_drive
+            _drive_result = _detect_drive(context_hint, source="heartbeat", source_id=sid)
+            if _drive_result:
+                # Check for READY signals relevant to current area
+                from db import get_drive_signals as _get_drive
+                _ready = _get_drive(status="ready", limit=3)
+                if _ready:
+                    parts.append("")
+                    parts.append(f"DRIVE: {len(_ready)} mature signal(s) ready for investigation")
+                    for _ds in _ready[:2]:
+                        parts.append(f"  [{_ds['id']}] {_ds['signal_type']}: {_ds['summary'][:80]}")
+    except Exception:
+        pass  # Drive detection is best-effort, never block heartbeat
+
     # ── Layer 3: DIARY_OVERDUE signal based on heartbeat count + time ──
     conn = get_db()
     row = conn.execute("SELECT started_epoch FROM sessions WHERE sid = ?", (sid,)).fetchone()