@simbimbo/memory-ocmemog 0.1.11 → 0.1.13

package/ocmemog/sidecar/app.py

@@ -1,10 +1,15 @@
 from __future__ import annotations
 
 import json
+import atexit
+import faulthandler
 import os
 import re
 import threading
+import tempfile
 import time
+import sys
+from contextlib import asynccontextmanager
 from pathlib import Path
 from typing import Any, Dict, Iterable, List, Optional
 
@@ -13,17 +18,126 @@ from fastapi.responses import HTMLResponse, StreamingResponse, JSONResponse
 from pydantic import BaseModel, Field
 from datetime import datetime, timedelta
 
-from brain.runtime import state_store
-from brain.runtime.memory import api, conversation_state, distill, health, memory_links, pondering_engine, provenance, reinforcement, retrieval, store
+from ocmemog import __version__
+from ocmemog.runtime import state_store
+from ocmemog.runtime.memory import (
+    api,
+    conversation_state,
+    distill,
+    health,
+    memory_links,
+    pondering_engine,
+    provenance,
+    reinforcement,
+    retrieval,
+    store,
+)
 from ocmemog.sidecar.compat import flatten_results, probe_runtime
 from ocmemog.sidecar.transcript_watcher import watch_forever
 
 DEFAULT_CATEGORIES = tuple(store.MEMORY_TABLES)
 
-app = FastAPI(title="ocmemog sidecar", version="0.1.10")
-
 API_TOKEN = os.environ.get("OCMEMOG_API_TOKEN")
+_GOVERNANCE_REVIEW_CACHE_TTL_SECONDS = 15.0
+_governance_review_cache: Dict[str, Any] = {"key": None, "expires_at": 0.0, "payload": None}
+
+
+_BOOL_TRUE_VALUES = {"1", "true", "yes", "on", "y", "t"}
+_BOOL_FALSE_VALUES = {"0", "false", "no", "off", "n", "f"}
+
+
+def _parse_bool_env_value(raw: Any | None, default: bool = False) -> tuple[bool, bool]:
+    """Return ``(value, valid)``, where ``valid`` indicates parser confidence."""
+    if raw is None:
+        return default, True
+
+    raw_value = str(raw).strip().lower()
+    if raw_value in _BOOL_TRUE_VALUES:
+        return True, True
+    if raw_value in _BOOL_FALSE_VALUES:
+        return False, True
+    if not raw_value:
+        return default, False
+    return default, False
+
+
+def _parse_bool_env(name: str, default: bool = False) -> bool:
+    raw = os.environ.get(name)
+    value, _ = _parse_bool_env_value(raw, default=default)
+    return value
+
+
+def _parse_float_env(name: str, default: float, minimum: float | None = None) -> float:
+    raw = os.environ.get(name)
+    try:
+        value = float(raw if raw is not None else default)
+    except Exception:
+        print(
+            f"[ocmemog][config] invalid float env value: {name}={raw!r}; using default {default}",
+            file=sys.stderr,
+        )
+        return default
+    if minimum is not None and value < minimum:
+        print(
+            f"[ocmemog][config] env value below minimum: {name}={value}; using default {default}",
+            file=sys.stderr,
+        )
+        return default
+    return value
+
+
+def _parse_int_env(name: str, default: int, minimum: int | None = None) -> int:
+    raw = os.environ.get(name)
+    try:
+        value = int(raw if raw is not None else default)
+    except Exception:
+        print(
+            f"[ocmemog][config] invalid int env value: {name}={raw!r}; using default {default}",
+            file=sys.stderr,
+        )
+        return default
+    if minimum is not None and value < minimum:
+        print(
+            f"[ocmemog][config] env value below minimum: {name}={value}; using default {default}",
+            file=sys.stderr,
+        )
+        return default
+    return value
+
+
+_SHUTDOWN_TIMING = _parse_bool_env("OCMEMOG_SHUTDOWN_TIMING", default=True)
+
 
+@asynccontextmanager
+async def _sidecar_lifespan(_: FastAPI):
+    _startup_started = time.perf_counter()
+    try:
+        _start_transcript_watcher()
+        _start_ingest_worker()
+        if _SHUTDOWN_TIMING:
+            print(
+                f"[ocmemog][shutdown] lifespan_startup elapsed={time.perf_counter()-_startup_started:.3f}s",
+                file=sys.stderr,
+            )
+        yield
+    finally:
+        shutdown_started = time.perf_counter()
+        _stop_background_workers()
+        if _SHUTDOWN_TIMING:
+            print(
+                f"[ocmemog][shutdown] lifespan_shutdown elapsed={time.perf_counter()-shutdown_started:.3f}s",
+                file=sys.stderr,
+            )
+
+
+app = FastAPI(title="ocmemog sidecar", version=__version__, lifespan=_sidecar_lifespan)
+
+_INGEST_WORKER_STOP = threading.Event()
+_INGEST_WORKER_THREAD: threading.Thread | None = None
+_INGEST_WORKER_LOCK = threading.Lock()
+_WATCHER_STOP = threading.Event()
+_WATCHER_THREAD: threading.Thread | None = None
+_WATCHER_LOCK = threading.Lock()
 QUEUE_LOCK = threading.Lock()
 QUEUE_PROCESS_LOCK = threading.Lock()
 QUEUE_STATS = {
@@ -33,6 +147,8 @@ QUEUE_STATS = {
     "last_error": None,
     "last_batch": 0,
 }
+_POSTPROCESS_TASK_KEY = "_ocmemog_task"
+_POSTPROCESS_TASK_VALUE = "postprocess_memory"
 
 
 _REFLECTION_RECLASSIFY_PREFERENCE_PATTERNS = (
@@ -85,9 +201,14 @@ def _load_queue_stats() -> None:
 
 def _save_queue_stats() -> None:
     path = _queue_stats_path()
-    tmp = path.with_suffix('.tmp')
-    tmp.write_text(json.dumps(QUEUE_STATS, indent=2, sort_keys=True), encoding='utf-8')
-    tmp.replace(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = json.dumps(QUEUE_STATS, indent=2, sort_keys=True)
+    with tempfile.NamedTemporaryFile('w', encoding='utf-8', dir=str(path.parent), prefix='queue_stats.', suffix='.tmp', delete=False) as handle:
+        handle.write(payload)
+        handle.flush()
+        os.fsync(handle.fileno())
+        tmp_name = handle.name
+    Path(tmp_name).replace(path)
 
 
 @app.middleware("http")
@@ -100,14 +221,23 @@ async def _auth_middleware(request: Request, call_next):
     return await call_next(request)
 
 
-@app.on_event("startup")
 def _start_transcript_watcher() -> None:
+    global _WATCHER_THREAD
     _load_queue_stats()
-    enabled = os.environ.get("OCMEMOG_TRANSCRIPT_WATCHER", "").lower() in {"1", "true", "yes"}
+    enabled = _parse_bool_env("OCMEMOG_TRANSCRIPT_WATCHER")
     if not enabled:
         return
-    thread = threading.Thread(target=watch_forever, daemon=True)
-    thread.start()
+    with _WATCHER_LOCK:
+        if _WATCHER_THREAD and _WATCHER_THREAD.is_alive():
+            return
+        _WATCHER_STOP.clear()
+        _WATCHER_THREAD = threading.Thread(
+            target=watch_forever,
+            args=(_WATCHER_STOP,),
+            daemon=True,
+            name="ocmemog-transcript-watcher",
+        )
+        _WATCHER_THREAD.start()
 
 
 def _queue_path() -> Path:
@@ -186,6 +316,24 @@ def _enqueue_payload(payload: Dict[str, Any]) -> int:
         return _queue_depth()
 
 
+def _enqueue_postprocess(reference: str, *, skip_embedding_provider: bool = True) -> int:
+    return _enqueue_payload({
+        _POSTPROCESS_TASK_KEY: _POSTPROCESS_TASK_VALUE,
+        "reference": reference,
+        "skip_embedding_provider": bool(skip_embedding_provider),
+    })
+
+
+def _run_postprocess_payload(payload: Dict[str, Any]) -> None:
+    reference = str(payload.get("reference") or "").strip()
+    if not reference:
+        raise ValueError("missing_reference")
+    skip_embedding_provider = bool(payload.get("skip_embedding_provider", True))
+    result = api.postprocess_stored_memory(reference, skip_embedding_provider=skip_embedding_provider)
+    if not result.get("ok"):
+        raise RuntimeError(str(result.get("error") or "postprocess_failed"))
+
+
 
 def _process_queue(limit: Optional[int] = None) -> Dict[str, Any]:
     processed = 0
@@ -208,8 +356,11 @@ def _process_queue(limit: Optional[int] = None) -> Dict[str, Any]:
             acknowledged = 0
             for line_no, payload in batch:
                 try:
-                    req = IngestRequest(**payload)
-                    _ingest_request(req)
+                    if isinstance(payload, dict) and payload.get(_POSTPROCESS_TASK_KEY) == _POSTPROCESS_TASK_VALUE:
+                        _run_postprocess_payload(payload)
+                    else:
+                        req = IngestRequest(**payload)
+                        _ingest_request(req)
                     processed += 1
                     batch_processed += 1
                     acknowledged = line_no
@@ -240,15 +391,16 @@ def _process_queue(limit: Optional[int] = None) -> Dict[str, Any]:
 
 
 def _ingest_worker() -> None:
-    enabled = os.environ.get("OCMEMOG_INGEST_ASYNC_WORKER", "true").lower() in {"1", "true", "yes"}
+    enabled = _parse_bool_env("OCMEMOG_INGEST_ASYNC_WORKER", default=True)
     if not enabled:
         return
-    poll_seconds = float(os.environ.get("OCMEMOG_INGEST_ASYNC_POLL_SECONDS", "5"))
-    batch_max = int(os.environ.get("OCMEMOG_INGEST_ASYNC_BATCH_MAX", "25"))
+    poll_seconds = _parse_float_env("OCMEMOG_INGEST_ASYNC_POLL_SECONDS", default=5.0, minimum=0.0)
+    batch_max = _parse_int_env("OCMEMOG_INGEST_ASYNC_BATCH_MAX", default=25, minimum=1)
 
-    while True:
+    while not _INGEST_WORKER_STOP.is_set():
         _process_queue(batch_max)
-        time.sleep(poll_seconds)
+        if _INGEST_WORKER_STOP.wait(poll_seconds):
+            break
 
 
 
@@ -256,10 +408,122 @@ def _drain_queue(limit: Optional[int] = None) -> Dict[str, Any]:
     return _process_queue(limit)
 
 
-@app.on_event("startup")
 def _start_ingest_worker() -> None:
-    thread = threading.Thread(target=_ingest_worker, daemon=True)
-    thread.start()
+    global _INGEST_WORKER_THREAD
+    with _INGEST_WORKER_LOCK:
+        if _INGEST_WORKER_THREAD and _INGEST_WORKER_THREAD.is_alive():
+            return
+        _INGEST_WORKER_STOP.clear()
+        _INGEST_WORKER_THREAD = threading.Thread(
+            target=_ingest_worker,
+            daemon=True,
+            name="ocmemog-ingest-worker",
+        )
+        _INGEST_WORKER_THREAD.start()
+
+
+def _stop_background_workers() -> None:
+    global _INGEST_WORKER_THREAD, _WATCHER_THREAD
+    shutdown_start = time.perf_counter()
+    if _SHUTDOWN_TIMING:
+        print(f"[ocmemog][shutdown] shutdown_begin", file=sys.stderr)
+    timeout = _parse_float_env(
+        "OCMEMOG_WORKER_SHUTDOWN_TIMEOUT_SECONDS",
+        default=0.35,
+        minimum=0.0,
+    )
+    if _SHUTDOWN_TIMING:
+        print(f"[ocmemog][shutdown] shutdown_config timeout={timeout:.3f}s", file=sys.stderr)
+
+    queue_drain_requested = _parse_bool_env("OCMEMOG_SHUTDOWN_DRAIN_QUEUE")
+    if queue_drain_requested and _queue_depth() > 0:
+        _queue_drain_start = time.perf_counter()
+        drain_stats = _drain_queue()
+        if _SHUTDOWN_TIMING:
+            print(
+                f"[ocmemog][shutdown] queue_drain elapsed={time.perf_counter()-_queue_drain_start:.3f}s processed={drain_stats.get('processed', 0)} errors={drain_stats.get('errors', 0)}",
+                file=sys.stderr,
+            )
+    _INGEST_WORKER_STOP.set()
+    _WATCHER_STOP.set()
+    if _SHUTDOWN_TIMING:
+        print(
+            f"[ocmemog][shutdown] stop_signals_set elapsed={time.perf_counter()-shutdown_start:.3f}s",
+            file=sys.stderr,
+        )
+
+    if _parse_bool_env("OCMEMOG_SHUTDOWN_DUMP_THREADS"):
+        _dump_thread_dump("post-stop requested")
+
+    with _INGEST_WORKER_LOCK:
+        ingest_worker = _INGEST_WORKER_THREAD
+    if ingest_worker is not None and ingest_worker.is_alive():
+        ingest_join_start = time.perf_counter()
+        ingest_worker.join(timeout=timeout)
+        if _SHUTDOWN_TIMING:
+            print(
+                f"[ocmemog][shutdown] ingest_worker_join elapsed={time.perf_counter()-ingest_join_start:.3f}s alive={ingest_worker.is_alive()}",
+                file=sys.stderr,
+            )
+        if _parse_bool_env("OCMEMOG_SHUTDOWN_DUMP_THREADS"):
+            _dump_join_result("ingest-worker", ingest_worker, timeout)
+        if not ingest_worker.is_alive():
+            with _INGEST_WORKER_LOCK:
+                if _INGEST_WORKER_THREAD is ingest_worker:
+                    _INGEST_WORKER_THREAD = None
+
+    with _WATCHER_LOCK:
+        watcher_thread = _WATCHER_THREAD
+    if watcher_thread is not None and watcher_thread.is_alive():
+        watcher_join_start = time.perf_counter()
+        watcher_thread.join(timeout=timeout)
+        if _SHUTDOWN_TIMING:
+            print(
+                f"[ocmemog][shutdown] transcript_watcher_join elapsed={time.perf_counter()-watcher_join_start:.3f}s alive={watcher_thread.is_alive()}",
+                file=sys.stderr,
+            )
+    if _parse_bool_env("OCMEMOG_SHUTDOWN_DUMP_THREADS"):
+        _dump_join_result("transcript-watcher", watcher_thread, timeout)
+        if not watcher_thread.is_alive():
+            with _WATCHER_LOCK:
+                if _WATCHER_THREAD is watcher_thread:
+                    _WATCHER_THREAD = None
+    if _SHUTDOWN_TIMING:
+        print(
+            f"[ocmemog][shutdown] shutdown_complete elapsed={time.perf_counter()-shutdown_start:.3f}s",
+            file=sys.stderr,
+        )
+
+
+def _dump_thread_dump(context: str) -> None:
+    print(f"[ocmemog][thread-dump:{context}]", file=sys.stderr)
+    _dump_thread_states()
+    faulthandler.dump_traceback(file=sys.stderr, all_threads=True)
+
+
+def _dump_join_result(thread_label: str, thread: threading.Thread, timeout: float) -> None:
+    if thread.is_alive():
+        print(
+            f"[ocmemog][shutdown] {thread_label} still alive after join timeout={timeout:.3f}s",
+            file=sys.stderr,
+        )
+        _dump_thread_dump(thread_label)
+    else:
+        print(
+            f"[ocmemog][shutdown] {thread_label} joined cleanly",
+            file=sys.stderr,
+        )
+
+
+def _dump_thread_states() -> None:
+    for thread in threading.enumerate():
+        print(
+            f"[ocmemog][thread-state] name={thread.name} alive={thread.is_alive()} daemon={thread.daemon} ident={thread.ident}",
+            file=sys.stderr,
+        )
+
+
+atexit.register(_stop_background_workers)
 
 
 class SearchRequest(BaseModel):
@@ -290,6 +554,7 @@ class GovernanceReviewRequest(BaseModel):
     categories: Optional[List[str]] = None
     limit: int = Field(default=100, ge=1, le=500)
     context_depth: int = Field(default=1, ge=0, le=2)
+    scan_limit: int = Field(default=3000, ge=1, le=10000)
 
 
 class GovernanceDecisionRequest(BaseModel):
@@ -481,6 +746,8 @@ def _runtime_payload() -> Dict[str, Any]:
     return {
         "mode": status.mode,
         "missingDeps": status.missing_deps,
+        "identity": status.identity,
+        "capabilities": status.capabilities,
         "todo": status.todo,
         "warnings": status.warnings,
     }
@@ -679,6 +946,7 @@ def _read_transcript_snippet(path: Path, line_start: Optional[int], line_end: Op
 def healthz() -> dict[str, Any]:
     payload = _runtime_payload()
     payload["ok"] = True
+    payload["ready"] = payload.get("mode") == "ready"
     return payload
 
 
@@ -686,14 +954,35 @@ def healthz() -> dict[str, Any]:
 def memory_search(request: SearchRequest) -> dict[str, Any]:
     categories = _normalize_categories(request.categories)
     runtime = _runtime_payload()
+    started = time.perf_counter()
+    query = request.query or ""
+    skip_vector_provider = _parse_bool_env("OCMEMOG_SEARCH_SKIP_EMBEDDING_PROVIDER", default=True)
     try:
-        results = retrieval.retrieve_for_queries([request.query], limit=request.limit, categories=categories)
+        results = retrieval.retrieve_for_queries(
+            [query],
+            limit=request.limit,
+            categories=categories,
+            skip_vector_provider=skip_vector_provider,
+        )
         flattened = flatten_results(results)
+        if len(flattened) > request.limit:
+            flattened = flattened[: request.limit]
         used_fallback = False
     except Exception as exc:
         flattened = _fallback_search(request.query, request.limit, categories)
         used_fallback = True
         runtime["warnings"] = [*runtime["warnings"], f"search fallback enabled: {exc}"]
+    elapsed_ms = round((time.perf_counter() - started) * 1000, 3)
+    if elapsed_ms >= 10:
+        print(
+            f"[ocmemog][route] memory_search elapsed_ms={elapsed_ms:.3f} limit={request.limit} categories={','.join(categories)} fallback={used_fallback}",
+            file=sys.stderr,
+        )
+        if elapsed_ms >= 200:
+            print(
+                f"[ocmemog][route] memory_search slow_path query={query[:128]!r} result_count={len(flattened)}",
+                file=sys.stderr,
+            )
 
     return {
         "ok": True,
@@ -764,17 +1053,59 @@ def memory_governance_review(request: GovernanceReviewRequest) -> dict[str, Any]
         categories=request.categories,
         limit=request.limit,
         context_depth=request.context_depth,
+        scan_limit=request.scan_limit,
     )
     return {
         "ok": True,
         "categories": request.categories,
         "limit": request.limit,
         "context_depth": request.context_depth,
+        "scan_limit": request.scan_limit,
         "items": items,
         **runtime,
     }
 
 
+@app.post("/memory/governance/review/summary")
+def memory_governance_review_summary(request: GovernanceReviewRequest) -> dict[str, Any]:
+    runtime = _runtime_payload()
+    limit = min(int(request.limit or 25), 50)
+    scan_limit = min(int(request.scan_limit or max(limit * 10, 250)), 500)
+    cache_key = json.dumps(
+        {
+            "categories": sorted(request.categories or []),
+            "limit": limit,
+            "context_depth": 0,
+            "scan_limit": scan_limit,
+        },
+        sort_keys=True,
+    )
+    now = time.time()
+    if _governance_review_cache.get("key") == cache_key and float(_governance_review_cache.get("expires_at") or 0.0) > now:
+        cached_payload = _governance_review_cache.get("payload") or {}
+        return {**cached_payload, **runtime, "cached": True}
+
+    items = api.list_governance_review_items(
+        categories=request.categories,
+        limit=limit,
+        context_depth=0,
+        scan_limit=scan_limit,
+    )
+    payload = {
+        "ok": True,
+        "categories": request.categories,
+        "limit": limit,
+        "context_depth": 0,
+        "scan_limit": scan_limit,
+        "items": items,
+        "cached": False,
+    }
+    _governance_review_cache.update(
+        {"key": cache_key, "expires_at": now + _GOVERNANCE_REVIEW_CACHE_TTL_SECONDS, "payload": payload}
+    )
+    return {**payload, **runtime}
+
+
 @app.post("/memory/governance/decision")
 def memory_governance_decision(request: GovernanceDecisionRequest) -> dict[str, Any]:
     runtime = _runtime_payload()
@@ -1197,8 +1528,10 @@ def _ingest_request(request: IngestRequest) -> dict[str, Any]:
             source=request.source,
             metadata=metadata,
             timestamp=request.timestamp,
+            post_process=False,
         )
         reference = f"{memory_type}:{memory_id}"
+        _enqueue_postprocess(reference, skip_embedding_provider=_parse_bool_env("OCMEMOG_POSTPROCESS_SKIP_EMBEDDING_PROVIDER", default=True))
         if request.conversation_id:
             memory_links.add_memory_link(reference, "conversation", f"conversation:{request.conversation_id}")
         if request.session_id:
@@ -1295,7 +1628,11 @@ def _ingest_request(request: IngestRequest) -> dict[str, Any]:
 
 @app.post("/memory/ingest")
 def memory_ingest(request: IngestRequest) -> dict[str, Any]:
-    return _ingest_request(request)
+    started = time.perf_counter()
+    payload = _ingest_request(request)
+    elapsed_ms = round((time.perf_counter() - started) * 1000, 3)
+    print(f"[ocmemog][route] memory_ingest elapsed_ms={elapsed_ms:.3f} kind={request.kind} reference={payload.get('reference', '')}", file=sys.stderr)
+    return payload
 
 
 @app.post("/memory/ingest_async")
@@ -1344,32 +1681,35 @@ def memory_distill(request: DistillRequest) -> dict[str, Any]:
 @app.get("/metrics")
 def metrics() -> dict[str, Any]:
     runtime = _runtime_payload()
-    payload = health.get_memory_health()
+    payload = health.get_memory_health_fast()
     counts = payload.get("counts", {})
     counts["queue_depth"] = _queue_depth()
     counts["queue_processed"] = QUEUE_STATS.get("processed", 0)
     counts["queue_errors"] = QUEUE_STATS.get("errors", 0)
     payload["counts"] = counts
+
     coverage_tables = list(store.MEMORY_TABLES)
     conn = store.connect()
     try:
+        vector_counts: Dict[str, int] = {str(row[0]): int(row[1] or 0) for row in conn.execute("SELECT source_type, COUNT(*) FROM vector_embeddings GROUP BY source_type")}
         payload["coverage"] = [
             {
                 "table": table,
                 "rows": int(counts.get(table, 0) or 0),
-                "vectors": int(conn.execute("SELECT COUNT(*) FROM vector_embeddings WHERE source_type=?", (table,)).fetchone()[0] or 0),
-                "missing": max(int(counts.get(table, 0) or 0) - int(conn.execute("SELECT COUNT(*) FROM vector_embeddings WHERE source_type=?", (table,)).fetchone()[0] or 0), 0),
+                "vectors": int(vector_counts.get(table, 0) or 0),
+                "missing": max(int(counts.get(table, 0) or 0) - int(vector_counts.get(table, 0) or 0), 0),
             }
             for table in coverage_tables
         ]
     finally:
         conn.close()
+
     payload["queue"] = QUEUE_STATS
     return {"ok": True, "metrics": payload, **runtime}
 
 
 def _event_stream():
-    path = state_store.reports_dir() / "brain_memory.log.jsonl"
+    path = state_store.report_log_path()
     path.parent.mkdir(parents=True, exist_ok=True)
     if not path.exists():
         path.write_text("")
@@ -1389,33 +1729,55 @@ def events() -> StreamingResponse:
 
 
 def _tail_events(limit: int = 50) -> str:
-    path = state_store.reports_dir() / "brain_memory.log.jsonl"
+    path = state_store.report_log_path()
     if not path.exists():
         return ""
     try:
-        lines = path.read_text(encoding="utf-8", errors="ignore").splitlines()
-    except Exception:
+        size = path.stat().st_size
+        # Read only the trailing chunk to avoid loading very large logs.
+        # This bounds dashboard latency even when the report log grows huge.
+        max_bytes = 256 * 1024
+        with path.open("rb") as handle:
+            if size > max_bytes:
+                handle.seek(-max_bytes, 2)
+            data = handle.read()
+        text = data.decode("utf-8", errors="ignore")
+        lines = text.splitlines()
+    except Exception as exc:
+        print(f"[ocmemog][events] tail_read_failed path={path} error={exc!r}", file=sys.stderr)
         return ""
     return "\n".join(lines[-limit:])
 
 
 @app.get("/dashboard")
 def dashboard() -> HTMLResponse:
-    metrics_payload = health.get_memory_health()
+    metrics_payload = health.get_memory_health_fast()
     counts = metrics_payload.get("counts", {})
     coverage_tables = list(store.MEMORY_TABLES)
     conn = store.connect()
     try:
+        cursor = conn.execute("SELECT source_type, COUNT(*) FROM vector_embeddings GROUP BY source_type")
+        try:
+            vector_rows = list(cursor)
+        except TypeError:
+            fetchall = getattr(cursor, "fetchall", None)
+            if callable(fetchall):
+                vector_rows = fetchall()
+            else:
+                fetchone = getattr(cursor, "fetchone", None)
+                row = fetchone() if callable(fetchone) else None
+                vector_rows = [row] if row is not None else []
+        vector_counts: Dict[str, int] = {}
+        for row in vector_rows:
+            if not isinstance(row, (list, tuple)) or len(row) < 2:
+                continue
+            vector_counts[str(row[0])] = int(row[1] or 0)
+        if hasattr(cursor, "close"):
+            cursor.close()
         coverage_rows = []
         for table in coverage_tables:
             total = int(counts.get(table, 0) or 0)
-            vectors = int(
-                conn.execute(
-                    "SELECT COUNT(*) FROM vector_embeddings WHERE source_type=?",
-                    (table,),
-                ).fetchone()[0]
-                or 0
-            )
+            vectors = int(vector_counts.get(table, 0) or 0)
             missing = max(total - vectors, 0)
             coverage_rows.append({"table": table, "rows": total, "vectors": vectors, "missing": missing})
     finally:
@@ -1517,15 +1879,12 @@ def dashboard() -> HTMLResponse:
           <thead>
             <tr>
               <th>Priority</th>
-              <th>Kind</th>
-              <th>Source</th>
-              <th>Target</th>
-              <th>Summary</th>
+              <th>Review</th>
               <th>Actions</th>
             </tr>
           </thead>
           <tbody id="review-table-body">
-            <tr><td colspan="6" class="muted">Loading...</td></tr>
+            <tr><td colspan="3" class="muted">Loading...</td></tr>
           </tbody>
         </table>
       </div>
@@ -1591,6 +1950,17 @@ def dashboard() -> HTMLResponse:
           return Number.isNaN(parsed.getTime()) ? String(value) : parsed.toLocaleString();
         }}
 
+        function summarizeReviewItem(item) {{
+          const sourceRef = item.source?.reference || item.reference || 'source memory';
+          const targetRef = item.target?.reference || item.target_reference || 'target memory';
+          const sourceText = item.source?.content || sourceRef;
+          const targetText = item.target?.content || targetRef;
+          const relation = item.relationship || (item.kind_label || item.kind || 'relationship').toLowerCase();
+          const when = item.timestamp ? ` Reviewed signal from ${{formatTimestamp(item.timestamp)}}.` : '';
+          const signal = item.signal ? ` Signal score: ${{item.signal}}.` : '';
+          return `${{sourceRef}} may ${{relation.replaceAll('_', ' ')}} ${{targetRef}}. Source: “${{sourceText}}” Target: “${{targetText}}”.${{signal}}${{when}}`;
+        }}
+
         function renderReviewTable() {{
           const kindFilter = reviewKindFilterEl.value;
           const priorityFilter = reviewPriorityFilterEl.value;
@@ -1608,29 +1978,20 @@ def dashboard() -> HTMLResponse:
           reviewNoteEl.textContent = `${{filtered.length}} items shown${{reviewItems.length !== filtered.length ? ` of ${{reviewItems.length}}` : ''}} • Last refresh: ${{reviewLastRefresh ? formatTimestamp(reviewLastRefresh) : 'n/a'}}`;
 
           if (!filtered.length) {{
-            reviewTableBodyEl.innerHTML = '<tr><td colspan="6" class="muted">No review items match the current filters.</td></tr>';
+            reviewTableBodyEl.innerHTML = '<tr><td colspan="3" class="muted">No review items match the current filters.</td></tr>';
             return;
           }}
 
           reviewTableBodyEl.innerHTML = filtered.map((item) => {{
             const disabled = pendingReviewIds.has(item.review_id) ? 'disabled' : '';
-            const sourceContent = item.source?.content || item.reference;
-            const targetContent = item.target?.content || item.target_reference;
+            const reviewText = summarizeReviewItem(item);
+            const summaryBits = [item.kind_label || item.kind, item.summary].filter(Boolean).join(' • ');
             return `
               <tr>
                 <td>${{escapeHtml(item.priority)}}</td>
-                <td>${{escapeHtml(item.kind_label || item.kind)}}</td>
-                <td>
-                  <strong>${{escapeHtml(item.reference)}}</strong><br/>
-                  <span class="muted">${{escapeHtml(sourceContent)}}</span>
-                </td>
-                <td>
-                  <strong>${{escapeHtml(item.target_reference)}}</strong><br/>
-                  <span class="muted">${{escapeHtml(targetContent)}}</span>
-                </td>
                 <td>
-                  <strong>${{escapeHtml(item.summary || '')}}</strong><br/>
-                  <span class="muted">${{escapeHtml(item.relationship || '')}}${{item.signal ? ` • signal ${{item.signal}}` : ''}}</span>
+                  <strong>${{escapeHtml(summaryBits || 'Governance review item')}}</strong><br/>
+                  <span class="muted">${{escapeHtml(reviewText)}}</span>
                 </td>
                 <td>
                   <button type="button" data-review-id="${{escapeHtml(item.review_id)}}" data-approved="true" ${{disabled}}>Approve</button>
@@ -1675,10 +2036,10 @@ def dashboard() -> HTMLResponse:
         async function refreshGovernanceReview() {{
           reviewErrorEl.textContent = '';
           try {{
-            const res = await fetch('/memory/governance/review', {{
+            const res = await fetch('/memory/governance/review/summary', {{
               method: 'POST',
               headers: {{ 'Content-Type': 'application/json' }},
-              body: JSON.stringify({{ limit: 100, context_depth: 1 }}),
+              body: JSON.stringify({{ limit: 20, context_depth: 0, scan_limit: 250 }}),
             }});
             const data = await res.json();
             if (!res.ok || !data.ok) {{
@@ -1689,7 +2050,7 @@ def dashboard() -> HTMLResponse:
             renderReviewTable();
           }} catch (error) {{
             reviewErrorEl.textContent = error instanceof Error ? error.message : String(error);
-            reviewTableBodyEl.innerHTML = '<tr><td colspan="6" class="muted">Unable to load review items.</td></tr>';
+            reviewTableBodyEl.innerHTML = '<tr><td colspan="3" class="muted">Unable to load review items.</td></tr>';
           }}
         }}