nexo-brain 2.6.21 → 3.0.0

package/src/client_sync.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 import argparse
 import json
 import os
+import re
+import shlex
 import shutil
 import subprocess
 import sys
@@ -308,6 +310,179 @@ def _write_json_object(path: Path, payload: dict) -> None:
     path.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n")
 
 
+CORE_HOOK_SPECS = [
+    {
+        "event": "SessionStart",
+        "identity": "session-start-ts",
+        "timeout": 2,
+        "command_template": lambda nexo_home, _runtime_root, _hooks_dir: (
+            f"mkdir -p {shlex.quote(str(nexo_home / 'operations'))} && "
+            f"date +%s > {shlex.quote(str(nexo_home / 'operations' / '.session-start-ts'))}"
+        ),
+    },
+    {
+        "event": "SessionStart",
+        "identity": "daily-briefing-check.sh",
+        "timeout": 5,
+        "script": "daily-briefing-check.sh",
+    },
+    {
+        "event": "SessionStart",
+        "identity": "session-start.sh",
+        "timeout": 35,
+        "script": "session-start.sh",
+    },
+    {
+        "event": "Stop",
+        "identity": "session-stop.sh",
+        "timeout": 10,
+        "script": "session-stop.sh",
+    },
+    {
+        "event": "PostToolUse",
+        "identity": "capture-tool-logs.sh",
+        "timeout": 5,
+        "script": "capture-tool-logs.sh",
+    },
+    {
+        "event": "PostToolUse",
+        "identity": "capture-session.sh",
+        "timeout": 3,
+        "script": "capture-session.sh",
+    },
+    {
+        "event": "PostToolUse",
+        "identity": "inbox-hook.sh",
+        "timeout": 5,
+        "script": "inbox-hook.sh",
+    },
+    {
+        "event": "PostToolUse",
+        "identity": "protocol-guardrail.sh",
+        "timeout": 5,
+        "script": "protocol-guardrail.sh",
+    },
+    {
+        "event": "PreCompact",
+        "identity": "pre-compact.sh",
+        "timeout": 10,
+        "script": "pre-compact.sh",
+    },
+    {
+        "event": "PostCompact",
+        "identity": "post-compact.sh",
+        "timeout": 10,
+        "script": "post-compact.sh",
+    },
+]
+
+
+def _resolve_hook_source_dir(runtime_root: Path) -> Path:
+    direct = runtime_root / "hooks"
+    if direct.is_dir():
+        return direct
+    sibling = runtime_root.parent / "src" / "hooks"
+    if sibling.is_dir():
+        return sibling
+    fallback = runtime_root.parent / "hooks"
+    if fallback.is_dir():
+        return fallback
+    return direct
+
+
+def _render_hook_command(spec: dict, *, nexo_home: Path, runtime_root: Path, hooks_dir: Path) -> str:
+    command_template = spec.get("command_template")
+    if callable(command_template):
+        return command_template(nexo_home, runtime_root, hooks_dir)
+    script_name = spec.get("script", "").strip()
+    script_path = hooks_dir / script_name
+    return (
+        f"NEXO_HOME={shlex.quote(str(nexo_home))} "
+        f"NEXO_CODE={shlex.quote(str(runtime_root))} "
+        f"bash {shlex.quote(str(script_path))}"
+    )
+
+
+def _hook_identity(command: str) -> str:
+    text = str(command or "")
+    if ".session-start-ts" in text:
+        return "session-start-ts"
+    match = re.search(r"([A-Za-z0-9._-]+\.sh)\b", text)
+    if match:
+        return match.group(1)
+    return text.strip()
+
+
+def _normalize_hook_sections(entries) -> list[dict]:
+    normalized: list[dict] = []
+    for entry in entries or []:
+        if not isinstance(entry, dict):
+            continue
+        hooks = entry.get("hooks")
+        if isinstance(hooks, list):
+            normalized.append(
+                {
+                    "matcher": entry.get("matcher", "*") or "*",
+                    "hooks": [dict(hook) for hook in hooks if isinstance(hook, dict)],
+                }
+            )
+            continue
+        if entry.get("command"):
+            hook = {"type": entry.get("type", "command"), "command": entry["command"]}
+            if entry.get("timeout"):
+                hook["timeout"] = entry["timeout"]
+            normalized.append({"matcher": entry.get("matcher", "*") or "*", "hooks": [hook]})
+    return normalized
+
+
+def _merge_core_hooks(existing_hooks, *, runtime_root: Path, nexo_home: Path) -> tuple[dict, int]:
+    hooks_payload = dict(existing_hooks) if isinstance(existing_hooks, dict) else {}
+    hooks_dir = _resolve_hook_source_dir(runtime_root)
+    managed_count = 0
+
+    for spec in CORE_HOOK_SPECS:
+        event = spec["event"]
+        sections = _normalize_hook_sections(hooks_payload.get(event))
+        hooks_payload[event] = sections
+        command = _render_hook_command(spec, nexo_home=nexo_home, runtime_root=runtime_root, hooks_dir=hooks_dir)
+        identity = spec["identity"]
+
+        found = False
+        for section in sections:
+            for hook in section["hooks"]:
+                if _hook_identity(hook.get("command", "")) != identity:
+                    continue
+                hook["type"] = "command"
+                hook["command"] = command
+                if spec.get("timeout"):
+                    hook["timeout"] = spec["timeout"]
+                found = True
+                managed_count += 1
+                break
+            if found:
+                break
+
+        if found:
+            continue
+
+        target = None
+        for section in sections:
+            if section.get("matcher", "*") == "*":
+                target = section
+                break
+        if target is None:
+            target = {"matcher": "*", "hooks": []}
+            sections.append(target)
+
+        new_hook = {"type": "command", "command": command}
+        if spec.get("timeout"):
+            new_hook["timeout"] = spec["timeout"]
+        target["hooks"].append(new_hook)
+        managed_count += 1
+
+    return hooks_payload, managed_count
+
+
 def _sync_json_client(path: Path, server_config: dict, label: str, *, managed_metadata: dict | None = None) -> dict:
     payload = _load_json_object(path)
     mcp_servers = payload.setdefault("mcpServers", {})
@@ -343,6 +518,32 @@ def _claude_desktop_managed_metadata(server_config: dict, *, operator_name: str)
     }
 
 
+def _sync_claude_code_settings(path: Path, server_config: dict) -> dict:
+    payload = _load_json_object(path)
+    mcp_servers = payload.setdefault("mcpServers", {})
+    if not isinstance(mcp_servers, dict):
+        mcp_servers = {}
+        payload["mcpServers"] = mcp_servers
+    action = "updated" if "nexo" in mcp_servers else "created"
+    mcp_servers["nexo"] = server_config
+
+    runtime_root = Path(server_config.get("env", {}).get("NEXO_CODE", "")).expanduser()
+    nexo_home = Path(server_config.get("env", {}).get("NEXO_HOME", "")).expanduser()
+    payload["hooks"], managed_hook_count = _merge_core_hooks(
+        payload.get("hooks", {}),
+        runtime_root=runtime_root,
+        nexo_home=nexo_home,
+    )
+    _write_json_object(path, payload)
+    return {
+        "ok": True,
+        "client": "claude_code",
+        "action": action,
+        "path": str(path),
+        "managed_hook_count": managed_hook_count,
+    }
+
+
 def sync_claude_code(
     *,
     nexo_home: str | os.PathLike[str] | None = None,
@@ -358,10 +559,9 @@ def sync_claude_code(
         python_path=python_path,
         operator_name=operator_name,
     )
-    result = _sync_json_client(
+    result = _sync_claude_code_settings(
         _claude_code_settings_path(Path(user_home).expanduser() if user_home else None),
         server_config,
-        "claude_code",
     )
     bootstrap_result = sync_client_bootstrap(
         "claude_code",

package/src/cognitive/__init__.py

@@ -29,7 +29,7 @@ from cognitive._search import (
     search, bm25_search, hyde_expand_query,
     record_co_activation,
     _kg_boost_results, _apply_temporal_boost,
-    create_trigger, check_triggers, list_triggers, delete_trigger, rearm_trigger,
+    create_trigger, preview_triggers, check_triggers, list_triggers, delete_trigger, rearm_trigger,
     # Constants
     CO_ACTIVATION_DECAY, CO_ACTIVATION_BOOST, CO_ACTIVATION_MIN_STRENGTH,
 )

package/src/cognitive/_search.py

@@ -542,18 +542,17 @@ def create_trigger(pattern: str, action: str, context: str = "") -> int:
     return cur.lastrowid
 
 
-def check_triggers(text: str, use_semantic: bool = False, semantic_threshold: float = 0.7) -> list[dict]:
-    """Check text against all armed triggers. Fires matches.
-
-    Uses keyword matching by default. If use_semantic=True, also checks
-    semantic similarity (Vestige TriggerPattern.matches pattern).
+def _match_triggers(
+    text: str,
+    *,
+    use_semantic: bool = False,
+    semantic_threshold: float = 0.7,
+    fire: bool = False,
+) -> list[dict]:
+    """Match armed prospective triggers against text.
 
-    Args:
-        text: Input text to check
-        use_semantic: Also do embedding similarity matching
-        semantic_threshold: Min cosine similarity for semantic match
-    Returns:
-        List of fired triggers with actions
+    When ``fire`` is False, matches are previewed without mutating trigger state.
+    When ``fire`` is True, matching armed triggers transition to fired.
     """
     if not text or not text.strip():
         return []
@@ -571,7 +570,7 @@ def check_triggers(text: str, use_semantic: bool = False, semantic_threshold: fl
     if use_semantic:
         text_vec = embed(text)
 
-    fired = []
+    matched_triggers = []
     now = datetime.utcnow().isoformat()
 
     for trigger in armed:
@@ -594,11 +593,12 @@ def check_triggers(text: str, use_semantic: bool = False, semantic_threshold: fl
                 match_type = f"semantic({sim:.3f})"
 
         if matched:
-            db.execute(
-                "UPDATE prospective_triggers SET status = 'fired', fired_at = ? WHERE id = ?",
-                (now, trigger["id"])
-            )
-            fired.append({
+            if fire:
+                db.execute(
+                    "UPDATE prospective_triggers SET status = 'fired', fired_at = ? WHERE id = ?",
+                    (now, trigger["id"])
+                )
+            matched_triggers.append({
                 "id": trigger["id"],
                 "pattern": trigger["trigger_pattern"],
                 "action": trigger["action"],
@@ -607,10 +607,30 @@ def check_triggers(text: str, use_semantic: bool = False, semantic_threshold: fl
                 "created_at": trigger["created_at"],
             })
 
-    if fired:
+    if fire and matched_triggers:
         db.commit()
 
-    return fired
+    return matched_triggers
+
+
+def preview_triggers(text: str, use_semantic: bool = False, semantic_threshold: float = 0.7) -> list[dict]:
+    """Preview trigger matches without consuming or firing them."""
+    return _match_triggers(
+        text,
+        use_semantic=use_semantic,
+        semantic_threshold=semantic_threshold,
+        fire=False,
+    )
+
+
+def check_triggers(text: str, use_semantic: bool = False, semantic_threshold: float = 0.7) -> list[dict]:
+    """Check text against all armed triggers and fire matching ones."""
+    return _match_triggers(
+        text,
+        use_semantic=use_semantic,
+        semantic_threshold=semantic_threshold,
+        fire=True,
+    )
 
 
 def list_triggers(status: str = "armed") -> list[dict]:

package/src/dashboard/app.py

@@ -156,6 +156,233 @@ def _email_db():
     return conn
 
 
+def _deep_sleep_dir() -> Path:
+    nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+    return nexo_home / "operations" / "deep-sleep"
+
+
+def _latest_periodic_summary(kind: str) -> dict:
+    root = _deep_sleep_dir()
+    pattern = f"*-{kind}-summary.json"
+    candidates = []
+    for path in root.glob(pattern):
+        try:
+            payload = json.loads(path.read_text(encoding="utf-8"))
+        except Exception:
+            continue
+        label = str(payload.get("label", "") or "")
+        if label:
+            candidates.append((label, payload))
+    if not candidates:
+        return {}
+    return sorted(candidates, key=lambda item: item[0])[-1][1]
+
+
+def _summarize_engineering_loop(weekly: dict, monthly: dict) -> dict:
+    matters_now = []
+    for item in (weekly.get("project_pulse") or weekly.get("top_projects") or [])[:4]:
+        matters_now.append(
+            {
+                "title": str(item.get("project", "") or "unknown"),
+                "detail": f"score {item.get('score', 0)}",
+                "tone": str(item.get("status", "watch") or "watch"),
+                "meta": ", ".join(item.get("reasons", [])[:2]) if isinstance(item.get("reasons"), list) else "",
+            }
+        )
+
+    drifting = []
+    protocol = weekly.get("protocol_summary") or {}
+    for key, label in (
+        ("guard_check", "guard_check"),
+        ("heartbeat", "heartbeat"),
+        ("change_log", "change_log"),
+    ):
+        item = protocol.get(key) or {}
+        pct = item.get("compliance_pct")
+        if isinstance(pct, (int, float)) and pct < 70:
+            drifting.append(
+                {
+                    "title": label,
+                    "detail": f"{pct:.1f}% compliance",
+                    "tone": "critical" if pct < 45 else "elevated",
+                    "meta": "",
+                }
+            )
+    for item in (weekly.get("top_patterns") or [])[:3]:
+        pattern = str(item.get("pattern", "") or "")
+        if pattern:
+            drifting.append(
+                {
+                    "title": pattern,
+                    "detail": f"{item.get('count', 0)}x this period",
+                    "tone": "watch",
+                    "meta": "recurring pattern",
+                }
+            )
+        if len(drifting) >= 4:
+            break
+
+    improving = []
+    trend = weekly.get("trend") or {}
+    trust_delta = trend.get("avg_trust_delta")
+    if isinstance(trust_delta, (int, float)) and trust_delta > 0:
+        improving.append({"title": "Trust", "detail": f"{trust_delta:+.1f}", "tone": "healthy", "meta": "vs previous window"})
+    delivery = weekly.get("delivery_metrics") or {}
+    if int(delivery.get("engineering_followups", 0) or 0) > 0:
+        improving.append(
+            {
+                "title": "Engineering followups",
+                "detail": str(delivery.get("engineering_followups", 0)),
+                "tone": "healthy",
+                "meta": "guardrails created from recurring patterns",
+            }
+        )
+    protocol_delta = trend.get("protocol_compliance_delta")
+    if isinstance(protocol_delta, (int, float)) and protocol_delta > 0:
+        improving.append({"title": "Protocol", "detail": f"{protocol_delta:+.1f}%", "tone": "healthy", "meta": "vs previous window"})
+    duplicate_followup_delta = trend.get("followup_duplicate_open_delta")
+    if isinstance(duplicate_followup_delta, int) and duplicate_followup_delta < 0:
+        improving.append({"title": "Followup duplication", "detail": f"{duplicate_followup_delta:+d}", "tone": "healthy", "meta": "open duplicates"})
+    learning_noise_delta = trend.get("learning_noise_delta")
+    if isinstance(learning_noise_delta, int) and learning_noise_delta < 0:
+        improving.append({"title": "Learning noise", "detail": f"{learning_noise_delta:+d}", "tone": "healthy", "meta": "active noise pressure"})
+    corrections_delta = trend.get("total_corrections_delta")
+    if isinstance(corrections_delta, int) and corrections_delta < 0:
+        improving.append({"title": "Corrections", "detail": f"{corrections_delta:+d}", "tone": "healthy", "meta": "lower is better"})
+    mood_delta = trend.get("avg_mood_delta")
+    if isinstance(mood_delta, (int, float)) and mood_delta > 0:
+        improving.append({"title": "Mood", "detail": f"{mood_delta:+.3f}", "tone": "healthy", "meta": "vs previous window"})
+
+    duplicate_followup_rate_delta = trend.get("followup_duplicate_rate_delta")
+    if isinstance(duplicate_followup_rate_delta, (int, float)) and duplicate_followup_rate_delta > 0:
+        drifting.append({"title": "followup_duplicates", "detail": f"{duplicate_followup_rate_delta:+.1f}%", "tone": "critical" if duplicate_followup_rate_delta >= 5 else "watch", "meta": "open duplicate rate"})
+    learning_noise_rate_delta = trend.get("learning_noise_rate_delta")
+    if isinstance(learning_noise_rate_delta, (int, float)) and learning_noise_rate_delta > 0:
+        drifting.append({"title": "learning_noise", "detail": f"{learning_noise_rate_delta:+.1f}%", "tone": "critical" if learning_noise_rate_delta >= 5 else "watch", "meta": "active noise rate"})
+
+    return {
+        "weekly": weekly,
+        "monthly": monthly,
+        "matters_now": matters_now[:4],
+        "drifting": drifting[:4],
+        "improving": improving[:4],
+    }
+
+
+def _safe_json(value, default):
+    if value in (None, ""):
+        return default
+    if isinstance(value, (list, dict)):
+        return value
+    try:
+        return json.loads(value)
+    except Exception:
+        return default
+
+
+def _protocol_explainability_snapshot(limit: int = 20) -> dict:
+    db = _db()
+    conn = db.get_db()
+    max_limit = max(5, min(int(limit or 20), 100))
+
+    protocol_summary = db.protocol_compliance_summary(7)
+    recent_tasks = []
+    for row in conn.execute(
+        """SELECT * FROM protocol_tasks
+           ORDER BY opened_at DESC
+           LIMIT ?""",
+        (max_limit,),
+    ).fetchall():
+        item = dict(row)
+        for field in (
+            "files",
+            "plan",
+            "known_facts",
+            "unknowns",
+            "constraints",
+            "evidence_refs",
+            "response_reasons",
+        ):
+            item[field] = _safe_json(item.get(field), [])
+        item["has_evidence"] = bool(str(item.get("close_evidence") or "").strip())
+        item["guarded_open"] = bool(item.get("opened_with_guard") or item.get("opened_with_rules"))
+        recent_tasks.append(item)
+
+    recent_debts = [dict(row) for row in conn.execute(
+        """SELECT * FROM protocol_debt
+           ORDER BY created_at DESC
+           LIMIT ?""",
+        (max_limit,),
+    ).fetchall()]
+
+    debt_summary = {"open_total": 0, "by_severity": {}, "by_type": {}}
+    for debt in recent_debts:
+        if debt.get("status") != "open":
+            continue
+        debt_summary["open_total"] += 1
+        severity = str(debt.get("severity") or "warn")
+        debt_type = str(debt.get("debt_type") or "unknown")
+        debt_summary["by_severity"][severity] = debt_summary["by_severity"].get(severity, 0) + 1
+        debt_summary["by_type"][debt_type] = debt_summary["by_type"].get(debt_type, 0) + 1
+
+    recent_runs = db.list_workflow_runs(include_closed=True, limit=max_limit)
+    workflow_summary = {
+        "total": len(recent_runs),
+        "open_runs": sum(1 for run in recent_runs if run.get("status") not in {"completed", "failed", "cancelled"}),
+        "blocked_runs": sum(1 for run in recent_runs if run.get("status") == "blocked"),
+        "waiting_approval": sum(1 for run in recent_runs if run.get("status") == "waiting_approval"),
+    }
+
+    recent_goals = db.list_workflow_goals(include_closed=True, limit=max_limit)
+    goal_summary = {
+        "total": len(recent_goals),
+        "active": sum(1 for goal in recent_goals if goal.get("status") == "active"),
+        "blocked": sum(1 for goal in recent_goals if goal.get("status") == "blocked"),
+        "closed": sum(1 for goal in recent_goals if goal.get("status") in {"completed", "cancelled", "abandoned"}),
+    }
+
+    guard_checks = [dict(row) for row in conn.execute(
+        """SELECT area, files, learnings_returned, blocking_rules_returned, created_at
+           FROM guard_checks
+           ORDER BY created_at DESC
+           LIMIT ?""",
+        (max_limit,),
+    ).fetchall()]
+    areas = {}
+    blocking_hits = 0
+    for check in guard_checks:
+        area = str(check.get("area") or "unknown")
+        areas[area] = areas.get(area, 0) + 1
+        blocking_hits += int(check.get("blocking_rules_returned") or 0)
+
+    conditioned_learnings = [dict(row) for row in conn.execute(
+        """SELECT id, title, applies_to, priority, status, weight, guard_hits, updated_at
+           FROM learnings
+           WHERE status = 'active' AND applies_to IS NOT NULL AND TRIM(applies_to) != ''
+           ORDER BY COALESCE(guard_hits, 0) DESC, updated_at DESC
+           LIMIT ?""",
+        (max_limit,),
+    ).fetchall()]
+
+    return {
+        "protocol_summary": protocol_summary,
+        "debt_summary": debt_summary,
+        "recent_tasks": recent_tasks,
+        "recent_debts": recent_debts,
+        "workflow_summary": workflow_summary,
+        "recent_runs": recent_runs,
+        "goal_summary": goal_summary,
+        "recent_goals": recent_goals,
+        "guard_summary": {
+            "recent_checks": len(guard_checks),
+            "blocking_hits": blocking_hits,
+            "areas": areas,
+        },
+        "guard_checks": guard_checks,
+        "conditioned_learnings": conditioned_learnings,
+    }
+
+
 # ---------------------------------------------------------------------------
 # HTML page routes — Jinja2 with fallback to plain file
 # ---------------------------------------------------------------------------
@@ -221,6 +448,10 @@ async def page_trust():
 async def page_guard():
     return _render("guard.html")
 
+@app.get("/protocol", response_class=HTMLResponse)
+async def page_protocol():
+    return _render("protocol.html", snapshot=_protocol_explainability_snapshot())
+
 @app.get("/cortex", response_class=HTMLResponse)
 async def page_cortex():
     return _render("cortex.html")
@@ -396,6 +627,30 @@ async def api_trust():
     }
 
 
+@app.get("/api/project-pulse")
+async def api_project_pulse(kind: str = Query("weekly", pattern="^(weekly|monthly)$")):
+    """Latest project pressure snapshot from Deep Sleep summaries."""
+    summary = _latest_periodic_summary(kind)
+    if not summary:
+        return JSONResponse({"error": f"No {kind} summary found"}, status_code=404)
+    return {
+        "kind": kind,
+        "label": summary.get("label"),
+        "project_pulse": summary.get("project_pulse", []),
+        "top_projects": summary.get("top_projects", []),
+    }
+
+
+@app.get("/api/engineering-loop")
+async def api_engineering_loop():
+    """Dashboard narrative: what matters now, what is drifting, what is improving."""
+    weekly = _latest_periodic_summary("weekly")
+    monthly = _latest_periodic_summary("monthly")
+    if not weekly and not monthly:
+        return JSONResponse({"error": "No periodic Deep Sleep summaries found"}, status_code=404)
+    return _summarize_engineering_loop(weekly or {}, monthly or {})
+
+
 @app.get("/api/adaptive")
 async def api_adaptive():
     """Adaptive personality: current weight state + mode history."""
@@ -1173,6 +1428,15 @@ async def api_trust_events(limit: int = Query(50, ge=1, le=200)):
     return {"events": [dict(r) for r in rows]}
 
 
+# ---------------------------------------------------------------------------
+# Protocol Explainability
+# ---------------------------------------------------------------------------
+
+@app.get("/api/protocol")
+async def api_protocol(limit: int = Query(20, ge=5, le=100)):
+    return _protocol_explainability_snapshot(limit=limit)
+
+
 # ---------------------------------------------------------------------------
 # Guard Heatmap
 # ---------------------------------------------------------------------------

package/src/dashboard/templates/base.html

@@ -162,6 +162,10 @@
             <svg class="w-4 h-4 flex-shrink-0" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M3.055 11H5a2 2 0 012 2v1a2 2 0 002 2 2 2 0 012 2v2.945M8 3.935V5.5A2.5 2.5 0 0010.5 8h.5a2 2 0 012 2 2 2 0 104 0 2 2 0 012-2h1.064M15 20.488V18a2 2 0 012-2h3.064M21 12a9 9 0 11-18 0 9 9 0 0118 0z"/></svg>
             Guard Heatmap
           </a>
+          <a href="/protocol" class="nav-item flex items-center gap-2.5 px-3 py-1.5 rounded-md text-xs text-slate-400 transition-colors" data-page="protocol">
+            <svg class="w-4 h-4 flex-shrink-0" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M9 12h6m-6 4h6M7 4h10a2 2 0 012 2v12a2 2 0 01-2 2H7a2 2 0 01-2-2V6a2 2 0 012-2z"/></svg>
+            Protocol Explainability
+          </a>
           <a href="/cortex" class="nav-item flex items-center gap-2.5 px-3 py-1.5 rounded-md text-xs text-slate-400 transition-colors" data-page="cortex">
             <svg class="w-4 h-4 flex-shrink-0" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M15 12a3 3 0 11-6 0 3 3 0 016 0z"/><path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M2.458 12C3.732 7.943 7.523 5 12 5c4.478 0 8.268 2.943 9.542 7-1.274 4.057-5.064 7-9.542 7-4.477 0-8.268-2.943-9.542-7z"/></svg>
             Cortex Monitor