nexo-brain 2.6.20 → 2.7.0

package/src/scripts/deep-sleep/synthesize-prompt.md

@@ -30,6 +30,15 @@ Synthesize across all sessions:
 - Cross-domain connections where an older learning or session sample explains a current issue
 - Topics repeatedly mentioned over time but never formalized into a learning or followup
 - Project pressure that is rising because of repeated diary mentions, open followups, or adverse outcomes
+- For medium/high-severity patterns, propose a concrete fix artifact:
+  - script
+  - hook
+  - checklist
+  - validation step
+  - workflow change
+  - guardrail
+
+Do not stop at diagnosis. Turn repeated problems into concrete engineering work.
 
 ### 2. Morning Agenda
 Generate a prioritized agenda for the next morning:
@@ -126,6 +135,14 @@ Merge and deduplicate all findings into a final action list. Each action should
 - `dedupe_key`: deterministic key for idempotency
 - `content`: the actual data to write
 
+When generating `followup_create`, prefer descriptions that start with a concrete verb and include the deliverable:
+- "Add a pre-release validation script ..."
+- "Implement a guard hook that ..."
+- "Create a checklist for ..."
+- "Write a watchdog check that ..."
+
+Avoid vague followups that merely restate the diagnosis.
+
 ## Output Format
 
 Return ONLY valid JSON. No markdown code fences. No explanation text.
@@ -140,6 +157,12 @@ Return ONLY valid JSON. No markdown code fences. No explanation text.
       "pattern": "Description of the pattern",
       "sessions": ["session1.jsonl", "session2.jsonl"],
       "severity": "low|medium|high",
+      "proposed_fix": {
+        "title": "Short concrete fix title",
+        "description": "Concrete engineering change to make",
+        "deliverable": "script|hook|checklist|workflow|guardrail",
+        "confidence": 0.0
+      },
       "evidence": [
         {"type": "transcript", "session_id": "...", "message_index": 42, "quote": "..."}
       ]

package/src/scripts/deep-sleep/synthesize.py

@@ -14,6 +14,7 @@ import json
 import os
 import subprocess
 import sys
+import hashlib
 from datetime import datetime
 from pathlib import Path
 
@@ -28,6 +29,7 @@ if str(NEXO_CODE) not in sys.path:
 from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
 
 CLAUDE_TIMEOUT = 21600  # 3h safety net (prevents zombie processes)
+ACTION_VERBS = {"add", "implement", "create", "write", "build", "enforce", "automate", "validate", "guard", "fix", "review"}
 
 
 def extract_json_from_response(text: str) -> dict | None:
@@ -86,6 +88,96 @@ def collect_skill_runtime_candidates(target_date: str) -> tuple[Path, dict]:
     return output_file, payload
 
 
+def _normalize_action_text(value: str) -> str:
+    return " ".join(str(value or "").strip().lower().split())
+
+
+def _looks_concrete_action(text: str) -> bool:
+    words = {word.strip(".,:;()[]{}").lower() for word in str(text or "").split()}
+    return bool(words & ACTION_VERBS)
+
+
+def _pattern_followup_from_fix(pattern: dict) -> dict | None:
+    severity = str(pattern.get("severity", "") or "").lower()
+    sessions = pattern.get("sessions", []) or []
+    if severity not in {"medium", "high"} and len(sessions) < 2:
+        return None
+
+    proposed_fix = pattern.get("proposed_fix") or {}
+    pattern_text = str(pattern.get("pattern", "") or "").strip()
+    title = str(proposed_fix.get("title", "") or "").strip()
+    description = str(proposed_fix.get("description", "") or "").strip()
+    deliverable = str(proposed_fix.get("deliverable", "") or proposed_fix.get("artifact", "") or "").strip()
+
+    if title and description:
+        if _looks_concrete_action(description):
+            followup_description = description
+        else:
+            followup_description = f"{title}: {description}"
+    elif description:
+        followup_description = description
+    elif title:
+        followup_description = title
+    elif pattern_text:
+        followup_description = (
+            f"Implement a concrete guardrail for recurring issue: {pattern_text}. "
+            "Deliverable should be a script, hook, checklist, or automated validation that prevents the same failure from repeating."
+        )
+    else:
+        return None
+
+    if deliverable and deliverable.lower() not in followup_description.lower():
+        followup_description = f"{followup_description} Deliverable: {deliverable}."
+    if not _looks_concrete_action(followup_description):
+        followup_description = f"Implement this fix: {followup_description}"
+
+    return {
+        "action_type": "followup_create",
+        "action_class": "auto_apply" if severity == "high" else "draft_for_morning",
+        "confidence": round(max(float(proposed_fix.get("confidence", 0.0) or 0.0), 0.86 if severity == "high" else 0.78), 2),
+        "impact": "high" if severity == "high" else "medium",
+        "reversibility": "reversible",
+        "evidence": pattern.get("evidence", []) or [],
+        "dedupe_key": "engineering-fix:" + hashlib.md5(
+            _normalize_action_text(followup_description).encode("utf-8")
+        ).hexdigest()[:16],
+        "content": {
+            "title": title or f"Engineering fix for: {pattern_text[:90]}",
+            "description": followup_description,
+            "date": "",
+            "reasoning": f"Deep Sleep engineering followup from recurring pattern: {pattern_text}",
+        },
+    }
+
+
+def backfill_engineering_actions(payload: dict) -> dict:
+    if not isinstance(payload, dict):
+        return payload
+    actions = payload.get("actions")
+    if not isinstance(actions, list):
+        actions = []
+        payload["actions"] = actions
+
+    existing_keys = {str(action.get("dedupe_key", "") or "") for action in actions}
+    existing_descriptions = {
+        _normalize_action_text(action.get("content", {}).get("description", ""))
+        for action in actions
+        if isinstance(action, dict)
+    }
+
+    for pattern in payload.get("cross_session_patterns", []) or []:
+        action = _pattern_followup_from_fix(pattern)
+        if not action:
+            continue
+        description = _normalize_action_text(action["content"]["description"])
+        if action["dedupe_key"] in existing_keys or description in existing_descriptions:
+            continue
+        actions.append(action)
+        existing_keys.add(action["dedupe_key"])
+        existing_descriptions.add(description)
+    return payload
+
+
 def main():
     target_date = sys.argv[1] if len(sys.argv) > 1 else datetime.now().strftime("%Y-%m-%d")
 
@@ -177,6 +269,8 @@ def main():
             print(f"[synthesize] Failed to parse JSON. Raw output saved to {debug_file}", file=sys.stderr)
             sys.exit(1)
 
+        parsed = backfill_engineering_actions(parsed)
+
         # Write synthesis output
         output_file = DEEP_SLEEP_DIR / f"{target_date}-synthesis.json"
         with open(output_file, "w") as f:

package/templates/nexo_helper.py

@@ -16,6 +16,36 @@ from pathlib import Path
 
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+DEFAULT_ALLOWED_TOOLS = "Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*"
+
+
+def _load_schedule() -> dict:
+    schedule_path = NEXO_HOME / "config" / "schedule.json"
+    if not schedule_path.is_file():
+        return {}
+    try:
+        return json.loads(schedule_path.read_text())
+    except Exception:
+        return {}
+
+
+def _resolve_automation_backend() -> str:
+    data = _load_schedule()
+    return str(data.get("automation_backend", "claude_code") or "claude_code")
+
+
+def _load_bootstrap_prompt() -> str:
+    backend = _resolve_automation_backend()
+    if backend == "codex":
+        path = Path.home() / ".codex" / "AGENTS.md"
+    else:
+        path = Path.home() / ".claude" / "CLAUDE.md"
+    if not path.is_file():
+        return ""
+    try:
+        return path.read_text()
+    except Exception:
+        return ""
 
 
 def run_nexo(args: list[str]) -> str:
@@ -57,6 +87,9 @@ def run_automation_text(
     model: str = "",
     reasoning_effort: str = "",
     cwd: str = "",
+    allowed_tools: str = DEFAULT_ALLOWED_TOOLS,
+    append_system_prompt: str = "",
+    include_bootstrap: bool = True,
 ) -> str:
     """Run the configured NEXO automation backend and return text output.
 
@@ -75,6 +108,17 @@ def run_automation_text(
         cmd.extend(["--reasoning-effort", reasoning_effort])
     if cwd:
         cmd.extend(["--cwd", cwd])
+    merged_system_prompt = []
+    if include_bootstrap:
+        bootstrap = _load_bootstrap_prompt()
+        if bootstrap:
+            merged_system_prompt.append(bootstrap)
+    if append_system_prompt:
+        merged_system_prompt.append(append_system_prompt)
+    if merged_system_prompt:
+        cmd.extend(["--append-system-prompt", "\n\n".join(merged_system_prompt)])
+    if allowed_tools:
+        cmd.extend(["--allowed-tools", allowed_tools])
 
     env = os.environ.copy()
     env.setdefault("NEXO_HOME", str(NEXO_HOME))