nexo-brain 5.3.20 → 5.3.21

package/src/scripts/nexo-impact-scorer 2.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+"""NEXO Impact Scorer — recalculate followup impact scores for real queues."""
+
+import json
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+_script_dir = Path(__file__).resolve().parent
+_repo_src = _script_dir.parent
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(_repo_src) if (_repo_src / "server.py").exists() else str(NEXO_HOME)))
+if str(NEXO_CODE) not in sys.path:
+    sys.path.insert(0, str(NEXO_CODE))
+
+import db as nexo_db
+
+LOG_FILE = NEXO_HOME / "logs" / "impact-scorer.log"
+SUMMARY_FILE = NEXO_HOME / "coordination" / "impact-scorer-summary.json"
+
+
+def log(message: str):
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    line = f"[{ts}] {message}"
+    print(line, flush=True)
+    LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+    with open(LOG_FILE, "a") as handle:
+        handle.write(line + "\n")
+
+
+def _active_followup_scores() -> dict[str, float]:
+    conn = nexo_db.get_db()
+    rows = conn.execute(
+        """SELECT id, impact_score FROM followups
+           WHERE status IN ('PENDING', 'ACTIVE', 'WAITING', 'BLOCKED')"""
+    ).fetchall()
+    return {str(row["id"]): float(row["impact_score"] or 0.0) for row in rows}
+
+
+def _reasoning_for(row: dict) -> str:
+    factors = row.get("impact_factors") or {}
+    if isinstance(factors, str):
+        try:
+            factors = json.loads(factors)
+        except json.JSONDecodeError:
+            factors = {}
+    if isinstance(factors, dict):
+        return str(factors.get("reasoning") or "").strip()
+    return ""
+
+
+def main() -> int:
+    log("=== Impact Scorer starting ===")
+    nexo_db.init_db()
+    previous_scores = _active_followup_scores()
+    scored = nexo_db.score_active_followups(limit=500)
+    top = [
+        {
+            "id": row.get("id"),
+            "date": row.get("date"),
+            "priority": row.get("priority"),
+            "impact_score": row.get("impact_score", 0),
+            "impact_factors": row.get("impact_factors") or {},
+            "impact_reasoning": _reasoning_for(row),
+        }
+        for row in scored[:5]
+    ]
+    top_changes = sorted(
+        [
+            {
+                "id": row.get("id"),
+                "priority": row.get("priority"),
+                "date": row.get("date"),
+                "impact_score": row.get("impact_score", 0),
+                "previous_score": previous_scores.get(str(row.get("id")), 0.0),
+                "delta": round(float(row.get("impact_score") or 0.0) - previous_scores.get(str(row.get("id")), 0.0), 2),
+                "impact_reasoning": _reasoning_for(row),
+            }
+            for row in scored
+        ],
+        key=lambda item: (abs(float(item["delta"])), float(item["impact_score"] or 0.0)),
+        reverse=True,
+    )[:5]
+    summary = {
+        "scored_at": datetime.now().isoformat(timespec="seconds"),
+        "scored_count": len(scored),
+        "top_followups": top,
+        "top_changes": top_changes,
+    }
+    SUMMARY_FILE.parent.mkdir(parents=True, exist_ok=True)
+    SUMMARY_FILE.write_text(json.dumps(summary, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    log(f"Scored {len(scored)} active followups.")
+    for item in top:
+        log(
+            f"Top -> {item['id']} score={item['impact_score']} "
+            f"priority={item['priority']} date={item['date'] or '—'} "
+            f"because={item['impact_reasoning'] or 'no reasoning'}"
+        )
+    changed = [item for item in top_changes if abs(float(item["delta"])) >= 1.0]
+    if changed:
+        log("Strong top-5 changes:")
+        for item in changed:
+            direction = "+" if float(item["delta"]) >= 0 else ""
+            log(
+                f"  Δ {item['id']} {direction}{item['delta']:.2f} -> {item['impact_score']:.2f} "
+                f"priority={item['priority']} because={item['impact_reasoning'] or 'no reasoning'}"
+            )
+    else:
+        log("Strong top-5 changes: none")
+    log("=== Impact Scorer complete ===")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src/scripts/nexo-inbox-hook 2.sh

@@ -0,0 +1,74 @@
+#!/bin/bash
+# nexo-inbox-hook.sh — PostToolUse: automatic inter-terminal inbox check (D+)
+#
+# Zero output when no messages = zero tokens consumed in Claude's context.
+# Reads SQLite directly (no MCP overhead). Write-only: INSERT OR IGNORE for mark-as-read.
+# Debounce: skips if last check was <2 seconds ago.
+
+INPUT=$(cat)
+
+# 1. Skip read-only tools (same logic as capture-tool-logs.sh)
+TOOL_NAME=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('tool_name',''))" 2>/dev/null)
+case "$TOOL_NAME" in
+    Read|Grep|Glob|LS|Skill|ToolSearch|Agent) exit 0 ;;
+esac
+
+# 2. Extract Claude Code session_id
+CLAUDE_SID=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('session_id',''))" 2>/dev/null)
+[ -z "$CLAUDE_SID" ] && exit 0
+
+# 3. Debounce: skip if last check <2s ago
+DEBOUNCE_FILE="/tmp/nexo-inbox-ts-${CLAUDE_SID}"
+NOW=$(date +%s)
+LAST=$(cat "$DEBOUNCE_FILE" 2>/dev/null || echo 0)
+DIFF=$((NOW - LAST))
+[ "$DIFF" -lt 2 ] && exit 0
+echo "$NOW" > "$DEBOUNCE_FILE"
+
+# 4. Find NEXO SID mapped to this Claude session_id
+NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
+DB="$NEXO_HOME/data/nexo.db"
+[ -f "$DB" ] || exit 0
+
+NEXO_SID=$(sqlite3 "$DB" "SELECT sid FROM sessions WHERE (external_session_id = '${CLAUDE_SID}' OR claude_session_id = '${CLAUDE_SID}') AND last_update_epoch > (strftime('%s','now') - 900) ORDER BY last_update_epoch DESC LIMIT 1;" 2>/dev/null)
+[ -z "$NEXO_SID" ] && exit 0
+
+# 5. Check inbox — messages addressed to this session or broadcast
+MESSAGES=$(sqlite3 -separator '|' "$DB" "
+    SELECT m.id, m.from_sid, m.text FROM messages m
+    WHERE (m.to_sid = 'all' OR m.to_sid = '${NEXO_SID}')
+    AND m.from_sid != '${NEXO_SID}'
+    AND m.id NOT IN (SELECT message_id FROM message_reads WHERE sid = '${NEXO_SID}')
+    LIMIT 5;
+" 2>/dev/null)
+
+# 6. Check pending questions
+QUESTIONS=$(sqlite3 -separator '|' "$DB" "
+    SELECT qid, from_sid, question FROM questions
+    WHERE to_sid = '${NEXO_SID}' AND answer IS NULL
+    LIMIT 3;
+" 2>/dev/null)
+
+# 7. If empty → silent exit (0 tokens consumed)
+[ -z "$MESSAGES" ] && [ -z "$QUESTIONS" ] && exit 0
+
+# 8. Format and output (injected into Claude's context)
+echo ""
+echo "📨 INTER-TERMINAL MESSAGE (auto-detected):"
+
+if [ -n "$MESSAGES" ]; then
+    echo "$MESSAGES" | while IFS='|' read -r mid from text; do
+        echo "  [$from]: $text"
+        # Mark as read (lightweight INSERT, WAL mode, no lock contention)
+        sqlite3 "$DB" "INSERT OR IGNORE INTO message_reads (message_id, sid) VALUES ('${mid}', '${NEXO_SID}');" 2>/dev/null
+    done
+fi
+
+if [ -n "$QUESTIONS" ]; then
+    echo "  ⚠ PREGUNTAS de otra terminal — responder con nexo_answer:"
+    echo "$QUESTIONS" | while IFS='|' read -r qid from question; do
+        echo "  Q[$qid] de [$from]: $question"
+    done
+fi
+
+exit 0

package/src/scripts/nexo-install 2.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python3
+"""DEPRECATED: Use 'npx nexo-brain' instead. This installer is no longer maintained."""
+import sys
+print("This installer is deprecated. Please use: npx nexo-brain")
+print("See: https://github.com/wazionapps/nexo#installation")
+sys.exit(1)

package/src/scripts/nexo-learning-housekeep 2.py

@@ -0,0 +1,401 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+"""NEXO Learning Housekeeping — Nightly dedup, weight adjustment, and review.
+
+Runs daily. Adjusts learning weights based on usage (guard_hits),
+detects duplicates via semantic similarity, and archives stale learnings.
+"""
+
+import json
+import os
+import sqlite3
+import sys
+import time
+from datetime import datetime, timedelta
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+# Auto-detect: if running from repo (src/scripts/), use src/ as NEXO_CODE
+_script_dir = Path(__file__).resolve().parent
+_repo_src = _script_dir.parent  # src/scripts/ -> src/
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(_repo_src) if (_repo_src / "server.py").exists() else str(NEXO_HOME)))
+
+sys.path.insert(0, str(NEXO_CODE))
+
+DB_PATH = NEXO_HOME / "data" / "nexo.db"
+STATE_FILE = NEXO_HOME / "operations" / ".catchup-state.json"
+
+# Weight adjustment rates
+GUARD_HIT_BOOST = 0.02       # per guard hit since last run
+DECAY_RATE = 0.005            # daily decay for unused learnings
+MIN_WEIGHT = 0.05
+MAX_WEIGHT = 1.0
+DEDUP_THRESHOLD = 0.85        # cosine similarity for duplicate detection
+ARCHIVE_AFTER_DAYS = 90       # archive if weight < 0.1 and no hits in this many days
+REVIEW_EXTEND_DAYS = 30       # extend review_due by this many days when confirming
+
+
+def get_db():
+    conn = sqlite3.connect(str(DB_PATH))
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def update_catchup_state():
+    try:
+        state = json.loads(STATE_FILE.read_text()) if STATE_FILE.exists() else {}
+    except Exception:
+        state = {}
+    state["learning-housekeep"] = datetime.now().isoformat()
+    STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    STATE_FILE.write_text(json.dumps(state, indent=2))
+
+
+def adjust_weights(conn):
+    """Boost weight for frequently-used learnings, decay unused ones."""
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    now = time.time()
+    one_day_ago = now - 86400
+
+    learnings = conn.execute(
+        "SELECT id, weight, guard_hits, last_guard_hit_at, priority, created_at "
+        "FROM learnings WHERE status = 'active'"
+    ).fetchall()
+
+    adjusted = 0
+    for l in learnings:
+        old_weight = l["weight"] or 0.5
+        hits = l["guard_hits"] or 0
+        last_hit = l["last_guard_hit_at"] or 0
+        priority = l["priority"] or "medium"
+
+        # Priority floor — critical learnings never drop below 0.5
+        priority_floor = {"critical": 0.5, "high": 0.3, "medium": 0.1, "low": 0.05}.get(priority, 0.1)
+
+        new_weight = old_weight
+
+        if last_hit > one_day_ago:
+            # Recent guard hit — boost
+            recent_hits = 1  # Simplified: at least 1 hit today
+            new_weight = min(MAX_WEIGHT, old_weight + (GUARD_HIT_BOOST * recent_hits))
+        else:
+            # No recent hits — decay
+            new_weight = max(priority_floor, old_weight - DECAY_RATE)
+
+        new_weight = max(MIN_WEIGHT, min(MAX_WEIGHT, new_weight))
+
+        if abs(new_weight - old_weight) > 0.001:
+            conn.execute("UPDATE learnings SET weight = ? WHERE id = ?", (round(new_weight, 4), l["id"]))
+            adjusted += 1
+
+    conn.commit()
+    print(f"[{ts}] Weight adjustment: {adjusted}/{len(learnings)} learnings adjusted")
+    return adjusted
+
+
+def auto_prioritize(conn):
+    """Auto-upgrade priority based on guard hits and repetitions."""
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    # Learnings with 10+ guard hits that are still medium → upgrade to high
+    upgraded = conn.execute(
+        "UPDATE learnings SET priority = 'high', weight = MAX(weight, 0.7) "
+        "WHERE status = 'active' AND priority = 'medium' AND guard_hits >= 10"
+    ).rowcount
+
+    # Learnings with repetitions (same error happened again) → upgrade to high
+    repeated = conn.execute(
+        """UPDATE learnings SET priority = 'high', weight = MAX(weight, 0.7)
+           WHERE status = 'active' AND priority IN ('medium', 'low')
+           AND id IN (SELECT original_learning_id FROM error_repetitions)"""
+    ).rowcount
+
+    conn.commit()
+    total = upgraded + repeated
+    if total > 0:
+        print(f"[{ts}] Auto-prioritize: {upgraded} by guard_hits, {repeated} by repetitions")
+    return total
+
+
+def detect_duplicates(conn):
+    """Find semantically similar learnings using fastembed."""
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    try:
+        from fastembed import TextEmbedding
+        import numpy as np
+    except ImportError:
+        print(f"[{ts}] Dedup skipped: fastembed not available")
+        return []
+
+    learnings = conn.execute(
+        "SELECT id, title, content, weight, guard_hits FROM learnings WHERE status = 'active'"
+    ).fetchall()
+
+    if len(learnings) < 2:
+        return []
+
+    model = TextEmbedding("BAAI/bge-base-en-v1.5")
+    texts = [f"{l['title']}: {l['content'][:300]}" for l in learnings]
+    embeddings = list(model.embed(texts))
+    embeddings = np.array(embeddings)
+
+    # Normalize
+    norms = np.linalg.norm(embeddings, axis=1, keepdims=True)
+    norms[norms == 0] = 1
+    embeddings = embeddings / norms
+
+    duplicates = []
+    for i in range(len(learnings)):
+        for j in range(i + 1, len(learnings)):
+            sim = float(np.dot(embeddings[i], embeddings[j]))
+            if sim >= DEDUP_THRESHOLD:
+                # Keep the one with higher weight/hits
+                a, b = learnings[i], learnings[j]
+                score_a = (a["weight"] or 0.5) + (a["guard_hits"] or 0) * 0.01
+                score_b = (b["weight"] or 0.5) + (b["guard_hits"] or 0) * 0.01
+                keep, drop = (a, b) if score_a >= score_b else (b, a)
+                duplicates.append({
+                    "keep_id": keep["id"], "keep_title": keep["title"],
+                    "drop_id": drop["id"], "drop_title": drop["title"],
+                    "similarity": round(sim, 3)
+                })
+
+    if duplicates:
+        print(f"[{ts}] Duplicates found: {len(duplicates)} pairs (>= {DEDUP_THRESHOLD})")
+        for d in duplicates[:10]:
+            print(f"[{ts}]   [{d['similarity']}] keep #{d['keep_id']} '{d['keep_title'][:40]}', archive #{d['drop_id']} '{d['drop_title'][:40]}'")
+            # Archive the duplicate (don't delete — just mark inactive)
+            conn.execute("UPDATE learnings SET status = 'archived' WHERE id = ?", (d["drop_id"],))
+        conn.commit()
+    else:
+        print(f"[{ts}] No duplicates found ({len(learnings)} learnings scanned)")
+
+    return duplicates
+
+
+def archive_stale(conn):
+    """Archive learnings with very low weight and no recent guard hits."""
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    cutoff = time.time() - (ARCHIVE_AFTER_DAYS * 86400)
+
+    stale = conn.execute(
+        "SELECT id, title, weight, last_guard_hit_at FROM learnings "
+        "WHERE status = 'active' AND weight < 0.1 AND priority NOT IN ('critical', 'high') "
+        "AND (last_guard_hit_at IS NULL OR last_guard_hit_at < ?)",
+        (cutoff,)
+    ).fetchall()
+
+    if stale:
+        for s in stale:
+            conn.execute("UPDATE learnings SET status = 'archived' WHERE id = ?", (s["id"],))
+            print(f"[{ts}]   Archived #{s['id']} '{s['title'][:50]}' (weight={s['weight']:.2f})")
+        conn.commit()
+        print(f"[{ts}] Archived {len(stale)} stale learnings")
+    else:
+        print(f"[{ts}] No stale learnings to archive")
+
+    return len(stale)
+
+
+def _reconcile_decision_outcome(conn, decision_id: int, decision_text: str) -> str | None:
+    """Try to find evidence of a decision's outcome in diaries, followups, and change_log.
+
+    Returns outcome text if found, None otherwise.
+    """
+    # Extract keywords from the decision for matching
+    keywords = [w for w in decision_text.lower().split() if len(w) > 4][:5]
+    if not keywords:
+        return None
+
+    like_clauses = " OR ".join(f"summary LIKE ?" for _ in keywords)
+    like_params = [f"%{kw}%" for kw in keywords]
+
+    # Check session diaries for evidence
+    diary_match = conn.execute(
+        f"SELECT summary FROM session_diary WHERE ({like_clauses}) "
+        "AND created_at > (SELECT created_at FROM decisions WHERE id = ?) "
+        "ORDER BY created_at DESC LIMIT 1",
+        like_params + [decision_id]
+    ).fetchone()
+    if diary_match:
+        return f"[auto-reconciled from diary] {diary_match['summary'][:200]}"
+
+    # Check completed followups
+    like_clauses_f = " OR ".join(f"description LIKE ?" for _ in keywords)
+    followup_match = conn.execute(
+        f"SELECT description, verification FROM followups WHERE status = 'COMPLETED' "
+        f"AND ({like_clauses_f}) ORDER BY date DESC LIMIT 1",
+        like_params
+    ).fetchone()
+    if followup_match:
+        result = followup_match['verification'] or followup_match['description']
+        return f"[auto-reconciled from followup] {result[:200]}"
+
+    # Check change_log (schema: what_changed, why, commit_ref, affects)
+    like_clauses_c = " OR ".join(f"what_changed LIKE ?" for _ in keywords)
+    change_match = conn.execute(
+        f"SELECT what_changed, why, commit_ref FROM change_log WHERE ({like_clauses_c}) "
+        "ORDER BY created_at DESC LIMIT 1",
+        like_params
+    ).fetchone()
+    if change_match:
+        ref = change_match['commit_ref'] or ''
+        desc = change_match['what_changed'] or change_match['why'] or ''
+        return f"[auto-reconciled from change_log] {desc[:150]} {ref}"
+
+    return None
+
+
+def process_overdue_reviews(conn):
+    """Process learnings and decisions whose review_due_at has passed.
+
+    Learnings:
+      - guard_hits > 5 since last review -> confirm (extend review_due by 30 days)
+      - guard_hits = 0 and weight < 0.3 -> archive
+      - otherwise -> extend review_due by 30 days (still useful, just not urgent)
+
+    Decisions:
+      - status = 'pending_review' and review_due_at < now -> archive if >30 days old
+    """
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    now = time.time()
+    now_iso = datetime.now().isoformat(timespec="seconds")
+
+    # --- Overdue learnings ---
+    try:
+        overdue_learnings = conn.execute(
+            "SELECT id, title, weight, guard_hits, review_due_at, last_reviewed_at "
+            "FROM learnings "
+            "WHERE review_due_at IS NOT NULL AND review_due_at <= ? AND status = 'active'",
+            (now,)
+        ).fetchall()
+    except Exception as e:
+        print(f"[{ts}] Overdue reviews: error querying learnings: {e}")
+        return 0
+
+    confirmed = 0
+    archived = 0
+    for l in overdue_learnings:
+        lid = l["id"]
+        hits = l["guard_hits"] or 0
+        weight = l["weight"] or 0.5
+        last_reviewed = l["last_reviewed_at"] or 0
+
+        if hits > 5:
+            # Active and useful -- confirm: extend review date
+            new_due = now + (REVIEW_EXTEND_DAYS * 86400)
+            conn.execute(
+                "UPDATE learnings SET review_due_at = ?, last_reviewed_at = ? WHERE id = ?",
+                (new_due, now, lid)
+            )
+            confirmed += 1
+        elif hits == 0 and weight < 0.3:
+            # Unused and low weight -- archive
+            conn.execute(
+                "UPDATE learnings SET status = 'archived' WHERE id = ?",
+                (lid,)
+            )
+            archived += 1
+            print(f"[{ts}]   Archived overdue learning #{lid} '{l['title'][:50]}' (hits=0, weight={weight:.2f})")
+        else:
+            # Middle ground -- extend review date, keep active
+            new_due = now + (REVIEW_EXTEND_DAYS * 86400)
+            conn.execute(
+                "UPDATE learnings SET review_due_at = ?, last_reviewed_at = ? WHERE id = ?",
+                (new_due, now, lid)
+            )
+            confirmed += 1
+
+    # --- Overdue decisions ---
+    decision_archived = 0
+    try:
+        cutoff_30d = (datetime.now() - timedelta(days=30)).isoformat(timespec="seconds")
+        overdue_decisions = conn.execute(
+            "SELECT id, decision, created_at FROM decisions "
+            "WHERE status = 'pending_review' AND review_due_at IS NOT NULL AND review_due_at <= ?",
+            (now_iso,)
+        ).fetchall()
+
+        for d in overdue_decisions:
+            did = d["id"]
+            created = d["created_at"] or ""
+            decision_text = d["decision"] or ""
+
+            # Try to reconcile outcome from diaries, followups, change_log
+            outcome = _reconcile_decision_outcome(conn, did, decision_text)
+            if outcome:
+                conn.execute(
+                    "UPDATE decisions SET status = 'resolved', outcome = ? WHERE id = ?",
+                    (outcome, did)
+                )
+                decision_archived += 1
+                print(f"[{ts}]   Resolved decision #{did} '{decision_text[:50]}' — outcome found in logs")
+            elif created < cutoff_30d:
+                conn.execute(
+                    "UPDATE decisions SET status = 'archived' WHERE id = ?",
+                    (did,)
+                )
+                decision_archived += 1
+                print(f"[{ts}]   Archived decision #{did} '{decision_text[:50]}' (>30d, no outcome found)")
+    except Exception as e:
+        print(f"[{ts}] Overdue reviews: error processing decisions: {e}")
+
+    conn.commit()
+    total_learnings = len(overdue_learnings) if 'overdue_learnings' in dir() else 0
+    total_decisions = len(overdue_decisions) if 'overdue_decisions' in dir() else 0
+    print(f"[{ts}] Overdue reviews: {total_learnings} learnings ({confirmed} confirmed, {archived} archived), "
+          f"{total_decisions} decisions ({decision_archived} archived)")
+    return confirmed + archived + decision_archived
+
+
+def print_summary(conn):
+    """Print summary stats."""
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    stats = conn.execute(
+        """SELECT
+            COUNT(*) as total,
+            SUM(CASE WHEN status = 'active' THEN 1 ELSE 0 END) as active,
+            SUM(CASE WHEN status = 'archived' THEN 1 ELSE 0 END) as archived,
+            SUM(CASE WHEN priority = 'critical' THEN 1 ELSE 0 END) as critical,
+            SUM(CASE WHEN priority = 'high' THEN 1 ELSE 0 END) as high,
+            SUM(CASE WHEN priority = 'medium' THEN 1 ELSE 0 END) as medium,
+            SUM(CASE WHEN priority = 'low' THEN 1 ELSE 0 END) as low,
+            printf('%.2f', AVG(CASE WHEN status = 'active' THEN weight END)) as avg_weight
+        FROM learnings"""
+    ).fetchone()
+    print(f"[{ts}] Summary: {stats['active']} active, {stats['archived']} archived | "
+          f"Priority: {stats['critical']}C {stats['high']}H {stats['medium']}M {stats['low']}L | "
+          f"Avg weight: {stats['avg_weight']}")
+
+
+def main():
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    print(f"[{ts}] Learning housekeeping starting...")
+
+    conn = get_db()
+
+    # 1. Adjust weights based on usage
+    adjust_weights(conn)
+
+    # 2. Auto-prioritize based on guard hits and repetitions
+    auto_prioritize(conn)
+
+    # 3. Detect and archive duplicates
+    detect_duplicates(conn)
+
+    # 4. Archive stale learnings
+    archive_stale(conn)
+
+    # 5. Process overdue reviews (review_due_at < now)
+    process_overdue_reviews(conn)
+
+    # 6. Summary
+    print_summary(conn)
+
+    conn.close()
+    update_catchup_state()
+    print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Done.")
+
+
+if __name__ == "__main__":
+    main()