nexo-brain 2.7.0 → 3.0.0

package/src/public_contribution.py

@@ -120,52 +120,93 @@ def save_public_contribution_config(config: dict) -> dict:
 
 
 def _gh(*args: str, cwd: Path | None = None, timeout: int = 20) -> subprocess.CompletedProcess:
+    env = os.environ.copy()
+    token = (
+        str(env.get("GH_TOKEN") or env.get("GITHUB_TOKEN") or "").strip()
+        or _github_token_from_credentials()
+    )
+    if token:
+        env["GH_TOKEN"] = token
     return subprocess.run(
         ["gh", *args],
         cwd=str(cwd) if cwd else None,
         capture_output=True,
         text=True,
         timeout=timeout,
+        env=env,
     )
 
 
+def _github_token_from_credentials() -> str:
+    try:
+        from db import get_credential
+    except Exception:
+        return ""
+    for key in ("token", "gh_token", "github_token"):
+        try:
+            matches = get_credential("github", key)
+        except Exception:
+            continue
+        for item in matches or []:
+            value = str(item.get("value") or "").strip()
+            if value:
+                return value
+    return ""
+
+
 def github_auth_status() -> dict:
     if not shutil.which("gh"):
-        return {"ok": False, "message": "GitHub CLI not found.", "login": ""}
+        return {"ok": False, "message": "GitHub CLI not found.", "login": "", "code": "gh_missing"}
     try:
         result = _gh("api", "user", timeout=20)
     except Exception as e:
-        return {"ok": False, "message": str(e), "login": ""}
+        return {"ok": False, "message": str(e), "login": "", "code": "gh_error"}
     if result.returncode != 0:
-        return {"ok": False, "message": (result.stderr or result.stdout).strip(), "login": ""}
+        message = (result.stderr or result.stdout).strip()
+        lowered = message.lower()
+        code = "auth_missing"
+        if "keychain" in lowered:
+            code = "keychain_blocked"
+        elif "token" in lowered or "authentication" in lowered or "login" in lowered:
+            code = "auth_missing"
+        return {"ok": False, "message": message, "login": "", "code": code}
     try:
         payload = json.loads(result.stdout or "{}")
         login = str(payload.get("login") or "").strip()
     except Exception:
         login = ""
-    return {"ok": bool(login), "message": "", "login": login}
+    return {"ok": bool(login), "message": "", "login": login, "code": "ok" if login else "auth_missing"}
 
 
 def ensure_fork(login: str) -> dict:
     if not login:
-        return {"ok": False, "message": "Missing GitHub login.", "fork_repo": ""}
+        return {"ok": False, "message": "Missing GitHub login.", "fork_repo": "", "code": "missing_login"}
     fork_repo = f"{login}/nexo"
     if not shutil.which("gh"):
-        return {"ok": False, "message": "GitHub CLI not found.", "fork_repo": ""}
+        return {"ok": False, "message": "GitHub CLI not found.", "fork_repo": "", "code": "gh_missing"}
     try:
         check = _gh("repo", "view", fork_repo, "--json", "nameWithOwner", timeout=20)
         if check.returncode == 0:
-            return {"ok": True, "message": "", "fork_repo": fork_repo}
+            return {"ok": True, "message": "", "fork_repo": fork_repo, "code": "ok"}
         create = _gh("repo", "fork", UPSTREAM_REPO, "--clone=false", "--remote=false", timeout=60)
         if create.returncode == 0:
-            return {"ok": True, "message": "", "fork_repo": fork_repo}
+            return {"ok": True, "message": "", "fork_repo": fork_repo, "code": "ok"}
         return {
             "ok": False,
             "message": (create.stderr or create.stdout or check.stderr or check.stdout).strip(),
             "fork_repo": "",
+            "code": "fork_unavailable",
         }
     except Exception as e:
-        return {"ok": False, "message": str(e), "fork_repo": ""}
+        return {"ok": False, "message": str(e), "fork_repo": "", "code": "fork_error"}
+
+
+def _set_pending_auth(config: dict, message: str) -> dict:
+    config["status"] = STATUS_PENDING_AUTH
+    config["last_result"] = f"pending_auth:{message}"
+    save_public_contribution_config(config)
+    config["message"] = message
+    return config
 
 
 def _parse_iso(ts: str | None) -> datetime | None:
@@ -336,13 +377,45 @@ def refresh_public_contribution_state(config: dict | None = None) -> dict:
             config["status"] = STATUS_COOLDOWN
             save_public_contribution_config(config)
             return config
+        return _set_pending_auth(
+            config,
+            f"GitHub Draft PR status check failed: {(result.stderr or result.stdout).strip() or 'unknown gh error'}",
+        )
 
     cooldown_until = _parse_iso(config.get("cooldown_until"))
     if cooldown_until and cooldown_until > _utcnow():
         config["status"] = STATUS_COOLDOWN
-    elif config["mode"] == MODE_PENDING_AUTH:
+        save_public_contribution_config(config)
+        return config
+
+    auth = github_auth_status()
+    if not auth.get("ok"):
+        return _set_pending_auth(
+            config,
+            auth.get("message") or "GitHub authentication is missing for public contribution.",
+        )
+    login = str(auth.get("login") or "").strip()
+    configured_login = str(config.get("github_user") or "").strip()
+    if configured_login and login and configured_login.lower() != login.lower():
+        return _set_pending_auth(
+            config,
+            f"GitHub login drift detected: configured {configured_login}, current {login}. Reconfirm public contribution credentials.",
+        )
+    if login and not configured_login:
+        config["github_user"] = login
+
+    if not str(config.get("fork_repo") or "").strip():
+        fork = ensure_fork(login)
+        if not fork.get("ok"):
+            return _set_pending_auth(
+                config,
+                fork.get("message") or "GitHub fork setup is missing for public contribution.",
+            )
+        config["fork_repo"] = str(fork.get("fork_repo") or "").strip()
+
+    if config["mode"] == MODE_PENDING_AUTH:
         config["status"] = STATUS_PENDING_AUTH
-    elif config["mode"] == MODE_DRAFT_PRS:
+    else:
         config["status"] = STATUS_ACTIVE
     save_public_contribution_config(config)
     return config
@@ -351,7 +424,8 @@ def refresh_public_contribution_state(config: dict | None = None) -> dict:
 def can_run_public_contribution(config: dict | None = None) -> tuple[bool, str, dict]:
     config = refresh_public_contribution_state(config)
     if config["mode"] == MODE_PENDING_AUTH or config["status"] == STATUS_PENDING_AUTH:
-        return False, "github authentication or fork setup is pending", config
+        detail = str(config.get("message") or config.get("last_result") or "").strip()
+        return False, detail or "github authentication or fork setup is pending", config
     if config["mode"] != MODE_DRAFT_PRS or not config.get("enabled"):
         return False, "public contribution is disabled", config
     if config["status"] == STATUS_PAUSED_OPEN_PR:

package/src/script_registry.py

@@ -662,6 +662,105 @@ def _canonical_schedule_value(schedule_type: str, schedule_value: str | dict | l
     return str(schedule_value or "")
 
 
+def _extract_launchctl_value(output: str, prefixes: str | tuple[str, ...]) -> str | None:
+    if isinstance(prefixes, str):
+        prefixes = (prefixes,)
+    for raw_line in output.splitlines():
+        line = raw_line.strip()
+        for prefix in prefixes:
+            if line.startswith(prefix):
+                return line[len(prefix):].strip()
+    return None
+
+
+def _launchctl_service_state(label: str) -> dict:
+    state = {
+        "loaded": None,
+        "pid": "",
+        "state": "",
+        "last_exit_status": "",
+        "error": "",
+    }
+    if platform.system() != "Darwin":
+        return state
+
+    try:
+        result = subprocess.run(
+            ["launchctl", "print", f"gui/{os.getuid()}/{label}"],
+            capture_output=True,
+            text=True,
+            timeout=3,
+        )
+    except Exception as exc:
+        return {**state, "loaded": False, "error": str(exc)}
+
+    output = (result.stdout or "") + (result.stderr or "")
+    if result.returncode != 0 or "Could not find service" in output:
+        return {**state, "loaded": False, "error": output.strip() or "not loaded"}
+
+    return {
+        "loaded": True,
+        "pid": _extract_launchctl_value(output, ("pid = ", "PID = ")) or "",
+        "state": _extract_launchctl_value(output, "state = ") or "",
+        "last_exit_status": _extract_launchctl_value(
+            output,
+            ("last exit code = ", "last exit status = ", "LastExitStatus = "),
+        ) or "",
+        "error": "",
+    }
+
+
+def _keep_alive_runtime_snapshot(record: dict) -> dict:
+    if record.get("schedule_type") != "keep_alive":
+        return {
+            "runtime_state": "unknown",
+            "runtime_summary": "",
+            "runtime_problems": [],
+        }
+
+    label = record.get("launchd_label") or f"com.nexo.{record.get('cron_id', '')}"
+    service = _launchctl_service_state(str(label))
+    problems: list[str] = []
+
+    if service.get("loaded") is False:
+        problems.append("keep_alive service not loaded in launchd")
+        return {
+            "runtime_state": "stale",
+            "runtime_summary": "keep_alive service not loaded",
+            "runtime_problems": problems,
+        }
+
+    pid = str(service.get("pid", "") or "").strip()
+    service_state = str(service.get("state", "") or "").strip().lower()
+    last_exit = str(service.get("last_exit_status", "") or "").strip()
+    if pid:
+        return {
+            "runtime_state": "alive",
+            "runtime_summary": f"running with pid {pid}",
+            "runtime_problems": [],
+        }
+    if service_state in {"running", "spawned"}:
+        return {
+            "runtime_state": "alive",
+            "runtime_summary": f"launchd state {service_state}",
+            "runtime_problems": [],
+        }
+    if last_exit and last_exit != "0":
+        problems.append(f"keep_alive daemon exited with status {last_exit}")
+        return {
+            "runtime_state": "degraded",
+            "runtime_summary": f"last exit {last_exit}",
+            "runtime_problems": problems,
+        }
+
+    problems.append("keep_alive service is loaded but has no active pid")
+    return {
+        "runtime_state": "degraded",
+        "runtime_summary": "loaded but not running",
+        "runtime_problems": problems,
+    }
+
+
 def _discover_personal_schedule_records() -> list[dict]:
     """Inspect macOS LaunchAgents and return raw personal schedule records."""
     if platform.system() != "Darwin":
@@ -737,6 +836,12 @@ def audit_personal_schedules() -> dict:
         "healthy": 0,
         "problems": 0,
         "managed_registered": 0,
+        "keep_alive": 0,
+        "runtime_alive": 0,
+        "runtime_degraded": 0,
+        "runtime_duplicated": 0,
+        "runtime_stale": 0,
+        "runtime_unknown": 0,
     }
 
     for record in _discover_personal_schedule_records():
@@ -790,6 +895,7 @@ def audit_personal_schedules() -> dict:
             schedule_state = "orphaned"
 
         audited_record = dict(record)
+        runtime_snapshot = _keep_alive_runtime_snapshot(record)
         audited_record.update({
             "schedule_origin": schedule_origin,
             "schedule_declared": declared_valid,
@@ -799,6 +905,7 @@ def audit_personal_schedules() -> dict:
             "problems": problems,
             "script_name": script.get("name", "") if script else "",
             "declared_schedule": declared if script else {},
+            **runtime_snapshot,
         })
         audited.append(audited_record)
         summary[schedule_origin] += 1
@@ -808,6 +915,41 @@ def audit_personal_schedules() -> dict:
         else:
             summary["problems"] += 1
 
+    duplicate_cron_ids: dict[str, int] = {}
+    duplicate_script_paths: dict[str, int] = {}
+    for record in audited:
+        if record.get("schedule_type") != "keep_alive":
+            continue
+        cron_id = str(record.get("cron_id", "") or "")
+        script_path = str(record.get("script_path", "") or "")
+        if cron_id:
+            duplicate_cron_ids[cron_id] = duplicate_cron_ids.get(cron_id, 0) + 1
+        if script_path:
+            duplicate_script_paths[script_path] = duplicate_script_paths.get(script_path, 0) + 1
+
+    for record in audited:
+        if record.get("schedule_type") == "keep_alive":
+            cron_id = str(record.get("cron_id", "") or "")
+            script_path = str(record.get("script_path", "") or "")
+            duplicated = (
+                (cron_id and duplicate_cron_ids.get(cron_id, 0) > 1)
+                or (script_path and duplicate_script_paths.get(script_path, 0) > 1)
+            )
+            if duplicated:
+                runtime_problems = list(record.get("runtime_problems", []))
+                runtime_problems.append("duplicate keep_alive schedules discovered for the same cron/script")
+                record["runtime_state"] = "duplicated"
+                record["runtime_summary"] = "multiple keep_alive schedules discovered"
+                record["runtime_problems"] = runtime_problems
+
+        if record.get("schedule_type") == "keep_alive":
+            summary["keep_alive"] += 1
+            runtime_state = str(record.get("runtime_state", "unknown") or "unknown")
+            key = f"runtime_{runtime_state}"
+            if key not in summary:
+                summary[key] = 0
+            summary[key] += 1
+
     return {
         "schedules": audited,
         "summary": summary,

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

@@ -1080,6 +1080,10 @@ def _aggregate_delivery_metrics(applied_logs: list[dict]) -> dict:
         "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 {}
@@ -1093,6 +1097,16 @@ def _aggregate_delivery_metrics(applied_logs: list[dict]) -> dict:
                 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)
@@ -1100,6 +1114,147 @@ def _aggregate_delivery_metrics(applied_logs: list[dict]) -> dict:
     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]] = []
@@ -1169,6 +1324,10 @@ def _build_period_trend(summary: dict, previous_summary: dict | None) -> dict:
             "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")
@@ -1177,6 +1336,14 @@ def _build_period_trend(summary: dict, previous_summary: dict | None) -> dict:
     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,
@@ -1184,6 +1351,10 @@ def _build_period_trend(summary: dict, previous_summary: dict | None) -> dict:
         "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,
     }
 
 
@@ -1236,6 +1407,8 @@ def _build_period_summary(target_date: str, synthesis: dict, *, kind: str, windo
     ]
     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)
 
@@ -1267,6 +1440,8 @@ def _build_period_summary(target_date: str, synthesis: dict, *, kind: str, windo
         "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)
@@ -1328,6 +1503,27 @@ def _render_period_summary_markdown(summary: dict) -> str:
             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"):
@@ -1379,6 +1575,14 @@ def _render_period_summary_markdown(summary: dict) -> str:
             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"