nexo-brain 2.6.21 → 3.0.0

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

@@ -992,6 +992,372 @@ def _load_period_syntheses(target_date: str, *, window_days: int) -> list[dict]:
     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")
@@ -1001,6 +1367,8 @@ def _build_period_summary(target_date: str, synthesis: dict, *, kind: str, windo
         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)
 
@@ -1037,6 +1405,12 @@ def _build_period_summary(target_date: str, synthesis: dict, *, kind: str, windo
         {"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:
@@ -1045,9 +1419,11 @@ def _build_period_summary(target_date: str, synthesis: dict, *, kind: str, windo
         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)
 
-    return {
+    period_summary = {
         "kind": kind,
         "label": label,
         "window_days": window_days,
@@ -1059,11 +1435,17 @@ def _build_period_summary(target_date: str, synthesis: dict, *, kind: str, windo
         "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 = [
@@ -1082,6 +1464,68 @@ def _render_period_summary_markdown(summary: dict) -> str:
         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("")
@@ -1091,6 +1535,20 @@ def _render_period_summary_markdown(summary: dict) -> str:
                 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("")
@@ -1105,6 +1563,28 @@ def _render_period_summary_markdown(summary: dict) -> str:
             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"
 
 

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

@@ -25,6 +25,7 @@ NEXO_CODE = Path(os.environ.get("NEXO_CODE", ""))
 DEEP_SLEEP_DIR = NEXO_HOME / "operations" / "deep-sleep"
 NEXO_DB = NEXO_HOME / "data" / "nexo.db"
 COGNITIVE_DB = NEXO_HOME / "data" / "cognitive.db"
+_TABLE_COLUMNS_CACHE: dict[tuple[str, str], set[str]] = {}
 
 MIN_USER_MESSAGES = 3  # Skip trivial sessions
 
@@ -304,6 +305,33 @@ def safe_query(db_path: Path, query: str, params: tuple = ()) -> list[dict]:
         return []
 
 
+def _table_columns(db_path: Path, table_name: str) -> set[str]:
+    cache_key = (str(db_path), table_name)
+    cached = _TABLE_COLUMNS_CACHE.get(cache_key)
+    if cached is not None:
+        return cached
+    if not db_path.exists():
+        _TABLE_COLUMNS_CACHE[cache_key] = set()
+        return set()
+    try:
+        conn = sqlite3.connect(str(db_path))
+        conn.row_factory = sqlite3.Row
+        rows = conn.execute(f"PRAGMA table_info({table_name})").fetchall()
+        conn.close()
+    except Exception:
+        _TABLE_COLUMNS_CACHE[cache_key] = set()
+        return set()
+    columns = {str(row["name"]) for row in rows}
+    _TABLE_COLUMNS_CACHE[cache_key] = columns
+    return columns
+
+
+def _optional_column_sql(db_path: Path, table_name: str, column_name: str, default_sql: str = "''") -> str:
+    if column_name in _table_columns(db_path, table_name):
+        return column_name
+    return f"{default_sql} AS {column_name}"
+
+
 def collect_followups() -> list[dict]:
     """Active followups from nexo.db."""
     return safe_query(
@@ -513,9 +541,13 @@ def _project_priority_signals(target_day: datetime, compact_diaries: list[dict])
         for project in candidates:
             bump(project, 3.0 * recency_bonus, "diary_sessions", "recent session diary activity")
 
+    learning_priority_sql = _optional_column_sql(NEXO_DB, "learnings", "priority", "'medium'")
+    learning_weight_sql = _optional_column_sql(NEXO_DB, "learnings", "weight", "0")
+    learning_applies_sql = _optional_column_sql(NEXO_DB, "learnings", "applies_to", "''")
     learning_rows = safe_query(
         NEXO_DB,
-        "SELECT category, title, content, created_at, updated_at, priority, weight, applies_to FROM learnings "
+        f"SELECT category, title, content, created_at, updated_at, {learning_priority_sql}, "
+        f"{learning_weight_sql}, {learning_applies_sql} FROM learnings "
         "ORDER BY COALESCE(updated_at, created_at) DESC LIMIT 160",
     )
     for row in learning_rows:
@@ -535,9 +567,12 @@ def _project_priority_signals(target_day: datetime, compact_diaries: list[dict])
         for project in matched:
             bump(project, score, "learnings", "recent leverage-bearing learning")
 
+    followup_priority_sql = _optional_column_sql(NEXO_DB, "followups", "priority", "'medium'")
+    followup_reasoning_sql = _optional_column_sql(NEXO_DB, "followups", "reasoning", "''")
     followup_rows = safe_query(
         NEXO_DB,
-        "SELECT id, description, date, status, priority, created_at, updated_at, reasoning FROM followups "
+        f"SELECT id, description, date, status, {followup_priority_sql}, created_at, updated_at, "
+        f"{followup_reasoning_sql} FROM followups "
         "WHERE status NOT IN ('COMPLETED', 'CANCELLED') ORDER BY date ASC, created_at ASC LIMIT 120",
     )
     for row in followup_rows:
@@ -565,9 +600,13 @@ def _project_priority_signals(target_day: datetime, compact_diaries: list[dict])
         for project in matched:
             bump(project, score, "followups", "open followup pressure")
 
+    decision_status_sql = _optional_column_sql(NEXO_DB, "decisions", "status", "''")
+    decision_reasoning_sql = _optional_column_sql(NEXO_DB, "decisions", "reasoning", "''")
+    decision_review_due_sql = _optional_column_sql(NEXO_DB, "decisions", "review_due_at", "NULL")
     decision_rows = safe_query(
         NEXO_DB,
-        "SELECT domain, outcome, status, reasoning, created_at, review_due_at FROM decisions "
+        f"SELECT domain, outcome, {decision_status_sql}, {decision_reasoning_sql}, decision, based_on, created_at, "
+        f"{decision_review_due_sql} FROM decisions "
         "ORDER BY COALESCE(created_at, review_due_at) DESC LIMIT 120",
     )
     for row in decision_rows:
@@ -579,6 +618,8 @@ def _project_priority_signals(target_day: datetime, compact_diaries: list[dict])
             " ".join(
                 [
                     str(row.get("reasoning", "") or ""),
+                    str(row.get("decision", "") or ""),
+                    str(row.get("based_on", "") or ""),
                     str(row.get("outcome", "") or ""),
                     str(row.get("status", "") or ""),
                 ]
@@ -647,9 +688,13 @@ def collect_long_horizon_context(
     recurring_states = Counter(row["mental_state"] for row in compact_diaries if row.get("mental_state"))
     recurring_critiques = Counter(row["self_critique"] for row in compact_diaries if row.get("self_critique"))
 
+    learning_reasoning_sql = _optional_column_sql(NEXO_DB, "learnings", "reasoning", "''")
+    learning_prevention_sql = _optional_column_sql(NEXO_DB, "learnings", "prevention", "''")
+    learning_applies_sql = _optional_column_sql(NEXO_DB, "learnings", "applies_to", "''")
     learning_rows = safe_query(
         NEXO_DB,
-        "SELECT category, title, content, created_at, updated_at, reasoning, prevention, applies_to "
+        f"SELECT category, title, content, created_at, updated_at, {learning_reasoning_sql}, "
+        f"{learning_prevention_sql}, {learning_applies_sql} "
         "FROM learnings ORDER BY COALESCE(updated_at, created_at) DESC LIMIT 120"
     )
     long_horizon_learnings = []

package/src/scripts/nexo-agent-run.py

@@ -29,6 +29,7 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument("--prompt", default="", help="Prompt text")
     parser.add_argument("--prompt-file", default="", help="Read prompt text from a file")
     parser.add_argument("--cwd", default="", help="Working directory for the backend")
+    parser.add_argument("--task-profile", default="", help="Automation task profile: default|fast|balanced|deep")
     parser.add_argument("--model", default="", help="Backend model hint")
     parser.add_argument("--reasoning-effort", default="", help="Backend reasoning effort/profile")
     parser.add_argument("--timeout", type=int, default=21600, help="Timeout in seconds")
@@ -51,6 +52,7 @@ def main(argv: list[str] | None = None) -> int:
         result = run_automation_prompt(
             prompt,
             cwd=args.cwd or None,
+            task_profile=args.task_profile,
             model=args.model,
             reasoning_effort=args.reasoning_effort,
             timeout=args.timeout,