nexo-brain 2.4.0 → 2.5.0

package/src/cli.py

@@ -0,0 +1,605 @@
+#!/usr/bin/env python3
+"""NEXO Runtime CLI — operational commands for scripts and diagnostics.
+
+Entry points:
+  nexo scripts list [--all] [--json]
+  nexo scripts run NAME_OR_PATH [-- args...]
+  nexo scripts doctor [NAME_OR_PATH] [--json]
+  nexo scripts call TOOL --input JSON [--json-output]
+  nexo skills list [--level ...] [--source-kind ...] [--json]
+  nexo skills get ID [--json]
+  nexo skills apply ID [--params JSON] [--mode ...] [--dry-run] [--json]
+  nexo skills sync [--json]
+  nexo skills approve ID [--execution-level ...] [--approved-by ...] [--json]
+  nexo skills featured [--limit N] [--json]
+  nexo skills evolution [--json]
+  nexo doctor [--tier boot|runtime|deep|all] [--json] [--fix]
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import contextlib
+import io
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent)))
+
+# Ensure src/ is on path for imports
+if str(NEXO_CODE) not in sys.path:
+    sys.path.insert(0, str(NEXO_CODE))
+
+
+def _scripts_list(args):
+    from script_registry import list_scripts
+    scripts = list_scripts(include_core=args.all)
+    if args.json:
+        print(json.dumps(scripts, indent=2))
+    else:
+        if not scripts:
+            print("No personal scripts found in", NEXO_HOME / "scripts")
+            return 0
+        # Table output
+        name_w = max(len(s["name"]) for s in scripts)
+        rt_w = max(len(s["runtime"]) for s in scripts)
+        for s in scripts:
+            tag = " [core]" if s.get("core") else ""
+            print(f"  {s['name']:<{name_w}}  {s['runtime']:<{rt_w}}  {s['description']}{tag}")
+    return 0
+
+
+def _scripts_run(args):
+    from script_registry import resolve_script_reference
+
+    info = resolve_script_reference(args.name)
+    if not info:
+        print(f"Script not found: {args.name}", file=sys.stderr)
+        return 1
+
+    path = Path(info["path"])
+    runtime = info["runtime"]
+    meta = info["metadata"]
+    is_core = info.get("core", False)
+
+    # Build environment
+    env = {
+        **os.environ,
+        "NEXO_HOME": str(NEXO_HOME),
+        "NEXO_CODE": str(NEXO_CODE),
+        "NEXO_SCRIPT_NAME": info["name"],
+        "NEXO_SCRIPT_PATH": str(path),
+        "NEXO_CLI": "nexo",
+    }
+
+    # Only inject DB paths for core scripts
+    if is_core:
+        env["NEXO_DB"] = str(NEXO_HOME / "data" / "nexo.db")
+        env["NEXO_COGNITIVE_DB"] = str(NEXO_HOME / "data" / "cognitive.db")
+
+    # Timeout
+    timeout = None
+    timeout_str = meta.get("timeout", "")
+    if timeout_str:
+        try:
+            timeout = int(timeout_str)
+        except ValueError:
+            pass
+
+    # Build command
+    if runtime == "python":
+        cmd = [sys.executable, str(path)] + args.script_args
+    elif runtime == "shell":
+        cmd = ["bash", str(path)] + args.script_args
+    else:
+        # Try to execute directly
+        cmd = [str(path)] + args.script_args
+
+    try:
+        result = subprocess.run(cmd, env=env, timeout=timeout)
+        return result.returncode
+    except subprocess.TimeoutExpired:
+        print(f"Script timed out after {timeout}s", file=sys.stderr)
+        return 124
+    except Exception as e:
+        print(f"Error running script: {e}", file=sys.stderr)
+        return 1
+
+
+def _scripts_doctor(args):
+    from script_registry import doctor_script, doctor_all_scripts
+
+    if args.name:
+        results = [doctor_script(args.name)]
+    else:
+        results = doctor_all_scripts()
+
+    if args.json:
+        print(json.dumps(results, indent=2))
+    else:
+        if not results:
+            print("No personal scripts to check.")
+            return 0
+        any_fail = False
+        for r in results:
+            name = r.get("name", "?")
+            status = r.get("status", "?")
+            icon = {"pass": "✓", "warn": "⚠", "fail": "✗"}.get(status, "?")
+            print(f"\n{icon} {name} [{status}]")
+            for item in r.get("items", []):
+                lvl = item["level"]
+                prefix = {"pass": "  ✓", "warn": "  ⚠", "fail": "  ✗"}.get(lvl, "  ?")
+                print(f"{prefix} {item['msg']}")
+            if status == "fail":
+                any_fail = True
+        print()
+        return 1 if any_fail else 0
+
+    return 0
+
+
+def _scripts_call(args):
+    """Call a NEXO MCP tool via in-process fastmcp client."""
+    tool_name = args.tool
+    try:
+        payload = json.loads(args.input) if args.input else {}
+    except json.JSONDecodeError as e:
+        print(f"Invalid JSON input: {e}", file=sys.stderr)
+        return 1
+
+    def _bootstrap_mcp():
+        os.environ["NEXO_CLI_MODE"] = "1"
+        from db import init_db
+        from plugin_loader import load_all_plugins
+        from server import mcp
+
+        init_db()
+
+        # Plugin loading is required so scripts can call plugin tools such as
+        # nexo_doctor, but the loader is noisy on stderr and would pollute CLI output.
+        with contextlib.redirect_stderr(io.StringIO()):
+            load_all_plugins(mcp)
+
+        return mcp
+
+    def _extract_tool_value(result):
+        structured = getattr(result, "structured_content", None)
+        if structured not in (None, {}):
+            return structured
+
+        content = getattr(result, "content", None)
+        if isinstance(content, list):
+            texts = [item.text for item in content if hasattr(item, "text")]
+            if texts:
+                return "\n".join(texts)
+
+        dumped = getattr(result, "model_dump", None)
+        if callable(dumped):
+            data = dumped()
+            if isinstance(data, dict):
+                return data.get("structured_content") or data.get("content") or data
+
+        return str(result)
+
+    try:
+        mcp = _bootstrap_mcp()
+
+        async def _call():
+            tool = await mcp.get_tool(tool_name)
+            if tool is None:
+                tools = await mcp.list_tools()
+                available = sorted(t.name for t in tools)
+                raise LookupError(
+                    f"Tool not found: {tool_name}\nAvailable tools: {', '.join(available)}"
+                )
+            return await mcp.call_tool(tool_name, payload)
+
+        result = asyncio.run(_call())
+        value = _extract_tool_value(result)
+
+        if args.json_output:
+            if (
+                isinstance(value, dict)
+                and set(value.keys()) == {"result"}
+                and isinstance(value["result"], str)
+            ):
+                try:
+                    value = json.loads(value["result"])
+                except json.JSONDecodeError:
+                    pass
+            if isinstance(value, str):
+                try:
+                    value = json.loads(value)
+                except json.JSONDecodeError:
+                    value = {"result": value}
+            elif not isinstance(value, (dict, list)):
+                value = {"result": value}
+            print(json.dumps(value, indent=2, ensure_ascii=False))
+            return 0
+
+        if isinstance(value, dict) and set(value.keys()) == {"result"} and isinstance(value["result"], str):
+            print(value["result"])
+        elif isinstance(value, (dict, list)):
+            print(json.dumps(value, indent=2, ensure_ascii=False))
+        else:
+            print(value)
+        return 0
+
+    except LookupError as e:
+        print(str(e), file=sys.stderr)
+        return 1
+    except Exception as e:
+        print(f"Error calling tool {tool_name}: {e}", file=sys.stderr)
+        return 1
+
+
+def _update(args):
+    """Sync all repo files to NEXO_HOME."""
+    import shutil
+
+    src_dir = NEXO_CODE
+    repo_dir = NEXO_CODE.parent
+    dest = NEXO_HOME
+
+    # Packages (directories with __init__.py or known structure)
+    packages = ["db", "cognitive", "doctor", "dashboard", "rules", "crons", "hooks"]
+    copied_packages = 0
+    for pkg in packages:
+        pkg_src = src_dir / pkg
+        pkg_dest = dest / pkg
+        if pkg_src.is_dir():
+            if pkg_dest.exists():
+                shutil.rmtree(str(pkg_dest), ignore_errors=True)
+            shutil.copytree(
+                str(pkg_src), str(pkg_dest),
+                ignore=shutil.ignore_patterns("__pycache__", "*.pyc", "*.pyo", "*.db"),
+            )
+            copied_packages += 1
+
+    # Flat Python files
+    flat_files = [
+        "server.py", "plugin_loader.py", "knowledge_graph.py", "kg_populate.py",
+        "maintenance.py", "storage_router.py", "claim_graph.py", "hnsw_index.py",
+        "evolution_cycle.py", "migrate_embeddings.py", "auto_close_sessions.py",
+        "auto_update.py", "tools_sessions.py", "tools_coordination.py",
+        "tools_reminders.py", "tools_reminders_crud.py", "tools_learnings.py",
+        "tools_credentials.py", "tools_task_history.py", "tools_menu.py",
+        "cli.py", "script_registry.py", "skills_runtime.py", "user_context.py",
+        "requirements.txt",
+    ]
+    copied_files = 0
+    for f in flat_files:
+        src_f = src_dir / f
+        if src_f.is_file():
+            shutil.copy2(str(src_f), str(dest / f))
+            copied_files += 1
+
+    # Plugins
+    plugins_src = src_dir / "plugins"
+    plugins_dest = dest / "plugins"
+    if plugins_src.is_dir():
+        plugins_dest.mkdir(parents=True, exist_ok=True)
+        for f in plugins_src.iterdir():
+            if f.is_file() and f.suffix == ".py":
+                shutil.copy2(str(f), str(plugins_dest / f.name))
+
+    # Scripts
+    scripts_src = src_dir / "scripts"
+    scripts_dest = dest / "scripts"
+    if scripts_src.is_dir():
+        for f in scripts_src.iterdir():
+            if f.name == "__pycache__" or f.name.startswith("."):
+                continue
+            dst = scripts_dest / f.name
+            if f.is_dir():
+                if dst.exists():
+                    shutil.rmtree(str(dst), ignore_errors=True)
+                shutil.copytree(str(f), str(dst), ignore=shutil.ignore_patterns("__pycache__", "*.pyc"))
+            elif f.is_file():
+                shutil.copy2(str(f), str(dst))
+                if f.suffix == ".sh":
+                    dst.chmod(0o755)
+
+    # Templates
+    templates_src = repo_dir / "templates"
+    templates_dest = dest / "templates"
+    if templates_src.is_dir():
+        templates_dest.mkdir(parents=True, exist_ok=True)
+        for f in templates_src.iterdir():
+            if f.is_file():
+                shutil.copy2(str(f), str(templates_dest / f.name))
+
+    # Core skills
+    skills_src = src_dir / "skills"
+    skills_dest = dest / "skills-core"
+    if skills_src.is_dir():
+        if skills_dest.exists():
+            shutil.rmtree(str(skills_dest), ignore_errors=True)
+        shutil.copytree(
+            str(skills_src), str(skills_dest),
+            ignore=shutil.ignore_patterns("__pycache__", "*.pyc"),
+        )
+
+    # Runtime CLI wrapper
+    bin_dir = dest / "bin"
+    bin_dir.mkdir(parents=True, exist_ok=True)
+    wrapper = bin_dir / "nexo"
+    wrapper_content = (
+        "#!/usr/bin/env bash\n"
+        "set -euo pipefail\n\n"
+        f'NEXO_HOME="{dest}"\n'
+        'PYTHON="$NEXO_HOME/.venv/bin/python3"\n'
+        'if [ ! -x "$PYTHON" ]; then\n'
+        '  if command -v python3 >/dev/null 2>&1; then PYTHON="python3"; else PYTHON="python"; fi\n'
+        'fi\n'
+        'export NEXO_HOME\n'
+        'export NEXO_CODE="$NEXO_HOME"\n'
+        'exec "$PYTHON" "$NEXO_HOME/cli.py" "$@"\n'
+    )
+    wrapper.write_text(wrapper_content)
+    wrapper.chmod(0o755)
+
+    result = {
+        "packages": copied_packages,
+        "files": copied_files,
+        "nexo_home": str(dest),
+        "source": str(src_dir),
+    }
+    if args.json:
+        print(json.dumps(result, indent=2))
+    else:
+        print(f"Updated NEXO_HOME ({dest})")
+        print(f"  {copied_packages} packages, {copied_files} files synced from {src_dir}")
+    return 0
+
+
+def _doctor(args):
+    """Run unified doctor diagnostics."""
+    try:
+        from db import init_db
+        from doctor.orchestrator import run_doctor
+        from doctor.formatters import format_report
+    except ImportError:
+        print("Doctor module not found. Ensure NEXO is properly installed.", file=sys.stderr)
+        return 1
+
+    init_db()
+    report = run_doctor(tier=args.tier, fix=args.fix)
+    output = format_report(report, fmt="json" if args.json else "text")
+    print(output)
+
+    if report.overall_status == "critical":
+        return 2
+    elif report.overall_status == "degraded":
+        return 1
+    return 0
+
+
+def _skills_list(args):
+    from db import init_db, list_skills, sync_skill_directories
+
+    init_db()
+    sync_skill_directories()
+    skills = list_skills(level=args.level, tag=args.tag, source_kind=args.source_kind)
+    if args.json:
+        print(json.dumps(skills, indent=2, ensure_ascii=False))
+        return 0
+
+    if not skills:
+        print("No skills found.")
+        return 0
+
+    for skill in skills:
+        print(
+            f"[{skill['id']}] {skill['name']} "
+            f"({skill['level']}, {skill.get('mode', 'guide')}, {skill.get('source_kind', 'personal')}, "
+            f"trust={skill['trust_score']}, used={skill['use_count']}x)"
+        )
+    return 0
+
+
+def _skills_get(args):
+    from db import get_skill, init_db, sync_skill_directories
+
+    init_db()
+    sync_skill_directories()
+    skill = get_skill(args.id)
+    if not skill:
+        print(f"Skill not found: {args.id}", file=sys.stderr)
+        return 1
+    if args.json:
+        print(json.dumps(skill, indent=2, ensure_ascii=False))
+    else:
+        print(json.dumps(skill, indent=2, ensure_ascii=False))
+    return 0
+
+
+def _skills_apply(args):
+    from skills_runtime import apply_skill
+
+    try:
+        params = json.loads(args.params) if args.params else {}
+    except json.JSONDecodeError as e:
+        print(f"Invalid params JSON: {e}", file=sys.stderr)
+        return 1
+
+    result = apply_skill(args.id, params=params, mode=args.mode, dry_run=args.dry_run, context=args.context)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    return 0 if result.get("ok") else 1
+
+
+def _skills_sync(args):
+    from skills_runtime import sync_skills
+
+    result = sync_skills()
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    return 0 if not result.get("issues") else 1
+
+
+def _skills_approve(args):
+    from skills_runtime import approve_skill_execution
+
+    result = approve_skill_execution(args.id, execution_level=args.execution_level, approved_by=args.approved_by)
+    if "error" in result:
+        print(result["error"], file=sys.stderr)
+        return 1
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    return 0
+
+
+def _skills_featured(args):
+    from skills_runtime import get_featured_skill_summaries
+
+    result = get_featured_skill_summaries(limit=args.limit)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    return 0
+
+
+def _skills_evolution(args):
+    from skills_runtime import list_evolution_candidates
+
+    result = list_evolution_candidates()
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    return 0
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="nexo", description="NEXO Runtime CLI")
+    sub = parser.add_subparsers(dest="command")
+
+    # -- scripts --
+    scripts_parser = sub.add_parser("scripts", help="Manage personal scripts")
+    scripts_sub = scripts_parser.add_subparsers(dest="scripts_command")
+
+    # scripts list
+    list_p = scripts_sub.add_parser("list", help="List scripts")
+    list_p.add_argument("--all", action="store_true", help="Include core/internal scripts")
+    list_p.add_argument("--json", action="store_true", help="JSON output")
+
+    # scripts run
+    run_p = scripts_sub.add_parser("run", help="Run a script by name")
+    run_p.add_argument("name", help="Script name")
+    run_p.add_argument("script_args", nargs="*", help="Arguments to pass to the script")
+
+    # scripts doctor
+    doc_p = scripts_sub.add_parser("doctor", help="Validate scripts")
+    doc_p.add_argument("name", nargs="?", help="Specific script to check")
+    doc_p.add_argument("--json", action="store_true", help="JSON output")
+
+    # scripts call
+    call_p = scripts_sub.add_parser("call", help="Call a NEXO MCP tool")
+    call_p.add_argument("tool", help="MCP tool name")
+    call_p.add_argument("--input", default="{}", help="JSON input payload")
+    call_p.add_argument("--json-output", action="store_true", help="Force JSON output")
+
+    # -- update --
+    update_parser = sub.add_parser("update", help="Sync all repo files to NEXO_HOME")
+    update_parser.add_argument("--json", action="store_true", help="JSON output")
+
+    # -- doctor --
+    doctor_parser = sub.add_parser("doctor", help="Unified diagnostics")
+    doctor_parser.add_argument("--tier", default="boot", choices=["boot", "runtime", "deep", "all"],
+                               help="Diagnostic tier (default: boot)")
+    doctor_parser.add_argument("--json", action="store_true", help="JSON output")
+    doctor_parser.add_argument("--fix", action="store_true", help="Apply deterministic fixes")
+
+    # -- skills --
+    skills_parser = sub.add_parser("skills", help="Skills v2 runtime")
+    skills_sub = skills_parser.add_subparsers(dest="skills_command")
+
+    skills_list_p = skills_sub.add_parser("list", help="List skills")
+    skills_list_p.add_argument("--level", default="", help="Filter by level")
+    skills_list_p.add_argument("--tag", default="", help="Filter by tag")
+    skills_list_p.add_argument("--source-kind", default="", help="Filter by source kind")
+    skills_list_p.add_argument("--json", action="store_true", help="JSON output")
+
+    skills_get_p = skills_sub.add_parser("get", help="Get skill")
+    skills_get_p.add_argument("id", help="Skill ID")
+    skills_get_p.add_argument("--json", action="store_true", help="JSON output")
+
+    skills_apply_p = skills_sub.add_parser("apply", help="Apply a skill")
+    skills_apply_p.add_argument("id", help="Skill ID")
+    skills_apply_p.add_argument("--params", default="{}", help="JSON parameters")
+    skills_apply_p.add_argument("--mode", default="auto", choices=["auto", "guide", "execute", "hybrid"])
+    skills_apply_p.add_argument("--dry-run", action="store_true", help="Render without executing")
+    skills_apply_p.add_argument("--context", default="", help="Usage context for feedback loop")
+    skills_apply_p.add_argument("--json", action="store_true", help="JSON output")
+
+    skills_sync_p = skills_sub.add_parser("sync", help="Sync filesystem skills")
+    skills_sync_p.add_argument("--json", action="store_true", help="JSON output")
+
+    skills_approve_p = skills_sub.add_parser("approve", help="Approve an executable skill")
+    skills_approve_p.add_argument("id", help="Skill ID")
+    skills_approve_p.add_argument("--execution-level", default="", choices=["", "read-only", "local", "remote"])
+    skills_approve_p.add_argument("--approved-by", default="", help="Approver name")
+    skills_approve_p.add_argument("--json", action="store_true", help="JSON output")
+
+    skills_featured_p = skills_sub.add_parser("featured", help="Featured startup skills")
+    skills_featured_p.add_argument("--limit", type=int, default=5)
+    skills_featured_p.add_argument("--json", action="store_true", help="JSON output")
+
+    skills_evolution_p = skills_sub.add_parser("evolution", help="Evolution candidates")
+    skills_evolution_p.add_argument("--json", action="store_true", help="JSON output")
+
+    args = parser.parse_args()
+
+    if args.command == "scripts":
+        if args.scripts_command == "list":
+            return _scripts_list(args)
+        elif args.scripts_command == "run":
+            return _scripts_run(args)
+        elif args.scripts_command == "doctor":
+            return _scripts_doctor(args)
+        elif args.scripts_command == "call":
+            return _scripts_call(args)
+        else:
+            scripts_parser.print_help()
+            return 0
+    elif args.command == "update":
+        return _update(args)
+    elif args.command == "doctor":
+        return _doctor(args)
+    elif args.command == "skills":
+        if args.skills_command == "list":
+            return _skills_list(args)
+        elif args.skills_command == "get":
+            return _skills_get(args)
+        elif args.skills_command == "apply":
+            return _skills_apply(args)
+        elif args.skills_command == "sync":
+            return _skills_sync(args)
+        elif args.skills_command == "approve":
+            return _skills_approve(args)
+        elif args.skills_command == "featured":
+            return _skills_featured(args)
+        elif args.skills_command == "evolution":
+            return _skills_evolution(args)
+        else:
+            skills_parser.print_help()
+            return 0
+    else:
+        parser.print_help()
+        return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src/cognitive/_ingest.py

@@ -79,7 +79,7 @@ def ingest(
 
     # Auto-pin: corrections and blocking learnings get pinned (zero decay, +0.2 boost)
     # This ensures user's corrections NEVER fade away
-    _pin_lifecycle = None
+    _pin_lifecycle = 'active'
     if auto_pin or (source_type in ('learning', 'feedback') and
                     any(kw in content.upper() for kw in ('BLOCKING', 'CRÍTICO', 'CRITICAL', 'NUNCA', 'NEVER', 'PROHIBIDO'))):
         _pin_lifecycle = 'pinned'

package/src/cognitive/_memory.py

@@ -398,20 +398,20 @@ def get_stats() -> dict:
     """Return statistics about the cognitive memory system."""
     db = _get_db()
 
-    stm_active = db.execute("SELECT COUNT(*) FROM stm_memories WHERE lifecycle_state = 'active' AND promoted_to_ltm = 0").fetchone()[0]
+    stm_active = db.execute("SELECT COUNT(*) FROM stm_memories WHERE lifecycle_state IN ('active', 'pinned') AND promoted_to_ltm = 0").fetchone()[0]
     stm_promoted = db.execute("SELECT COUNT(*) FROM stm_memories WHERE promoted_to_ltm = 1").fetchone()[0]
-    stm_total = db.execute("SELECT COUNT(*) FROM stm_memories WHERE lifecycle_state = 'active'").fetchone()[0]
+    stm_total = db.execute("SELECT COUNT(*) FROM stm_memories WHERE lifecycle_state IN ('active', 'pinned')").fetchone()[0]
     ltm_active = db.execute("SELECT COUNT(*) FROM ltm_memories WHERE is_dormant = 0").fetchone()[0]
     ltm_dormant = db.execute("SELECT COUNT(*) FROM ltm_memories WHERE is_dormant = 1").fetchone()[0]
 
-    avg_stm = db.execute("SELECT AVG(strength) FROM stm_memories WHERE lifecycle_state = 'active' AND promoted_to_ltm = 0").fetchone()[0] or 0.0
+    avg_stm = db.execute("SELECT AVG(strength) FROM stm_memories WHERE lifecycle_state IN ('active', 'pinned') AND promoted_to_ltm = 0").fetchone()[0] or 0.0
     avg_ltm = db.execute("SELECT AVG(strength) FROM ltm_memories WHERE is_dormant = 0").fetchone()[0] or 0.0
 
     total_retrievals = db.execute("SELECT COUNT(*) FROM retrieval_log").fetchone()[0]
     avg_retrieval_score = db.execute("SELECT AVG(top_score) FROM retrieval_log").fetchone()[0] or 0.0
 
     top_domains_stm = db.execute(
-        "SELECT domain, COUNT(*) as cnt FROM stm_memories WHERE lifecycle_state = 'active' AND promoted_to_ltm = 0 AND domain != '' GROUP BY domain ORDER BY cnt DESC LIMIT 5"
+        "SELECT domain, COUNT(*) as cnt FROM stm_memories WHERE lifecycle_state IN ('active', 'pinned') AND promoted_to_ltm = 0 AND domain != '' GROUP BY domain ORDER BY cnt DESC LIMIT 5"
     ).fetchall()
     top_domains_ltm = db.execute(
         "SELECT domain, COUNT(*) as cnt FROM ltm_memories WHERE is_dormant = 0 AND domain != '' GROUP BY domain ORDER BY cnt DESC LIMIT 5"

package/src/crons/manifest.json

@@ -94,6 +94,14 @@
       "run_at_load": true,
       "description": "Morning catchup briefing for the user",
       "core": true
+    },
+    {
+      "id": "day-orchestrator",
+      "script": "scripts/nexo-day-orchestrator.sh",
+      "type": "shell",
+      "description": "Autonomous NEXO cycle — checks followups, emails, infra every 15 min (8:00-23:00)",
+      "core": true,
+      "optional": "orchestrator"
     }
   ]
 }