nexo-brain 3.0.0 → 3.0.2

package/src/doctor/providers/runtime.py

@@ -12,16 +12,20 @@ import sqlite3
 import subprocess
 import sys
 import time
-import tomllib
 from pathlib import Path
 
+try:
+    import tomllib
+except ModuleNotFoundError:  # Python < 3.11
+    import tomli as tomllib
+
 from client_preferences import (
     detect_installed_clients,
     normalize_client_preferences,
     resolve_client_runtime_profile,
 )
 from cron_recovery import should_run_at_load
-from doctor.models import DoctorCheck
+from doctor.models import DoctorCheck, safe_check
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parents[2])))
@@ -402,21 +406,22 @@ def _load_active_conditioned_learnings() -> list[dict]:
         import sqlite3
 
         conn = sqlite3.connect(str(db_path), timeout=2)
-        conn.row_factory = sqlite3.Row
-        table = conn.execute(
-            "SELECT name FROM sqlite_master WHERE type='table' AND name='learnings'"
-        ).fetchone()
-        if not table:
+        try:
+            conn.row_factory = sqlite3.Row
+            table = conn.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name='learnings'"
+            ).fetchone()
+            if not table:
+                return []
+            rows = conn.execute(
+                """SELECT id, title, applies_to
+                   FROM learnings
+                   WHERE status = 'active' AND COALESCE(applies_to, '') != ''
+                   ORDER BY updated_at DESC, id DESC"""
+            ).fetchall()
+            return [dict(row) for row in rows]
+        finally:
             conn.close()
-            return []
-        rows = conn.execute(
-            """SELECT id, title, applies_to
-               FROM learnings
-               WHERE status = 'active' AND COALESCE(applies_to, '') != ''
-               ORDER BY updated_at DESC, id DESC"""
-        ).fetchall()
-        conn.close()
-        return [dict(row) for row in rows]
     except Exception:
         return []
 
@@ -591,22 +596,23 @@ def _open_protocol_debt_summary(*debt_types: str) -> dict:
 
     try:
         conn = sqlite3.connect(str(db_path), timeout=2)
-        conn.row_factory = sqlite3.Row
-        table = conn.execute(
-            "SELECT name FROM sqlite_master WHERE type='table' AND name='protocol_debt'"
-        ).fetchone()
-        if not table:
+        try:
+            conn.row_factory = sqlite3.Row
+            table = conn.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name='protocol_debt'"
+            ).fetchone()
+            if not table:
+                return summary
+            placeholders = ",".join("?" for _ in debt_types)
+            rows = conn.execute(
+                f"""SELECT debt_type, COUNT(*) AS total
+                    FROM protocol_debt
+                    WHERE status = 'open' AND debt_type IN ({placeholders})
+                    GROUP BY debt_type""",
+                tuple(debt_types),
+            ).fetchall()
+        finally:
             conn.close()
-            return summary
-        placeholders = ",".join("?" for _ in debt_types)
-        rows = conn.execute(
-            f"""SELECT debt_type, COUNT(*) AS total
-                FROM protocol_debt
-                WHERE status = 'open' AND debt_type IN ({placeholders})
-                GROUP BY debt_type""",
-            tuple(debt_types),
-        ).fetchall()
-        conn.close()
     except Exception:
         return summary
 
@@ -738,7 +744,7 @@ def _parse_timestamp(value: str) -> dt.datetime | None:
     except ValueError:
         return None
     if parsed.tzinfo is None:
-        parsed = parsed.replace(tzinfo=dt.UTC)
+        parsed = parsed.replace(tzinfo=dt.timezone.utc)
     return parsed
 
 
@@ -1168,14 +1174,16 @@ def check_stale_sessions() -> DoctorCheck:
                 summary="No DB to check sessions",
             )
         conn = sqlite3.connect(str(db_path), timeout=2)
-        conn.row_factory = sqlite3.Row
-        cutoff = time.time() - 7200
-        day_ago = time.time() - 86400
-        rows = conn.execute(
-            "SELECT COUNT(*) as cnt FROM sessions WHERE last_update_epoch < ? AND last_update_epoch > ?",
-            (cutoff, day_ago),
-        ).fetchone()
-        conn.close()
+        try:
+            conn.row_factory = sqlite3.Row
+            cutoff = time.time() - 7200
+            day_ago = time.time() - 86400
+            rows = conn.execute(
+                "SELECT COUNT(*) as cnt FROM sessions WHERE last_update_epoch < ? AND last_update_epoch > ?",
+                (cutoff, day_ago),
+            ).fetchone()
+        finally:
+            conn.close()
         count = rows["cnt"] if rows else 0
         if count > 0:
             return DoctorCheck(
@@ -1217,24 +1225,25 @@ def check_cron_freshness() -> DoctorCheck:
                 summary="No DB to check cron runs",
             )
         conn = sqlite3.connect(str(db_path), timeout=2)
-        # Check if cron_runs table exists
-        tables = conn.execute(
-            "SELECT name FROM sqlite_master WHERE type='table' AND name='cron_runs'"
-        ).fetchone()
-        if not tables:
+        try:
+            # Check if cron_runs table exists
+            tables = conn.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name='cron_runs'"
+            ).fetchone()
+            if not tables:
+                return DoctorCheck(
+                    id="runtime.cron_freshness",
+                    tier="runtime",
+                    status="healthy",
+                    severity="info",
+                    summary="No cron_runs table yet",
+                )
+            # Latest run per cron
+            rows = conn.execute(
+                "SELECT cron_id, MAX(started_at) as last_run FROM cron_runs GROUP BY cron_id"
+            ).fetchall()
+        finally:
             conn.close()
-            return DoctorCheck(
-                id="runtime.cron_freshness",
-                tier="runtime",
-                status="healthy",
-                severity="info",
-                summary="No cron_runs table yet",
-            )
-        # Latest run per cron
-        rows = conn.execute(
-            "SELECT cron_id, MAX(started_at) as last_run FROM cron_runs GROUP BY cron_id"
-        ).fetchall()
-        conn.close()
 
         stale = []
         expectations = _cron_expectations()
@@ -2163,32 +2172,36 @@ def check_protocol_compliance() -> DoctorCheck:
         db_path = NEXO_HOME / "data" / "nexo.db"
         if db_path.is_file():
             conn = sqlite3.connect(str(db_path), timeout=2)
-            conn.row_factory = sqlite3.Row
-            tables = {
-                row["name"]
-                for row in conn.execute(
-                    "SELECT name FROM sqlite_master WHERE type='table' AND name IN ('protocol_tasks', 'protocol_debt')"
-                ).fetchall()
-            }
-            if {"protocol_tasks", "protocol_debt"}.issubset(tables):
-                window = "-7 days"
-                tasks = conn.execute(
-                    """SELECT * FROM protocol_tasks
-                       WHERE opened_at >= datetime('now', ?)
-                       ORDER BY opened_at DESC""",
-                    (window,),
-                ).fetchall()
-                debt_rows = conn.execute(
-                    """SELECT severity, debt_type, COUNT(*) AS total
-                       FROM protocol_debt
-                       WHERE status = 'open' AND created_at >= datetime('now', ?)
-                       GROUP BY severity, debt_type
-                       ORDER BY total DESC, debt_type ASC""",
-                    (window,),
-                ).fetchall()
+            try:
+                conn.row_factory = sqlite3.Row
+                tables = {
+                    row["name"]
+                    for row in conn.execute(
+                        "SELECT name FROM sqlite_master WHERE type='table' AND name IN ('protocol_tasks', 'protocol_debt')"
+                    ).fetchall()
+                }
+                tasks = None
+                debt_rows = None
+                if {"protocol_tasks", "protocol_debt"}.issubset(tables):
+                    window = "-7 days"
+                    tasks = conn.execute(
+                        """SELECT * FROM protocol_tasks
+                           WHERE opened_at >= datetime('now', ?)
+                           ORDER BY opened_at DESC""",
+                        (window,),
+                    ).fetchall()
+                    debt_rows = conn.execute(
+                        """SELECT severity, debt_type, COUNT(*) AS total
+                           FROM protocol_debt
+                           WHERE status = 'open' AND created_at >= datetime('now', ?)
+                           GROUP BY severity, debt_type
+                           ORDER BY total DESC, debt_type ASC""",
+                        (window,),
+                    ).fetchall()
+            finally:
                 conn.close()
 
-                if tasks or debt_rows:
+            if tasks is not None and debt_rows is not None and (tasks or debt_rows):
                     closed_tasks = [row for row in tasks if row["status"] != "open"]
                     verify_required = [row for row in closed_tasks if row["must_verify"] and row["status"] == "done"]
                     verify_ok = [row for row in verify_required if (row["close_evidence"] or "").strip()]
@@ -2406,11 +2419,13 @@ def check_state_watchers() -> DoctorCheck:
     if db_path.is_file():
         try:
             conn = sqlite3.connect(str(db_path))
-            row = conn.execute(
-                "SELECT COUNT(*) FROM state_watchers WHERE status = 'active'"
-            ).fetchone()
-            conn.close()
-            active_watchers = int(row[0] or 0) if row else 0
+            try:
+                row = conn.execute(
+                    "SELECT COUNT(*) FROM state_watchers WHERE status = 'active'"
+                ).fetchone()
+                active_watchers = int(row[0] or 0) if row else 0
+            finally:
+                conn.close()
         except Exception:
             active_watchers = 0
 
@@ -2470,7 +2485,7 @@ def check_state_watchers() -> DoctorCheck:
             generated_dt = dt.datetime.fromisoformat(str(generated_at).replace("Z", "+00:00"))
         except Exception:
             generated_dt = None
-    if not generated_dt or (dt.datetime.now(dt.UTC) - generated_dt).total_seconds() > 36 * 3600:
+    if not generated_dt or (dt.datetime.now(dt.timezone.utc) - generated_dt).total_seconds() > 36 * 3600:
         status = "degraded"
         severity = "warn"
         repair_plan.append("Refresh state watchers daily so repo/API/expiry drift stays explicit")
@@ -2514,37 +2529,38 @@ def check_automation_telemetry(days: int = 7) -> DoctorCheck:
 
     try:
         conn = sqlite3.connect(str(db_path), timeout=2)
-        conn.row_factory = sqlite3.Row
-        table = conn.execute(
-            "SELECT name FROM sqlite_master WHERE type='table' AND name='automation_runs'"
-        ).fetchone()
-        if not table:
-            conn.close()
-            return DoctorCheck(
-                id="runtime.automation_telemetry",
-                tier="runtime",
-                status="degraded",
-                severity="warn",
-                summary="Automation telemetry schema is missing",
-                evidence=["table automation_runs not found"],
-                repair_plan=["Run NEXO migrations before trusting automation cost/parity metrics"],
-                escalation_prompt="Shared automation runs are happening without the telemetry table that release metrics depend on.",
-            )
+        try:
+            conn.row_factory = sqlite3.Row
+            table = conn.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name='automation_runs'"
+            ).fetchone()
+            if not table:
+                return DoctorCheck(
+                    id="runtime.automation_telemetry",
+                    tier="runtime",
+                    status="degraded",
+                    severity="warn",
+                    summary="Automation telemetry schema is missing",
+                    evidence=["table automation_runs not found"],
+                    repair_plan=["Run NEXO migrations before trusting automation cost/parity metrics"],
+                    escalation_prompt="Shared automation runs are happening without the telemetry table that release metrics depend on.",
+                )
 
-        row = conn.execute(
-            """
-            SELECT
-                COUNT(*) AS runs,
-                SUM(CASE WHEN (input_tokens + cached_input_tokens + output_tokens) > 0 THEN 1 ELSE 0 END) AS usage_runs,
-                SUM(CASE WHEN total_cost_usd IS NOT NULL THEN 1 ELSE 0 END) AS cost_runs,
-                SUM(CASE WHEN cost_source = 'pricing_unavailable' THEN 1 ELSE 0 END) AS pricing_gaps,
-                GROUP_CONCAT(DISTINCT backend) AS backends
-            FROM automation_runs
-            WHERE created_at >= datetime('now', ?)
-            """,
-            (f"-{days} days",),
-        ).fetchone()
-        conn.close()
+            row = conn.execute(
+                """
+                SELECT
+                    COUNT(*) AS runs,
+                    SUM(CASE WHEN (input_tokens + cached_input_tokens + output_tokens) > 0 THEN 1 ELSE 0 END) AS usage_runs,
+                    SUM(CASE WHEN total_cost_usd IS NOT NULL THEN 1 ELSE 0 END) AS cost_runs,
+                    SUM(CASE WHEN cost_source = 'pricing_unavailable' THEN 1 ELSE 0 END) AS pricing_gaps,
+                    GROUP_CONCAT(DISTINCT backend) AS backends
+                FROM automation_runs
+                WHERE created_at >= datetime('now', ?)
+                """,
+                (f"-{days} days",),
+            ).fetchone()
+        finally:
+            conn.close()
     except Exception as exc:
         return DoctorCheck(
             id="runtime.automation_telemetry",
@@ -2619,22 +2635,22 @@ def check_automation_telemetry(days: int = 7) -> DoctorCheck:
 def run_runtime_checks(fix: bool = False) -> list[DoctorCheck]:
     """Run all runtime-tier checks. Read-only by default."""
     return [
-        check_immune_status(),
-        check_watchdog_status(),
-        check_stale_sessions(),
-        check_cron_freshness(),
-        check_client_backend_preferences(),
-        check_client_bootstrap_parity(fix=fix),
-        check_codex_session_parity(),
-        check_codex_conditioned_file_discipline(),
-        check_claude_desktop_shared_brain(),
-        check_transcript_source_parity(),
-        check_client_assumption_regressions(),
-        check_protocol_compliance(),
-        check_automation_telemetry(),
-        check_state_watchers(),
-        check_release_artifact_sync(),
-        check_launchagent_integrity(fix=fix),
-        check_personal_script_registry(fix=fix),
-        check_skill_health(fix=fix),
+        safe_check(check_immune_status),
+        safe_check(check_watchdog_status),
+        safe_check(check_stale_sessions),
+        safe_check(check_cron_freshness),
+        safe_check(check_client_backend_preferences),
+        safe_check(check_client_bootstrap_parity, fix=fix),
+        safe_check(check_codex_session_parity),
+        safe_check(check_codex_conditioned_file_discipline),
+        safe_check(check_claude_desktop_shared_brain),
+        safe_check(check_transcript_source_parity),
+        safe_check(check_client_assumption_regressions),
+        safe_check(check_protocol_compliance),
+        safe_check(check_automation_telemetry),
+        safe_check(check_state_watchers),
+        safe_check(check_release_artifact_sync),
+        safe_check(check_launchagent_integrity, fix=fix),
+        safe_check(check_personal_script_registry, fix=fix),
+        safe_check(check_skill_health, fix=fix),
     ]

package/src/evolution_cycle.py

@@ -120,52 +120,54 @@ def save_objective(obj: dict):
 def get_week_data(db_path: str) -> dict:
     """Gather last 7 days of learnings, decisions, changes, diaries."""
     conn = sqlite3.connect(db_path, timeout=10)
-    conn.row_factory = sqlite3.Row
-    cutoff_epoch = time.time() - 7 * 86400
-    cutoff_date = (date.today() - timedelta(days=7)).isoformat()
-
-    data = {}
-
-    rows = conn.execute(
-        "SELECT category, title, content FROM learnings WHERE created_at > ? ORDER BY created_at DESC LIMIT 50",
-        (cutoff_epoch,)
-    ).fetchall()
-    data["learnings"] = [dict(r) for r in rows]
-
-    rows = conn.execute(
-        "SELECT domain, decision, alternatives, based_on, confidence, outcome FROM decisions "
-        "WHERE created_at > ? ORDER BY created_at DESC LIMIT 20",
-        (cutoff_date,)
-    ).fetchall()
-    data["decisions"] = [dict(r) for r in rows]
-
-    rows = conn.execute(
-        "SELECT files, what_changed, why, affects, risks FROM change_log "
-        "WHERE created_at > ? ORDER BY created_at DESC LIMIT 30",
-        (cutoff_date,)
-    ).fetchall()
-    data["changes"] = [dict(r) for r in rows]
-
-    rows = conn.execute(
-        "SELECT summary, decisions as diary_decisions, pending, mental_state, domain, user_signals "
-        "FROM session_diary WHERE created_at > ? ORDER BY created_at DESC LIMIT 20",
-        (cutoff_date,)
-    ).fetchall()
-    data["diaries"] = [dict(r) for r in rows]
-
-    rows = conn.execute(
-        "SELECT * FROM evolution_log ORDER BY id DESC LIMIT 20"
-    ).fetchall()
-    data["evolution_history"] = [dict(r) for r in rows]
-
-    rows = conn.execute(
-        "SELECT dimension, score, delta, measured_at FROM evolution_metrics "
-        "WHERE id IN (SELECT MAX(id) FROM evolution_metrics GROUP BY dimension)"
-    ).fetchall()
-    data["current_metrics"] = {r["dimension"]: dict(r) for r in rows}
-
-    conn.close()
-    return data
+    try:
+        conn.row_factory = sqlite3.Row
+        cutoff_epoch = time.time() - 7 * 86400
+        cutoff_date = (date.today() - timedelta(days=7)).isoformat()
+
+        data = {}
+
+        rows = conn.execute(
+            "SELECT category, title, content FROM learnings WHERE created_at > ? ORDER BY created_at DESC LIMIT 50",
+            (cutoff_epoch,)
+        ).fetchall()
+        data["learnings"] = [dict(r) for r in rows]
+
+        rows = conn.execute(
+            "SELECT domain, decision, alternatives, based_on, confidence, outcome FROM decisions "
+            "WHERE created_at > ? ORDER BY created_at DESC LIMIT 20",
+            (cutoff_date,)
+        ).fetchall()
+        data["decisions"] = [dict(r) for r in rows]
+
+        rows = conn.execute(
+            "SELECT files, what_changed, why, affects, risks FROM change_log "
+            "WHERE created_at > ? ORDER BY created_at DESC LIMIT 30",
+            (cutoff_date,)
+        ).fetchall()
+        data["changes"] = [dict(r) for r in rows]
+
+        rows = conn.execute(
+            "SELECT summary, decisions as diary_decisions, pending, mental_state, domain, user_signals "
+            "FROM session_diary WHERE created_at > ? ORDER BY created_at DESC LIMIT 20",
+            (cutoff_date,)
+        ).fetchall()
+        data["diaries"] = [dict(r) for r in rows]
+
+        rows = conn.execute(
+            "SELECT * FROM evolution_log ORDER BY id DESC LIMIT 20"
+        ).fetchall()
+        data["evolution_history"] = [dict(r) for r in rows]
+
+        rows = conn.execute(
+            "SELECT dimension, score, delta, measured_at FROM evolution_metrics "
+            "WHERE id IN (SELECT MAX(id) FROM evolution_metrics GROUP BY dimension)"
+        ).fetchall()
+        data["current_metrics"] = {r["dimension"]: dict(r) for r in rows}
+
+        return data
+    finally:
+        conn.close()
 
 
 def create_snapshot(files_to_backup: list) -> str:

package/src/kg_populate.py

@@ -147,25 +147,27 @@ def backfill_decisions() -> int:
 def backfill_somatic() -> int:
     """Read somatic_markers from cognitive.db → create file/area nodes with risk."""
     cdb = _cognitive_db()
-    rows = cdb.execute(
-        "SELECT target, target_type, risk_score, incident_count FROM somatic_markers"
-    ).fetchall()
-    count = 0
-    for row in rows:
-        target_type = row["target_type"] or "file"
-        node_ref = f"{target_type}:{row['target']}"
-        kg.upsert_node(
-            node_type=target_type,
-            node_ref=node_ref,
-            label=os.path.basename(row["target"]) or row["target"],
-            properties={
-                "risk_score": row["risk_score"],
-                "incident_count": row["incident_count"],
-            },
-        )
-        count += 1
-    cdb.close()
-    return count
+    try:
+        rows = cdb.execute(
+            "SELECT target, target_type, risk_score, incident_count FROM somatic_markers"
+        ).fetchall()
+        count = 0
+        for row in rows:
+            target_type = row["target_type"] or "file"
+            node_ref = f"{target_type}:{row['target']}"
+            kg.upsert_node(
+                node_type=target_type,
+                node_ref=node_ref,
+                label=os.path.basename(row["target"]) or row["target"],
+                properties={
+                    "risk_score": row["risk_score"],
+                    "incident_count": row["incident_count"],
+                },
+            )
+            count += 1
+        return count
+    finally:
+        cdb.close()
 
 
 def run_full_backfill() -> dict:

package/src/maintenance.py

@@ -1,7 +1,7 @@
 """Opportunistic maintenance — run overdue tasks on MCP startup."""
 
 import time
-from datetime import datetime
+from datetime import datetime, timezone
 from db import get_db
 
 
@@ -16,7 +16,7 @@ def check_and_run_overdue():
         if last_run:
             try:
                 last_dt = datetime.strptime(last_run, "%Y-%m-%dT%H:%M:%S")
-                hours_since = (datetime.now(datetime.timezone.utc).replace(tzinfo=None) - last_dt).total_seconds() / 3600
+                hours_since = (datetime.now(timezone.utc).replace(tzinfo=None) - last_dt).total_seconds() / 3600
                 if hours_since < interval:
                     continue
             except (ValueError, TypeError):
@@ -28,7 +28,7 @@ def check_and_run_overdue():
             conn.execute(
                 "UPDATE maintenance_schedule SET last_run_at = ?, last_duration_ms = ?, "
                 "run_count = run_count + 1 WHERE task_name = ?",
-                (datetime.now(datetime.timezone.utc).replace(tzinfo=None).strftime("%Y-%m-%dT%H:%M:%S"), duration_ms, task))
+                (datetime.now(timezone.utc).replace(tzinfo=None).strftime("%Y-%m-%dT%H:%M:%S"), duration_ms, task))
             conn.commit()
             ran.append({"task": task, "duration_ms": duration_ms})
         except Exception as e:

package/src/migrate_embeddings.py

@@ -30,15 +30,17 @@ MODELS = {
 def verify():
     """Check current embedding dimensions in the database."""
     conn = sqlite3.connect(DB_PATH)
-    for table in ["stm_memories", "ltm_memories"]:
-        count = conn.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0]
-        if count == 0:
-            print(f"  {table}: {count} rows (empty)")
-            continue
-        row = conn.execute(f"SELECT embedding FROM {table} LIMIT 1").fetchone()
-        vec = np.frombuffer(row[0], dtype=np.float32)
-        print(f"  {table}: {count} rows, embedding dim = {len(vec)}")
-    conn.close()
+    try:
+        for table in ["stm_memories", "ltm_memories"]:
+            count = conn.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0]
+            if count == 0:
+                print(f"  {table}: {count} rows (empty)")
+                continue
+            row = conn.execute(f"SELECT embedding FROM {table} LIMIT 1").fetchone()
+            vec = np.frombuffer(row[0], dtype=np.float32)
+            print(f"  {table}: {count} rows, embedding dim = {len(vec)}")
+    finally:
+        conn.close()
 
 
 def upgrade():
@@ -62,31 +64,31 @@ def upgrade():
     model = TextEmbedding(model_name)
 
     conn = sqlite3.connect(DB_PATH)
-
-    for table in ["stm_memories", "ltm_memories"]:
-        rows = conn.execute(f"SELECT id, content FROM {table}").fetchall()
-        if not rows:
-            print(f"\n{table}: empty, skipping")
-            continue
-
-        print(f"\n{table}: re-embedding {len(rows)} memories...")
-        t0 = time.time()
-
-        # Batch embed for speed
-        contents = [r[1] for r in rows]
-        ids = [r[0] for r in rows]
-
-        embeddings = list(model.embed(contents))
-
-        for mem_id, emb in zip(ids, embeddings):
-            blob = np.array(emb, dtype=np.float32).tobytes()
-            conn.execute(f"UPDATE {table} SET embedding = ? WHERE id = ?", (blob, mem_id))
-
-        conn.commit()
-        elapsed = time.time() - t0
-        print(f"  Done: {len(rows)} memories in {elapsed:.1f}s ({elapsed/len(rows)*1000:.0f}ms/memory)")
-
-    conn.close()
+    try:
+        for table in ["stm_memories", "ltm_memories"]:
+            rows = conn.execute(f"SELECT id, content FROM {table}").fetchall()
+            if not rows:
+                print(f"\n{table}: empty, skipping")
+                continue
+
+            print(f"\n{table}: re-embedding {len(rows)} memories...")
+            t0 = time.time()
+
+            # Batch embed for speed
+            contents = [r[1] for r in rows]
+            ids = [r[0] for r in rows]
+
+            embeddings = list(model.embed(contents))
+
+            for mem_id, emb in zip(ids, embeddings):
+                blob = np.array(emb, dtype=np.float32).tobytes()
+                conn.execute(f"UPDATE {table} SET embedding = ? WHERE id = ?", (blob, mem_id))
+
+            conn.commit()
+            elapsed = time.time() - t0
+            print(f"  Done: {len(rows)} memories in {elapsed:.1f}s ({elapsed/len(rows)*1000:.0f}ms/memory)")
+    finally:
+        conn.close()
 
     print("\nAfter upgrade:")
     verify()