nexo-brain 2.7.0 → 3.0.1

package/src/scripts/nexo-daily-self-audit.py

@@ -19,6 +19,7 @@ Runs via launchd at 7:00 AM daily.
 import json
 import hashlib
 import os
+import re
 import sqlite3
 import subprocess
 import sys
@@ -37,6 +38,8 @@ from agent_runner import AutomationBackendUnavailableError, run_automation_promp
 
 LOG_DIR = NEXO_HOME / "logs"
 LOG_DIR.mkdir(parents=True, exist_ok=True)
+AUDIT_HISTORY_DIR = LOG_DIR / "self-audit"
+AUDIT_HISTORY_DIR.mkdir(parents=True, exist_ok=True)
 LOG_FILE = LOG_DIR / "self-audit.log"
 NEXO_DB = NEXO_HOME / "data" / "nexo.db"
 # Configure your main project repo to check for uncommitted changes (optional)
@@ -85,6 +88,314 @@ def finding(severity, area, msg):
     log(f"  [{severity}] {area}: {msg}")
 
 
+def _parse_iso_dt(value: str | None) -> datetime | None:
+    text = str(value or "").strip()
+    if not text:
+        return None
+    try:
+        return datetime.fromisoformat(text.replace("Z", "+00:00"))
+    except Exception:
+        return None
+
+
+def _area_summary_from_daily_summaries(summaries: list[dict]) -> tuple[list[dict], list[str]]:
+    per_area: dict[str, dict] = {}
+    area_days: dict[str, set[str]] = {}
+    for item in summaries:
+        day = str(item.get("date_label") or item.get("timestamp") or "")[:10]
+        for finding_item in item.get("findings", []):
+            area = str(finding_item.get("area") or "unknown").strip() or "unknown"
+            severity = str(finding_item.get("severity") or "INFO").strip().upper()
+            bucket = per_area.setdefault(area, {"area": area, "count": 0, "error": 0, "warn": 0, "info": 0})
+            bucket["count"] += 1
+            if severity == "ERROR":
+                bucket["error"] += 1
+            elif severity == "WARN":
+                bucket["warn"] += 1
+            else:
+                bucket["info"] += 1
+            if day:
+                area_days.setdefault(area, set()).add(day)
+    top_areas = sorted(
+        per_area.values(),
+        key=lambda item: (-item["count"], -item["error"], item["area"]),
+    )[:10]
+    repeated = sorted(area for area, days in area_days.items() if len(days) >= 2)
+    return top_areas, repeated
+
+
+def _load_recent_daily_summaries(reference_dt: datetime, window_days: int) -> list[dict]:
+    summaries: list[dict] = []
+    cutoff = reference_dt - timedelta(days=window_days - 1)
+    for path in sorted(AUDIT_HISTORY_DIR.glob("*-daily-summary.json")):
+        try:
+            payload = json.loads(path.read_text())
+        except Exception:
+            continue
+        ts = _parse_iso_dt(payload.get("timestamp"))
+        if not ts:
+            continue
+        if ts.date() < cutoff.date() or ts.date() > reference_dt.date():
+            continue
+        summaries.append(payload)
+    summaries.sort(key=lambda item: str(item.get("timestamp") or ""))
+    return summaries
+
+
+def write_horizon_summaries(summary_payload: dict, *, now: datetime | None = None) -> dict:
+    now = now or datetime.now()
+    daily_payload = dict(summary_payload)
+    daily_payload.setdefault("date_label", now.strftime("%Y-%m-%d"))
+    daily_file = AUDIT_HISTORY_DIR / f"{daily_payload['date_label']}-daily-summary.json"
+    daily_file.write_text(json.dumps(daily_payload, indent=2))
+
+    outputs = {
+        "daily_file": str(daily_file),
+        "weekly_file": "",
+        "weekly_latest": "",
+        "monthly_file": "",
+        "monthly_latest": "",
+    }
+    for kind, window_days in (("weekly", 7), ("monthly", 30)):
+        recent = _load_recent_daily_summaries(now, window_days)
+        total_counts = {"error": 0, "warn": 0, "info": 0}
+        for item in recent:
+            counts = item.get("counts") or {}
+            for key in total_counts:
+                total_counts[key] += int(counts.get(key) or 0)
+        top_areas, repeated_areas = _area_summary_from_daily_summaries(recent)
+        if kind == "weekly":
+            year, week, _ = now.isocalendar()
+            label = f"{year}-W{week:02d}"
+        else:
+            label = now.strftime("%Y-%m")
+        rollup = {
+            "timestamp": now.isoformat(),
+            "label": label,
+            "horizon": kind,
+            "window_days": window_days,
+            "source_daily_summaries": len(recent),
+            "days": [item.get("date_label") for item in recent if item.get("date_label")],
+            "counts": total_counts,
+            "top_areas": top_areas,
+            "repeated_areas": repeated_areas,
+        }
+        dated_file = AUDIT_HISTORY_DIR / f"{label}-{kind}-summary.json"
+        latest_file = LOG_DIR / f"self-audit-{kind}-summary.json"
+        dated_file.write_text(json.dumps(rollup, indent=2))
+        latest_file.write_text(json.dumps(rollup, indent=2))
+        outputs[f"{kind}_file"] = str(dated_file)
+        outputs[f"{kind}_latest"] = str(latest_file)
+    return outputs
+
+
+def _protocol_debt_table_exists(conn: sqlite3.Connection) -> bool:
+    row = conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='protocol_debt'"
+    ).fetchone()
+    return bool(row)
+
+
+def _table_exists(conn: sqlite3.Connection, table_name: str) -> bool:
+    row = conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name = ?",
+        (table_name,),
+    ).fetchone()
+    return bool(row)
+
+
+def _ensure_protocol_debt(conn: sqlite3.Connection, *, debt_type: str, severity: str, evidence: str) -> bool:
+    existing = conn.execute(
+        """SELECT id
+           FROM protocol_debt
+           WHERE status = 'open' AND debt_type = ? AND evidence = ?
+           LIMIT 1""",
+        (debt_type, evidence),
+    ).fetchone()
+    if existing:
+        return False
+    conn.execute(
+        """INSERT INTO protocol_debt (session_id, task_id, debt_type, severity, evidence)
+           VALUES ('', '', ?, ?, ?)""",
+        (debt_type, severity, evidence),
+    )
+    return True
+
+
+def _ensure_followup(conn: sqlite3.Connection, *, prefix: str, description: str,
+                     verification: str, reasoning: str, priority: str = "high") -> str:
+    if not _table_exists(conn, "followups"):
+        return ""
+    existing = conn.execute(
+        """SELECT id FROM followups
+           WHERE status NOT LIKE 'COMPLETED%'
+             AND status NOT IN ('DELETED','archived','blocked','waiting')
+             AND description = ?
+           LIMIT 1""",
+        (description,),
+    ).fetchone()
+    if existing:
+        return str(existing["id"])
+
+    followup_id = f"NF-{prefix}-{hashlib.sha1(description.encode('utf-8')).hexdigest()[:8].upper()}"
+    now_epoch = int(datetime.now().timestamp())
+    columns = {row["name"] for row in conn.execute("PRAGMA table_info(followups)").fetchall()}
+    values = {
+        "id": followup_id,
+        "date": "",
+        "description": description,
+        "verification": verification,
+        "status": "PENDING",
+        "reasoning": reasoning,
+        "recurrence": None,
+        "created_at": now_epoch,
+        "updated_at": now_epoch,
+    }
+    if "priority" in columns:
+        values["priority"] = priority
+
+    ordered_columns = [name for name in values.keys() if name in columns]
+    placeholders = ", ".join("?" for _ in ordered_columns)
+    conn.execute(
+        f"INSERT INTO followups ({', '.join(ordered_columns)}) VALUES ({placeholders})",
+        [values[name] for name in ordered_columns],
+    )
+    return followup_id
+
+
+TOPIC_STOPWORDS = {
+    "the", "and", "for", "with", "from", "that", "this", "into", "about", "after",
+    "before", "again", "need", "needs", "task", "tasks", "work", "working",
+    "continue", "continuing", "review", "check", "checks", "make", "making",
+    "fix", "fixes", "build", "create", "created", "update", "updates", "ship",
+    "prepare", "finish", "open", "another", "around", "must",
+}
+
+
+def _topic_signature(text: str) -> str:
+    tokens = [
+        token for token in re.findall(r"[a-z0-9]+", (text or "").lower())
+        if len(token) >= 3 and token not in TOPIC_STOPWORDS
+    ]
+    return " ".join(tokens[:2])
+
+
+REPAIR_KEYWORDS = {
+    "fix", "fixed", "bug", "bugs", "regression", "regressions", "repair", "repaired",
+    "correct", "corrected", "correction", "typo", "hotfix", "patch", "patched",
+    "resolve", "resolved", "failure", "error", "issue", "broken", "broke",
+}
+
+
+def _split_changed_files(raw: str) -> list[str]:
+    text = str(raw or "").strip()
+    if not text:
+        return []
+    if text.startswith("["):
+        try:
+            value = json.loads(text)
+        except Exception:
+            value = []
+        if isinstance(value, list):
+            return [str(item).strip() for item in value if str(item).strip()]
+    parts = re.split(r"[\n,;]+", text)
+    return [part.strip() for part in parts if part.strip()]
+
+
+def _looks_like_repair_change(text: str) -> bool:
+    tokens = {token for token in re.findall(r"[a-z0-9]+", (text or "").lower()) if len(token) >= 3}
+    return bool(tokens & REPAIR_KEYWORDS)
+
+
+def _parse_mixed_datetime(value) -> datetime | None:
+    if value in (None, ""):
+        return None
+    if isinstance(value, (int, float)):
+        try:
+            return datetime.fromtimestamp(float(value))
+        except Exception:
+            return None
+    text = str(value).strip()
+    if not text:
+        return None
+    try:
+        return datetime.fromisoformat(text.replace("Z", "+00:00")).replace(tzinfo=None)
+    except Exception:
+        return None
+
+
+def _learning_matches_change(row: sqlite3.Row, files: list[str], change_text: str, created_at: datetime | None) -> bool:
+    learning_text = " ".join(
+        str(row[key] or "")
+        for key in ("title", "content", "reasoning", "prevention")
+        if key in row.keys()
+    )
+    applies_to = str(row["applies_to"] or "").strip() if "applies_to" in row.keys() else ""
+    if files and applies_to:
+        applies_tokens = {item for item in _split_changed_files(applies_to)}
+        if any(file_path in applies_tokens or Path(file_path).name in applies_to for file_path in files):
+            return True
+    change_signature = _topic_signature(change_text)
+    learning_signature = _topic_signature(learning_text)
+    if change_signature and learning_signature and change_signature == learning_signature:
+        return True
+    if change_signature and change_signature in learning_text.lower():
+        return True
+
+    updated_at = _parse_mixed_datetime(row["updated_at"] if "updated_at" in row.keys() else None)
+    if created_at and updated_at:
+        delta = updated_at - created_at
+        if timedelta(hours=-1) <= delta <= timedelta(days=3):
+            return True
+    return False
+
+
+def _attempt_repair_learning_auto_capture(row: sqlite3.Row) -> dict:
+    try:
+        from tools_learnings import find_conflicting_active_learning, handle_learning_add
+    except Exception as exc:
+        return {"ok": False, "error": f"learning runtime unavailable: {exc}"}
+
+    files = _split_changed_files(str(row["files"] or ""))
+    title_seed = str(row["what_changed"] or row["why"] or "").strip() or f"Repair change #{row['id']}"
+    title = title_seed[:120]
+    content_parts = [
+        str(row["what_changed"] or "").strip(),
+        str(row["why"] or "").strip(),
+    ]
+    if files:
+        content_parts.append(f"Affected files: {', '.join(files[:5])}")
+    content = " ".join(part for part in content_parts if part).strip()
+    if not content:
+        content = f"Repair-oriented change log entry #{row['id']} required a canonical learning."
+    applies_to = ",".join(files)
+    conflicting = find_conflicting_active_learning(
+        category="nexo-ops",
+        title=title,
+        content=content,
+        applies_to=applies_to,
+    )
+    supersedes_id = int(conflicting["id"]) if conflicting else 0
+    response = handle_learning_add(
+        category="nexo-ops",
+        title=title,
+        content=content,
+        reasoning=f"Auto-captured by daily self-audit from repair change #{row['id']}.",
+        prevention="Review the canonical repair learning before touching the affected file again." if applies_to else "",
+        applies_to=applies_to,
+        priority="high",
+        supersedes_id=supersedes_id,
+    )
+    match = re.search(r"Learning #(\d+)", response)
+    if match and "ERROR:" not in response:
+        return {
+            "ok": True,
+            "learning_id": int(match.group(1)),
+            "response": response,
+        }
+    return {"ok": False, "error": response}
+
+
 # ═══════════════════════════════════════════════════════════════════════════════
 # Stage A: Mechanical checks (UNCHANGED from v1 — all 18 checks)
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -253,6 +564,396 @@ def check_memory_reviews():
         finding("INFO", "memory", f"{total} reviews due")
 
 
+def check_learning_contradictions():
+    if not NEXO_DB.exists():
+        return
+    conn = sqlite3.connect(str(NEXO_DB))
+    conn.row_factory = sqlite3.Row
+    if not _table_exists(conn, "learnings"):
+        conn.close()
+        return
+
+    from tools_learnings import _applies_overlap, _looks_contradictory
+
+    rows = conn.execute(
+        """SELECT id, title, content, applies_to
+           FROM learnings
+           WHERE status = 'active' AND COALESCE(applies_to, '') != ''
+           ORDER BY updated_at DESC, id DESC
+           LIMIT 200"""
+    ).fetchall()
+    contradictions: list[tuple[sqlite3.Row, sqlite3.Row]] = []
+    for index, left in enumerate(rows):
+        for right in rows[index + 1:]:
+            if not _applies_overlap(left["applies_to"], right["applies_to"]):
+                continue
+            if not _looks_contradictory(
+                f"{left['title']} {left['content']}",
+                f"{right['title']} {right['content']}",
+            ):
+                continue
+            contradictions.append((left, right))
+
+    if contradictions:
+        finding("ERROR", "contradictions", f"{len(contradictions)} contradictory active learning pair(s)")
+        for left, right in contradictions[:5]:
+            description = (
+                f"Resolve contradictory active learnings #{left['id']} and #{right['id']} "
+                f"for {left['applies_to'] or right['applies_to']}"
+            )
+            reasoning = (
+                "Daily self-audit found two active canonical rules that contradict each other. "
+                "One rule must be superseded or reconciled before the next edit repeats the error."
+            )
+            _ensure_followup(
+                conn,
+                prefix="CONTRADICTION",
+                description=description,
+                verification="One canonical learning remains active and the conflicting rule is superseded or archived",
+                reasoning=reasoning,
+                priority="critical",
+            )
+        conn.commit()
+    conn.close()
+
+
+def check_error_memory_loop():
+    if not NEXO_DB.exists():
+        return
+    conn = sqlite3.connect(str(NEXO_DB))
+    conn.row_factory = sqlite3.Row
+    if not _table_exists(conn, "protocol_tasks"):
+        conn.close()
+        return
+
+    rows = conn.execute(
+        """SELECT task_id, goal, area, files, status, learning_id
+           FROM protocol_tasks
+           WHERE status IN ('failed', 'blocked')
+             AND (learning_id IS NULL OR learning_id = 0)
+             AND opened_at >= datetime('now', '-30 days')
+           ORDER BY opened_at DESC"""
+    ).fetchall()
+
+    grouped: dict[str, list[sqlite3.Row]] = {}
+    for row in rows:
+        files = str(row["files"] or "").strip()
+        signature = files if files and files != "[]" else (row["area"] or row["goal"] or "general")
+        grouped.setdefault(signature[:220], []).append(row)
+
+    repeated = {signature: items for signature, items in grouped.items() if len(items) >= 2}
+    if repeated:
+        finding("WARN", "prevention", f"{len(repeated)} repeated failure cluster(s) still lack canonical prevention learnings")
+        for signature, items in list(repeated.items())[:5]:
+            description = (
+                f"Mine a canonical prevention learning from repeated failed/blocked protocol tasks around {signature}"
+            )
+            reasoning = (
+                f"Daily self-audit found {len(items)} failed/blocked protocol tasks without a linked learning. "
+                "Turn the repeated failure into a prevention rule before it repeats again."
+            )
+            _ensure_followup(
+                conn,
+                prefix="PREVENTION",
+                description=description,
+                verification="Canonical prevention learning captured and linked to the repeated failure pattern",
+                reasoning=reasoning,
+                priority="high",
+            )
+        conn.commit()
+    conn.close()
+
+
+def check_repair_changes_missing_learning_capture():
+    if not NEXO_DB.exists():
+        return
+    conn = sqlite3.connect(str(NEXO_DB))
+    conn.row_factory = sqlite3.Row
+    if not _table_exists(conn, "change_log") or not _table_exists(conn, "learnings"):
+        conn.close()
+        return
+
+    learning_rows = conn.execute(
+        """SELECT *
+           FROM learnings
+           WHERE COALESCE(status, 'active') != 'deleted'
+           ORDER BY updated_at DESC, created_at DESC
+           LIMIT 300"""
+    ).fetchall()
+    if not learning_rows:
+        learning_rows = []
+
+    rows = conn.execute(
+        """SELECT id, files, what_changed, why, created_at
+           FROM change_log
+           WHERE created_at >= datetime('now', '-14 days')
+           ORDER BY created_at DESC
+           LIMIT 200"""
+    ).fetchall()
+    missing: list[sqlite3.Row] = []
+    for row in rows:
+        change_text = f"{row['what_changed'] or ''} {row['why'] or ''}".strip()
+        if not _looks_like_repair_change(change_text):
+            continue
+        files = _split_changed_files(str(row["files"] or ""))
+        created_at = _parse_mixed_datetime(row["created_at"])
+        if any(_learning_matches_change(learning, files, change_text, created_at) for learning in learning_rows):
+            continue
+        missing.append(row)
+
+    if missing:
+        auto_captured = 0
+        unresolved: list[sqlite3.Row] = []
+        for row in missing:
+            captured = _attempt_repair_learning_auto_capture(row)
+            if captured.get("ok"):
+                auto_captured += 1
+                continue
+            unresolved.append(row)
+
+        if unresolved:
+            finding(
+                "WARN",
+                "learning-capture",
+                f"{len(unresolved)} repair/logged fix change(s) still lack linked learnings "
+                f"after {auto_captured} self-audit auto-capture(s)",
+            )
+        else:
+            finding(
+                "INFO",
+                "learning-capture",
+                f"Self-audit auto-captured {auto_captured} missing repair learning(s)",
+            )
+
+        for row in unresolved[:5]:
+            files = _split_changed_files(str(row["files"] or ""))
+            target = files[0] if files else str(row["what_changed"] or "recent repair")[:120]
+            evidence = (
+                f"Repair-oriented change log entry #{row['id']} on {target} has no nearby linked learning capture."
+            )
+            _ensure_protocol_debt(
+                conn,
+                debt_type="repair_change_without_learning_capture",
+                severity="warn",
+                evidence=evidence,
+            )
+            _ensure_followup(
+                conn,
+                prefix="LEARNCAP",
+                description=f"Capture canonical learning for repair change touching {target}",
+                verification="A learning exists with applies_to/topic linked to the repair change",
+                reasoning="Daily self-audit found a repair/fix change log entry with no durable learning attached.",
+                priority="high",
+            )
+        conn.commit()
+    conn.close()
+
+
+def check_unformalized_mentions():
+    if not NEXO_DB.exists():
+        return
+    conn = sqlite3.connect(str(NEXO_DB))
+    conn.row_factory = sqlite3.Row
+    if not _table_exists(conn, "protocol_tasks"):
+        conn.close()
+        return
+
+    rows = conn.execute(
+        """SELECT goal, area, learning_id, followup_id
+           FROM protocol_tasks
+           WHERE opened_at >= datetime('now', '-30 days')
+             AND COALESCE(goal, '') != ''
+           ORDER BY opened_at DESC"""
+    ).fetchall()
+    if not rows:
+        conn.close()
+        return
+
+    formalized_topics: set[str] = set()
+    if _table_exists(conn, "workflow_goals"):
+        goal_rows = conn.execute(
+            """SELECT title, objective
+               FROM workflow_goals
+               WHERE status NOT IN ('abandoned', 'cancelled')"""
+        ).fetchall()
+        for row in goal_rows:
+            for candidate in (row["title"], row["objective"]):
+                signature = _topic_signature(str(candidate or ""))
+                if signature:
+                    formalized_topics.add(signature)
+
+    repeated: dict[tuple[str, str], list[sqlite3.Row]] = {}
+    for row in rows:
+        if row["learning_id"] or str(row["followup_id"] or "").strip():
+            continue
+        signature = _topic_signature(str(row["goal"] or ""))
+        if not signature or signature in formalized_topics:
+            continue
+        area = str(row["area"] or "general").strip() or "general"
+        repeated.setdefault((area, signature), []).append(row)
+
+    loose_topics = {
+        key: items
+        for key, items in repeated.items()
+        if len(items) >= 2
+    }
+    if loose_topics:
+        finding("WARN", "formalization", f"{len(loose_topics)} repeated topic(s) keep being mentioned without durable formalization")
+        for (area, signature), items in list(loose_topics.items())[:5]:
+            sample_goal = str(items[0]["goal"] or "").strip()[:120]
+            description = (
+                f"Formalize repeated unresolved theme in {area}: '{sample_goal}' "
+                f"appears {len(items)} times without a durable goal, followup, or learning."
+            )
+            reasoning = (
+                "Daily self-audit found the same theme recurring across protocol tasks without being "
+                "converted into a workflow goal, followup, or learning. Formalize it before it keeps resurfacing."
+            )
+            _ensure_followup(
+                conn,
+                prefix="FORMALIZE",
+                description=description,
+                verification="Theme converted into a durable goal, followup, or canonical learning",
+                reasoning=reasoning,
+                priority="high",
+            )
+        conn.commit()
+    conn.close()
+
+
+def check_automation_opportunities():
+    if not NEXO_DB.exists():
+        return
+    conn = sqlite3.connect(str(NEXO_DB))
+    conn.row_factory = sqlite3.Row
+    if not _table_exists(conn, "protocol_tasks"):
+        conn.close()
+        return
+
+    rows = conn.execute(
+        """SELECT goal, area, files
+           FROM protocol_tasks
+           WHERE status = 'done'
+             AND closed_at >= datetime('now', '-30 days')
+           ORDER BY closed_at DESC"""
+    ).fetchall()
+    if not rows:
+        conn.close()
+        return
+
+    grouped: dict[tuple[str, str], list[sqlite3.Row]] = {}
+    for row in rows:
+        signature = str(row["files"] or "").strip() or _topic_signature(str(row["goal"] or ""))
+        if not signature:
+            continue
+        area = str(row["area"] or "general").strip() or "general"
+        grouped.setdefault((area, signature[:220]), []).append(row)
+
+    repeated = {
+        key: items
+        for key, items in grouped.items()
+        if len(items) >= 3
+    }
+    if repeated:
+        finding("INFO", "opportunities", f"{len(repeated)} repeated manual pattern(s) are good candidates for skills/scripts")
+        for (area, signature), items in list(repeated.items())[:5]:
+            sample_goal = str(items[0]["goal"] or "").strip()[:120]
+            description = (
+                f"Extract a reusable automation for repeated {area} work around '{sample_goal}' "
+                f"(seen {len(items)} successful protocol tasks in 30 days)."
+            )
+            reasoning = (
+                "Daily self-audit found repeated successful manual work. Convert it into a skill, script, "
+                "or reusable workflow before it keeps consuming operator time."
+            )
+            _ensure_followup(
+                conn,
+                prefix="OPPORTUNITY",
+                description=description,
+                verification="A reusable skill, script, or workflow now covers the repeated manual pattern",
+                reasoning=reasoning,
+                priority="medium",
+            )
+        conn.commit()
+    conn.close()
+
+
+def check_state_watchers():
+    try:
+        import importlib
+        import db as _db
+        import state_watchers_runtime as _state_watchers_runtime
+    except Exception as exc:
+        finding("WARN", "watchers", f"state watchers runtime unavailable: {exc}")
+        return
+    importlib.reload(_db)
+    runtime = importlib.reload(_state_watchers_runtime)
+    summary = runtime.run_state_watchers(persist=True)
+    counts = summary.get("counts") or {}
+    if int(counts.get("critical") or 0) > 0:
+        finding("ERROR", "watchers", f"{counts.get('critical')} critical state watcher(s)")
+    elif int(counts.get("degraded") or 0) > 0:
+        finding("WARN", "watchers", f"{counts.get('degraded')} degraded state watcher(s)")
+    elif int(summary.get("watcher_count") or 0) > 0:
+        finding("INFO", "watchers", f"{summary.get('watcher_count')} state watcher(s) healthy")
+
+
+def check_memory_quality_scores():
+    if not NEXO_DB.exists():
+        return
+    conn = sqlite3.connect(str(NEXO_DB))
+    conn.row_factory = sqlite3.Row
+    if not _table_exists(conn, "learnings"):
+        conn.close()
+        return
+    try:
+        from tools_learnings import score_learning_quality
+    except Exception:
+        conn.close()
+        return
+
+    rows = conn.execute(
+        """SELECT *
+           FROM learnings
+           WHERE status = 'active'
+           ORDER BY updated_at DESC, id DESC
+           LIMIT 200"""
+    ).fetchall()
+    if not rows:
+        conn.close()
+        return
+
+    normalized = [dict(row) for row in rows]
+    scored = [(row, score_learning_quality(row, conn)) for row in normalized]
+    weak = [(row, quality) for row, quality in scored if quality["score"] < 60]
+    fragile_conditioned = [
+        (row, quality)
+        for row, quality in weak
+        if str(row.get("applies_to") or "").strip()
+    ]
+    if weak:
+        finding("WARN", "memory-quality", f"{len(weak)} active learning(s) have low quality scores")
+        if fragile_conditioned:
+            sample = fragile_conditioned[0][0]
+            description = (
+                f"Refresh low-quality conditioned learnings; first weak rule is #{sample['id']} "
+                f"for {sample['applies_to']}"
+            )
+        else:
+            sample = weak[0][0]
+            description = f"Refresh low-quality learnings; first weak rule is #{sample['id']} {sample['title']}"
+        _ensure_followup(
+            conn,
+            prefix="MEMQ",
+            description=description,
+            verification="Weak active learnings refreshed with stronger reasoning/prevention/applies_to coverage",
+            reasoning="Daily self-audit found active learnings with weak quality scores that may mislead retrieval or guard.",
+            priority="high" if fragile_conditioned else "medium",
+        )
+        conn.commit()
+    conn.close()
+
+
 def _sha256(path):
     return hashlib.sha256(path.read_bytes()).hexdigest()
 
@@ -435,6 +1136,131 @@ def check_cognitive_health():
             finding("WARN", "cognitive", f"Weekly GC failed: {e}")
 
 
+def check_codex_conditioned_file_discipline():
+    try:
+        from doctor.providers.runtime import _recent_codex_conditioned_file_discipline_status
+    except Exception as e:
+        finding("WARN", "codex-discipline", f"Codex discipline audit unavailable: {e}")
+        return
+
+    audit = _recent_codex_conditioned_file_discipline_status()
+    if not audit.get("conditioned_rules"):
+        return
+
+    read_violations = int(audit.get("read_without_protocol") or 0)
+    write_without_protocol = int(audit.get("write_without_protocol") or 0)
+    write_without_guard_ack = int(audit.get("write_without_guard_ack") or 0)
+    delete_without_protocol = int(audit.get("delete_without_protocol") or 0)
+    delete_without_guard_ack = int(audit.get("delete_without_guard_ack") or 0)
+    total_violations = (
+        read_violations
+        + write_without_protocol
+        + write_without_guard_ack
+        + delete_without_protocol
+        + delete_without_guard_ack
+    )
+    if total_violations <= 0:
+        return
+
+    created_debts = 0
+    if NEXO_DB.exists():
+        conn = sqlite3.connect(str(NEXO_DB))
+        if _protocol_debt_table_exists(conn):
+            debt_type_map = {
+                "read_without_protocol": ("codex_conditioned_read_without_protocol", "warn"),
+                "write_without_protocol": ("codex_conditioned_write_without_protocol", "error"),
+                "write_without_guard_ack": ("codex_conditioned_write_without_guard_ack", "error"),
+                "delete_without_protocol": ("codex_conditioned_delete_without_protocol", "error"),
+                "delete_without_guard_ack": ("codex_conditioned_delete_without_guard_ack", "error"),
+            }
+            for sample in audit.get("samples", []):
+                debt_info = debt_type_map.get(sample.get("kind"))
+                if not debt_info:
+                    continue
+                debt_type, severity = debt_info
+                evidence = (
+                    "Codex conditioned-file transcript audit: "
+                    f"{sample.get('kind')} {sample.get('file')} via {sample.get('tool')} "
+                    f"in {sample.get('session_file')}"
+                )
+                if _ensure_protocol_debt(conn, debt_type=debt_type, severity=severity, evidence=evidence):
+                    created_debts += 1
+            conn.commit()
+        conn.close()
+
+    severity = "ERROR" if (write_without_protocol or write_without_guard_ack) else "WARN"
+    message = (
+        "Codex conditioned-file discipline drift: "
+        f"{read_violations} read(s) without protocol/guard, "
+        f"{write_without_protocol} write(s) without protocol, "
+        f"{write_without_guard_ack} write(s) without guard ack, "
+        f"{delete_without_protocol} delete(s) without protocol, "
+        f"{delete_without_guard_ack} delete(s) without guard ack"
+    )
+    if created_debts:
+        message += f" | opened {created_debts} protocol debt item(s)"
+    finding(severity, "codex-discipline", message)
+
+
+def check_codex_startup_discipline():
+    try:
+        from doctor.providers.runtime import _recent_codex_session_parity_status
+    except Exception as e:
+        finding("WARN", "codex-startup", f"Codex startup audit unavailable: {e}")
+        return
+
+    audit = _recent_codex_session_parity_status()
+    if not audit.get("files"):
+        return
+
+    samples = audit.get("samples", [])
+    missing_startup = [sample for sample in samples if not sample.get("startup")]
+    missing_heartbeat = [sample for sample in samples if sample.get("startup") and not sample.get("heartbeat")]
+    missing_bootstrap = [
+        sample for sample in samples
+        if sample.get("startup") and sample.get("heartbeat") and not sample.get("bootstrap")
+    ]
+    if not missing_startup and not missing_heartbeat and not missing_bootstrap:
+        return
+
+    created_debts = 0
+    if NEXO_DB.exists():
+        conn = sqlite3.connect(str(NEXO_DB))
+        if _protocol_debt_table_exists(conn):
+            for sample in samples:
+                debt_type = ""
+                severity = "warn"
+                if not sample.get("startup"):
+                    debt_type = "codex_session_missing_startup"
+                    severity = "error"
+                elif not sample.get("heartbeat"):
+                    debt_type = "codex_session_missing_heartbeat"
+                elif not sample.get("bootstrap"):
+                    debt_type = "codex_session_missing_bootstrap"
+                if not debt_type:
+                    continue
+                evidence = (
+                    "Codex session parity audit: "
+                    f"{debt_type} in {sample.get('file')} "
+                    f"(origin={sample.get('origin') or 'unknown'})"
+                )
+                if _ensure_protocol_debt(conn, debt_type=debt_type, severity=severity, evidence=evidence):
+                    created_debts += 1
+            conn.commit()
+        conn.close()
+
+    severity = "ERROR" if missing_startup else "WARN"
+    message = (
+        "Codex startup discipline drift: "
+        f"{len(missing_bootstrap)} session(s) missing bootstrap marker, "
+        f"{len(missing_startup)} missing startup, "
+        f"{len(missing_heartbeat)} missing heartbeat"
+    )
+    if created_debts:
+        message += f" | opened {created_debts} protocol debt item(s)"
+    finding(severity, "codex-startup", message)
+
+
 # ═══════════════════════════════════════════════════════════════════════════════
 # Stage B: Interpretation (automation backend) — NEW in v2
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -533,6 +1359,15 @@ def main():
     check_repetition_rate()
     check_unused_learnings()
     check_memory_reviews()
+    check_learning_contradictions()
+    check_error_memory_loop()
+    check_repair_changes_missing_learning_capture()
+    check_unformalized_mentions()
+    check_automation_opportunities()
+    check_state_watchers()
+    check_memory_quality_scores()
+    check_codex_startup_discipline()
+    check_codex_conditioned_file_discipline()
     check_watchdog_registry()
     check_snapshot_sync()
     check_restore_activity()
@@ -547,13 +1382,16 @@ def main():
     infos = sum(1 for f in findings if f["severity"] == "INFO")
     log(f"Stage A complete: {errors} errors, {warns} warnings, {infos} info")
 
-    # Write raw summary (backward compatible)
-    summary_file = LOG_DIR / "self-audit-summary.json"
-    summary_file.write_text(json.dumps({
+    # Write raw summary (backward compatible) + horizon rollups
+    summary_payload = {
         "timestamp": datetime.now().isoformat(),
         "findings": findings,
-        "counts": {"error": errors, "warn": warns, "info": infos}
-    }, indent=2))
+        "counts": {"error": errors, "warn": warns, "info": infos},
+        "date_label": datetime.now().strftime("%Y-%m-%d"),
+    }
+    summary_file = LOG_DIR / "self-audit-summary.json"
+    summary_file.write_text(json.dumps(summary_payload, indent=2))
+    write_horizon_summaries(summary_payload)
 
     # Stage B: CLI interpretation (graceful fallback if CLI unavailable)
     cli_ok = interpret_findings(findings)