nexo-brain 2.6.15 → 2.6.16

package/src/cognitive/_ingest.py

@@ -7,6 +7,7 @@ from cognitive._core import (
     _get_db, embed, cosine_similarity, _blob_to_array, _array_to_blob,
     redact_secrets, extract_temporal_date, EMBEDDING_DIM,
     PE_GATE_REJECT, PE_GATE_REFINE, _gate_stats,
+    initial_memory_profile, rehearsal_profile_update,
 )
 
 
@@ -76,6 +77,7 @@ def ingest(
     vec = embed(clean_content)
     blob = _array_to_blob(vec)
     temporal = extract_temporal_date(content)
+    stability, difficulty = initial_memory_profile(source_type, store="stm")
 
     # Auto-pin: corrections and blocking learnings get pinned (zero decay, +0.2 boost)
     # This ensures user's corrections NEVER fade away
@@ -94,9 +96,9 @@ def ingest(
         db.commit()
         # Now actually store in STM
         cur2 = db.execute(
-            """INSERT INTO stm_memories (content, embedding, source_type, source_id, source_title, domain, redaction_applied, temporal_date, lifecycle_state)
-               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
-            (clean_content, blob, source_type, source_id, source_title, domain, was_redacted, temporal, _pin_lifecycle)
+            """INSERT INTO stm_memories (content, embedding, source_type, source_id, source_title, domain, redaction_applied, temporal_date, lifecycle_state, stability, difficulty)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+            (clean_content, blob, source_type, source_id, source_title, domain, was_redacted, temporal, _pin_lifecycle, stability, difficulty)
         )
         db.commit()
         _hnsw_notify_insert("stm", cur2.lastrowid, vec)
@@ -105,9 +107,9 @@ def ingest(
     # skip_quarantine = direct STM (backward compatibility)
     if skip_quarantine:
         cur = db.execute(
-            """INSERT INTO stm_memories (content, embedding, source_type, source_id, source_title, domain, redaction_applied, temporal_date, lifecycle_state)
-               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
-            (clean_content, blob, source_type, source_id, source_title, domain, was_redacted, temporal, _pin_lifecycle)
+            """INSERT INTO stm_memories (content, embedding, source_type, source_id, source_title, domain, redaction_applied, temporal_date, lifecycle_state, stability, difficulty)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+            (clean_content, blob, source_type, source_id, source_title, domain, was_redacted, temporal, _pin_lifecycle, stability, difficulty)
         )
         db.commit()
         _hnsw_notify_insert("stm", cur.lastrowid, vec)
@@ -246,10 +248,11 @@ def ingest_to_ltm(
     was_redacted = 1 if clean_content != content else 0
     vec = embed(clean_content)
     blob = _array_to_blob(vec)
+    stability, difficulty = initial_memory_profile(source_type, store="ltm")
     cur = db.execute(
-        """INSERT INTO ltm_memories (content, embedding, source_type, source_id, source_title, domain, tags, redaction_applied)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
-        (clean_content, blob, source_type, source_id, source_title, domain, tags, was_redacted)
+        """INSERT INTO ltm_memories (content, embedding, source_type, source_id, source_title, domain, tags, redaction_applied, stability, difficulty)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+        (clean_content, blob, source_type, source_id, source_title, domain, tags, was_redacted, stability, difficulty)
     )
     db.commit()
     return cur.lastrowid
@@ -267,10 +270,11 @@ def ingest_sensory(
     vec = embed(clean_content)
     blob = _array_to_blob(vec)
     ts = created_at or datetime.utcnow().isoformat()
+    stability, difficulty = initial_memory_profile("sensory", store="stm")
     cur = db.execute(
-        """INSERT INTO stm_memories (content, embedding, source_type, source_id, domain, created_at, redaction_applied)
-           VALUES (?, ?, 'sensory', ?, ?, ?, ?)""",
-        (clean_content, blob, source_id, domain, ts, was_redacted)
+        """INSERT INTO stm_memories (content, embedding, source_type, source_id, domain, created_at, redaction_applied, stability, difficulty)
+           VALUES (?, ?, 'sensory', ?, ?, ?, ?, ?, ?)""",
+        (clean_content, blob, source_id, domain, ts, was_redacted, stability, difficulty)
     )
     db.commit()
     return cur.lastrowid
@@ -386,6 +390,12 @@ def _refine_memory(match_info: dict, new_content: str) -> int:
     db = _get_db()
     table = "stm_memories" if match_info["store"] == "stm" else "ltm_memories"
     memory_id = match_info["id"]
+    profile_row = db.execute(
+        f"SELECT stability, difficulty FROM {table} WHERE id = ?",
+        (memory_id,),
+    ).fetchone()
+    current_stability = profile_row["stability"] if profile_row else 1.0
+    current_difficulty = profile_row["difficulty"] if profile_row else 0.5
 
     # Check word-level diff to avoid appending near-identical text
     existing_words = set(match_info["content"].lower().split())
@@ -395,10 +405,16 @@ def _refine_memory(match_info: dict, new_content: str) -> int:
     if len(unique_new) < 3:
         # Almost no new words -- just strengthen the existing memory
         now = datetime.utcnow().isoformat()
+        new_stability, new_difficulty = rehearsal_profile_update(
+            current_stability,
+            current_difficulty,
+            score=0.7,
+            refinement=True,
+        )
         db.execute(
             f"UPDATE {table} SET strength = MIN(1.0, strength + 0.1), "
-            f"access_count = access_count + 1, last_accessed = ? WHERE id = ?",
-            (now, memory_id)
+            f"access_count = access_count + 1, last_accessed = ?, stability = ?, difficulty = ? WHERE id = ?",
+            (now, new_stability, new_difficulty, memory_id)
         )
         db.commit()
         return memory_id
@@ -408,11 +424,17 @@ def _refine_memory(match_info: dict, new_content: str) -> int:
     new_vec = embed(merged_content)
     new_blob = _array_to_blob(new_vec)
     now = datetime.utcnow().isoformat()
+    new_stability, new_difficulty = rehearsal_profile_update(
+        current_stability,
+        current_difficulty,
+        score=0.82,
+        refinement=True,
+    )
 
     db.execute(
         f"UPDATE {table} SET content = ?, embedding = ?, strength = MIN(1.0, strength + 0.15), "
-        f"access_count = access_count + 1, last_accessed = ? WHERE id = ?",
-        (merged_content, new_blob, now, memory_id)
+        f"access_count = access_count + 1, last_accessed = ?, stability = ?, difficulty = ? WHERE id = ?",
+        (merged_content, new_blob, now, new_stability, new_difficulty, memory_id)
     )
     db.commit()
     return memory_id
@@ -614,10 +636,10 @@ def process_quarantine() -> dict:
         if should_promote:
             # Promote to STM
             cur = db.execute(
-                """INSERT INTO stm_memories (content, embedding, source_type, source_id, source_title, domain, redaction_applied)
-                   VALUES (?, ?, ?, ?, ?, ?, 0)""",
+                """INSERT INTO stm_memories (content, embedding, source_type, source_id, source_title, domain, redaction_applied, stability, difficulty)
+                   VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)""",
                 (content, row["embedding"], row["source_type"], row["source_id"],
-                 row["source_title"], row["domain"])
+                 row["source_title"], row["domain"], *initial_memory_profile(row["source_type"], store="stm"))
             )
             db.execute(
                 "UPDATE quarantine SET status = 'promoted', promoted_at = datetime('now'), confidence = 1.0 WHERE id = ?",
@@ -689,10 +711,10 @@ def quarantine_promote(quarantine_id: int) -> str:
 
     # Insert into STM
     db.execute(
-        """INSERT INTO stm_memories (content, embedding, source_type, source_id, source_title, domain, redaction_applied)
-           VALUES (?, ?, ?, ?, ?, ?, 0)""",
+        """INSERT INTO stm_memories (content, embedding, source_type, source_id, source_title, domain, redaction_applied, stability, difficulty)
+           VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)""",
         (row["content"], row["embedding"], row["source_type"], row["source_id"],
-         row["source_title"], row["domain"])
+         row["source_title"], row["domain"], *initial_memory_profile(row["source_type"], store="stm"))
     )
     db.execute(
         "UPDATE quarantine SET status = 'promoted', promoted_at = datetime('now'), confidence = 1.0 WHERE id = ?",

package/src/cognitive/_memory.py

@@ -406,6 +406,10 @@ def get_stats() -> dict:
 
     avg_stm = db.execute("SELECT AVG(strength) FROM stm_memories WHERE lifecycle_state IN ('active', 'pinned') AND promoted_to_ltm = 0").fetchone()[0] or 0.0
     avg_ltm = db.execute("SELECT AVG(strength) FROM ltm_memories WHERE is_dormant = 0").fetchone()[0] or 0.0
+    avg_stm_stability = db.execute("SELECT AVG(stability) FROM stm_memories WHERE lifecycle_state IN ('active', 'pinned') AND promoted_to_ltm = 0").fetchone()[0] or 0.0
+    avg_ltm_stability = db.execute("SELECT AVG(stability) FROM ltm_memories WHERE is_dormant = 0").fetchone()[0] or 0.0
+    avg_stm_difficulty = db.execute("SELECT AVG(difficulty) FROM stm_memories WHERE lifecycle_state IN ('active', 'pinned') AND promoted_to_ltm = 0").fetchone()[0] or 0.0
+    avg_ltm_difficulty = db.execute("SELECT AVG(difficulty) FROM ltm_memories WHERE is_dormant = 0").fetchone()[0] or 0.0
 
     total_retrievals = db.execute("SELECT COUNT(*) FROM retrieval_log").fetchone()[0]
     avg_retrieval_score = db.execute("SELECT AVG(top_score) FROM retrieval_log").fetchone()[0] or 0.0
@@ -428,6 +432,10 @@ def get_stats() -> dict:
         "ltm_dormant": ltm_dormant,
         "avg_stm_strength": round(avg_stm, 3),
         "avg_ltm_strength": round(avg_ltm, 3),
+        "avg_stm_stability": round(avg_stm_stability, 3),
+        "avg_ltm_stability": round(avg_ltm_stability, 3),
+        "avg_stm_difficulty": round(avg_stm_difficulty, 3),
+        "avg_ltm_difficulty": round(avg_ltm_difficulty, 3),
         "total_retrievals": total_retrievals,
         "avg_retrieval_score": round(avg_retrieval_score, 3),
         "top_domains_stm": [(r["domain"], r["cnt"]) for r in top_domains_stm],

package/src/cognitive/_search.py

@@ -1,9 +1,14 @@
 """NEXO Cognitive — Search, retrieval, ranking."""
 import math
+import re
 import sqlite3
 import numpy as np
 from datetime import datetime
-from cognitive._core import _get_db, embed, cosine_similarity, _blob_to_array, _array_to_blob, _get_model, _get_reranker, rerank_results, EMBEDDING_DIM
+from cognitive._core import (
+    _get_db, embed, cosine_similarity, _blob_to_array, _array_to_blob,
+    _get_model, _get_reranker, rerank_results, EMBEDDING_DIM,
+    rehearsal_profile_update,
+)
 
 def bm25_search(query_text: str, stores: str = "both", top_k: int = 20,
                 source_type_filter: str = "") -> list[dict]:
@@ -151,6 +156,10 @@ _HISTORICAL_CUES = frozenset({
     "cuando", "hace", "meses", "año", "anterior", "antes",
 })
 
+_EXACT_LOOKUP_RE = re.compile(
+    r"(/|\\|::|\.[A-Za-z0-9]+|#L\d+|line \d+|error[: ]|exception|traceback|0x[0-9a-fA-F]+|[A-Z]{2,}-\d+)"
+)
+
 
 def _apply_temporal_boost(results: list[dict], query_text: str) -> list[dict]:
     """Apply bounded temporal boost to retrieval results.
@@ -209,6 +218,42 @@ def _apply_temporal_boost(results: list[dict], query_text: str) -> list[dict]:
     return results
 
 
+def _looks_like_exact_lookup(query_text: str) -> bool:
+    query = str(query_text or "").strip()
+    if not query:
+        return False
+    lowered = query.lower()
+    if _EXACT_LOOKUP_RE.search(query):
+        return True
+    if any(token in lowered for token in ("file ", "path ", "port ", "localhost", "grep ", "rg ", "exact", "literal")):
+        return True
+    if any(ch in query for ch in ('"', "'", "`", "=", "[", "]")):
+        return True
+    return False
+
+
+def _auto_use_hyde(query_text: str, source_type_filter: str = "") -> bool:
+    query = str(query_text or "").strip()
+    if not query or source_type_filter:
+        return False
+    if len(query) < 18 or _looks_like_exact_lookup(query):
+        return False
+    intent = _classify_query_intent(query)
+    return intent in {"howto", "definition", "reasoning"} or (intent == "lookup" and len(query.split()) >= 4)
+
+
+def _auto_spreading_depth(query_text: str, source_type_filter: str = "") -> int:
+    query = str(query_text or "").strip().lower()
+    if not query or source_type_filter or _looks_like_exact_lookup(query):
+        return 0
+    intent = _classify_query_intent(query)
+    if intent in {"howto", "definition", "reasoning"}:
+        return 1
+    if any(connector in query for connector in (" and ", " because ", " related ", " connect ", " why ", " how ")):
+        return 1
+    return 0
+
+
 # ============================================================================
 # FEATURE 0.5: Knowledge Graph Boost
 # Memories connected to more KG nodes (files, areas, other learnings) are
@@ -614,9 +659,18 @@ def _rehearse_results(results: list[dict], skip_ids: set = None):
         if (r["store"], r["id"]) in skip:
             continue
         table = "stm_memories" if r["store"] == "stm" else "ltm_memories"
+        current = db.execute(
+            f"SELECT stability, difficulty FROM {table} WHERE id = ?",
+            (r["id"],),
+        ).fetchone()
+        new_stability, new_difficulty = rehearsal_profile_update(
+            current["stability"] if current else 1.0,
+            current["difficulty"] if current else 0.5,
+            score=r.get("score", 0.6),
+        )
         db.execute(
-            f"UPDATE {table} SET strength = MIN(1.0, strength + 0.08), access_count = access_count + 1, last_accessed = ? WHERE id = ?",
-            (now, r["id"])
+            f"UPDATE {table} SET strength = MIN(1.0, strength + 0.08), access_count = access_count + 1, last_accessed = ?, stability = ?, difficulty = ? WHERE id = ?",
+            (now, new_stability, new_difficulty, r["id"])
         )
     db.commit()
 
@@ -630,18 +684,18 @@ def search(
     rehearse: bool = True,
     source_type_filter: str = "",
     include_archived: bool = False,
-    use_hyde: bool = False,
+    use_hyde: bool | None = None,
     hybrid: bool = True,
     hybrid_alpha: float = 0.6,
-    spreading_depth: int = 0,
+    spreading_depth: int | None = None,
     decompose: bool = True,
     exclude_dreams: bool = True,
 ) -> list[dict]:
     """Full vector search across STM and/or LTM with rehearsal and dormant reactivation.
 
     Args:
-        use_hyde: If True, use HyDE query expansion for richer embedding (default False)
-        spreading_depth: If >0, fetch co-activated neighbors and boost their scores (default 0)
+        use_hyde: If True, force HyDE on; if False, force it off; if None, auto-enable for conceptual queries.
+        spreading_depth: If >0, fetch co-activated neighbors and boost their scores. If None, use a shallow auto-default for multi-hop queries.
         exclude_dreams: If True (default), exclude dream_insight memories from results.
                         Dream insights are 21% of LTM and dilute search precision.
                         Set to False only when explicitly looking for cross-domain patterns.
@@ -677,6 +731,8 @@ def search(
                     return merged
 
     db = _get_db()
+    resolved_use_hyde = _auto_use_hyde(query_text, source_type_filter) if use_hyde is None else bool(use_hyde)
+    resolved_spreading_depth = _auto_spreading_depth(query_text, source_type_filter) if spreading_depth is None else max(0, int(spreading_depth))
 
     # Detect temporal queries — boost results with temporal_date
     _temporal_keywords = {"when", "date", "time", "first", "last", "before", "after",
@@ -684,7 +740,7 @@ def search(
     query_lower = query_text.lower().split()
     is_temporal_query = bool(_temporal_keywords & set(query_lower))
 
-    if use_hyde:
+    if resolved_use_hyde:
         query_vec = hyde_expand_query(query_text)
     else:
         query_vec = embed(query_text)
@@ -855,9 +911,9 @@ def search(
 
     # Spreading activation: boost co-activated neighbors (Feature 2)
     co_activation_applied = False
-    if spreading_depth > 0 and results:
+    if resolved_spreading_depth > 0 and results:
         memory_ids = [(r["store"], r["id"]) for r in results]
-        neighbor_boosts = _get_co_activated_neighbors(memory_ids, depth=spreading_depth)
+        neighbor_boosts = _get_co_activated_neighbors(memory_ids, depth=resolved_spreading_depth)
 
         if neighbor_boosts:
             co_activation_applied = True
@@ -911,7 +967,7 @@ def search(
         reactivated = r.get("reactivated", False)
 
         ranking_desc = "semantic_similarity"
-        if use_hyde:
+        if resolved_use_hyde:
             ranking_desc = "hyde_centroid_similarity"
         parts = [f"Ranked #{rank}: {ranking_desc}={score:.3f}"]
         parts.append(f"store={store}, strength={strength:.2f}, accesses={access_count}")
@@ -919,6 +975,10 @@ def search(
             parts.append(f"kg_boost=+{r['kg_boost']:.3f} ({r.get('kg_connections', 0)} edges)")
         if r.get("co_activation_boost"):
             parts.append(f"co_activation_boost=+{r['co_activation_boost']:.3f}")
+        if use_hyde is None and resolved_use_hyde:
+            parts.append("hyde=auto")
+        if spreading_depth is None and resolved_spreading_depth > 0:
+            parts.append(f"spreading=auto:{resolved_spreading_depth}")
         if created:
             parts.append(f"created={created[:10]}")
         if tags:

package/src/dashboard/app.py

@@ -28,6 +28,8 @@ _PARENT = str(Path(__file__).resolve().parent.parent)
 if _PARENT not in sys.path:
     sys.path.insert(0, _PARENT)
 
+from agent_runner import AgentRunnerError, build_followup_terminal_shell_command
+
 app = FastAPI(title="NEXO Brain Dashboard", version="3.0.0")
 
 TEMPLATES_DIR = Path(__file__).resolve().parent / "templates"
@@ -137,7 +139,7 @@ class ChatMessage(BaseModel):
 
 def _cognitive_db():
     """Direct connection to cognitive.db."""
-    nexo_home = os.environ.get("NEXO_HOME", str(Path.home() / "claude"))
+    nexo_home = os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))
     db_path = Path(nexo_home) / "data" / "cognitive.db"
     conn = sqlite3.connect(str(db_path))
     conn.row_factory = sqlite3.Row
@@ -145,7 +147,8 @@ def _cognitive_db():
 
 def _email_db():
     """Direct connection to nexo-email.db."""
-    db_path = Path.home() / "claude" / "nexo-email" / "nexo-email.db"
+    nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+    db_path = nexo_home / "nexo-email" / "nexo-email.db"
     if not db_path.exists():
         return None
     conn = sqlite3.connect(str(db_path))
@@ -420,7 +423,7 @@ async def api_sessions(limit: int = Query(10, ge=1, le=50)):
     conn = db.get_db()
     # Active sessions (from sessions table, not diaries)
     active_rows = conn.execute(
-        "SELECT sid as session_id, task, last_update_epoch, claude_session_id "
+        "SELECT sid as session_id, task, last_update_epoch, claude_session_id, external_session_id, session_client "
         "FROM sessions WHERE last_update_epoch > (strftime('%s','now') - 900) "
         "ORDER BY last_update_epoch DESC"
     ).fetchall()
@@ -716,7 +719,7 @@ async def api_ops_move(body: MoveRequest):
 
 @app.post("/api/ops/execute/{fid}")
 async def api_ops_execute(fid: str):
-    """Execute a followup by opening Terminal with claude command."""
+    """Execute a followup by opening Terminal with the configured NEXO client."""
     db = _db()
     conn = db.get_db()
     row = conn.execute("SELECT * FROM followups WHERE id = ?", (fid,)).fetchone()
@@ -734,9 +737,13 @@ async def api_ops_execute(fid: str):
     tmp = tempfile.NamedTemporaryFile(mode="w", suffix=".txt", prefix="nexo-followup-", delete=False)
     tmp.write(fid)
     tmp.close()
-    # The claude command reads the followup ID from the temp file — no shell interpolation of description
-    claude_cmd = f'claude \\"NEXO: execute followup from file $(cat {tmp.name})\\"'
-    script = f'tell application "Terminal" to do script "{claude_cmd}"'
+    # The selected terminal client reads the followup ID from the temp file — no shell interpolation of description
+    try:
+        _, shell_cmd = build_followup_terminal_shell_command(tmp.name)
+    except AgentRunnerError as exc:
+        return JSONResponse({"error": str(exc)}, status_code=503)
+    escaped = shell_cmd.replace("\\", "\\\\").replace('"', '\\"')
+    script = f'tell application "Terminal" to do script "{escaped}"'
     subprocess.Popen(["osascript", "-e", script])
     return {"success": True, "followup_id": fid}
 
@@ -1388,7 +1395,7 @@ async def api_credentials():
 
 @app.get("/api/backups")
 async def api_backups():
-    nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / "claude")))
+    nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
     backup_dir = nexo_home / "backups"
     data_dir = nexo_home / "data"
     backups = []

package/src/db/_schema.py

@@ -256,6 +256,15 @@ def _m13_claude_session_id(conn):
     conn.commit()
 
 
+def _m21_external_session_fields(conn):
+    """Generalize session linkage beyond Claude-specific naming."""
+    _migrate_add_column(conn, "sessions", "external_session_id", "TEXT DEFAULT ''")
+    _migrate_add_column(conn, "sessions", "session_client", "TEXT DEFAULT ''")
+    _migrate_add_index(conn, "idx_sessions_external_sid", "sessions", "external_session_id")
+    _migrate_add_index(conn, "idx_sessions_client", "sessions", "session_client")
+    conn.commit()
+
+
 def _m14_learnings_priority_weight(conn):
     """Add priority, weight, and guard usage tracking to learnings + followup priority."""
     _migrate_add_column(conn, "learnings", "priority", "TEXT DEFAULT 'medium'")
@@ -445,6 +454,7 @@ MIGRATIONS = [
     (18, "skills_steps_column", _m18_skills_steps),
     (19, "skills_v2", _m19_skills_v2),
     (20, "personal_scripts_registry", _m20_personal_scripts_registry),
+    (21, "external_session_fields", _m21_external_session_fields),
 ]
 
 

package/src/db/_sessions.py

@@ -34,18 +34,26 @@ def _validate_sid(sid: str) -> str:
     raise ValueError(f"Invalid SID format: {sid[:80]}")
 
 
-def register_session(sid: str, task: str, claude_session_id: str = "") -> dict:
+def register_session(
+    sid: str,
+    task: str,
+    claude_session_id: str = "",
+    *,
+    external_session_id: str = "",
+    session_client: str = "",
+) -> dict:
     """Register or re-register a session."""
     sid = _validate_sid(sid)
     conn = get_db()
     now = now_epoch()
+    linked_session_id = (external_session_id or claude_session_id or "").strip()
     conn.execute(
-        "INSERT OR REPLACE INTO sessions (sid, task, started_epoch, last_update_epoch, local_time, claude_session_id) "
-        "VALUES (?, ?, ?, ?, ?, ?)",
-        (sid, task, now, now, local_time_str(), claude_session_id)
+        "INSERT OR REPLACE INTO sessions (sid, task, started_epoch, last_update_epoch, local_time, claude_session_id, external_session_id, session_client) "
+        "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+        (sid, task, now, now, local_time_str(), linked_session_id, linked_session_id, (session_client or "").strip())
     )
     conn.commit()
-    return {"sid": sid, "task": task}
+    return {"sid": sid, "task": task, "external_session_id": linked_session_id, "session_client": (session_client or "").strip()}
 
 
 def update_session(sid: str, task: str | None) -> dict:
@@ -320,4 +328,3 @@ def _expire_old_questions(conn: sqlite3.Connection):
         (cutoff,)
     )
 
-

package/src/doctor/providers/runtime.py

@@ -9,6 +9,7 @@ import plistlib
 import subprocess
 import sys
 import time
+import tomllib
 from pathlib import Path
 
 from client_preferences import (
@@ -39,6 +40,32 @@ OPTIONALS_FILE = NEXO_HOME / "config" / "optionals.json"
 SCHEDULE_FILE = NEXO_HOME / "config" / "schedule.json"
 
 
+def _codex_bootstrap_config_status() -> dict:
+    path = Path.home() / ".codex" / "config.toml"
+    if not path.is_file():
+        return {"exists": False, "path": str(path), "bootstrap_managed": False}
+    try:
+        payload = tomllib.loads(path.read_text())
+    except Exception as exc:
+        return {
+            "exists": True,
+            "path": str(path),
+            "bootstrap_managed": False,
+            "error": str(exc),
+        }
+    managed = bool(payload.get("nexo", {}).get("codex", {}).get("bootstrap_managed"))
+    initial_messages = payload.get("initial_messages", [])
+    has_initial_messages = bool(initial_messages)
+    return {
+        "exists": True,
+        "path": str(path),
+        "bootstrap_managed": managed,
+        "has_initial_messages": has_initial_messages,
+        "model": str(payload.get("model", "") or ""),
+        "reasoning_effort": str(payload.get("model_reasoning_effort", "") or ""),
+    }
+
+
 def _file_age_seconds(path: Path) -> float | None:
     """Return file age in seconds, or None if not found."""
     try:
@@ -1054,13 +1081,41 @@ def check_client_bootstrap_parity(fix: bool = False) -> DoctorCheck:
                 f"`{client_key}` bootstrap version {info.get('version') or 'unknown'} != template {info.get('template_version')}"
             )
             repair_plan.append("Refresh bootstrap files from the current NEXO templates")
+        if client_key == "codex":
+            codex_config = _codex_bootstrap_config_status()
+            if codex_config.get("error"):
+                status = "degraded"
+                severity = "warn"
+                evidence.append(f"codex config TOML invalid at {codex_config.get('path')}: {codex_config.get('error')}")
+                repair_plan.append("Repair ~/.codex/config.toml so NEXO can manage Codex bootstrap and model defaults")
+            elif codex_config.get("exists") and not codex_config.get("bootstrap_managed"):
+                status = "degraded"
+                severity = "warn"
+                evidence.append(f"codex config missing managed bootstrap injection at {codex_config.get('path')}")
+                repair_plan.append("Run `nexo clients sync` or `nexo update` so plain Codex sessions inherit the NEXO bootstrap")
+            elif codex_config.get("exists"):
+                evidence.append(
+                    "codex config bootstrap managed"
+                    + (
+                        f" ({codex_config.get('model') or 'default'}, {codex_config.get('reasoning_effort') or 'default'})"
+                    )
+                )
 
     if fix and status != "healthy":
-        sync_enabled_bootstraps(
-            nexo_home=NEXO_HOME,
-            user_home=Path.home(),
-            preferences=prefs,
-        )
+        try:
+            from client_sync import sync_all_clients
+            sync_all_clients(
+                nexo_home=NEXO_HOME,
+                runtime_root=NEXO_CODE,
+                user_home=Path.home(),
+                preferences=prefs,
+            )
+        except Exception:
+            sync_enabled_bootstraps(
+                nexo_home=NEXO_HOME,
+                user_home=Path.home(),
+                preferences=prefs,
+            )
         post = check_client_bootstrap_parity(fix=False)
         if post.status == "healthy":
             post.fixed = True

package/src/hooks/capture-tool-logs.sh

@@ -113,8 +113,8 @@ conn.row_factory = sqlite3.Row
 row = None
 if session_id and session_id != 'global':
     row = conn.execute(
-        'SELECT sid, task FROM sessions WHERE claude_session_id = ? LIMIT 1',
-        (session_id,)
+        'SELECT sid, task FROM sessions WHERE external_session_id = ? OR claude_session_id = ? LIMIT 1',
+        (session_id, session_id)
     ).fetchone()
 
 # Fallback: most recent active session

package/src/hooks/inbox-hook.sh

@@ -32,7 +32,7 @@ DB="$NEXO_HOME/data/nexo.db"
 mkdir -p "$NEXO_HOME/data"
 [ -f "$DB" ] || exit 0
 
-NEXO_SID=$(sqlite3 "$DB" "SELECT sid FROM sessions WHERE claude_session_id = '${CLAUDE_SID}' AND last_update_epoch > (strftime('%s','now') - 900) ORDER BY last_update_epoch DESC LIMIT 1;" 2>/dev/null)
+NEXO_SID=$(sqlite3 "$DB" "SELECT sid FROM sessions WHERE (external_session_id = '${CLAUDE_SID}' OR claude_session_id = '${CLAUDE_SID}') AND last_update_epoch > (strftime('%s','now') - 900) ORDER BY last_update_epoch DESC LIMIT 1;" 2>/dev/null)
 [ -z "$NEXO_SID" ] && exit 0
 
 # 5. Check inbox — messages addressed to this session or broadcast

package/src/plugins/cognitive_memory.py

@@ -19,8 +19,8 @@ def handle_cognitive_retrieve(
     source_type: str = "",
     domain: str = "",
     include_archived: bool = False,
-    use_hyde: bool = False,
-    spreading_depth: int = 0,
+    use_hyde: bool | None = None,
+    spreading_depth: int | None = None,
 ) -> str:
     """RAG query over cognitive memory (STM + LTM). Triggers rehearsal on retrieved memories.
 
@@ -32,8 +32,8 @@ def handle_cognitive_retrieve(
         source_type: Filter by source type e.g. "change", "learning", "diary" (default: all)
         domain: Filter by domain e.g. "project-a", "shopify" (default: all)
         include_archived: If True, also search archived memories (default False)
-        use_hyde: If True, use HyDE query expansion — embeds 3-5 query variants and searches with centroid. Better recall for conceptual queries. (default False)
-        spreading_depth: If >0, boost co-activated neighbors (memories frequently retrieved together). 1=direct neighbors only. (default 0)
+        use_hyde: If True/False, force HyDE on/off. If omitted, NEXO auto-enables it for conceptual queries.
+        spreading_depth: If >0, boost co-activated neighbors directly. If omitted, NEXO may auto-enable shallow spreading for multi-hop queries.
     """
     if not query or not query.strip():
         return "ERROR: query is required."
@@ -57,10 +57,14 @@ def handle_cognitive_retrieve(
 
     formatted = cognitive.format_results(results)
     mode_parts = [f"stores={stores}", f"min_score={min_score}"]
-    if use_hyde:
+    if use_hyde is True:
         mode_parts.append("hyde=ON")
-    if spreading_depth > 0:
+    elif use_hyde is None:
+        mode_parts.append("hyde=AUTO")
+    if spreading_depth and spreading_depth > 0:
         mode_parts.append(f"spreading={spreading_depth}")
+    elif spreading_depth is None:
+        mode_parts.append("spreading=AUTO")
     header = f"COGNITIVE RETRIEVE — query: '{query}' | {len(results)} results ({', '.join(mode_parts)})\n\n"
     return header + formatted
 
@@ -76,6 +80,10 @@ def handle_cognitive_stats() -> str:
         f"  LTM dormant:         {stats['ltm_dormant']}",
         f"  Avg STM strength:    {stats['avg_stm_strength']:.3f}",
         f"  Avg LTM strength:    {stats['avg_ltm_strength']:.3f}",
+        f"  Avg STM stability:   {stats.get('avg_stm_stability', 0.0):.3f}",
+        f"  Avg LTM stability:   {stats.get('avg_ltm_stability', 0.0):.3f}",
+        f"  Avg STM difficulty:  {stats.get('avg_stm_difficulty', 0.0):.3f}",
+        f"  Avg LTM difficulty:  {stats.get('avg_ltm_difficulty', 0.0):.3f}",
         f"  Total retrievals:    {stats['total_retrievals']}",
         f"  Avg retrieval score: {stats['avg_retrieval_score']:.3f}",
     ]