nexo-brain 0.8.9 → 0.9.0

package/README.md

@@ -1,16 +1,22 @@
 # NEXO Brain — Your AI Gets a Brain
 
-[![npm v0.8.0](https://img.shields.io/npm/v/nexo-brain?label=npm&color=purple)](https://www.npmjs.com/package/nexo-brain)
+[![npm v0.8.10](https://img.shields.io/npm/v/nexo-brain?label=npm&color=purple)](https://www.npmjs.com/package/nexo-brain)
 [![F1 0.588 on LoCoMo](https://img.shields.io/badge/LoCoMo_F1-0.588-brightgreen)](https://github.com/wazionapps/nexo/blob/main/benchmarks/locomo/results/)
 [![+55% vs GPT-4](https://img.shields.io/badge/vs_GPT--4-%2B55%25-blue)](https://github.com/snap-research/locomo/issues/33)
 [![GitHub stars](https://img.shields.io/github/stars/wazionapps/nexo?style=social)](https://github.com/wazionapps/nexo/stargazers)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-> **v0.8.0** — Knowledge Graph (988 bi-temporal nodes, D3 visualization), Web Dashboard (6 pages at localhost:6174), Cross-Platform support (Linux + Windows), Smart dedup with event-sourced edges, and 4 new KG tools.
+> **v0.8.10** — Knowledge Graph (988 bi-temporal nodes, D3 visualization), Web Dashboard (6 pages at localhost:6174), Cross-Platform support (Linux + Windows + WSL), Session keepalive, PEP 668 compliance, full English translation, and 4 new KG tools.
 
 **NEXO Brain transforms any MCP-compatible AI agent from a stateless assistant into a cognitive partner that remembers, learns, forgets, adapts, and builds a relationship with you over time.**
 
-[Watch the overview on YouTube](https://www.youtube.com/watch?v=-uvhicUhGTY)
+<p align="center">
+  <a href="https://www.youtube.com/watch?v=J0hCWnYU4UY">
+    <img src="assets/nexo-brain-infographic-v4.png" alt="NEXO Brain Architecture" width="700">
+  </a>
+</p>
+
+[Watch the 1-minute overview on YouTube](https://www.youtube.com/watch?v=J0hCWnYU4UY) · [Watch the full deep-dive](https://www.youtube.com/watch?v=-uvhicUhGTY)
 
 Every time you close a session, everything is lost. Your agent doesn't remember yesterday's decisions, repeats the same mistakes, and starts from zero. NEXO Brain fixes this with a cognitive architecture modeled after how human memory actually works.
 
@@ -257,7 +263,7 @@ npx nexo-brain  # detects v0.5.0, migrates automatically
 - **Never touches your data** (memories, learnings, preferences)
 - Saves updated CLAUDE.md as reference (doesn't overwrite customizations)
 
-## Knowledge Graph & Dashboard (v0.8.0)
+## Knowledge Graph & Dashboard (v0.8)
 
 ### Knowledge Graph
 A bi-temporal entity-relationship graph with 988 nodes and 896 edges. Entities and relationships carry both valid-time (when the fact was true) and system-time (when it was recorded), enabling temporal queries like "what did we know about X last Tuesday?". BFS traversal discovers multi-hop connections between concepts. Event-sourced edges with smart dedup (ADD/UPDATE/NOOP) prevent redundant writes while preserving full history.
@@ -268,7 +274,9 @@ A bi-temporal entity-relationship graph with 988 nodes and 896 edges. Entities a
 A visual interface at `localhost:6174` with 6 pages: Overview (system health at a glance), Graph (interactive D3.js visualization of the knowledge graph), Memory (browse and search all memory stores), Somatic (pain map per file/area), Adaptive (personality signals and weights), and Sessions (active and historical sessions). Built with FastAPI backend and D3.js frontend.
 
 ### Cross-Platform Support
-v0.8.0 adds full Linux and Windows support. The installer detects the platform and configures the appropriate process manager (LaunchAgents on macOS, systemd on Linux, Task Scheduler on Windows). Opportunistic maintenance runs cognitive processes when resources are available.
+Full Linux support and Windows via WSL. The installer detects the platform and configures the appropriate process manager (LaunchAgents on macOS, catch-up on startup for Linux). PEP 668 compliance (venv on Ubuntu 24.04+). Session keepalive prevents phantom sessions during long tasks. Opportunistic maintenance runs cognitive processes when resources are available.
+
+> **Windows users:** NEXO Brain requires [WSL (Windows Subsystem for Linux)](https://learn.microsoft.com/en-us/windows/wsl/install). Install WSL first, then run `npx nexo-brain` inside the Ubuntu/WSL terminal.
 
 ### Storage Router
 A new abstraction layer routes storage operations through a unified interface, making the system multi-tenant ready. Each operator's data is isolated while sharing the same cognitive engine.
@@ -343,7 +351,7 @@ That's it. No need to run `claude` manually. Atlas will greet you immediately
 
 ### Requirements
 
-- **macOS, Linux, or Windows**
+- **macOS or Linux** (Windows via [WSL](https://learn.microsoft.com/en-us/windows/wsl/install))
 - **Node.js 18+** (for the installer)
 - **Claude Opus (latest version) strongly recommended.** NEXO Brain provides 109+ MCP tools across 19 categories. This cognitive load requires a top-tier model with large context window. Smaller models (Haiku, Sonnet) may struggle with tool selection and produce inconsistent results. Opus handles all 109+ tools without hesitation.
 - Python 3, Homebrew, and Claude Code are installed automatically if missing.

package/bin/nexo-brain.js

@@ -77,8 +77,14 @@ async function main() {
 
   // Check prerequisites
   const platform = process.platform;
-  if (platform !== "darwin" && platform !== "linux" && platform !== "win32") {
-    log(`Unsupported platform: ${platform}. NEXO supports macOS, Linux, and Windows.`);
+  if (platform === "win32") {
+    log("Windows detected. NEXO Brain requires WSL (Windows Subsystem for Linux).");
+    log("Install WSL: https://learn.microsoft.com/en-us/windows/wsl/install");
+    log("Then run this command inside WSL (Ubuntu terminal), not PowerShell/CMD.");
+    process.exit(1);
+  }
+  if (platform !== "darwin" && platform !== "linux") {
+    log(`Unsupported platform: ${platform}. NEXO supports macOS and Linux (Windows via WSL).`);
     process.exit(1);
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "0.8.9",
+  "version": "0.9.0",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO — Cognitive co-operator for Claude Code. Atkinson-Shiffrin memory, semantic RAG, trust scoring, and metacognitive error prevention.",
   "bin": {

package/src/db.py

@@ -898,6 +898,36 @@ def _m8_adaptive_log_and_somatic(conn):
     conn.execute("CREATE INDEX IF NOT EXISTS idx_somatic_events_projected ON somatic_events(projected)")
 
 
+def _m10_diary_archive(conn):
+    """Permanent diary archive — diaries are never truly deleted, just moved here."""
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS diary_archive (
+            id INTEGER PRIMARY KEY,
+            session_id TEXT NOT NULL,
+            created_at TEXT NOT NULL,
+            decisions TEXT NOT NULL,
+            discarded TEXT,
+            pending TEXT,
+            context_next TEXT,
+            summary TEXT NOT NULL,
+            mental_state TEXT,
+            domain TEXT,
+            user_signals TEXT,
+            self_critique TEXT DEFAULT '',
+            source TEXT DEFAULT 'claude',
+            archived_at TEXT DEFAULT (datetime('now'))
+        )
+    """)
+    conn.execute("""
+        CREATE INDEX IF NOT EXISTS idx_diary_archive_created
+        ON diary_archive (created_at)
+    """)
+    conn.execute("""
+        CREATE INDEX IF NOT EXISTS idx_diary_archive_domain
+        ON diary_archive (domain)
+    """)
+
+
 def _m9_maintenance_schedule(conn):
     conn.execute("""
         CREATE TABLE IF NOT EXISTS maintenance_schedule (
@@ -931,6 +961,7 @@ MIGRATIONS = [
     (7, "diary_source_and_draft", _m7_diary_source_and_draft),
     (8, "adaptive_log_and_somatic", _m8_adaptive_log_and_somatic),
     (9, "maintenance_schedule", _m9_maintenance_schedule),
+    (10, "diary_archive", _m10_diary_archive),
 ]
 
 
@@ -1763,7 +1794,12 @@ def delete_credential(service: str, key: str = None) -> bool:
 
 
 def get_credential(service: str, key: str = None) -> list[dict]:
-    """Get credential(s). If key=None, return all for the service."""
+    """Get credential(s). If key=None, return all for the service.
+
+    When exact match fails, performs fuzzy search across service, key,
+    and notes fields. Returns results tagged with _fuzzy=True so
+    the caller can differentiate suggestions from exact hits.
+    """
     conn = get_db()
     if key:
         rows = conn.execute(
@@ -1773,7 +1809,29 @@ def get_credential(service: str, key: str = None) -> list[dict]:
         rows = conn.execute(
             "SELECT * FROM credentials WHERE service = ?", (service,)
         ).fetchall()
-    return [dict(r) for r in rows]
+    if rows:
+        return [dict(r) for r in rows]
+
+    # Fuzzy fallback: search term in service, key and notes (not value — too noisy)
+    # Prioritize: service/key matches first, notes-only matches second
+    term = f"%{service}%"
+    fuzzy_rows = conn.execute(
+        "SELECT *, "
+        "CASE WHEN service LIKE ? THEN 0 "
+        "     WHEN key LIKE ? THEN 1 "
+        "     ELSE 2 END AS _rank "
+        "FROM credentials WHERE "
+        "service LIKE ? OR key LIKE ? OR notes LIKE ? "
+        "ORDER BY _rank ASC, service ASC, key ASC",
+        (term, term, term, term, term),
+    ).fetchall()
+    results = []
+    for r in fuzzy_rows:
+        d = dict(r)
+        d["_fuzzy"] = True
+        d.pop("_rank", None)
+        results.append(d)
+    return results
 
 
 def list_credentials(service: str = None) -> list[dict]:
@@ -2262,15 +2320,37 @@ def search_decisions(query: str = '', domain: str = '', days: int = 30) -> list[
 # ── Session Diary ────────────────────────────────────────────────
 
 def cleanup_old_diaries(retention_days: int = 180) -> int:
-    """Delete session_diary entries older than retention_days. Returns count deleted."""
+    """Archive then delete session_diary entries older than retention_days.
+
+    Diaries are moved to diary_archive (permanent) before being removed from
+    the active session_diary table. Nothing is ever truly lost.
+    """
     conn = get_db()
+    cutoff = f"-{retention_days} days"
+
+    # Archive before deleting — permanent subconscious memory
+    try:
+        conn.execute("""
+            INSERT OR IGNORE INTO diary_archive
+                (id, session_id, created_at, decisions, discarded, pending,
+                 context_next, summary, mental_state, domain, user_signals,
+                 self_critique, source)
+            SELECT id, session_id, created_at, decisions, discarded, pending,
+                   context_next, summary, mental_state, domain, user_signals,
+                   self_critique, source
+            FROM session_diary
+            WHERE created_at < datetime('now', ?)
+        """, (cutoff,))
+    except Exception:
+        pass  # Table may not exist yet (pre-migration)
+
     ids = [str(r[0]) for r in conn.execute(
         "SELECT id FROM session_diary WHERE created_at < datetime('now', ?)",
-        (f"-{retention_days} days",)
+        (cutoff,)
     ).fetchall()]
     cursor = conn.execute(
         "DELETE FROM session_diary WHERE created_at < datetime('now', ?)",
-        (f"-{retention_days} days",)
+        (cutoff,)
     )
     for did in ids:
         conn.execute("DELETE FROM unified_search WHERE source = 'diary' AND source_id = ?", (did,))
@@ -2309,6 +2389,99 @@ def check_session_has_diary(session_id: str) -> bool:
     return row is not None
 
 
+# ── Diary Archive (permanent subconscious) ──────────────────────
+
+
+def diary_archive_search(query: str = '', domain: str = '',
+                         year: int = 0, month: int = 0,
+                         limit: int = 20) -> list[dict]:
+    """Search the permanent diary archive. Supports text search, domain filter, and date filter.
+
+    Args:
+        query: Text to search in summary, decisions, mental_state, pending
+        domain: Filter by domain (e.g. 'wazion', 'my-store')
+        year: Filter by year (e.g. 2026)
+        month: Filter by month (1-12), requires year
+        limit: Max results (default 20)
+    """
+    conn = get_db()
+    try:
+        conn.execute("SELECT 1 FROM diary_archive LIMIT 1")
+    except Exception:
+        return []  # Table doesn't exist yet
+
+    conditions = []
+    params = []
+
+    if query:
+        words = query.strip().split()
+        for word in words:
+            conditions.append(
+                "(summary LIKE ? OR decisions LIKE ? OR mental_state LIKE ? "
+                "OR pending LIKE ? OR self_critique LIKE ?)"
+            )
+            w = f"%{word}%"
+            params.extend([w, w, w, w, w])
+
+    if domain:
+        conditions.append("domain = ?")
+        params.append(domain)
+
+    if year:
+        if month:
+            date_start = f"{year:04d}-{month:02d}-01"
+            if month == 12:
+                date_end = f"{year + 1:04d}-01-01"
+            else:
+                date_end = f"{year:04d}-{month + 1:02d}-01"
+            conditions.append("created_at >= ? AND created_at < ?")
+            params.extend([date_start, date_end])
+        else:
+            conditions.append("created_at >= ? AND created_at < ?")
+            params.extend([f"{year:04d}-01-01", f"{year + 1:04d}-01-01"])
+
+    where = " AND ".join(conditions) if conditions else "1=1"
+
+    rows = conn.execute(f"""
+        SELECT id, session_id, created_at, summary, decisions, domain,
+               mental_state, pending, self_critique, source
+        FROM diary_archive
+        WHERE {where}
+        ORDER BY created_at DESC
+        LIMIT ?
+    """, params + [limit]).fetchall()
+    return [dict(r) for r in rows]
+
+
+def diary_archive_read(diary_id: int) -> dict | None:
+    """Read a single archived diary entry by ID — full content."""
+    conn = get_db()
+    try:
+        row = conn.execute(
+            "SELECT * FROM diary_archive WHERE id = ?", (diary_id,)
+        ).fetchone()
+        return dict(row) if row else None
+    except Exception:
+        return None
+
+
+def diary_archive_stats() -> dict:
+    """Get archive statistics: count, date range, domains."""
+    conn = get_db()
+    try:
+        count = conn.execute("SELECT COUNT(*) FROM diary_archive").fetchone()[0]
+        if count == 0:
+            return {"count": 0, "oldest": None, "newest": None, "domains": []}
+        oldest = conn.execute("SELECT MIN(created_at) FROM diary_archive").fetchone()[0]
+        newest = conn.execute("SELECT MAX(created_at) FROM diary_archive").fetchone()[0]
+        domains = [r[0] for r in conn.execute(
+            "SELECT DISTINCT domain FROM diary_archive WHERE domain IS NOT NULL AND domain != '' ORDER BY domain"
+        ).fetchall()]
+        return {"count": count, "oldest": oldest, "newest": newest, "domains": domains}
+    except Exception:
+        return {"count": 0, "oldest": None, "newest": None, "domains": []}
+
+
 # ── Session Diary Drafts ─────────────────────────────────────────
 
 

package/src/plugins/episodic_memory.py

@@ -163,11 +163,11 @@ def handle_memory_review_queue(days: int = 0) -> str:
 def handle_session_diary_write(decisions: str, summary: str,
                                 discarded: str = '', pending: str = '',
                                 context_next: str = '', mental_state: str = '',
-                                francisco_signals: str = '',
+                                user_signals: str = '',
                                 domain: str = '',
                                 session_id: str = '',
                                 self_critique: str = '') -> str:
-    """Write session diary entry at end of session. OBLIGATORIO antes de cerrar.
+    """Write session diary entry at end of session. Mandatory before closing.
 
     Args:
         decisions: What was decided and why (JSON array or structured text)
@@ -176,16 +176,16 @@ def handle_session_diary_write(decisions: str, summary: str,
         pending: Items left unresolved, with doubt level
         context_next: What the next session should know to continue effectively
         mental_state: Internal state to transfer — thread of thought, tone, observations not yet shared, momentum. Written in first person as NEXO.
-        francisco_signals: Observable signals from Francisco during session — response speed (fast='s' vs detailed explanations), tone (direct, frustrated, exploratory, excited), corrections given, topics he initiated vs topics NEXO initiated. Factual observations only, not interpretations.
-        domain: Project context: recambios, wazion, nexo, canarirural, server, other
+        user_signals: Observable signals from the user during session — response speed (fast='s' vs detailed explanations), tone (direct, frustrated, exploratory, excited), corrections given, topics they initiated vs topics NEXO initiated. Factual observations only, not interpretations.
+        domain: Project context (e.g. project name, area)
         session_id: Current session ID
-        self_critique: MANDATORY. Honest post-mortem: What should I have done proactively? Did Francisco ask for something I should have detected? Did I repeat known errors? What concrete rule would prevent the recurrence? If clean session: 'No self-critique — clean session.'
+        self_critique: MANDATORY. Honest post-mortem: What should I have done proactively? Did the user ask for something I should have detected? Did I repeat known errors? What concrete rule would prevent the recurrence? If clean session: 'No self-critique — clean session.'
     """
     sid = session_id or 'unknown'
     # Clean up draft — manual diary supersedes it
     from db import delete_diary_draft
     delete_diary_draft(sid)
-    result = write_session_diary(sid, decisions, summary, discarded, pending, context_next, mental_state, domain=domain, user_signals=francisco_signals, self_critique=self_critique)
+    result = write_session_diary(sid, decisions, summary, discarded, pending, context_next, mental_state, domain=domain, user_signals=user_signals, self_critique=self_critique)
     if "error" in result:
         return f"ERROR: {result['error']}"
     _cognitive_ingest_safe(summary, "diary", f"diary#{result.get('id','')}", f"Session {sid} summary", domain)
@@ -256,8 +256,8 @@ def handle_session_diary_read(session_id: str = '', last_n: int = 3, last_day: b
             lines.append(f"  For next session: {d['context_next'][:200]}")
         if d.get('mental_state'):
             lines.append(f"  Mental state: {d['mental_state'][:300]}")
-        if d.get('francisco_signals'):
-            lines.append(f"  Francisco signals: {d['francisco_signals'][:300]}")
+        if d.get('user_signals'):
+            lines.append(f"  User signals: {d['user_signals'][:300]}")
     return "\n".join(lines)
 
 
@@ -271,7 +271,7 @@ def handle_change_log(files: str, what_changed: str, why: str,
         files: File path(s) modified (comma-separated if multiple)
         what_changed: What was modified — functions, lines, behavior change
         why: WHY this change was needed — the root cause, not just "fix bug"
-        triggered_by: What triggered this — bug report, metric, Francisco's request, followup ID
+        triggered_by: What triggered this — bug report, metric, user request, followup ID
         affects: What systems/users/flows this change impacts
         risks: What could go wrong — regressions, edge cases, dependencies
         verify: How to verify this works — what to check, followup ID if created
@@ -351,8 +351,18 @@ def handle_recall(query: str, days: int = 30) -> str:
         days: Look back N days (default 30)
     """
     results = recall(query, days)
-    if not results:
-        return f"No results for '{query}' in the last {days} days."
+
+    # Fallback to diary archive if few results (subconscious memory)
+    archive_results = []
+    if len(results) < 5:
+        try:
+            from db import diary_archive_search
+            archive_results = diary_archive_search(query=query, limit=5)
+        except Exception:
+            pass
+
+    if not results and not archive_results:
+        return f"No results for '{query}' in the last {days} days or in the archive."
 
     # v1.2: Passive rehearsal — strengthen matching cognitive memories
     try:
@@ -365,18 +375,19 @@ def handle_recall(query: str, days: int = 30) -> str:
         pass
 
     SOURCE_LABELS = {
-        'change_log': '[CAMBIO]',
-        'change':     '[CAMBIO]',
+        'change_log': '[CHANGE]',
+        'change':     '[CHANGE]',
         'decision':   '[DECISION]',
         'learning':   '[LEARNING]',
         'followup':   '[FOLLOWUP]',
-        'diary':      '[DIARIO]',
-        'entity':     '[ENTIDAD]',
-        'file':       '[ARCHIVO]',
+        'diary':      '[DIARY]',
+        'diary_archive': '[ARCHIVE]',
+        'entity':     '[ENTITY]',
+        'file':       '[FILE]',
         'code':       '[CODE]',
     }
 
-    lines = [f"RECALL '{query}' — {len(results)} resultado(s):"]
+    lines = [f"RECALL '{query}' — {len(results)} result(s):"]
     for r in results:
         source = r.get('source', '?')
         label = SOURCE_LABELS.get(source, f"[{source.upper()}]")
@@ -389,8 +400,93 @@ def handle_recall(query: str, days: int = 30) -> str:
         lines.append(f"    {title}")
         if snippet:
             lines.append(f"    {snippet}")
-    if len(results) < 5:
-        lines.append(f"\n  💡 Only {len(results)} results in NEXO. For deeper history, also search claude-mem: mcp__plugin_claude-mem_mcp-search__search")
+
+    if archive_results:
+        lines.append(f"\n--- SUBCONSCIOUS (diary archive) — {len(archive_results)} result(s) ---")
+        for r in archive_results:
+            lines.append(f"\n  [ARCHIVE] #{r['id']} ({r['created_at'][:10]}) [{r.get('domain', '?')}]")
+            lines.append(f"    {r['summary'][:200]}")
+    elif len(results) < 5:
+        lines.append(f"\n  Only {len(results)} results. Diary archive empty (auto-populated after 180 days).")
+    return "\n".join(lines)
+
+
+def handle_diary_archive_search(
+    query: str = "",
+    domain: str = "",
+    year: int = 0,
+    month: int = 0,
+    limit: int = 20
+) -> str:
+    """Search the permanent diary archive (subconscious memory). Use for 'last year', 'months ago', 'in February', etc.
+
+    Args:
+        query: Text to search in diary content
+        domain: Filter by project domain (e.g. 'wazion', 'my-store')
+        year: Filter by year (e.g. 2026)
+        month: Filter by month (1-12), requires year
+        limit: Max results (default 20)
+    """
+    from db import diary_archive_search, diary_archive_stats
+
+    if not query and not domain and not year:
+        stats = diary_archive_stats()
+        if stats["count"] == 0:
+            return "Archive empty — diaries are archived automatically after 180 days."
+        return (
+            f"DIARY ARCHIVE STATS:\n"
+            f"  Total: {stats['count']} archived diaries\n"
+            f"  Range: {stats['oldest']} -> {stats['newest']}\n"
+            f"  Domains: {', '.join(stats['domains']) if stats['domains'] else 'N/A'}\n"
+            f"\nUse query, domain, year/month to search."
+        )
+
+    results = diary_archive_search(query=query, domain=domain, year=year, month=month, limit=limit)
+    if not results:
+        return f"No results in archive for: query='{query}' domain='{domain}' year={year} month={month}"
+
+    lines = [f"DIARY ARCHIVE — {len(results)} result(s):"]
+    for r in results:
+        lines.append(f"\n  [#{r['id']}] {r['created_at'][:10]} [{r.get('domain', '?')}]")
+        lines.append(f"    {r['summary'][:200]}")
+        if r.get('decisions'):
+            lines.append(f"    Decisions: {r['decisions'][:150]}")
+        if r.get('mental_state'):
+            lines.append(f"    State: {r['mental_state'][:100]}")
+    return "\n".join(lines)
+
+
+def handle_diary_archive_read(diary_id: int = 0) -> str:
+    """Read a single archived diary entry in full detail.
+
+    Args:
+        diary_id: The archive diary ID (from search results)
+    """
+    if not diary_id:
+        return "ERROR: diary_id required. Use nexo_diary_archive_search to find IDs."
+
+    from db import diary_archive_read
+    entry = diary_archive_read(diary_id)
+    if not entry:
+        return f"Diary #{diary_id} not found in the archive."
+
+    lines = [f"DIARY ARCHIVE #{entry['id']} — {entry['created_at']}"]
+    lines.append(f"  Session: {entry['session_id']}")
+    lines.append(f"  Domain: {entry.get('domain', 'N/A')}")
+    lines.append(f"  Source: {entry.get('source', 'N/A')}")
+    lines.append(f"\nSUMMARY:\n  {entry['summary']}")
+    if entry.get('decisions'):
+        lines.append(f"\nDECISIONS:\n  {entry['decisions']}")
+    if entry.get('pending'):
+        lines.append(f"\nPENDING:\n  {entry['pending']}")
+    if entry.get('mental_state'):
+        lines.append(f"\nMENTAL STATE:\n  {entry['mental_state']}")
+    if entry.get('self_critique'):
+        lines.append(f"\nSELF-CRITIQUE:\n  {entry['self_critique']}")
+    if entry.get('user_signals'):
+        lines.append(f"\nUSER SIGNALS:\n  {entry['user_signals']}")
+    if entry.get('context_next'):
+        lines.append(f"\nCONTEXT FOR NEXT SESSION:\n  {entry['context_next']}")
     return "\n".join(lines)
 
 
@@ -404,5 +500,7 @@ TOOLS = [
     (handle_memory_review_queue, "nexo_memory_review_queue", "Show decisions and learnings that are due for review"),
     (handle_session_diary_write, "nexo_session_diary_write", "Write end-of-session diary with decisions, discards, and context for next session"),
     (handle_session_diary_read, "nexo_session_diary_read", "Read recent session diaries for context continuity"),
-    (handle_recall, "nexo_recall", "Search across ALL NEXO memory — changes, decisions, learnings, followups, diary, entities, .md files, code files. For deep historical context (older sessions, past work), also search claude-mem (mcp__plugin_claude-mem_mcp-search__search)."),
+    (handle_recall, "nexo_recall", "Search across ALL NEXO memory — changes, decisions, learnings, followups, diary, entities, .md files, code files. For deep historical context (older sessions, past work), also searches the diary archive."),
+    (handle_diary_archive_search, "nexo_diary_archive_search", "Search the permanent diary archive (subconscious memory). Diaries older than 180d are moved here forever. Use for historical lookups: 'last year', 'months ago', 'in February', etc."),
+    (handle_diary_archive_read, "nexo_diary_archive_read", "Read a single archived diary entry in full detail. Get the ID from diary_archive_search."),
 ]

package/src/tools_credentials.py

@@ -9,7 +9,11 @@ def handle_credential_get(service: str, key: str = '') -> str:
     if not results:
         target = f"{service}/{key}" if key else service
         return f"ERROR: No credentials found for '{target}'."
+    is_fuzzy = any(r.get("_fuzzy") for r in results)
     lines = []
+    if is_fuzzy:
+        lines.append(f"No exact match for '{service}'. Similar results ({len(results)}):")
+        lines.append("")
     for r in results:
         lines.append(f"CREDENTIAL {r['service']}/{r['key']}:")
         lines.append(f"  Value: {r['value']}")