nexo-brain 7.23.2 → 7.23.4

package/src/db/_episodic.py

@@ -318,6 +318,61 @@ def cleanup_old_diaries(retention_days: int = 180) -> int:
     return cursor.rowcount
 
 
+def _diary_quality_tier(source: str = "", summary: str = "", mental_state: str = "") -> str:
+    normalized_source = (source or "").strip().lower()
+    blob = f"{summary or ''} {mental_state or ''}".lower()
+    if normalized_source in {"human", "operator", "manual"}:
+        return "human_authored"
+    if normalized_source == "auto-close":
+        if "0 heartbeats" in blob or "minimal diary" in blob or "[auto-" in blob:
+            return "auto_close_minimal"
+        return "agent_authored"
+    if normalized_source in {"cron", "automation"} or "[auto-" in blob:
+        return "fallback_minimal"
+    return "agent_authored"
+
+
+def _diary_quality_score(
+    *,
+    summary: str = "",
+    decisions: str = "",
+    pending: str = "",
+    context_next: str = "",
+    self_critique: str = "",
+    mental_state: str = "",
+    tier: str = "",
+) -> int:
+    score = 0
+    if (summary or "").strip():
+        score += 25
+    if (decisions or "").strip():
+        score += 20
+    if (pending or "").strip():
+        score += 15
+    if (context_next or "").strip():
+        score += 20
+    if (self_critique or "").strip():
+        score += 20
+    if (mental_state or "").strip():
+        score += 5
+    if tier in {"auto_close_minimal", "fallback_minimal"}:
+        score = max(0, score - 40)
+    if tier == "human_authored":
+        score += 10
+    return min(score, 100)
+
+
+def _diary_order_sql() -> str:
+    return (
+        "CASE quality_tier "
+        "WHEN 'human_authored' THEN 0 "
+        "WHEN 'agent_authored' THEN 1 "
+        "WHEN 'auto_close_minimal' THEN 2 "
+        "WHEN 'fallback_minimal' THEN 3 "
+        "ELSE 4 END, quality_score DESC, created_at DESC"
+    )
+
+
 def write_session_diary(session_id: str, decisions: str, summary: str,
                         discarded: str = '', pending: str = '',
                         context_next: str = '', mental_state: str = '',
@@ -326,10 +381,34 @@ def write_session_diary(session_id: str, decisions: str, summary: str,
     """Write a session diary entry with mental state and self-critique for continuity."""
     conn = get_db()
     cleanup_old_diaries()
+    quality_tier = _diary_quality_tier(source=source, summary=summary, mental_state=mental_state)
+    quality_score = _diary_quality_score(
+        summary=summary,
+        decisions=decisions,
+        pending=pending,
+        context_next=context_next,
+        self_critique=self_critique,
+        mental_state=mental_state,
+        tier=quality_tier,
+    )
     cursor = conn.execute(
-        "INSERT INTO session_diary (session_id, decisions, discarded, pending, context_next, mental_state, summary, domain, user_signals, self_critique, source) "
-        "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
-        (session_id, decisions, discarded, pending, context_next, mental_state, summary, domain, user_signals, self_critique, source)
+        "INSERT INTO session_diary (session_id, decisions, discarded, pending, context_next, mental_state, summary, domain, user_signals, self_critique, source, quality_tier, quality_score) "
+        "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        (
+            session_id,
+            decisions,
+            discarded,
+            pending,
+            context_next,
+            mental_state,
+            summary,
+            domain,
+            user_signals,
+            self_critique,
+            source,
+            quality_tier,
+            quality_score,
+        )
     )
     conn.commit()
     did = cursor.lastrowid
@@ -601,19 +680,19 @@ def read_session_diary(session_id: str = '', last_n: int = 3, last_day: bool = F
 
     if session_id:
         rows = conn.execute(
-            f"SELECT * FROM session_diary WHERE session_id = ?{domain_clause} ORDER BY created_at DESC",
+            f"SELECT * FROM session_diary WHERE session_id = ?{domain_clause} ORDER BY {_diary_order_sql()}",
             (session_id,) + domain_params
         ).fetchall()
     elif last_day:
         rows = conn.execute(
             f"SELECT * FROM session_diary "
             f"WHERE created_at >= datetime('now', '-36 hours'){domain_clause}{source_clause} "
-            f"ORDER BY created_at DESC",
+            f"ORDER BY {_diary_order_sql()}",
             domain_params
         ).fetchall()
     else:
         rows = conn.execute(
-            f"SELECT * FROM session_diary WHERE 1=1{domain_clause}{source_clause} ORDER BY created_at DESC LIMIT ?",
+            f"SELECT * FROM session_diary WHERE 1=1{domain_clause}{source_clause} ORDER BY {_diary_order_sql()} LIMIT ?",
             domain_params + (last_n,)
         ).fetchall()
     return [dict(r) for r in rows]
@@ -759,4 +838,3 @@ def recall(query: str, days: int = 30) -> list[dict]:
 
     results.sort(key=lambda r: r.get('created_at', ''), reverse=True)
     return results[:20]
-

package/src/db/_schema.py

@@ -2002,6 +2002,84 @@ def _m64_local_context_live_dirs(conn):
     )
 
 
+def _backfill_diary_quality(conn):
+    for table in ("session_diary", "diary_archive"):
+        conn.execute(f"""
+            UPDATE {table}
+            SET quality_tier = CASE
+                WHEN source = 'auto-close' THEN 'auto_close_minimal'
+                WHEN source IN ('cron', 'automation') OR COALESCE(summary, '') LIKE '[AUTO-%' THEN 'fallback_minimal'
+                ELSE 'agent_authored'
+            END
+            WHERE quality_tier IS NULL
+               OR quality_tier = ''
+               OR quality_tier = 'agent_authored'
+        """)
+        conn.execute(f"""
+            UPDATE {table}
+            SET quality_score =
+                CASE WHEN COALESCE(summary, '') != '' THEN 25 ELSE 0 END +
+                CASE WHEN COALESCE(decisions, '') != '' THEN 20 ELSE 0 END +
+                CASE WHEN COALESCE(pending, '') != '' THEN 15 ELSE 0 END +
+                CASE WHEN COALESCE(context_next, '') != '' THEN 20 ELSE 0 END +
+                CASE WHEN COALESCE(self_critique, '') != '' THEN 20 ELSE 0 END
+            WHERE quality_score IS NULL OR quality_score = 0
+        """)
+
+
+def _m65_diary_quality(conn):
+    _m4_session_diary_columns(conn)
+    _m7_diary_source_and_draft(conn)
+    _m10_diary_archive(conn)
+    _migrate_add_column(conn, "session_diary", "quality_tier", "TEXT DEFAULT 'agent_authored'")
+    _migrate_add_column(conn, "session_diary", "quality_score", "INTEGER DEFAULT 0")
+    _migrate_add_column(conn, "diary_archive", "quality_tier", "TEXT DEFAULT 'agent_authored'")
+    _migrate_add_column(conn, "diary_archive", "quality_score", "INTEGER DEFAULT 0")
+    _backfill_diary_quality(conn)
+    _migrate_add_index(conn, "idx_session_diary_quality", "session_diary", "quality_tier, quality_score, created_at")
+    _migrate_add_index(conn, "idx_diary_archive_quality", "diary_archive", "quality_tier, quality_score, created_at")
+
+
+def _m66_transcript_index(conn):
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS transcript_index (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            source_client TEXT NOT NULL,
+            conversation_id TEXT DEFAULT '',
+            session_id TEXT DEFAULT '',
+            message_count INTEGER DEFAULT 0,
+            user_message_count INTEGER DEFAULT 0,
+            first_user_at TEXT DEFAULT '',
+            last_user_at TEXT DEFAULT '',
+            path_ref TEXT NOT NULL,
+            display_name TEXT DEFAULT '',
+            indexed_at TEXT DEFAULT (datetime('now')),
+            modified_at TEXT DEFAULT '',
+            content_hash TEXT NOT NULL,
+            sanitized_summary TEXT DEFAULT '',
+            metadata_json TEXT DEFAULT '{}',
+            UNIQUE(source_client, path_ref)
+        )
+    """)
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_transcript_index_client_modified ON transcript_index(source_client, modified_at)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_transcript_index_session ON transcript_index(session_id)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_transcript_index_conversation ON transcript_index(conversation_id)")
+
+
+def _m67_diary_quality_backfill_repair(conn):
+    """Repair DBs that already ran the original m65 default-only backfill."""
+    _m4_session_diary_columns(conn)
+    _m7_diary_source_and_draft(conn)
+    _m10_diary_archive(conn)
+    _migrate_add_column(conn, "session_diary", "quality_tier", "TEXT DEFAULT 'agent_authored'")
+    _migrate_add_column(conn, "session_diary", "quality_score", "INTEGER DEFAULT 0")
+    _migrate_add_column(conn, "diary_archive", "quality_tier", "TEXT DEFAULT 'agent_authored'")
+    _migrate_add_column(conn, "diary_archive", "quality_score", "INTEGER DEFAULT 0")
+    _backfill_diary_quality(conn)
+    _migrate_add_index(conn, "idx_session_diary_quality", "session_diary", "quality_tier, quality_score, created_at")
+    _migrate_add_index(conn, "idx_diary_archive_quality", "diary_archive", "quality_tier, quality_score, created_at")
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -2067,6 +2145,9 @@ MIGRATIONS = [
     (62, "memory_observations_fts_trigger_fix", _m62_memory_observations_fts_trigger_fix),
     (63, "local_context_layer", _m63_local_context_layer),
     (64, "local_context_live_dirs", _m64_local_context_live_dirs),
+    (65, "diary_quality", _m65_diary_quality),
+    (66, "transcript_index", _m66_transcript_index),
+    (67, "diary_quality_backfill_repair", _m67_diary_quality_backfill_repair),
 ]
 
 

package/src/db/_skills.py

@@ -568,9 +568,7 @@ def retire_superseded_personal_skills(*, dry_run: bool = False) -> dict:
             continue
 
         if backup_root is None:
-            timestamp = datetime.datetime.now().strftime("%Y-%m-%d-%H%M%S")
-            backup_root = paths.backups_dir() / f"retired-personal-skills-{timestamp}"
-            backup_root.mkdir(parents=True, exist_ok=True)
+            backup_root = paths.create_backup_dir("retired-personal-skills")
         target = backup_root / child.name
         suffix = 2
         while target.exists():
@@ -588,6 +586,8 @@ def retire_superseded_personal_skills(*, dry_run: bool = False) -> dict:
             })
         except Exception as exc:
             report["errors"].append({"path": str(child), "error": str(exc)})
+    if backup_root is not None:
+        paths.finalize_backup_snapshot(backup_root)
     return report
 
 

package/src/disk_recovery/__init__.py

@@ -0,0 +1,11 @@
+"""Post-disk-recovery self-heal hooks."""
+
+from .registry import RecoveryContext, RecoveryRegistry, RecoveryResult, build_default_registry, run_sweep
+
+__all__ = [
+    "RecoveryContext",
+    "RecoveryRegistry",
+    "RecoveryResult",
+    "build_default_registry",
+    "run_sweep",
+]

package/src/disk_recovery/handlers/__init__.py

@@ -0,0 +1 @@
+"""Platform handlers for disk recovery sweeps."""

package/src/disk_recovery/handlers/common.py

@@ -0,0 +1,37 @@
+"""Common app restart handlers used after disk pressure is relieved."""
+from __future__ import annotations
+
+from disk_recovery.registry import RecoveryContext, RecoveryRegistry, RecoveryResult
+
+
+def _has_process(ctx: RecoveryContext, *needles: str) -> bool:
+    lowered = {name.lower() for name in ctx.processes}
+    return any(needle.lower() in lowered for needle in needles)
+
+
+def _commands_for(ctx: RecoveryContext, app: str) -> list[list[str]]:
+    if ctx.platform == "darwin":
+        return [["killall", app], ["open", "-a", app]]
+    exe = f"{app}.exe" if not app.lower().endswith(".exe") else app
+    return [
+        ["taskkill", "/IM", exe, "/F"],
+        ["powershell", "-NoProfile", "-Command", f"Start-Process '{app}'"],
+    ]
+
+
+def _restart_if_running(ctx: RecoveryContext, app: str, *process_names: str) -> RecoveryResult:
+    if not _has_process(ctx, *process_names):
+        return RecoveryResult(app=app, touched=False, detail="not_running")
+    commands = _commands_for(ctx, app)
+    errors: list[str] = []
+    for command in commands:
+        result = ctx.run(command)
+        if not result.get("ok"):
+            errors.append(str(result.get("error") or result.get("stderr") or "command_failed"))
+    return RecoveryResult(app=app, touched=True, commands=commands, errors=errors)
+
+
+def register_common_handlers(registry: RecoveryRegistry) -> None:
+    registry.register("dropbox", {"darwin", "windows"}, lambda ctx: _restart_if_running(ctx, "Dropbox", "dropbox", "dropbox.exe"))
+    registry.register("google_drive", {"darwin", "windows"}, lambda ctx: _restart_if_running(ctx, "Google Drive", "google drive", "googledrivefs", "googledrivefs.exe"))
+    registry.register("slack", {"darwin", "windows"}, lambda ctx: _restart_if_running(ctx, "Slack", "slack", "slack.exe"))

package/src/disk_recovery/handlers/macos.py

@@ -0,0 +1,39 @@
+"""macOS sync handlers for post-disk-recovery sweep."""
+from __future__ import annotations
+
+from disk_recovery.registry import RecoveryContext, RecoveryRegistry, RecoveryResult
+
+
+def _run_commands(ctx: RecoveryContext, app: str, commands: list[list[str]]) -> RecoveryResult:
+    errors: list[str] = []
+    for command in commands:
+        result = ctx.run(command)
+        if not result.get("ok"):
+            errors.append(str(result.get("error") or result.get("stderr") or "command_failed"))
+    return RecoveryResult(app=app, touched=True, commands=commands, errors=errors)
+
+
+def calendar_mail_handler(ctx: RecoveryContext) -> RecoveryResult:
+    commands = [
+        ["killall", "CalendarAgent"],
+        ["killall", "Calendar"],
+        ["osascript", "-e", 'tell application "Mail" to check for new mail'],
+    ]
+    return _run_commands(ctx, "macos_calendar_mail", commands)
+
+
+def icloud_handler(ctx: RecoveryContext) -> RecoveryResult:
+    commands: list[list[str]] = []
+    processes = {name.lower() for name in ctx.processes}
+    if "cloudd" in processes:
+        commands.append(["killall", "cloudd"])
+    if "bird" in processes:
+        commands.append(["killall", "bird"])
+    if not commands:
+        return RecoveryResult(app="icloud_drive", touched=False, detail="not_running")
+    return _run_commands(ctx, "icloud_drive", commands)
+
+
+def register_macos_handlers(registry: RecoveryRegistry) -> None:
+    registry.register("macos_calendar_mail", {"darwin"}, calendar_mail_handler)
+    registry.register("icloud_drive", {"darwin"}, icloud_handler)

package/src/disk_recovery/handlers/windows.py

@@ -0,0 +1,49 @@
+"""Windows sync handlers for post-disk-recovery sweep."""
+from __future__ import annotations
+
+from disk_recovery.registry import RecoveryContext, RecoveryRegistry, RecoveryResult
+
+
+def _run_commands(ctx: RecoveryContext, app: str, commands: list[list[str]]) -> RecoveryResult:
+    errors: list[str] = []
+    for command in commands:
+        result = ctx.run(command)
+        if not result.get("ok"):
+            errors.append(str(result.get("error") or result.get("stderr") or "command_failed"))
+    return RecoveryResult(app=app, touched=True, commands=commands, errors=errors)
+
+
+def onesync_handler(ctx: RecoveryContext) -> RecoveryResult:
+    commands = [
+        ["powershell", "-NoProfile", "-Command", "Get-Service OneSyncSvc* | Restart-Service -Force"],
+    ]
+    return _run_commands(ctx, "windows_onesync", commands)
+
+
+def outlook_handler(ctx: RecoveryContext) -> RecoveryResult:
+    commands = [[
+        "powershell",
+        "-NoProfile",
+        "-Command",
+        "$o = New-Object -ComObject Outlook.Application; $o.Session.SendAndReceive($false)",
+    ]]
+    return _run_commands(ctx, "outlook_send_receive", commands)
+
+
+def onedrive_handler(ctx: RecoveryContext) -> RecoveryResult:
+    processes = {name.lower() for name in ctx.processes}
+    if "onedrive.exe" not in processes and "onedrive" not in processes:
+        return RecoveryResult(app="onedrive", touched=False, detail="not_running")
+    local = ctx.env.get("LOCALAPPDATA", r"%LOCALAPPDATA%")
+    exe = local + r"\Microsoft\OneDrive\OneDrive.exe"
+    commands = [
+        [exe, "/shutdown"],
+        ["powershell", "-NoProfile", "-Command", f"Start-Process '{exe}'"],
+    ]
+    return _run_commands(ctx, "onedrive", commands)
+
+
+def register_windows_handlers(registry: RecoveryRegistry) -> None:
+    registry.register("windows_onesync", {"windows"}, onesync_handler)
+    registry.register("outlook_send_receive", {"windows"}, outlook_handler)
+    registry.register("onedrive", {"windows"}, onedrive_handler)

package/src/disk_recovery/registry.py

@@ -0,0 +1,135 @@
+"""Extensible registry for post-disk-recovery app sync nudges."""
+from __future__ import annotations
+
+import os
+import platform as platform_module
+import subprocess
+from dataclasses import asdict, dataclass, field
+from typing import Callable
+
+
+Runner = Callable[[list[str]], dict]
+Handler = Callable[["RecoveryContext"], "RecoveryResult"]
+
+
+@dataclass
+class RecoveryContext:
+    platform: str
+    processes: set[str] = field(default_factory=set)
+    dry_run: bool = False
+    env: dict[str, str] = field(default_factory=lambda: dict(os.environ))
+    runner: Runner | None = None
+
+    def run(self, command: list[str]) -> dict:
+        if self.dry_run:
+            return {"ok": True, "dry_run": True, "command": command}
+        runner = self.runner or default_runner
+        return runner(command)
+
+
+@dataclass
+class RecoveryResult:
+    app: str
+    touched: bool
+    commands: list[list[str]] = field(default_factory=list)
+    errors: list[str] = field(default_factory=list)
+    detail: str = ""
+
+
+def default_runner(command: list[str]) -> dict:
+    try:
+        proc = subprocess.run(command, capture_output=True, text=True, timeout=20)
+        return {
+            "ok": proc.returncode == 0,
+            "returncode": proc.returncode,
+            "stdout": proc.stdout[-1000:],
+            "stderr": proc.stderr[-1000:],
+            "command": command,
+        }
+    except Exception as exc:
+        return {"ok": False, "error": str(exc), "command": command}
+
+
+def default_processes(system: str | None = None) -> set[str]:
+    system = (system or platform_module.system()).lower()
+    command = ["tasklist"] if system == "windows" else ["ps", "-axo", "comm="]
+    try:
+        proc = subprocess.run(command, capture_output=True, text=True, timeout=5)
+    except Exception:
+        return set()
+    names: set[str] = set()
+    for raw in proc.stdout.splitlines():
+        name = _process_name_from_line(raw, windows=system == "windows")
+        if not name:
+            continue
+        names.add(name)
+    return names
+
+
+def _process_name_from_line(raw: str, *, windows: bool) -> str:
+    line = str(raw or "").strip()
+    if not line:
+        return ""
+    if not windows:
+        return line.strip('"').rsplit("/", 1)[-1].lower()
+    lower = line.lower()
+    if lower.startswith("image name") or lower.startswith("="):
+        return ""
+    if line.startswith('"') and "," in line:
+        return line.split(",", 1)[0].strip().strip('"').lower()
+    return line.split(None, 1)[0].strip().strip('"').lower()
+
+
+class RecoveryRegistry:
+    def __init__(self) -> None:
+        self._handlers: list[tuple[str, set[str], Handler]] = []
+
+    def register(self, name: str, platforms: set[str], handler: Handler) -> None:
+        self._handlers.append((name, {p.lower() for p in platforms}, handler))
+
+    def run(
+        self,
+        *,
+        platform: str | None = None,
+        processes: set[str] | None = None,
+        dry_run: bool = False,
+        runner: Runner | None = None,
+        env: dict[str, str] | None = None,
+    ) -> dict:
+        system = (platform or platform_module.system()).lower()
+        ctx = RecoveryContext(
+            platform=system,
+            processes=processes if processes is not None else default_processes(system),
+            dry_run=dry_run,
+            env=env or dict(os.environ),
+            runner=runner,
+        )
+        results: list[RecoveryResult] = []
+        for _name, platforms, handler in self._handlers:
+            if "all" not in platforms and system not in platforms:
+                continue
+            results.append(handler(ctx))
+        touched = [result.app for result in results if result.touched]
+        return {
+            "ok": not any(result.errors for result in results),
+            "platform": system,
+            "dry_run": dry_run,
+            "touched_apps": touched,
+            "results": [asdict(result) for result in results],
+        }
+
+
+def build_default_registry() -> RecoveryRegistry:
+    from .handlers.common import register_common_handlers
+    from .handlers.macos import register_macos_handlers
+    from .handlers.windows import register_windows_handlers
+
+    registry = RecoveryRegistry()
+    register_common_handlers(registry)
+    register_macos_handlers(registry)
+    register_windows_handlers(registry)
+    return registry
+
+
+def run_sweep(**kwargs) -> dict:
+    return build_default_registry().run(**kwargs)