nexo-brain 7.23.13 → 7.24.0

package/src/plugins/backup.py

@@ -174,7 +174,7 @@ def handle_backup_restore(filename: str) -> str:
             pass
         db._shared_conn = None
 
-    return f"DB restaurada desde {filename}. Safety backup: {safety.name}"
+    return f"DB restored from {filename}. Safety backup: {safety.name}"
 
 
 def _cleanup_old():

package/src/plugins/cortex.py

@@ -578,44 +578,44 @@ def _score_alternative(
 
     if direct_hits:
         impact += min(1.6, direct_hits * 0.4)
-        reasons.append("apunta directo al objetivo")
+        reasons.append("points directly at the goal")
     if safe_hits:
         success += min(1.8, safe_hits * 0.45)
         risk = max(1.0, risk - min(1.1, safe_hits * 0.35))
-        reasons.append("incluye verificación o despliegue seguro")
+        reasons.append("includes verification or safe deployment")
     if not safe_hits and task_type in {"edit", "execute"}:
         risk += 1.2
-        reasons.append("no explicita verificación")
+        reasons.append("does not make verification explicit")
     if risk_hits:
         risk += min(2.8, risk_hits * 0.7)
-        reasons.append("contiene señales de alto riesgo")
+        reasons.append("contains high-risk signals")
 
     if focus == "impact" and direct_hits:
         impact += 0.45
         risk = max(1.0, risk - 0.35)
-        reasons.append("el perfil activo prioriza impacto")
+        reasons.append("the active profile prioritizes impact")
     elif focus == "impact":
         impact = max(1.0, impact - 0.35)
-        reasons.append("el perfil activo penaliza opciones de bajo empuje")
+        reasons.append("the active profile penalizes low-momentum options")
     elif focus == "success" and safe_hits:
         success += 0.45
-        reasons.append("el perfil activo prioriza exito verificable")
+        reasons.append("the active profile prioritizes verifiable success")
     elif focus == "risk":
         if safe_hits:
             risk = max(1.0, risk - 0.4)
         if risk_hits:
             risk += 0.8
-        reasons.append("el perfil activo penaliza riesgo")
+        reasons.append("the active profile penalizes risk")
     elif focus == "somatic":
-        reasons.append("el perfil activo da peso a la huella somática")
+        reasons.append("the active profile weights the somatic footprint")
 
     history = _history_signal(lowered, area=area, goal=goal)
     success += history["positive"]
     risk += history["negative"]
     if history["positive"]:
-        reasons.append("histórico parecido favorable")
+        reasons.append("similar history is favorable")
     if history["negative"]:
-        reasons.append("histórico parecido conflictivo")
+        reasons.append("similar history is conflicting")
 
     historical = _historical_outcome_signal(
         alternative.get("name", ""),
@@ -628,15 +628,15 @@ def _score_alternative(
         risk += historical["risk_adjustment"]
         if historical["success_adjustment"] > 0:
             reasons.append(
-                f"histórico resuelto favorable ({historical['met']}/{historical['resolved_outcomes']} met)"
+                f"resolved history is favorable ({historical['met']}/{historical['resolved_outcomes']} met)"
             )
         elif historical["success_adjustment"] < 0:
             reasons.append(
-                f"histórico resuelto flojo ({historical['missed']}/{historical['resolved_outcomes']} missed)"
+                f"resolved history is weak ({historical['missed']}/{historical['resolved_outcomes']} missed)"
             )
     elif historical["resolved_outcomes"] > 0:
         reasons.append(
-            f"histórico insuficiente aún ({historical['resolved_outcomes']}/{historical['threshold']} outcomes)"
+            f"history is still insufficient ({historical['resolved_outcomes']}/{historical['threshold']} outcomes)"
         )
 
     pattern_learning = _pattern_learning_signal(
@@ -649,9 +649,9 @@ def _score_alternative(
         success += pattern_learning["success_adjustment"]
         risk += pattern_learning["risk_adjustment"]
         if pattern_learning["mode"] == "prefer":
-            reasons.append("regla estructurada capturada favorece esta estrategia")
+            reasons.append("captured structured rule favors this strategy")
         elif pattern_learning["mode"] == "avoid":
-            reasons.append("regla estructurada capturada penaliza esta estrategia")
+            reasons.append("captured structured rule penalizes this strategy")
 
     constraint_penalty, constraint_reasons = _constraint_penalty(lowered, constraints)
     if constraint_penalty:
@@ -722,19 +722,19 @@ def _log_cortex_activation(goal: str, task_type: str, result: dict):
 
 
 def _format_decision_summary(recommended: dict, alternatives_scored: list[dict]) -> str:
-    notes = ", ".join(recommended.get("notes") or []) or "balance general más sólido"
+    notes = ", ".join(recommended.get("notes") or []) or "strongest overall balance"
     historical = recommended.get("historical_signal") or {}
     second_gap = 0.0
     if len(alternatives_scored) > 1:
         second_gap = recommended["total_score"] - alternatives_scored[1]["total_score"]
     if historical.get("active"):
         notes = (
-            f"{notes}; histórico resuelto {historical.get('met', 0)}/"
-            f"{historical.get('resolved_outcomes', 0)} favorable en contexto comparable"
+            f"{notes}; resolved history {historical.get('met', 0)}/"
+            f"{historical.get('resolved_outcomes', 0)} favorable in comparable context"
         )
     if second_gap > 0.2:
-        return f"Recomendada por margen claro ({second_gap:.2f}) y porque {notes}."
-    return f"Recomendada por el mejor balance entre impacto, éxito, riesgo y huella somática; {notes}."
+        return f"Recommended by a clear margin ({second_gap:.2f}) and because {notes}."
+    return f"Recommended for the best balance between impact, success, risk, and somatic footprint; {notes}."
 
 
 def _parse_json_object_response(raw: str) -> dict:

package/src/plugins/episodic_memory.py

@@ -256,7 +256,7 @@ def handle_session_diary_write(decisions: str = '', summary: str = '',
                                 self_critique: str = '',
                                 source: str = 'claude',
                                 payload_json: str = '') -> str:
-    """Write session diary entry at end of session. OBLIGATORIO antes de cerrar.
+    """Write a session diary entry at end of session. Mandatory before closing.
 
     Args:
         decisions: What was decided and why (JSON array or structured text)
@@ -344,22 +344,22 @@ def handle_session_diary_write(decisions: str = '', summary: str = '',
     if repo_orphan_changes > 0:
         if recent_repo_orphan_changes > 0 and recent_repo_orphan_changes != repo_orphan_changes:
             warnings.append(
-                f"{_recent_change_phrase(recent_repo_orphan_changes)} de repo sin commit_ref "
+                f"{_recent_change_phrase(recent_repo_orphan_changes)} repo changes without commit_ref "
                 f"({_format_change_count(repo_orphan_changes)} de repo total)"
             )
         elif recent_repo_orphan_changes > 0:
             warnings.append(
-                f"{_recent_change_phrase(recent_repo_orphan_changes)} de repo sin commit_ref"
+                f"{_recent_change_phrase(recent_repo_orphan_changes)} repo changes without commit_ref"
             )
         else:
             warnings.append(
-                f"{_format_change_count(repo_orphan_changes)} históricos de repo sin commit_ref"
+                f"{_format_change_count(repo_orphan_changes)} historical repo changes without commit_ref"
             )
     orphan_decisions = conn.execute(
         "SELECT COUNT(*) FROM decisions WHERE (outcome IS NULL OR outcome = '') AND created_at < datetime('now', '-7 days')"
     ).fetchone()[0]
     if orphan_decisions > 0:
-        warnings.append(f"{orphan_decisions} decisions >7d sin outcome")
+        warnings.append(f"{orphan_decisions} decisions >7d without outcome")
     if warnings:
         msg += "\n⚠ EPISODIC GAPS: " + " | ".join(warnings) + " — resolve before closing session."
 
@@ -423,13 +423,13 @@ def _handle_session_diary_read_inner(session_id: str = '', last_n: int = 3, last
         if d.get('decisions'):
             lines.append(f"  Decisions: {d['decisions'][:200]}")
         if d.get('discarded'):
-            lines.append(f"  Descartado: {d['discarded'][:150]}")
+            lines.append(f"  Discarded: {d['discarded'][:150]}")
         if d.get('pending'):
             lines.append(f"  Pending: {d['pending'][:150]}")
         if d.get('context_next'):
             lines.append(f"  For next session: {d['context_next'][:200]}")
         if d.get('mental_state'):
-            lines.append(f"  Estado mental: {d['mental_state'][:300]}")
+            lines.append(f"  Mental state: {d['mental_state'][:300]}")
         if d.get('user_signals'):
             lines.append(f"  User signals: {d['user_signals'][:300]}")
     return "\n".join(lines)
@@ -477,7 +477,7 @@ def handle_change_log(files: str, what_changed: str, why: str,
             )
         else:
             msg += (
-                f"\n⚠ NO COMMIT GIT. If this was a local/server-side change, link a marker "
+                f"\n⚠ NO GIT COMMIT. If this was a local/server-side change, link a marker "
                 f"with nexo_change_commit({change_id}, 'server-direct') or "
                 f"'local-uncommitted'."
             )
@@ -507,9 +507,9 @@ def handle_change_search(query: str = '', files: str = '', days: int = 30) -> st
         if c.get('triggered_by'):
             lines.append(f"    Trigger: {c['triggered_by'][:80]}")
         if c.get('affects'):
-            lines.append(f"    Afecta: {c['affects'][:80]}")
+            lines.append(f"    Affects: {c['affects'][:80]}")
         if c.get('risks'):
-            lines.append(f"    Riesgos: {c['risks'][:80]}")
+            lines.append(f"    Risks: {c['risks'][:80]}")
     return "\n".join(lines)
 
 
@@ -644,7 +644,7 @@ def handle_diary_archive_search(
         if r.get('decisions'):
             lines.append(f"    Decisions: {r['decisions'][:150]}")
         if r.get('mental_state'):
-            lines.append(f"    Estado: {r['mental_state'][:100]}")
+            lines.append(f"    State: {r['mental_state'][:100]}")
     return "\n".join(lines)
 
 

package/src/plugins/goal_engine.py

@@ -107,11 +107,11 @@ def handle_goal_engine_status() -> str:
     }
     next_gap = []
     if not readiness["has_outcome_history"]:
-        next_gap.append("Necesita acumular outcomes reales antes de optimizar por historico.")
+        next_gap.append("Needs real outcomes before optimizing from history.")
     if not readiness["has_cortex_history"]:
-        next_gap.append("Necesita acumular evaluaciones reales del cortex antes de medir Decision Cortex v2.")
+        next_gap.append("Needs real cortex evaluations before measuring Decision Cortex v2.")
     if not readiness["has_linked_decisions"]:
-        next_gap.append("Necesita decisiones de impacto enlazadas a outcome para cerrar el loop.")
+        next_gap.append("Needs impact decisions linked to outcomes to close the loop.")
 
     return json.dumps(
         {

package/src/plugins/personal_scripts.py

@@ -6,13 +6,19 @@ from collections import Counter
 from db import init_db, list_personal_scripts, list_personal_script_schedules
 from plugins.schedule import handle_schedule_add
 from script_registry import (
+    archive_agent,
     classify_scripts_dir,
+    create_agent_script,
     create_script,
     ensure_personal_schedules,
+    get_agent_status,
     get_automation_status,
+    list_agents,
     list_operator_automations,
     reconcile_personal_scripts,
     remove_personal_script,
+    set_agent_enabled,
+    set_agent_schedule,
     set_automation_enabled,
     set_automation_instructions,
     set_automation_schedule,
@@ -168,6 +174,61 @@ def handle_automations_list(include_all: bool = False) -> str:
     return json.dumps({"ok": True, "automations": list_operator_automations(include_all=include_all)}, ensure_ascii=False)
 
 
+def handle_agents_list(include_archived: bool = False) -> str:
+    init_db()
+    return json.dumps({"ok": True, "agents": list_agents(include_archived=include_archived)}, ensure_ascii=False)
+
+
+def handle_agent_status(name: str) -> str:
+    init_db()
+    return json.dumps(get_agent_status(name), ensure_ascii=False)
+
+
+def handle_agent_create(name: str, description: str = "", runtime: str = "python") -> str:
+    init_db()
+    try:
+        return json.dumps(create_agent_script(name, description=description, runtime=runtime), ensure_ascii=False)
+    except (FileExistsError, ValueError) as exc:
+        return json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False)
+
+
+def handle_agent_enable(name: str) -> str:
+    init_db()
+    return json.dumps(set_agent_enabled(name, True), ensure_ascii=False)
+
+
+def handle_agent_disable(name: str) -> str:
+    init_db()
+    return json.dumps(set_agent_enabled(name, False), ensure_ascii=False)
+
+
+def handle_agent_archive(name: str, restore: bool = False) -> str:
+    init_db()
+    return json.dumps(archive_agent(name, archived=not bool(restore)), ensure_ascii=False)
+
+
+def handle_agent_schedule(
+    name: str,
+    every_seconds: int = 0,
+    daily_at: str = "",
+    clear: bool = False,
+) -> str:
+    init_db()
+    try:
+        interval_seconds = int(every_seconds or 0) or None
+    except (TypeError, ValueError):
+        return json.dumps({"ok": False, "error": f"Invalid every_seconds: {every_seconds}"}, ensure_ascii=False)
+    return json.dumps(
+        set_agent_schedule(
+            name,
+            interval_seconds=interval_seconds,
+            daily_at=str(daily_at or "").strip() or None,
+            clear=bool(clear),
+        ),
+        ensure_ascii=False,
+    )
+
+
 def handle_automation_status(name: str) -> str:
     init_db()
     return json.dumps(get_automation_status(name), ensure_ascii=False)
@@ -273,6 +334,20 @@ TOOLS = [
      "Set or clear operator-side extra instructions for one automation without editing the core prompt."),
     (handle_automation_schedule, "nexo_automation_schedule",
      "Set or clear the cadence override for one operator-facing automation."),
+    (handle_agents_list, "nexo_agents_list",
+     "List personal scripts marked as NEXO agents for the Desktop Home panel."),
+    (handle_agent_status, "nexo_agent_status",
+     "Read the composed runtime status for one personal-script-backed agent."),
+    (handle_agent_create, "nexo_agent_create",
+     "Create a personal script scaffold already marked as a NEXO agent."),
+    (handle_agent_enable, "nexo_agent_enable",
+     "Enable one personal-script-backed agent."),
+    (handle_agent_disable, "nexo_agent_disable",
+     "Disable one personal-script-backed agent without deleting its schedule."),
+    (handle_agent_archive, "nexo_agent_archive",
+     "Archive or restore one personal-script-backed agent without deleting its file."),
+    (handle_agent_schedule, "nexo_agent_schedule",
+     "Set or clear the cadence for one personal-script-backed agent."),
     (handle_core_schedules_list, "nexo_core_schedules_list",
      "List structural core crons whose cadence can be tuned without disabling them."),
     (handle_core_schedule_status, "nexo_core_schedule_status",

package/src/plugins/protocol.py

@@ -325,6 +325,7 @@ HIGH_STAKES_OVERRIDE_FALSE = {
     "dry-run",
     "dryrun",
 }
+TASK_OPEN_LOCAL_CONTEXT_TRUE_VALUES = {"1", "true", "yes", "y", "on", "force"}
 
 _INTERNAL_AUDIT_AREAS = {
     "guardian",
@@ -450,6 +451,14 @@ def _parse_bool(value) -> bool:
     return bool(value)
 
 
+def _task_open_local_context_enabled() -> bool:
+    """Keep heavy local-context routing off the task_open critical path by default."""
+    return (
+        os.environ.get("NEXO_TASK_OPEN_LOCAL_CONTEXT", "").strip().lower()
+        in TASK_OPEN_LOCAL_CONTEXT_TRUE_VALUES
+    )
+
+
 def _parse_int_list(value) -> list[int]:
     items = _parse_list(value)
     parsed: list[int] = []
@@ -1326,7 +1335,7 @@ def handle_task_open(
         response_contract["next_action"] = next_action
 
     recent_excerpt = format_pre_action_context_bundle(recent_bundle, compact=True) if recent_bundle.get("has_matches") else ""
-    if append_local_context_evidence is not None:
+    if append_local_context_evidence is not None and _task_open_local_context_enabled():
         recent_excerpt = append_local_context_evidence(
             recent_excerpt,
             " | ".join(part for part in [clean_goal, context_hint.strip()] if part),

package/src/pre_answer_router.py

@@ -440,6 +440,7 @@ _SOURCE_PLANS: dict[str, SourcePlan] = {
         fallback=(
             SourceStep("transcripts", phase="fallback", timeout_ms=700),
             SourceStep("memory", phase="fallback", timeout_ms=400),
+            SourceStep("local_context", phase="fallback", timeout_ms=700, max_chars=700),
         ),
     ),
     "file_location": SourcePlan(
@@ -1174,6 +1175,25 @@ def _source_project_atlas(request: SourceRequest) -> SourceResult:
 def _source_local_context(request: SourceRequest) -> SourceResult:
     from local_context import api as local_context_api
 
+    mode = _local_context_pre_answer_mode()
+    if mode == "off":
+        _record_local_context_skip(request, mode=mode, reason="disabled")
+        return SourceResult(
+            source="local_context",
+            ok=True,
+            skipped=True,
+            aborted_reason="disabled",
+        )
+    if not _local_context_query_worthwhile(request):
+        _record_local_context_skip(request, mode=mode, reason="adaptive_skip")
+        return SourceResult(
+            source="local_context",
+            ok=True,
+            skipped=True,
+            aborted_reason="adaptive_skip",
+        )
+
+    started = time.monotonic()
     payload = local_context_api.context_router(
         request.query,
         intent=request.intent,
@@ -1181,6 +1201,20 @@ def _source_local_context(request: SourceRequest) -> SourceResult:
         current_context=request.current_context,
         max_chars=request.max_chars,
     )
+    elapsed_ms = (time.monotonic() - started) * 1000
+    _record_local_context_pre_answer_usage(
+        request,
+        payload,
+        mode=mode,
+        elapsed_ms=elapsed_ms,
+    )
+    if mode == "shadow":
+        return SourceResult(
+            source="local_context",
+            ok=True,
+            skipped=True,
+            aborted_reason="shadow_no_inject",
+        )
     if not payload.get("should_inject"):
         return SourceResult(source="local_context", result_count=0)
     return SourceResult(
@@ -1191,6 +1225,88 @@ def _source_local_context(request: SourceRequest) -> SourceResult:
     )
 
 
+def _local_context_pre_answer_mode() -> str:
+    value = (
+        os.environ.get("NEXO_PRE_ANSWER_LOCAL_CONTEXT_MODE")
+        or os.environ.get("NEXO_LOCAL_CONTEXT_PRE_ANSWER_MODE")
+        or "inject"
+    )
+    clean = str(value or "").strip().lower()
+    if clean in {"0", "false", "no", "off", "disabled"}:
+        return "off"
+    if clean in {"shadow", "observe", "observability", "audit"}:
+        return "shadow"
+    return "inject"
+
+
+def _local_context_query_worthwhile(request: SourceRequest) -> bool:
+    if request.intent == "file_location":
+        return True
+    if request.files.strip() or request.area.strip():
+        return True
+    normalized = _normalize(f"{request.query}\n{request.current_context}")
+    if _PATHISH_RE.search(normalized):
+        return True
+    tokens = _plain_tokens(normalized)
+    concept_score = max(
+        _feature_score(tokens, _FEATURE_LEXICON[field])
+        for field in ("existing_ref", "location", "memory", "modify", "past_work")
+    )
+    return concept_score >= 0.18
+
+
+def _record_local_context_skip(request: SourceRequest, *, mode: str, reason: str) -> None:
+    try:
+        from local_context import usage_events
+
+        usage_events.record_usage_event(
+            query=request.query,
+            client="pre_answer_router",
+            tool="local_context",
+            source="local_context",
+            route_stage=f"pre_answer:{mode}",
+            intent=request.intent,
+            result_count=0,
+            should_inject=False,
+            aborted_reason=reason,
+            used_before_response=True,
+            metadata={
+                "adaptive": reason == "adaptive_skip",
+                "current_context_present": bool(request.current_context),
+            },
+        )
+    except Exception:
+        return
+
+
+def _record_local_context_pre_answer_usage(
+    request: SourceRequest,
+    payload: dict[str, Any],
+    *,
+    mode: str,
+    elapsed_ms: float,
+) -> None:
+    try:
+        from local_context import usage_events
+
+        usage_payload = dict(payload)
+        usage_payload["intent"] = request.intent
+        usage_payload["should_inject"] = bool(payload.get("should_inject")) and mode == "inject"
+        usage_events.record_router_usage(
+            request.query,
+            usage_payload,
+            client="pre_answer_router",
+            tool="local_context",
+            route_stage=f"pre_answer:{mode}",
+            intent=request.intent,
+            elapsed_ms=int(max(0.0, elapsed_ms)),
+            deadline_ms=0,
+            used_before_response=True,
+        )
+    except Exception:
+        return
+
+
 def _source_filesystem(request: SourceRequest) -> SourceResult:
     root = Path.cwd()
     try:

package/src/r_catalog.py

@@ -4,11 +4,10 @@ Pre-create discovery probe. Two trigger families:
 
   (a) `nexo_*_create` / `_open` / `_add` — the original MCP-tool path.
   (b) v7.7: `Edit` / `Write` writing into artefact-bearing paths
-      (skills/, plugins/, scripts/, personal scripts). The checklist
-      item "ampliar el ámbito del pre-probe de catálogo para cubrir
-      no solo nexo_*_create/_open/_add, sino también writes de
-      archivos que materializan skills/plugins/scripts/plantillas/
-      artefactos aunque no hayan pasado por un tool MCP de 'create'".
+      (skills/, plugins/, scripts/, personal scripts). This expands the
+      catalog pre-probe beyond `nexo_*_create/_open/_add` to also cover
+      writes that materialise skills, plugins, scripts, templates, or
+      artefacts without going through a dedicated MCP `create` tool.
 
 Rationale: the Guardian should not re-teach what tools exist; the live
 catalog does that. But if the agent materialises a new skill / plugin /