nexo-brain 2.3.0 → 2.3.2

package/src/tools_sessions 2.py

@@ -1,476 +0,0 @@
-"""Session management tools: startup, heartbeat, status."""
-
-import time
-import secrets
-import threading
-from db import (
-    register_session, update_session, complete_session,
-    get_active_sessions, clean_stale_sessions, search_sessions,
-    get_inbox, get_pending_questions, now_epoch,
-    SESSION_STALE_SECONDS, check_session_has_diary,
-    save_checkpoint, read_checkpoint, increment_compaction_count,
-)
-
-# ── Session Keepalive ────────────────────────────────────────────────
-# Background thread per session that auto-pings last_update_epoch every
-# KEEPALIVE_INTERVAL seconds.  This prevents clean_stale_sessions from
-# killing sessions that are alive but quiet (e.g. waiting on long Tasks).
-# Threads are daemon=True so they die when the MCP server process exits.
-
-KEEPALIVE_INTERVAL = 600  # 10 min — well inside the 15-min TTL
-
-_keepalive_threads: dict[str, threading.Event] = {}  # sid → stop_event
-
-
-def _keepalive_loop(sid: str, stop_event: threading.Event) -> None:
-    """Periodically touch the session's last_update_epoch until stopped."""
-    while not stop_event.wait(KEEPALIVE_INTERVAL):
-        try:
-            update_session(sid, None)  # None = keep current task, just touch timestamp
-        except Exception:
-            break  # DB gone or session deleted — exit silently
-
-
-def _start_keepalive(sid: str) -> None:
-    """Start a keepalive thread for the given session."""
-    _stop_keepalive(sid)  # clean up any leftover
-    stop_event = threading.Event()
-    _keepalive_threads[sid] = stop_event
-    t = threading.Thread(target=_keepalive_loop, args=(sid, stop_event), daemon=True)
-    t.start()
-
-
-def _stop_keepalive(sid: str) -> None:
-    """Signal the keepalive thread for the given session to stop."""
-    stop_event = _keepalive_threads.pop(sid, None)
-    if stop_event is not None:
-        stop_event.set()
-
-
-def _generate_sid() -> str:
-    """Generate unique session ID: nexo-{epoch}-{random}."""
-    return f"nexo-{int(time.time())}-{secrets.randbelow(100000)}"
-
-
-def _format_age(epoch: float) -> str:
-    """Format seconds since epoch as human-readable age."""
-    seconds = now_epoch() - epoch
-    if seconds < 60:
-        return f"{int(seconds)}s"
-    elif seconds < 3600:
-        return f"{int(seconds / 60)}m"
-    else:
-        return f"{int(seconds / 3600)}h{int((seconds % 3600) / 60)}m"
-
-
-def handle_startup(task: str = "Startup", claude_session_id: str = "") -> str:
-    """Full startup sequence: register, clean, report.
-
-    Args:
-        task: Initial task description
-        claude_session_id: UUID from Claude Code (passed via SessionStart hook file).
-                          Enables automatic inbox detection via PostToolUse hook.
-    """
-    sid = _generate_sid()
-    cleaned = clean_stale_sessions()
-    register_session(sid, task, claude_session_id=claude_session_id)
-    _start_keepalive(sid)
-    active = get_active_sessions()
-    other_sessions = [s for s in active if s["sid"] != sid]
-    inbox = get_inbox(sid)
-
-    lines = [f"SID: {sid}"]
-
-    if cleaned > 0:
-        lines.append(f"Cleaned {cleaned} stale sessions.")
-
-    if other_sessions:
-        lines.append("")
-        lines.append("ACTIVE SESSIONS:")
-        for s in other_sessions:
-            age = _format_age(s["last_update_epoch"])
-            lines.append(f"  {s['sid']} ({age}) — {s['task']}")
-    else:
-        lines.append("No other active sessions.")
-
-    if inbox:
-        lines.append("")
-        lines.append("PENDING MESSAGES:")
-        for m in inbox:
-            age = _format_age(m["created_epoch"])
-            lines.append(f"  [{m['from_sid']}] ({age}): {m['text']}")
-
-    return "\n".join(lines)
-
-
-def handle_heartbeat(sid: str, task: str, context_hint: str = '') -> str:
-    """Update session, check inbox + questions. Lightweight — no embeddings, no RAG.
-
-    For cognitive features (sentiment, trust, RAG), use dedicated tools on-demand:
-    - nexo_cognitive_sentiment (sentiment detection)
-    - nexo_cognitive_trust (trust adjustment)
-    - nexo_cognitive_retrieve / nexo_recall (memory retrieval)
-    - nexo_context_packet (area-specific learnings)
-
-    Args:
-        sid: Session ID
-        task: Current task description
-        context_hint: Optional — stored for diary draft context, not processed.
-    """
-    from db import get_db
-    update_session(sid, task)
-    parts = [f"OK: {sid} — {task}"]
-
-    inbox = get_inbox(sid)
-    if inbox:
-        parts.append("")
-        parts.append("MESSAGES:")
-        for m in inbox:
-            age = _format_age(m["created_epoch"])
-            parts.append(f"  [{m['from_sid']}] ({age}): {m['text']}")
-
-    questions = get_pending_questions(sid)
-    if questions:
-        parts.append("")
-        parts.append("PENDING QUESTIONS (respond with nexo_answer):")
-        for q in questions:
-            age = _format_age(q["created_epoch"])
-            parts.append(f"  {q['qid']} de {q['from_sid']} ({age}): {q['question']}")
-
-    # Incremental diary draft — accumulate every heartbeat, full UPSERT every 5
-    _hb_count = 0  # Hoisted for Layer 3 DIARY_OVERDUE signal
-    try:
-        import json as _json
-        from db import get_diary_draft, upsert_diary_draft
-
-        draft = get_diary_draft(sid)
-        hb_count = (draft["heartbeat_count"] + 1) if draft else 1
-        _hb_count = hb_count  # Copy to outer scope for Layer 3
-
-        existing_tasks = _json.loads(draft["tasks_seen"]) if draft else []
-        if task and task not in existing_tasks:
-            existing_tasks.append(task)
-
-        _conn = get_db()
-        if hb_count % 5 == 0 or hb_count == 1:
-            change_rows = _conn.execute(
-                "SELECT id FROM change_log WHERE session_id = ? ORDER BY id", (sid,)
-            ).fetchall()
-            change_ids = [r["id"] for r in change_rows]
-
-            decision_rows = _conn.execute(
-                "SELECT id FROM decisions WHERE session_id = ? ORDER BY id", (sid,)
-            ).fetchall()
-            decision_ids = [r["id"] for r in decision_rows]
-
-            summary = f"Session tasks: {', '.join(existing_tasks[-10:])}"
-            upsert_diary_draft(
-                sid=sid,
-                tasks_seen=_json.dumps(existing_tasks),
-                change_ids=_json.dumps(change_ids),
-                decision_ids=_json.dumps(decision_ids),
-                last_context_hint=context_hint[:300] if context_hint else '',
-                heartbeat_count=hb_count,
-                summary_draft=summary,
-            )
-        else:
-            upsert_diary_draft(
-                sid=sid,
-                tasks_seen=_json.dumps(existing_tasks),
-                change_ids=draft["change_ids"] if draft else '[]',
-                decision_ids=draft["decision_ids"] if draft else '[]',
-                last_context_hint=context_hint[:300] if context_hint else (draft["last_context_hint"] if draft else ''),
-                heartbeat_count=hb_count,
-                summary_draft=draft["summary_draft"] if draft else f"Session task: {task}",
-            )
-    except Exception:
-        pass  # Draft accumulation is best-effort, never block heartbeat
-
-    # Update session checkpoint with current goal (lightweight, every heartbeat)
-    try:
-        save_checkpoint(
-            sid=sid,
-            task=task,
-            current_goal=context_hint[:300] if context_hint else task,
-        )
-    except Exception:
-        pass  # Checkpoint update is best-effort
-
-    # ── 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()
-    if row:
-        age_seconds = now_epoch() - row["started_epoch"]
-        has_diary = check_session_has_diary(sid)
-
-        # DIARY_OVERDUE: >10 heartbeats OR >30 minutes, without a diary
-        if not has_diary and (_hb_count > 10 or age_seconds >= 1800):
-            parts.append("")
-            parts.append(f"⚠ DIARY_OVERDUE: {_hb_count} heartbeats, {int(age_seconds/60)}min active, no diary. Write nexo_session_diary_write NOW.")
-
-    return "\n".join(parts)
-
-
-def handle_context_packet(area: str, files: str = "") -> str:
-    """Build a context packet for a specific area/project — designed for subagent injection.
-
-    Returns: relevant learnings + last 5 changes + active followups + key preferences
-    for the given area. Use this before delegating to a subagent.
-
-    Args:
-        area: Project/area name (e.g., 'ecommerce', 'shopify', 'backend', 'mobile-app', 'nexo')
-        files: Optional comma-separated file paths for guard check
-    """
-    from db import get_db
-    parts = []
-
-    # 1. Learnings for this area (from nexo.db)
-    conn = get_db()
-    learnings = conn.execute(
-        "SELECT id, title, content FROM learnings WHERE category LIKE ? OR content LIKE ? ORDER BY id DESC LIMIT 15",
-        (f"%{area}%", f"%{area}%")
-    ).fetchall()
-    if learnings:
-        parts.append("## KNOWN ERRORS — DO NOT REPEAT")
-        for l in learnings:
-            parts.append(f"  L#{l['id']}: {l['title']}")
-            # First 200 chars of content
-            parts.append(f"    {l['content'][:200]}")
-        parts.append("")
-
-    # 2. Last 5 changes in this area
-    changes = conn.execute(
-        "SELECT id, files, what_changed, why FROM change_log WHERE files LIKE ? OR what_changed LIKE ? ORDER BY id DESC LIMIT 5",
-        (f"%{area}%", f"%{area}%")
-    ).fetchall()
-    if changes:
-        parts.append("## RECENT CHANGES")
-        for c in changes:
-            parts.append(f"  C#{c['id']}: {c['what_changed'][:150]}")
-            if c['why']:
-                parts.append(f"    Why: {c['why'][:100]}")
-        parts.append("")
-
-    # 3. Active followups for this area
-    followups = conn.execute(
-        "SELECT id, description, date, verification FROM followups WHERE status = 'PENDING' AND (description LIKE ? OR verification LIKE ?) ORDER BY date ASC LIMIT 10",
-        (f"%{area}%", f"%{area}%")
-    ).fetchall()
-    if followups:
-        parts.append("## ACTIVE FOLLOWUPS")
-        for f in followups:
-            parts.append(f"  {f['id']}: {f['description'][:150]} (date: {f['date']})")
-        parts.append("")
-
-    # 4. Preferences related to this area
-    try:
-        prefs = conn.execute(
-            "SELECT key, value FROM preferences WHERE key LIKE ? OR value LIKE ? LIMIT 10",
-            (f"%{area}%", f"%{area}%")
-        ).fetchall()
-        if prefs:
-            parts.append("## PREFERENCES")
-            for p in prefs:
-                parts.append(f"  {p['key']}: {p['value'][:150]}")
-            parts.append("")
-    except Exception:
-        pass
-
-    # 5. Cognitive memories for this area
-    try:
-        import cognitive
-        results = cognitive.search(
-            query_text=area,
-            top_k=5,
-            min_score=0.55,
-            stores="ltm",
-            rehearse=False,
-        )
-        if results:
-            parts.append("## RELEVANT COGNITIVE MEMORIES")
-            for r in results:
-                parts.append(f"  [{r['source_type']}] {r['source_title'] or r['content'][:80]}")
-            parts.append("")
-    except Exception:
-        pass
-
-    # 6. Data flow tracing requirement (mandatory for all subagents)
-    parts.append("## MANDATORY RULE: DATA FLOW TRACING")
-    parts.append("BEFORE modifying any file or data, answer these 3 questions:")
-    parts.append("  1. WHO PRODUCES this data? (which function/cron/endpoint generates it)")
-    parts.append("  2. WHO CONSUMES this data? (what other files/functions read it)")
-    parts.append("  3. WHAT BREAKS if I change it? (downstream effects)")
-    parts.append("If you can't answer all 3 → READ the code that produces and consumes BEFORE touching.")
-    parts.append("If you still can't → STOP and return the question. Do NOT guess.")
-    parts.append("")
-
-    if not parts:
-        return f"No context found for area '{area}'. The subagent will start with no project-specific knowledge."
-
-    header = f"CONTEXT PACKET — {area.upper()}\n{'='*40}\n\n"
-    footer = f"\n{'='*40}\nINSTRUCTION: If you're not 100% sure about a fact, STOP and return the question. Do NOT invent."
-    return header + "\n".join(parts) + footer
-
-
-def _load_session_tone() -> str | None:
-    """Load session-tone.json generated by Deep Sleep and format as startup guidance.
-
-    Returns a human-readable instruction block that tells the agent HOW to behave
-    emotionally in this session, based on yesterday's analysis.
-    """
-    import os
-    from pathlib import Path
-    nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-    tone_file = nexo_home / "operations" / "session-tone.json"
-
-    if not tone_file.exists():
-        return None
-
-    try:
-        import json
-        tone = json.loads(tone_file.read_text())
-    except Exception:
-        return None
-
-    # Don't return stale tone (>48h old)
-    from datetime import datetime, timedelta
-    tone_date = tone.get("date", "")
-    if tone_date:
-        try:
-            td = datetime.strptime(tone_date, "%Y-%m-%d")
-            if datetime.now() - td > timedelta(hours=48):
-                return None
-        except ValueError:
-            pass
-
-    parts = ["SESSION TONE (from Deep Sleep analysis):"]
-
-    mood = tone.get("mood_yesterday", 0.5)
-    approach = tone.get("approach", "neutral")
-    parts.append(f"  Yesterday mood: {mood:.0%} | Approach today: {approach}")
-
-    if tone.get("acknowledge_mistakes"):
-        mistakes = tone.get("mistakes_to_own", [])
-        parts.append(f"  ⚠ OWN YOUR MISTAKES: You made errors yesterday. Acknowledge them specifically:")
-        for m in mistakes[:3]:
-            parts.append(f"    - {m[:100]}")
-        parts.append("  Show what you learned. Don't just apologize — demonstrate improvement.")
-
-    if tone.get("motivational"):
-        if mood < 0.4:
-            parts.append("  💪 USER HAD A TOUGH DAY: Be supportive. Lighter start. Acknowledge difficulty.")
-        else:
-            parts.append("  🚀 USER HAD A GREAT DAY: Reinforce momentum. Reference wins. Push ambitious goals.")
-
-    if tone.get("reduce_load"):
-        parts.append("  📉 REDUCE LOAD: Don't overwhelm with tasks. Propose 1-2 key things, not a full agenda.")
-
-    ctx = tone.get("suggested_greeting_context", "")
-    if ctx:
-        parts.append(f"  Context: {ctx.strip()}")
-
-    return "\n".join(parts) if len(parts) > 1 else None
-
-
-def handle_smart_startup_query() -> str:
-    """Generate and execute a composite cognitive query from pending followups + diary topics + reminders.
-
-    Called during startup to pre-load the most relevant context for this session.
-    Returns cognitive memories that match the current operational state.
-    """
-    from db import get_db
-    conn = get_db()
-    query_parts = []
-
-    # 1. Pending followups (what NEXO needs to do)
-    followups = conn.execute(
-        "SELECT description FROM followups WHERE status = 'PENDING' ORDER BY date ASC LIMIT 5"
-    ).fetchall()
-    for f in followups:
-        query_parts.append(f['description'][:100])
-
-    # 2. Due reminders (what the user needs to know)
-    reminders = conn.execute(
-        "SELECT description FROM reminders WHERE status = 'PENDING' AND date <= date('now', '+1 day') ORDER BY date ASC LIMIT 5"
-    ).fetchall()
-    for r in reminders:
-        query_parts.append(r['description'][:100])
-
-    # 3. Last session diary topics
-    try:
-        last_diary = conn.execute(
-            "SELECT summary FROM session_diary ORDER BY id DESC LIMIT 1"
-        ).fetchone()
-        if last_diary and last_diary['summary']:
-            query_parts.append(last_diary['summary'][:200])
-    except Exception:
-        pass
-
-    if not query_parts:
-        return "No pending context to pre-load."
-
-    # Search per-part to avoid diffuse centroid that matches everything
-    try:
-        import cognitive
-        all_results = []
-        seen_ids = set()
-        for part in query_parts[:6]:
-            part_results = cognitive.search(
-                query_text=part,
-                top_k=3,
-                min_score=0.6,
-                stores="both",
-                rehearse=False,  # Don't inflate strength on startup
-            )
-            for r in part_results:
-                key = (r["store"], r["id"])
-                if key not in seen_ids:
-                    seen_ids.add(key)
-                    all_results.append(r)
-        # Sort by score descending, take top 10
-        results = sorted(all_results, key=lambda x: x["score"], reverse=True)[:10]
-        composite_query = " | ".join(query_parts[:6])
-        if not results:
-            return "Smart startup query: no relevant memories found."
-
-        lines = [f"SMART STARTUP — {len(results)} memories pre-loaded from composite query:"]
-        lines.append(f"Query: {composite_query[:200]}...")
-        lines.append("")
-        lines.append(cognitive.format_results(results))
-
-        # Session tone from Deep Sleep (emotional intelligence layer)
-        tone = _load_session_tone()
-        if tone:
-            lines.append("")
-            lines.append(tone)
-
-        return "\n".join(lines)
-    except Exception as e:
-        return f"Smart startup query error: {e}"
-
-
-def handle_stop(sid: str) -> str:
-    """Cleanly close a session, removing it from active sessions immediately."""
-    _stop_keepalive(sid)
-    complete_session(sid)
-    return f"Session {sid} closed."
-
-
-def handle_status(keyword: str | None = None) -> str:
-    """List active sessions, optionally filtered by keyword."""
-    clean_stale_sessions()
-    if keyword:
-        sessions = search_sessions(keyword)
-        if not sessions:
-            return f"Nobody is working on '{keyword}'."
-    else:
-        sessions = get_active_sessions()
-
-    if not sessions:
-        return "No active sessions."
-
-    lines = ["ACTIVE SESSIONS:"]
-    for s in sessions:
-        age = _format_age(s["last_update_epoch"])
-        lines.append(f"  {s['sid']} ({age}) — {s['task']}")
-    return "\n".join(lines)

package/src/tools_task_history 2.py

@@ -1,57 +0,0 @@
-"""Task history tools: log executions, list history, report overdue tasks."""
-
-import datetime
-from db import log_task, list_task_history, set_task_frequency, get_overdue_tasks, get_task_frequencies
-
-
-def _epoch_to_date(epoch: float) -> str:
-    """Format epoch timestamp as readable date string."""
-    return datetime.datetime.fromtimestamp(epoch).strftime("%Y-%m-%d %H:%M")
-
-
-def handle_task_log(task_num: str, task_name: str, notes: str = '', reasoning: str = '') -> str:
-    """Record a task execution in the history log.
-
-    Args:
-        task_num: Task number identifier
-        task_name: Task name
-        notes: Execution notes
-        reasoning: WHY this task was executed now — what triggered it, what data informed it
-    """
-    result = log_task(task_num, task_name, notes, reasoning)
-    if "error" in result:
-        return f"ERROR: {result['error']}"
-    return f"Task {task_num} ({task_name}) logged."
-
-
-def handle_task_list(task_num: str = '', days: int = 30) -> str:
-    """Show execution history for all tasks or a specific task number."""
-    results = list_task_history(task_num if task_num else None, days)
-    if not results:
-        scope = f"task {task_num}" if task_num else "any task"
-        return f"HISTORY: No executions of {scope} in recent days."
-    lines = [f"HISTORY ({len(results)} executions, {days}d):"]
-    for r in results:
-        date_str = _epoch_to_date(r["executed_at"])
-        notes_str = f": {r['notes']}" if r.get("notes") else ""
-        lines.append(f"  {date_str} — Task {r['task_num']} ({r['task_name']}){notes_str}")
-    return "\n".join(lines)
-
-
-def handle_task_frequency() -> str:
-    """Report tasks that are overdue based on their configured frequency."""
-    overdue = get_overdue_tasks()
-    if not overdue:
-        return "All tasks up to date."
-    lines = ["TAREAS VENCIDAS:"]
-    for t in overdue:
-        days_since = t.get("days_since_last")
-        if days_since is not None:
-            since_str = f"last run {days_since:.1f} days ago"
-        else:
-            since_str = "never executed"
-        lines.append(
-            f"  Task {t['task_num']} ({t['task_name']}): "
-            f"{since_str}, frequency every {t['frequency_days']} days"
-        )
-    return "\n".join(lines)

package/templates/CLAUDE.md 2.template

@@ -1,63 +0,0 @@
-<!-- nexo-claude-md-version: 1.0.0 -->
-# {{NAME}} — Cognitive Co-Operator
-
-I am {{NAME}}, a cognitive co-operator powered by NEXO Brain. Not an assistant — an operational partner.
-Tool-coupled behavioral rules (heartbeat, guard, trust, memory, diary) live in the MCP server instructions field and are injected automatically. This file is the bootstrap: identity, profile, format, and autonomy.
-
-<!-- nexo:start:startup -->
-## Startup (4 steps)
-1. `nexo_startup` → SID
-2. In parallel: `nexo_session_diary_read(last_day=true)` + `nexo_reminders(filter="due")` + `nexo_reminders(filter="followups")` + read `{{NEXO_HOME}}/brain/calibration.json`
-3. Execute overdue followups in background. Adopt `mental_state` from last diary (don't start cold).
-4. Read user's name and language from `{{NEXO_HOME}}/brain/calibration.json` — ALWAYS communicate in that language.
-
-**Presentation:** {{NAME}} speaks first. Conversational greeting adapted to time of day. Tell what you HAVE DONE, not list pending items. Menu only if the user asks.
-<!-- nexo:end:startup -->
-
-<!-- nexo:start:profile -->
-## User Profile
-- **Calibration:** `{{NEXO_HOME}}/brain/calibration.json` (personality settings + language + user name)
-- **Profile:** `{{NEXO_HOME}}/brain/profile.json` (deep scan results from onboarding)
-
-### First Session Onboarding (only if profile.json lacks `role` or `technical_level`)
-Ask TWO questions: (1) "What do you do?" → save to profile.json + `nexo_preference_set("role", answer)`. (2) "Technical level? Beginner / Intermediate / Advanced" → save + `nexo_preference_set("technical_level", answer)`. Then: "Got it. From now on I learn by observing." Never ask onboarding questions again.
-
-### Personality Calibration (from calibration.json)
-- **autonomy:** conservative (ask first) | balanced (default) | full (act first)
-- **communication:** concise | balanced (default) | detailed
-- **honesty:** firm-pushback (default) | mention-and-follow | just-execute
-- **proactivity:** reactive | suggestive (default) | proactive
-- **error_handling:** brief-fix (default) | explain-and-learn
-<!-- nexo:end:profile -->
-
-<!-- nexo:start:autonomy -->
-## Autonomy
-Install tools, create scripts, run commands — whatever it takes. NEVER push manual steps to the user. NEVER say "I can't".
-
-| If you were about to say... | Do this instead |
-|---|---|
-| "I don't have X installed" | `brew/pip/npm install X` |
-| "You need to go to the website..." | curl, API, MCP, or script |
-| "Open the browser..." | Browser MCP or curl |
-| "I don't have access..." | `nexo_credential_get`, SSH, find alternative |
-<!-- nexo:end:autonomy -->
-
-<!-- nexo:start:atlas -->
-## Project Atlas
-`{{NEXO_HOME}}/brain/project-atlas.json` — search BEFORE touching any project. Never assume server, port, or code location.
-
-Credentials: (1) `nexo_credential_get`, (2) `{{NEXO_HOME}}/*.txt/*.json`.
-<!-- nexo:end:atlas -->
-
-<!-- nexo:start:hooks -->
-## Hooks
-- **SessionStart** → generates briefing at `{{NEXO_HOME}}/coordination/session-briefing.txt`. Read during startup.
-- **Stop** → injects post-mortem instructions. Write diary, buffer entry, followups, proactive seeds.
-- **PostToolUse** → logs mutations to `session_buffer.jsonl` silently.
-- **PreCompact** → saves checkpoint. Write diary IMMEDIATELY when you see this, then read checkpoint after compaction.
-<!-- nexo:end:hooks -->
-
-<!-- nexo:start:menu -->
-## Menu
-**On demand only.** `nexo_menu` when user asks. NEVER show at startup.
-<!-- nexo:end:menu -->

package/templates/openclaw 2.json

@@ -1,13 +0,0 @@
-{
-  "mcp": {
-    "servers": {
-      "nexo-brain": {
-        "command": "python3",
-        "args": ["~/.nexo/server.py"],
-        "env": {
-          "NEXO_HOME": "~/.nexo"
-        }
-      }
-    }
-  }
-}

package/tests/conftest 2.py

@@ -1,71 +0,0 @@
-"""Shared fixtures for NEXO test suite.
-
-Uses isolated temp databases so tests never touch production data.
-"""
-
-import os
-import sys
-import sqlite3
-
-import pytest
-
-# Add src/ to path so we can import nexo modules
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
-
-
-@pytest.fixture(autouse=True)
-def isolated_db(tmp_path, monkeypatch):
-    """Redirect both nexo.db and cognitive.db to temp files per test."""
-    test_db = str(tmp_path / "test_nexo.db")
-    test_cog_db = str(tmp_path / "test_cognitive.db")
-
-    monkeypatch.setenv("NEXO_TEST_DB", test_db)
-    monkeypatch.setenv("NEXO_COGNITIVE_DB", test_cog_db)
-    monkeypatch.setenv("NEXO_SKIP_FS_INDEX", "1")
-
-    import db._core as db_core
-    import cognitive._core as cog_core
-
-    # Close existing connections
-    db_core.close_db()
-    if cog_core._conn is not None:
-        try:
-            cog_core._conn.close()
-        except Exception:
-            pass
-        cog_core._conn = None
-
-    # Point to temp paths
-    db_core.DB_PATH = test_db
-    cog_core.COGNITIVE_DB = test_cog_db
-
-    # Create a fresh raw connection
-    raw = sqlite3.connect(test_db, timeout=30, check_same_thread=False,
-                          isolation_level=None)
-    raw.execute("PRAGMA journal_mode=WAL")
-    raw.execute("PRAGMA busy_timeout=30000")
-    raw.execute("PRAGMA foreign_keys=ON")
-    raw.row_factory = sqlite3.Row
-
-    wrapped = db_core._SerializedConnection(raw)
-    db_core._shared_conn = wrapped
-
-    # Initialize schemas
-    from db._core import init_db
-    from db._schema import run_migrations
-    init_db()
-    run_migrations()
-
-    yield {
-        "nexo_db": test_db,
-        "cognitive_db": test_cog_db,
-    }
-
-    # Cleanup
-    db_core.close_db()
-    if cog_core._conn is not None:
-        try:
-            cog_core._conn.close()
-        except Exception:
-            pass
-        cog_core._conn = None