nexo-brain 2.7.0 → 3.0.1

package/src/plugins/schedule.py

@@ -9,6 +9,7 @@ from pathlib import Path
 from db import (
     init_db, cron_runs_recent, cron_runs_summary,
     upsert_personal_script, register_personal_script_schedule,
+    get_personal_script_schedule,
 )
 from script_registry import (
     PERSONAL_SCHEDULE_MANAGED_ENV,
@@ -29,13 +30,18 @@ def handle_schedule_status(hours: int = 24, cron_id: str = '') -> str:
         runs = cron_runs_recent(hours, cron_id)
         if not runs:
             return f"No runs for '{cron_id}' in the last {hours}h."
+        schedule_meta = get_personal_script_schedule(cron_id) or {}
         lines = [f"CRON RUNS — {cron_id} (last {hours}h): {len(runs)} executions"]
         for r in runs:
-            status = "✅" if r.get("exit_code") == 0 else "❌"
-            dur = f"{r['duration_secs']:.0f}s" if r.get("duration_secs") else "running"
+            status, detail = _run_status_marker(r.get("exit_code"), r.get("summary"), schedule_meta=schedule_meta)
+            if schedule_meta.get("schedule_type") == "keep_alive" and r.get("exit_code") is None:
+                dur = "daemon active"
+            else:
+                dur = f"{r['duration_secs']:.0f}s" if r.get("duration_secs") else "running"
             summary = f" — {r['summary'][:100]}" if r.get("summary") else ""
             error = f" ERROR: {r['error'][:100]}" if r.get("error") else ""
-            lines.append(f"  {status} {r['started_at']} ({dur}){summary}{error}")
+            suffix = f" [{detail}]" if detail else ""
+            lines.append(f"  {status} {r['started_at']} ({dur}){summary}{error}{suffix}")
         return "\n".join(lines)
 
     # Summary view — one line per cron
@@ -45,15 +51,43 @@ def handle_schedule_status(hours: int = 24, cron_id: str = '') -> str:
 
     lines = [f"CRON STATUS (last {hours}h):"]
     for s in summary:
-        status = "✅" if s.get("last_exit_code") == 0 else "❌"
-        rate = f"{s['succeeded']}/{s['total_runs']}"
+        schedule_meta = get_personal_script_schedule(s["cron_id"]) or {}
+        status, detail = _run_status_marker(s.get("last_exit_code"), s.get("last_summary"), schedule_meta=schedule_meta)
+        if schedule_meta.get("schedule_type") == "keep_alive" and s.get("last_exit_code") is None:
+            rate = "daemon active"
+        else:
+            rate = f"{s['succeeded']}/{s['total_runs']}"
         dur = f"{s['avg_duration']:.0f}s avg" if s.get("avg_duration") else ""
         summary_txt = f" — {s['last_summary'][:80]}" if s.get("last_summary") else ""
-        lines.append(f"  {status} {s['cron_id']}: {rate} OK, {dur}{summary_txt}")
+        suffix = f" [{detail}]" if detail else ""
+        lines.append(f"  {status} {s['cron_id']}: {rate}, {dur}{summary_txt}{suffix}")
 
     return "\n".join(lines)
 
 
+def _summary_has_warning(summary: str = "") -> bool:
+    lowered = str(summary or "").strip().lower()
+    if not lowered:
+        return False
+    if "no warning" in lowered or "without warnings" in lowered:
+        return False
+    warning_tokens = ("warning", "warnings", "warn:", "degraded", "partial failure", "issues detected")
+    return any(token in lowered for token in warning_tokens)
+
+
+def _run_status_marker(exit_code, summary: str = "", *, schedule_meta: dict | None = None) -> tuple[str, str]:
+    schedule_meta = schedule_meta or {}
+    if schedule_meta.get("schedule_type") == "keep_alive" and exit_code is None:
+        return "🟢", "keep_alive daemon active"
+    if exit_code == 0 and _summary_has_warning(summary):
+        return "⚠", "exit 0 with warnings"
+    if exit_code == 0:
+        return "✅", "exit 0"
+    if exit_code is None:
+        return "❌", "missing exit code"
+    return "❌", f"exit {exit_code}"
+
+
 def handle_schedule_add(cron_id: str, script: str, schedule: str = '',
                         interval_seconds: int = 0, description: str = '',
                         script_type: str = 'auto', keep_alive: bool = False) -> str:

package/src/plugins/simple_api.py

@@ -0,0 +1,103 @@
+"""Minimal public API wrappers for the core NEXO mental model."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+
+import cognitive
+
+from plugins.episodic_memory import handle_recall
+from plugins.workflow import handle_workflow_open
+
+
+def handle_remember(
+    content: str,
+    title: str = "",
+    domain: str = "",
+    source_type: str = "note",
+    tags: str = "",
+    bypass_gate: bool = True,
+) -> str:
+    """Store one durable memory item with a single high-level call."""
+    clean_content = (content or "").strip()
+    if not clean_content:
+        return json.dumps({"ok": False, "error": "content is required"}, ensure_ascii=False, indent=2)
+
+    clean_title = (title or "").strip()[:120]
+    source_id = hashlib.sha1(f"{clean_title}|{clean_content}".encode("utf-8")).hexdigest()[:12]
+    memory_id = cognitive.ingest_to_ltm(
+        clean_content,
+        source_type=(source_type or "note").strip()[:40],
+        source_id=source_id,
+        source_title=clean_title or clean_content[:80],
+        domain=(domain or "").strip()[:120],
+        tags=(tags or "").strip()[:200],
+        bypass_gate=bool(bypass_gate),
+    )
+    return json.dumps(
+        {
+            "ok": bool(memory_id),
+            "memory_id": int(memory_id or 0),
+            "source_type": (source_type or "note").strip()[:40],
+            "title": clean_title or clean_content[:80],
+            "domain": (domain or "").strip()[:120],
+        },
+        ensure_ascii=False,
+        indent=2,
+    )
+
+
+def handle_memory_recall(query: str, days: int = 30) -> str:
+    """High-level memory lookup wrapper around nexo_recall."""
+    return handle_recall((query or "").strip(), days=max(1, int(days or 30)))
+
+
+def handle_consolidate(
+    max_insights: int = 12,
+    threshold: float = 0.9,
+    dry_run: bool = False,
+) -> str:
+    """Run the core memory consolidation cycle explicitly."""
+    promoted = cognitive.promote_stm_to_ltm()
+    quarantine = cognitive.process_quarantine()
+    dreamed = cognitive.dream_cycle(max_insights=max(1, int(max_insights or 12)))
+    semantic = cognitive.consolidate_semantic(threshold=float(threshold or 0.9), dry_run=bool(dry_run))
+    payload = {
+        "ok": True,
+        "promoted_to_ltm": int(promoted or 0),
+        "quarantine": quarantine,
+        "dream_cycle": dreamed,
+        "semantic_consolidation": semantic,
+        "dry_run": bool(dry_run),
+    }
+    return json.dumps(payload, ensure_ascii=False, indent=2)
+
+
+def handle_run_workflow(
+    sid: str,
+    goal: str,
+    steps: str = "[]",
+    goal_id: str = "",
+    shared_state: str = "{}",
+    owner: str = "",
+    idempotency_key: str = "",
+) -> str:
+    """Open a durable workflow with the public mental-model naming."""
+    return handle_workflow_open(
+        sid=sid,
+        goal=goal,
+        steps=steps,
+        goal_id=goal_id,
+        shared_state=shared_state,
+        owner=owner,
+        idempotency_key=idempotency_key,
+    )
+
+
+TOOLS = [
+    (handle_remember, "nexo_remember", "High-level memory write: store one durable memory item."),
+    (handle_memory_recall, "nexo_memory_recall", "High-level memory lookup wrapper around nexo_recall."),
+    (handle_consolidate, "nexo_consolidate", "Run NEXO memory consolidation explicitly: promote, process quarantine, dream, consolidate."),
+    (handle_run_workflow, "nexo_run_workflow", "High-level durable workflow entry point for the public API surface."),
+]

package/src/plugins/skills.py

@@ -19,9 +19,13 @@ from db import (
 from skills_runtime import (
     apply_skill,
     approve_skill_execution,
+    compose_skills,
     get_featured_skill_summaries,
     list_evolution_candidates,
+    promote_skill,
+    retire_skill,
     sync_skills,
+    test_skill,
 )
 
 
@@ -171,6 +175,10 @@ def handle_skill_apply(id: str, params: str = "{}", mode: str = "auto", dry_run:
     return json.dumps(apply_skill(id, params=params, mode=mode, dry_run=dry_run, context=context), ensure_ascii=False)
 
 
+def handle_skill_test(id: str, params: str = "{}", mode: str = "auto", context: str = "") -> str:
+    return json.dumps(test_skill(id, params=params, mode=mode, context=context), ensure_ascii=False)
+
+
 def handle_skill_approve(id: str, execution_level: str = "", approved_by: str = "") -> str:
     result = approve_skill_execution(id, execution_level=execution_level, approved_by=approved_by)
     if "error" in result:
@@ -196,6 +204,57 @@ def handle_skill_evolution_candidates() -> str:
     return json.dumps(list_evolution_candidates(), ensure_ascii=False)
 
 
+def handle_skill_promote(id: str, target_level: str = "published", reason: str = "") -> str:
+    return json.dumps(promote_skill(id, target_level=target_level, reason=reason), ensure_ascii=False)
+
+
+def handle_skill_retire(id: str, replacement_id: str = "", reason: str = "") -> str:
+    return json.dumps(retire_skill(id, replacement_id=replacement_id, reason=reason), ensure_ascii=False)
+
+
+def handle_skill_compose(
+    new_id: str,
+    name: str,
+    component_ids: str = "[]",
+    description: str = "",
+    level: str = "draft",
+    mode: str = "guide",
+    tags: str = "[]",
+    trigger_patterns: str = "[]",
+) -> str:
+    try:
+        component_list = json.loads(component_ids) if str(component_ids or "").strip().startswith("[") else [
+            item.strip() for item in str(component_ids or "").split(",") if item.strip()
+        ]
+    except json.JSONDecodeError:
+        component_list = []
+    try:
+        tags_list = json.loads(tags) if str(tags or "").strip().startswith("[") else [
+            item.strip() for item in str(tags or "").split(",") if item.strip()
+        ]
+    except json.JSONDecodeError:
+        tags_list = []
+    try:
+        trigger_list = json.loads(trigger_patterns) if str(trigger_patterns or "").strip().startswith("[") else [
+            item.strip() for item in str(trigger_patterns or "").split(",") if item.strip()
+        ]
+    except json.JSONDecodeError:
+        trigger_list = []
+    return json.dumps(
+        compose_skills(
+            new_skill_id=new_id,
+            name=name,
+            component_ids=component_list,
+            description=description,
+            level=level,
+            mode=mode,
+            tags=tags_list,
+            trigger_patterns=trigger_list,
+        ),
+        ensure_ascii=False,
+    )
+
+
 TOOLS = [
     (handle_skill_create, "nexo_skill_create",
      "Create a new skill with guide/execute/hybrid metadata, triggers, params schema, and execution level."),
@@ -213,6 +272,8 @@ TOOLS = [
      "Show aggregate skill statistics."),
     (handle_skill_apply, "nexo_skill_apply",
      "Apply a skill in guide, execute, or hybrid mode. Execution goes through the stable nexo scripts runtime."),
+    (handle_skill_test, "nexo_skill_test",
+     "Test a skill through the canonical runtime in dry-run mode before wider use."),
     (handle_skill_approve, "nexo_skill_approve",
      "Approve a local/remote executable skill so it can run."),
     (handle_skill_sync, "nexo_skill_sync",
@@ -221,4 +282,10 @@ TOOLS = [
      "Return featured published/stable skills for startup discovery."),
     (handle_skill_evolution_candidates, "nexo_skill_evolution_candidates",
      "Return candidates for skill improvement or text-to-script evolution."),
+    (handle_skill_promote, "nexo_skill_promote",
+     "Promote a skill to a stronger published/stable lifecycle stage."),
+    (handle_skill_retire, "nexo_skill_retire",
+     "Retire a skill cleanly so it leaves the active lifecycle."),
+    (handle_skill_compose, "nexo_skill_compose",
+     "Compose multiple existing skills into one higher-level reusable skill."),
 ]

package/src/plugins/state_watchers.py

@@ -0,0 +1,79 @@
+"""State watchers plugin — persistent drift/health/expiry watchers."""
+
+from __future__ import annotations
+
+import json
+
+from db import create_state_watcher, list_state_watchers, update_state_watcher
+from state_watchers_runtime import run_state_watchers
+
+
+def handle_state_watcher_create(
+    watcher_type: str,
+    title: str,
+    target: str = "",
+    severity: str = "warn",
+    status: str = "active",
+    config: str = "{}",
+) -> str:
+    """Create a persistent state watcher for drift, health, or expiry."""
+    try:
+        watcher = create_state_watcher(
+            watcher_type,
+            title,
+            target=target,
+            severity=severity,
+            status=status,
+            config=json.loads(config) if str(config).strip() else {},
+        )
+    except (ValueError, json.JSONDecodeError) as exc:
+        return json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False, indent=2)
+    return json.dumps({"ok": True, "watcher": watcher}, ensure_ascii=False, indent=2)
+
+
+def handle_state_watcher_update(
+    watcher_id: str,
+    title: str = "",
+    target: str = "",
+    severity: str = "",
+    status: str = "",
+    config: str = "",
+) -> str:
+    """Update an existing state watcher."""
+    payload = None
+    if str(config).strip():
+        try:
+            payload = json.loads(config)
+        except json.JSONDecodeError as exc:
+            return json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False, indent=2)
+    watcher = update_state_watcher(
+        watcher_id,
+        title=(title or None),
+        target=(target or None),
+        severity=(severity or None),
+        status=(status or None),
+        config=payload,
+    )
+    if not watcher:
+        return json.dumps({"ok": False, "error": f"Unknown watcher_id: {watcher_id}"}, ensure_ascii=False, indent=2)
+    return json.dumps({"ok": True, "watcher": watcher}, ensure_ascii=False, indent=2)
+
+
+def handle_state_watcher_list(status: str = "", watcher_type: str = "", limit: int = 50) -> str:
+    """List configured state watchers."""
+    watchers = list_state_watchers(status=status, watcher_type=watcher_type, limit=max(1, int(limit or 50)))
+    return json.dumps({"ok": True, "count": len(watchers), "watchers": watchers}, ensure_ascii=False, indent=2)
+
+
+def handle_state_watcher_run(status: str = "active", persist: bool = True) -> str:
+    """Run active state watchers and return their current health."""
+    summary = run_state_watchers(status=status or "active", persist=bool(persist))
+    return json.dumps({"ok": True, **summary}, ensure_ascii=False, indent=2)
+
+
+TOOLS = [
+    (handle_state_watcher_create, "nexo_state_watcher_create", "Create a persistent state watcher for repo drift, cron drift, API health, environment drift, or expiry."),
+    (handle_state_watcher_update, "nexo_state_watcher_update", "Update an existing persistent state watcher."),
+    (handle_state_watcher_list, "nexo_state_watcher_list", "List persistent state watchers."),
+    (handle_state_watcher_run, "nexo_state_watcher_run", "Run persistent state watchers and return their current health summary."),
+]