nexo-brain 7.30.0 → 7.30.2

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.0",
+  "version": "7.30.2",
   "description": "Local cognitive runtime for Claude Code \u2014 persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
   "author": {
     "name": "NEXO Brain",

package/README.md

@@ -18,7 +18,11 @@
 
 [Watch the overview video](https://nexo-brain.com/watch/) · [Watch on YouTube](https://www.youtube.com/watch?v=i2lkGhKyVqI) · [Open the infographic](https://nexo-brain.com/assets/nexo-brain-infographic-v5.png)
 
-Version `7.30.0` is the current packaged-runtime line. Minor release over v7.29.0 - morning briefing preferences now support weather/news, selectable weekdays, safer SMTP certificates, Opus 4.8 defaults, and an agent-facing preference catalog so NEXO can explain or change supported settings by chat.
+Version `7.30.2` is the current packaged-runtime line. Patch release over v7.30.1 - Deep Sleep now fails closed on partial nightly runs, carries complete learning context into synthesis, writes an explicit agent start packet, and creates governed followups with verification, priority, owner, and date fields.
+
+Previously in `7.30.1`: patch release over v7.30.0 - morning briefings now behave more like a start-of-day assistant, explain news/weather as verified optional sources, and keep user type inference inside NEXO instead of asking the user to choose a role manually.
+
+Previously in `7.30.0`: minor release over v7.29.0 - morning briefing preferences now support weather/news, selectable weekdays, safer SMTP certificates, Opus 4.8 defaults, and an agent-facing preference catalog so NEXO can explain or change supported settings by chat.
 
 Previously in `7.29.0`: minor release over v7.28.0 - the morning briefing now has structured content preferences, Desktop-facing briefing presentation state, and per-account email signature support.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.0",
+  "version": "7.30.2",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain — Shared brain for AI agents. Persistent memory, semantic RAG, natural forgetting, metacognitive guard, trust scoring, 150+ MCP tools. Works with Claude Code, Codex, Claude Desktop & any MCP client. 100% local, free.",
   "homepage": "https://nexo-brain.com",

package/src/automation_preferences.py

@@ -83,14 +83,14 @@ MORNING_AGENT_SCHEMA: dict[str, Any] = {
                     "type": "boolean",
                     "label": "News",
                     "default": False,
-                    "help": "A short set of public headlines from the configured news feed. If the feed is unreachable, NEXO simply says it was unavailable.",
+                    "help": "A short set of current public headlines from the configured news feed, included only when the source can be verified.",
                 },
                 {
                     "id": "weather",
                     "type": "boolean",
                     "label": "Weather",
                     "default": True,
-                    "help": "Today's weather from the location saved in Desktop or your residence in the profile.",
+                    "help": "Today's weather from the location saved in Desktop or your residence in the profile, included only when the forecast can be verified.",
                 },
             ],
         },
@@ -348,8 +348,12 @@ def format_automation_preferences_prompt_block(name_or_path: str) -> str:
     return (
         "\n== STRUCTURED CONTENT PREFERENCES FOR THIS AUTOMATION ==\n"
         f"{compact}\n"
+        "Morning briefing intent: act like a professional personal assistant preparing the operator for the day. "
+        "Do not merely list available records; filter, rank, and explain what deserves attention first.\n"
+        "Adapt the emphasis from the operator profile, role, recent activity, and context. "
+        "Do not ask the user to choose a user type manually and do not assume a profession unless the context supports it.\n"
         "Use these preferences to decide what to include, omit, and emphasize. "
-        "Disabled/unavailable data sources must not be invented.\n"
+        "Disabled/unavailable data sources must not be invented; news and weather require verified collected data.\n"
     )
 
 

package/src/cognitive/_core.py

@@ -666,6 +666,9 @@ def _get_reranker():
     """Lazy-load cross-encoder reranking model."""
     global _reranker
     if _reranker is None:
+        if _model_download_disabled():
+            _reranker = False
+            return None
         try:
             from local_models import build_fastembed_reranker
 

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

@@ -418,6 +418,10 @@ def _touch_existing_followup(
     date: str = "",
     reasoning_note: str = "",
     status: str = "",
+    verification: str = "",
+    priority: str = "",
+    internal: object = None,
+    owner: str = "",
 ) -> dict:
     cols = _table_columns(NEXO_DB, "followups")
     if not cols:
@@ -433,6 +437,15 @@ def _touch_existing_followup(
     desired_status = (status or "").strip()
     if desired_status and "status" in cols and desired_status != str(existing.get("status", "") or ""):
         updates["status"] = desired_status
+    existing_verification = str(existing.get("verification", "") or "").strip()
+    if verification and "verification" in cols and not existing_verification:
+        updates["verification"] = verification
+    if priority and "priority" in cols and priority != str(existing.get("priority", "") or ""):
+        updates["priority"] = priority
+    if internal is not None and "internal" in cols:
+        updates["internal"] = 1 if str(internal).strip().lower() in {"1", "true", "yes", "on"} else 0
+    if owner and "owner" in cols and owner != str(existing.get("owner", "") or ""):
+        updates["owner"] = owner
     note = reasoning_note or "Deep Sleep matched this followup semantically."
     changed = False
     if updates:
@@ -693,12 +706,52 @@ def add_learning(category: str, title: str, content: str) -> dict:
         return {"success": False, "error": str(e)}
 
 
-def create_followup(description: str, date: str = "", reasoning_note: str = "", status: str = "PENDING") -> dict:
+def _default_followup_date(date: str, *, status: str = "") -> str:
+    clean = str(date or "").strip()
+    if clean or str(status or "").strip().lower() == "archived":
+        return clean
+    return (datetime.now() + timedelta(days=1)).strftime("%Y-%m-%d")
+
+
+def _default_followup_verification(description: str, verification: str = "") -> str:
+    clean = str(verification or "").strip()
+    if clean:
+        return clean
+    description_text = str(description or "").strip()
+    if not description_text:
+        return "Verify the Deep Sleep followup has a concrete deliverable or close it as invalid."
+    return f"Verify completion evidence for: {description_text[:180]}"
+
+
+def _normalize_followup_priority(priority: str = "", impact: str = "") -> str:
+    clean = str(priority or "").strip().lower()
+    if clean in {"critical", "high", "medium", "low"}:
+        return clean
+    impact_clean = str(impact or "").strip().lower()
+    if impact_clean in {"critical", "high", "medium", "low"}:
+        return impact_clean
+    return "medium"
+
+
+def create_followup(
+    description: str,
+    date: str = "",
+    reasoning_note: str = "",
+    status: str = "PENDING",
+    verification: str = "",
+    priority: str = "",
+    internal: object = 1,
+    owner: str = "agent",
+) -> 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"
+        desired_date = _default_followup_date(date, status=desired_status)
+        desired_verification = _default_followup_verification(description, verification)
+        desired_priority = _normalize_followup_priority(priority)
+        desired_owner = (owner or "agent").strip() or "agent"
         is_abandoned = description.strip().startswith("[Abandoned]")
         if not is_abandoned:
             matched = _find_similar_followup(description)
@@ -706,9 +759,13 @@ def create_followup(description: str, date: str = "", reasoning_note: str = "",
                 return _touch_existing_followup(
                     matched,
                     description=description,
-                    date=date,
+                    date=desired_date,
                     reasoning_note=reasoning_note or "Deep Sleep matched this followup semantically.",
                     status=desired_status,
+                    verification=desired_verification,
+                    priority=desired_priority,
+                    internal=internal,
+                    owner=desired_owner,
                 )
 
         # Generate a deterministic ID — content fingerprint, not security-sensitive.
@@ -718,19 +775,26 @@ def create_followup(description: str, date: str = "", reasoning_note: str = "",
             return _touch_existing_followup(
                 existing,
                 description=description,
-                date=date,
+                date=desired_date,
                 reasoning_note=reasoning_note or "Deep Sleep revisited this deterministic followup.",
                 status=desired_status,
+                verification=desired_verification,
+                priority=desired_priority,
+                internal=internal,
+                owner=desired_owner,
             )
 
         followup_result = nexo_db.create_followup(
             id=fid,
             description=description,
-            date=date or None,
-            verification="",
+            date=desired_date or None,
+            verification=desired_verification,
             status=desired_status,
             reasoning=reasoning_note or "Deep Sleep v2 overnight analysis",
             recurrence=None,
+            priority=desired_priority,
+            internal=internal,
+            owner=desired_owner,
         )
         if followup_result.get("error"):
             return {"success": False, "error": followup_result["error"]}
@@ -2113,10 +2177,15 @@ def apply_action(action: dict, run_id: str) -> dict:
         log_entry["details"] = result
 
     elif action_type == "followup_create":
+        description = content.get("description", content.get("title", ""))
         result = create_followup(
-            description=content.get("description", content.get("title", "")),
+            description=description,
             date=content.get("date", ""),
             reasoning_note=content.get("reasoning", content.get("why", "")),
+            verification=content.get("verification", content.get("success_signal", "")),
+            priority=_normalize_followup_priority(content.get("priority", ""), action.get("impact", "")),
+            internal=content.get("internal", 1),
+            owner=content.get("owner", "agent"),
         )
         log_entry["status"] = "applied" if result.get("success") else "error"
         log_entry["details"] = result

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

@@ -190,6 +190,62 @@ def backfill_engineering_actions(payload: dict) -> dict:
     return payload
 
 
+def _compact_action_title(action: dict) -> str:
+    content = action.get("content") if isinstance(action, dict) else {}
+    if isinstance(content, dict):
+        return str(content.get("title") or content.get("description") or "").strip()
+    return str(content or "").strip()
+
+
+def build_agent_start_packet(payload: dict, target_date: str) -> dict:
+    """Build a compact handoff packet for the next interactive agent startup."""
+    agenda = payload.get("morning_agenda") if isinstance(payload, dict) else []
+    packets = payload.get("context_packets") if isinstance(payload, dict) else []
+    actions = payload.get("actions") if isinstance(payload, dict) else []
+
+    review_items = []
+    if isinstance(actions, list):
+        for action in actions:
+            if not isinstance(action, dict):
+                continue
+            if action.get("action_class") != "draft_for_morning":
+                continue
+            title = _compact_action_title(action)
+            if title:
+                review_items.append(
+                    {
+                        "title": title,
+                        "action_type": action.get("action_type", ""),
+                        "impact": action.get("impact", ""),
+                        "confidence": action.get("confidence", 0),
+                    }
+                )
+
+    return {
+        "date": str(payload.get("date") or target_date),
+        "generated_at": datetime.now().isoformat(),
+        "source": "deep-sleep/synthesize",
+        "summary": str(payload.get("summary") or "").strip(),
+        "agenda": agenda[:5] if isinstance(agenda, list) else [],
+        "context_packets": packets[:5] if isinstance(packets, list) else [],
+        "review_items": review_items[:5],
+        "counts": {
+            "actions": len(actions) if isinstance(actions, list) else 0,
+            "agenda": len(agenda) if isinstance(agenda, list) else 0,
+            "context_packets": len(packets) if isinstance(packets, list) else 0,
+            "review_items": len(review_items),
+        },
+    }
+
+
+def write_agent_start_packet(payload: dict, target_date: str) -> Path:
+    """Persist a startup-ready Deep Sleep packet next to synthesis outputs."""
+    packet = build_agent_start_packet(payload, target_date)
+    packet_file = DEEP_SLEEP_DIR / f"{target_date}-agent-start-packet.json"
+    packet_file.write_text(json.dumps(packet, indent=2, ensure_ascii=False), encoding="utf-8")
+    return packet_file
+
+
 def main():
     target_date = sys.argv[1] if len(sys.argv) > 1 else datetime.now().strftime("%Y-%m-%d")
 
@@ -226,7 +282,9 @@ def main():
         output_file = DEEP_SLEEP_DIR / f"{target_date}-synthesis.json"
         with open(output_file, "w") as f:
             json.dump(output, f, indent=2, ensure_ascii=False)
+        packet_file = write_agent_start_packet(output, target_date)
         print(f"[synthesize] Output: {output_file}")
+        print(f"[synthesize] Agent start packet: {packet_file}")
         return
 
     # Build prompt
@@ -288,6 +346,7 @@ def main():
         output_file = DEEP_SLEEP_DIR / f"{target_date}-synthesis.json"
         with open(output_file, "w") as f:
             json.dump(parsed, f, indent=2, ensure_ascii=False)
+        packet_file = write_agent_start_packet(parsed, target_date)
 
         n_actions = len(parsed.get("actions", []))
         n_patterns = len(parsed.get("cross_session_patterns", []))
@@ -300,6 +359,7 @@ def main():
         print(f"  Morning agenda items: {n_agenda}")
         print(f"  Context packets: {n_packets}")
         print(f"[synthesize] Output: {output_file}")
+        print(f"[synthesize] Agent start packet: {packet_file}")
 
     except AutomationBackendUnavailableError as exc:
         print(f"[synthesize] Automation backend unavailable: {exc}", file=sys.stderr)

package/src/scripts/nexo-deep-sleep.sh

@@ -63,7 +63,10 @@ fi
 
 # Phase 2: Extract findings per session (configured automation backend)
 log "Phase 2: Extracting findings from $SESSIONS sessions..."
-python3 "$SCRIPT_DIR/deep-sleep/extract.py" "$RUN_ID" >> "$LOG_DIR/deep-sleep.log" 2>&1
+if ! python3 "$SCRIPT_DIR/deep-sleep/extract.py" "$RUN_ID" >> "$LOG_DIR/deep-sleep.log" 2>&1; then
+    log "Extraction failed. Watermark NOT updated (will retry next run)."
+    exit 1
+fi
 
 if [ ! -f "$DEEP_SLEEP_DIR/$RUN_ID-extractions.json" ]; then
     log "Extraction failed. Watermark NOT updated (will retry next run)."
@@ -72,16 +75,22 @@ fi
 
 # Phase 3: Cross-session synthesis (configured automation backend, one call)
 log "Phase 3: Synthesizing cross-session findings..."
-python3 "$SCRIPT_DIR/deep-sleep/synthesize.py" "$RUN_ID" >> "$LOG_DIR/deep-sleep.log" 2>&1
+if ! python3 "$SCRIPT_DIR/deep-sleep/synthesize.py" "$RUN_ID" >> "$LOG_DIR/deep-sleep.log" 2>&1; then
+    log "Synthesis failed. Watermark NOT updated (will retry next run)."
+    exit 1
+fi
 
 if [ ! -f "$DEEP_SLEEP_DIR/$RUN_ID-synthesis.json" ]; then
-    log "Synthesis failed. Falling back to extractions only."
-    cp "$DEEP_SLEEP_DIR/$RUN_ID-extractions.json" "$DEEP_SLEEP_DIR/$RUN_ID-synthesis.json"
+    log "Synthesis output missing. Watermark NOT updated (will retry next run)."
+    exit 1
 fi
 
 # Phase 4: Apply findings
 log "Phase 4: Applying findings..."
-python3 "$SCRIPT_DIR/deep-sleep/apply_findings.py" "$RUN_ID" >> "$LOG_DIR/deep-sleep.log" 2>&1
+if ! python3 "$SCRIPT_DIR/deep-sleep/apply_findings.py" "$RUN_ID" >> "$LOG_DIR/deep-sleep.log" 2>&1; then
+    log "Apply failed. Watermark NOT updated (will retry next run)."
+    exit 1
+fi
 
 # Update watermark on success
 echo "$UNTIL" > "$WATERMARK_FILE"

package/src/scripts/nexo-sleep.py

@@ -63,6 +63,11 @@ COMPRESSED_MEMORIES_DIR = BRAIN_DIR / "compressed_memories"
 HEARTBEAT_LOG = COORD_DIR / "heartbeat-log.json"
 REFLECTION_LOG = COORD_DIR / "reflection-log.json"
 SLEEP_LOG = COORD_DIR / "sleep-log.json"
+SLEEP_HEALTH_FILE = COORD_DIR / "sleep-health.json"
+LEARNINGS_DUMP_FILE = COORD_DIR / "sleep-learnings-dump.json"
+LEARNINGS_CHUNKS_DIR = COORD_DIR / "sleep-learnings-chunks"
+MIN_LEARNING_COVERAGE_PCT = 95.0
+LEARNING_CHUNK_MAX_CHARS = 50000
 
 MEMORY_MD = paths.memory_dir() / "MEMORY.md"
 NEXO_DB = paths.db_path()
@@ -209,6 +214,41 @@ def append_sleep_log(entry: dict):
     save_json(SLEEP_LOG, entries)
 
 
+def write_sleep_health(
+    run_log: dict,
+    state: dict,
+    *,
+    status: str,
+    error: str = "",
+    actions: dict | None = None,
+) -> dict:
+    """Write a small machine-readable health file for startup/briefings."""
+    stage_b = run_log.get("stage_b") if isinstance(run_log, dict) else {}
+    if not isinstance(stage_b, dict):
+        stage_b = {}
+    coverage = {}
+    if isinstance(actions, dict):
+        coverage = actions.get("coverage") or {}
+    if not coverage and isinstance(stage_b, dict):
+        coverage = stage_b.get("coverage") or {}
+
+    health = {
+        "date": str(TODAY),
+        "status": status,
+        "generated_at": datetime.now().isoformat(),
+        "error": error,
+        "learnings_total": len(state.get("learnings", []) if isinstance(state, dict) else []),
+        "memory_md_lines": state.get("memory_md_lines", 0) if isinstance(state, dict) else 0,
+        "old_observations": state.get("claude_mem_old", 0) if isinstance(state, dict) else 0,
+        "stage_a": run_log.get("stage_a") if isinstance(run_log, dict) else None,
+        "stage_b": stage_b,
+        "coverage": coverage,
+        "last_run_marked_complete": status == "ok",
+    }
+    save_json(SLEEP_HEALTH_FILE, health)
+    return health
+
+
 # ─── Stage A: Mechanical cleanup (UNCHANGED from v1) ─────────────────────────
 
 def stage_a_cleanup() -> dict:
@@ -388,13 +428,108 @@ def should_dream(state: dict) -> bool:
     )
 
 
+def write_learning_context(state: dict) -> dict:
+    """Persist all learnings to files so Stage B never receives a truncated list."""
+    learnings = state.get("learnings", []) if isinstance(state, dict) else []
+    LEARNINGS_CHUNKS_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Remove stale chunks for today's run before rewriting them.
+    today_prefix = f"{TODAY}-chunk-"
+    for old_chunk in LEARNINGS_CHUNKS_DIR.glob(f"{today_prefix}*.json"):
+        try:
+            old_chunk.unlink()
+        except Exception:
+            pass
+
+    chunks: list[list[dict]] = []
+    current: list[dict] = []
+    current_chars = 2
+    for learning in learnings:
+        rendered = json.dumps(learning, ensure_ascii=False, separators=(",", ":"))
+        if current and current_chars + len(rendered) + 1 > LEARNING_CHUNK_MAX_CHARS:
+            chunks.append(current)
+            current = []
+            current_chars = 2
+        current.append(learning)
+        current_chars += len(rendered) + 1
+    if current or not chunks:
+        chunks.append(current)
+
+    chunk_files: list[str] = []
+    for index, chunk in enumerate(chunks, start=1):
+        chunk_path = LEARNINGS_CHUNKS_DIR / f"{TODAY}-chunk-{index:03d}.json"
+        save_json(
+            chunk_path,
+            {
+                "date": str(TODAY),
+                "chunk_index": index,
+                "chunk_count": len(chunks),
+                "learnings_total_declared": len(learnings),
+                "learnings_in_chunk": len(chunk),
+                "learnings": chunk,
+            },
+        )
+        chunk_files.append(str(chunk_path))
+
+    coverage = {
+        "learnings_visible_count": len(learnings),
+        "learnings_total_declared": len(learnings),
+        "coverage_pct": 100.0 if learnings or len(learnings) == 0 else 0.0,
+        "source_file": str(LEARNINGS_DUMP_FILE),
+        "chunk_count": len(chunk_files),
+    }
+    save_json(
+        LEARNINGS_DUMP_FILE,
+        {
+            "date": str(TODAY),
+            "generated_at": datetime.now().isoformat(),
+            "coverage": coverage,
+            "chunk_files": chunk_files,
+            "learnings": learnings,
+        },
+    )
+    return {
+        "dump_file": str(LEARNINGS_DUMP_FILE),
+        "chunk_files": chunk_files,
+        "coverage": coverage,
+    }
+
+
+def validate_actions_coverage(actions: dict, state: dict) -> tuple[bool, str]:
+    """Fail closed when Stage B did not inspect nearly all active learnings."""
+    expected_total = len(state.get("learnings", []) if isinstance(state, dict) else [])
+    if expected_total == 0:
+        return True, "no active learnings"
+
+    coverage = actions.get("coverage") if isinstance(actions, dict) else None
+    if not isinstance(coverage, dict):
+        return False, "sleep-actions.json is missing coverage metadata"
+
+    try:
+        visible_count = int(coverage.get("learnings_visible_count", 0) or 0)
+    except Exception:
+        visible_count = 0
+    try:
+        declared_total = int(coverage.get("learnings_total_declared", 0) or 0)
+    except Exception:
+        declared_total = 0
+    try:
+        coverage_pct = float(coverage.get("coverage_pct", 0.0) or 0.0)
+    except Exception:
+        coverage_pct = 0.0
+
+    if declared_total != expected_total:
+        return False, f"coverage declared {declared_total} learnings but state has {expected_total}"
+    if visible_count < expected_total:
+        return False, f"coverage only saw {visible_count}/{expected_total} learnings"
+    if coverage_pct < MIN_LEARNING_COVERAGE_PCT:
+        return False, f"coverage {coverage_pct:.1f}% is below {MIN_LEARNING_COVERAGE_PCT:.1f}%"
+    return True, "coverage ok"
+
+
 def dream(state: dict) -> dict:
     """The brain dreams — CLI does the intelligent work."""
-
-    # Truncate learnings JSON if too large
-    learnings_json = json.dumps(state["learnings"], ensure_ascii=False, indent=1)
-    if len(learnings_json) > 15000:
-        learnings_json = learnings_json[:15000] + "\n... (truncated)"
+    learning_context = write_learning_context(state)
 
     tasks = []
 
@@ -410,12 +545,30 @@ Write your findings to {COORD_DIR}/sleep-report.md with sections:
 - "## Stale candidates" — IDs of learnings that may be obsolete
 
 Also write a machine-readable file {COORD_DIR}/sleep-actions.json:
-{{"archive_ids": [1, 2, 3], "contradiction_pairs": [[4, 5]], "stale_ids": [6, 7]}}
+{{
+  "archive_ids": [1, 2, 3],
+  "contradiction_pairs": [[4, 5]],
+  "stale_ids": [6, 7],
+  "coverage": {{
+    "learnings_visible_count": {len(state['learnings'])},
+    "learnings_total_declared": {len(state['learnings'])},
+    "coverage_pct": 100.0,
+    "source_file": "{learning_context['dump_file']}",
+    "chunk_files_read": {json.dumps(learning_context['chunk_files'], ensure_ascii=False)}
+  }}
+}}
 
 The wrapper will execute the actual DB operations based on this JSON.
+The wrapper will fail closed if coverage is missing or below {MIN_LEARNING_COVERAGE_PCT:.0f}%.
+
+LEARNINGS SOURCE:
+Read the full learning list from {learning_context['dump_file']}.
+If the file is too large for one read, read every chunk listed below and merge them by ID:
+{json.dumps(learning_context['chunk_files'], ensure_ascii=False, indent=2)}
 
-LEARNINGS:
-{learnings_json}""")
+Do not infer duplicates/stale items from a partial list. If you cannot read at least
+{MIN_LEARNING_COVERAGE_PCT:.0f}% of the declared learnings, write empty archive/stale arrays
+and include coverage.blocking_reason explaining the read failure.""")
 
     if state["memory_md_lines"] > 170:
         tasks.append(f"""TASK 2: MEMORY.MD COMPRESSION ({state['memory_md_lines']} lines, limit 200)
@@ -461,20 +614,25 @@ The wrapper will handle the actual DB cleanup safely.""")
 
         if result.returncode != 0:
             log(f"Stage B: CLI error ({result.returncode}): {(result.stderr or '')[:300]}")
-            return {"error": result.returncode}
+            return {"error": result.returncode, "learning_context": learning_context}
 
         log(f"Stage B: Dreaming complete. Output: {len(result.stdout or '')} chars")
-        return {"ok": True, "output_len": len(result.stdout or "")}
+        return {
+            "ok": True,
+            "output_len": len(result.stdout or ""),
+            "learning_context": learning_context,
+            "coverage": learning_context["coverage"],
+        }
 
     except AutomationBackendUnavailableError as e:
         log(f"Stage B: automation backend unavailable: {e}")
-        return {"error": "backend-unavailable"}
+        return {"error": "backend-unavailable", "learning_context": learning_context}
     except subprocess.TimeoutExpired:
-        log("Stage B: CLI timed out (600s)")
-        return {"error": "timeout"}
+        log(f"Stage B: CLI timed out ({AUTOMATION_SUBPROCESS_TIMEOUT}s)")
+        return {"error": "timeout", "learning_context": learning_context}
     except Exception as e:
         log(f"Stage B: Exception: {e}")
-        return {"error": str(e)}
+        return {"error": str(e), "learning_context": learning_context}
 
 
 def execute_dream_actions(actions: dict, state: dict):
@@ -573,8 +731,11 @@ def main():
             start_phase = get_interrupted_phase()
 
         run_log = {"date": str(TODAY), "started": TIMESTAMP,
-                   "stage_a": None, "stage_b": None, "completed": None}
+                   "stage_a": None, "stage_b": None, "completed": None,
+                   "marked_complete": False}
         sleep_had_errors = False
+        sleep_error = ""
+        actions = None
 
         # Stage A: Housekeeping (mechanical)
         if start_phase == "stage_a":
@@ -598,22 +759,49 @@ def main():
                 log(f"Stage B: Dreaming failed ({dream_result['error']}). "
                     "Stage A cleanup completed successfully. Not marking catchup to allow retry.")
                 sleep_had_errors = True
+                sleep_error = str(dream_result["error"])
             else:
                 # Stage B2: Execute actions from CLI output
                 actions_file = COORD_DIR / "sleep-actions.json"
                 if actions_file.exists():
                     try:
                         actions = json.loads(actions_file.read_text())
-                        execute_dream_actions(actions, state)
+                        coverage_ok, coverage_reason = validate_actions_coverage(actions, state)
+                        run_log["stage_b"]["actions_file"] = str(actions_file)
+                        run_log["stage_b"]["coverage_ok"] = coverage_ok
+                        run_log["stage_b"]["coverage_reason"] = coverage_reason
+                        if not coverage_ok:
+                            log(f"Stage B2: Refusing dream actions: {coverage_reason}")
+                            sleep_had_errors = True
+                            sleep_error = coverage_reason
+                        else:
+                            execute_dream_actions(actions, state)
                     except Exception as e:
                         log(f"Stage B2: Error executing actions: {e}")
+                        sleep_had_errors = True
+                        sleep_error = str(e)
+                else:
+                    sleep_had_errors = True
+                    sleep_error = f"missing actions file: {actions_file}"
+                    run_log["stage_b"]["error"] = sleep_error
+                    log(f"Stage B2: {sleep_error}")
         else:
             log("Brain is clean -- no dreaming needed.")
             run_log["stage_b"] = {"skipped": True}
 
         # Done
         run_log["completed"] = datetime.now().strftime("%Y-%m-%d %H:%M")
+        if sleep_had_errors:
+            run_log["status"] = "failed"
+            write_sleep_health(run_log, state, status="failed", error=sleep_error, actions=actions)
+            append_sleep_log(run_log)
+            log("NEXO Sleep v2 failed during Stage B; not marking today complete so the next trigger retries.")
+            sys.exit(1)
+
         mark_complete()
+        run_log["marked_complete"] = True
+        run_log["status"] = "ok"
+        write_sleep_health(run_log, state, status="ok", actions=actions)
         append_sleep_log(run_log)
         log(f"NEXO Sleep v2 complete at {run_log['completed']}")
 

package/src/tools_sessions.py

@@ -634,6 +634,192 @@ def _read_session_briefing_excerpt(max_lines: int = 6) -> tuple[str, str]:
     return excerpt, str(briefing_path)
 
 
+def _read_sleep_health_warning() -> tuple[list[str], str]:
+    """Return a compact warning when nightly sleep failed or degraded."""
+    health_path = paths.coordination_dir() / "sleep-health.json"
+    try:
+        payload = json.loads(health_path.read_text(encoding="utf-8"))
+    except (FileNotFoundError, OSError, json.JSONDecodeError):
+        return [], str(health_path)
+
+    if not isinstance(payload, dict):
+        return [], str(health_path)
+    status = str(payload.get("status") or "").strip().lower()
+    if not status or status == "ok":
+        return [], str(health_path)
+
+    date_value = str(payload.get("date") or "").strip()
+    error = _safe_packet_text(payload.get("error") or "unknown", max_chars=180)
+    lines = [f"status={status} date={date_value or '?'} error={error}"]
+
+    coverage = payload.get("coverage") or {}
+    if isinstance(coverage, dict):
+        visible = coverage.get("learnings_visible_count")
+        total = coverage.get("learnings_total_declared")
+        pct = coverage.get("coverage_pct")
+        if visible is not None or total is not None or pct is not None:
+            lines.append(f"coverage={visible or 0}/{total or 0} ({pct or 0}%)")
+
+    return lines, str(health_path)
+
+
+def _latest_deep_sleep_synthesis() -> Path | None:
+    deep_sleep_dir = paths.operations_dir() / "deep-sleep"
+    try:
+        candidates = [
+            path
+            for path in deep_sleep_dir.glob("????-??-??-synthesis.json")
+            if path.is_file()
+        ]
+    except OSError:
+        return None
+    if not candidates:
+        return None
+    return max(candidates, key=lambda path: (path.name[:10], path.stat().st_mtime))
+
+
+def _latest_deep_sleep_start_packet() -> Path | None:
+    deep_sleep_dir = paths.operations_dir() / "deep-sleep"
+    try:
+        candidates = [
+            path
+            for path in deep_sleep_dir.glob("????-??-??-agent-start-packet.json")
+            if path.is_file()
+        ]
+    except OSError:
+        return None
+    if not candidates:
+        return None
+    return max(candidates, key=lambda path: (path.name[:10], path.stat().st_mtime))
+
+
+def _read_agent_start_packet(payload: dict, packet_path: Path) -> tuple[list[str], str]:
+    lines: list[str] = []
+    date_value = str(payload.get("date") or packet_path.name[:10]).strip()
+    summary = str(payload.get("summary") or "").strip()
+    if date_value:
+        lines.append(f"date={date_value}")
+    if summary:
+        lines.append(f"summary={_safe_packet_text(summary, max_chars=220)}")
+
+    agenda = payload.get("agenda") or []
+    if isinstance(agenda, list):
+        for item in agenda[:3]:
+            if not isinstance(item, dict):
+                continue
+            priority = str(item.get("priority") or "?").strip()
+            title = str(item.get("title") or "").strip()
+            description = str(item.get("description") or "").strip()
+            if title or description:
+                text = title if not description else f"{title} - {description}"
+                lines.append(f"agenda[{priority}]={_safe_packet_text(text, max_chars=220)}")
+
+    packets = payload.get("context_packets") or []
+    if isinstance(packets, list):
+        for packet in packets[:2]:
+            if not isinstance(packet, dict):
+                continue
+            topic = str(packet.get("topic") or "context").strip()
+            last_state = str(packet.get("last_state") or "").strip()
+            if topic or last_state:
+                text = topic if not last_state else f"{topic}: {last_state}"
+                lines.append(f"context={_safe_packet_text(text, max_chars=240)}")
+            files = packet.get("key_files") or []
+            if isinstance(files, list) and files:
+                rendered_files = ", ".join(str(file) for file in files[:4] if str(file).strip())
+                if rendered_files:
+                    lines.append(f"files={_safe_packet_text(rendered_files, max_chars=220)}")
+
+    review_items = payload.get("review_items") or []
+    if isinstance(review_items, list):
+        for item in review_items[:2]:
+            if not isinstance(item, dict):
+                continue
+            title = str(item.get("title") or "").strip()
+            if title:
+                lines.append(f"review={_safe_packet_text(title, max_chars=220)}")
+
+    return lines[:10], str(packet_path)
+
+
+def _read_deep_sleep_start_context() -> tuple[list[str], str]:
+    """Summarize the latest Deep Sleep synthesis for new agent sessions."""
+    packet_path = _latest_deep_sleep_start_packet()
+    if packet_path is not None:
+        try:
+            packet_payload = json.loads(packet_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            packet_payload = None
+        if isinstance(packet_payload, dict):
+            return _read_agent_start_packet(packet_payload, packet_path)
+
+    synthesis_path = _latest_deep_sleep_synthesis()
+    if synthesis_path is None:
+        return [], str(paths.operations_dir() / "deep-sleep")
+
+    try:
+        payload = json.loads(synthesis_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return [], str(synthesis_path)
+    if not isinstance(payload, dict):
+        return [], str(synthesis_path)
+
+    lines: list[str] = []
+    date_value = str(payload.get("date") or synthesis_path.name[:10]).strip()
+    summary = str(payload.get("summary") or "").strip()
+    if date_value:
+        lines.append(f"date={date_value}")
+    if summary:
+        lines.append(f"summary={_safe_packet_text(summary, max_chars=220)}")
+
+    agenda = payload.get("morning_agenda") or []
+    if isinstance(agenda, list):
+        for item in agenda[:3]:
+            if not isinstance(item, dict):
+                continue
+            priority = str(item.get("priority") or "?").strip()
+            title = str(item.get("title") or "").strip()
+            description = str(item.get("description") or "").strip()
+            if title or description:
+                text = title if not description else f"{title} - {description}"
+                lines.append(f"agenda[{priority}]={_safe_packet_text(text, max_chars=220)}")
+
+    packets = payload.get("context_packets") or []
+    if isinstance(packets, list):
+        for packet in packets[:2]:
+            if not isinstance(packet, dict):
+                continue
+            topic = str(packet.get("topic") or "context").strip()
+            last_state = str(packet.get("last_state") or "").strip()
+            if topic or last_state:
+                text = topic if not last_state else f"{topic}: {last_state}"
+                lines.append(f"context={_safe_packet_text(text, max_chars=240)}")
+            files = packet.get("key_files") or []
+            if isinstance(files, list) and files:
+                rendered_files = ", ".join(str(file) for file in files[:4] if str(file).strip())
+                if rendered_files:
+                    lines.append(f"files={_safe_packet_text(rendered_files, max_chars=220)}")
+
+    actions = payload.get("actions") or []
+    if isinstance(actions, list):
+        review_count = 0
+        for action in actions:
+            if review_count >= 2 or not isinstance(action, dict):
+                continue
+            if action.get("action_class") != "draft_for_morning":
+                continue
+            content = action.get("content") or {}
+            if isinstance(content, dict):
+                title = str(content.get("title") or content.get("description") or "").strip()
+            else:
+                title = str(content or "").strip()
+            if title:
+                lines.append(f"review={_safe_packet_text(title, max_chars=220)}")
+                review_count += 1
+
+    return lines[:10], str(synthesis_path)
+
+
 def handle_startup(
     task: str = "Startup",
     claude_session_id: str = "",
@@ -796,6 +982,22 @@ def handle_startup(
             lines.append(f"  {_safe_packet_text(raw_line)}")
         lines.append(f"  Full briefing: {_safe_packet_text(briefing_path)}")
 
+    sleep_health, sleep_health_path = _read_sleep_health_warning()
+    if sleep_health:
+        lines.append("")
+        lines.append("SLEEP HEALTH:")
+        for raw_line in sleep_health:
+            lines.append(f"  {_safe_packet_text(raw_line)}")
+        lines.append(f"  Full health: {_safe_packet_text(sleep_health_path)}")
+
+    start_context, start_context_path = _read_deep_sleep_start_context()
+    if start_context:
+        lines.append("")
+        lines.append("DEEP SLEEP CONTEXT:")
+        for raw_line in start_context:
+            lines.append(f"  {_safe_packet_text(raw_line)}")
+        lines.append(f"  Full synthesis: {_safe_packet_text(start_context_path)}")
+
     try:
         from memory_layer_audit import audit_memory_layers, format_memory_layer_warnings
 

package/templates/core-prompts/morning-agent.md

@@ -4,6 +4,13 @@ Write the email using ONLY the facts present in the structured context below.
 Use the operator's preferred language: [[operator_language]].
 If the language value is invalid or unclear, use English.
 
+Product intent:
+- This is a start-of-day briefing, not a report dump. The operator should finish reading it knowing what matters, what changed, what can wait, and what needs a decision.
+- Think like a professional personal assistant or chief of staff: filter noise, rank priorities, connect related items, and make the day feel prepared.
+- Adapt the emphasis to the operator's real context: administrative work needs tasks, deadlines, email movement and missing inputs; executives need decisions, risks, money, people and blocked outcomes; technical users need incidents, deployments, regressions and dependencies; commercial users need leads, customers and follow-ups; regulated or clinical users need careful wording, pending actions and factual status only.
+- Do not ask the operator to choose a user type. Infer the useful angle from the structured context, profile fields, recent activity and explicit preferences. If the context is thin, stay general and practical.
+- Include news and weather only when verified collected data exists in the context. Never fabricate public news, forecasts, calendar events, emails or professional advice.
+
 Hard rules:
 - Do not invent achievements, blockers, meetings, messages, or external events.
 - Do not mention source files, JSON, MCP, prompts, or internal implementation.