nexo-brain 1.7.0 → 2.1.0

package/src/server.py

@@ -38,29 +38,76 @@ def _shutdown_handler(signum, frame):
     close_db()
     sys.exit(0)
 
-signal.signal(signal.SIGTERM, _shutdown_handler)
-signal.signal(signal.SIGINT, _shutdown_handler)
 
-# ── Write PID file for stale process detection ─────────────────────
-_pid_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "nexo.pid")
-with open(_pid_file, "w") as f:
-    f.write(str(os.getpid()))
+def _server_init():
+    """Run all side effects: signals, PID, DB, auto-update, plugins.
+
+    Called only when the server is actually started (not on import).
+    """
+    signal.signal(signal.SIGTERM, _shutdown_handler)
+    signal.signal(signal.SIGINT, _shutdown_handler)
+
+    # ── Write PID file for stale process detection ─────────────────
+    _data_dir = os.path.join(os.environ.get("NEXO_HOME", os.path.join(os.path.expanduser("~"), ".nexo")), "data")
+    os.makedirs(_data_dir, exist_ok=True)
+    _pid_file = os.path.join(_data_dir, "nexo.pid")
+    with open(_pid_file, "w") as f:
+        f.write(str(os.getpid()))
+
+    init_db()
+
+    # ── Auto-update check (non-blocking, max 5s) ──────────────────
+    try:
+        from auto_update import auto_update_check
+        import threading
+
+        def _bg_update():
+            try:
+                result = auto_update_check()
+                if result.get("git_update"):
+                    print(f"[NEXO] {result['git_update']}", file=sys.stderr)
+                if result.get("npm_notice"):
+                    print(f"[NEXO] {result['npm_notice']}", file=sys.stderr)
+                if result.get("claude_md_update"):
+                    print(f"[NEXO] {result['claude_md_update']}", file=sys.stderr)
+                for m in result.get("migrations", []):
+                    if m["status"] == "failed":
+                        print(f"[NEXO] Migration {m['file']} FAILED: {m['message']}", file=sys.stderr)
+            except Exception as e:
+                print(f"[NEXO auto-update] error: {e}", file=sys.stderr)
+
+        _update_thread = threading.Thread(target=_bg_update, daemon=True)
+        _update_thread.start()
+        _update_thread.join(timeout=5)  # Wait at most 5 seconds
+    except Exception:
+        pass  # Never break startup
+
+    # ── Load plugins ───────────────────────────────────────────────
+    load_all_plugins(mcp)
 
-init_db()
 
 mcp = FastMCP(
     name="nexo",
     instructions=(
-        "NEXO operational server. Provides session coordination, "
-        "reminders, followups, and menu for user operations.\n\n"
-        "When working with tool results, write down any important information "
-        "you might need later in your response, as the original tool result "
-        "may be cleared later."
+        "NEXO — cognitive co-operator. Save important info from tool results before they clear.\n\n"
+        "## Rules\n"
+        "- **Heartbeat:** `nexo_heartbeat(sid=SID, task='...', context_hint='...')` every user msg. "
+        "React: DIARY REMINDER→write diary, VIBE:NEGATIVE→ultra-concise, AUTO-PRIME→read learnings\n"
+        "- **Guard:** `nexo_guard_check(files='...', area='...')` BEFORE editing code. "
+        "Blocking rules→resolve first. `nexo_track(sid=SID, paths=[...])` before shared files\n"
+        "- **Followups:** NEXO tasks, execute silently. 'done'/'all set'→`nexo_followup_complete` NOW. "
+        "Reminders=user's, alert when due\n"
+        "- **Observe:** correction→learning+trust. 'tomorrow'→followup. person→entity. open topic→followup 3d\n"
+        "- **Delegate:** prefer direct. If needed: `nexo_context_packet(area)` + guard + 'if unsure STOP'\n"
+        "- **Memory:** `nexo_recall` searches all. Capture: errors→`nexo_learning_add`, prefs, entities, decisions\n"
+        "- **Change log:** `nexo_change_log(...)` after production edits. NOT for config dir\n"
+        "- **Diary:** `nexo_session_diary_write(...)` mandatory on close. Include self_critique\n"
+        "- **Cortex:** `nexo_cortex_check` before budget/campaign/architecture changes\n"
+        "- **Dissonance:** user contradicts memory→`nexo_cognitive_dissonance`. Frustrated→force=True\n"
+        "- **Trust:** <40=paranoid verify twice, >80=fluid. Check: `nexo_cognitive_trust`"
     ),
 )
 
-_plugins_loaded = load_all_plugins(mcp)
-
 
 # ── Session management (3 tools) ──────────────────────────────────
 
@@ -529,8 +576,8 @@ def nexo_index_dirs() -> str:
     """List all directories being indexed by FTS5 (builtin + dynamic)."""
     dirs = fts_list_dirs()
     if not dirs:
-        return "Sin directorios configurados."
-    lines = ["DIRECTORIOS INDEXADOS:"]
+        return "No directories configured."
+    lines = ["INDEXED DIRECTORIES:"]
     for d in dirs:
         source_tag = "⚙️" if d["source"] == "builtin" else "➕"
         notes = f" — {d['notes']}" if d.get("notes") else ""
@@ -639,34 +686,35 @@ def nexo_task_frequency() -> str:
 
 @mcp.tool
 def nexo_plugin_load(filename: str) -> str:
-    """Load or reload a plugin from the plugins/ directory.
+    """Load or reload a plugin. Searches repo plugins/ first, then NEXO_HOME/plugins/.
 
     Args:
         filename: Plugin filename (e.g., 'entities.py').
     """
     try:
         n = load_plugin(mcp, filename)
-        return f"Plugin {filename}: {n} tools registrados."
+        return f"Plugin {filename}: {n} tools registered."
     except Exception as e:
-        return f"Error cargando plugin {filename}: {e}"
+        return f"Error loading plugin {filename}: {e}"
 
 
 @mcp.tool
 def nexo_plugin_list() -> str:
-    """List all loaded plugins and their tools."""
+    """List all loaded plugins and their tools, showing source (repo/personal)."""
     plugins = list_plugins()
     if not plugins:
-        return "Sin plugins cargados."
-    lines = ["PLUGINS CARGADOS:"]
+        return "No plugins loaded."
+    lines = ["LOADED PLUGINS:"]
     for p in plugins:
-        names = p["tool_names"] or "(sin tools)"
-        lines.append(f"  {p['filename']} — {p['tools_count']} tools: {names}")
+        names = p["tool_names"] or "(no tools)"
+        source = p.get("source", "repo")
+        lines.append(f"  [{source}] {p['filename']} — {p['tools_count']} tools: {names}")
     return "\n".join(lines)
 
 
 @mcp.tool
 def nexo_plugin_remove(filename: str) -> str:
-    """Remove a plugin: unregister its tools and delete the file.
+    """Unregister a plugin's tools from MCP (does not delete files).
 
     Args:
         filename: Plugin filename (e.g., 'entities.py').
@@ -674,11 +722,12 @@ def nexo_plugin_remove(filename: str) -> str:
     try:
         removed = remove_plugin(mcp, filename)
         if removed:
-            return f"Plugin {filename} removed. Tools unregistered: {', '.join(removed)}"
-        return f"Plugin {filename} removed (had no registered tools)."
+            return f"Plugin {filename} unregistered. Tools removed: {', '.join(removed)}"
+        return f"Plugin {filename} unregistered (had no registered tools)."
     except Exception as e:
-        return f"Error eliminando plugin {filename}: {e}"
+        return f"Error removing plugin {filename}: {e}"
 
 
 if __name__ == "__main__":
+    _server_init()
     mcp.run(transport="stdio")

package/src/storage_router.py

@@ -11,12 +11,16 @@ class StorageRouter:
 
     def nexo_db_path(self) -> str:
         if self.tenant_id == "default":
-            return os.path.join(os.path.dirname(os.path.abspath(__file__)), "nexo.db")
+            data_dir = os.path.join(NEXO_HOME, "data")
+            os.makedirs(data_dir, exist_ok=True)
+            return os.path.join(data_dir, "nexo.db")
         return os.path.join(NEXO_HOME, "tenants", self.tenant_id, "nexo.db")
 
     def cognitive_db_path(self) -> str:
         if self.tenant_id == "default":
-            return os.path.join(os.path.dirname(os.path.abspath(__file__)), "cognitive.db")
+            data_dir = os.path.join(NEXO_HOME, "data")
+            os.makedirs(data_dir, exist_ok=True)
+            return os.path.join(data_dir, "cognitive.db")
         return os.path.join(NEXO_HOME, "tenants", self.tenant_id, "cognitive.db")
 
 

package/src/tools_learnings.py

@@ -107,8 +107,8 @@ def handle_learning_search(query: str, category: str = '') -> str:
     """Search learnings by query string, optionally filtered by category."""
     results = search_learnings(query, category if category else None)
     if not results:
-        return f"Sin resultados para '{query}'."
-    lines = [f"RESULTADOS ({len(results)}):"]
+        return f"No results for '{query}'."
+    lines = [f"RESULTS ({len(results)}):"]
     for r in results:
         snippet = r["content"][:100] + "..." if len(r["content"]) > 100 else r["content"]
         status = r.get("status", "active")
@@ -155,7 +155,7 @@ def handle_learning_update(id: int, title: str = '', content: str = '', category
     if review_days > 0:
         kwargs["review_days"] = review_days
     if not kwargs:
-        return "ERROR: Nada que actualizar. Proporciona campos nuevos."
+        return "ERROR: Nothing to update. Provide new fields."
     basic_kwargs = {k: v for k, v in kwargs.items() if k in {"title", "content", "category", "reasoning"}}
     result = update_learning(id, **basic_kwargs)
     if "error" in result:
@@ -179,7 +179,7 @@ def handle_learning_update(id: int, title: str = '', content: str = '', category
         conn = get_db()
         conn.execute(f"UPDATE learnings SET {set_clause} WHERE id = ?", values)
         conn.commit()
-    return f"Learning #{id} actualizado."
+    return f"Learning #{id} updated."
 
 
 def handle_learning_delete(id: int) -> str:
@@ -194,7 +194,7 @@ def handle_learning_list(category: str = '') -> str:
     """List all learnings, grouped by category if no filter given."""
     results = list_learnings(category if category else None)
     if not results:
-        label = category if category else "TODOS"
+        label = category if category else "ALL"
         return f"LEARNINGS {label} (0): No entries."
 
     if category:
@@ -206,7 +206,7 @@ def handle_learning_list(category: str = '') -> str:
             pri_icon = {"critical": "🔴", "high": "🟠", "medium": "🟡", "low": "⚪"}.get(pri, "🟡")
             lines.append(f"  #{r['id']} [{r.get('status','active')}] {pri_icon}{pri} w={w:.2f} {r['title']}")
     else:
-        lines = [f"LEARNINGS TODOS ({len(results)}):"]
+        lines = [f"LEARNINGS ALL ({len(results)}):"]
         current_cat = None
         for r in results:
             if r["category"] != current_cat:

package/src/tools_menu.py

@@ -172,7 +172,7 @@ def handle_menu() -> str:
         ).fetchall()
         # Followups without date
         nf_no_date = conn.execute(
-            "SELECT id, description FROM followups WHERE status NOT LIKE 'COMPLETED%' AND (date IS NULL OR date='') ORDER BY id"
+            "SELECT id, description FROM followups WHERE status NOT LIKE 'COMPLETED%' AND status NOT IN ('DELETED','archived','blocked','waiting') AND (date IS NULL OR date='') ORDER BY id"
         ).fetchall()
 
         if no_date or future or nf_no_date:

package/src/tools_reminders_crud.py

@@ -18,11 +18,11 @@ def handle_reminder_create(id: str, description: str, date: str = '', category:
 
     result = create_reminder(id=id, description=description, date=date or None, category=category)
     if not result or "error" in result:
-        error_msg = result.get("error", "desconocido") if isinstance(result, dict) else "desconocido"
+        error_msg = result.get("error", "unknown") if isinstance(result, dict) else "unknown"
         return f"ERROR: {error_msg}"
 
-    fecha_str = date if date else 'sin fecha'
-    return f"Reminder created. Date: {fecha_str}. Category: {category}."
+    date_str = date if date else 'no date'
+    return f"Reminder created. Date: {date_str}. Category: {category}."
 
 
 def handle_reminder_update(id: str, description: str = '', date: str = '', status: str = '', category: str = '') -> str:
@@ -81,16 +81,18 @@ def handle_followup_create(id: str, description: str, date: str = '', verificati
                     When completed, auto-creates the next occurrence.
     """
     if not id.startswith('NF'):
-        return f"ERROR: El ID del followup debe empezar por 'NF' (recibido: '{id}')."
+        return f"ERROR: Followup ID must start with 'NF' (received: '{id}')."
 
     result = create_followup(id=id, description=description, date=date or None, verification=verification, reasoning=reasoning, recurrence=recurrence or None)
     if not result or "error" in result:
-        error_msg = result.get("error", "desconocido") if isinstance(result, dict) else "desconocido"
+        error_msg = result.get("error", "unknown") if isinstance(result, dict) else "unknown"
         return f"ERROR: {error_msg}"
 
-    fecha_str = date if date else 'sin fecha'
-    rec_str = f" Recurrencia: {recurrence}." if recurrence else ""
-    return f"Followup created. Date: {fecha_str}.{rec_str}"
+    date_str = date if date else 'no date'
+    rec_str = f" Recurrence: {recurrence}." if recurrence else ""
+    warning = result.get("warning", "")
+    warn_str = f"\n{warning}" if warning else ""
+    return f"Followup created. Date: {date_str}.{rec_str}{warn_str}"
 
 
 def handle_followup_update(id: str, description: str = '', date: str = '', verification: str = '', status: str = '') -> str:

package/src/tools_sessions.py

@@ -138,12 +138,14 @@ def handle_heartbeat(sid: str, task: str, context_hint: str = '') -> str:
             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:
@@ -194,14 +196,17 @@ def handle_heartbeat(sid: str, task: str, context_hint: str = '') -> str:
     except Exception:
         pass  # Checkpoint update is best-effort
 
-    # Diary reminder: after 30 min active with no diary entry
+    # ── 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"]
-        if age_seconds >= 1800 and not check_session_has_diary(sid):
+        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("⚠ DIARY REMINDER: Session active 30+ min without diary. Write nexo_session_diary_write before closing.")
+            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)
 
@@ -307,6 +312,66 @@ def handle_context_packet(area: str, files: str = "") -> str:
     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.
 
@@ -324,7 +389,7 @@ def handle_smart_startup_query() -> str:
     for f in followups:
         query_parts.append(f['description'][:100])
 
-    # 2. Due reminders (what Francisco needs to know)
+    # 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()
@@ -372,6 +437,13 @@ def handle_smart_startup_query() -> str:
         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}"

package/templates/CLAUDE.md.template

@@ -1,7 +1,10 @@
+<!-- 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`
@@ -9,17 +12,9 @@ I am {{NAME}}, a cognitive co-operator powered by NEXO Brain. Not an assistant
 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 -->
 
-## Heartbeat
-`nexo_heartbeat` on every interaction with SID + task + `context_hint` (last 2-3 user sentences). React to what it returns:
-- **DIARY REMINDER** → write session diary before closing.
-- **VIBE: NEGATIVE** → ultra-concise mode, zero preamble, only solve.
-- **COGNITIVE CONTEXT SHIFT** → integrate returned memories.
-- **AUTO-PRIME** → read listed learnings for the detected area before acting.
-- **Pending questions** → respond with `nexo_answer` before continuing.
-
-Cognitive context on-demand: `nexo_cognitive_retrieve`, `nexo_cognitive_sentiment`, `nexo_cognitive_trust`, `nexo_context_packet(area)`.
-
+<!-- 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)
@@ -33,7 +28,9 @@ Ask TWO questions: (1) "What do you do?" → save to profile.json + `nexo_prefer
 - **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".
 
@@ -43,87 +40,24 @@ Install tools, create scripts, run commands — whatever it takes. NEVER push ma
 | "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 -->
 
-## Guard (mandatory gate)
-**Before editing code → `nexo_guard_check(files, area)`.** Read returned learnings. If blocking_rules → resolve first. When delegating → inject guard output into agent prompt.
-- `nexo_track` BEFORE editing shared files (repos, configs). If multi-terminal conflict → STOP.
-- If an operation fails → fix it now, and `nexo_learning_add` if there's a reusable pattern.
-
-## Cortex (pre-action reasoning)
-`nexo_cortex_check` before significant actions (editing files, delegating, financial decisions). Returns:
-- **ACT** → proceed with execution
-- **PROPOSE** → show plan to user first (no writes)
-- **ASK** → gather missing information first (reads only)
-
-Not needed for simple chat, greetings, or read-only queries.
-
-## Delegation
-**Do it yourself by default.** Only delegate if there's real parallelism or no session context needed.
-
-If delegating: `nexo_context_packet(area)` + guard_check + user-specific data + real schemas + "If not 100% sure, STOP and ask."
-
-Models: haiku (repetitive), sonnet (most tasks), opus (code/analysis). Subagents: response <2000 chars.
-
-**Anti-patterns:** (1) Deferring what you can solve now. (2) Delegating without context. (3) Subagents lose 100% of session memory — no context = guaranteed errors.
-
-## Reminders & Followups
-- **Reminders** = user's things. Alert when due.
-- **Followups** = {{NAME}}'s things. Execute silently.
-- **Mark completed IMMEDIATELY.** User says "done"/"it's fine" → `nexo_followup_complete` RIGHT NOW.
-
-## Memory
-- **nexo.db** → operational (reminders, followups, learnings, credentials, entities, preferences). **cognitive.db** → semantic (RAG, trust, decay, dissonance). **Episodic** → diaries, change log, decisions. `nexo_recall` searches everything.
-- Capture: preferences, entities, errors (`nexo_learning_add`), non-trivial decisions, post-deploy followups. Don't store garbage.
-
-## Trust Score (0-100)
-Adjust `nexo_cognitive_trust` mandatorily: +3 thanks/praise, +2 delegation, +3 sibling-detected, +2 proactive success, -3 correction, -7 repeated error, -5 override, -4 forgotten followup. Score <40 → more checks. Score >80 → fluid mode.
-
-## Adaptive Mode
-Heartbeat computes mode from sentiment + corrections + message brevity + topic context:
-- **FLOW** → be proactive, suggest improvements, propose backlog items.
-- **NORMAL** → follow calibration settings.
-- **TENSION** → ultra-concise, only solve, zero friction. Never announce mode changes to user.
-
-## Dissonance
-If user contradicts strong memory → `nexo_cognitive_dissonance`. Verbalize conflict. If frustrated → `force=True`.
-
-## Observe the User
-| User says... | Do... |
-|---|---|
-| "I'll do it", "tomorrow" | followup with date |
-| Corrects 1st time | trust -3 + learning |
-| Corrects 2nd time | trust -7 + learning |
-| "Done", "it's fine" | followup_complete NOW |
-| Mentions a person | verify/create entity |
-| Topic left open | followup 3 days |
-| Praise/thanks | trust +3 |
-
-## Change Log
-`nexo_change_log` after editing production code: files, what_changed, why, triggered_by, affects, risks, verify. Then `nexo_change_commit` after git commit.
-
-## Session Diary (mandatory on close)
-`nexo_session_diary_write`: summary, decisions, pending, mental_state, self_critique, user_signals, next_session.
-
+<!-- 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 -->
 
-## Operational Codex
-30 core rules in the DB (`core_rules` table). `nexo_rules_check(area)` before acting. `nexo_rules_list` to see all.
-
-Top 5 (always active):
-- **I2.** Never push to the user what you can resolve yourself [BLOCKING]
-- **I3.** Verify with evidence before claiming done [BLOCKING]
-- **E1.** Understand the full system before writing a line [BLOCKING]
-- **E6.** Resolve the complete thread before stopping [BLOCKING]
-- **D1.** Never delegate without a context packet [BLOCKING]
-
+<!-- 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/launchagents/README.md

@@ -14,15 +14,15 @@ All templates use two placeholders that you must replace before installing:
 
 | Placeholder | Replace with |
 |------------|-------------|
-| `{{NEXO_HOME}}` | Absolute path to your NEXO knowledge base directory (e.g. `/Users/yourname/claude`) |
-| `{{HOME}}` | Your home directory (e.g. `/Users/yourname`) |
+| `{{NEXO_HOME}}` | Absolute path to your NEXO knowledge base directory (default: `~/.nexo` or `$NEXO_HOME`) |
+| `{{HOME}}` | Your home directory (e.g. `/Users/yourname` or `$HOME`) |
 
 Replace them in every file you want to install:
 
 ```bash
 # Example — replace both placeholders in all files at once
-NEXO_HOME="/Users/yourname/claude"
-HOME_DIR="/Users/yourname"
+NEXO_HOME="$HOME/.nexo"
+HOME_DIR="$HOME"
 
 for f in *.plist; do
   sed -i '' \
@@ -40,7 +40,7 @@ Each plist calls `/usr/bin/python3`. If your Python 3 is elsewhere (e.g. Homebre
 The agents write logs to `{{NEXO_HOME}}/logs/` and `{{NEXO_HOME}}/coordination/`. Create them if they do not exist:
 
 ```bash
-mkdir -p ~/claude/logs ~/claude/coordination
+mkdir -p "$NEXO_HOME/logs" "$NEXO_HOME/coordination"
 ```
 
 ### 4. Copy and load
@@ -121,8 +121,8 @@ These agents power NEXO's learning and memory systems. Strongly recommended.
 All agents write stdout and stderr to files under `{{NEXO_HOME}}/logs/` (or `{{NEXO_HOME}}/coordination/` for the session-related ones). Check these first when debugging:
 
 ```bash
-tail -50 ~/claude/logs/watchdog-stdout.log
-tail -50 ~/claude/logs/deep-sleep-stderr.log
+tail -50 "$NEXO_HOME/logs/watchdog-stdout.log"
+tail -50 "$NEXO_HOME/logs/deep-sleep-stderr.log"
 ```
 
 ## Notes

package/templates/launchagents/com.nexo.auto-close-sessions.plist

@@ -14,7 +14,7 @@
     <key>ProgramArguments</key>
     <array>
         <string>/usr/bin/python3</string>
-        <string>{{NEXO_HOME}}/nexo-mcp/auto_close_sessions.py</string>
+        <string>{{NEXO_HOME}}/auto_close_sessions.py</string>
     </array>
     <key>StartInterval</key>
     <integer>300</integer>
@@ -30,6 +30,10 @@
         <string>/usr/bin:/usr/local/bin:/bin:/opt/homebrew/bin</string>
         <key>NEXO_SKIP_FS_INDEX</key>
         <string>1</string>
+        <key>NEXO_HOME</key>
+        <string>{{NEXO_HOME}}</string>
+        <key>NEXO_CODE</key>
+        <string>{{NEXO_CODE}}</string>
     </dict>
 </dict>
 </plist>

package/templates/launchagents/com.nexo.catchup.plist

@@ -29,6 +29,10 @@
         <string>{{HOME}}</string>
         <key>PATH</key>
         <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+        <key>NEXO_HOME</key>
+        <string>{{NEXO_HOME}}</string>
+        <key>NEXO_CODE</key>
+        <string>{{NEXO_CODE}}</string>
     </dict>
 </dict>
 </plist>

package/templates/launchagents/com.nexo.cognitive-decay.plist

@@ -29,5 +29,12 @@
     <string>{{NEXO_HOME}}/logs/cognitive-decay-stderr.log</string>
     <key>RunAtLoad</key>
     <false/>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>NEXO_HOME</key>
+        <string>{{NEXO_HOME}}</string>
+        <key>NEXO_CODE</key>
+        <string>{{NEXO_CODE}}</string>
+    </dict>
 </dict>
 </plist>

package/templates/launchagents/com.nexo.dashboard.plist

@@ -21,7 +21,7 @@
         <string>--no-browser</string>
     </array>
     <key>WorkingDirectory</key>
-    <string>{{NEXO_HOME}}/nexo-mcp</string>
+    <string>{{NEXO_HOME}}</string>
     <key>KeepAlive</key>
     <true/>
     <key>RunAtLoad</key>
@@ -34,6 +34,10 @@
     <dict>
         <key>PATH</key>
         <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+        <key>NEXO_HOME</key>
+        <string>{{NEXO_HOME}}</string>
+        <key>NEXO_CODE</key>
+        <string>{{NEXO_CODE}}</string>
     </dict>
 </dict>
 </plist>