nexo-brain 2.6.14 → 2.6.16

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}",
     ]

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

@@ -16,6 +16,7 @@ import os
 import re
 import sqlite3
 import sys
+from collections import Counter
 from datetime import datetime, timedelta
 from pathlib import Path
 
@@ -344,6 +345,172 @@ def collect_trust_score() -> list[dict]:
     )
 
 
+def _parse_diary_created_at(value) -> datetime | None:
+    if value in (None, ""):
+        return None
+    try:
+        if isinstance(value, (int, float)) or (isinstance(value, str) and str(value).strip().isdigit()):
+            return datetime.fromtimestamp(float(value))
+    except Exception:
+        return None
+    try:
+        return datetime.fromisoformat(str(value).replace("Z", "+00:00").replace("+00:00", ""))
+    except Exception:
+        return None
+
+
+def _sample_evenly(rows: list[dict], limit: int) -> list[dict]:
+    if limit <= 0 or not rows:
+        return []
+    if len(rows) <= limit:
+        return list(rows)
+    if limit == 1:
+        return [rows[-1]]
+    step = (len(rows) - 1) / float(limit - 1)
+    indices = sorted({round(i * step) for i in range(limit)})
+    sampled = [rows[idx] for idx in indices]
+    i = 0
+    while len(sampled) < limit and i < len(rows):
+        if rows[i] not in sampled:
+            sampled.append(rows[i])
+        i += 1
+    return sampled[:limit]
+
+
+def _compact_diary_row(row: dict) -> dict:
+    created = _parse_diary_created_at(row.get("created_at"))
+    return {
+        "session_id": row.get("session_id", ""),
+        "created_at": created.isoformat() if created else str(row.get("created_at", "")),
+        "domain": row.get("domain", "") or "",
+        "mental_state": row.get("mental_state", "") or "",
+        "summary": str(row.get("summary", "") or "")[:240],
+        "self_critique": str(row.get("self_critique", "") or "")[:240],
+        "source": row.get("source", "") or "",
+    }
+
+
+def collect_long_horizon_context(
+    target_date: str,
+    *,
+    horizon_days: int = 60,
+    recent_days: int = 14,
+    max_diaries: int = 20,
+    max_sessions: int = 12,
+) -> dict:
+    """Build long-horizon context blending recent and older evidence.
+
+    Strategy:
+    - recent 70% from the last `recent_days`
+    - older 30% sampled evenly from the rest of the `horizon_days` window
+    """
+    target_day = datetime.strptime(target_date, "%Y-%m-%d")
+    horizon_start = target_day - timedelta(days=horizon_days)
+    recent_start = target_day - timedelta(days=recent_days)
+
+    diary_rows = safe_query(
+        NEXO_DB,
+        "SELECT session_id, created_at, summary, mental_state, domain, self_critique, source "
+        "FROM session_diary ORDER BY created_at ASC"
+    )
+    compact_diaries = []
+    for row in diary_rows:
+        created = _parse_diary_created_at(row.get("created_at"))
+        if not created:
+            continue
+        if not (horizon_start <= created < target_day):
+            continue
+        compact_diaries.append(_compact_diary_row(row))
+
+    recent_diaries = [row for row in compact_diaries if _parse_diary_created_at(row.get("created_at")) and _parse_diary_created_at(row.get("created_at")) >= recent_start]
+    older_diaries = [row for row in compact_diaries if row not in recent_diaries]
+    recent_quota = max(1, round(max_diaries * 0.7))
+    older_quota = max(0, max_diaries - recent_quota)
+    sampled_diaries = recent_diaries[-recent_quota:] + _sample_evenly(older_diaries, older_quota)
+    sampled_diaries.sort(key=lambda row: row.get("created_at", ""))
+
+    recurring_domains = Counter(row["domain"] for row in compact_diaries if row.get("domain"))
+    recurring_states = Counter(row["mental_state"] for row in compact_diaries if row.get("mental_state"))
+    recurring_critiques = Counter(row["self_critique"] for row in compact_diaries if row.get("self_critique"))
+
+    learning_rows = safe_query(
+        NEXO_DB,
+        "SELECT category, title, content, created_at, updated_at, reasoning, prevention, applies_to "
+        "FROM learnings ORDER BY COALESCE(updated_at, created_at) DESC LIMIT 120"
+    )
+    long_horizon_learnings = []
+    for row in learning_rows:
+        long_horizon_learnings.append({
+            "category": row.get("category", ""),
+            "title": str(row.get("title", "") or "")[:140],
+            "content": str(row.get("content", "") or "")[:260],
+            "reasoning": str(row.get("reasoning", "") or "")[:180],
+            "prevention": str(row.get("prevention", "") or "")[:180],
+            "applies_to": str(row.get("applies_to", "") or "")[:180],
+            "updated_at": str(row.get("updated_at", "") or row.get("created_at", "")),
+        })
+    long_horizon_learnings = long_horizon_learnings[:24]
+
+    transcript_candidates: list[dict] = []
+    transcript_files: list[tuple[str, Path]] = [
+        ("claude_code", path) for path in find_claude_session_files()
+    ] + [
+        ("codex", path) for path in find_codex_session_files()
+    ]
+    horizon_end = target_day
+    for client, path in transcript_files:
+        try:
+            modified = datetime.fromtimestamp(path.stat().st_mtime)
+        except OSError:
+            continue
+        if not (horizon_start <= modified < horizon_end):
+            continue
+        transcript_candidates.append({
+            "client": client,
+            "session_file": _session_identifier(client, path.name),
+            "modified": modified.isoformat(),
+            "session_path": str(path),
+        })
+    transcript_candidates.sort(key=lambda row: row["modified"])
+    recent_sessions = [row for row in transcript_candidates if datetime.fromisoformat(row["modified"]) >= recent_start]
+    older_sessions = [row for row in transcript_candidates if row not in recent_sessions]
+    recent_session_quota = max(1, round(max_sessions * 0.7))
+    older_session_quota = max(0, max_sessions - recent_session_quota)
+    sampled_sessions = recent_sessions[-recent_session_quota:] + _sample_evenly(older_sessions, older_session_quota)
+    sampled_sessions.sort(key=lambda row: row["modified"])
+
+    stale_followups = safe_query(
+        NEXO_DB,
+        "SELECT id, description, date, status, created_at, updated_at FROM followups "
+        "WHERE status NOT IN ('COMPLETED', 'CANCELLED') ORDER BY date ASC, created_at ASC LIMIT 50"
+    )
+    older_than_week = []
+    week_ago = target_day - timedelta(days=7)
+    for row in stale_followups:
+        created = _parse_diary_created_at(row.get("created_at"))
+        if created and created < week_ago:
+            older_than_week.append({
+                "id": row.get("id", ""),
+                "description": str(row.get("description", "") or "")[:180],
+                "date": row.get("date", ""),
+                "status": row.get("status", ""),
+                "created_at": created.isoformat(),
+            })
+
+    return {
+        "horizon_days": horizon_days,
+        "recent_window_days": recent_days,
+        "sample_strategy": "70% recent + 30% older evenly sampled",
+        "historical_diaries": sampled_diaries,
+        "historical_sessions": sampled_sessions,
+        "historical_learnings": long_horizon_learnings,
+        "recurring_domains": recurring_domains.most_common(8),
+        "recurring_mental_states": recurring_states.most_common(8),
+        "recurring_self_critiques": recurring_critiques.most_common(6),
+        "stale_followups": older_than_week[:12],
+    }
+
+
 # ── Discovery: scan NEXO_HOME for non-core content ───────────────────────
 
 CORE_DIRS = {"data", "operations", "logs", "coordination", "brain"}
@@ -550,6 +717,14 @@ def main():
     error_logs = collect_error_logs(target_date)
     print(f"  Log files with errors: {len(error_logs)}")
 
+    print("[collect] Building long-horizon context...")
+    long_horizon = collect_long_horizon_context(target_date)
+    print(
+        "  Long horizon: "
+        f"{len(long_horizon.get('historical_diaries', []))} diary samples, "
+        f"{len(long_horizon.get('historical_sessions', []))} session samples"
+    )
+
     # 5. Build per-session files + shared context
     date_dir = DEEP_SLEEP_DIR / target_date
     date_dir.mkdir(parents=True, exist_ok=True)
@@ -568,12 +743,17 @@ def main():
     shared_parts.append(format_section("TRUST SCORE HISTORY (7d)", trust_history))
     shared_parts.append(format_section("DISCOVERED NON-CORE CONTENT", extras))
     shared_parts.append(format_section("ERROR LOGS", error_logs))
+    shared_parts.append(format_section("LONG-HORIZON CONTEXT (60d blend)", long_horizon))
 
     shared_text = "\n".join(shared_parts)
     shared_file = date_dir / "shared-context.txt"
     shared_file.write_text(shared_text, encoding="utf-8")
     print(f"  Shared context: {len(shared_text) / 1024:.0f} KB")
 
+    long_horizon_file = date_dir / "long-horizon-context.json"
+    long_horizon_file.write_text(json.dumps(long_horizon, indent=2, ensure_ascii=False), encoding="utf-8")
+    print(f"  Long horizon JSON: {long_horizon_file.name}")
+
     # Individual session files
     session_files_written = []
     session_txt_map = {}
@@ -654,6 +834,7 @@ def main():
         "error_log_files": len(error_logs),
         "date_dir": str(date_dir),
         "shared_context_file": str(shared_file),
+        "long_horizon_file": str(long_horizon_file),
         "context_file": str(legacy_file),
         "total_size_bytes": total_size,
     }

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

@@ -12,12 +12,17 @@ Read the extractions file provided below. It contains per-session findings inclu
 
 Also read the runtime skill candidate file at `{{SKILL_RUNTIME_FILE}}`. It contains mature guide skills with repeated successful usage and candidates for automatic text→script evolution.
 
+Also read the long-horizon file at `{{LONG_HORIZON_FILE}}`. It blends recent and older evidence from the last 60 days using a 70% recent / 30% older sample strategy. Use it to detect patterns that a single-day view would miss.
+
 Synthesize across all sessions:
 
 ### 1. Cross-Session Patterns
 - Same error appearing in multiple sessions (escalate confidence)
 - Same protocol violation repeated (systemic issue)
 - Related ideas mentioned across sessions (consolidate)
+- Themes that recur across multiple weeks, not just today
+- Cross-domain connections where an older learning or session sample explains a current issue
+- Topics repeatedly mentioned over time but never formalized into a learning or followup
 
 ### 2. Morning Agenda
 Generate a prioritized agenda for the next morning:

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

@@ -91,6 +91,7 @@ def main():
 
     extractions_file = DEEP_SLEEP_DIR / f"{target_date}-extractions.json"
     context_file = DEEP_SLEEP_DIR / f"{target_date}-context.txt"
+    long_horizon_file = DEEP_SLEEP_DIR / target_date / "long-horizon-context.json"
 
     if not extractions_file.exists():
         print(f"[synthesize] No extractions file for {target_date}. Run extract.py first.")
@@ -129,6 +130,7 @@ def main():
     prompt = prompt_template.replace("{{EXTRACTIONS_FILE}}", str(extractions_file))
     prompt = prompt.replace("{{CONTEXT_FILE}}", str(context_file))
     prompt = prompt.replace("{{SKILL_RUNTIME_FILE}}", str(runtime_candidates_file))
+    prompt = prompt.replace("{{LONG_HORIZON_FILE}}", str(long_horizon_file))
 
     print(f"[synthesize] Phase 3: Synthesizing {total_findings} findings from {target_date}")
     print(f"[synthesize] Skill runtime candidates: {runtime_candidate_count}")

package/src/scripts/nexo-inbox-hook.sh

@@ -30,7 +30,7 @@ NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
 DB="$NEXO_HOME/data/nexo.db"
 [ -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/scripts/nexo-reflection.py

@@ -132,7 +132,7 @@ def analyze_entries(entries):
         "files_modified": files_modified,
         "self_critiques": self_critiques,
         "entry_count": len(entries),
-        "claude_entries": sum(1 for e in entries if e.get("source") == "claude"),
+        "source_counts": dict(Counter(e.get("source") or "unknown" for e in entries)),
     }
 
 
@@ -188,7 +188,7 @@ def main():
     # Filter out pure hook entries (tool captures)
     session_entries = [
         e for e in entries
-        if e.get("source") in ("claude", "hook-fallback")
+        if e.get("source") in ("claude", "hook-fallback", "codex", "codex_cli", "codex_cli_rs")
         or "tasks" in e
     ]
 
@@ -210,7 +210,7 @@ def main():
     reflection = {
         "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M"),
         "entries_processed": analysis["entry_count"],
-        "claude_entries": analysis["claude_entries"],
+        "source_counts": analysis["source_counts"],
         "tasks_seen": len(analysis["tasks"]),
         "decisions_made": len(analysis["decisions"]),
         "errors_resolved": len(analysis["errors"]),
@@ -243,8 +243,11 @@ def main():
     except Exception as e:
         print(f"Adaptive decay skipped: {e}")
 
+    source_summary = ", ".join(
+        f"{source}={count}" for source, count in sorted(analysis["source_counts"].items())
+    ) or "none"
     print(f"Reflection complete: {analysis['entry_count']} entries processed, "
-          f"{analysis['claude_entries']} from Claude, "
+          f"sources: {source_summary}, "
           f"{len(analysis['errors'])} errors, "
           f"{len(analysis['self_critiques'])} critiques.")
 

package/src/server.py

@@ -200,7 +200,7 @@ mcp = FastMCP(
 # ── Session management (3 tools) ──────────────────────────────────
 
 @mcp.tool
-def nexo_startup(task: str = "Startup", claude_session_id: str = "") -> str:
+def nexo_startup(task: str = "Startup", claude_session_id: str = "", session_token: str = "", session_client: str = "") -> str:
     """Register new session, clean stale ones, return active sessions + alerts.
 
     Call this ONCE at the start of every conversation.
@@ -208,11 +208,18 @@ def nexo_startup(task: str = "Startup", claude_session_id: str = "") -> str:
 
     Args:
         task: Initial task description.
-        claude_session_id: External client session token. Claude Code passes its UUID via hooks;
-                          other clients may pass a synthetic durable token when useful.
-                          Pass this to enable automatic inter-terminal inbox detection when available.
-    """
-    return handle_startup(task, claude_session_id=claude_session_id)
+        claude_session_id: Legacy alias for the external client session token.
+        session_token: External client session token. Claude Code passes its UUID via hooks;
+                      other clients may pass a synthetic durable token when useful.
+                      Pass this to enable automatic inter-terminal inbox detection when available.
+        session_client: Optional client label such as `claude_code` or `codex`.
+    """
+    return handle_startup(
+        task,
+        claude_session_id=claude_session_id,
+        session_token=session_token,
+        session_client=session_client,
+    )
 
 
 @mcp.tool

package/src/tools_sessions.py

@@ -64,18 +64,35 @@ def _format_age(epoch: float) -> str:
         return f"{int(seconds / 3600)}h{int((seconds % 3600) / 60)}m"
 
 
-def handle_startup(task: str = "Startup", claude_session_id: str = "") -> str:
+def handle_startup(
+    task: str = "Startup",
+    claude_session_id: str = "",
+    session_token: str = "",
+    session_client: str = "",
+) -> str:
     """Full startup sequence: register, clean, report.
 
     Args:
         task: Initial task description
-        claude_session_id: External client session token. Claude Code passes its UUID via hooks;
-                          other clients may pass a synthetic durable ID when useful.
-                          Enables automatic inbox detection when hook-backed clients provide one.
+        claude_session_id: Legacy alias for the external client session token.
+        session_token: External client session token. Claude Code passes its UUID via hooks;
+                      other clients may pass a synthetic durable ID when useful.
+                      Enables automatic inbox detection when hook-backed clients provide one.
+        session_client: Optional client label such as `claude_code` or `codex`.
     """
     sid = _generate_sid()
     cleaned = clean_stale_sessions()
-    register_session(sid, task, claude_session_id=claude_session_id)
+    linked_session_id = (session_token or claude_session_id or "").strip()
+    inferred_client = (session_client or "").strip()
+    if not inferred_client and claude_session_id and not session_token:
+        inferred_client = "claude_code"
+    register_session(
+        sid,
+        task,
+        claude_session_id=linked_session_id,
+        external_session_id=linked_session_id,
+        session_client=inferred_client,
+    )
     _start_keepalive(sid)
     active = get_active_sessions()
     other_sessions = [s for s in active if s["sid"] != sid]

package/templates/CODEX.AGENTS.md.template

@@ -1,4 +1,4 @@
-<!-- nexo-codex-agents-version: 1.0.0 -->
+<!-- nexo-codex-agents-version: 1.1.0 -->
 ******CORE******
 <!-- nexo:core:start -->
 # {{NAME}} — NEXO Shared Brain for Codex
@@ -19,7 +19,7 @@ NEXO updates may rewrite `CORE`, but they must preserve `USER` verbatim.
 
 ## Codex Runtime Notes
 - Codex does not provide Claude Code hooks. Compensate explicitly: startup, heartbeat on every user message, diary on clear end-of-session intent, and memory capture on every correction or durable decision.
-- If a stable session token is useful, you may pass a synthetic `claude_session_id` like `codex-<task>-<date>` to `nexo_startup`; otherwise leave it blank.
+- If a stable session token is useful, pass `session_token='codex-<task>-<date>'` and `session_client='codex'` to `nexo_startup`; otherwise leave them blank.
 - `nexo chat` must inject this bootstrap explicitly when it launches Codex so the session starts as NEXO even if plain global Codex startup ignores global instructions.
 - `nexo chat` should open the configured client and keep runtime/model alignment with NEXO preferences.