nexo-brain 0.8.10 → 0.10.0-beta.1

package/README.md

@@ -1,12 +1,14 @@
 # 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.9.0](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.10.0-beta.1** — Artifact Registry (structured recall for services, dashboards, scripts), Retrieval Ladder (alias → port → path → fuzzy → semantic), User-Language Alias Learning. Plus everything from v0.9.0.
+>
+> Install beta: `npx nexo-brain@beta` | Stable: `npx nexo-brain`
 
 **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.**
 
@@ -16,7 +18,7 @@
   </a>
 </p>
 
-[Watch the 1-minute overview on YouTube](https://www.youtube.com/watch?v=J0hCWnYU4UY)
+[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.
 
@@ -263,7 +265,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.
@@ -274,7 +276,7 @@ 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 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). 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.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "0.8.10",
+  "version": "0.10.0-beta.1",
   "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/cognitive.py

@@ -30,13 +30,13 @@ DISCRIMINATING_ENTITIES = {
     # OS / Environment
     "linux", "mac", "macos", "windows", "darwin", "ubuntu", "debian", "alpine",
     # Platforms
-    "shopify", "wazion", "canarirural", "recambios", "whatsapp", "chrome", "firefox",
+    "shopify", "wazion", "project-a", "project-b", "whatsapp", "chrome", "firefox",
     # Languages / Runtimes
     "python", "php", "javascript", "typescript", "node", "deno", "ruby",
     # Versions
     "v1", "v2", "v3", "v4", "v5", "5.6", "7.4", "8.0", "8.1", "8.2",
     # Infrastructure
-    "mundiserver", "cloudrun", "gcloud", "vps", "local", "production", "staging",
+    "server", "cloudrun", "gcloud", "vps", "local", "production", "staging",
     # DB
     "mysql", "sqlite", "postgresql", "postgres", "redis",
 }

package/src/db.py

@@ -898,6 +898,85 @@ 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 _m11_artifact_registry(conn):
+    """Artifact Registry — structured index of things the agent creates/deploys.
+
+    Solves 'recent work amnesia': agents build services, dashboards, scripts, APIs
+    but can't find them hours later because semantic search fails on operational
+    vocabulary mismatches (e.g., 'backend' vs 'FastAPI localhost:6174').
+
+    Design informed by multi-AI debate (GPT-5.4 + Gemini 3.1 Pro + Claude Opus 4.6).
+    """
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS artifact_registry (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            kind TEXT NOT NULL,
+            canonical_name TEXT NOT NULL,
+            aliases TEXT DEFAULT '[]',
+            description TEXT DEFAULT '',
+            uri TEXT DEFAULT '',
+            ports TEXT DEFAULT '[]',
+            paths TEXT DEFAULT '[]',
+            run_cmd TEXT DEFAULT '',
+            repo TEXT DEFAULT '',
+            domain TEXT DEFAULT '',
+            state TEXT DEFAULT 'active',
+            session_id TEXT DEFAULT '',
+            created_at TEXT DEFAULT (datetime('now')),
+            last_touched_at TEXT DEFAULT (datetime('now')),
+            last_verified_at TEXT DEFAULT NULL,
+            metadata TEXT DEFAULT '{}'
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS artifact_aliases (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            artifact_id INTEGER NOT NULL REFERENCES artifact_registry(id) ON DELETE CASCADE,
+            phrase TEXT NOT NULL,
+            source TEXT DEFAULT 'manual',
+            confidence REAL DEFAULT 1.0,
+            created_at TEXT DEFAULT (datetime('now')),
+            UNIQUE(artifact_id, phrase)
+        )
+    """)
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_artifact_state ON artifact_registry(state)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_artifact_kind ON artifact_registry(kind)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_artifact_domain ON artifact_registry(domain)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_artifact_last_touched ON artifact_registry(last_touched_at)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_artifact_aliases_phrase ON artifact_aliases(phrase)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_artifact_aliases_aid ON artifact_aliases(artifact_id)")
+
+
 def _m9_maintenance_schedule(conn):
     conn.execute("""
         CREATE TABLE IF NOT EXISTS maintenance_schedule (
@@ -931,6 +1010,8 @@ 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),
+    (11, "artifact_registry", _m11_artifact_registry),
 ]
 
 
@@ -1763,7 +1844,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 +1859,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 +2370,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 +2439,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/artifact_registry.py

@@ -0,0 +1,450 @@
+"""Artifact Registry plugin — structured index of things NEXO creates/deploys.
+
+Solves 'recent work amnesia': NEXO builds services, dashboards, scripts, APIs
+but can't find them hours later because semantic search ('backend') doesn't
+match operational terms ('FastAPI localhost:6174').
+
+Architecture (from 3-way AI debate — GPT-5.4 + Gemini 3.1 Pro + Claude Opus 4.6):
+1. Structured SQLite table with aliases, ports, paths, run commands
+2. Retrieval ladder: exact alias → port/path match → fuzzy token → semantic fallback
+3. User-language alias learning: when the user says 'backend' and it resolves
+   to dashboard:6174, store that mapping for O(1) next time
+4. Temporal filtering: 'last night' → hard SQL constraint before any search
+"""
+
+import json
+import datetime
+from db import get_db
+
+
+# Valid artifact kinds
+VALID_KINDS = {
+    'service', 'dashboard', 'script', 'api', 'cron', 'website',
+    'database', 'repo', 'config', 'tool', 'plugin', 'other',
+}
+
+VALID_STATES = {'active', 'inactive', 'broken', 'archived'}
+
+
+def _cognitive_ingest_safe(content, source_type, source_id="", source_title="", domain=""):
+    """Ingest to cognitive STM. Silently fails if cognitive engine unavailable."""
+    try:
+        import cognitive
+        cognitive.ingest(content, source_type, source_id, source_title, domain)
+    except Exception:
+        pass
+
+
+def handle_artifact_create(
+    kind: str,
+    canonical_name: str,
+    aliases: str = '[]',
+    description: str = '',
+    uri: str = '',
+    ports: str = '[]',
+    paths: str = '[]',
+    run_cmd: str = '',
+    repo: str = '',
+    domain: str = '',
+    session_id: str = '',
+    metadata: str = '{}',
+) -> str:
+    """Register a new artifact (service, dashboard, script, API, etc.).
+
+    Call this whenever NEXO creates, deploys, or discovers a runnable/accessible artifact.
+
+    Args:
+        kind: Type — service, dashboard, script, api, cron, website, database, repo, config, tool, plugin, other
+        canonical_name: Primary name (e.g., 'NEXO Brain Dashboard')
+        aliases: JSON array of alternative names users might use (e.g., '["backend", "dashboard", "nexo web"]')
+        description: What it does (1-2 sentences)
+        uri: Access URL or address (e.g., 'localhost:6174', 'nexo-brain.com')
+        ports: JSON array of ports (e.g., '[6174]')
+        paths: JSON array of file paths (e.g., '["/Users/x/nexo/src/dashboard/app.py"]')
+        run_cmd: Command to start/open it (e.g., 'python3 -m dashboard.app --port 6174')
+        repo: Repository path or URL
+        domain: Project domain (project-a, project-b, etc.)
+        session_id: Current session ID
+        metadata: JSON object with extra key-value pairs
+    """
+    if kind not in VALID_KINDS:
+        return f"ERROR: kind must be one of: {', '.join(sorted(VALID_KINDS))}"
+
+    # Parse aliases
+    try:
+        alias_list = json.loads(aliases) if aliases and aliases != '[]' else []
+    except (json.JSONDecodeError, TypeError):
+        alias_list = [a.strip() for a in aliases.split(',') if a.strip()]
+
+    conn = get_db()
+    cur = conn.execute(
+        """INSERT INTO artifact_registry
+           (kind, canonical_name, aliases, description, uri, ports, paths,
+            run_cmd, repo, domain, state, session_id, metadata)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?)""",
+        (kind, canonical_name, json.dumps(alias_list), description, uri, ports,
+         paths, run_cmd, repo, domain, session_id, metadata),
+    )
+    artifact_id = cur.lastrowid
+    conn.commit()
+
+    # Insert aliases into lookup table
+    for alias in alias_list + [canonical_name.lower()]:
+        alias_clean = alias.strip().lower()
+        if alias_clean:
+            try:
+                conn.execute(
+                    "INSERT OR IGNORE INTO artifact_aliases (artifact_id, phrase, source) VALUES (?, ?, 'create')",
+                    (artifact_id, alias_clean),
+                )
+            except Exception:
+                pass
+    conn.commit()
+
+    # Ingest to cognitive memory
+    content = f"Artifact: {canonical_name} ({kind}). {description}. URI: {uri}. Aliases: {', '.join(alias_list)}"
+    _cognitive_ingest_safe(content, "artifact", f"A{artifact_id}", canonical_name[:80], domain)
+
+    return f"Artifact #{artifact_id} created: {canonical_name} ({kind}) — {uri or 'no URI'}"
+
+
+def handle_artifact_find(query: str, kind: str = '', state: str = 'active') -> str:
+    """Find artifacts using the retrieval ladder: exact alias → port/path → fuzzy token → all recent.
+
+    This is the PRIMARY retrieval tool. Use it when the user references something
+    they or NEXO built/deployed/created. Designed for natural language like
+    'the backend', 'that script from yesterday', 'localhost something'.
+
+    Args:
+        query: What to search for — name, alias, port, path, or description fragment
+        kind: Filter by kind (optional)
+        state: Filter by state — default 'active'. Use 'all' for everything.
+    """
+    conn = get_db()
+    results = []
+    query_lower = query.strip().lower()
+
+    state_filter = "AND state = ?" if state != 'all' else ""
+    state_params = (state,) if state != 'all' else ()
+
+    kind_filter = "AND kind = ?" if kind else ""
+    kind_params = (kind,) if kind else ()
+
+    extra_filters = state_filter + " " + kind_filter
+    extra_params = state_params + kind_params
+
+    # --- STAGE 1: Exact alias match (fastest, O(1)) ---
+    rows = conn.execute(
+        f"""SELECT DISTINCT r.* FROM artifact_registry r
+            JOIN artifact_aliases a ON a.artifact_id = r.id
+            WHERE a.phrase = ? {extra_filters}
+            ORDER BY r.last_touched_at DESC LIMIT 5""",
+        (query_lower,) + extra_params,
+    ).fetchall()
+    if rows:
+        results = [dict(r) for r in rows]
+        return _format_results(results, "alias match", query)
+
+    # --- STAGE 2: Port or URI match ---
+    rows = conn.execute(
+        f"""SELECT * FROM artifact_registry
+            WHERE (uri LIKE ? OR ports LIKE ?) {extra_filters}
+            ORDER BY last_touched_at DESC LIMIT 5""",
+        (f"%{query_lower}%", f"%{query_lower}%") + extra_params,
+    ).fetchall()
+    if rows:
+        results = [dict(r) for r in rows]
+        return _format_results(results, "URI/port match", query)
+
+    # --- STAGE 3: Path match ---
+    rows = conn.execute(
+        f"""SELECT * FROM artifact_registry
+            WHERE paths LIKE ? {extra_filters}
+            ORDER BY last_touched_at DESC LIMIT 5""",
+        (f"%{query_lower}%",) + extra_params,
+    ).fetchall()
+    if rows:
+        results = [dict(r) for r in rows]
+        return _format_results(results, "path match", query)
+
+    # --- STAGE 4: Fuzzy token match on name, description, aliases ---
+    tokens = query_lower.split()
+    if tokens:
+        conditions = " AND ".join(
+            "(LOWER(canonical_name) LIKE ? OR LOWER(description) LIKE ? OR LOWER(aliases) LIKE ?)"
+            for _ in tokens
+        )
+        params = []
+        for t in tokens:
+            p = f"%{t}%"
+            params.extend([p, p, p])
+        rows = conn.execute(
+            f"""SELECT * FROM artifact_registry
+                WHERE {conditions} {extra_filters}
+                ORDER BY last_touched_at DESC LIMIT 10""",
+            tuple(params) + extra_params,
+        ).fetchall()
+        if rows:
+            results = [dict(r) for r in rows]
+            return _format_results(results, "token match", query)
+
+    # --- STAGE 5: Recent artifacts (last 72h) as fallback ---
+    cutoff = (datetime.datetime.now() - datetime.timedelta(hours=72)).isoformat()
+    rows = conn.execute(
+        f"""SELECT * FROM artifact_registry
+            WHERE last_touched_at >= ? {extra_filters}
+            ORDER BY last_touched_at DESC LIMIT 10""",
+        (cutoff,) + extra_params,
+    ).fetchall()
+    if rows:
+        results = [dict(r) for r in rows]
+        return _format_results(results, "recent (72h)", query)
+
+    return f"No artifacts found for '{query}'. Use artifact_list to see all registered artifacts."
+
+
+def handle_artifact_update(
+    id: int,
+    canonical_name: str = '',
+    aliases: str = '',
+    description: str = '',
+    uri: str = '',
+    ports: str = '',
+    paths: str = '',
+    run_cmd: str = '',
+    state: str = '',
+    domain: str = '',
+    metadata: str = '',
+) -> str:
+    """Update an artifact. Only non-empty fields are changed.
+
+    Args:
+        id: Artifact ID to update
+        canonical_name: New primary name
+        aliases: New JSON array of aliases (replaces existing)
+        description: New description
+        uri: New URI
+        ports: New ports JSON array
+        paths: New paths JSON array
+        run_cmd: New run command
+        state: New state (active, inactive, broken, archived)
+        domain: New domain
+        metadata: New metadata JSON (merged with existing)
+    """
+    conn = get_db()
+    row = conn.execute("SELECT * FROM artifact_registry WHERE id = ?", (id,)).fetchone()
+    if not row:
+        return f"ERROR: Artifact #{id} not found."
+
+    updates = []
+    params = []
+
+    if canonical_name:
+        updates.append("canonical_name = ?"); params.append(canonical_name)
+    if description:
+        updates.append("description = ?"); params.append(description)
+    if uri:
+        updates.append("uri = ?"); params.append(uri)
+    if ports:
+        updates.append("ports = ?"); params.append(ports)
+    if paths:
+        updates.append("paths = ?"); params.append(paths)
+    if run_cmd:
+        updates.append("run_cmd = ?"); params.append(run_cmd)
+    if domain:
+        updates.append("domain = ?"); params.append(domain)
+    if state:
+        if state not in VALID_STATES:
+            return f"ERROR: state must be one of: {', '.join(sorted(VALID_STATES))}"
+        updates.append("state = ?"); params.append(state)
+    if metadata:
+        try:
+            existing = json.loads(row["metadata"] or '{}')
+            new = json.loads(metadata)
+            existing.update(new)
+            updates.append("metadata = ?"); params.append(json.dumps(existing))
+        except (json.JSONDecodeError, TypeError):
+            pass
+
+    if aliases:
+        try:
+            alias_list = json.loads(aliases) if aliases.startswith('[') else [a.strip() for a in aliases.split(',')]
+        except (json.JSONDecodeError, TypeError):
+            alias_list = [a.strip() for a in aliases.split(',')]
+        updates.append("aliases = ?"); params.append(json.dumps(alias_list))
+        # Rebuild alias lookup table
+        conn.execute("DELETE FROM artifact_aliases WHERE artifact_id = ?", (id,))
+        for alias in alias_list:
+            alias_clean = alias.strip().lower()
+            if alias_clean:
+                conn.execute(
+                    "INSERT OR IGNORE INTO artifact_aliases (artifact_id, phrase, source) VALUES (?, ?, 'update')",
+                    (id, alias_clean),
+                )
+
+    if not updates:
+        return "Nothing to update."
+
+    updates.append("last_touched_at = datetime('now')")
+    params.append(id)
+    conn.execute(f"UPDATE artifact_registry SET {', '.join(updates)} WHERE id = ?", tuple(params))
+    conn.commit()
+    return f"Artifact #{id} updated."
+
+
+def handle_artifact_learn_alias(id: int, phrase: str) -> str:
+    """Learn a new alias from user language. Call this when the user refers to an
+    artifact with a term not yet registered (e.g., the user says 'backend' for dashboard:6174).
+
+    Args:
+        id: Artifact ID
+        phrase: The user's term (e.g., 'backend', 'that api thing')
+    """
+    conn = get_db()
+    row = conn.execute("SELECT * FROM artifact_registry WHERE id = ?", (id,)).fetchone()
+    if not row:
+        return f"ERROR: Artifact #{id} not found."
+
+    phrase_clean = phrase.strip().lower()
+    if not phrase_clean:
+        return "ERROR: Empty phrase."
+
+    # Add to alias lookup table
+    conn.execute(
+        "INSERT OR IGNORE INTO artifact_aliases (artifact_id, phrase, source) VALUES (?, ?, 'user_language')",
+        (id, phrase_clean),
+    )
+
+    # Also add to the artifact's aliases JSON array
+    try:
+        existing = json.loads(row["aliases"] or '[]')
+    except (json.JSONDecodeError, TypeError):
+        existing = []
+    if phrase_clean not in [a.lower() for a in existing]:
+        existing.append(phrase_clean)
+        conn.execute(
+            "UPDATE artifact_registry SET aliases = ?, last_touched_at = datetime('now') WHERE id = ?",
+            (json.dumps(existing), id),
+        )
+
+    conn.commit()
+    return f"Alias '{phrase_clean}' learned for artifact #{id} ({row['canonical_name']})."
+
+
+def handle_artifact_list(kind: str = '', state: str = 'active', recent_hours: int = 0) -> str:
+    """List all artifacts, optionally filtered.
+
+    Args:
+        kind: Filter by kind (service, dashboard, script, etc.)
+        state: Filter by state — 'active' (default), 'all', 'inactive', 'broken', 'archived'
+        recent_hours: If >0, only show artifacts touched in the last N hours
+    """
+    conn = get_db()
+    conditions = []
+    params = []
+
+    if state != 'all':
+        conditions.append("state = ?"); params.append(state)
+    if kind:
+        conditions.append("kind = ?"); params.append(kind)
+    if recent_hours > 0:
+        cutoff = (datetime.datetime.now() - datetime.timedelta(hours=recent_hours)).isoformat()
+        conditions.append("last_touched_at >= ?"); params.append(cutoff)
+
+    where = "WHERE " + " AND ".join(conditions) if conditions else ""
+    rows = conn.execute(
+        f"SELECT * FROM artifact_registry {where} ORDER BY last_touched_at DESC",
+        tuple(params),
+    ).fetchall()
+
+    if not rows:
+        filters = []
+        if kind: filters.append(f"kind={kind}")
+        if state != 'all': filters.append(f"state={state}")
+        if recent_hours: filters.append(f"last {recent_hours}h")
+        return f"No artifacts found{' (' + ', '.join(filters) + ')' if filters else ''}."
+
+    lines = [f"ARTIFACT REGISTRY ({len(rows)}):"]
+    for r in rows:
+        r = dict(r)
+        aliases_str = ""
+        try:
+            aliases = json.loads(r.get("aliases", "[]"))
+            if aliases:
+                aliases_str = f" aka [{', '.join(aliases[:3])}]"
+        except (json.JSONDecodeError, TypeError):
+            pass
+        uri_str = f" → {r['uri']}" if r.get("uri") else ""
+        cmd_str = f" | cmd: {r['run_cmd'][:60]}" if r.get("run_cmd") else ""
+        touched = r.get("last_touched_at", "")[:16]
+        lines.append(
+            f"  #{r['id']} [{r['kind']}] {r['canonical_name']}{aliases_str}{uri_str}{cmd_str} "
+            f"({r['state']}, {touched})"
+        )
+    return "\n".join(lines)
+
+
+def handle_artifact_delete(id: int) -> str:
+    """Delete an artifact from the registry.
+
+    Args:
+        id: Artifact ID to delete
+    """
+    conn = get_db()
+    row = conn.execute("SELECT canonical_name FROM artifact_registry WHERE id = ?", (id,)).fetchone()
+    if not row:
+        return f"ERROR: Artifact #{id} not found."
+    name = row["canonical_name"]
+    conn.execute("DELETE FROM artifact_aliases WHERE artifact_id = ?", (id,))
+    conn.execute("DELETE FROM artifact_registry WHERE id = ?", (id,))
+    conn.commit()
+    return f"Artifact #{id} ({name}) deleted."
+
+
+def _format_results(results, method, query):
+    """Format search results for display."""
+    lines = [f"ARTIFACTS FOUND ({len(results)}, via {method} for '{query}'):"]
+    for r in results:
+        aliases_str = ""
+        try:
+            aliases = json.loads(r.get("aliases", "[]"))
+            if aliases:
+                aliases_str = f" aka [{', '.join(aliases[:4])}]"
+        except (json.JSONDecodeError, TypeError):
+            pass
+        uri_str = f" → {r['uri']}" if r.get("uri") else ""
+        cmd_str = f"\n    Run: {r['run_cmd']}" if r.get("run_cmd") else ""
+        paths_str = ""
+        try:
+            paths = json.loads(r.get("paths", "[]"))
+            if paths:
+                paths_str = f"\n    Paths: {', '.join(paths[:3])}"
+        except (json.JSONDecodeError, TypeError):
+            pass
+        touched = r.get("last_touched_at", "")[:16]
+        lines.append(
+            f"  #{r['id']} [{r['kind']}] {r['canonical_name']}{aliases_str}{uri_str} "
+            f"({r['state']}, {touched}){cmd_str}{paths_str}"
+        )
+    return "\n".join(lines)
+
+
+# Plugin registration — TOOLS array consumed by plugin_loader.py
+TOOLS = [
+    (handle_artifact_create, "nexo_artifact_create",
+     "Register a new artifact (service, dashboard, script, API, etc.) in the Artifact Registry. "
+     "Call this whenever NEXO creates, deploys, or discovers a runnable/accessible artifact."),
+    (handle_artifact_find, "nexo_artifact_find",
+     "Find artifacts using the retrieval ladder: exact alias → port/path → fuzzy token → recent. "
+     "PRIMARY retrieval tool for when users reference something built/deployed. Handles natural "
+     "language like 'the backend', 'that script', 'localhost something'."),
+    (handle_artifact_update, "nexo_artifact_update",
+     "Update an existing artifact. Only non-empty fields are changed."),
+    (handle_artifact_learn_alias, "nexo_artifact_learn_alias",
+     "Learn a new alias from user language. Call when the user refers to an artifact with "
+     "an unregistered term (e.g., 'backend' for the NEXO Brain Dashboard)."),
+    (handle_artifact_list, "nexo_artifact_list",
+     "List all registered artifacts, optionally filtered by kind, state, or recency."),
+    (handle_artifact_delete, "nexo_artifact_delete",
+     "Delete an artifact from the registry."),
+]

package/src/plugins/episodic_memory.py

@@ -27,7 +27,7 @@ def handle_decision_log(domain: str, decision: str, alternatives: str = '',
     """Log a non-trivial decision with reasoning context.
 
     Args:
-        domain: Area (ads, shopify, server, wazion, nexo, canarirural, other)
+        domain: Area (ads, shopify, server, wazion, nexo, project, other)
         decision: What was decided
         alternatives: JSON array or text of options considered and why discarded
         based_on: Data, metrics, or observations that informed this decision
@@ -35,7 +35,7 @@ def handle_decision_log(domain: str, decision: str, alternatives: str = '',
         context_ref: Related followup/reminder ID (e.g., NF-ADS1, R71)
         session_id: Current session ID (auto-filled if empty)
     """
-    valid_domains = {'ads', 'shopify', 'server', 'wazion', 'nexo', 'canarirural', 'other'}
+    valid_domains = {'ads', 'shopify', 'server', 'wazion', 'nexo', 'project', 'other'}
     if domain not in valid_domains:
         return f"ERROR: domain debe ser uno de: {', '.join(sorted(valid_domains))}"
     if confidence not in ('high', 'medium', 'low'):
@@ -92,10 +92,10 @@ def handle_decision_search(query: str = '', domain: str = '', days: int = 30) ->
 
     Args:
         query: Text to search in decision, alternatives, based_on, outcome
-        domain: Filter by area (ads, shopify, server, wazion, nexo, canarirural, other)
+        domain: Filter by area (ads, shopify, server, wazion, nexo, project, other)
         days: Look back N days (default 30)
     """
-    valid_domains = {'ads', 'shopify', 'server', 'wazion', 'nexo', 'canarirural', 'other'}
+    valid_domains = {'ads', 'shopify', 'server', 'wazion', 'nexo', 'project', 'other'}
     if domain and domain not in valid_domains:
         return f"ERROR: domain debe ser uno de: {', '.join(sorted(valid_domains))}"
     results = search_decisions(query, domain, days)
@@ -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)
@@ -235,7 +235,7 @@ def handle_session_diary_read(session_id: str = '', last_n: int = 3, last_day: b
         session_id: Specific session ID to read (optional)
         last_n: Number of recent entries to return (default 3)
         last_day: If true, returns ALL entries from the most recent day (multi-terminal aware). Use this at startup.
-        domain: Filter by project context: recambios, wazion, nexo, canarirural, server, other
+        domain: Filter by project context: project-a, project-b, nexo, project-c, server, other
     """
     results = read_session_diary(session_id, last_n, last_day, domain)
     if not results:
@@ -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']}")

package/src/tools_menu.py

@@ -39,8 +39,8 @@ MENU_ITEMS = [
         ("6", "Cambiar Promocion Shopify"),
     ]),
     ("Servidor e Infraestructura", [
-        ("2", "Servidor - Chequeo cl105e.mundiserver.com"),
-        ("3", "WhatsApp Logs - Revisar logs vicshopsysteam"),
+        ("2", "Servidor - Chequeo server health check"),
+        ("3", "WhatsApp Logs - Review WhatsApp logs"),
         ("11", "File Tracker - Reporte archivos PHP"),
         ("12", "Google Cloud - Gasto, consumo y estado GCP"),
     ]),