nexo-brain 7.23.2 → 7.23.4

package/src/doctor/providers/boot.py

@@ -2,8 +2,11 @@
 from __future__ import annotations
 
 import os
+import json
 import shutil
+import subprocess
 import sys
+import time
 from pathlib import Path
 
 from doctor.models import DoctorCheck, safe_check
@@ -356,33 +359,130 @@ def check_required_dirs() -> DoctorCheck:
     )
 
 
+def _disk_recovery_state_file(paths_module) -> Path:
+    return paths_module.runtime_state_dir() / "disk-recovery-state.json"
+
+
+def _read_disk_recovery_state(paths_module) -> dict:
+    try:
+        path = _disk_recovery_state_file(paths_module)
+        if path.is_file():
+            return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        pass
+    return {}
+
+
+def _write_disk_recovery_state(paths_module, payload: dict) -> None:
+    try:
+        path = _disk_recovery_state_file(paths_module)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")
+    except Exception:
+        pass
+
+
+def _post_disk_recovery_sweep(paths_module, *, reason: str, free_bytes: int) -> dict:
+    candidates = [
+        Path(__file__).resolve().parents[2] / "scripts" / "post_disk_recovery_sweep.py",
+        paths_module.core_scripts_dir() / "post_disk_recovery_sweep.py",
+    ]
+    script = next((candidate for candidate in candidates if candidate.is_file()), None)
+    if script is None:
+        return {"ok": False, "skipped": True, "reason": "script_missing"}
+    try:
+        proc = subprocess.run(
+            [
+                sys.executable,
+                str(script),
+                "--reason",
+                reason,
+                "--json",
+                "--network-window-seconds",
+                "0",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        return {
+            "ok": proc.returncode == 0,
+            "returncode": proc.returncode,
+            "free_bytes": free_bytes,
+            "stdout": proc.stdout[-1000:],
+            "stderr": proc.stderr[-1000:],
+        }
+    except Exception as exc:
+        return {"ok": False, "error": str(exc), "free_bytes": free_bytes}
+
+
 def check_disk_space() -> DoctorCheck:
-    """Check disk free space on NEXO_HOME partition."""
+    """Check disk free space after silently purging NEXO-owned backups."""
+    import paths
+
     try:
-        usage = shutil.disk_usage(str(NEXO_HOME))
+        state = _read_disk_recovery_state(paths)
+        floor = int(paths.backup_min_free_bytes())
+        critical_floor = 1 * 1024 ** 3
+        usage_before = shutil.disk_usage(str(paths.home()))
+        cleanup_report = None
+
+        if usage_before.free < floor:
+            cleanup_report = paths.aggressive_runtime_backup_prune(
+                min_free_bytes=floor,
+                reason="doctor_boot_disk_space",
+            )
+
+        usage = shutil.disk_usage(str(paths.home()))
         free_gb = usage.free / (1024 ** 3)
         pct_free = (usage.free / usage.total) * 100
-
-        if free_gb < 1:
+        evidence = [f"Total: {usage.total / (1024**3):.0f} GB, Free: {free_gb:.1f} GB"]
+        if cleanup_report:
+            evidence.append(f"NEXO backup self-cleanup: {cleanup_report.get('steps')}")
+
+        if usage.free < floor:
+            _write_disk_recovery_state(paths, {
+                "low": True,
+                "free_bytes": int(usage.free),
+                "threshold_bytes": floor,
+                "updated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            })
+            status = "critical" if usage.free < critical_floor else "degraded"
+            severity = "error" if status == "critical" else "warn"
             return DoctorCheck(
                 id="boot.disk_space",
                 tier="boot",
-                status="critical",
-                severity="error",
-                summary=f"Very low disk space: {free_gb:.1f} GB free ({pct_free:.0f}%)",
-                evidence=[f"Total: {usage.total / (1024**3):.0f} GB, Free: {free_gb:.1f} GB"],
-                repair_plan=["Free up disk space — NEXO needs at least 1 GB for normal operation"],
-                escalation_prompt="Disk space critically low — backups and logs may fail.",
+                status=status,
+                severity=severity,
+                summary=f"Disk almost full ({free_gb:.1f} GB free). NEXO has already cleaned up its own backups. Review personal files to free space.",
+                evidence=evidence,
+                repair_plan=["Open the user folder and review personal files to free space"],
+                escalation_prompt=f"Disk almost full ({free_gb:.1f} GB free). NEXO has already cleaned up its own backups. Review personal files to free space.",
+            )
+
+        if usage_before.free < floor or state.get("low"):
+            sweep = _post_disk_recovery_sweep(
+                paths,
+                reason="doctor_disk_low_to_ok",
+                free_bytes=int(usage.free),
             )
-        elif free_gb < 5:
+            _write_disk_recovery_state(paths, {
+                "low": False,
+                "free_bytes": int(usage.free),
+                "threshold_bytes": floor,
+                "last_recovery_sweep": sweep,
+                "updated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            })
             return DoctorCheck(
                 id="boot.disk_space",
                 tier="boot",
-                status="degraded",
-                severity="warn",
-                summary=f"Low disk space: {free_gb:.1f} GB free ({pct_free:.0f}%)",
-                evidence=[f"Total: {usage.total / (1024**3):.0f} GB, Free: {free_gb:.1f} GB"],
+                status="healthy",
+                severity="info",
+                summary=f"Disk space recovered after NEXO backup self-cleanup: {free_gb:.1f} GB free ({pct_free:.0f}%)",
+                evidence=evidence + [f"Post-disk recovery sweep: {sweep}"],
+                fixed=True,
             )
+
         return DoctorCheck(
             id="boot.disk_space",
             tier="boot",

package/src/kg_populate.py

@@ -5,6 +5,7 @@ import os
 import sqlite3
 from typing import Optional
 
+from cognitive_paths import resolve_cognitive_db
 import knowledge_graph as kg
 from db import get_db
 
@@ -13,11 +14,7 @@ from db import get_db
 
 def _cognitive_db():
     """Direct cognitive.db connection (for somatic_markers)."""
-    nexo_home = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
-    data_dir = os.path.join(nexo_home, "data")
-    os.makedirs(data_dir, exist_ok=True)
-    path = os.path.join(data_dir, "cognitive.db")
-    conn = sqlite3.connect(path)
+    conn = sqlite3.connect(str(resolve_cognitive_db(for_write=True)))
     conn.row_factory = sqlite3.Row
     return conn
 

package/src/paths.py

@@ -55,6 +55,11 @@ that hardcoded the old paths keeps resolving via symlink during the
 from __future__ import annotations
 
 import os
+import json
+import shutil
+import subprocess
+import sys
+import time
 from pathlib import Path
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
@@ -320,6 +325,321 @@ def backups_dir() -> Path:
     return new
 
 
+_GiB = 1024 ** 3
+BACKUP_DEFAULT_MAX_BYTES = 50 * _GiB
+BACKUP_MIN_CAP_BYTES = 10 * _GiB
+BACKUP_MAX_CAP_BYTES = 50 * _GiB
+BACKUP_DEFAULT_MIN_FREE_BYTES = 5 * _GiB
+
+
+class BackupSnapshotPath:
+    """Path returned by backup helpers; usable as a post-pruning context."""
+
+    def __init__(self, value: str | Path, *, backups_root: Path | None = None):
+        self._path = Path(value)
+        self._nexo_backups_root = Path(backups_root) if backups_root is not None else None
+        self._nexo_finalized = False
+
+    def __fspath__(self) -> str:
+        return os.fspath(self._path)
+
+    def __str__(self) -> str:
+        return str(self._path)
+
+    def __repr__(self) -> str:
+        return f"BackupSnapshotPath({self._path!r})"
+
+    def __truediv__(self, key):
+        return self._path / key
+
+    def __eq__(self, other) -> bool:
+        return self._path == Path(other)
+
+    def __getattr__(self, name: str):
+        return getattr(self._path, name)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, _exc_type, _exc, _tb):
+        self.finalize()
+        return False
+
+    def finalize(self) -> dict:
+        if self._nexo_finalized:
+            return {"ok": True, "skipped": True, "reason": "already_finalized"}
+        self._nexo_finalized = True
+        return finalize_backup_snapshot(self, backups_root=self._nexo_backups_root)
+
+
+def parse_size_bytes(value: str | int | None, *, default: int = BACKUP_DEFAULT_MAX_BYTES) -> int:
+    """Parse size strings like ``10G`` / ``512M`` into bytes."""
+    if value is None or value == "":
+        return default
+    if isinstance(value, int):
+        return max(0, value)
+    raw = str(value).strip().lower()
+    if not raw:
+        return default
+    multiplier = 1
+    if raw[-1:] in {"k", "m", "g", "t"}:
+        unit = raw[-1]
+        raw = raw[:-1].strip()
+        multiplier = {"k": 1024, "m": 1024 ** 2, "g": _GiB, "t": 1024 ** 4}[unit]
+    try:
+        return max(0, int(float(raw) * multiplier))
+    except ValueError:
+        return default
+
+
+def backup_min_free_bytes() -> int:
+    return parse_size_bytes(os.environ.get("NEXO_BACKUP_MIN_FREE_BYTES"), default=BACKUP_DEFAULT_MIN_FREE_BYTES)
+
+
+def backup_retention_cap_bytes(*, backups_root: Path | None = None, configured: str | int | None = None) -> int:
+    """Return the effective technical-backup cap for this install.
+
+    The default adapts to the user's disk: 5% of total capacity, floored at
+    10 GiB and capped at 50 GiB. ``NEXO_BACKUP_MAX_BYTES`` remains an upper
+    bound, and explicit lower caps are allowed for emergency prune steps.
+    """
+    raw = parse_size_bytes(
+        configured if configured is not None else os.environ.get("NEXO_BACKUP_MAX_BYTES"),
+        default=BACKUP_DEFAULT_MAX_BYTES,
+    )
+    if raw < BACKUP_MIN_CAP_BYTES:
+        return raw
+    root = Path(backups_root or backups_dir())
+    probe = root if root.exists() else root.parent
+    try:
+        usage = shutil.disk_usage(str(probe))
+        adaptive = int(usage.total * 0.05)
+    except Exception:
+        adaptive = BACKUP_DEFAULT_MAX_BYTES
+    adaptive = max(BACKUP_MIN_CAP_BYTES, min(BACKUP_MAX_CAP_BYTES, adaptive))
+    return min(raw, adaptive)
+
+
+def backup_free_bytes(*, backups_root: Path | None = None) -> int | None:
+    root = Path(backups_root or backups_dir())
+    probe = root if root.exists() else root.parent
+    try:
+        return int(shutil.disk_usage(str(probe)).free)
+    except Exception:
+        return None
+
+
+def _backup_pruner_script() -> Path | None:
+    candidates = [
+        Path(__file__).resolve().parent / "scripts" / "prune_runtime_backups.py",
+        core_scripts_dir() / "prune_runtime_backups.py",
+    ]
+    seen: set[str] = set()
+    for candidate in candidates:
+        key = str(candidate)
+        if key in seen:
+            continue
+        seen.add(key)
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def _append_backup_retention_event(event: dict) -> None:
+    try:
+        log_path = operations_dir() / "backup-retention-events.jsonl"
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        payload = {
+            "ts": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            **event,
+            "os": sys.platform,
+        }
+        with log_path.open("a", encoding="utf-8") as fh:
+            fh.write(json.dumps(payload, sort_keys=True) + "\n")
+    except Exception:
+        pass
+
+
+def run_runtime_backup_prune(
+    *,
+    max_bytes: str | int | None = None,
+    backups_root: Path | None = None,
+    delete_all_technical: bool = False,
+    timeout: int = 120,
+) -> dict:
+    """Run the technical-backup pruner. Safe no-op when the script is absent."""
+    script = _backup_pruner_script()
+    root = Path(backups_root or backups_dir())
+    cap = parse_size_bytes(max_bytes, default=backup_retention_cap_bytes(backups_root=root))
+    if max_bytes is None:
+        cap = backup_retention_cap_bytes(backups_root=root)
+    if script is None:
+        return {"ok": False, "skipped": True, "reason": "pruner_missing", "root": str(root)}
+    args = [
+        sys.executable,
+        str(script),
+        "--root",
+        str(root),
+        "--apply",
+        "--json",
+        "--max-bytes",
+        str(cap),
+    ]
+    if delete_all_technical:
+        args.append("--delete-all-technical")
+    try:
+        proc = subprocess.run(args, capture_output=True, text=True, timeout=timeout)
+        report = json.loads(proc.stdout or "{}") if proc.stdout.strip().startswith("{") else {}
+        return {
+            "ok": proc.returncode == 0,
+            "returncode": proc.returncode,
+            "max_bytes": cap,
+            "root": str(root),
+            "stdout": proc.stdout[-4000:],
+            "stderr": proc.stderr[-4000:],
+            "report": report,
+        }
+    except Exception as exc:
+        return {"ok": False, "error": str(exc), "max_bytes": cap, "root": str(root)}
+
+
+def aggressive_runtime_backup_prune(
+    *,
+    min_free_bytes: int | None = None,
+    backups_root: Path | None = None,
+    reason: str = "",
+) -> dict:
+    """Escalate NEXO-owned backup pruning before any user-facing disk alert.
+
+    Escalation never targets protected business/hourly backup classes; the
+    pruner enforces that policy.
+    """
+    root = Path(backups_root or backups_dir())
+    floor = int(min_free_bytes if min_free_bytes is not None else backup_min_free_bytes())
+    steps: list[dict] = []
+    escalated = False
+    plan = [
+        ("standard", None, False),
+        ("cap-10gb", 10 * _GiB, False),
+        ("cap-5gb", 5 * _GiB, False),
+        ("delete-all-technical", 0, True),
+    ]
+    for label, cap, delete_all in plan:
+        before = backup_free_bytes(backups_root=root)
+        if before is not None and before >= floor and steps:
+            break
+        if label != "standard":
+            escalated = True
+        result = run_runtime_backup_prune(max_bytes=cap, backups_root=root, delete_all_technical=delete_all)
+        after = backup_free_bytes(backups_root=root)
+        steps.append({
+            "step": label,
+            "before_free_bytes": before,
+            "after_free_bytes": after,
+            "ok": result.get("ok") is True,
+            "delete_count": (((result.get("report") or {}).get("totals") or {}).get("delete_count")),
+            "delete_bytes": (((result.get("report") or {}).get("totals") or {}).get("delete_bytes")),
+        })
+        if after is not None and after >= floor:
+            break
+    final_free = backup_free_bytes(backups_root=root)
+    if escalated:
+        dominant = ""
+        try:
+            deletes = []
+            for step in steps:
+                # Detailed family data is emitted by the script report; keep
+                # this anonymous and compact for product telemetry.
+                if step.get("delete_bytes"):
+                    deletes.append((int(step.get("delete_bytes") or 0), step.get("step") or ""))
+            dominant = max(deletes)[1] if deletes else ""
+        except Exception:
+            dominant = ""
+        _append_backup_retention_event({
+            "event": "backup_prune_escalated",
+            "reason": reason,
+            "steps": len(steps),
+            "dominant_prefix": dominant,
+            "final_free_bytes": final_free,
+        })
+    return {
+        "ok": final_free is None or final_free >= floor,
+        "root": str(root),
+        "min_free_bytes": floor,
+        "final_free_bytes": final_free,
+        "steps": steps,
+    }
+
+
+def backup_space_error(
+    *,
+    reason: str = "",
+    min_free_bytes: int | None = None,
+    backups_root: Path | None = None,
+) -> str | None:
+    report = aggressive_runtime_backup_prune(
+        min_free_bytes=min_free_bytes,
+        backups_root=backups_root,
+        reason=reason,
+    )
+    free = report.get("final_free_bytes")
+    floor = int(report.get("min_free_bytes") or backup_min_free_bytes())
+    if free is not None and free < floor:
+        return (
+            "free disk below NEXO backup safety floor after NEXO self-cleanup "
+            f"({free}B < {floor}B)"
+        )
+    return None
+
+
+def create_backup_dir(prefix: str, *, backups_root: Path | None = None) -> Path:
+    """Create a technical backup directory through the universal guard."""
+    clean = str(prefix or "").strip().strip("-")
+    if not clean or any(sep in clean for sep in ("/", "\\")):
+        raise ValueError("backup prefix must be a single path segment")
+    err = backup_space_error(reason=f"create_backup_dir:{clean}", backups_root=backups_root)
+    if err:
+        raise RuntimeError(err)
+    root = Path(backups_root or backups_dir())
+    root.mkdir(parents=True, exist_ok=True)
+    stamp = time.strftime("%Y-%m-%d-%H%M%S", time.gmtime())
+    candidate = root / f"{clean}-{stamp}"
+    suffix = 2
+    while candidate.exists():
+        candidate = root / f"{clean}-{stamp}-{suffix}"
+        suffix += 1
+    candidate.mkdir(parents=True, exist_ok=False)
+    return BackupSnapshotPath(candidate, backups_root=root)
+
+
+def create_backup_path(prefix: str, suffix: str = "", *, backups_root: Path | None = None) -> Path:
+    """Reserve a backup file path under runtime/backups via the same guard."""
+    clean = str(prefix or "").strip().strip("-")
+    if not clean or any(sep in clean for sep in ("/", "\\")):
+        raise ValueError("backup prefix must be a single path segment")
+    err = backup_space_error(reason=f"create_backup_path:{clean}", backups_root=backups_root)
+    if err:
+        raise RuntimeError(err)
+    root = Path(backups_root or backups_dir())
+    root.mkdir(parents=True, exist_ok=True)
+    stamp = time.strftime("%Y-%m-%d-%H%M%S", time.gmtime())
+    candidate = root / f"{clean}-{stamp}{suffix}"
+    index = 2
+    while candidate.exists():
+        candidate = root / f"{clean}-{stamp}-{index}{suffix}"
+        index += 1
+    return BackupSnapshotPath(candidate, backups_root=root)
+
+
+def finalize_backup_snapshot(_path: Path | str | None = None, *, backups_root: Path | None = None) -> dict:
+    """Post-snapshot cleanup; callers invoke after writing large artifacts."""
+    root = Path(backups_root) if backups_root is not None else None
+    if root is None and _path is not None:
+        snapshot = Path(_path)
+        root = snapshot.parent
+    return run_runtime_backup_prune(backups_root=root)
+
+
 def memory_dir() -> Path:
     new = runtime_dir() / "memory"
     legacy = home() / "memory"
@@ -329,11 +649,7 @@ def memory_dir() -> Path:
 
 
 def cognitive_dir() -> Path:
-    new = runtime_dir() / "cognitive"
-    legacy = home() / "cognitive"
-    if not new.exists() and legacy.exists():
-        return legacy
-    return new
+    return runtime_dir() / "cognitive"
 
 
 def models_dir() -> Path:

package/src/plugins/update.py

@@ -155,8 +155,8 @@ def _env_int(name: str, default: int) -> int:
         return default
 
 
-BACKUP_MAX_BYTES = _env_int("NEXO_BACKUP_MAX_BYTES", 50 * 1024 * 1024 * 1024)
-BACKUP_MIN_FREE_BYTES = _env_int("NEXO_BACKUP_MIN_FREE_BYTES", 5 * 1024 * 1024 * 1024)
+BACKUP_MAX_BYTES = paths.backup_retention_cap_bytes(backups_root=BACKUP_BASE)
+BACKUP_MIN_FREE_BYTES = paths.backup_min_free_bytes()
 LOCAL_CONTEXT_MAX_BACKUP_BYTES = _env_int("NEXO_LOCAL_CONTEXT_MAX_BACKUP_BYTES", 2 * 1024 * 1024 * 1024)
 
 # In packaged installs, update.py lives at <NEXO_HOME>/plugins/update.py.
@@ -199,26 +199,7 @@ def _rotate_backup_family(prefix: str, keep: int = TECHNICAL_BACKUP_KEEP) -> int
 
 
 def _run_runtime_backup_prune() -> None:
-    script = SRC_DIR / "scripts" / "prune_runtime_backups.py"
-    if not script.is_file():
-        return
-    try:
-        subprocess.run(
-            [
-                sys.executable,
-                str(script),
-                "--root",
-                str(BACKUP_BASE),
-                "--apply",
-                "--max-bytes",
-                str(BACKUP_MAX_BYTES),
-            ],
-            capture_output=True,
-            text=True,
-            timeout=120,
-        )
-    except Exception:
-        pass
+    paths.run_runtime_backup_prune(max_bytes=BACKUP_MAX_BYTES, backups_root=BACKUP_BASE)
 
 
 def _backup_free_bytes() -> int | None:
@@ -230,14 +211,11 @@ def _backup_free_bytes() -> int | None:
 
 
 def _backup_space_error() -> str | None:
-    _run_runtime_backup_prune()
-    free = _backup_free_bytes()
-    if free is not None and free < BACKUP_MIN_FREE_BYTES:
-        return (
-            "free disk below NEXO backup safety floor after automatic cleanup "
-            f"({free}B < {BACKUP_MIN_FREE_BYTES}B)"
-        )
-    return None
+    return paths.backup_space_error(
+        reason="manual_update",
+        min_free_bytes=BACKUP_MIN_FREE_BYTES,
+        backups_root=BACKUP_BASE,
+    )
 
 
 def _should_include_local_context_backup(path: Path) -> bool:
@@ -578,8 +556,7 @@ def _backup_databases() -> tuple[str, str | None]:
     a backup that silently loses data returns an error instead of a green
     "backup_dir" string that the rollback logic would then restore from.
     """
-    timestamp = time.strftime("%Y-%m-%d-%H%M")
-    backup_dir = BACKUP_BASE / f"pre-update-{timestamp}"
+    backup_dir: Path | None = None
 
     db_files = list(DATA_DIR.glob("*.db")) if DATA_DIR.is_dir() else []
     local_context_db = paths.memory_dir() / "local-context.db"
@@ -593,13 +570,14 @@ def _backup_databases() -> tuple[str, str | None]:
         db_files.append(src_db)
 
     if not db_files:
+        backup_dir = paths.create_backup_dir("pre-update", backups_root=BACKUP_BASE)
         return str(backup_dir), None  # No DBs to backup, not an error
 
     space_err = _backup_space_error()
     if space_err:
         return str(backup_dir), space_err
 
-    backup_dir.mkdir(parents=True, exist_ok=True)
+    backup_dir = paths.create_backup_dir("pre-update", backups_root=BACKUP_BASE)
 
     for db_file in db_files:
         dest = backup_dir / db_file.name
@@ -618,6 +596,7 @@ def _backup_databases() -> tuple[str, str | None]:
         _rotate_backup_family("pre-update-")
     except Exception:
         pass
+    paths.finalize_backup_snapshot(backup_dir)
     return str(backup_dir), None
 
 
@@ -988,8 +967,7 @@ def _sync_hooks_to_home():
 
 def _backup_code_tree() -> tuple[str | None, str | None]:
     """Snapshot NEXO_HOME code dirs before npm update. Returns (backup_dir, error)."""
-    timestamp = time.strftime("%Y-%m-%d-%H%M%S")
-    backup_dir = BACKUP_BASE / f"code-tree-{timestamp}"
+    backup_dir = paths.create_backup_dir("code-tree", backups_root=BACKUP_BASE)
     # Directories and flat files that postinstall copies into NEXO_HOME
     code_dirs = [
         "bin",
@@ -1010,7 +988,6 @@ def _backup_code_tree() -> tuple[str | None, str | None]:
     ]
     code_files_glob = ["*.py", "requirements.txt", "package.json"]
     try:
-        backup_dir.mkdir(parents=True, exist_ok=True)
         # Backup directories
         for d in code_dirs:
             src = NEXO_HOME / d
@@ -1031,6 +1008,7 @@ def _backup_code_tree() -> tuple[str | None, str | None]:
         _rotate_backup_family("code-tree-")
     except Exception:
         pass
+    paths.finalize_backup_snapshot(backup_dir)
     return str(backup_dir), None
 
 

package/src/pre_answer_router.py

@@ -1098,6 +1098,27 @@ def _source_diary(request: SourceRequest) -> SourceResult:
 
 
 def _source_transcripts(request: SourceRequest) -> SourceResult:
+    try:
+        from transcript_index import index_recent_transcripts, search_transcript_index
+
+        index_recent_transcripts(hours=72, limit=120, min_user_messages=1)
+        indexed_rows = search_transcript_index(request.query, hours=72, limit=4)
+        if indexed_rows:
+            indexed_result = _rows_result(
+                "transcript_index",
+                indexed_rows,
+                ("source_client", "display_name", "session_id", "sanitized_summary", "modified_at"),
+                request.max_chars,
+            )
+            return SourceResult(
+                source="transcripts",
+                rendered=indexed_result.rendered,
+                evidence_refs=indexed_result.evidence_refs,
+                result_count=indexed_result.result_count,
+            )
+    except Exception:
+        pass
+
     from tools_transcripts import handle_transcript_search
 
     rendered = handle_transcript_search(request.query, hours=72, limit=4)