nexo-brain 2.7.0 → 3.0.0

package/src/cli.py

@@ -1056,6 +1056,23 @@ def _skills_apply(args):
     return 0 if result.get("ok") else 1
 
 
+def _skills_test(args):
+    from skills_runtime import test_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 = test_skill(args.id, params=params, mode=args.mode, 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
 
@@ -1103,6 +1120,62 @@ def _skills_evolution(args):
     return 0
 
 
+def _skills_promote(args):
+    from skills_runtime import promote_skill
+
+    result = promote_skill(args.id, target_level=args.target_level, reason=args.reason)
+    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_retire(args):
+    from skills_runtime import retire_skill
+
+    result = retire_skill(args.id, replacement_id=args.replacement_id, reason=args.reason)
+    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_compose(args):
+    from skills_runtime import compose_skills
+
+    try:
+        component_ids = json.loads(args.component_ids) if args.component_ids.strip().startswith("[") else [
+            item.strip() for item in args.component_ids.split(",") if item.strip()
+        ]
+        tags = json.loads(args.tags) if args.tags.strip().startswith("[") else [
+            item.strip() for item in args.tags.split(",") if item.strip()
+        ]
+        trigger_patterns = json.loads(args.trigger_patterns) if args.trigger_patterns.strip().startswith("[") else [
+            item.strip() for item in args.trigger_patterns.split(",") if item.strip()
+        ]
+    except json.JSONDecodeError as e:
+        print(f"Invalid JSON: {e}", file=sys.stderr)
+        return 1
+
+    result = compose_skills(
+        new_skill_id=args.new_id,
+        name=args.name,
+        component_ids=component_ids,
+        description=args.description,
+        level=args.level,
+        mode=args.mode,
+        tags=tags,
+        trigger_patterns=trigger_patterns,
+    )
+    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 _print_help():
     v = _get_version()
     print(f"""NEXO Runtime CLI v{v}
@@ -1248,6 +1321,13 @@ def main():
     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_test_p = skills_sub.add_parser("test", help="Dry-run test a skill")
+    skills_test_p.add_argument("id", help="Skill ID")
+    skills_test_p.add_argument("--params", default="{}", help="JSON parameters")
+    skills_test_p.add_argument("--mode", default="auto", choices=["auto", "guide", "execute", "hybrid"])
+    skills_test_p.add_argument("--context", default="", help="Testing context")
+    skills_test_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")
 
@@ -1264,6 +1344,29 @@ def main():
     skills_evolution_p = skills_sub.add_parser("evolution", help="Evolution candidates")
     skills_evolution_p.add_argument("--json", action="store_true", help="JSON output")
 
+    skills_promote_p = skills_sub.add_parser("promote", help="Promote a skill lifecycle level")
+    skills_promote_p.add_argument("id", help="Skill ID")
+    skills_promote_p.add_argument("--target-level", default="published", choices=["draft", "published", "stable"])
+    skills_promote_p.add_argument("--reason", default="", help="Why promote this skill")
+    skills_promote_p.add_argument("--json", action="store_true", help="JSON output")
+
+    skills_retire_p = skills_sub.add_parser("retire", help="Archive a skill")
+    skills_retire_p.add_argument("id", help="Skill ID")
+    skills_retire_p.add_argument("--replacement-id", default="", help="Optional replacement skill ID")
+    skills_retire_p.add_argument("--reason", default="", help="Why retire this skill")
+    skills_retire_p.add_argument("--json", action="store_true", help="JSON output")
+
+    skills_compose_p = skills_sub.add_parser("compose", help="Compose multiple skills into one")
+    skills_compose_p.add_argument("new_id", help="New skill ID")
+    skills_compose_p.add_argument("name", help="New skill name")
+    skills_compose_p.add_argument("--component-ids", required=True, help="JSON array or comma-separated skill IDs")
+    skills_compose_p.add_argument("--description", default="", help="Composite skill description")
+    skills_compose_p.add_argument("--level", default="draft", choices=["trace", "draft", "published", "stable"])
+    skills_compose_p.add_argument("--mode", default="guide", choices=["guide", "hybrid"])
+    skills_compose_p.add_argument("--tags", default="[]", help="JSON array or comma-separated tags")
+    skills_compose_p.add_argument("--trigger-patterns", default="[]", help="JSON array or comma-separated trigger patterns")
+    skills_compose_p.add_argument("--json", action="store_true", help="JSON output")
+
     # -- dashboard --
     dashboard_parser = sub.add_parser("dashboard", help="Web dashboard control")
     dashboard_parser.add_argument("action", choices=["on", "off", "status"], help="Start, stop, or check dashboard")
@@ -1332,6 +1435,8 @@ def main():
             return _skills_get(args)
         elif args.skills_command == "apply":
             return _skills_apply(args)
+        elif args.skills_command == "test":
+            return _skills_test(args)
         elif args.skills_command == "sync":
             return _skills_sync(args)
         elif args.skills_command == "approve":
@@ -1340,6 +1445,12 @@ def main():
             return _skills_featured(args)
         elif args.skills_command == "evolution":
             return _skills_evolution(args)
+        elif args.skills_command == "promote":
+            return _skills_promote(args)
+        elif args.skills_command == "retire":
+            return _skills_retire(args)
+        elif args.skills_command == "compose":
+            return _skills_compose(args)
         else:
             skills_parser.print_help()
             return 0

package/src/client_preferences.py

@@ -30,6 +30,12 @@ AUTOMATION_BACKEND_KEYS = (
     CLIENT_CLAUDE_CODE,
     CLIENT_CODEX,
 )
+AUTOMATION_TASK_PROFILE_KEYS = (
+    "default",
+    "fast",
+    "balanced",
+    "deep",
+)
 INSTALL_PREFERENCE_KEYS = {
     "ask",
     "auto",
@@ -40,6 +46,10 @@ DEFAULT_CLAUDE_CODE_MODEL = "claude-opus-4-6[1m]"
 DEFAULT_CLAUDE_CODE_REASONING_EFFORT = ""
 DEFAULT_CODEX_MODEL = "gpt-5.4"
 DEFAULT_CODEX_REASONING_EFFORT = "xhigh"
+DEFAULT_FAST_MODEL = "gpt-5.4-mini"
+DEFAULT_FAST_REASONING_EFFORT = "medium"
+
+
 def _user_home() -> Path:
     return Path(os.environ.get("HOME", str(Path.home()))).expanduser()
 
@@ -77,6 +87,7 @@ def default_client_preferences() -> dict:
         "automation_enabled": True,
         "automation_backend": CLIENT_CLAUDE_CODE,
         "client_runtime_profiles": default_client_runtime_profiles(),
+        "automation_task_profiles": default_automation_task_profiles(),
         "client_install_preferences": {
             CLIENT_CLAUDE_CODE: "ask",
             CLIENT_CODEX: "ask",
@@ -237,6 +248,31 @@ def default_client_runtime_profiles() -> dict[str, dict[str, str]]:
     }
 
 
+def default_automation_task_profiles() -> dict[str, dict[str, str]]:
+    return {
+        "default": {
+            "backend": "",
+            "model": "",
+            "reasoning_effort": "",
+        },
+        "fast": {
+            "backend": CLIENT_CODEX,
+            "model": DEFAULT_FAST_MODEL,
+            "reasoning_effort": DEFAULT_FAST_REASONING_EFFORT,
+        },
+        "balanced": {
+            "backend": "",
+            "model": "",
+            "reasoning_effort": "",
+        },
+        "deep": {
+            "backend": CLIENT_CLAUDE_CODE,
+            "model": DEFAULT_CLAUDE_CODE_MODEL,
+            "reasoning_effort": DEFAULT_CLAUDE_CODE_REASONING_EFFORT,
+        },
+    }
+
+
 def _normalize_runtime_model(value, *, default: str) -> str:
     candidate = str(value or "").strip()
     return candidate or default
@@ -276,6 +312,31 @@ def normalize_client_runtime_profiles(value) -> dict[str, dict[str, str]]:
     return normalized
 
 
+def normalize_automation_task_profiles(value) -> dict[str, dict[str, str]]:
+    defaults = default_automation_task_profiles()
+    normalized = {key: dict(profile) for key, profile in defaults.items()}
+    if not isinstance(value, dict):
+        return normalized
+
+    for raw_profile, raw_value in value.items():
+        profile_key = str(raw_profile or "").strip().lower()
+        if profile_key not in AUTOMATION_TASK_PROFILE_KEYS:
+            continue
+        if not isinstance(raw_value, dict):
+            continue
+        backend = normalize_backend_key(raw_value.get("backend"))
+        if backend == BACKEND_NONE:
+            backend = ""
+        normalized[profile_key] = {
+            "backend": backend or defaults[profile_key]["backend"],
+            "model": str(raw_value.get("model") or defaults[profile_key]["model"]).strip(),
+            "reasoning_effort": str(
+                raw_value.get("reasoning_effort") or defaults[profile_key]["reasoning_effort"]
+            ).strip().lower(),
+        }
+    return normalized
+
+
 def normalize_client_preferences(
     schedule: dict | None = None,
     *,
@@ -312,6 +373,9 @@ def normalize_client_preferences(
         "automation_enabled": automation_enabled,
         "automation_backend": automation_backend,
         "client_runtime_profiles": runtime_profiles,
+        "automation_task_profiles": normalize_automation_task_profiles(
+            schedule.get("automation_task_profiles")
+        ),
         "client_install_preferences": install_preferences,
     }
 
@@ -325,6 +389,7 @@ def apply_client_preferences(
     automation_enabled=None,
     automation_backend: str | None = None,
     client_runtime_profiles: dict | None = None,
+    automation_task_profiles: dict | None = None,
     client_install_preferences: dict | None = None,
 ) -> dict:
     merged = dict(schedule or {})
@@ -352,6 +417,11 @@ def apply_client_preferences(
         if client_runtime_profiles is not None
         else current["client_runtime_profiles"]
     )
+    merged["automation_task_profiles"] = normalize_automation_task_profiles(
+        automation_task_profiles
+        if automation_task_profiles is not None
+        else current["automation_task_profiles"]
+    )
     merged["client_install_preferences"] = normalize_client_install_preferences(
         client_install_preferences
         if client_install_preferences is not None
@@ -372,6 +442,7 @@ def save_client_preferences(
     automation_enabled=None,
     automation_backend: str | None = None,
     client_runtime_profiles: dict | None = None,
+    automation_task_profiles: dict | None = None,
     client_install_preferences: dict | None = None,
 ) -> Path:
     schedule = apply_client_preferences(
@@ -382,6 +453,7 @@ def save_client_preferences(
         automation_enabled=automation_enabled,
         automation_backend=automation_backend,
         client_runtime_profiles=client_runtime_profiles,
+        automation_task_profiles=automation_task_profiles,
         client_install_preferences=client_install_preferences,
     )
     return save_schedule_config(schedule)
@@ -477,3 +549,25 @@ def resolve_client_runtime_profile(
             default=defaults[client_key]["reasoning_effort"],
         ),
     }
+
+
+def resolve_automation_task_profile(
+    profile: str | None,
+    *,
+    preferences: dict | None = None,
+) -> dict[str, str]:
+    normalized = preferences or load_client_preferences()
+    defaults = default_automation_task_profiles()
+    profile_key = str(profile or "").strip().lower() or "default"
+    if profile_key not in AUTOMATION_TASK_PROFILE_KEYS:
+        profile_key = "default"
+    configured = normalize_automation_task_profiles(normalized.get("automation_task_profiles"))
+    selected = dict(configured.get(profile_key) or defaults[profile_key])
+    backend = selected.get("backend") or resolve_automation_backend(normalized)
+    runtime_profile = resolve_client_runtime_profile(backend, preferences=normalized)
+    return {
+        "name": profile_key,
+        "backend": backend,
+        "model": selected.get("model") or runtime_profile["model"],
+        "reasoning_effort": selected.get("reasoning_effort") or runtime_profile["reasoning_effort"],
+    }

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]: