@simbimbo/memory-ocmemog 0.1.12 → 0.1.13

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.1.13 — 2026-03-22
+
+Final hardening release before a possible 1.0 cut.
+
+### Highlights
+- tested the full shipped surface aggressively: full pytest suite, release gate, live sidecar contract smoke, packaging dry-run, installer surfaces, and governance summary responsiveness checks all passed together
+- fixed a supersession-governance regression that could suppress `supersession_recommendation` generation and break governance queue/review/summary and auto-resolve flows
+- moved dashboard supersession plain-English rewriting out of the render path so live dashboard loads stay fast while recommendations still carry human-readable text
+- added a lightweight cached governance review summary path for the dashboard, reducing review load time from multi-second scans to sub-second first load and near-instant cached refresh
+- simplified Governance Review UI output into more concise, single-row plain-English review items
+- hardened supersession summary generation against polluted transcript/log content with tighter preview normalization, aggressive noise stripping, bounded local-model rewriting, and safe heuristic fallbacks
+- fixed dashboard cursor handling so the dashboard route tolerates minimal/mock DB cursor implementations used by tests
+- hardened the integrated proof token/session identifiers to avoid fresh-state collisions during repeated release validation
+
 ## 0.1.12 — 2026-03-21
 
 Release hardening, integrated proof validation, and native-ownership cleanup.

package/ocmemog/runtime/config.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import os
 
-__wrapped_from__ = "brain.runtime.config"
 
 OCMEMOG_EMBED_MODEL_LOCAL = os.environ.get("OCMEMOG_EMBED_MODEL_LOCAL", "")
 OCMEMOG_EMBED_LOCAL_MODEL = OCMEMOG_EMBED_MODEL_LOCAL or os.environ.get("BRAIN_EMBED_MODEL_LOCAL", "simple")

package/ocmemog/runtime/inference.py

@@ -9,7 +9,6 @@ import urllib.request
 
 from . import config, instrumentation, state_store
 
-__wrapped_from__ = "brain.runtime.inference"
 
 LOGFILE = state_store.report_log_path()
 

package/ocmemog/runtime/memory/api.py

@@ -2,6 +2,9 @@ from __future__ import annotations
 
 import json
 import os
+import re
+import threading
+from queue import Queue
 from typing import List, Dict, Any, Optional
 
 from ocmemog.runtime import inference
@@ -9,6 +12,8 @@ from ocmemog.runtime.instrumentation import emit_event
 from . import provenance, store
 from ocmemog.runtime.security import redaction
 
+_SUPERSESSION_SUMMARY_CACHE: Dict[str, str] = {}
+
 _REVIEW_KIND_METADATA: Dict[str, Dict[str, str]] = {
     "duplicate_candidate": {
         "relationship": "duplicate_of",
@@ -36,6 +41,26 @@ def _sanitize(text: str) -> str:
     return redacted
 
 
+def _run_with_timeout(fn, timeout_s: float, default: Any) -> Any:
+    result_queue: Queue[tuple[str, Any]] = Queue(maxsize=1)
+
+    def _target() -> None:
+        try:
+            result_queue.put(("ok", fn()))
+        except Exception as exc:
+            result_queue.put(("error", exc))
+
+    worker = threading.Thread(target=_target, name="ocmemog-governance-summary", daemon=True)
+    worker.start()
+    worker.join(timeout_s)
+    if worker.is_alive() or result_queue.empty():
+        return default
+    status, payload = result_queue.get_nowait()
+    if status != "ok":
+        return default
+    return payload
+
+
 def _parse_memory_reference(reference: str) -> tuple[str, str] | None:
     if ":" not in str(reference or ""):
         return None
@@ -320,6 +345,17 @@ def _auto_attach_governance_candidates(reference: str, *, use_model: bool = True
         duplicate_candidates=duplicate_candidates,
         contradiction_candidates=contradiction_candidates,
     )
+    if supersession_recommendation.get("recommended"):
+        target_reference = str(supersession_recommendation.get("target_reference") or "").strip()
+        target_payload = provenance.fetch_reference(target_reference) or {} if target_reference else {}
+        supersession_recommendation["plain_english"] = _plain_english_supersession_summary(
+            reference=reference,
+            target_reference=target_reference,
+            source_content=str(payload.get("content") or ""),
+            target_content=str(target_payload.get("content") or ""),
+            reason=str(supersession_recommendation.get("reason") or ""),
+        )
+
     supersession_recommendation = _auto_apply_supersession_recommendation(
         reference,
         contradiction_candidates=contradiction_candidates,
@@ -841,6 +877,23 @@ def _remove_from_list(values: Any, target: str) -> List[str]:
 
 
 def _review_item_context(reference: str, *, depth: int = 1) -> Dict[str, Any]:
+    if depth <= 0:
+        payload = provenance.fetch_reference(reference) or {"reference": reference}
+        metadata = payload.get("metadata") if isinstance(payload.get("metadata"), dict) else {}
+        prov = metadata.get("provenance") if isinstance(metadata.get("provenance"), dict) else {}
+        return {
+            "reference": reference,
+            "bucket": payload.get("table"),
+            "id": payload.get("id"),
+            "timestamp": payload.get("timestamp"),
+            "content": payload.get("content"),
+            "memory_status": prov.get("memory_status") or metadata.get("memory_status") or "active",
+            "provenance_preview": provenance.preview_from_metadata(metadata),
+            "metadata": metadata,
+            "links": [],
+            "backlinks": [],
+        }
+
     payload = provenance.hydrate_reference(reference, depth=depth) or {"reference": reference}
     metadata = payload.get("metadata") if isinstance(payload.get("metadata"), dict) else {}
     prov = metadata.get("provenance") if isinstance(metadata.get("provenance"), dict) else {}
@@ -868,6 +921,106 @@ def _review_item_summary(kind: str, reference: str, target_reference: str) -> st
     return f"{reference} requires review against {target_reference}"
 
 
+def _normalize_supersession_preview(text: str, fallback: str) -> str:
+    raw = str(text or "").strip()
+    if not raw:
+        return fallback
+    cleaned = _sanitize(raw)
+    cleaned = re.sub(r"\[\[reply_to_current\]\]", "", cleaned, flags=re.IGNORECASE)
+    cleaned = re.sub(r"\([^\)]*assistant\)", "", cleaned, flags=re.IGNORECASE)
+    cleaned = re.sub(r"\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z\b", "", cleaned)
+    cleaned = re.sub(r"https?://\S+", "", cleaned)
+    cleaned = re.sub(r"\s+", " ", cleaned).strip()
+    lower = cleaned.lower()
+    noisy_markers = [
+        "provider monitor",
+        "memory-sync",
+        "launchctl",
+        "reply_to_current",
+        "openclaw gateway restart",
+        "python3 -u -m",
+        "logged to",
+        "checkpoint saved",
+    ]
+    if any(marker in lower for marker in noisy_markers):
+        return fallback
+    if len(cleaned) > 140:
+        sentence = re.split(r"(?<=[.!?])\s+", cleaned, maxsplit=1)[0].strip()
+        cleaned = sentence or cleaned[:140]
+    cleaned = cleaned[:140].rstrip(" ,;:-")
+    return cleaned or fallback
+
+
+def _heuristic_supersession_summary(
+    reference: str,
+    target_reference: str,
+    source_content: str,
+    target_content: str,
+    reason: str,
+) -> str:
+    source = _normalize_supersession_preview(source_content, "a newer consolidated memory")
+    target = _normalize_supersession_preview(target_content, "an older noisier memory")
+    because = _normalize_supersession_preview(reason, "the newer memory appears cleaner and more useful")
+    return f"This newer memory probably replaces an older one: new = {source}; old = {target}; reason = {because}."[:220].rstrip()
+
+
+def _plain_english_supersession_summary(
+    *,
+    reference: str,
+    target_reference: str,
+    source_content: str,
+    target_content: str,
+    reason: str,
+) -> str:
+    cache_key = json.dumps(
+        {
+            "reference": reference,
+            "target_reference": target_reference,
+            "source_content": source_content,
+            "target_content": target_content,
+            "reason": reason,
+        },
+        sort_keys=True,
+        ensure_ascii=False,
+    )
+    cached = _SUPERSESSION_SUMMARY_CACHE.get(cache_key)
+    if cached:
+        return cached
+
+    fallback = _heuristic_supersession_summary(reference, target_reference, source_content, target_content, reason)
+    source_preview = _normalize_supersession_preview(source_content, "a newer consolidated memory")
+    target_preview = _normalize_supersession_preview(target_content, "an older noisier memory")
+    reason_preview = _normalize_supersession_preview(reason, "the newer memory appears cleaner and more useful")
+    prompt = (
+        "Rewrite this supersession recommendation as exactly one short plain-English sentence for a human dashboard. "
+        "Describe the relationship only. Do not quote or repeat full memory contents. Do not use JSON, bullets, markdown, timestamps, or command text. Keep it under 160 characters.\n\n"
+        f"Newer candidate reference: {reference}\n"
+        f"Potentially replaced reference: {target_reference}\n"
+        f"Newer candidate preview: {source_preview}\n"
+        f"Older candidate preview: {target_preview}\n"
+        f"Recommendation reason: {reason_preview}\n\n"
+        "Plain-English dashboard sentence:"
+    )
+    result = _run_with_timeout(
+        lambda: inference.infer(
+            prompt,
+            provider_name=os.environ.get("OCMEMOG_PONDER_MODEL", "local-openai:qwen2.5-7b-instruct"),
+        ),
+        1.5,
+        {"status": "timeout", "output": ""},
+    )
+    output = str((result or {}).get("output") or "").strip()
+    cleaned = output.replace("\n", " ").strip(" -:\t")
+    cleaned = re.sub(r"^(summary|sentence|plain-english dashboard sentence)\s*:\s*", "", cleaned, flags=re.IGNORECASE).strip()
+    cleaned = _normalize_supersession_preview(cleaned, "")
+    if cleaned and len(cleaned) >= 24:
+        summary = cleaned[:160]
+    else:
+        summary = fallback
+    _SUPERSESSION_SUMMARY_CACHE[cache_key] = summary
+    return summary
+
+
 def _review_actions(kind: str, relationship: str) -> List[Dict[str, Any]]:
     meta = _REVIEW_KIND_METADATA.get(kind, {})
     return [
@@ -899,8 +1052,9 @@ def list_governance_review_items(
     categories: Optional[List[str]] = None,
     limit: int = 100,
     context_depth: int = 1,
+    scan_limit: int = 3000,
 ) -> List[Dict[str, Any]]:
-    items = governance_queue(categories=categories, limit=limit)
+    items = governance_queue(categories=categories, limit=limit, scan_limit=scan_limit)
     review_items: List[Dict[str, Any]] = []
     for item in items:
         kind = str(item.get("kind") or "")
@@ -909,6 +1063,13 @@ def list_governance_review_items(
         target_reference = str(item.get("target_reference") or "")
         if not reference or not target_reference or not relationship:
             continue
+        source = _review_item_context(reference, depth=context_depth)
+        target = _review_item_context(target_reference, depth=context_depth)
+        summary = _review_item_summary(kind, reference, target_reference)
+        if kind == "supersession_recommendation":
+            plain_english = str(item.get("plain_english") or "").strip()
+            if plain_english:
+                summary = plain_english
         review_items.append({
             "review_id": f"{kind}:{reference}->{target_reference}",
             "kind": kind,
@@ -921,10 +1082,10 @@ def list_governance_review_items(
             "reason": item.get("reason"),
             "reference": reference,
             "target_reference": target_reference,
-            "summary": _review_item_summary(kind, reference, target_reference),
+            "summary": summary,
             "actions": _review_actions(kind, relationship),
-            "source": _review_item_context(reference, depth=context_depth),
-            "target": _review_item_context(target_reference, depth=context_depth),
+            "source": source,
+            "target": target,
         })
     return review_items
 
@@ -1073,15 +1234,17 @@ def rollback_governance_decision(
     return None
 
 
-def governance_queue(*, categories: Optional[List[str]] = None, limit: int = 100) -> List[Dict[str, Any]]:
+def governance_queue(*, categories: Optional[List[str]] = None, limit: int = 100, scan_limit: int = 3000) -> List[Dict[str, Any]]:
     allowed = set(store.MEMORY_TABLES)
     tables = [table for table in (categories or list(allowed)) if table in allowed]
+    per_table_scan_limit = max(int(scan_limit or 0), max(int(limit or 0), 1))
     conn = store.connect()
     try:
         items: List[Dict[str, Any]] = []
         for table in tables:
             rows = conn.execute(
-                f"SELECT id, timestamp, content, metadata_json FROM {table} ORDER BY id DESC LIMIT 3000"
+                f"SELECT id, timestamp, content, metadata_json FROM {table} ORDER BY id DESC LIMIT ?",
+                (per_table_scan_limit,),
             ).fetchall()
             for row in rows:
                 reference = f"{table}:{row['id'] if isinstance(row, dict) else row[0]}"

package/ocmemog/runtime/memory/health.py

@@ -55,3 +55,39 @@ def get_memory_health() -> Dict[str, Any]:
         "vector_index_integrity_status": integrity_result.get("ok"),
         "integrity": integrity_result,
     }
+
+
+def get_memory_health_fast() -> Dict[str, Any]:
+    conn = store.connect()
+    counts: Dict[str, int] = {}
+    try:
+        for table in ["experiences", "candidates", "promotions", "memory_index", *store.MEMORY_TABLES, "vector_embeddings"]:
+            try:
+                counts[table] = conn.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0]
+            except Exception:
+                counts[table] = 0
+
+        vector_index_count = 0
+        for table in EMBED_TABLES:
+            try:
+                vector_index_count += conn.execute(
+                    "SELECT COUNT(*) FROM vector_embeddings WHERE source_type=?",
+                    (table,),
+                ).fetchone()[0]
+            except Exception:
+                continue
+    finally:
+        conn.close()
+
+    total_embed_sources = sum(counts.get(table, 0) for table in EMBED_TABLES)
+    coverage = 0.0
+    if total_embed_sources:
+        coverage = round(vector_index_count / total_embed_sources, 3)
+
+    return {
+        "counts": counts,
+        "vector_index_count": vector_index_count,
+        "vector_index_coverage": coverage,
+        "vector_index_integrity_status": None,
+        "integrity": {"ok": None, "mode": "deferred"},
+    }

package/ocmemog/runtime/model_roles.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 from . import config
 
-__wrapped_from__ = "brain.runtime.model_roles"
 
 
 def get_model_for_role(role: str) -> str:

package/ocmemog/runtime/model_router.py

@@ -6,7 +6,6 @@ from dataclasses import dataclass
 
 from . import config
 
-__wrapped_from__ = "brain.runtime.model_router"
 
 
 @dataclass(frozen=True)

package/ocmemog/runtime/providers.py

@@ -8,7 +8,6 @@ import urllib.request
 
 from . import config, instrumentation, state_store
 
-__wrapped_from__ = "brain.runtime.providers"
 
 LOGFILE = state_store.report_log_path()
 

package/ocmemog/runtime/state_store.py

@@ -6,8 +6,6 @@ from pathlib import Path
 
 from . import storage_paths
 
-__wrapped_from__ = "brain.runtime.state_store"
-__wrapped_by__ = "ocmemog-runtime-bridge"
 
 
 def root_dir() -> Path:

package/ocmemog/sidecar/app.py

@@ -6,6 +6,7 @@ import faulthandler
 import os
 import re
 import threading
+import tempfile
 import time
 import sys
 from contextlib import asynccontextmanager
@@ -37,6 +38,8 @@ from ocmemog.sidecar.transcript_watcher import watch_forever
 DEFAULT_CATEGORIES = tuple(store.MEMORY_TABLES)
 
 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"}
@@ -198,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")
@@ -546,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):
@@ -1044,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()
@@ -1630,26 +1681,29 @@ 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}
 
@@ -1679,7 +1733,16 @@ def _tail_events(limit: int = 50) -> str:
     if not path.exists():
         return ""
     try:
-        lines = path.read_text(encoding="utf-8", errors="ignore").splitlines()
+        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 ""
@@ -1688,21 +1751,33 @@ def _tail_events(limit: int = 50) -> str:
 
 @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:
@@ -1804,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>
@@ -1878,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;
@@ -1895,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>
@@ -1962,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) {{
@@ -1976,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>';
           }}
         }}
 

package/ocmemog/sidecar/transcript_watcher.py

@@ -118,8 +118,15 @@ def _pick_latest(path: Path, pattern: str) -> Optional[Path]:
         return path
     if not path.exists():
         return None
-    files = sorted(path.glob(pattern), key=lambda p: p.stat().st_mtime)
-    return files[-1] if files else None
+    files = []
+    for candidate in path.glob(pattern):
+        try:
+            mtime = candidate.stat().st_mtime
+        except FileNotFoundError:
+            continue
+        files.append((mtime, candidate))
+    files.sort(key=lambda item: item[0])
+    return files[-1][1] if files else None
 
 
 def _apply_auth_headers(req: urlrequest.Request) -> None:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simbimbo/memory-ocmemog",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "Advanced OpenClaw memory plugin with durable recall, transcript-backed continuity, and sidecar APIs",
   "license": "MIT",
   "repository": {

package/scripts/ocmemog-integrated-proof.py

@@ -215,10 +215,11 @@ def _derive_port(endpoint: str) -> int | None:
 
 
 def run_probe(endpoint: str) -> dict[str, Any]:
-    token = "proof-token-demo-12345"
-    conversation = "proof-conv-demo"
-    session = "proof-sess-demo"
-    thread = "proof-thread-demo"
+    nonce = uuid.uuid4().hex
+    token = f"proof-token-{nonce}"
+    conversation = f"proof-conv-{nonce}"
+    session = f"proof-sess-{nonce}"
+    thread = f"proof-thread-{nonce}"
 
     ingest_payload = {
         "content": f"I learned that the {token} is the canonical token for this verification.",