@simbimbo/memory-ocmemog 0.1.4

package/scripts/install-ocmemog.sh

@@ -0,0 +1,277 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+TARGET_DIR="${ROOT_DIR}"
+REPO_URL="${OCMEMOG_REPO_URL:-https://github.com/simbimbo/ocmemog.git}"
+PLUGIN_PACKAGE="@simbimbo/memory-ocmemog"
+PLUGIN_ID="memory-ocmemog"
+ENDPOINT="${OCMEMOG_ENDPOINT:-http://127.0.0.1:17890}"
+TIMEOUT_MS="${OCMEMOG_TIMEOUT_MS:-30000}"
+DEFAULT_OLLAMA_MODEL="${OCMEMOG_OLLAMA_MODEL:-phi3:latest}"
+DEFAULT_OLLAMA_EMBED_MODEL="${OCMEMOG_OLLAMA_EMBED_MODEL:-nomic-embed-text:latest}"
+INSTALL_PREREQS="${OCMEMOG_INSTALL_PREREQS:-false}"
+SKIP_PLUGIN_INSTALL="false"
+SKIP_LAUNCHAGENTS="false"
+SKIP_MODEL_PULLS="false"
+DRY_RUN="false"
+
+usage() {
+  cat <<'EOF'
+Usage: scripts/install-ocmemog.sh [target-dir] [options]
+
+Install/configure ocmemog for local OpenClaw use.
+
+Arguments:
+  target-dir                 Optional clone/update target directory.
+
+Options:
+  --help                     Show this help text.
+  --install-prereqs          Auto-install missing ollama/ffmpeg via Homebrew.
+  --skip-plugin-install      Skip OpenClaw plugin install/enable.
+  --skip-launchagents        Skip LaunchAgent install/load.
+  --skip-model-pulls         Skip local Ollama model pulls.
+  --dry-run                  Print what would happen without making changes.
+  --endpoint URL             Override sidecar endpoint (default: http://127.0.0.1:17890).
+  --timeout-ms N             Override plugin timeout summary value (default: 30000).
+  --repo-url URL             Override git clone/update source.
+
+Environment:
+  OCMEMOG_INSTALL_PREREQS=true   Same as --install-prereqs.
+  OCMEMOG_OLLAMA_MODEL           Default local model to pull.
+  OCMEMOG_OLLAMA_EMBED_MODEL     Default local embedding model to pull.
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --help|-h)
+      usage
+      exit 0
+      ;;
+    --install-prereqs)
+      INSTALL_PREREQS="true"
+      shift
+      ;;
+    --skip-plugin-install)
+      SKIP_PLUGIN_INSTALL="true"
+      shift
+      ;;
+    --skip-launchagents)
+      SKIP_LAUNCHAGENTS="true"
+      shift
+      ;;
+    --skip-model-pulls)
+      SKIP_MODEL_PULLS="true"
+      shift
+      ;;
+    --dry-run)
+      DRY_RUN="true"
+      shift
+      ;;
+    --endpoint)
+      ENDPOINT="$2"
+      shift 2
+      ;;
+    --timeout-ms)
+      TIMEOUT_MS="$2"
+      shift 2
+      ;;
+    --repo-url)
+      REPO_URL="$2"
+      shift 2
+      ;;
+    --*)
+      printf 'Unknown option: %s\n\n' "$1" >&2
+      usage >&2
+      exit 1
+      ;;
+    *)
+      TARGET_DIR="$1"
+      shift
+      ;;
+  esac
+done
+
+export PATH="/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:${PATH:-}"
+
+log() {
+  printf '[ocmemog-install] %s\n' "$*"
+}
+
+warn() {
+  printf '[ocmemog-install] WARN: %s\n' "$*" >&2
+}
+
+have() {
+  command -v "$1" >/dev/null 2>&1
+}
+
+run_cmd() {
+  if [[ "$DRY_RUN" == "true" ]]; then
+    printf '[ocmemog-install] DRY RUN: '
+    printf '%q ' "$@"
+    printf '\n'
+    return 0
+  fi
+  "$@"
+}
+
+maybe_install_prereqs() {
+  if [[ "$INSTALL_PREREQS" != "true" ]]; then
+    return
+  fi
+  if ! have brew; then
+    warn "Homebrew not found; cannot auto-install prerequisites"
+    return
+  fi
+  if ! have ollama; then
+    log "Installing Ollama via Homebrew"
+    run_cmd brew install ollama || warn "brew install ollama failed"
+  fi
+  if ! have ffmpeg; then
+    log "Installing ffmpeg via Homebrew"
+    run_cmd brew install ffmpeg || warn "brew install ffmpeg failed"
+  fi
+}
+
+ensure_repo() {
+  if [[ "$TARGET_DIR" == "$ROOT_DIR" ]]; then
+    log "Using existing repo at $TARGET_DIR"
+    return
+  fi
+  if [[ -d "$TARGET_DIR/.git" ]]; then
+    log "Updating existing checkout at $TARGET_DIR"
+    run_cmd git -C "$TARGET_DIR" pull --ff-only
+  else
+    log "Cloning $REPO_URL to $TARGET_DIR"
+    run_cmd git clone "$REPO_URL" "$TARGET_DIR"
+  fi
+  ROOT_DIR="$TARGET_DIR"
+}
+
+ensure_python() {
+  if ! have python3; then
+    warn "python3 is required but not installed"
+    exit 1
+  fi
+  if [[ ! -x "$ROOT_DIR/.venv/bin/python" ]]; then
+    log "Creating virtualenv"
+    run_cmd python3 -m venv "$ROOT_DIR/.venv"
+  fi
+  if [[ "$DRY_RUN" == "true" ]]; then
+    log "Would install Python requirements into $ROOT_DIR/.venv"
+    return
+  fi
+  log "Installing Python requirements"
+  "$ROOT_DIR/.venv/bin/python" -m pip install --upgrade pip setuptools wheel
+  "$ROOT_DIR/.venv/bin/python" -m pip install -r "$ROOT_DIR/requirements.txt"
+}
+
+install_plugin() {
+  if [[ "$SKIP_PLUGIN_INSTALL" == "true" ]]; then
+    log "Skipping plugin install/enable by request"
+    return
+  fi
+  if ! have openclaw; then
+    warn "openclaw CLI not found; skipping plugin install/enable"
+    return
+  fi
+  log "Installing/enabling OpenClaw plugin if needed"
+  if [[ "$DRY_RUN" == "true" ]]; then
+    log "Would attempt package install: openclaw plugins install $PLUGIN_PACKAGE"
+    log "Would fall back to local path install if needed: openclaw plugins install -l $ROOT_DIR"
+    log "Would enable plugin: openclaw plugins enable $PLUGIN_ID"
+    return
+  fi
+  if openclaw plugins install "$PLUGIN_PACKAGE" >/dev/null 2>&1; then
+    log "Installed plugin package $PLUGIN_PACKAGE"
+  else
+    warn "Package install failed or package unavailable here; falling back to local path install"
+    openclaw plugins install -l "$ROOT_DIR"
+  fi
+  openclaw plugins enable "$PLUGIN_ID" || warn "Could not enable plugin automatically"
+}
+
+install_launchagents() {
+  if [[ "$SKIP_LAUNCHAGENTS" == "true" ]]; then
+    log "Skipping LaunchAgent install/load by request"
+    return
+  fi
+  if [[ ! -x "$ROOT_DIR/scripts/ocmemog-install.sh" ]]; then
+    warn "LaunchAgent installer missing at scripts/ocmemog-install.sh"
+    return
+  fi
+  log "Installing LaunchAgents"
+  run_cmd "$ROOT_DIR/scripts/ocmemog-install.sh"
+}
+
+ensure_ollama_models() {
+  if [[ "$SKIP_MODEL_PULLS" == "true" ]]; then
+    log "Skipping local model pulls by request"
+    return
+  fi
+  if ! have ollama; then
+    warn "Ollama not found. Install from https://ollama.com/download to enable local models."
+    return
+  fi
+  if ! ollama list | rg -q "$(printf '%s' "$DEFAULT_OLLAMA_MODEL" | sed 's/:.*$//')"; then
+    log "Pulling local model $DEFAULT_OLLAMA_MODEL"
+    run_cmd ollama pull "$DEFAULT_OLLAMA_MODEL"
+  fi
+  if ! ollama list | rg -q "$(printf '%s' "$DEFAULT_OLLAMA_EMBED_MODEL" | sed 's/:.*$//')"; then
+    log "Pulling local embed model $DEFAULT_OLLAMA_EMBED_MODEL"
+    run_cmd ollama pull "$DEFAULT_OLLAMA_EMBED_MODEL"
+  fi
+}
+
+validate_install() {
+  if ! have curl; then
+    warn "curl not found; skipping health check"
+    return
+  fi
+  if [[ "$DRY_RUN" == "true" ]]; then
+    log "Would validate sidecar health at $ENDPOINT/healthz"
+    return
+  fi
+  log "Waiting for sidecar health check at $ENDPOINT/healthz"
+  for _ in {1..20}; do
+    if curl -fsS --max-time 3 "$ENDPOINT/healthz" >/dev/null 2>&1; then
+      log "Sidecar is healthy"
+      return
+    fi
+    sleep 1
+  done
+  warn "Sidecar health check did not pass yet"
+}
+
+print_summary() {
+  cat <<EOF
+
+ocmemog install summary
+- repo: $ROOT_DIR
+- endpoint: $ENDPOINT
+- timeoutMs: $TIMEOUT_MS
+- local model: $DEFAULT_OLLAMA_MODEL
+- embed model: $DEFAULT_OLLAMA_EMBED_MODEL
+- install prereqs automatically: $INSTALL_PREREQS
+- skip plugin install: $SKIP_PLUGIN_INSTALL
+- skip LaunchAgents: $SKIP_LAUNCHAGENTS
+- skip model pulls: $SKIP_MODEL_PULLS
+- dry run: $DRY_RUN
+
+Next checks:
+- openclaw plugins
+- curl $ENDPOINT/healthz
+- openclaw status --deep
+EOF
+}
+
+ensure_repo
+maybe_install_prereqs
+ensure_python
+install_plugin
+install_launchagents
+ensure_ollama_models
+validate_install
+print_summary

package/scripts/launchagents/com.openclaw.ocmemog.guard.plist

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>com.openclaw.ocmemog.guard</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/bin/bash</string>
+    <string>__ROOT_DIR__/scripts/ocmemog-guard.sh</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>StartInterval</key><integer>900</integer>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key><string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>
+  </dict>
+  <key>ProcessType</key><string>Background</string>
+  <key>StandardOutPath</key><string>/tmp/ocmemog-guard.out.log</string>
+  <key>StandardErrorPath</key><string>/tmp/ocmemog-guard.err.log</string>
+  <key>WorkingDirectory</key><string>__ROOT_DIR__</string>
+</dict>
+</plist>

package/scripts/launchagents/com.openclaw.ocmemog.ponder.plist

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>com.openclaw.ocmemog.ponder</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/bin/bash</string>
+    <string>__ROOT_DIR__/scripts/ocmemog-ponder.sh</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>StartInterval</key><integer>3600</integer>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key><string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>
+  </dict>
+  <key>ProcessType</key><string>Background</string>
+  <key>StandardOutPath</key><string>/tmp/ocmemog-ponder.out.log</string>
+  <key>StandardErrorPath</key><string>/tmp/ocmemog-ponder.err.log</string>
+  <key>WorkingDirectory</key><string>__ROOT_DIR__</string>
+</dict>
+</plist>

package/scripts/launchagents/com.openclaw.ocmemog.sidecar.plist

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>com.openclaw.ocmemog.sidecar</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/bin/bash</string>
+    <string>__ROOT_DIR__/scripts/ocmemog-sidecar.sh</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key><false/>
+  </dict>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key><string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>
+    <key>PYTHONUNBUFFERED</key><string>1</string>
+  </dict>
+  <key>ProcessType</key><string>Background</string>
+  <key>ThrottleInterval</key><integer>10</integer>
+  <key>StandardOutPath</key><string>/tmp/ocmemog-sidecar.out.log</string>
+  <key>StandardErrorPath</key><string>/tmp/ocmemog-sidecar.err.log</string>
+  <key>WorkingDirectory</key><string>__ROOT_DIR__</string>
+</dict>
+</plist>

package/scripts/ocmemog-context.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REF="${1:-}"
+RADIUS="${2:-10}"
+ENDPOINT="${OCMEMOG_ENDPOINT:-http://127.0.0.1:17890}"
+
+if [[ -z "${REF}" ]]; then
+  echo "usage: ocmemog-context.sh <reference> [radius]" >&2
+  exit 1
+fi
+
+curl -s "${ENDPOINT}/memory/context" \
+  -H 'content-type: application/json' \
+  -d "{\"reference\":\"${REF}\",\"radius\":${RADIUS}}"

package/scripts/ocmemog-continuity-benchmark.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+import sys
+sys.path.insert(0, str(REPO_ROOT))
+
+from brain.runtime.memory import store  # noqa: E402
+from ocmemog.sidecar import app  # noqa: E402
+
+
+def _reset_runtime(state_dir: str) -> None:
+    os.environ["OCMEMOG_STATE_DIR"] = state_dir
+    os.environ["OCMEMOG_TRANSCRIPT_ROOTS"] = state_dir
+    store._SCHEMA_READY = False
+    app.QUEUE_STATS.update({
+        "last_run": None,
+        "processed": 0,
+        "errors": 0,
+        "last_error": None,
+        "last_batch": 0,
+    })
+
+
+def _message_id_list(items: List[Dict[str, Any]]) -> List[str]:
+    return [str(item.get("message_id") or "") for item in items if item.get("message_id")]
+
+
+def _run_check(results: List[Dict[str, Any]], name: str, ok: bool, details: Dict[str, Any]) -> None:
+    results.append({"name": name, "ok": bool(ok), "details": details})
+
+
+def run_scenario(scenario: Dict[str, Any]) -> Dict[str, Any]:
+    with tempfile.TemporaryDirectory() as tempdir:
+        _reset_runtime(tempdir)
+        scope = dict(scenario.get("scope") or {})
+        checkpoints = []
+        message_to_turn_id: Dict[str, int] = {}
+
+        for idx, turn in enumerate(scenario.get("turns") or []):
+            response = app.conversation_ingest_turn(
+                app.ConversationTurnRequest(
+                    role=turn["role"],
+                    content=turn["content"],
+                    conversation_id=scope.get("conversation_id"),
+                    session_id=scope.get("session_id"),
+                    thread_id=scope.get("thread_id"),
+                    message_id=turn.get("message_id"),
+                    metadata=turn.get("metadata"),
+                    timestamp=f"2026-03-15 18:00:{idx:02d}",
+                )
+            )
+            if turn.get("message_id"):
+                message_to_turn_id[str(turn["message_id"])] = int(response["turn_id"])
+            if turn.get("message_id") in set(scenario.get("checkpoint_after") or []):
+                checkpoints.append(
+                    app.conversation_checkpoint(
+                        app.ConversationCheckpointRequest(
+                            conversation_id=scope.get("conversation_id"),
+                            session_id=scope.get("session_id"),
+                            thread_id=scope.get("thread_id"),
+                            checkpoint_kind="benchmark",
+                            turns_limit=32,
+                        )
+                    )["checkpoint"]
+                )
+
+        hydrate = app.conversation_hydrate(
+            app.ConversationHydrateRequest(
+                conversation_id=scope.get("conversation_id"),
+                session_id=scope.get("session_id"),
+                thread_id=scope.get("thread_id"),
+                turns_limit=32,
+            )
+        )
+
+        # Simulated restart/recovery: reset schema bootstrap and hydrate from persisted SQLite state.
+        store._SCHEMA_READY = False
+        recovered = app.conversation_hydrate(
+            app.ConversationHydrateRequest(
+                conversation_id=scope.get("conversation_id"),
+                session_id=scope.get("session_id"),
+                thread_id=scope.get("thread_id"),
+                turns_limit=32,
+            )
+        )
+
+        latest_checkpoint = checkpoints[-1] if checkpoints else None
+        checkpoint_expand = None
+        if latest_checkpoint:
+            checkpoint_expand = app.conversation_checkpoint_expand(
+                app.ConversationCheckpointExpandRequest(checkpoint_id=int(latest_checkpoint["id"]), turns_limit=48)
+            )
+        turn_expand = None
+        if scenario.get("turn_expand_message_id"):
+            turn_id = message_to_turn_id[str(scenario["turn_expand_message_id"])]
+            turn_expand = app.conversation_turn_expand(
+                app.ConversationTurnExpandRequest(turn_id=turn_id, radius_turns=8, turns_limit=48)
+            )
+
+        checks: List[Dict[str, Any]] = []
+        expect = dict(scenario.get("expect") or {})
+        latest_user_contains = str(expect.get("latest_user_contains") or "").strip()
+        if latest_user_contains:
+            value = str((hydrate.get("state") or {}).get("latest_user_ask") or "")
+            recovered_value = str((recovered.get("state") or {}).get("latest_user_ask") or "")
+            _run_check(checks, "hydrate.latest_user_contains", latest_user_contains in value, {"value": value, "expected": latest_user_contains})
+            _run_check(checks, "restart.latest_user_contains", latest_user_contains in recovered_value, {"value": recovered_value, "expected": latest_user_contains})
+
+        reply_chain_expected = list(expect.get("active_branch_reply_chain_contains") or [])
+        if reply_chain_expected:
+            reply_chain_ids = _message_id_list((hydrate.get("active_branch") or {}).get("reply_chain") or [])
+            recovered_reply_chain_ids = _message_id_list((recovered.get("active_branch") or {}).get("reply_chain") or [])
+            _run_check(checks, "hydrate.reply_chain_contains", all(item in reply_chain_ids for item in reply_chain_expected), {"value": reply_chain_ids, "expected": reply_chain_expected})
+            _run_check(checks, "restart.reply_chain_contains", all(item in recovered_reply_chain_ids for item in reply_chain_expected), {"value": recovered_reply_chain_ids, "expected": reply_chain_expected})
+
+        excluded = list(expect.get("active_branch_turns_exclude") or [])
+        if excluded:
+            branch_turn_ids = _message_id_list((hydrate.get("active_branch") or {}).get("turns") or [])
+            _run_check(checks, "hydrate.active_branch_excludes", all(item not in branch_turn_ids for item in excluded), {"value": branch_turn_ids, "excluded": excluded})
+
+        top_ranked_turn_message_id = str(expect.get("top_ranked_turn_message_id") or "").strip()
+        if top_ranked_turn_message_id and checkpoint_expand:
+            ranked = checkpoint_expand.get("salience_ranked_turns") or []
+            top_id = str((((ranked[0] if ranked else {}).get("turn") or {}).get("message_id") or ""))
+            _run_check(checks, "checkpoint_expand.top_ranked_turn", top_id == top_ranked_turn_message_id, {"value": top_id, "expected": top_ranked_turn_message_id})
+        if top_ranked_turn_message_id and turn_expand:
+            ranked = turn_expand.get("salience_ranked_turns") or []
+            top_id = str((((ranked[0] if ranked else {}).get("turn") or {}).get("message_id") or ""))
+            _run_check(checks, "turn_expand.top_ranked_turn", top_id == top_ranked_turn_message_id, {"value": top_id, "expected": top_ranked_turn_message_id})
+
+        passed = sum(1 for item in checks if item["ok"])
+        total = len(checks)
+        score = 1.0 if total == 0 else round(passed / total, 3)
+        return {
+            "name": scenario.get("name"),
+            "score": score,
+            "passed": passed,
+            "total": total,
+            "ok": passed == total,
+            "checks": checks,
+            "checkpoint_id": latest_checkpoint.get("id") if latest_checkpoint else None,
+        }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--fixture", default=str(REPO_ROOT / "tests" / "fixtures" / "continuity_benchmark.json"))
+    parser.add_argument("--report", default="")
+    args = parser.parse_args()
+
+    fixture = json.loads(Path(args.fixture).read_text(encoding="utf-8"))
+    scenarios = [run_scenario(item) for item in fixture.get("scenarios") or []]
+    overall_score = round(sum(item["score"] for item in scenarios) / max(len(scenarios), 1), 3)
+    continuity_bar = float(fixture.get("continuity_bar", 1.0))
+    report = {
+        "ok": overall_score >= continuity_bar and all(item["ok"] for item in scenarios),
+        "overall_score": overall_score,
+        "continuity_bar": continuity_bar,
+        "scenario_count": len(scenarios),
+        "scenarios": scenarios,
+    }
+    output = json.dumps(report, indent=2, sort_keys=True)
+    if args.report:
+        Path(args.report).write_text(output + "\n", encoding="utf-8")
+    print(output)
+    return 0 if report["ok"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/ocmemog-demo.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import time
+from pathlib import Path
+from urllib import request as urlrequest
+
+import sys
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(REPO_ROOT))
+
+from brain.runtime.memory import store
+
+ENDPOINT = "http://127.0.0.1:17890"
+
+
+def post(path: str, payload: dict) -> dict:
+    data = json.dumps(payload).encode("utf-8")
+    req = urlrequest.Request(f"{ENDPOINT}{path}", data=data, method="POST")
+    req.add_header("Content-Type", "application/json")
+    with urlrequest.urlopen(req, timeout=30) as resp:
+        return json.loads(resp.read().decode("utf-8"))
+
+
+def get(path: str) -> dict:
+    with urlrequest.urlopen(f"{ENDPOINT}{path}", timeout=20) as resp:
+        return json.loads(resp.read().decode("utf-8"))
+
+
+def demo_context_anchor() -> dict:
+    conn = store.connect()
+    row = conn.execute(
+        "SELECT source_reference, target_reference FROM memory_links WHERE link_type='transcript' ORDER BY rowid DESC LIMIT 1"
+    ).fetchone()
+    conn.close()
+    if not row:
+        return {"ok": False, "error": "no_transcript_links"}
+    reference = row[0]
+    context = post("/memory/context", {"reference": reference, "radius": 5})
+    return {"reference": reference, "context": context}
+
+
+def demo_precision() -> dict:
+    queries = [
+        "ssh key policy",
+        "synology nas",
+        "openclaw status --deep",
+        "gateway bind loopback",
+        "ollama embeddings",
+        "memory pipeline",
+        "jira projects",
+        "calix arden",
+    ]
+    results = []
+    for query in queries:
+        t0 = time.time()
+        resp = post("/memory/search", {"query": query, "limit": 5})
+        elapsed = time.time() - t0
+        hits = 0
+        top = resp.get("results", []) or []
+        for item in top:
+            if any(token in str(item.get("content", "")).lower() for token in query.split()):
+                hits += 1
+        results.append({
+            "query": query,
+            "hits": hits,
+            "elapsed": round(elapsed, 3),
+            "top": [str(item.get("content", ""))[:160] for item in top[:2]],
+        })
+    hit_rate = round(sum(1 for r in results if r["hits"] > 0) / max(1, len(results)), 3)
+    return {"hit_rate": hit_rate, "samples": results}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--pretty", action="store_true")
+    args = parser.parse_args()
+
+    metrics = get("/metrics")
+    cold_count = 0
+    try:
+        conn = store.connect()
+        cold_count = conn.execute("SELECT COUNT(*) FROM cold_storage").fetchone()[0]
+        conn.close()
+    except Exception:
+        cold_count = 0
+
+    anchor = demo_context_anchor()
+    precision = demo_precision()
+
+    if args.pretty:
+        counts = metrics["metrics"]["counts"]
+        print("=== ocmemog demo (pretty) ===")
+        print(f"Memories: {counts}")
+        print(f"Cold storage: {cold_count}")
+        if anchor.get("context", {}).get("transcript", {}).get("snippet"):
+            snippet = anchor["context"]["transcript"]["snippet"].splitlines()[:5]
+            print("\nContext anchor snippet:")
+            for line in snippet:
+                print(f"  {line}")
+        print("\nSearch quality (hit‑rate):", precision.get("hit_rate"))
+        for sample in precision.get("samples", [])[:6]:
+            print(f"  - {sample['query']} → hits: {sample['hits']} (top: {sample['top'][0] if sample.get('top') else ''})")
+        return
+
+    print("=== ocmemog demo ===")
+    print(f"Memory counts: {metrics['metrics']['counts']}")
+    print(f"Cold storage count: {cold_count}")
+
+    print("\n--- Context anchor demo ---")
+    print(json.dumps(anchor, indent=2)[:1000])
+
+    print("\n--- Precision@5 sample ---")
+    print(json.dumps(precision, indent=2)[:1000])
+
+
+if __name__ == "__main__":
+    main()

package/scripts/ocmemog-failover-test.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+DURATION=${1:-30}
+CONCURRENCY=${2:-10}
+OUT=${3:-/tmp/ocmemog-failover.json}
+
+"${ROOT_DIR}/scripts/ocmemog-load-test.py" \
+  --mode mixed --duration "${DURATION}" --concurrency "${CONCURRENCY}" > "${OUT}" &
+PID=$!
+
+sleep 5
+launchctl kickstart -k gui/$UID/com.openclaw.ocmemog.sidecar
+
+wait ${PID}
+cat "${OUT}"