nexo-brain 1.4.0 → 1.4.1

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 (nexo, my-project, 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/cognitive_memory.py

@@ -30,7 +30,7 @@ def handle_cognitive_retrieve(
         min_score: Minimum cosine similarity score (default 0.5)
         stores: Which store to search — "both", "stm", or "ltm" (default "both")
         source_type: Filter by source type e.g. "change", "learning", "diary" (default: all)
-        domain: Filter by domain e.g. "wazion", "shopify" (default: all)
+        domain: Filter by domain e.g. "my-project", "shopify" (default: all)
         include_archived: If True, also search archived memories (default False)
         use_hyde: If True, use HyDE query expansion — embeds 3-5 query variants and searches with centroid. Better recall for conceptual queries. (default False)
         spreading_depth: If >0, boost co-activated neighbors (memories frequently retrieved together). 1=direct neighbors only. (default 0)
@@ -222,13 +222,13 @@ def handle_cognitive_metrics(days: int = 7) -> str:
 
 
 def handle_cognitive_sentiment(text: str) -> str:
-    """Detect Francisco's sentiment from his text. Returns mood, intensity, and guidance.
+    """Detect the user's sentiment from his text. Returns mood, intensity, and guidance.
 
-    Call this with Francisco's recent message to adapt NEXO's tone and behavior.
+    Call this with the user's recent message to adapt NEXO's tone and behavior.
     Also logs the sentiment for historical tracking.
 
     Args:
-        text: Francisco's recent message or instruction
+        text: The user's recent message or instruction
     """
     result = cognitive.log_sentiment(text)
     trust = cognitive.get_trust_score()
@@ -294,8 +294,8 @@ def handle_cognitive_trust(event: str = '', context: str = '', delta: float = No
 def handle_cognitive_dissonance(instruction: str, force: bool = False) -> str:
     """Detect cognitive dissonance: find established memories that conflict with a new instruction.
 
-    Use BEFORE applying a new preference or rule from Francisco that might contradict
-    existing knowledge. If conflicts found, verbalize them and ask Francisco to resolve.
+    Use BEFORE applying a new preference or rule from the user that might contradict
+    existing knowledge. If conflicts found, verbalize them and ask the user to resolve.
 
     Args:
         instruction: The new instruction or preference to check against LTM
@@ -328,7 +328,7 @@ def handle_cognitive_dissonance(instruction: str, force: bool = False) -> str:
         lines.append("")
 
     lines.append("RESOLVE with nexo_cognitive_resolve, or use force=True to skip:")
-    lines.append("  - 'paradigm_shift': Francisco changed his mind permanently.")
+    lines.append("  - 'paradigm_shift': The user changed their mind permanently.")
     lines.append("  - 'exception': One-time override. Old memory stays.")
     lines.append("  - 'override': Old memory was wrong.")
 
@@ -336,7 +336,7 @@ def handle_cognitive_dissonance(instruction: str, force: bool = False) -> str:
 
 
 def handle_cognitive_resolve(memory_id: int, resolution: str, context: str = '') -> str:
-    """Resolve a cognitive dissonance by applying Francisco's decision.
+    """Resolve a cognitive dissonance by applying the user's decision.
 
     Args:
         memory_id: The LTM memory ID from the dissonance detection
@@ -546,7 +546,7 @@ TOOLS = [
     (handle_cognitive_metrics, "nexo_cognitive_metrics", "Performance metrics: retrieval relevance %, repeat error rate, multilingual recommendation (spec section 9)"),
     (handle_cognitive_dissonance, "nexo_cognitive_dissonance", "Detect conflicts between a new instruction and established LTM memories. force=True to skip discussion."),
     (handle_cognitive_resolve, "nexo_cognitive_resolve", "Resolve a cognitive dissonance: paradigm_shift, exception, or override."),
-    (handle_cognitive_sentiment, "nexo_cognitive_sentiment", "Detect Francisco's sentiment and get tone guidance. Also logs for tracking."),
+    (handle_cognitive_sentiment, "nexo_cognitive_sentiment", "Detect the user's sentiment and get tone guidance. Also logs for tracking."),
     (handle_cognitive_trust, "nexo_cognitive_trust", "View or adjust trust score (0-100). Without args: view. With event: adjust."),
     (handle_cognitive_pin, "nexo_cognitive_pin", "Pin a memory — never decays, boosted +0.2 in search results."),
     (handle_cognitive_snooze, "nexo_cognitive_snooze", "Snooze a memory — hidden from searches until a date, then auto-restores."),

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, project, other)
+        domain: Area (ads, shopify, server, my-project, 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', 'project', 'other'}
+    valid_domains = {'ads', 'shopify', 'server', 'my-project', '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, project, other)
+        domain: Filter by area (ads, shopify, server, my-project, nexo, project, other)
         days: Look back N days (default 30)
     """
-    valid_domains = {'ads', 'shopify', 'server', 'wazion', 'nexo', 'project', 'other'}
+    valid_domains = {'ads', 'shopify', 'server', 'my-project', '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)
@@ -103,7 +103,7 @@ def handle_decision_search(query: str = '', domain: str = '', days: int = 30) ->
         scope = f"'{query}'" if query else domain or 'todas'
         return f"No decisions found for {scope} in {days} days."
 
-    lines = [f"DECISIONES ({len(results)}):"]
+    lines = [f"DECISIONS ({len(results)}):"]
     for d in results:
         conf = d.get('confidence', '?')
         outcome_str = f" → {d['outcome'][:50]}" if d.get('outcome') else ""
@@ -265,7 +265,7 @@ def handle_change_log(files: str, what_changed: str, why: str,
                       triggered_by: str = '', affects: str = '',
                       risks: str = '', verify: str = '',
                       commit_ref: str = '', session_id: str = '') -> str:
-    """Log a code/config change with full context. OBLIGATORIO after every edit to production code.
+    """Log a code/config change with full context. MANDATORY after every edit to production code.
 
     Args:
         files: File path(s) modified (comma-separated if multiple)
@@ -279,7 +279,7 @@ def handle_change_log(files: str, what_changed: str, why: str,
         session_id: Current session ID
     """
     if not files or not what_changed or not why:
-        return "ERROR: files, what_changed, y why son obligatorios"
+        return "ERROR: files, what_changed, and why are required"
     sid = session_id or 'unknown'
     result = log_change(sid, files, what_changed, why, triggered_by, affects, risks, verify, commit_ref)
     if "error" in result:
@@ -422,7 +422,7 @@ def handle_diary_archive_search(
 
     Args:
         query: Text to search in diary content
-        domain: Filter by project domain (e.g. 'wazion', 'my-store')
+        domain: Filter by project domain (e.g. 'my-project', 'my-store')
         year: Filter by year (e.g. 2026)
         month: Filter by month (1-12), requires year
         limit: Max results (default 20)

package/src/plugins/evolution.py

@@ -77,10 +77,10 @@ def handle_evolution_approve(log_id: int, notes: str = '') -> str:
 
     Args:
         log_id: Evolution log entry ID to approve
-        notes: Optional notes from Francisco
+        notes: Optional notes from the owner
     """
     update_evolution_log_status(log_id, "accepted",
-                                test_result=f"Approved by Francisco. {notes}".strip())
+                                test_result=f"Approved by the owner. {notes}".strip())
     return f"Proposal #{log_id} APPROVED. Will be applied in next Evolution cycle."
 
 
@@ -92,7 +92,7 @@ def handle_evolution_reject(log_id: int, reason: str = '') -> str:
         reason: Why this proposal was rejected
     """
     update_evolution_log_status(log_id, "rejected",
-                                test_result=f"Rejected: {reason}" if reason else "Rejected by Francisco")
+                                test_result=f"Rejected: {reason}" if reason else "Rejected by the owner")
     return f"Proposal #{log_id} REJECTED. Reason: {reason or 'no reason given'}"
 
 
@@ -104,7 +104,7 @@ TOOLS = [
     (handle_evolution_propose, "nexo_evolution_propose",
      "Manually trigger an evolution analysis outside weekly schedule"),
     (handle_evolution_approve, "nexo_evolution_approve",
-     "Approve a pending Evolution proposal (Francisco only)"),
+     "Approve a pending Evolution proposal (owner only)"),
     (handle_evolution_reject, "nexo_evolution_reject",
      "Reject a pending Evolution proposal with reason"),
 ]

package/src/plugins/guard.py

@@ -59,7 +59,7 @@ def handle_guard_check(files: str = "", area: str = "", include_schemas: str = "
 
     Args:
         files: Comma-separated file paths about to be edited
-        area: System area (wazion, shopify, infrastructure, nexo-ops, etc.)
+        area: System area (my-project, shopify, infrastructure, nexo-ops, etc.)
         include_schemas: Include DB table schemas if files touch database code (true/false)
     """
     conn = get_db()
@@ -174,6 +174,23 @@ def handle_guard_check(files: str = "", area: str = "", include_schemas: str = "
                 "reason": "prohibition_keyword"
             })
 
+    # 5b. Behavioral rules — when called without files (session-level check)
+    if not file_list:
+        behavioral = conn.execute(
+            """SELECT l.id, l.title, l.category, COUNT(e.id) as violations
+               FROM learnings l
+               LEFT JOIN error_repetitions e ON e.original_learning_id = l.id
+               WHERE l.category = 'nexo-ops' AND l.status = 'active'
+               GROUP BY l.id
+               ORDER BY violations DESC, l.created_at DESC
+               LIMIT 5"""
+        ).fetchall()
+        if behavioral:
+            result["behavioral_rules"] = [
+                {"id": r["id"], "rule": r["title"], "violations": r["violations"]}
+                for r in behavioral
+            ]
+
     # 6. Area repetition rate
     if area:
         total_area = conn.execute(
@@ -266,6 +283,13 @@ def handle_guard_check(files: str = "", area: str = "", include_schemas: str = "
             lines.append(f"  #{l['id']} [{l['category']}] {l['rule']}")
         lines.append("")
 
+    if result.get("behavioral_rules"):
+        lines.append("SESSION BEHAVIORAL RULES (top 5 most-violated):")
+        for r in result["behavioral_rules"]:
+            v = f" ({r['violations']}x violated)" if r["violations"] > 0 else ""
+            lines.append(f"  #{r['id']} {r['rule']}{v}")
+        lines.append("")
+
     if result["universal_rules"]:
         lines.append(f"UNIVERSAL RULES ({len(result['universal_rules'])}):")
         for r in result["universal_rules"][:10]:
@@ -456,7 +480,7 @@ def handle_guard_cross_check(findings: list, area: str = "") -> str:
 
     Args:
         findings: List of audit finding strings to cross-check
-        area: System area to narrow the learning search (wazion, shopify, etc.)
+        area: System area to narrow the learning search (my-project, shopify, etc.)
     """
     # Common English/Spanish stopwords to skip during keyword extraction
     STOPWORDS = {