nexo-brain 2.4.0 → 2.5.1

package/src/evolution_cycle.py

@@ -34,14 +34,83 @@ PROMPT_FILE = _resolve_evolution_file("evolution-prompt.md")
 MAX_SNAPSHOTS = 8
 
 
+def _normalize_dimensions(raw: dict | None) -> dict:
+    normalized = {}
+    for key, value in (raw or {}).items():
+        canonical_key = "agi" if key == "agi_readiness" else key
+        if isinstance(value, dict):
+            normalized[canonical_key] = {
+                "current": int(value.get("current", 0) or 0),
+                "target": int(value.get("target", 0) or 0),
+            }
+        else:
+            normalized[canonical_key] = {
+                "current": 0,
+                "target": int(value or 0),
+            }
+    return normalized
+
+
+def normalize_objective(obj: dict | None) -> dict:
+    """Upgrade legacy objective files to the canonical schema."""
+    source = dict(obj or {})
+
+    if "evolution_mode" in source:
+        mode = str(source.get("evolution_mode") or "auto").strip().lower()
+    else:
+        legacy_mode = str(source.get("review_mode") or "").strip().lower()
+        if legacy_mode in {"manual", "review"}:
+            mode = "review"
+        elif legacy_mode in {"managed", "hybrid", "owner", "core"}:
+            mode = "managed"
+        else:
+            mode = "auto"
+
+    if mode not in {"auto", "review", "managed"}:
+        mode = "auto"
+
+    dimensions = source.get("dimensions")
+    if not isinstance(dimensions, dict) or not dimensions:
+        dimensions = _normalize_dimensions(source.get("dimension_targets"))
+    else:
+        dimensions = _normalize_dimensions(dimensions)
+
+    defaults = {
+        "episodic_memory": {"current": 0, "target": 90},
+        "autonomy": {"current": 0, "target": 80},
+        "proactivity": {"current": 0, "target": 70},
+        "self_improvement": {"current": 0, "target": 60},
+        "agi": {"current": 0, "target": 20},
+    }
+    merged_dimensions = dict(defaults)
+    merged_dimensions.update(dimensions)
+
+    normalized = dict(source)
+    normalized["evolution_mode"] = mode
+    normalized["dimensions"] = merged_dimensions
+    normalized["total_evolutions"] = int(source.get("total_evolutions", source.get("cycles_completed", 0)) or 0)
+    normalized["last_evolution"] = source.get("last_evolution", source.get("last_cycle"))
+    normalized["total_proposals_made"] = int(source.get("total_proposals_made", 0) or 0)
+    normalized["total_auto_applied"] = int(source.get("total_auto_applied", 0) or 0)
+    normalized["consecutive_failures"] = int(source.get("consecutive_failures", 0) or 0)
+    normalized["history"] = source.get("history", []) if isinstance(source.get("history"), list) else []
+    normalized["evolution_enabled"] = bool(source.get("evolution_enabled", True))
+    normalized.pop("review_mode", None)
+    normalized.pop("dimension_targets", None)
+    normalized.pop("cycles_completed", None)
+    normalized.pop("last_cycle", None)
+    return normalized
+
+
 def load_objective() -> dict:
     if OBJECTIVE_FILE.exists():
-        return json.loads(OBJECTIVE_FILE.read_text())
-    return {}
+        return normalize_objective(json.loads(OBJECTIVE_FILE.read_text()))
+    return normalize_objective({})
 
 
 def save_objective(obj: dict):
-    OBJECTIVE_FILE.write_text(json.dumps(obj, indent=2, ensure_ascii=False))
+    OBJECTIVE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    OBJECTIVE_FILE.write_text(json.dumps(normalize_objective(obj), indent=2, ensure_ascii=False))
 
 
 def get_week_data(db_path: str) -> dict:
@@ -196,9 +265,18 @@ def build_evolution_prompt(week_data: dict, objective: dict) -> str:
         "current_scores": {dim: m["score"] for dim, m in week_data.get("current_metrics", {}).items()},
     }
 
-    mode = objective.get("evolution_mode", "auto")
+    mode = normalize_objective(objective).get("evolution_mode", "auto")
     total = objective.get("total_evolutions", 0)
     max_auto = max_auto_changes(total)
+    if mode == "review":
+        mode_desc = "review-only, nothing executes automatically"
+        safe_zones = "~/.nexo/scripts/, ~/.nexo/plugins/, ~/.nexo/brain/"
+    elif mode == "managed":
+        mode_desc = f"owner-managed, max {max_auto} auto-applied changes with rollback and followups"
+        safe_zones = "~/.nexo/scripts/, ~/.nexo/plugins/, ~/.nexo/brain/, NEXO_CODE/src, repo bin/docs/templates/tests"
+    else:
+        mode_desc = f"public auto, max {max_auto} auto-applied changes in personal safe zones"
+        safe_zones = "~/.nexo/scripts/, ~/.nexo/plugins/"
 
     prompt = f"""You are NEXO Evolution — the weekly self-improvement cycle.
 
@@ -212,7 +290,7 @@ WEEK SUMMARY:
 - {stats['evolution_history']} past evolution proposals
 - Current scores: {json.dumps(stats['current_scores'])}
 
-MODE: {mode} ({"proposals only, owner reviews" if mode == "review" else f"max {max_auto} auto-applied changes"})
+MODE: {mode} ({mode_desc})
 CYCLE: #{total + 1}
 
 INVESTIGATE using these tools:
@@ -232,9 +310,11 @@ LOOK FOR:
 - Patterns in self-critique that suggest systemic issues
 
 SAFETY:
-- Safe zones for auto changes: ~/.nexo/scripts/, ~/.nexo/plugins/, ~/.nexo/brain/
+- Safe zones for this mode: {safe_zones}
 - IMMUTABLE files (never touch): db.py, server.py, plugin_loader.py, cognitive.py, CLAUDE.md
 - Every change needs: what file, what to change, why, risk, how to verify
+- AUTO changes must be deterministic. If the edit is ambiguous, risky, or needs human taste, mark it as "propose".
+- In managed mode, failed AUTO changes will be rolled back automatically and turned into followups with evidence.
 
 OUTPUT FORMAT (JSON):
 {{

package/src/hooks/post-compact.sh

@@ -18,8 +18,12 @@ fi
 # PreCompact writes the SID to /tmp/nexo-compacting-sid
 TARGET_SID=""
 if [ -f /tmp/nexo-compacting-sid ]; then
-    TARGET_SID=$(cat /tmp/nexo-compacting-sid 2>/dev/null || echo "")
+    RAW_SID=$(cat /tmp/nexo-compacting-sid 2>/dev/null || echo "")
     rm -f /tmp/nexo-compacting-sid
+    # Validate SID format: must be nexo-DIGITS-DIGITS
+    if [[ "$RAW_SID" =~ ^nexo-[0-9]+-[0-9]+$ ]]; then
+        TARGET_SID="$RAW_SID"
+    fi
 fi
 
 CHECKPOINT=""

package/src/hooks/pre-compact.sh

@@ -22,7 +22,7 @@ if [ -f "$NEXO_DB" ]; then
         SELECT sid FROM sessions ORDER BY last_update_epoch DESC LIMIT 1
     " 2>/dev/null || echo "")
 
-    if [ -n "$LATEST_SID" ]; then
+    if [ -n "$LATEST_SID" ] && [[ "$LATEST_SID" =~ ^nexo-[0-9]+-[0-9]+$ ]]; then
         # Write SID to temp file so PostCompact knows which session compacted
         echo "$LATEST_SID" > /tmp/nexo-compacting-sid
         # Pull diary draft data into checkpoint

package/src/plugins/doctor.py

@@ -0,0 +1,36 @@
+"""Doctor plugin — exposes nexo_doctor as MCP tool."""
+from __future__ import annotations
+
+import sys
+import os
+from pathlib import Path
+
+# Ensure src/ is importable
+SRC_DIR = Path(__file__).resolve().parent.parent
+if str(SRC_DIR) not in sys.path:
+    sys.path.insert(0, str(SRC_DIR))
+
+
+def handle_doctor(tier: str = "boot", fix: bool = False, output: str = "text") -> str:
+    """Unified diagnostic report for boot/runtime/deep health.
+
+    Args:
+        tier: Diagnostic tier — boot, runtime, deep, or all (default: boot)
+        fix: Apply deterministic fixes (default: False)
+        output: Output format — text or json (default: text)
+    """
+    from doctor.orchestrator import run_doctor
+    from doctor.formatters import format_report
+
+    if tier not in ("boot", "runtime", "deep", "all"):
+        return f"Invalid tier '{tier}'. Use: boot, runtime, deep, all"
+    if output not in ("text", "json"):
+        return f"Invalid output '{output}'. Use: text, json"
+
+    report = run_doctor(tier=tier, fix=fix)
+    return format_report(report, fmt=output)
+
+
+TOOLS = [
+    (handle_doctor, "nexo_doctor", "Unified diagnostic report for boot/runtime/deep health."),
+]

package/src/plugins/evolution.py

@@ -18,7 +18,8 @@ def handle_evolution_status() -> str:
         "agi": "AGI",
     }
 
-    lines = ["NEXO EVOLUTION STATUS:"]
+    from user_context import get_context
+    lines = [f"{get_context().assistant_name} EVOLUTION STATUS:"]
     for key, label in BARS.items():
         m = metrics.get(key)
         if m:
@@ -42,8 +43,15 @@ def handle_evolution_history(limit: int = 10) -> str:
 
     lines = [f"EVOLUTION HISTORY ({len(history)} entries):"]
     for h in history:
-        status_icon = {"applied": "✓", "rolled_back": "✗", "proposed": "?",
-                       "accepted": "✓✓", "rejected": "✗✗"}.get(h["status"], "·")
+        status_icon = {
+            "applied": "✓",
+            "rolled_back": "↺",
+            "blocked": "⛔",
+            "proposed": "?",
+            "pending_review": "…",
+            "accepted": "✓✓",
+            "rejected": "✗✗",
+        }.get(h["status"], "·")
         lines.append(f"  {status_icon} #{h['id']} [{h['classification']}] {h['dimension']}")
         lines.append(f"    {h['proposal'][:100]}")
         if h.get("test_result"):

package/src/plugins/skills.py

@@ -1,264 +1,224 @@
-"""Skills plugin — reusable procedures extracted from complex tasks.
+"""Skills plugin — reusable procedures, executable skills, and feedback loops."""
 
-Skills are procedural knowledge (step-by-step how-tos) vs learnings which are
-declarative (don't do X). Created automatically by Deep Sleep or manually.
-
-Pipeline: trace → draft → published, fully autonomous.
-Trust score with decay controls quality — no human approval gates.
-"""
+from __future__ import annotations
 
 import json
+
 from db import (
-    create_skill, get_skill, list_skills, search_skills,
-    update_skill, delete_skill,
-    record_skill_usage, match_skills, merge_skills, get_skill_stats,
+    create_skill,
+    delete_skill,
+    get_skill,
+    get_skill_stats,
+    list_skills,
+    match_skills,
+    merge_skills,
+    record_skill_usage,
+    search_skills,
+    update_skill,
+)
+from skills_runtime import (
+    apply_skill,
+    approve_skill_execution,
+    get_featured_skill_summaries,
+    list_evolution_candidates,
+    sync_skills,
 )
 
 
 def handle_skill_create(
     id: str,
     name: str,
-    description: str = '',
-    level: str = 'draft',
-    tags: str = '[]',
-    trigger_patterns: str = '[]',
-    source_sessions: str = '[]',
-    linked_learnings: str = '[]',
-    file_path: str = '',
+    description: str = "",
+    level: str = "draft",
+    tags: str = "[]",
+    trigger_patterns: str = "[]",
+    source_sessions: str = "[]",
+    linked_learnings: str = "[]",
+    file_path: str = "",
+    mode: str = "",
+    source_kind: str = "personal",
+    execution_level: str = "none",
+    approval_required: bool = False,
+    params_schema: str = "{}",
+    command_template: str = "{}",
+    executable_entry: str = "",
 ) -> str:
-    """Create a new skill (reusable procedure).
-
-    Skills are procedural knowledge — step-by-step instructions for complex tasks.
-    Created by Deep Sleep (auto-extraction) or manually during sessions.
-
-    Pipeline levels: trace → draft → published → archived.
-    Promotion is automatic: 2+ successful uses in distinct contexts → published.
-
-    Args:
-        id: Unique ID starting with 'SK-' (e.g., SK-DEPLOY-CHROME-EXT).
-        name: Human-readable name (e.g., 'Deploy Chrome Extension').
-        description: What this skill does (1-2 sentences).
-        level: Starting level — trace, draft (default), published, archived.
-        tags: JSON array of tags for discovery (e.g., '["chrome", "extension", "deploy"]').
-        trigger_patterns: JSON array of phrases that should trigger this skill
-                         (e.g., '["deploy extension", "publish chrome"]').
-        source_sessions: JSON array of diary IDs where this skill was observed.
-        linked_learnings: JSON array of learning IDs related to this skill.
-        file_path: Path to the .md file with full procedure (if stored as file).
-    """
-    if not id.startswith('SK-'):
+    if not id.startswith("SK-"):
         return "ERROR: Skill ID must start with 'SK-' (e.g., SK-DEPLOY-CHROME-EXT)"
-
-    existing = get_skill(id)
-    if existing:
+    if get_skill(id):
         return f"ERROR: Skill {id} already exists. Use nexo_skill_update to modify."
 
     result = create_skill(
-        skill_id=id, name=name, description=description, level=level,
-        tags=tags, trigger_patterns=trigger_patterns,
-        source_sessions=source_sessions, linked_learnings=linked_learnings,
+        skill_id=id,
+        name=name,
+        description=description,
+        level=level,
+        tags=tags,
+        trigger_patterns=trigger_patterns,
+        source_sessions=source_sessions,
+        linked_learnings=linked_learnings,
         file_path=file_path,
+        mode=mode,
+        source_kind=source_kind,
+        execution_level=execution_level,
+        approval_required=approval_required,
+        params_schema=params_schema,
+        command_template=command_template,
+        executable_entry=executable_entry,
     )
     if "error" in result:
         return f"ERROR: {result['error']}"
 
     return (
-        f"Skill {id} created ({level}, trust={result.get('trust_score', 50)}).\n"
+        f"Skill {id} created ({result['level']}, {result.get('mode', 'guide')}, trust={result.get('trust_score', 50)}).\n"
         f"  Name: {name}\n"
-        f"  Tags: {tags}\n"
-        f"  Triggers: {trigger_patterns}"
+        f"  Source: {result.get('source_kind', source_kind)}\n"
+        f"  Execution: {result.get('execution_level', execution_level)}"
     )
 
 
-def handle_skill_match(task: str, level: str = '') -> str:
-    """Find skills matching a task description. Call BEFORE starting multi-step tasks.
-
-    Searches by: FTS5 relevance, trigger pattern matching, tag keyword overlap.
-    Returns top-3 matches sorted by trust score.
-
-    Args:
-        task: Description of what you're about to do (e.g., 'deploy chrome extension to CWS').
-        level: Filter by level (optional). Default: draft + published.
-    """
+def handle_skill_match(task: str, level: str = "") -> str:
     matches = match_skills(task, level=level)
     if not matches:
         return f"No skills found for: '{task}'"
 
     lines = [f"SKILLS MATCHED ({len(matches)}) for '{task}':"]
-    for m in matches:
-        match_method = m.pop('_match', 'unknown')
-        fp = f" → {m['file_path']}" if m.get('file_path') else ""
+    for match in matches:
+        match_method = match.pop("_match", "unknown")
         lines.append(
-            f"  [{m['id']}] {m['name']} ({m['level']}, trust={m['trust_score']}, "
-            f"used={m['use_count']}x) via {match_method}{fp}\n"
-            f"    {m['description'][:120]}"
+            f"  [{match['id']}] {match['name']} ({match['level']}, {match.get('mode', 'guide')}, "
+            f"{match.get('source_kind', 'personal')}, trust={match['trust_score']}, used={match['use_count']}x) "
+            f"via {match_method}"
         )
-        try:
-            triggers = json.loads(m.get('trigger_patterns', '[]'))
-            if triggers:
-                lines.append(f"    Triggers: {', '.join(triggers[:5])}")
-        except (json.JSONDecodeError, TypeError):
-            pass
+        lines.append(f"    {match['description'][:140]}")
     return "\n".join(lines)
 
 
 def handle_skill_get(id: str) -> str:
-    """Get a skill's full details including usage history.
-
-    Args:
-        id: Skill ID (e.g., SK-DEPLOY-CHROME-EXT).
-    """
     skill = get_skill(id)
     if not skill:
         return f"ERROR: Skill {id} not found."
 
-    from db import get_db
-    conn = get_db()
-    recent_uses = conn.execute(
-        "SELECT * FROM skill_usage WHERE skill_id = ? ORDER BY created_at DESC LIMIT 5",
-        (id,),
-    ).fetchall()
-
     lines = [
         f"SKILL: {skill['id']}",
         f"  Name: {skill['name']}",
         f"  Description: {skill['description']}",
         f"  Level: {skill['level']}",
+        f"  Mode: {skill.get('mode', 'guide')}",
+        f"  Source: {skill.get('source_kind', 'personal')}",
         f"  Trust: {skill['trust_score']}",
-        f"  File: {skill['file_path'] or '(none)'}",
-        f"  Tags: {skill['tags']}",
+        f"  Execution level: {skill.get('execution_level', 'none')}",
+        f"  Approval required: {bool(skill.get('approval_required', 0))}",
+        f"  Approved at: {skill.get('approved_at') or 'no'}",
+        f"  Definition: {skill.get('definition_path') or '(none)'}",
+        f"  File: {skill.get('file_path') or '(none)'}",
+        f"  Params schema: {skill.get('params_schema', '{}')}",
         f"  Triggers: {skill['trigger_patterns']}",
-        f"  Source sessions: {skill['source_sessions']}",
-        f"  Linked learnings: {skill['linked_learnings']}",
         f"  Stats: {skill['use_count']} uses, {skill['success_count']} success, {skill['fail_count']} fail",
-        f"  Created: {skill['created_at']}",
-        f"  Last used: {skill['last_used_at'] or 'never'}",
     ]
-
-    if recent_uses:
-        lines.append("\n  RECENT USAGE:")
-        for u in recent_uses:
-            u = dict(u)
-            status = "✓" if u['success'] else "✗"
-            lines.append(f"    {status} {u['created_at']} — {u['context'][:60] or '(no context)'}")
-            if u.get('notes'):
-                lines.append(f"      Notes: {u['notes'][:80]}")
-
     return "\n".join(lines)
 
 
-def handle_skill_result(id: str, success: bool = True, context: str = '', notes: str = '') -> str:
-    """Record the result of using a skill. Auto-promotes/degrades based on trust rules.
-
-    Call this AFTER following a skill's procedure to record whether it worked.
-    - Success: trust +5. After 2+ successes in distinct contexts: draft → published.
-    - Failure: trust -10. If trust < 20: → archived.
-
-    Args:
-        id: Skill ID.
-        success: Whether the skill's procedure worked correctly.
-        context: What task you were doing (used for distinct-context promotion).
-        notes: Additional notes (especially useful for failures — what went wrong).
-    """
+def handle_skill_result(id: str, success: bool = True, context: str = "", notes: str = "") -> str:
     result = record_skill_usage(skill_id=id, success=success, context=context, notes=notes)
     if "error" in result:
         return f"ERROR: {result['error']}"
 
-    promotion = result.pop('_promotion', None)
-    status = "SUCCESS" if success else "FAILURE"
-    msg = f"Skill {id} usage recorded: {status} (trust={result['trust_score']})"
+    promotion = result.get("_promotion")
+    msg = f"Skill {id} usage recorded: {'SUCCESS' if success else 'FAILURE'} (trust={result['trust_score']})"
     if promotion:
         msg += f"\n  ⚡ PROMOTION: {promotion}"
     return msg
 
 
-def handle_skill_list(level: str = '', tag: str = '') -> str:
-    """List all skills, optionally filtered by level or tag.
-
-    Args:
-        level: Filter by level — trace, draft, published, archived.
-        tag: Filter by tag (e.g., 'chrome', 'deploy', 'shopify').
-    """
-    skills = list_skills(level=level, tag=tag)
+def handle_skill_list(level: str = "", tag: str = "", source_kind: str = "") -> str:
+    skills = list_skills(level=level, tag=tag, source_kind=source_kind)
     if not skills:
-        filters = []
-        if level: filters.append(f"level={level}")
-        if tag: filters.append(f"tag={tag}")
-        return f"No skills found{' (' + ', '.join(filters) + ')' if filters else ''}."
+        return "No skills found."
 
     lines = [f"SKILLS ({len(skills)}):"]
-    for s in skills:
-        fp = f" → {s['file_path']}" if s.get('file_path') else ""
-        used = f", last={s['last_used_at'][:10]}" if s.get('last_used_at') else ""
+    for skill in skills:
         lines.append(
-            f"  [{s['id']}] {s['name']} ({s['level']}, trust={s['trust_score']}, "
-            f"used={s['use_count']}x{used}){fp}"
+            f"  [{skill['id']}] {skill['name']} ({skill['level']}, {skill.get('mode', 'guide')}, "
+            f"{skill.get('source_kind', 'personal')}, trust={skill['trust_score']}, used={skill['use_count']}x)"
         )
     return "\n".join(lines)
 
 
-def handle_skill_merge(id1: str, id2: str, keep_id: str = '') -> str:
-    """Merge two similar skills into one. Combines tags, triggers, usage history.
-
-    The survivor keeps the higher trust score and all combined metadata.
-    The donor is deleted.
-
-    Args:
-        id1: First skill ID.
-        id2: Second skill ID.
-        keep_id: Which one to keep (default: higher trust score).
-    """
+def handle_skill_merge(id1: str, id2: str, keep_id: str = "") -> str:
     result = merge_skills(id1, id2, keep_id=keep_id)
     if "error" in result:
         return f"ERROR: {result['error']}"
-
-    merged_from = result.pop('_merged_from', '?')
     return (
-        f"Skills merged. Kept {result['id']}, deleted {merged_from}.\n"
-        f"  Trust: {result['trust_score']}, Uses: {result['use_count']}, "
-        f"Tags: {result['tags']}"
+        f"Skills merged. Kept {result['id']}, deleted {result['_merged_from']}.\n"
+        f"  Trust: {result['trust_score']}, Uses: {result['use_count']}"
     )
 
 
 def handle_skill_stats() -> str:
-    """Show aggregate skill statistics: total count, by level, avg trust, usage rates."""
     stats = get_skill_stats()
-    levels = stats.get('by_level', {})
-    lines = [
-        "SKILL STATS:",
-        f"  Total: {stats['total']}",
-        f"  By level: {', '.join(f'{k}={v}' for k, v in sorted(levels.items()))}",
-        f"  Avg trust: {stats['avg_trust']}",
-        f"  Total uses: {stats['total_uses']} (success rate: {stats['success_rate']}%)",
-        f"  Uses last 7d: {stats['uses_last_7d']}",
-    ]
-    return "\n".join(lines)
+    return (
+        "SKILL STATS:\n"
+        f"  Total: {stats['total']}\n"
+        f"  By level: {', '.join(f'{k}={v}' for k, v in sorted(stats['by_level'].items()))}\n"
+        f"  Avg trust: {stats['avg_trust']}\n"
+        f"  Total uses: {stats['total_uses']} (success rate: {stats['success_rate']}%)\n"
+        f"  Uses last 7d: {stats['uses_last_7d']}"
+    )
+
+
+def handle_skill_apply(id: str, params: str = "{}", mode: str = "auto", dry_run: bool = False, context: str = "") -> str:
+    return json.dumps(apply_skill(id, params=params, mode=mode, dry_run=dry_run, 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:
+        return f"ERROR: {result['error']}"
+    return (
+        f"Skill {id} approved.\n"
+        f"  Execution level: {result.get('execution_level', 'none')}\n"
+        f"  Approved at: {result.get('approved_at', '')}\n"
+        f"  Approved by: {result.get('approved_by', '')}"
+    )
+
+
+def handle_skill_sync() -> str:
+    result = sync_skills()
+    return json.dumps(result, ensure_ascii=False)
+
+
+def handle_skill_featured(limit: int = 5) -> str:
+    return json.dumps(get_featured_skill_summaries(limit=limit), ensure_ascii=False)
+
+
+def handle_skill_evolution_candidates() -> str:
+    return json.dumps(list_evolution_candidates(), ensure_ascii=False)
 
 
-# Plugin registration — TOOLS array consumed by plugin_loader.py
 TOOLS = [
     (handle_skill_create, "nexo_skill_create",
-     "Create a new skill (reusable procedure). Skills are step-by-step instructions for complex tasks. "
-     "Auto-promoted from draft→published after 2+ successful uses. ID must start with 'SK-'."),
-
+     "Create a new skill with guide/execute/hybrid metadata, triggers, params schema, and execution level."),
     (handle_skill_match, "nexo_skill_match",
-     "Find skills matching a task description. Call BEFORE starting multi-step tasks "
-     "to check if a reusable procedure exists. Returns top-3 matches by trust score."),
-
+     "Find skills matching a task description. Call before multi-step tasks."),
     (handle_skill_get, "nexo_skill_get",
-     "Get a skill's full details including procedure, tags, triggers, and usage history."),
-
+     "Get a skill's full details, including execution metadata and approval state."),
     (handle_skill_result, "nexo_skill_result",
-     "Record the result of using a skill (success/failure). Auto-promotes draft→published "
-     "after 2+ successes, auto-archives if trust drops below 20."),
-
+     "Record the result of using a skill. Updates trust and promotions."),
     (handle_skill_list, "nexo_skill_list",
-     "List all skills, optionally filtered by level (trace/draft/published/archived) or tag."),
-
+     "List skills, optionally filtered by level, tag, or source kind."),
     (handle_skill_merge, "nexo_skill_merge",
-     "Merge two similar skills into one. Combines tags, triggers, and usage history. "
-     "Survivor keeps the higher trust score."),
-
+     "Merge two similar skills into one."),
     (handle_skill_stats, "nexo_skill_stats",
-     "Show aggregate skill statistics: count by level, average trust, usage rates."),
+     "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_approve, "nexo_skill_approve",
+     "Approve a local/remote executable skill so it can run."),
+    (handle_skill_sync, "nexo_skill_sync",
+     "Sync filesystem skill definitions from personal/core/community directories into SQLite."),
+    (handle_skill_featured, "nexo_skill_featured",
+     "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."),
 ]

package/src/requirements.txt

@@ -10,3 +10,4 @@ fastembed
 fastapi
 uvicorn
 pydantic
+jinja2