nexo-brain 2.1.0 → 2.3.0

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

@@ -135,21 +135,147 @@ def update_calibration_mood(synthesis: dict) -> dict:
         # Keep last 30 days
         cal["mood_history"] = cal["mood_history"][-30:]
 
-        # Apply calibration recommendation if any
+        # Apply calibration recommendation automatically
         rec = emotional_day.get("calibration_recommendation")
         if rec and rec != "null":
-            if "calibration_notes" not in cal:
-                cal["calibration_notes"] = []
-            cal["calibration_notes"].append({
+            applied_changes = []
+
+            # Parse and apply known calibration adjustments
+            rec_lower = rec.lower()
+            personality = cal.get("personality", {})
+
+            # Autonomy adjustments
+            if "autonomy" in rec_lower or "autonomía" in rec_lower:
+                if any(w in rec_lower for w in ["full", "más autonomía", "subir", "increase"]):
+                    personality["autonomy"] = "full"
+                    applied_changes.append("autonomy → full")
+                elif any(w in rec_lower for w in ["conservative", "reducir", "bajar"]):
+                    personality["autonomy"] = "conservative"
+                    applied_changes.append("autonomy → conservative")
+
+            # Communication adjustments
+            if any(w in rec_lower for w in ["concis", "breve", "shorter", "telegráf"]):
+                personality["communication"] = "concise"
+                applied_changes.append("communication → concise")
+            elif any(w in rec_lower for w in ["detail", "explicar más", "más contexto"]):
+                personality["communication"] = "detailed"
+                applied_changes.append("communication → detailed")
+
+            # Proactivity adjustments
+            if any(w in rec_lower for w in ["más proactiv", "proactive", "anticipar"]):
+                personality["proactivity"] = "proactive"
+                applied_changes.append("proactivity → proactive")
+
+            cal["personality"] = personality
+
+            # Log the recommendation and what was applied
+            if "calibration_log" not in cal:
+                cal["calibration_log"] = []
+            cal["calibration_log"].append({
                 "date": synthesis.get("date", ""),
                 "recommendation": rec,
-                "applied": False,
+                "applied": applied_changes if applied_changes else ["noted, no auto-applicable changes"],
             })
-            # Keep last 10
-            cal["calibration_notes"] = cal["calibration_notes"][-10:]
+            cal["calibration_log"] = cal["calibration_log"][-20:]
 
         calibration_file.write_text(json.dumps(cal, indent=2, ensure_ascii=False))
-        return {"success": True, "mood_score": emotional_day.get("mood_score")}
+        changes_str = ", ".join(applied_changes) if rec and applied_changes else "none"
+        return {"success": True, "mood_score": emotional_day.get("mood_score"), "calibration_applied": changes_str}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def calibrate_trust_score(synthesis: dict, target_date: str) -> dict:
+    """Set the daily trust score from Deep Sleep analysis.
+
+    This is the authoritative score for the day — replaces incremental
+    adjustments with a holistic evaluation of the entire day.
+    """
+    trust_cal = synthesis.get("trust_calibration")
+    if not trust_cal or "score" not in trust_cal:
+        return {"success": False, "error": "no trust_calibration in synthesis"}
+
+    score = max(0, min(100, trust_cal["score"]))
+    reasoning = trust_cal.get("reasoning", "Deep Sleep calibration")
+    trend = trust_cal.get("trend", "stable")
+    highlights = trust_cal.get("highlights", [])
+    lowlights = trust_cal.get("lowlights", [])
+
+    context = (
+        f"Deep Sleep {target_date} | trend: {trend} | "
+        f"highlights: {', '.join(highlights[:3])} | "
+        f"lowlights: {', '.join(lowlights[:3])}"
+    )
+
+    try:
+        # Get current score for delta calculation
+        db = sqlite3.connect(str(COGNITIVE_DB))
+        row = db.execute(
+            "SELECT score FROM trust_score ORDER BY id DESC LIMIT 1"
+        ).fetchone()
+        old_score = row[0] if row else 50.0
+        delta = score - old_score
+
+        db.execute(
+            "INSERT INTO trust_score (score, event, delta, context) VALUES (?, ?, ?, ?)",
+            (score, f"deep_sleep_calibration: {reasoning[:200]}", delta, context[:500])
+        )
+        db.commit()
+        db.close()
+
+        return {
+            "success": True,
+            "old_score": old_score,
+            "new_score": score,
+            "delta": delta,
+            "trend": trend,
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def create_skill(skill_data: dict) -> dict:
+    """Create a skill in nexo.db from Deep Sleep extraction."""
+    if not NEXO_DB.exists():
+        return {"success": False, "error": "nexo.db not found"}
+    try:
+        import hashlib
+        skill_id = skill_data.get("id", "")
+        if not skill_id:
+            skill_id = "SK-DS-" + hashlib.md5(
+                skill_data.get("name", "").encode()
+            ).hexdigest()[:8].upper()
+
+        name = skill_data.get("name", "")
+        description = skill_data.get("description", "")
+        tags = json.dumps(skill_data.get("tags", []))
+        trigger_patterns = json.dumps(skill_data.get("trigger_patterns", []))
+        source_sessions = json.dumps(skill_data.get("source_sessions", []))
+        steps = skill_data.get("steps", [])
+        gotchas = skill_data.get("gotchas", [])
+
+        # Build file content for the skill .md file
+        steps_md = "\n".join(f"{i+1}. {s}" for i, s in enumerate(steps))
+        gotchas_md = "\n".join(f"- {g}" for g in gotchas) if gotchas else "None"
+
+        conn = sqlite3.connect(str(NEXO_DB))
+        # Check if skill already exists
+        existing = conn.execute("SELECT id FROM skills WHERE id = ?", (skill_id,)).fetchone()
+        if existing:
+            conn.close()
+            return {"success": False, "error": f"Skill {skill_id} already exists", "id": skill_id}
+
+        now = datetime.now().isoformat(timespec='seconds')
+        conn.execute(
+            """INSERT INTO skills
+               (id, name, description, level, trust_score, tags, trigger_patterns,
+                source_sessions, linked_learnings, created_at, updated_at)
+               VALUES (?, ?, ?, 'draft', 50, ?, ?, ?, '[]', ?, ?)""",
+            (skill_id, name, description, tags, trigger_patterns, source_sessions, now, now),
+        )
+        conn.commit()
+        conn.close()
+        return {"success": True, "id": skill_id, "name": name}
     except Exception as e:
         return {"success": False, "error": str(e)}
 
@@ -445,6 +571,11 @@ def apply_action(action: dict, run_id: str) -> dict:
         log_entry["status"] = "applied" if result.get("success") else "error"
         log_entry["details"] = result
 
+    elif action_type == "skill_create":
+        result = create_skill(content)
+        log_entry["status"] = "applied" if result.get("success") else "error"
+        log_entry["details"] = result
+
     elif action_type == "morning_briefing_item":
         # These are included in the briefing file, not applied separately
         log_entry["status"] = "included_in_briefing"
@@ -527,6 +658,35 @@ def main():
     else:
         print(f"  Mood skip: {mood_result.get('error', '?')}")
 
+    # Calibrate trust score (authoritative daily score from Deep Sleep)
+    print("[apply] Calibrating trust score...")
+    trust_result = calibrate_trust_score(synthesis, target_date)
+    if trust_result.get("success"):
+        stats["applied"] += 1
+        print(f"  Trust: {trust_result['old_score']:.0f} → {trust_result['new_score']:.0f} (Δ{trust_result['delta']:+.0f}, {trust_result['trend']})")
+    else:
+        print(f"  Trust skip: {trust_result.get('error', '?')}")
+
+    # Create skills from synthesis
+    skills_data = synthesis.get("skills", [])
+    if skills_data:
+        print(f"[apply] Creating {len(skills_data)} skill(s)...")
+        for skill_data in skills_data:
+            if skill_data.get("confidence", 0) < 0.7:
+                continue
+            if skill_data.get("merge_with"):
+                print(f"  Skip {skill_data.get('id', '?')}: merge candidate (needs runtime merge)")
+                continue
+            result = create_skill(skill_data)
+            if result.get("success"):
+                stats["applied"] += 1
+                print(f"  Skill created: {result['id']} — {result.get('name', '')[:50]}")
+            elif "already exists" in result.get("error", ""):
+                stats["skipped_dedupe"] += 1
+            else:
+                stats["errors"] += 1
+                print(f"  Skill error: {result.get('error', 'unknown')}", file=sys.stderr)
+
     # Create followups for abandoned projects
     abandoned_results = create_abandoned_followups(synthesis)
     for r in abandoned_results:

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

@@ -116,8 +116,15 @@ def extract_session(jsonl_path: Path) -> dict | None:
     }
 
 
-def collect_transcripts(target_date: str) -> list[dict]:
-    """Collect all sessions modified on the target date."""
+def collect_transcripts_since(since_iso: str, until_iso: str = "") -> list[dict]:
+    """Collect all sessions modified after `since_iso` (exclusive) up to `until_iso` (inclusive).
+
+    Uses a watermark approach: deep sleep tracks the last processed timestamp
+    so nothing is missed regardless of when sessions happen (day, night, etc.).
+    """
+    since_dt = datetime.fromisoformat(since_iso)
+    until_dt = datetime.fromisoformat(until_iso) if until_iso else datetime.now()
+
     sessions = []
     for sdir in find_session_dirs():
         for f in sdir.glob("*.jsonl"):
@@ -125,7 +132,7 @@ def collect_transcripts(target_date: str) -> list[dict]:
                 mtime = datetime.fromtimestamp(f.stat().st_mtime)
             except OSError:
                 continue
-            if mtime.strftime("%Y-%m-%d") == target_date:
+            if since_dt < mtime <= until_dt:
                 session = extract_session(f)
                 if session:
                     session["modified"] = mtime.isoformat()
@@ -339,25 +346,40 @@ def format_transcripts(sessions: list[dict]) -> str:
 
 
 def main():
-    target_date = sys.argv[1] if len(sys.argv) > 1 else datetime.now().strftime("%Y-%m-%d")
+    # Watermark-based collection: since_iso and until_iso passed by the wrapper script
+    # argv[1] = run_id (date label for output files)
+    # argv[2] = since_iso (exclusive lower bound, e.g. "2026-04-01T04:30:00")
+    # argv[3] = until_iso (inclusive upper bound, e.g. "2026-04-02T04:30:00") — optional, defaults to now
+    run_id = sys.argv[1] if len(sys.argv) > 1 else datetime.now().strftime("%Y-%m-%d")
+    since_iso = sys.argv[2] if len(sys.argv) > 2 else ""
+    until_iso = sys.argv[3] if len(sys.argv) > 3 else ""
+
     DEEP_SLEEP_DIR.mkdir(parents=True, exist_ok=True)
 
-    print(f"[collect] Phase 1: Collecting context for {target_date}")
+    print(f"[collect] Phase 1: Collecting context (run_id={run_id})")
 
-    # 1. Transcripts
-    print("[collect] Gathering transcripts...")
-    sessions = collect_transcripts(target_date)
+    # 1. Transcripts — watermark-based
+    if since_iso:
+        print(f"[collect] Gathering transcripts since {since_iso}" + (f" until {until_iso}" if until_iso else ""))
+        sessions = collect_transcripts_since(since_iso, until_iso)
+    else:
+        # Fallback: collect everything from last 48h (safe catch-all)
+        fallback_since = (datetime.now() - timedelta(hours=48)).isoformat()
+        print(f"[collect] No watermark — collecting last 48h since {fallback_since}")
+        sessions = collect_transcripts_since(fallback_since)
     print(f"  Found {len(sessions)} sessions")
 
     if not sessions:
-        print(f"[collect] No sessions found for {target_date}. Writing minimal context file.")
-        output_file = DEEP_SLEEP_DIR / f"{target_date}-context.txt"
+        print(f"[collect] No new sessions found. Writing minimal context file.")
+        output_file = DEEP_SLEEP_DIR / f"{run_id}-context.txt"
         output_file.write_text(
-            f"Deep Sleep Context for {target_date}\n\nNo sessions found for this date.\n"
+            f"Deep Sleep Context for {run_id}\n\nNo sessions found.\n"
         )
         print(f"[collect] Output: {output_file}")
         return
 
+    target_date = run_id  # Keep variable name for downstream compat
+
     # 2. Core DB data
     print("[collect] Querying databases...")
     followups = collect_followups()

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

@@ -58,6 +58,22 @@ Detect work that was started but not finished in this session:
 - Investigations started but conclusions never reached
 Only flag if the work was NOT captured in a followup or reminder.
 
+### 9. Skill Candidates (Reusable Procedures)
+Detect multi-step tasks that were completed successfully and could be reused:
+- Tasks that required 3+ distinct steps to complete
+- Tasks where the agent followed a clear sequence of actions
+- Procedures that are likely to be repeated in the future
+- Examples: deploying code, configuring a service, running an audit, setting up infrastructure
+
+For each candidate, extract:
+- The full step-by-step procedure (what was actually done, in order)
+- Tags describing the domain (e.g., "shopify", "chrome", "deploy")
+- Trigger phrases that would indicate this procedure is needed (e.g., "deploy extension", "push theme")
+- Any gotchas or warnings discovered during execution
+
+Only flag if the procedure was SUCCESSFUL (the task was completed without major failures).
+Do NOT flag trivial tasks (single-step actions, simple file edits, quick lookups).
+
 ### 8. Productivity Patterns
 Analyze how the session went in terms of efficiency:
 - How many times did the agent need correction before getting it right?
@@ -195,6 +211,28 @@ Return ONLY valid JSON. No markdown code fences. No explanation text before or a
     }
   ],
 
+  "skill_candidates": [
+    {
+      "name": "Short name for the procedure (e.g., Deploy Chrome Extension)",
+      "description": "What this procedure accomplishes (1-2 sentences)",
+      "steps": [
+        "Step 1: What was done first",
+        "Step 2: What was done next",
+        "Step 3: etc."
+      ],
+      "tags": ["domain1", "domain2"],
+      "trigger_phrases": ["phrase that would trigger this", "another trigger"],
+      "gotchas": ["Warning or caveat discovered during execution"],
+      "evidence": {
+        "type": "transcript",
+        "session_id": "filename.jsonl",
+        "message_index": 10,
+        "quote": "Start of the multi-step task"
+      },
+      "confidence": 0.85
+    }
+  ],
+
   "productivity_score": {
     "corrections_needed": 0,
     "proactivity": "reactive|mixed|proactive",

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

@@ -113,6 +113,14 @@ def analyze_session(session_id: str, date_dir: Path, shared_context_file: Path |
     try:
         env = os.environ.copy()
         env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
+        env.pop("CLAUDECODE", None)
+        env.pop("CLAUDE_CODE", None)
+
+        JSON_SYSTEM_PROMPT = (
+            "You are a JSON-only analyst. Your ENTIRE response must be a single valid JSON object. "
+            "No text before it. No text after it. No markdown fences. No explanations. "
+            "If you want to summarize, put it inside the JSON fields. Start with { and end with }."
+        )
 
         result = subprocess.run(
             [
@@ -120,8 +128,9 @@ def analyze_session(session_id: str, date_dir: Path, shared_context_file: Path |
                 "-p", prompt,
                 "--model", "opus",
                 "--output-format", "text",
+                "--append-system-prompt", JSON_SYSTEM_PROMPT,
                 "--allowedTools",
-                "Read,Grep,Bash,mcp__nexo__nexo_startup,mcp__nexo__nexo_learning_search,mcp__nexo__nexo_recall"
+                "Read,Grep,Bash"
             ],
             capture_output=True,
             text=True,
@@ -139,6 +148,28 @@ def analyze_session(session_id: str, date_dir: Path, shared_context_file: Path |
             if not line.strip().startswith("Post-mortem") and line.strip()
         )
         parsed = extract_json_from_response(output)
+
+        # Fallback: if Claude returned text instead of JSON, ask a short conversion call
+        if not parsed and len(output.strip()) > 50:
+            print(f"    Got text instead of JSON ({len(output)} chars). Converting...")
+            convert_prompt = (
+                f"Convert the following analysis into the exact JSON schema required. "
+                f"Return ONLY the JSON object, nothing else.\n\n"
+                f"Analysis:\n{output[:8000]}\n\n"
+                f"Required schema: session_id, findings[], emotional_timeline[], "
+                f"abandoned_projects[], skill_candidates[], productivity_score, protocol_summary"
+            )
+            convert_result = subprocess.run(
+                [claude_bin, "-p", convert_prompt, "--model", "sonnet",
+                 "--output-format", "text",
+                 "--append-system-prompt", JSON_SYSTEM_PROMPT],
+                capture_output=True, text=True, timeout=120, env=env
+            )
+            if convert_result.returncode == 0:
+                parsed = extract_json_from_response(convert_result.stdout)
+                if parsed:
+                    print(f"    Conversion succeeded")
+
         if not parsed:
             # Save raw output for debugging
             debug_file = DEEP_SLEEP_DIR / f"debug-extract-{session_id[:20]}.txt"
@@ -207,32 +238,70 @@ def main():
     print(f"[extract] Phase 2: Analyzing {len(session_files)} sessions for {target_date}")
     print(f"[extract] Claude CLI: {claude_bin}")
 
+    # Checkpoint directory: one JSON per session, survives crashes
+    checkpoint_dir = date_dir / "checkpoints"
+    checkpoint_dir.mkdir(parents=True, exist_ok=True)
+
     all_extractions = []
     total_findings = 0
+    skipped = 0
+    MAX_RETRIES = 3
 
     for i, session_id in enumerate(session_files):
+        sid_safe = session_id.replace(".jsonl", "")[:30]
+        checkpoint_file = checkpoint_dir / f"{sid_safe}.json"
+
+        # Resume: skip already-processed sessions
+        if checkpoint_file.exists():
+            try:
+                with open(checkpoint_file) as f:
+                    cached = json.load(f)
+                findings_count = len(cached.get("findings", []))
+                total_findings += findings_count
+                all_extractions.append(cached)
+                skipped += 1
+                print(f"[extract] Session {i + 1}/{len(session_files)}: {session_id} (cached, {findings_count} findings)")
+                continue
+            except (json.JSONDecodeError, KeyError):
+                pass  # Corrupted checkpoint, re-process
+
         print(f"[extract] Session {i + 1}/{len(session_files)}: {session_id}")
 
-        result = analyze_session(session_id, date_dir, shared_context_file, claude_bin)
+        # Retry loop
+        result = None
+        for attempt in range(1, MAX_RETRIES + 1):
+            result = analyze_session(session_id, date_dir, shared_context_file, claude_bin)
+            if result:
+                break
+            if attempt < MAX_RETRIES:
+                print(f"    -> Attempt {attempt}/{MAX_RETRIES} failed, retrying...")
 
         if result:
             findings_count = len(result.get("findings", []))
             total_findings += findings_count
             all_extractions.append(result)
-            print(f"    -> {findings_count} findings extracted")
+            # Save checkpoint
+            with open(checkpoint_file, "w") as f:
+                json.dump(result, f, indent=2, ensure_ascii=False)
+            print(f"    -> {findings_count} findings extracted (checkpointed)")
         else:
-            print(f"    -> Extraction failed, continuing with next session")
-            all_extractions.append({
+            print(f"    -> Failed after {MAX_RETRIES} attempts, marking as failed")
+            failed_entry = {
                 "session_id": session_id,
                 "findings": [],
-                "error": "Extraction failed"
-            })
+                "error": f"Extraction failed after {MAX_RETRIES} attempts"
+            }
+            all_extractions.append(failed_entry)
+            # Save failed checkpoint too (so we don't retry forever)
+            with open(checkpoint_file, "w") as f:
+                json.dump(failed_entry, f, indent=2, ensure_ascii=False)
 
     # Merge into output
     output = {
         "date": target_date,
         "sessions_analyzed": len(session_files),
         "sessions_succeeded": len([e for e in all_extractions if "error" not in e]),
+        "sessions_cached": skipped,
         "total_findings": total_findings,
         "extractions": all_extractions
     }
@@ -241,7 +310,10 @@ def main():
     with open(output_file, "w") as f:
         json.dump(output, f, indent=2, ensure_ascii=False)
 
-    print(f"\n[extract] Done. {total_findings} total findings from {len(session_files)} sessions.")
+    if skipped:
+        print(f"\n[extract] Done. {total_findings} findings from {len(session_files)} sessions ({skipped} cached, {len(session_files) - skipped} new).")
+    else:
+        print(f"\n[extract] Done. {total_findings} findings from {len(session_files)} sessions.")
     print(f"[extract] Output: {output_file}")
 
 

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

@@ -52,7 +52,41 @@ Consolidate `abandoned_projects` from all sessions:
 - Cross-reference across sessions — was the abandoned work picked up later in another session?
 - Only flag projects that are truly abandoned (no followup AND not resumed)
 
-### 7. Consolidated Actions
+### 7. Trust Calibration (CRITICAL)
+Score the agent's performance for the day on a scale of 0-100. This score becomes the agent's trust score and directly affects its autonomy level the next day. Be fair but honest.
+
+Scoring guide:
+- **90-100**: Flawless day. Zero corrections needed. Proactive. Anticipated user needs. Deployed code without issues.
+- **70-89**: Good day. Minor corrections, quickly resolved. Mostly proactive. User satisfied.
+- **50-69**: Average day. Some corrections, some reactive behavior. Mixed results.
+- **30-49**: Below average. Multiple corrections. Repeated mistakes. User had to push.
+- **0-29**: Bad day. Many corrections, repeated errors, user frustrated. Broke things.
+
+Consider ALL of these:
+- Number and severity of corrections (most important signal)
+- Tasks completed successfully vs failed
+- Did the agent act autonomously or wait to be told?
+- Did the agent catch its own mistakes or did the user?
+- Did the agent repeat known errors (worst offense)?
+- User emotional signals throughout the day
+- Code deployed: did it work first try?
+
+The score should feel fair. A day with 2 minor corrections and 10 tasks completed is still a good day (75+). A day with 1 catastrophic error might be a 40 even if everything else was fine.
+
+### 9. Skill Extraction
+Consolidate `skill_candidates` from all session extractions into publishable skills:
+- Merge similar procedures from different sessions into a single skill
+- Generalize: replace session-specific IDs, paths, or names with placeholders or descriptions
+- Only include skills with confidence >= 0.7
+- Check if a similar skill already exists (use `nexo_skill_match` if available) — if so, note it for merging instead of creating new
+
+For each skill, generate:
+- A unique ID starting with `SK-` (e.g., `SK-DEPLOY-CHROME-EXT`)
+- Name, description, tags, trigger_patterns
+- The full step-by-step procedure as the skill content
+- Source session IDs for traceability
+
+### 8. Consolidated Actions
 Merge and deduplicate all findings into a final action list. Each action should have:
 - `action_type`: `learning_add`, `followup_create`, `morning_briefing_item`
 - `action_class`: `auto_apply` (confidence >= 0.8, reversible) or `draft_for_morning` (confidence < 0.8 or high impact)
@@ -101,9 +135,24 @@ Return ONLY valid JSON. No markdown code fences. No explanation text.
     }
   ],
 
+  "skills": [
+    {
+      "id": "SK-SHORT-ID",
+      "name": "Human readable name",
+      "description": "What this procedure does (1-2 sentences)",
+      "steps": ["Step 1", "Step 2", "Step 3"],
+      "tags": ["tag1", "tag2"],
+      "trigger_patterns": ["trigger phrase 1", "trigger phrase 2"],
+      "gotchas": ["Warning or caveat"],
+      "source_sessions": ["session1.jsonl"],
+      "confidence": 0.85,
+      "merge_with": null
+    }
+  ],
+
   "actions": [
     {
-      "action_type": "learning_add|followup_create|morning_briefing_item",
+      "action_type": "learning_add|followup_create|skill_create|morning_briefing_item",
       "action_class": "auto_apply|draft_for_morning",
       "confidence": 0.9,
       "impact": "low|medium|high",
@@ -147,6 +196,14 @@ Return ONLY valid JSON. No markdown code fences. No explanation text.
     }
   ],
 
+  "trust_calibration": {
+    "score": 72,
+    "reasoning": "Why this score -- based on corrections, completions, autonomy, proactivity, and user satisfaction signals across ALL sessions",
+    "highlights": ["What went well"],
+    "lowlights": ["What went poorly"],
+    "trend": "improving|stable|declining"
+  },
+
   "summary": "2-3 sentence overall assessment of the day"
 }
 ```

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

@@ -115,6 +115,8 @@ def main():
     try:
         env = os.environ.copy()
         env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
+        env.pop("CLAUDECODE", None)
+        env.pop("CLAUDE_CODE", None)
 
         result = subprocess.run(
             [
@@ -123,7 +125,7 @@ def main():
                 "--model", "opus",
                 "--output-format", "text",
                 "--allowedTools",
-                "Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__nexo_startup,mcp__nexo__nexo_learning_search,mcp__nexo__nexo_recall,mcp__nexo__nexo_reminders"
+                "Read,Grep,Bash"
             ],
             capture_output=True,
             text=True,

package/src/scripts/nexo-auto-update 2.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python3
+"""DEPRECATED: Updates are handled automatically by NEXO on startup."""
+import sys
+print("This script is deprecated. NEXO auto-updates on startup.")
+print("To update manually, use the nexo_update MCP tool.")
+sys.exit(0)

package/src/scripts/nexo-backup 2.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+# NEXO DB hourly backup — crontab: 0 * * * * $NEXO_HOME/scripts/nexo-backup.sh
+NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
+NEXO_DIR="$NEXO_HOME"
+BACKUP_DIR="$NEXO_HOME/backups"
+WEEKLY_DIR="$BACKUP_DIR/weekly"
+DB="$NEXO_HOME/data/nexo.db"
+RETENTION_HOURS=48
+
+mkdir -p "$BACKUP_DIR" "$WEEKLY_DIR"
+
+# Hourly backup
+TIMESTAMP=$(date +%Y-%m-%d-%H%M)
+sqlite3 "$DB" ".backup '$BACKUP_DIR/nexo-$TIMESTAMP.db'"
+
+# Weekly backup — save one per week (Sundays)
+WEEK=$(date +%Y-W%V)
+WEEKLY_FILE="$WEEKLY_DIR/weekly-$WEEK.db"
+if [ ! -f "$WEEKLY_FILE" ] && [ "$(date +%u)" = "7" ]; then
+    cp "$BACKUP_DIR/nexo-$TIMESTAMP.db" "$WEEKLY_FILE"
+fi
+
+# Cleanup: hourly >48h, weekly >90 days
+find "$BACKUP_DIR" -maxdepth 1 -name "nexo-*.db" -mmin +$((RETENTION_HOURS * 60)) -delete
+find "$WEEKLY_DIR" -name "weekly-*.db" -mtime +90 -delete