nexo-brain 5.3.20 → 5.3.21

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

@@ -0,0 +1,2327 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+"""
+Deep Sleep v2 -- Phase 4: Apply synthesized findings.
+
+Reads $DATE-synthesis.json and executes actions:
+- learning_add: inserts learnings into nexo.db
+- followup_create: inserts followups into nexo.db
+- morning_briefing_item: writes to morning briefing file
+
+All actions are idempotent (dedupe_key checked against last 7 days),
+backed up before mutation, and logged to $DATE-applied.json.
+
+Environment variables:
+  NEXO_HOME  -- root of the NEXO installation (default: ~/.nexo)
+"""
+import hashlib
+import json
+import os
+import re
+import sqlite3
+import sys
+from collections import Counter
+from datetime import datetime, timedelta
+from difflib import SequenceMatcher
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parents[2])))
+if str(NEXO_CODE) not in sys.path:
+    sys.path.insert(0, str(NEXO_CODE))
+
+import db as nexo_db
+
+DEEP_SLEEP_DIR = NEXO_HOME / "operations" / "deep-sleep"
+NEXO_DB = NEXO_HOME / "data" / "nexo.db"
+COGNITIVE_DB = NEXO_HOME / "data" / "cognitive.db"
+OPERATIONS_DIR = NEXO_HOME / "operations"
+BACKUP_DIR = DEEP_SLEEP_DIR  # backups stored alongside outputs
+
+STOPWORDS = {
+    "the", "a", "an", "and", "or", "but", "with", "for", "from", "into", "onto",
+    "that", "this", "these", "those", "have", "has", "had", "will", "would",
+    "could", "should", "must", "need", "needs", "your", "their", "there", "here",
+    "about", "before", "after", "during", "through", "without", "within", "while",
+    "que", "con", "para", "por", "los", "las", "una", "uno", "sobre", "desde",
+    "cuando", "como", "pero", "todo", "toda", "cada", "into", "across", "using",
+}
+CONCRETE_ACTION_VERBS = {
+    "add", "implement", "create", "write", "build", "introduce", "enforce",
+    "automate", "validate", "check", "verify", "guard", "fix", "migrate",
+    "review", "reconcile", "pin", "sync", "instrument",
+}
+NEGATION_PATTERNS = (
+    "do not", "don't", "never", "avoid", "skip", "without", "forbid", "forbidden",
+    "disable", "disabled", "remove", "ban", "bypass",
+)
+CONTRADICTION_PAIRS = (
+    ("enable", "disable"),
+    ("use", "avoid"),
+    ("add", "remove"),
+    ("allow", "forbid"),
+    ("always", "never"),
+    ("before", "after"),
+    ("require", "skip"),
+    ("validate", "bypass"),
+    ("include", "exclude"),
+)
+TABLE_COLUMNS_CACHE: dict[tuple[str, str], set[str]] = {}
+
+
+def generate_run_id(target_date: str) -> str:
+    """Generate a unique run ID for this execution."""
+    ts = datetime.now().strftime("%H%M%S")
+    return f"{target_date}-{ts}"
+
+
+def _decode_json_object(value) -> dict:
+    if isinstance(value, dict):
+        return value
+    if isinstance(value, str):
+        stripped = value.strip()
+        if not stripped:
+            return {}
+        try:
+            parsed = json.loads(stripped)
+        except json.JSONDecodeError:
+            return {}
+        return parsed if isinstance(parsed, dict) else {}
+    return {}
+
+
+def _top_followups_by_impact(limit: int = 5) -> list[dict]:
+    if not NEXO_DB.exists():
+        return []
+    try:
+        conn = sqlite3.connect(str(NEXO_DB))
+        conn.row_factory = sqlite3.Row
+        columns = {str(row[1]) for row in conn.execute("PRAGMA table_info(followups)").fetchall()}
+        if "impact_score" not in columns:
+            conn.close()
+            return []
+        impact_factors_sql = ", impact_factors" if "impact_factors" in columns else ""
+        rows = [
+            dict(row)
+            for row in conn.execute(
+                f"""SELECT id, description, date, priority, impact_score{impact_factors_sql}
+                    FROM followups
+                    WHERE status IN ('PENDING', 'ACTIVE', 'WAITING', 'BLOCKED')
+                    ORDER BY
+                      CASE WHEN COALESCE(impact_score, 0) > 0 THEN 0 ELSE 1 END ASC,
+                      COALESCE(impact_score, 0) DESC,
+                      CASE WHEN date IS NULL OR date = '' THEN 1 ELSE 0 END ASC,
+                      date ASC
+                    LIMIT ?""",
+                (max(1, int(limit)),),
+            ).fetchall()
+        ]
+        conn.close()
+    except Exception:
+        return []
+
+    for row in rows:
+        factors = _decode_json_object(row.get("impact_factors"))
+        row["impact_factors"] = factors
+        row["impact_reasoning"] = str(factors.get("reasoning") or "").strip()
+    return rows
+
+
+def _read_impact_summary() -> dict:
+    path = NEXO_HOME / "coordination" / "impact-scorer-summary.json"
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def load_recent_dedupe_keys(target_date: str, days: int = 7) -> set[str]:
+    """Load dedupe_keys from applied files in the last N days."""
+    keys = set()
+    base_date = datetime.strptime(target_date, "%Y-%m-%d")
+    for i in range(days):
+        d = (base_date - timedelta(days=i)).strftime("%Y-%m-%d")
+        applied_file = DEEP_SLEEP_DIR / f"{d}-applied.json"
+        if applied_file.exists():
+            try:
+                with open(applied_file) as f:
+                    data = json.load(f)
+                for action in data.get("applied_actions", []):
+                    dk = action.get("dedupe_key", "")
+                    if dk:
+                        keys.add(dk)
+            except (json.JSONDecodeError, KeyError):
+                continue
+    return keys
+
+
+def backup_db(db_path: Path, run_id: str) -> Path | None:
+    """Create a backup of a database before mutations."""
+    if not db_path.exists():
+        return None
+    backup_path = BACKUP_DIR / f"{run_id}-backup-{db_path.name}"
+    try:
+        import shutil
+        shutil.copy2(str(db_path), str(backup_path))
+        return backup_path
+    except Exception as e:
+        print(f"  [apply] Warning: backup failed for {db_path.name}: {e}", file=sys.stderr)
+        return None
+
+
+def _table_columns(db_path: Path, table: str) -> set[str]:
+    cache_key = (str(db_path), table)
+    if cache_key in TABLE_COLUMNS_CACHE:
+        return TABLE_COLUMNS_CACHE[cache_key]
+    if not db_path.exists():
+        TABLE_COLUMNS_CACHE[cache_key] = set()
+        return set()
+    try:
+        conn = sqlite3.connect(str(db_path))
+        rows = conn.execute(f"PRAGMA table_info({table})").fetchall()
+        conn.close()
+    except Exception:
+        TABLE_COLUMNS_CACHE[cache_key] = set()
+        return set()
+    cols = {str(row[1]) for row in rows}
+    TABLE_COLUMNS_CACHE[cache_key] = cols
+    return cols
+
+
+def _row_dict(row) -> dict:
+    if row is None:
+        return {}
+    if isinstance(row, sqlite3.Row):
+        return dict(row)
+    return dict(zip(row.keys(), row)) if hasattr(row, "keys") else dict(row)
+
+
+def _normalize_text(value: str) -> str:
+    text = str(value or "").lower()
+    text = re.sub(r"https?://\S+", " ", text)
+    text = re.sub(r"[^a-z0-9_/\-\s]+", " ", text)
+    text = re.sub(r"\s+", " ", text)
+    return text.strip()
+
+
+def _tokenize(value: str) -> list[str]:
+    tokens = re.findall(r"[a-z0-9_/-]+", _normalize_text(value))
+    return [token for token in tokens if len(token) > 2 and token not in STOPWORDS]
+
+
+def _text_similarity(left: str, right: str) -> float:
+    normalized_left = _normalize_text(left)
+    normalized_right = _normalize_text(right)
+    if not normalized_left or not normalized_right:
+        return 0.0
+    if normalized_left == normalized_right:
+        return 1.0
+
+    left_tokens = set(_tokenize(normalized_left))
+    right_tokens = set(_tokenize(normalized_right))
+    shared = left_tokens & right_tokens
+    if not shared:
+        return SequenceMatcher(None, normalized_left, normalized_right).ratio()
+
+    seq = SequenceMatcher(None, normalized_left, normalized_right).ratio()
+    jaccard = len(shared) / len(left_tokens | right_tokens) if (left_tokens or right_tokens) else 0.0
+    overlap = len(shared) / min(len(left_tokens), len(right_tokens)) if min(len(left_tokens), len(right_tokens)) else 0.0
+    containment = (
+        1.0
+        if normalized_left in normalized_right or normalized_right in normalized_left
+        else 0.0
+    )
+    return round(max((seq * 0.45) + (jaccard * 0.2) + (overlap * 0.35), overlap, (containment * 0.8) + (seq * 0.2)), 4)
+
+
+def _is_concrete_action(text: str) -> bool:
+    tokens = set(_tokenize(text))
+    return bool(tokens & CONCRETE_ACTION_VERBS)
+
+
+def _prefer_due_date(current_value, new_value) -> str:
+    current = _parse_any_datetime(current_value)
+    new = _parse_any_datetime(new_value)
+    if new and (not current or new <= current):
+        return str(new_value or "")
+    return str(current_value or "")
+
+
+def _append_note(base: str, note: str) -> str:
+    base = str(base or "").strip()
+    note = str(note or "").strip()
+    if not note:
+        return base
+    if not base:
+        return note
+    if note.lower() in base.lower():
+        return base
+    return f"{base}\n\n{note}"
+
+
+def _contains_negation(text: str) -> bool:
+    lowered = _normalize_text(text)
+    return any(token in lowered for token in NEGATION_PATTERNS)
+
+
+def _negated_action_verbs(text: str) -> set[str]:
+    lowered = _normalize_text(text)
+    matches = set()
+    for pattern in (r"(?:never|avoid|skip|disable|remove|forbid|bypass)\s+([a-z0-9_-]+)", r"(?:do not|don't)\s+([a-z0-9_-]+)"):
+        matches.update(re.findall(pattern, lowered))
+    return {match for match in matches if len(match) > 2}
+
+
+def _looks_contradictory(existing_text: str, new_text: str) -> bool:
+    existing_norm = _normalize_text(existing_text)
+    new_norm = _normalize_text(new_text)
+    if not existing_norm or not new_norm:
+        return False
+    existing_tokens = set(_tokenize(existing_norm))
+    new_tokens = set(_tokenize(new_norm))
+    if len(existing_tokens & new_tokens) < 3:
+        return False
+    existing_negated_verbs = _negated_action_verbs(existing_norm)
+    new_negated_verbs = _negated_action_verbs(new_norm)
+    if existing_negated_verbs & new_tokens and not existing_negated_verbs & new_negated_verbs:
+        return True
+    if new_negated_verbs & existing_tokens and not existing_negated_verbs & new_negated_verbs:
+        return True
+    if _contains_negation(existing_norm) != _contains_negation(new_norm):
+        return True
+    for positive, negative in CONTRADICTION_PAIRS:
+        existing_has_pair = positive in existing_norm or negative in existing_norm
+        new_has_pair = positive in new_norm or negative in new_norm
+        if existing_has_pair and new_has_pair:
+            if (positive in existing_norm and negative in new_norm) or (negative in existing_norm and positive in new_norm):
+                return True
+    return False
+
+
+def _fetch_open_followups() -> list[dict]:
+    if not NEXO_DB.exists():
+        return []
+    conn = sqlite3.connect(str(NEXO_DB))
+    conn.row_factory = sqlite3.Row
+    cols = _table_columns(NEXO_DB, "followups")
+    reasoning_sql = ", reasoning" if "reasoning" in cols else ""
+    verification_sql = ", verification" if "verification" in cols else ""
+    impact_sql = ", impact_score" if "impact_score" in cols else ""
+    try:
+        rows = conn.execute(
+            "SELECT id, description, date, status"
+            f"{verification_sql}{reasoning_sql}{impact_sql} "
+            "FROM followups WHERE status NOT LIKE 'COMPLETED%' "
+            "AND status NOT IN ('DELETED','archived','blocked','waiting','CANCELLED')"
+        ).fetchall()
+    finally:
+        conn.close()
+    return [dict(row) for row in rows]
+
+
+def _find_similar_followup(description: str, threshold: float = 0.58) -> dict | None:
+    candidates = []
+    query = str(description or "").strip()
+    if not query:
+        return None
+    query_tokens = set(_tokenize(query))
+    for row in _fetch_open_followups():
+        haystack = " ".join(
+            [
+                str(row.get("description", "") or ""),
+                str(row.get("verification", "") or ""),
+                str(row.get("reasoning", "") or ""),
+            ]
+        )
+        haystack_tokens = set(_tokenize(haystack))
+        if len(query_tokens & haystack_tokens) < 2 and _normalize_text(query) not in _normalize_text(haystack):
+            continue
+        score = _text_similarity(query, haystack)
+        if score >= threshold:
+            candidates.append({**row, "_similarity": score})
+    if not candidates:
+        return None
+    candidates.sort(key=lambda item: item["_similarity"], reverse=True)
+    return candidates[0]
+
+
+def _touch_existing_followup(
+    existing: dict,
+    *,
+    description: str,
+    date: str = "",
+    reasoning_note: str = "",
+    status: str = "",
+) -> dict:
+    cols = _table_columns(NEXO_DB, "followups")
+    if not cols:
+        return {"success": False, "error": "followups table not found"}
+
+    updates: dict[str, object] = {}
+    existing_description = str(existing.get("description", "") or "")
+    if _is_concrete_action(description) and not _is_concrete_action(existing_description):
+        updates["description"] = description
+    preferred_date = _prefer_due_date(existing.get("date", ""), date)
+    if preferred_date and preferred_date != str(existing.get("date", "") or "") and "date" in cols:
+        updates["date"] = preferred_date
+    desired_status = (status or "").strip()
+    if desired_status and "status" in cols and desired_status != str(existing.get("status", "") or ""):
+        updates["status"] = desired_status
+    note = reasoning_note or "Deep Sleep matched this followup semantically."
+    changed = False
+    if updates:
+        result = nexo_db.update_followup(
+            str(existing["id"]),
+            history_actor="deep-sleep",
+            history_event="updated",
+            history_note=note,
+            **updates,
+        )
+        if result.get("error"):
+            return {"success": False, "error": result["error"]}
+        changed = True
+    elif note:
+        note_result = nexo_db.add_followup_note(str(existing["id"]), note, actor="deep-sleep")
+        if note_result.get("error"):
+            return {"success": False, "error": note_result["error"]}
+        changed = True
+
+    return {
+        "success": True,
+        "id": existing["id"],
+        "outcome": "matched_existing_followup",
+        "similarity": existing.get("_similarity", 1.0),
+        "updated_existing": changed,
+    }
+
+
+def _fetch_learning_candidates(category: str = "") -> list[dict]:
+    if not NEXO_DB.exists():
+        return []
+    cols = _table_columns(NEXO_DB, "learnings")
+    if not cols:
+        return []
+    select_fields = ["id", "category", "title", "content", "created_at", "updated_at"]
+    for optional in ("reasoning", "prevention", "applies_to", "status", "review_due_at", "last_reviewed_at", "weight", "priority"):
+        if optional in cols:
+            select_fields.append(optional)
+    query = f"SELECT {', '.join(select_fields)} FROM learnings"
+    params: list[object] = []
+    if category and "category" in cols:
+        query += " WHERE category = ?"
+        params.append(category)
+    query += " ORDER BY COALESCE(updated_at, created_at) DESC LIMIT 240"
+    conn = sqlite3.connect(str(NEXO_DB))
+    conn.row_factory = sqlite3.Row
+    try:
+        rows = conn.execute(query, tuple(params)).fetchall()
+    finally:
+        conn.close()
+    return [dict(row) for row in rows]
+
+
+def _find_learning_match(category: str, title: str, content: str) -> dict | None:
+    candidates = []
+    new_text = " ".join([str(title or ""), str(content or "")]).strip()
+    for row in _fetch_learning_candidates(category):
+        existing_text = " ".join([str(row.get("title", "") or ""), str(row.get("content", "") or "")])
+        similarity = _text_similarity(new_text, existing_text)
+        if similarity < 0.58:
+            continue
+        contradiction = _looks_contradictory(existing_text, new_text)
+        candidates.append({**row, "_similarity": similarity, "_contradiction": contradiction})
+    if not candidates:
+        return None
+    candidates.sort(
+        key=lambda item: (item["_contradiction"], item["_similarity"], item.get("updated_at", 0) or item.get("created_at", 0)),
+        reverse=True,
+    )
+    return candidates[0]
+
+
+def _update_learning_row(learning_id: int, updates: dict[str, object]) -> None:
+    if not updates:
+        return
+    conn = sqlite3.connect(str(NEXO_DB))
+    set_clause = ", ".join(f"{column} = ?" for column in updates)
+    conn.execute(f"UPDATE learnings SET {set_clause} WHERE id = ?", list(updates.values()) + [learning_id])
+    conn.commit()
+    conn.close()
+
+
+def _bump_weight(existing_value, amount: float) -> float:
+    try:
+        base = float(existing_value or 0)
+    except Exception:
+        base = 0.0
+    return round(min(10.0, base + amount), 2)
+
+
+def _flag_learning_contradiction(existing: dict, category: str, title: str, content: str) -> dict:
+    review_description = (
+        f"Reconcile contradictory learning in {category or 'general'}: "
+        f"review existing learning #{existing.get('id')} ('{existing.get('title', '')}') "
+        f"against new Deep Sleep finding '{title}'. Produce one canonical rule, update guardrails, and remove ambiguity."
+    )
+    followup_result = create_followup(
+        description=review_description,
+        date="",
+        reasoning_note=f"Contradiction detected against learning #{existing.get('id')}: {content[:240]}",
+    )
+    return {
+        "success": followup_result.get("success", False),
+        "id": existing.get("id"),
+        "outcome": "contradiction_review",
+        "similarity": existing.get("_similarity", 0.0),
+        "review_followup_id": followup_result.get("id"),
+        "followup_result": followup_result,
+    }
+
+
+def add_learning(category: str, title: str, content: str) -> dict:
+    """Add a learning to nexo.db. Returns result dict."""
+    if not NEXO_DB.exists():
+        return {"success": False, "error": "nexo.db not found"}
+    try:
+        existing = _find_learning_match(category, title, content)
+        if existing:
+            similarity = existing.get("_similarity", 0.0)
+            if existing.get("_contradiction"):
+                return _flag_learning_contradiction(existing, category, title, content)
+
+            updates: dict[str, object] = {}
+            columns = _table_columns(NEXO_DB, "learnings")
+            if "updated_at" in columns:
+                updates["updated_at"] = datetime.now().timestamp()
+
+            existing_title = _normalize_text(existing.get("title", ""))
+            existing_content = _normalize_text(existing.get("content", ""))
+            incoming_title = _normalize_text(title)
+            incoming_content = _normalize_text(content)
+
+            if similarity >= 0.95 and (
+                existing_title == incoming_title
+                or existing_content == incoming_content
+                or incoming_content in existing_content
+                or existing_content in incoming_content
+            ):
+                if "weight" in columns:
+                    updates["weight"] = _bump_weight(existing.get("weight"), 0.1)
+                if "last_reviewed_at" in columns:
+                    updates["last_reviewed_at"] = datetime.now().timestamp()
+                if "reasoning" in columns:
+                    updates["reasoning"] = _append_note(
+                        existing.get("reasoning", ""),
+                        f"Reconfirmed by Deep Sleep on {datetime.now().strftime('%Y-%m-%d')}.",
+                    )
+                _update_learning_row(existing["id"], updates)
+                return {
+                    "success": True,
+                    "id": existing["id"],
+                    "outcome": "duplicate_learning",
+                    "similarity": similarity,
+                    "updated_existing": bool(updates),
+                }
+
+            if similarity >= 0.58:
+                if "weight" in columns:
+                    updates["weight"] = _bump_weight(existing.get("weight"), 0.25)
+                if "reasoning" in columns:
+                    updates["reasoning"] = _append_note(
+                        existing.get("reasoning", ""),
+                        f"Deep Sleep reinforcement ({datetime.now().strftime('%Y-%m-%d')}): {title}. {content[:240]}",
+                    )
+                elif "content" in columns and content and content not in str(existing.get("content", "")):
+                    updates["content"] = _append_note(
+                        existing.get("content", ""),
+                        f"Reinforced by Deep Sleep: {content[:240]}",
+                    )
+                _update_learning_row(existing["id"], updates)
+                return {
+                    "success": True,
+                    "id": existing["id"],
+                    "outcome": "reinforced_learning",
+                    "similarity": similarity,
+                    "updated_existing": bool(updates),
+                }
+
+        now = datetime.now().timestamp()
+        columns = _table_columns(NEXO_DB, "learnings")
+        payload = {
+            "category": category,
+            "title": title,
+            "content": content,
+            "created_at": now,
+            "updated_at": now,
+        }
+        if "reasoning" in columns:
+            payload["reasoning"] = "Deep Sleep v2 overnight analysis"
+        if "status" in columns:
+            payload["status"] = "active"
+        insert_columns = [column for column in payload if column in columns]
+        values = [payload[column] for column in insert_columns]
+
+        conn = sqlite3.connect(str(NEXO_DB))
+        cursor = conn.execute(
+            f"INSERT INTO learnings ({', '.join(insert_columns)}) VALUES ({', '.join('?' for _ in insert_columns)})",
+            values,
+        )
+        learning_id = cursor.lastrowid
+        conn.commit()
+        conn.close()
+        return {"success": True, "id": learning_id, "outcome": "new_learning"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def create_followup(description: str, date: str = "", reasoning_note: str = "", status: str = "PENDING") -> dict:
+    """Create a followup in nexo.db. Returns result dict."""
+    if not NEXO_DB.exists():
+        return {"success": False, "error": "nexo.db not found"}
+    try:
+        desired_status = (status or "PENDING").strip() or "PENDING"
+        is_abandoned = description.strip().startswith("[Abandoned]")
+        if not is_abandoned:
+            matched = _find_similar_followup(description)
+            if matched:
+                return _touch_existing_followup(
+                    matched,
+                    description=description,
+                    date=date,
+                    reasoning_note=reasoning_note or "Deep Sleep matched this followup semantically.",
+                    status=desired_status,
+                )
+
+        # Generate a deterministic ID — content fingerprint, not security-sensitive.
+        fid = "NF-DS-" + hashlib.md5(description.encode(), usedforsecurity=False).hexdigest()[:8].upper()
+        existing = nexo_db.get_followup(fid)
+        if existing:
+            return _touch_existing_followup(
+                existing,
+                description=description,
+                date=date,
+                reasoning_note=reasoning_note or "Deep Sleep revisited this deterministic followup.",
+                status=desired_status,
+            )
+
+        followup_result = nexo_db.create_followup(
+            id=fid,
+            description=description,
+            date=date or None,
+            verification="",
+            status=desired_status,
+            reasoning=reasoning_note or "Deep Sleep v2 overnight analysis",
+            recurrence=None,
+        )
+        if followup_result.get("error"):
+            return {"success": False, "error": followup_result["error"]}
+        if desired_status != "PENDING":
+            nexo_db.add_followup_note(
+                fid,
+                f"Deep Sleep created this followup directly as {desired_status}.",
+                actor="deep-sleep",
+            )
+        return {"success": True, "id": fid, "outcome": "new_followup"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def update_calibration_mood(synthesis: dict) -> dict:
+    """Update mood in calibration.json based on emotional analysis."""
+    calibration_file = NEXO_HOME / "brain" / "calibration.json"
+    if not calibration_file.exists():
+        return {"success": False, "error": "calibration.json not found"}
+
+    emotional_day = synthesis.get("emotional_day", {})
+    if not emotional_day:
+        return {"success": False, "error": "no emotional_day data"}
+
+    try:
+        cal = json.loads(calibration_file.read_text())
+
+        # Add/update mood history
+        if "mood_history" not in cal:
+            cal["mood_history"] = []
+
+        cal["mood_history"].append({
+            "date": synthesis.get("date", ""),
+            "score": emotional_day.get("mood_score", 0.5),
+            "arc": emotional_day.get("mood_arc", ""),
+            "triggers": emotional_day.get("recurring_triggers", {}),
+        })
+
+        # Keep last 30 days
+        cal["mood_history"] = cal["mood_history"][-30:]
+
+        # Apply calibration recommendation automatically
+        rec = emotional_day.get("calibration_recommendation")
+        if rec and rec != "null":
+            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": applied_changes if applied_changes else ["noted, no auto-applicable changes"],
+            })
+            cal["calibration_log"] = cal["calibration_log"][-20:]
+
+        calibration_file.write_text(json.dumps(cal, indent=2, ensure_ascii=False))
+        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 personal Skill v2 definition and sync it into SQLite."""
+    try:
+        from db import materialize_personal_skill_definition
+
+        skill_id = skill_data.get("id", "")
+        if not skill_id:
+            # Content fingerprint, not security-sensitive.
+            skill_id = "SK-DS-" + hashlib.md5(
+                skill_data.get("name", "").encode(), usedforsecurity=False
+            ).hexdigest()[:8].upper()
+
+        execution_level = skill_data.get("execution_level", "")
+        scriptable = bool(skill_data.get("scriptable"))
+        mode = skill_data.get("mode", "")
+        if not mode:
+            if scriptable and execution_level == "read-only":
+                mode = "hybrid"
+            else:
+                mode = "guide"
+
+        approval_required = bool(skill_data.get("approval_required", execution_level in {"local", "remote"}))
+        script_body = str(skill_data.get("script_body", "") or "")
+        executable_entry = str(skill_data.get("executable_entry", "") or "")
+
+        result = materialize_personal_skill_definition(
+            {
+                "id": skill_id,
+                "name": skill_data.get("name", ""),
+                "description": skill_data.get("description", ""),
+                "level": skill_data.get("level", "draft"),
+                "mode": mode,
+                "execution_level": execution_level if mode != "guide" else "none",
+                "approval_required": approval_required,
+                "tags": skill_data.get("tags", []),
+                "trigger_patterns": skill_data.get("trigger_patterns", []),
+                "source_sessions": skill_data.get("source_sessions", []),
+                "steps": skill_data.get("steps", []),
+                "gotchas": skill_data.get("gotchas", []),
+                "params_schema": skill_data.get("params_schema", skill_data.get("candidate_params", {})),
+                "command_template": skill_data.get("command_template", {}),
+                "executable_entry": executable_entry,
+                "script_body": script_body,
+                "content": skill_data.get("content", ""),
+            }
+        )
+        if "error" in result:
+            return {"success": False, "error": result["error"], "id": skill_id}
+        return {"success": True, "id": result["id"], "name": result.get("name", "")}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def create_abandoned_followups(synthesis: dict) -> list[dict]:
+    """Create followups for truly abandoned projects."""
+    results = []
+    abandoned = synthesis.get("abandoned_projects", [])
+    for proj in abandoned:
+        if proj.get("has_followup"):
+            continue
+        rec = proj.get("recommendation", "")
+        if "ignore" in rec.lower():
+            continue
+        result = create_followup(
+            description=f"[Abandoned] {proj.get('description', '')}",
+            date="",  # No date — it's a discovered gap
+            reasoning_note="Deep Sleep marked this as abandoned. Keep it as archived history, not active work.",
+            status="archived",
+        )
+        results.append(result)
+    return results
+
+
+def _safe_query(db_path: Path, query: str, params: tuple = ()) -> list[dict]:
+    if not db_path.exists():
+        return []
+    try:
+        conn = sqlite3.connect(str(db_path))
+        conn.row_factory = sqlite3.Row
+        rows = conn.execute(query, params).fetchall()
+        conn.close()
+        return [dict(row) for row in rows]
+    except Exception:
+        return []
+
+
+def _parse_any_datetime(value) -> datetime | None:
+    if value in (None, ""):
+        return None
+    try:
+        if isinstance(value, (int, float)) or (isinstance(value, str) and str(value).strip().isdigit()):
+            return datetime.fromtimestamp(float(value))
+    except Exception:
+        return None
+    raw = str(value).strip()
+    for fmt in ("%Y-%m-%d", "%Y-%m-%d %H:%M:%S"):
+        try:
+            return datetime.strptime(raw[:19], fmt)
+        except Exception:
+            continue
+    try:
+        dt = datetime.fromisoformat(raw.replace("Z", "+00:00"))
+        return dt.replace(tzinfo=None)
+    except Exception:
+        return None
+
+
+def _load_project_aliases() -> dict[str, set[str]]:
+    atlas_path = NEXO_HOME / "brain" / "project-atlas.json"
+    if not atlas_path.is_file():
+        return {}
+    try:
+        payload = json.loads(atlas_path.read_text())
+    except Exception:
+        return {}
+    if not isinstance(payload, dict):
+        return {}
+    aliases: dict[str, set[str]] = {}
+    for key, value in payload.items():
+        if str(key).startswith("_"):
+            continue
+        canonical = str(key).strip().lower()
+        alias_set = {canonical, canonical.replace("-", " "), canonical.replace("_", " ")}
+        if isinstance(value, dict):
+            for alias in value.get("aliases", []) or []:
+                alias_value = str(alias or "").strip().lower()
+                if alias_value:
+                    alias_set.add(alias_value)
+                    alias_set.add(alias_value.replace("-", " "))
+        aliases[canonical] = {item for item in alias_set if item}
+    return aliases
+
+
+def _match_projects(text: str, alias_map: dict[str, set[str]]) -> set[str]:
+    haystack = str(text or "").strip().lower()
+    if not haystack:
+        return set()
+    matches: set[str] = set()
+    for canonical, aliases in alias_map.items():
+        for alias in sorted(aliases, key=len, reverse=True):
+            if alias and alias in haystack:
+                matches.add(canonical)
+                break
+    return matches
+
+
+def _priority_weight(value) -> float:
+    lowered = str(value or "").strip().lower()
+    if lowered in {"critical", "urgent"}:
+        return 4.0
+    if lowered == "high":
+        return 3.0
+    if lowered == "medium":
+        return 2.0
+    if lowered == "low":
+        return 1.0
+    return 1.5
+
+
+def _project_weighting_window(target_date: str, *, window_days: int) -> list[dict]:
+    target_day = datetime.strptime(target_date, "%Y-%m-%d")
+    window_start = target_day - timedelta(days=max(0, window_days - 1))
+    alias_map = _load_project_aliases()
+    scoreboard: dict[str, dict] = {}
+
+    def normalize_project(project: str) -> str:
+        lowered = str(project or "").strip().lower()
+        if not lowered:
+            return ""
+        matched = _match_projects(lowered, alias_map)
+        if matched:
+            return sorted(matched)[0]
+        return lowered
+
+    def bump(project: str, score: float, signal_key: str, reason: str) -> None:
+        canonical = normalize_project(project)
+        if not canonical:
+            return
+        slot = scoreboard.setdefault(
+            canonical,
+            {
+                "project": canonical,
+                "score": 0.0,
+                "signals": {
+                    "diary_sessions": 0,
+                    "learnings": 0,
+                    "followups": 0,
+                    "decisions": 0,
+                },
+                "reasons": [],
+            },
+        )
+        slot["score"] += score
+        slot["signals"][signal_key] += 1
+        if reason and reason not in slot["reasons"]:
+            slot["reasons"].append(reason)
+
+    diary_rows = _safe_query(
+        NEXO_DB,
+        "SELECT created_at, summary, self_critique, domain FROM session_diary ORDER BY created_at DESC",
+    )
+    for row in diary_rows:
+        created = _parse_any_datetime(row.get("created_at"))
+        if not created or created < window_start or created > target_day + timedelta(days=1):
+            continue
+        recency_bonus = 1.4 if (target_day - created).days <= 7 else 1.0
+        matched = _match_projects(
+            " ".join(
+                [
+                    str(row.get("summary", "") or ""),
+                    str(row.get("self_critique", "") or ""),
+                ]
+            ),
+            alias_map,
+        )
+        domain = normalize_project(str(row.get("domain", "") or ""))
+        if domain:
+            matched.add(domain)
+        for project in matched:
+            bump(project, 3.0 * recency_bonus, "diary_sessions", "recent diary activity")
+
+    learning_rows = _safe_query(
+        NEXO_DB,
+        "SELECT title, content, applies_to, priority, weight, updated_at, created_at FROM learnings "
+        "ORDER BY COALESCE(updated_at, created_at) DESC LIMIT 180",
+    )
+    for row in learning_rows:
+        when = _parse_any_datetime(row.get("updated_at") or row.get("created_at"))
+        if when and when < window_start:
+            continue
+        matched = _match_projects(
+            " ".join(
+                [
+                    str(row.get("applies_to", "") or ""),
+                    str(row.get("title", "") or ""),
+                    str(row.get("content", "") or ""),
+                ]
+            ),
+            alias_map,
+        )
+        if not matched:
+            continue
+        score = 1.0 + _priority_weight(row.get("priority")) + min(2.0, max(0.0, float(row.get("weight", 0) or 0)))
+        for project in matched:
+            bump(project, score, "learnings", "recent leverage-bearing learning")
+
+    followup_rows = _safe_query(
+        NEXO_DB,
+        "SELECT description, date, status, priority, created_at, updated_at, reasoning, impact_score FROM followups "
+        "WHERE status NOT IN ('COMPLETED', 'CANCELLED') ORDER BY date ASC, created_at ASC LIMIT 160",
+    )
+    for row in followup_rows:
+        matched = _match_projects(
+            " ".join(
+                [
+                    str(row.get("description", "") or ""),
+                    str(row.get("reasoning", "") or ""),
+                ]
+            ),
+            alias_map,
+        )
+        if not matched:
+            continue
+        overdue_bonus = 0.0
+        due_dt = _parse_any_datetime(row.get("date"))
+        if due_dt and due_dt <= target_day:
+            overdue_bonus = 1.5
+        impact_bonus = min(4.0, max(0.0, float(row.get("impact_score", 0) or 0)) / 25.0)
+        score = 1.5 + _priority_weight(row.get("priority")) + overdue_bonus + impact_bonus
+        for project in matched:
+            bump(project, score, "followups", "open followup pressure")
+
+    decision_rows = _safe_query(
+        NEXO_DB,
+        "SELECT domain, outcome, status, reasoning, created_at, review_due_at FROM decisions "
+        "ORDER BY COALESCE(created_at, review_due_at) DESC LIMIT 160",
+    )
+    for row in decision_rows:
+        when = _parse_any_datetime(row.get("created_at") or row.get("review_due_at"))
+        if when and when < window_start:
+            continue
+        matched = _match_projects(
+            " ".join(
+                [
+                    str(row.get("reasoning", "") or ""),
+                    str(row.get("outcome", "") or ""),
+                    str(row.get("status", "") or ""),
+                ]
+            ),
+            alias_map,
+        )
+        domain = normalize_project(str(row.get("domain", "") or ""))
+        if domain:
+            matched.add(domain)
+        if not matched:
+            continue
+        outcome = str(row.get("outcome", "") or "").lower()
+        status = str(row.get("status", "") or "").lower()
+        score = 2.5
+        if any(token in outcome for token in ("fail", "error", "blocked", "regression")):
+            score += 2.0
+        if status in {"pending", "blocked", "open"}:
+            score += 1.5
+        for project in matched:
+            bump(project, score, "decisions", "recent decision pressure")
+
+    ranked = sorted(scoreboard.values(), key=lambda item: item["score"], reverse=True)
+    for item in ranked:
+        item["score"] = round(item["score"], 2)
+        item["reasons"] = item["reasons"][:4]
+    return ranked[:8]
+
+
+def _load_period_syntheses(target_date: str, *, window_days: int) -> list[dict]:
+    target_day = datetime.strptime(target_date, "%Y-%m-%d")
+    syntheses: list[dict] = []
+    for offset in range(window_days):
+        date_str = (target_day - timedelta(days=offset)).strftime("%Y-%m-%d")
+        path = DEEP_SLEEP_DIR / f"{date_str}-synthesis.json"
+        if not path.is_file():
+            continue
+        try:
+            payload = json.loads(path.read_text())
+        except Exception:
+            continue
+        if isinstance(payload, dict):
+            syntheses.append(payload)
+    syntheses.reverse()
+    return syntheses
+
+
+def _load_period_extractions(target_date: str, *, window_days: int) -> list[dict]:
+    target_day = datetime.strptime(target_date, "%Y-%m-%d")
+    payloads: list[dict] = []
+    for offset in range(window_days):
+        date_str = (target_day - timedelta(days=offset)).strftime("%Y-%m-%d")
+        path = DEEP_SLEEP_DIR / f"{date_str}-extractions.json"
+        if not path.is_file():
+            continue
+        try:
+            payload = json.loads(path.read_text())
+        except Exception:
+            continue
+        if isinstance(payload, dict):
+            payloads.append(payload)
+    payloads.reverse()
+    return payloads
+
+
+def _load_period_applied_logs(target_date: str, *, window_days: int) -> list[dict]:
+    target_day = datetime.strptime(target_date, "%Y-%m-%d")
+    payloads: list[dict] = []
+    for offset in range(window_days):
+        date_str = (target_day - timedelta(days=offset)).strftime("%Y-%m-%d")
+        path = DEEP_SLEEP_DIR / f"{date_str}-applied.json"
+        if not path.is_file():
+            continue
+        try:
+            payload = json.loads(path.read_text())
+        except Exception:
+            continue
+        if isinstance(payload, dict):
+            payloads.append(payload)
+    payloads.reverse()
+    return payloads
+
+
+def _safe_pct(numerator: float, denominator: float) -> float | None:
+    if denominator <= 0:
+        return None
+    return round((numerator / denominator) * 100.0, 1)
+
+
+def _aggregate_protocol_summary(extractions: list[dict]) -> dict:
+    totals = {
+        "sessions": 0,
+        "guard_check": {"required": 0, "executed": 0},
+        "heartbeat": {"total": 0, "with_context": 0},
+        "change_log": {"edits": 0, "logged": 0},
+    }
+
+    for payload in extractions:
+        for item in payload.get("extractions", []) or []:
+            if not isinstance(item, dict) or item.get("error"):
+                continue
+            totals["sessions"] += 1
+            protocol_summary = item.get("protocol_summary") or {}
+            for key in ("guard_check", "heartbeat", "change_log"):
+                current = protocol_summary.get(key) or {}
+                if key == "guard_check":
+                    totals[key]["required"] += int(current.get("required", 0) or 0)
+                    totals[key]["executed"] += int(current.get("executed", 0) or 0)
+                elif key == "heartbeat":
+                    totals[key]["total"] += int(current.get("total", 0) or 0)
+                    totals[key]["with_context"] += int(current.get("with_context", 0) or 0)
+                else:
+                    totals[key]["edits"] += int(current.get("edits", 0) or 0)
+                    totals[key]["logged"] += int(current.get("logged", 0) or 0)
+
+    guard_pct = _safe_pct(totals["guard_check"]["executed"], totals["guard_check"]["required"])
+    heartbeat_pct = _safe_pct(totals["heartbeat"]["with_context"], totals["heartbeat"]["total"])
+    change_pct = _safe_pct(totals["change_log"]["logged"], totals["change_log"]["edits"])
+    available = [value for value in (guard_pct, heartbeat_pct, change_pct) if value is not None]
+
+    totals["guard_check"]["compliance_pct"] = guard_pct
+    totals["heartbeat"]["compliance_pct"] = heartbeat_pct
+    totals["change_log"]["compliance_pct"] = change_pct
+    totals["overall_compliance_pct"] = round(sum(available) / len(available), 1) if available else None
+    return totals
+
+
+def _aggregate_delivery_metrics(applied_logs: list[dict]) -> dict:
+    totals = {
+        "runs": len(applied_logs),
+        "applied_actions": 0,
+        "deferred_actions": 0,
+        "skipped_dedupe": 0,
+        "errors": 0,
+        "engineering_followups": 0,
+        "followup_dedupe_matches": 0,
+        "learning_reinforcements": 0,
+        "learning_duplicate_skips": 0,
+        "learning_contradiction_reviews": 0,
+    }
+    for payload in applied_logs:
+        stats = payload.get("stats") or {}
+        totals["applied_actions"] += int(stats.get("applied", 0) or 0)
+        totals["deferred_actions"] += int(stats.get("deferred", 0) or 0)
+        totals["skipped_dedupe"] += int(stats.get("skipped_dedupe", 0) or 0)
+        totals["errors"] += int(stats.get("errors", 0) or 0)
+        for action in payload.get("applied_actions", []) or []:
+            details = action.get("details") or {}
+            if action.get("action_type") == "followup_create":
+                description = str(details.get("description", "") or "") + " " + str(details.get("reasoning", "") or "")
+                if "engineering" in description.lower() or "guardrail" in description.lower():
+                    totals["engineering_followups"] += 1
+                if details.get("outcome") == "matched_existing_followup":
+                    totals["followup_dedupe_matches"] += 1
+            elif action.get("action_type") == "learning_add":
+                outcome = str(details.get("outcome", "") or "")
+                if outcome == "reinforced_learning":
+                    totals["learning_reinforcements"] += 1
+                elif outcome == "duplicate_learning":
+                    totals["learning_duplicate_skips"] += 1
+                elif outcome == "contradiction_review":
+                    totals["learning_contradiction_reviews"] += 1
+
+    attempted = totals["applied_actions"] + totals["deferred_actions"] + totals["skipped_dedupe"] + totals["errors"]
+    totals["dedupe_rate_pct"] = _safe_pct(totals["skipped_dedupe"], attempted)
+    totals["error_rate_pct"] = _safe_pct(totals["errors"], attempted)
+    return totals
+
+
+def _semantic_duplicate_metrics(items: list[tuple[str, str]], *, threshold: float = 0.82) -> dict:
+    filtered = [(item_id, _normalize_text(text)) for item_id, text in items if _normalize_text(text)]
+    if len(filtered) < 2:
+        return {
+            "cluster_count": 0,
+            "duplicate_items": 0,
+            "duplicate_excess": 0,
+            "sample_clusters": [],
+        }
+
+    used: set[int] = set()
+    clusters: list[list[tuple[str, str]]] = []
+    for index, (item_id, text) in enumerate(filtered):
+        if index in used:
+            continue
+        cluster = [(item_id, text)]
+        for other_index in range(index + 1, len(filtered)):
+            if other_index in used:
+                continue
+            other_id, other_text = filtered[other_index]
+            if _text_similarity(text, other_text) >= threshold:
+                cluster.append((other_id, other_text))
+                used.add(other_index)
+        if len(cluster) > 1:
+            used.add(index)
+            clusters.append(cluster)
+
+    return {
+        "cluster_count": len(clusters),
+        "duplicate_items": sum(len(cluster) for cluster in clusters),
+        "duplicate_excess": sum(max(0, len(cluster) - 1) for cluster in clusters),
+        "sample_clusters": [
+            [item_id for item_id, _ in cluster[:4]]
+            for cluster in clusters[:5]
+        ],
+    }
+
+
+def _followup_deduplication_metrics() -> dict:
+    cols = _table_columns(NEXO_DB, "followups")
+    if "description" not in cols:
+        return {
+            "open_followups": 0,
+            "duplicate_clusters": 0,
+            "duplicate_open_followups": 0,
+            "duplicate_rate_pct": None,
+            "sample_clusters": [],
+        }
+
+    select_cols = ["description"]
+    if "id" in cols:
+        select_cols.append("id")
+    if "status" in cols:
+        select_cols.append("status")
+
+    conn = sqlite3.connect(str(NEXO_DB))
+    conn.row_factory = sqlite3.Row
+    rows = [dict(row) for row in conn.execute(f"SELECT {', '.join(select_cols)} FROM followups").fetchall()]
+    conn.close()
+
+    open_rows = []
+    for row in rows:
+        status = str(row.get("status", "pending") or "pending").strip().lower()
+        if status in {"done", "completed", "cancelled", "resolved"}:
+            continue
+        identifier = str(row.get("id") or row.get("description") or f"followup-{len(open_rows)+1}")
+        open_rows.append((identifier, str(row.get("description", "") or "")))
+
+    duplicates = _semantic_duplicate_metrics(open_rows)
+    return {
+        "open_followups": len(open_rows),
+        "duplicate_clusters": duplicates["cluster_count"],
+        "duplicate_open_followups": duplicates["duplicate_excess"],
+        "duplicate_rate_pct": _safe_pct(duplicates["duplicate_excess"], len(open_rows)),
+        "sample_clusters": duplicates["sample_clusters"],
+    }
+
+
+def _learning_consolidation_metrics() -> dict:
+    cols = _table_columns(NEXO_DB, "learnings")
+    if not {"title", "content"}.issubset(cols):
+        return {
+            "active_learnings": 0,
+            "weak_active_learnings": 0,
+            "duplicate_clusters": 0,
+            "duplicate_active_learnings": 0,
+            "noise_pressure": 0,
+            "noise_rate_pct": None,
+            "sample_clusters": [],
+        }
+
+    select_cols = ["title", "content"]
+    if "id" in cols:
+        select_cols.append("id")
+    for field in ("status", "weight", "reasoning", "prevention", "applies_to", "guard_hits"):
+        if field in cols:
+            select_cols.append(field)
+
+    conn = sqlite3.connect(str(NEXO_DB))
+    conn.row_factory = sqlite3.Row
+    rows = [dict(row) for row in conn.execute(f"SELECT {', '.join(select_cols)} FROM learnings").fetchall()]
+    conn.close()
+
+    active_rows = []
+    weak_active = 0
+    for row in rows:
+        status = str(row.get("status", "active") or "active").strip().lower()
+        if status != "active":
+            continue
+        active_rows.append(row)
+        weight = row.get("weight")
+        reasoning = str(row.get("reasoning", "") or "").strip()
+        prevention = str(row.get("prevention", "") or "").strip()
+        guard_hits = int(row.get("guard_hits", 0) or 0)
+        applies_to = str(row.get("applies_to", "") or "").strip()
+        if isinstance(weight, (int, float)) and float(weight) < 1.0:
+            weak_active += 1
+        elif not reasoning and not prevention:
+            weak_active += 1
+        elif applies_to and guard_hits <= 0:
+            weak_active += 1
+
+    duplicates = _semantic_duplicate_metrics(
+        [
+            (str(row.get("id") or f"learning-{index}"), f"{row.get('title', '')} {row.get('content', '')}")
+            for index, row in enumerate(active_rows, 1)
+        ],
+        threshold=0.8,
+    )
+    noise_pressure = weak_active + duplicates["duplicate_excess"]
+    return {
+        "active_learnings": len(active_rows),
+        "weak_active_learnings": weak_active,
+        "duplicate_clusters": duplicates["cluster_count"],
+        "duplicate_active_learnings": duplicates["duplicate_excess"],
+        "noise_pressure": noise_pressure,
+        "noise_rate_pct": _safe_pct(noise_pressure, len(active_rows)),
+        "sample_clusters": duplicates["sample_clusters"],
+    }
+
+
+def _load_previous_period_summary(kind: str, label: str) -> dict | None:
+    pattern = f"*-{kind}-summary.json"
+    candidates: list[tuple[str, Path]] = []
+    for path in DEEP_SLEEP_DIR.glob(pattern):
+        try:
+            payload = json.loads(path.read_text())
+        except Exception:
+            continue
+        candidate_label = str(payload.get("label", "") or "")
+        if candidate_label and candidate_label < label:
+            candidates.append((candidate_label, path))
+    if not candidates:
+        return None
+    _, path = sorted(candidates, key=lambda item: item[0])[-1]
+    try:
+        payload = json.loads(path.read_text())
+    except Exception:
+        return None
+    return payload if isinstance(payload, dict) else None
+
+
+def _build_project_pulse(top_projects: list[dict], previous_summary: dict | None) -> list[dict]:
+    previous_scores: dict[str, float] = {}
+    if previous_summary:
+        for item in previous_summary.get("project_pulse", []) or previous_summary.get("top_projects", []) or []:
+            project = str(item.get("project", "") or "")
+            if project:
+                previous_scores[project] = float(item.get("score", 0) or 0)
+
+    pulse: list[dict] = []
+    for item in top_projects:
+        project = str(item.get("project", "") or "")
+        score = float(item.get("score", 0) or 0)
+        previous_score = previous_scores.get(project, 0.0)
+        delta = round(score - previous_score, 2)
+        if score >= 18:
+            status = "critical"
+        elif score >= 10:
+            status = "elevated"
+        else:
+            status = "watch"
+        if delta >= 2.0:
+            trend = "rising"
+        elif delta <= -2.0:
+            trend = "cooling"
+        else:
+            trend = "steady"
+        pulse.append(
+            {
+                "project": project,
+                "score": round(score, 2),
+                "delta_vs_previous": delta,
+                "trend": trend,
+                "status": status,
+                "signals": item.get("signals", {}),
+                "reasons": item.get("reasons", []),
+            }
+        )
+    return pulse
+
+
+def _build_period_trend(summary: dict, previous_summary: dict | None) -> dict:
+    if not previous_summary:
+        return {
+            "has_previous": False,
+            "avg_mood_delta": None,
+            "avg_trust_delta": None,
+            "total_corrections_delta": None,
+            "protocol_compliance_delta": None,
+            "followup_duplicate_open_delta": None,
+            "followup_duplicate_rate_delta": None,
+            "learning_noise_delta": None,
+            "learning_noise_rate_delta": None,
+        }
+
+    current_protocol = summary.get("protocol_summary", {}).get("overall_compliance_pct")
+    previous_protocol = (previous_summary.get("protocol_summary") or {}).get("overall_compliance_pct")
+    current_mood = summary.get("avg_mood_score")
+    previous_mood = previous_summary.get("avg_mood_score")
+    current_trust = summary.get("avg_trust_score")
+    previous_trust = previous_summary.get("avg_trust_score")
+    current_followup = (summary.get("followup_deduplication") or {}).get("duplicate_open_followups")
+    previous_followup = (previous_summary.get("followup_deduplication") or {}).get("duplicate_open_followups")
+    current_followup_rate = (summary.get("followup_deduplication") or {}).get("duplicate_rate_pct")
+    previous_followup_rate = (previous_summary.get("followup_deduplication") or {}).get("duplicate_rate_pct")
+    current_learning_noise = (summary.get("learning_consolidation") or {}).get("noise_pressure")
+    previous_learning_noise = (previous_summary.get("learning_consolidation") or {}).get("noise_pressure")
+    current_learning_rate = (summary.get("learning_consolidation") or {}).get("noise_rate_pct")
+    previous_learning_rate = (previous_summary.get("learning_consolidation") or {}).get("noise_rate_pct")
+
+    return {
+        "has_previous": True,
+        "avg_mood_delta": round(current_mood - previous_mood, 3) if isinstance(current_mood, (int, float)) and isinstance(previous_mood, (int, float)) else None,
+        "avg_trust_delta": round(current_trust - previous_trust, 1) if isinstance(current_trust, (int, float)) and isinstance(previous_trust, (int, float)) else None,
+        "total_corrections_delta": int(summary.get("total_corrections", 0) or 0) - int(previous_summary.get("total_corrections", 0) or 0),
+        "protocol_compliance_delta": round(current_protocol - previous_protocol, 1) if isinstance(current_protocol, (int, float)) and isinstance(previous_protocol, (int, float)) else None,
+        "followup_duplicate_open_delta": int(current_followup or 0) - int(previous_followup or 0) if current_followup is not None or previous_followup is not None else None,
+        "followup_duplicate_rate_delta": round(float(current_followup_rate) - float(previous_followup_rate), 1) if isinstance(current_followup_rate, (int, float)) and isinstance(previous_followup_rate, (int, float)) else None,
+        "learning_noise_delta": int(current_learning_noise or 0) - int(previous_learning_noise or 0) if current_learning_noise is not None or previous_learning_noise is not None else None,
+        "learning_noise_rate_delta": round(float(current_learning_rate) - float(previous_learning_rate), 1) if isinstance(current_learning_rate, (int, float)) and isinstance(previous_learning_rate, (int, float)) else None,
+    }
+
+
+def _build_period_summary(target_date: str, synthesis: dict, *, kind: str, window_days: int) -> dict:
+    target_day = datetime.strptime(target_date, "%Y-%m-%d")
+    window_start = (target_day - timedelta(days=max(0, window_days - 1))).strftime("%Y-%m-%d")
+    label = (
+        f"{target_day.isocalendar().year}-W{target_day.isocalendar().week:02d}"
+        if kind == "weekly"
+        else target_day.strftime("%Y-%m")
+    )
+    syntheses = _load_period_syntheses(target_date, window_days=window_days)
+    extractions = _load_period_extractions(target_date, window_days=window_days)
+    applied_logs = _load_period_applied_logs(target_date, window_days=window_days)
+    if not any(item.get("date") == target_date for item in syntheses):
+        syntheses.append(synthesis)
+
+    mood_scores = []
+    trust_scores = []
+    total_corrections = 0
+    pattern_counter: Counter[str] = Counter()
+    agenda_counter: Counter[str] = Counter()
+    for item in syntheses:
+        mood = item.get("emotional_day", {}).get("mood_score")
+        if isinstance(mood, (int, float)):
+            mood_scores.append(float(mood))
+        trust = item.get("trust_calibration", {}).get("score")
+        if isinstance(trust, (int, float)):
+            trust_scores.append(float(trust))
+        total_corrections += int(item.get("productivity_day", {}).get("total_corrections", 0) or 0)
+        for pattern in item.get("cross_session_patterns", []) or []:
+            text = str(pattern.get("pattern", "") or "").strip()
+            if text:
+                pattern_counter[text] += 1
+        for agenda in item.get("morning_agenda", []) or []:
+            title = str(agenda.get("title", "") or "").strip()
+            if title:
+                agenda_counter[title] += 1
+
+    top_projects = _project_weighting_window(target_date, window_days=window_days)
+    avg_mood = round(sum(mood_scores) / len(mood_scores), 3) if mood_scores else None
+    avg_trust = round(sum(trust_scores) / len(trust_scores), 1) if trust_scores else None
+    top_patterns = [
+        {"pattern": pattern, "count": count}
+        for pattern, count in pattern_counter.most_common(6)
+    ]
+    recurring_agenda = [
+        {"title": title, "count": count}
+        for title, count in agenda_counter.most_common(6)
+    ]
+    protocol_summary = _aggregate_protocol_summary(extractions)
+    delivery_metrics = _aggregate_delivery_metrics(applied_logs)
+    followup_deduplication = _followup_deduplication_metrics()
+    learning_consolidation = _learning_consolidation_metrics()
+    previous_summary = _load_previous_period_summary(kind, label)
+    project_pulse = _build_project_pulse(top_projects, previous_summary)
+
+    summary_parts = [f"{len(syntheses)} Deep Sleep run(s)"]
+    if top_projects:
+        summary_parts.append(f"top focus: {top_projects[0]['project']}")
+    if top_patterns:
+        summary_parts.append(f"recurring pattern: {top_patterns[0]['pattern']}")
+    if avg_trust is not None:
+        summary_parts.append(f"avg trust {avg_trust:.1f}")
+    if protocol_summary.get("overall_compliance_pct") is not None:
+        summary_parts.append(f"protocol {protocol_summary['overall_compliance_pct']:.1f}%")
+    summary = " | ".join(summary_parts)
+
+    period_summary = {
+        "kind": kind,
+        "label": label,
+        "window_days": window_days,
+        "window_start": window_start,
+        "window_end": target_date,
+        "generated_at": datetime.now().isoformat(),
+        "daily_syntheses": len(syntheses),
+        "avg_mood_score": avg_mood,
+        "avg_trust_score": avg_trust,
+        "total_corrections": total_corrections,
+        "top_projects": top_projects,
+        "project_pulse": project_pulse,
+        "top_patterns": top_patterns,
+        "recurring_agenda": recurring_agenda,
+        "protocol_summary": protocol_summary,
+        "delivery_metrics": delivery_metrics,
+        "followup_deduplication": followup_deduplication,
+        "learning_consolidation": learning_consolidation,
+        "summary": summary,
+    }
+    period_summary["trend"] = _build_period_trend(period_summary, previous_summary)
+    return period_summary
+
+def _render_period_summary_markdown(summary: dict) -> str:
+    lines = [
+        f"# {summary.get('kind', 'period').title()} Deep Sleep Summary — {summary.get('label', '')}",
+        "",
+        f"- Window: {summary.get('window_start', '')} -> {summary.get('window_end', '')}",
+        f"- Deep Sleep runs: {summary.get('daily_syntheses', 0)}",
+    ]
+    if summary.get("avg_mood_score") is not None:
+        lines.append(f"- Avg mood score: {summary['avg_mood_score']:.2f}")
+    if summary.get("avg_trust_score") is not None:
+        lines.append(f"- Avg trust score: {summary['avg_trust_score']:.1f}")
+    lines.append(f"- Total corrections: {summary.get('total_corrections', 0)}")
+    lines.append("")
+    if summary.get("summary"):
+        lines.append(f"> {summary['summary']}")
+        lines.append("")
+
+    protocol_summary = summary.get("protocol_summary") or {}
+    if protocol_summary:
+        lines.append("## Protocol Compliance")
+        lines.append("")
+        overall = protocol_summary.get("overall_compliance_pct")
+        if overall is not None:
+            lines.append(f"- Overall compliance: {overall:.1f}%")
+        guard = protocol_summary.get("guard_check", {})
+        heartbeat = protocol_summary.get("heartbeat", {})
+        change_log = protocol_summary.get("change_log", {})
+        if guard:
+            lines.append(
+                f"- guard_check: {guard.get('executed', 0)}/{guard.get('required', 0)}"
+                + (f" ({guard['compliance_pct']:.1f}%)" if guard.get("compliance_pct") is not None else "")
+            )
+        if heartbeat:
+            lines.append(
+                f"- heartbeat with context: {heartbeat.get('with_context', 0)}/{heartbeat.get('total', 0)}"
+                + (f" ({heartbeat['compliance_pct']:.1f}%)" if heartbeat.get("compliance_pct") is not None else "")
+            )
+        if change_log:
+            lines.append(
+                f"- change_log after edits: {change_log.get('logged', 0)}/{change_log.get('edits', 0)}"
+                + (f" ({change_log['compliance_pct']:.1f}%)" if change_log.get("compliance_pct") is not None else "")
+            )
+        lines.append("")
+
+    delivery_metrics = summary.get("delivery_metrics") or {}
+    if delivery_metrics:
+        lines.append("## Loop Output")
+        lines.append("")
+        lines.append(f"- Applied actions: {delivery_metrics.get('applied_actions', 0)}")
+        lines.append(f"- Deferred actions: {delivery_metrics.get('deferred_actions', 0)}")
+        lines.append(f"- Dedupe skips: {delivery_metrics.get('skipped_dedupe', 0)}")
+        lines.append(f"- Engineering followups: {delivery_metrics.get('engineering_followups', 0)}")
+        if delivery_metrics.get("dedupe_rate_pct") is not None:
+            lines.append(f"- Dedupe rate: {delivery_metrics['dedupe_rate_pct']:.1f}%")
+        if delivery_metrics.get("error_rate_pct") is not None:
+            lines.append(f"- Error rate: {delivery_metrics['error_rate_pct']:.1f}%")
+        lines.append(f"- Followup dedupe matches: {delivery_metrics.get('followup_dedupe_matches', 0)}")
+        lines.append(f"- Learning reinforcements: {delivery_metrics.get('learning_reinforcements', 0)}")
+        lines.append(f"- Learning duplicate skips: {delivery_metrics.get('learning_duplicate_skips', 0)}")
+        lines.append(f"- Learning contradiction reviews: {delivery_metrics.get('learning_contradiction_reviews', 0)}")
+        lines.append("")
+
+    followup_deduplication = summary.get("followup_deduplication") or {}
+    learning_consolidation = summary.get("learning_consolidation") or {}
+    if followup_deduplication or learning_consolidation:
+        lines.append("## Prevention Quality")
+        lines.append("")
+        if followup_deduplication:
+            lines.append(f"- Open followups: {followup_deduplication.get('open_followups', 0)}")
+            lines.append(f"- Duplicate open followups: {followup_deduplication.get('duplicate_open_followups', 0)}")
+            if followup_deduplication.get("duplicate_rate_pct") is not None:
+                lines.append(f"- Duplicate followup rate: {followup_deduplication['duplicate_rate_pct']:.1f}%")
+        if learning_consolidation:
+            lines.append(f"- Active learnings: {learning_consolidation.get('active_learnings', 0)}")
+            lines.append(f"- Learning noise pressure: {learning_consolidation.get('noise_pressure', 0)}")
+            if learning_consolidation.get("noise_rate_pct") is not None:
+                lines.append(f"- Learning noise rate: {learning_consolidation['noise_rate_pct']:.1f}%")
+        lines.append("")
+
+    if summary.get("top_projects"):
+        lines.append("## Top Projects")
+        lines.append("")
+        for item in summary["top_projects"][:5]:
+            lines.append(f"- **{item['project']}** — score {item['score']}")
+            if item.get("reasons"):
+                lines.append(f"  Reasons: {', '.join(item['reasons'])}")
+        lines.append("")
+
+    if summary.get("project_pulse"):
+        lines.append("## Project Pulse")
+        lines.append("")
+        for item in summary["project_pulse"][:5]:
+            delta = item.get("delta_vs_previous")
+            delta_label = ""
+            if isinstance(delta, (int, float)):
+                delta_label = f" | Δ {delta:+.2f}"
+            lines.append(
+                f"- **{item['project']}** — {item.get('status', 'watch')} / {item.get('trend', 'steady')}"
+                f" | score {item.get('score', 0)}{delta_label}"
+            )
+        lines.append("")
+
+    if summary.get("top_patterns"):
+        lines.append("## Recurring Patterns")
+        lines.append("")
+        for item in summary["top_patterns"][:5]:
+            lines.append(f"- {item['pattern']} ({item['count']}x)")
+        lines.append("")
+
+    if summary.get("recurring_agenda"):
+        lines.append("## Recurring Agenda")
+        lines.append("")
+        for item in summary["recurring_agenda"][:5]:
+            lines.append(f"- {item['title']} ({item['count']}x)")
+        lines.append("")
+
+    trend = summary.get("trend") or {}
+    if trend.get("has_previous"):
+        lines.append("## Trend vs Previous")
+        lines.append("")
+        if trend.get("avg_mood_delta") is not None:
+            lines.append(f"- Mood delta: {trend['avg_mood_delta']:+.3f}")
+        if trend.get("avg_trust_delta") is not None:
+            lines.append(f"- Trust delta: {trend['avg_trust_delta']:+.1f}")
+        if trend.get("total_corrections_delta") is not None:
+            lines.append(f"- Corrections delta: {trend['total_corrections_delta']:+d}")
+        if trend.get("protocol_compliance_delta") is not None:
+            lines.append(f"- Protocol delta: {trend['protocol_compliance_delta']:+.1f}%")
+        if trend.get("followup_duplicate_open_delta") is not None:
+            lines.append(f"- Duplicate followups delta: {trend['followup_duplicate_open_delta']:+d}")
+        if trend.get("followup_duplicate_rate_delta") is not None:
+            lines.append(f"- Duplicate followup rate delta: {trend['followup_duplicate_rate_delta']:+.1f}%")
+        if trend.get("learning_noise_delta") is not None:
+            lines.append(f"- Learning noise delta: {trend['learning_noise_delta']:+d}")
+        if trend.get("learning_noise_rate_delta") is not None:
+            lines.append(f"- Learning noise rate delta: {trend['learning_noise_rate_delta']:+.1f}%")
+        lines.append("")
+
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def write_periodic_summaries(target_date: str, synthesis: dict) -> dict:
+    outputs: dict[str, str] = {}
+    for kind, window_days in (("weekly", 7), ("monthly", 30)):
+        summary = _build_period_summary(target_date, synthesis, kind=kind, window_days=window_days)
+        label = summary["label"]
+        json_path = DEEP_SLEEP_DIR / f"{label}-{kind}-summary.json"
+        md_path = DEEP_SLEEP_DIR / f"{label}-{kind}-summary.md"
+        json_path.write_text(json.dumps(summary, indent=2, ensure_ascii=False))
+        md_path.write_text(_render_period_summary_markdown(summary), encoding="utf-8")
+        outputs[f"{kind}_json"] = str(json_path)
+        outputs[f"{kind}_markdown"] = str(md_path)
+    return outputs
+
+
+def generate_session_tone(synthesis: dict, target_date: str) -> dict:
+    """Generate emotional tone guidance for next session startup.
+
+    This is the 'psychology' layer — tells NEXO how to behave emotionally
+    based on yesterday's analysis. Read by startup hook to adapt greeting.
+    """
+    emotional = synthesis.get("emotional_day", {})
+    productivity = synthesis.get("productivity_day", {})
+    patterns = synthesis.get("cross_session_patterns", [])
+    abandoned = synthesis.get("abandoned_projects", [])
+    mood_score = emotional.get("mood_score", 0.5)
+    corrections = productivity.get("total_corrections", 0)
+    proactivity = productivity.get("overall_proactivity", "mixed")
+
+    tone = {
+        "date": target_date,
+        "mood_yesterday": mood_score,
+        "approach": "neutral",
+        "opening_style": "normal",
+        "acknowledge_mistakes": False,
+        "mistakes_to_own": [],
+        "motivational": False,
+        "reduce_load": False,
+        "suggested_greeting_context": "",
+    }
+
+    # Agent made many mistakes yesterday → own it, apologize, show learning
+    if corrections > 5:
+        tone["acknowledge_mistakes"] = True
+        tone["opening_style"] = "humble"
+        # Collect what went wrong
+        high_patterns = [p["pattern"] for p in patterns if p.get("severity") == "high"]
+        tone["mistakes_to_own"] = high_patterns[:3]
+        tone["suggested_greeting_context"] = (
+            f"Yesterday the agent needed {corrections} corrections. "
+            f"Acknowledge specific mistakes, show what was learned, "
+            f"and demonstrate improvement from the first interaction."
+        )
+
+    # User had a bad day → supportive, less pressure
+    if mood_score < 0.4:
+        tone["approach"] = "supportive"
+        tone["motivational"] = True
+        tone["reduce_load"] = True
+        frustration_triggers = emotional.get("recurring_triggers", {}).get("frustration", [])
+        tone["suggested_greeting_context"] += (
+            f" User had a tough day (mood {mood_score:.0%}). "
+            f"Be supportive, acknowledge the difficulty, and propose a lighter start. "
+            f"Avoid these frustration triggers: {', '.join(frustration_triggers[:3])}."
+        )
+
+    # User had a great day → reinforce, push momentum
+    elif mood_score > 0.7:
+        tone["approach"] = "energetic"
+        tone["motivational"] = True
+        flow_triggers = emotional.get("recurring_triggers", {}).get("flow", [])
+        tone["suggested_greeting_context"] += (
+            f" User had a great day (mood {mood_score:.0%}). "
+            f"Reinforce the momentum. Reference yesterday's wins. "
+            f"Propose ambitious next steps. Flow triggers: {', '.join(flow_triggers[:3])}."
+        )
+
+    # Agent was too reactive → be proactive today
+    if proactivity == "reactive":
+        tone["approach"] = "proactive"
+        tone["suggested_greeting_context"] += (
+            " Agent was too reactive yesterday — today lead with proposals, "
+            "don't wait for instructions."
+        )
+
+    # There are abandoned projects → gently bring up
+    if abandoned:
+        truly_abandoned = [a for a in abandoned if not a.get("has_followup")]
+        if truly_abandoned:
+            tone["suggested_greeting_context"] += (
+                f" {len(truly_abandoned)} project(s) were started but not finished. "
+                f"Offer to pick them up today without pressure."
+            )
+
+    return tone
+
+
+def write_morning_briefing(target_date: str, synthesis: dict) -> Path:
+    """Write the morning briefing file from synthesis data."""
+    briefing_dir = OPERATIONS_DIR
+    briefing_dir.mkdir(parents=True, exist_ok=True)
+    briefing_file = briefing_dir / "morning-briefing.md"
+
+    # Generate session tone for startup
+    tone = generate_session_tone(synthesis, target_date)
+    tone_file = briefing_dir / "session-tone.json"
+    tone_file.write_text(json.dumps(tone, indent=2, ensure_ascii=False))
+
+    lines = [
+        f"# Morning Briefing -- {target_date}",
+        f"_Generated by Deep Sleep at {datetime.now().strftime('%H:%M')}_",
+        ""
+    ]
+
+    # Summary
+    summary = synthesis.get("summary", "")
+    if summary:
+        lines.append(f"> {summary}")
+        lines.append("")
+
+    # Morning agenda
+    agenda = synthesis.get("morning_agenda", [])
+    if agenda:
+        lines.append("## Agenda")
+        lines.append("")
+        for item in agenda:
+            priority = item.get("priority", "?")
+            title = item.get("title", "")
+            desc = item.get("description", "")
+            item_type = item.get("type", "")
+            lines.append(f"### {priority}. {title}")
+            if item_type:
+                lines.append(f"_Type: {item_type}_")
+            lines.append(desc)
+            if item.get("context"):
+                lines.append(f"\n> {item['context']}")
+            lines.append("")
+
+    top_impact = _top_followups_by_impact(limit=5)
+    if top_impact:
+        lines.append("## Top by Impact")
+        lines.append("")
+        for item in top_impact:
+            impact = float(item.get("impact_score") or 0.0)
+            due = item.get("date") or "—"
+            reason = item.get("impact_reasoning") or "impact score persisted without explicit reasoning"
+            lines.append(
+                f"- **{item.get('id', '?')}** [{impact:.1f}] {item.get('description', '')} "
+                f"(due {due}, priority {item.get('priority') or 'medium'})"
+            )
+            lines.append(f"  Why: {reason}")
+        lines.append("")
+
+    impact_summary = _read_impact_summary()
+    top_changes = [item for item in (impact_summary.get("top_changes") or []) if abs(float(item.get("delta") or 0.0)) >= 1.0]
+    if top_changes:
+        lines.append("## Impact Queue Changes")
+        lines.append("")
+        for item in top_changes[:5]:
+            delta = float(item.get("delta") or 0.0)
+            direction = "+" if delta >= 0 else ""
+            lines.append(
+                f"- **{item.get('id', '?')}** {direction}{delta:.1f} -> {float(item.get('impact_score') or 0.0):.1f} "
+                f"({item.get('impact_reasoning') or 'score recalculated'})"
+            )
+        lines.append("")
+
+    # Emotional day
+    emotional = synthesis.get("emotional_day", {})
+    if emotional:
+        mood_score = emotional.get("mood_score", 0.5)
+        mood_bar = "🟢" if mood_score >= 0.7 else "🟡" if mood_score >= 0.4 else "🔴"
+        lines.append(f"## Mood {mood_bar} {mood_score:.0%}")
+        lines.append("")
+        if emotional.get("mood_arc"):
+            lines.append(emotional["mood_arc"])
+        triggers = emotional.get("recurring_triggers", {})
+        if triggers.get("frustration"):
+            lines.append(f"**Frustration triggers:** {', '.join(triggers['frustration'])}")
+        if triggers.get("flow"):
+            lines.append(f"**Flow triggers:** {', '.join(triggers['flow'])}")
+        if emotional.get("calibration_recommendation"):
+            lines.append(f"\n💡 **Recommendation:** {emotional['calibration_recommendation']}")
+        lines.append("")
+
+    # Productivity
+    productivity = synthesis.get("productivity_day", {})
+    if productivity:
+        lines.append("## Productivity")
+        lines.append("")
+        lines.append(f"- Corrections needed: {productivity.get('total_corrections', '?')}")
+        lines.append(f"- Proactivity: {productivity.get('overall_proactivity', '?')}")
+        if productivity.get("tool_insights"):
+            lines.append(f"- Tools: {productivity['tool_insights']}")
+        inefficiencies = productivity.get("systemic_inefficiencies", [])
+        if inefficiencies:
+            lines.append(f"- Issues: {', '.join(inefficiencies)}")
+        lines.append("")
+
+    # Abandoned projects
+    abandoned = synthesis.get("abandoned_projects", [])
+    if abandoned:
+        truly_abandoned = [a for a in abandoned if not a.get("has_followup")]
+        if truly_abandoned:
+            lines.append("## Abandoned Projects")
+            lines.append("")
+            for a in truly_abandoned:
+                lines.append(f"- {a.get('description', '?')}")
+                if a.get("recommendation"):
+                    lines.append(f"  → {a['recommendation']}")
+            lines.append("")
+
+    # Cross-session patterns
+    patterns = synthesis.get("cross_session_patterns", [])
+    if patterns:
+        lines.append("## Patterns Detected")
+        lines.append("")
+        for p in patterns:
+            severity = p.get("severity", "")
+            lines.append(f"- **[{severity}]** {p.get('pattern', '')}")
+            sessions = p.get("sessions", [])
+            if sessions:
+                lines.append(f"  Sessions: {', '.join(sessions)}")
+        lines.append("")
+
+    # Draft actions (things that need user decision)
+    draft_actions = [
+        a for a in synthesis.get("actions", [])
+        if a.get("action_class") == "draft_for_morning"
+    ]
+    if draft_actions:
+        lines.append("## Items for Review")
+        lines.append("")
+        for a in draft_actions:
+            confidence = a.get("confidence", 0)
+            lines.append(f"- **{a.get('action_type', '')}** (confidence: {confidence:.0%})")
+            content = a.get("content", {})
+            if isinstance(content, dict):
+                title = content.get("title", content.get("description", ""))
+                lines.append(f"  {title}")
+            evidence = a.get("evidence", [])
+            if evidence and isinstance(evidence, list):
+                for ev in evidence[:2]:
+                    quote = ev.get("quote", "")
+                    if quote:
+                        lines.append(f'  > "{quote}"')
+        lines.append("")
+
+    # Context packets
+    packets = synthesis.get("context_packets", [])
+    if packets:
+        lines.append("## Context for Today's Work")
+        lines.append("")
+        for p in packets:
+            lines.append(f"### {p.get('topic', 'Unknown')}")
+            lines.append(f"**Last state:** {p.get('last_state', 'N/A')}")
+            files = p.get("key_files", [])
+            if files:
+                lines.append(f"**Files:** {', '.join(files)}")
+            questions = p.get("open_questions", [])
+            if questions:
+                lines.append("**Open questions:**")
+                for q in questions:
+                    lines.append(f"  - {q}")
+            lines.append("")
+
+    briefing_file.write_text("\n".join(lines), encoding="utf-8")
+    return briefing_file
+
+
+def apply_action(action: dict, run_id: str) -> dict:
+    """Apply a single action and return the result log."""
+    action_type = action.get("action_type", "")
+    action_class = action.get("action_class", "")
+    content = action.get("content", {})
+    dedupe_key = action.get("dedupe_key", "")
+
+    # Content fingerprint, not security-sensitive.
+    applied_id = f"{run_id}-{hashlib.md5(dedupe_key.encode(), usedforsecurity=False).hexdigest()[:8]}"
+
+    log_entry = {
+        "applied_action_id": applied_id,
+        "action_type": action_type,
+        "action_class": action_class,
+        "dedupe_key": dedupe_key,
+        "timestamp": datetime.now().isoformat(),
+        "status": "skipped",
+        "details": {}
+    }
+
+    # Only auto_apply actions get executed
+    if action_class != "auto_apply":
+        log_entry["status"] = "deferred_to_morning"
+        log_entry["details"] = {"reason": "action_class is not auto_apply"}
+        return log_entry
+
+    if not isinstance(content, dict):
+        log_entry["status"] = "error"
+        log_entry["details"] = {"error": "content is not a dict"}
+        return log_entry
+
+    if action_type == "learning_add":
+        result = add_learning(
+            category=content.get("category", "process"),
+            title=content.get("title", "Deep Sleep finding"),
+            content=content.get("content", content.get("description", ""))
+        )
+        log_entry["status"] = "applied" if result.get("success") else "error"
+        log_entry["details"] = result
+
+    elif action_type == "followup_create":
+        result = create_followup(
+            description=content.get("description", content.get("title", "")),
+            date=content.get("date", ""),
+            reasoning_note=content.get("reasoning", content.get("why", "")),
+        )
+        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"
+
+    elif action_type == "code_change":
+        # Closes Fase 2 item 5: deep sleep can now hand a concrete code
+        # change to the evolution apply pipeline. We do NOT touch any source
+        # file directly here — that would bypass the sandbox/snapshot/rollback
+        # safety net that lives in nexo-evolution-run.py:execute_auto_proposal.
+        # Instead we persist the proposal to evolution_log with status=accepted
+        # and a proposal_payload, so the next evolution cycle picks it up via
+        # _apply_accepted_proposals (added in Fase 2 item 1, m38).
+        result = apply_code_change_action(content, dedupe_key)
+        log_entry["status"] = "applied" if result.get("success") else "error"
+        log_entry["details"] = result
+
+    else:
+        log_entry["status"] = "unknown_type"
+        log_entry["details"] = {"error": f"Unknown action_type: {action_type}"}
+
+    return log_entry
+
+
+def apply_code_change_action(content: dict, dedupe_key: str) -> dict:
+    """Stage a code_change finding into evolution_log for the next cycle.
+
+    Required content keys:
+        dimension:  evolution dimension (reliability/safety/etc)
+        action:     short human-readable description of what to do
+        reasoning:  why deep sleep proposed this change
+        changes:    list of {file, operation, search?, content} entries
+                    matching nexo-evolution-run.py:apply_change semantics
+
+    Optional:
+        scope: 'local' | 'public' (default 'local')
+        classification: 'propose' | 'auto' (default 'propose')
+
+    Idempotent: if a row with the same dedupe_key already exists in
+    evolution_log (matched against proposal_payload extras.dedupe_key), the
+    function returns success without inserting a duplicate.
+
+    Returns: {success: bool, evolution_log_id: int|None, reason: str|None,
+              skipped_duplicate: bool}
+    """
+    if not isinstance(content, dict):
+        return {"success": False, "reason": "content must be a dict"}
+
+    dimension = (content.get("dimension") or "").strip()
+    action_text = (content.get("action") or content.get("title") or "").strip()
+    reasoning = (content.get("reasoning") or content.get("why") or "").strip()
+    changes = content.get("changes") or []
+    scope = (content.get("scope") or "local").strip() or "local"
+    classification = (content.get("classification") or "propose").strip() or "propose"
+
+    if not dimension:
+        return {"success": False, "reason": "missing dimension"}
+    if not action_text:
+        return {"success": False, "reason": "missing action"}
+    if not isinstance(changes, list) or not changes:
+        return {"success": False, "reason": "missing or empty changes array"}
+    for idx, change in enumerate(changes):
+        if not isinstance(change, dict):
+            return {"success": False, "reason": f"changes[{idx}] is not a dict"}
+        if not change.get("file"):
+            return {"success": False, "reason": f"changes[{idx}] missing file"}
+        if not change.get("operation"):
+            return {"success": False, "reason": f"changes[{idx}] missing operation"}
+
+    payload = {
+        "classification": classification,
+        "dimension": dimension,
+        "action": action_text,
+        "reasoning": reasoning,
+        "scope": scope,
+        "changes": changes,
+        "extras": {
+            "source": "deep_sleep",
+            "dedupe_key": dedupe_key,
+        },
+    }
+    payload_json = json.dumps(payload, ensure_ascii=False)
+
+    try:
+        conn = sqlite3.connect(str(NEXO_DB), timeout=10)
+    except Exception as e:
+        return {"success": False, "reason": f"cannot open nexo.db: {e}"}
+
+    try:
+        # Idempotency: skip if any prior row already staged this dedupe_key.
+        existing = conn.execute(
+            "SELECT id FROM evolution_log "
+            "WHERE proposal_payload IS NOT NULL "
+            "  AND proposal_payload LIKE ? "
+            "ORDER BY id DESC LIMIT 1",
+            (f'%"dedupe_key": "{dedupe_key}"%',),
+        ).fetchone()
+        if existing:
+            return {
+                "success": True,
+                "skipped_duplicate": True,
+                "evolution_log_id": int(existing[0]),
+                "reason": "already staged in evolution_log",
+            }
+
+        cur = conn.execute(
+            "INSERT INTO evolution_log "
+            "(cycle_number, dimension, proposal, classification, reasoning, status, proposal_payload) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?)",
+            (
+                0,  # cycle_number 0 = staged from outside the regular cycle
+                dimension,
+                action_text,
+                classification,
+                reasoning or "deep sleep proposed code change",
+                "accepted",
+                payload_json,
+            ),
+        )
+        try:
+            conn.commit()
+        except Exception:
+            pass
+        return {
+            "success": True,
+            "skipped_duplicate": False,
+            "evolution_log_id": int(cur.lastrowid),
+        }
+    except Exception as e:
+        return {"success": False, "reason": f"insert failed: {e}"}
+    finally:
+        try:
+            conn.close()
+        except Exception:
+            pass
+
+
+def main():
+    target_date = sys.argv[1] if len(sys.argv) > 1 else datetime.now().strftime("%Y-%m-%d")
+
+    synthesis_file = DEEP_SLEEP_DIR / f"{target_date}-synthesis.json"
+    if not synthesis_file.exists():
+        print(f"[apply] No synthesis file for {target_date}. Run synthesize.py first.")
+        sys.exit(1)
+
+    with open(synthesis_file) as f:
+        synthesis = json.load(f)
+
+    run_id = generate_run_id(target_date)
+    actions = synthesis.get("actions", [])
+    print(f"[apply] Phase 4: Applying findings for {target_date} (run: {run_id})")
+    print(f"[apply] Actions to process: {len(actions)}")
+
+    # Load recent dedupe keys for idempotency
+    existing_keys = load_recent_dedupe_keys(target_date)
+    print(f"[apply] Existing dedupe keys (7d): {len(existing_keys)}")
+
+    # Backup databases before mutations
+    auto_apply_count = sum(1 for a in actions if a.get("action_class") == "auto_apply")
+    if auto_apply_count > 0:
+        print("[apply] Creating database backups...")
+        nexo_backup = backup_db(NEXO_DB, run_id)
+        cog_backup = backup_db(COGNITIVE_DB, run_id)
+        if nexo_backup:
+            print(f"  Backup: {nexo_backup}")
+        if cog_backup:
+            print(f"  Backup: {cog_backup}")
+
+    # Process actions
+    applied_actions = []
+    stats = {"applied": 0, "deferred": 0, "skipped_dedupe": 0, "errors": 0}
+
+    for action in actions:
+        dedupe_key = action.get("dedupe_key", "")
+
+        # Idempotency check
+        if dedupe_key and dedupe_key in existing_keys:
+            applied_actions.append({
+                "applied_action_id": f"{run_id}-deduped",
+                "action_type": action.get("action_type"),
+                "dedupe_key": dedupe_key,
+                "status": "skipped_dedupe",
+                "timestamp": datetime.now().isoformat()
+            })
+            stats["skipped_dedupe"] += 1
+            continue
+
+        result = apply_action(action, run_id)
+        applied_actions.append(result)
+
+        if result["status"] == "applied":
+            stats["applied"] += 1
+            print(f"  Applied: {action.get('action_type')} -- {action.get('content', {}).get('title', '')[:50]}")
+        elif result["status"] == "deferred_to_morning":
+            stats["deferred"] += 1
+        elif result["status"] == "error":
+            stats["errors"] += 1
+            print(f"  Error: {result.get('details', {}).get('error', 'unknown')}", file=sys.stderr)
+
+    # Update mood in calibration.json
+    print("[apply] Updating mood/calibration...")
+    mood_result = update_calibration_mood(synthesis)
+    if mood_result.get("success"):
+        stats["applied"] += 1
+        print(f"  Mood score: {mood_result.get('mood_score', '?')}")
+    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)
+
+    evolution_candidates = synthesis.get("skill_evolution_candidates", [])
+    if evolution_candidates:
+        evolution_file = DEEP_SLEEP_DIR / f"{target_date}-skill-evolution-candidates.json"
+        with open(evolution_file, "w") as f:
+            json.dump(evolution_candidates, f, indent=2, ensure_ascii=False)
+        print(f"  Skill evolution candidates: {evolution_file}")
+
+    try:
+        from skills_runtime import auto_promote_skill_evolution
+
+        promotion_result = auto_promote_skill_evolution()
+        if promotion_result.get("promoted"):
+            promotion_file = DEEP_SLEEP_DIR / f"{target_date}-skill-autopromotions.json"
+            with open(promotion_file, "w") as f:
+                json.dump(promotion_result, f, indent=2, ensure_ascii=False)
+            stats["applied"] += len(promotion_result["promoted"])
+            print(f"  Skill autopromotions: {len(promotion_result['promoted'])} → {promotion_file}")
+    except Exception as e:
+        print(f"  Skill autopromotion error: {e}", file=sys.stderr)
+
+    # Apply drive synthesis (investigate/dismiss/promote signals)
+    drive_synthesis = synthesis.get("drive_synthesis", {})
+    if drive_synthesis:
+        print("[apply] Processing drive synthesis...")
+        try:
+            from db import update_drive_signal_status, reinforce_drive_signal
+            for item in drive_synthesis.get("investigated", []):
+                signal_id = item.get("signal_id")
+                action_taken = item.get("action_taken", "acted")
+                outcome = item.get("outcome", item.get("finding", ""))
+                if signal_id and outcome:
+                    update_drive_signal_status(signal_id, action_taken, outcome[:500])
+                    stats["applied"] += 1
+                    print(f"  Drive signal #{signal_id}: {action_taken}")
+            for item in drive_synthesis.get("promoted", []):
+                signal_id = item.get("signal_id")
+                reason = item.get("reason", "promoted by Deep Sleep")
+                if signal_id:
+                    reinforce_drive_signal(signal_id, f"Deep Sleep promotion: {reason}"[:500])
+                    print(f"  Drive signal #{signal_id}: promoted")
+        except Exception as e:
+            print(f"  Drive synthesis error: {e}", file=sys.stderr)
+
+    # Create followups for abandoned projects
+    abandoned_results = create_abandoned_followups(synthesis)
+    for r in abandoned_results:
+        if r.get("success"):
+            stats["applied"] += 1
+            print(f"  Abandoned project followup: {r.get('id')}")
+
+    # Write morning briefing
+    print("[apply] Writing morning briefing...")
+    briefing_path = write_morning_briefing(target_date, synthesis)
+    print(f"  Briefing: {briefing_path}")
+
+    print("[apply] Writing weekly/monthly Deep Sleep summaries...")
+    periodic_outputs = write_periodic_summaries(target_date, synthesis)
+    for label, path in periodic_outputs.items():
+        print(f"  {label}: {path}")
+
+    # Write applied log
+    applied_log = {
+        "date": target_date,
+        "run_id": run_id,
+        "applied_at": datetime.now().isoformat(),
+        "stats": stats,
+        "applied_actions": applied_actions,
+        "summary": synthesis.get("summary", ""),
+        "periodic_summaries": periodic_outputs,
+    }
+
+    applied_file = DEEP_SLEEP_DIR / f"{target_date}-applied.json"
+    with open(applied_file, "w") as f:
+        json.dump(applied_log, f, indent=2, ensure_ascii=False)
+
+    print(f"\n[apply] Done.")
+    print(f"  Applied: {stats['applied']}")
+    print(f"  Deferred to morning: {stats['deferred']}")
+    print(f"  Skipped (dedupe): {stats['skipped_dedupe']}")
+    print(f"  Errors: {stats['errors']}")
+    print(f"[apply] Log: {applied_file}")
+
+
+if __name__ == "__main__":
+    main()