nexo-brain 1.2.2 → 1.3.0

package/LICENSE

@@ -1,21 +1,26 @@
-MIT License
+GNU AFFERO GENERAL PUBLIC LICENSE
+Version 3, 19 November 2007
 
 Copyright (c) 2026 WAzion Apps
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+Additional permission under GNU AGPL version 3 section 7:
+
+If you modify this Program, or any covered work, by linking or combining
+it with other code, such combination is not by itself cause for the
+Program to be covered by the GNU Affero General Public License.
+
+For the full license text, see:
+https://www.gnu.org/licenses/agpl-3.0.en.html

package/README.md

@@ -4,7 +4,7 @@
 [![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)
+[![License: AGPL-3.0](https://img.shields.io/badge/License-AGPL--3.0-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)
 
 > **v1.1.1** — Context Continuity via auto-compaction hooks. PreCompact saves a full session checkpoint; PostCompact re-injects it so long sessions (8+ hours) feel like one continuous conversation. Plus: Cognitive Cortex, 30 Core Rules as DNA, Smart Startup, Context Packets, Auto-Prime. The first AI memory system with architectural inhibitory control — the agent reasons about whether to act before acting. Battle-tested from 6 months of production use, validated via multi-AI debate (Claude Opus + GPT-5.4 + Gemini 3.1 Pro).
 
@@ -650,7 +650,7 @@ If NEXO Brain is useful to you, consider:
 
 ## License
 
-MIT -- see [LICENSE](LICENSE)
+AGPL-3.0 -- see [LICENSE](LICENSE)
 
 ---
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "nexo-brain",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "mcpName": "io.github.wazionapps/nexo",
-  "description": "NEXO \u2014 Cognitive co-operator for Claude Code. Atkinson-Shiffrin memory, semantic RAG, trust scoring, and metacognitive error prevention.",
+  "description": "NEXO — Cognitive co-operator for Claude Code. Atkinson-Shiffrin memory, semantic RAG, trust scoring, and metacognitive error prevention.",
   "bin": {
     "nexo-brain": "./bin/nexo-brain.js"
   },
@@ -18,7 +18,7 @@
     "openclaw-plugin"
   ],
   "author": "NEXO Brain <info@nexo-brain.com>",
-  "license": "MIT",
+  "license": "AGPL-3.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/wazionapps/nexo.git"
@@ -32,4 +32,4 @@
     "templates/",
     "scripts/"
   ]
-}
+}

package/src/cognitive.py

@@ -1857,6 +1857,51 @@ def gc_stm():
     return (cur1.rowcount or 0) + (cur2.rowcount or 0)
 
 
+def gc_test_memories() -> int:
+    """Purge STM memories from test/dev sessions that pollute strength metrics.
+    Removes memories with test domains or known test content patterns.
+    Returns count of deleted memories.
+    """
+    db = _get_db()
+    test_domains = ("test", "test_session")
+    deleted = 0
+
+    # 1. Delete by test domain
+    for domain in test_domains:
+        cur = db.execute(
+            "DELETE FROM stm_memories WHERE domain = ? "
+            "AND (lifecycle_state IS NULL OR lifecycle_state != 'pinned')",
+            (domain,)
+        )
+        deleted += cur.rowcount or 0
+
+    # 2. Delete known test content patterns (empty domain, test-like content)
+    test_patterns = [
+        "%Secret redact test%",
+        "%quarantine test fact%",
+        "%Pin test memory%",
+        "%API rate limit%AM10%",
+        "%xyzzy server%",
+        "%Quantum entanglement enables FTL%",
+        "%Install Docker%AM10%",
+        "%normal safe content about coding%",
+        "%test diary%",
+        "%test critique%",
+        "%integration test diary%",
+    ]
+    for pattern in test_patterns:
+        cur = db.execute(
+            "DELETE FROM stm_memories WHERE content LIKE ? "
+            "AND (lifecycle_state IS NULL OR lifecycle_state != 'pinned')",
+            (pattern,)
+        )
+        deleted += cur.rowcount or 0
+
+    if deleted > 0:
+        db.commit()
+    return deleted
+
+
 def ingest_sensory(
     content: str,
     source_id: str = "",

package/src/evolution_cycle.py

@@ -0,0 +1,266 @@
+"""NEXO Evolution Cycle — Self-improvement via Opus API.
+
+Runs weekly after DMN. Analyzes patterns, proposes improvements.
+v1: observe-only (all proposals logged as 'proposed' for the owner to review).
+v1.1 (future): sandbox execution of auto-approved changes.
+"""
+
+import json
+import os
+import shutil
+import subprocess
+import sqlite3
+import time
+from datetime import datetime, date, timedelta
+from pathlib import Path
+
+NEXO_DB = Path.home() / "claude" / "nexo-mcp" / "nexo.db"
+CORTEX_DIR = Path(__file__).parent
+CLAUDE_DIR = Path.home() / "claude"
+SANDBOX_DIR = CLAUDE_DIR / "sandbox" / "workspace"
+SNAPSHOTS_DIR = CLAUDE_DIR / "snapshots"
+OBJECTIVE_FILE = CORTEX_DIR / "evolution-objective.json"
+PROMPT_FILE = CORTEX_DIR / "evolution-prompt.md"
+RESTORE_LOG = CLAUDE_DIR / "logs" / "snapshot-restores.log"
+
+MAX_SNAPSHOTS = 8
+
+
+def load_objective() -> dict:
+    if OBJECTIVE_FILE.exists():
+        return json.loads(OBJECTIVE_FILE.read_text())
+    return {}
+
+
+def save_objective(obj: dict):
+    OBJECTIVE_FILE.write_text(json.dumps(obj, indent=2, ensure_ascii=False))
+
+
+def get_week_data(db_path: str) -> dict:
+    """Gather last 7 days of learnings, decisions, changes, diaries."""
+    conn = sqlite3.connect(db_path, timeout=10)
+    conn.row_factory = sqlite3.Row
+    cutoff_epoch = time.time() - 7 * 86400
+    cutoff_date = (date.today() - timedelta(days=7)).isoformat()
+
+    data = {}
+
+    rows = conn.execute(
+        "SELECT category, title, content FROM learnings WHERE created_at > ? ORDER BY created_at DESC LIMIT 50",
+        (cutoff_epoch,)
+    ).fetchall()
+    data["learnings"] = [dict(r) for r in rows]
+
+    rows = conn.execute(
+        "SELECT domain, decision, alternatives, based_on, confidence, outcome FROM decisions "
+        "WHERE created_at > ? ORDER BY created_at DESC LIMIT 20",
+        (cutoff_date,)
+    ).fetchall()
+    data["decisions"] = [dict(r) for r in rows]
+
+    rows = conn.execute(
+        "SELECT files, what_changed, why, affects, risks FROM change_log "
+        "WHERE created_at > ? ORDER BY created_at DESC LIMIT 30",
+        (cutoff_date,)
+    ).fetchall()
+    data["changes"] = [dict(r) for r in rows]
+
+    rows = conn.execute(
+        "SELECT summary, decisions as diary_decisions, pending, mental_state, domain, user_signals "
+        "FROM session_diary WHERE created_at > ? ORDER BY created_at DESC LIMIT 20",
+        (cutoff_date,)
+    ).fetchall()
+    data["diaries"] = [dict(r) for r in rows]
+
+    rows = conn.execute(
+        "SELECT * FROM evolution_log ORDER BY id DESC LIMIT 20"
+    ).fetchall()
+    data["evolution_history"] = [dict(r) for r in rows]
+
+    rows = conn.execute(
+        "SELECT dimension, score, delta, measured_at FROM evolution_metrics "
+        "WHERE id IN (SELECT MAX(id) FROM evolution_metrics GROUP BY dimension)"
+    ).fetchall()
+    data["current_metrics"] = {r["dimension"]: dict(r) for r in rows}
+
+    conn.close()
+    return data
+
+
+def create_snapshot(files_to_backup: list) -> str:
+    """Create a snapshot of specific files before modification."""
+    ts = datetime.now().strftime("%Y-%m-%dT%H:%M")
+    snap_dir = SNAPSHOTS_DIR / ts
+    files_dir = snap_dir / "files"
+
+    manifest = {
+        "created_at": datetime.now().isoformat(),
+        "files": [],
+        "reason": "evolution_cycle"
+    }
+
+    for filepath in files_to_backup:
+        fp = Path(filepath).expanduser()
+        if fp.exists():
+            rel = str(fp).replace(str(Path.home()) + "/", "")
+            dest = files_dir / rel
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(fp, dest)
+            manifest["files"].append(rel)
+
+    snap_dir.mkdir(parents=True, exist_ok=True)
+    (snap_dir / "manifest.json").write_text(json.dumps(manifest, indent=2))
+
+    latest = SNAPSHOTS_DIR / "latest"
+    if latest.is_symlink():
+        latest.unlink()
+    latest.symlink_to(snap_dir)
+
+    _cleanup_snapshots()
+    return str(snap_dir)
+
+
+def _cleanup_snapshots():
+    """Remove old snapshots, keeping MAX_SNAPSHOTS most recent + golden."""
+    if not SNAPSHOTS_DIR.exists():
+        return
+    snaps = sorted(
+        [d for d in SNAPSHOTS_DIR.iterdir()
+         if d.is_dir() and d.name not in ("latest", "golden")],
+        key=lambda d: d.stat().st_mtime,
+        reverse=True
+    )
+    for old in snaps[MAX_SNAPSHOTS:]:
+        shutil.rmtree(old)
+
+
+def dry_run_restore_test() -> bool:
+    """Test that snapshot+restore works before making real changes."""
+    test_file = SANDBOX_DIR / "restore-test.txt"
+    test_file.parent.mkdir(parents=True, exist_ok=True)
+    test_file.write_text("original_content")
+
+    snap_dir = create_snapshot([str(test_file)])
+
+    test_file.write_text("modified_content")
+
+    try:
+        subprocess.run(
+            [str(CLAUDE_DIR / "scripts" / "nexo-snapshot-restore.sh"), snap_dir],
+            capture_output=True, timeout=10, check=True
+        )
+        content = test_file.read_text()
+        test_file.unlink(missing_ok=True)
+        # Clean up test snapshot
+        snap_path = Path(snap_dir)
+        if snap_path.exists():
+            shutil.rmtree(snap_path)
+        return content == "original_content"
+    except Exception:
+        test_file.unlink(missing_ok=True)
+        return False
+
+
+def build_evolution_prompt(week_data: dict, objective: dict) -> str:
+    """Build the prompt for the Opus Evolution cycle."""
+    if PROMPT_FILE.exists():
+        template = PROMPT_FILE.read_text()
+    else:
+        template = "You are NEXO Evolution. Analyze the data and propose improvements."
+
+    prompt = template + "\n\n## WEEKLY DATA\n\n"
+    prompt += f"### Learnings ({len(week_data.get('learnings', []))} this week)\n"
+    for l in week_data.get("learnings", [])[:30]:
+        prompt += f"- [{l['category']}] {l['title']}: {str(l['content'])[:150]}\n"
+
+    prompt += f"\n### Decisions ({len(week_data.get('decisions', []))} this week)\n"
+    for d in week_data.get("decisions", [])[:15]:
+        outcome = f" → {str(d['outcome'])[:80]}" if d.get("outcome") else " → no outcome yet"
+        prompt += f"- [{d['domain']}] {str(d['decision'])[:150]}{outcome}\n"
+
+    prompt += f"\n### Changes ({len(week_data.get('changes', []))} this week)\n"
+    for c in week_data.get("changes", [])[:20]:
+        prompt += f"- {str(c['files'])[:60]}: {str(c['what_changed'])[:100]}\n"
+
+    prompt += f"\n### Session Diaries ({len(week_data.get('diaries', []))} this week)\n"
+    for s in week_data.get("diaries", [])[:10]:
+        prompt += f"- [{s.get('domain','')}] {str(s['summary'])[:150]}\n"
+        if s.get("user_signals"):
+            prompt += f"  the owner: {str(s['user_signals'])[:100]}\n"
+
+    prompt += "\n### Current Dimension Scores\n"
+    for dim, m in week_data.get("current_metrics", {}).items():
+        prompt += f"- {dim}: {m['score']}% (delta: {m.get('delta', 0)})\n"
+
+    prompt += f"\n### Evolution History ({len(week_data.get('evolution_history', []))} entries)\n"
+    for h in week_data.get("evolution_history", [])[:10]:
+        prompt += f"- #{h['id']} [{h['status']}] {str(h['proposal'])[:100]}\n"
+
+    prompt += f"\n### Objective\n{json.dumps(objective, indent=2)}\n"
+
+    # Guard stats — error prevention effectiveness
+    try:
+        guard_conn = sqlite3.connect(str(NEXO_DB), timeout=10)
+        cutoff_7d = (date.today() - timedelta(days=7)).isoformat()
+        cutoff_epoch_7d = time.time() - 7 * 86400
+
+        total_reps = guard_conn.execute(
+            "SELECT COUNT(*) FROM error_repetitions WHERE created_at > ?", (cutoff_7d,)
+        ).fetchone()[0]
+        new_learnings_7d = guard_conn.execute(
+            "SELECT COUNT(*) FROM learnings WHERE created_at > ?", (cutoff_epoch_7d,)
+        ).fetchone()[0]
+        rep_rate = round(total_reps / new_learnings_7d, 2) if new_learnings_7d > 0 else 0.0
+        guard_checks = guard_conn.execute(
+            "SELECT COUNT(*) FROM guard_checks WHERE created_at > ?", (cutoff_7d,)
+        ).fetchone()[0]
+
+        top_areas = guard_conn.execute(
+            "SELECT area, COUNT(*) as cnt FROM error_repetitions WHERE created_at > ? GROUP BY area ORDER BY cnt DESC LIMIT 5",
+            (cutoff_7d,)
+        ).fetchall()
+
+        most_ignored = guard_conn.execute(
+            "SELECT original_learning_id, COUNT(*) as cnt FROM error_repetitions "
+            "GROUP BY original_learning_id HAVING cnt >= 3 ORDER BY cnt DESC LIMIT 5"
+        ).fetchall()
+
+        guard_conn.close()
+
+        prompt += "\n### Guard Stats (Error Prevention)\n"
+        prompt += f"- Repetition rate: {rep_rate:.0%} (target: <15%)\n"
+        prompt += f"- Guard checks this week: {guard_checks} (target: >5/session)\n"
+        prompt += f"- New learnings: {new_learnings_7d}, Repetitions: {total_reps}\n"
+        if top_areas:
+            prompt += "- Top problem areas: " + ", ".join(f"{r[0]}({r[1]})" for r in top_areas) + "\n"
+        if most_ignored:
+            prompt += "- Most ignored learnings (3+ repeats): " + ", ".join(f"#{r[0]}({r[1]}x)" for r in most_ignored) + "\n"
+        prompt += "- Propose more aggressive rules for areas with high repetition rate.\n"
+    except Exception:
+        pass
+
+    # Infrastructure inventory — so Opus knows what exists before proposing changes
+    inventory_script = Path.home() / "claude" / "scripts" / "nexo-infra-inventory.sh"
+    if inventory_script.exists():
+        try:
+            result = subprocess.run(
+                ["bash", str(inventory_script)],
+                capture_output=True, text=True, timeout=10
+            )
+            if result.stdout.strip():
+                prompt += f"\n### Infrastructure Inventory (hooks, scripts, memory, crons)\n"
+                prompt += "Before proposing any change, check this inventory to avoid duplicating existing infrastructure.\n"
+                prompt += f"```json\n{result.stdout.strip()}\n```\n"
+        except Exception:
+            pass
+
+    return prompt
+
+
+def max_auto_changes(total_evolutions: int) -> int:
+    """Progressive trust: 1 for first 4 cycles, 2 for next 4, then 3."""
+    if total_evolutions < 4:
+        return 1
+    elif total_evolutions < 8:
+        return 2
+    return 3